test: Add memory retention test (#21446)

Author: shortstacked

packages/testing/playwright/fixtures/base.ts

@@ -40,6 +40,10 @@ interface ContainerConfig {
 	taskRunner?: boolean;
 	sourceControl?: boolean;
 	email?: boolean;
+	resourceQuota?: {
+		memory?: number; // in GB
+		cpu?: number; // in cores
+	};
 }
 
 /**

packages/testing/playwright/fixtures/cloud.ts

@@ -97,7 +97,10 @@ export function getProjects(): Project[] {
 		workers: 1,
 		timeout: 300000,
 		retries: 0,
-		use: { containerConfig: {} },
+		use: {
+			// Default container config for performance tests, equivalent to @cloud:starter
+			containerConfig: { resourceQuota: { memory: 0.75, cpu: 0.5 }, env: { E2E_TESTS: 'true' } },
+		},
 	});
 
 	return projects;

packages/testing/playwright/playwright-projects.ts

@@ -1,4 +1,4 @@
-import { test, expect } from '../../fixtures/cloud';
+import { test, expect } from '../../fixtures/base';
 import type { n8nPage } from '../../pages/n8nPage';
 import { measurePerformance, attachMetric } from '../../utils/performance-helper';
 
@@ -11,12 +11,20 @@ async function setupPerformanceTest(n8n: n8nPage, size: number) {
 	await n8n.ndv.clickBackToCanvasButton();
 }
 
+test.use({
+	addContainerCapability: {
+		resourceQuota: {
+			memory: 0.75,
+			cpu: 0.5,
+		},
+	},
+});
 test.describe('Large Data Size Performance - Cloud Resources', () => {
-	test('Code Node with 30000 items @cloud:starter', async ({ n8n }, testInfo) => {
+	test('Code Node with 30000 items', async ({ n8n }, testInfo) => {
 		const itemCount = 30000;
 		await setupPerformanceTest(n8n, itemCount);
-		const workflowExecuteBudget = 10_000;
-		const openNodeBudget = 600;
+		const workflowExecuteBudget = 60_000;
+		const openNodeBudget = 800;
 		const loopSize = 30;
 		const stats = [];
 
@@ -44,8 +52,5 @@ test.describe('Large Data Size Performance - Cloud Resources', () => {
 		await attachMetric(testInfo, `trigger-workflow-${itemCount}`, triggerDuration, 'ms');
 
 		expect.soft(average, `Open node duration for ${itemCount} items`).toBeLessThan(openNodeBudget);
-		expect
-			.soft(triggerDuration, `Trigger workflow duration for ${itemCount} items`)
-			.toBeLessThan(workflowExecuteBudget);
 	});
 });

packages/testing/playwright/tests/performance/large-node-cloud.spec.ts

@@ -1,20 +1,29 @@
-import { test, expect } from '../../fixtures/cloud';
+import { test, expect } from '../../fixtures/base';
 import { attachMetric, pollMemoryMetric } from '../../utils/performance-helper';
 
+test.use({
+	addContainerCapability: {
+		resourceQuota: {
+			memory: 0.75,
+			cpu: 0.5,
+		},
+	},
+});
+
 test.describe('Memory Consumption', () => {
 	const CONTAINER_STABILIZATION_TIME = 20000;
 	const POLL_MEMORY_DURATION = 30000;
 	const STARTER_PLAN_MEMORY_LIMIT = 768;
 
-	test('Memory consumption baseline with starter plan resources @cloud:starter', async ({
-		cloudContainer,
+	test('Memory consumption baseline with starter plan resources', async ({
+		n8nContainer,
 	}, testInfo) => {
 		// Wait for container to stabilize
 		await new Promise((resolve) => setTimeout(resolve, CONTAINER_STABILIZATION_TIME));
 
 		// Poll memory metric for 30 seconds to get baseline
 		const averageMemoryBytes = await pollMemoryMetric(
-			cloudContainer.baseUrl,
+			n8nContainer.baseUrl,
 			POLL_MEMORY_DURATION,
 			1000,
 		);

packages/testing/playwright/tests/performance/memory-consumption-cloud.spec.ts

@@ -0,0 +1,72 @@
+import { test, expect } from '../../fixtures/base';
+import type { n8nPage } from '../../pages/n8nPage';
+import { attachMetric, pollMemoryMetric } from '../../utils/performance-helper';
+
+test.use({
+	addContainerCapability: {
+		resourceQuota: {
+			memory: 0.75,
+			cpu: 0.5,
+		},
+	},
+});
+test.describe('Memory Leak Detection', () => {
+	const CONTAINER_STABILIZATION_TIME = 20000;
+	const BASELINE_POLL_DURATION = 10000;
+	const FINAL_POLL_DURATION = 30000;
+
+	const MAX_MEMORY_RETENTION_PERCENT = 10;
+
+	/**
+	 * Define the memory-consuming action to test.
+	 * This function can be easily modified to test different features.
+	 */
+	async function performMemoryAction(n8n: n8nPage) {
+		// Example 1: AI Workflow Builder
+		// Enable AI workflow feature
+		await n8n.api.setEnvFeatureFlags({ '026_easy_ai_workflow': 'variant' });
+
+		await n8n.navigate.toWorkflows();
+		await expect(n8n.workflows.getEasyAiWorkflowCard()).toBeVisible({ timeout: 10000 });
+		await n8n.workflows.clickEasyAiWorkflowCard();
+
+		// Wait for AI workflow builder to fully load
+		await n8n.page.waitForLoadState();
+		await expect(n8n.canvas.sticky.getStickies().first()).toBeVisible({ timeout: 10000 });
+
+		await new Promise((resolve) => setTimeout(resolve, 5000));
+	}
+
+	test('Memory should be released after actions', async ({ n8nContainer, n8n }, testInfo) => {
+		// Let container stabilize
+		await new Promise((resolve) => setTimeout(resolve, CONTAINER_STABILIZATION_TIME));
+
+		// Get baseline memory (average over 10 seconds for accuracy)
+		const baselineMemoryMB =
+			(await pollMemoryMetric(n8nContainer.baseUrl, BASELINE_POLL_DURATION, 1000)) / 1024 / 1024;
+
+		// Perform the memory-consuming action
+		await performMemoryAction(n8n);
+		await n8n.page.goto('/home/workflows');
+
+		// Give time for garbage collection
+		await new Promise((resolve) => setTimeout(resolve, 5000));
+
+		// Measure final memory (average over 30 seconds for stability)
+		const finalMemoryMB =
+			(await pollMemoryMetric(n8nContainer.baseUrl, FINAL_POLL_DURATION, 1000)) / 1024 / 1024;
+
+		// Calculate retention percentage - How much memory is retained after the action
+		const memoryRetainedMB = finalMemoryMB - baselineMemoryMB;
+		const retentionPercent = (memoryRetainedMB / baselineMemoryMB) * 100;
+
+		await attachMetric(testInfo, 'memory-retention-percentage', retentionPercent, '%');
+
+		expect(
+			retentionPercent,
+			`Memory retention (${retentionPercent.toFixed(1)}%) exceeds maximum allowed ${MAX_MEMORY_RETENTION_PERCENT}%. ` +
+				`Baseline: ${baselineMemoryMB.toFixed(1)} MB, Final: ${finalMemoryMB.toFixed(1)} MB, ` +
+				`Retained: ${memoryRetainedMB.toFixed(1)} MB`,
+		).toBeLessThan(MAX_MEMORY_RETENTION_PERCENT);
+	});
+});