@elaraai/e3-api-tests 0.0.2-beta.31 → 0.0.2-beta.33

package/dist/src/suites/dataflow.js

@@ -7,31 +7,65 @@
  *
  * Tests: start, execute (blocking), poll for completion, logs
  */
-import { describe, it, beforeEach } from 'node:test';
+import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
 import { readFileSync } from 'node:fs';
 import { packageImport, workspaceCreate, workspaceDeploy, workspaceStatus, dataflowStart, dataflowExecute, dataflowExecution, dataflowCancel, dataflowGraph, taskLogs, ApiError, } from '@elaraai/e3-api-client';
 import { createPackageZip, createDiamondPackageZip, createFailingPackageZip, createSlowPackageZip, createParallelMixedPackageZip, createFailingDiamondPackageZip, createWideParallelPackageZip, } from '../fixtures.js';
+/** Helper: import package, create workspace, deploy */
+function withDeployed(setup, createZip, pkgName, wsName) {
+    return async (t) => {
+        const ctx = await setup(t);
+        const opts = await ctx.opts();
+        const zipPath = await createZip(ctx.tempDir, pkgName, '1.0.0');
+        const packageZip = readFileSync(zipPath);
+        await packageImport(ctx.config.baseUrl, ctx.repoName, packageZip, opts);
+        await workspaceCreate(ctx.config.baseUrl, ctx.repoName, wsName, opts);
+        await workspaceDeploy(ctx.config.baseUrl, ctx.repoName, wsName, `${pkgName}@1.0.0`, opts);
+        return ctx;
+    };
+}
 /**
  * Register dataflow execution tests.
  *
- * @param getContext - Function that returns the current test context
+ * @param setup - Factory that creates a fresh test context per test
  */
-export function dataflowTests(getContext) {
-    describe('dataflow', () => {
-        describe('simple execution', () => {
-            beforeEach(async () => {
-                const ctx = getContext();
-                const opts = await ctx.opts();
-                // Create and import a simple package
-                const zipPath = await createPackageZip(ctx.tempDir, 'exec-pkg', '1.0.0');
-                const packageZip = readFileSync(zipPath);
-                await packageImport(ctx.config.baseUrl, ctx.repoName, packageZip, opts);
-                await workspaceCreate(ctx.config.baseUrl, ctx.repoName, 'exec-ws', opts);
-                await workspaceDeploy(ctx.config.baseUrl, ctx.repoName, 'exec-ws', 'exec-pkg@1.0.0', opts);
-            });
-            it('dataflowExecute runs tasks and returns result (blocking)', async () => {
-                const ctx = getContext();
+export function dataflowTests(setup) {
+    const withSimpleExec = withDeployed(setup, createPackageZip, 'exec-pkg', 'exec-ws');
+    const withDiamond = withDeployed(setup, createDiamondPackageZip, 'diamond-pkg', 'diamond-ws');
+    const withFailing = withDeployed(setup, createFailingPackageZip, 'fail-pkg', 'fail-ws');
+    const withMixed = withDeployed(setup, createParallelMixedPackageZip, 'mixed-pkg', 'mixed-ws');
+    const withFailingDiamond = withDeployed(setup, createFailingDiamondPackageZip, 'fdiamond-pkg', 'fdiamond-ws');
+    const withWideParallel = async (t) => {
+        const ctx = await setup(t);
+        const opts = await ctx.opts();
+        const zipPath = await createWideParallelPackageZip(ctx.tempDir, 'wide-pkg', '1.0.0', 6);
+        const packageZip = readFileSync(zipPath);
+        await packageImport(ctx.config.baseUrl, ctx.repoName, packageZip, opts);
+        await workspaceCreate(ctx.config.baseUrl, ctx.repoName, 'wide-ws', opts);
+        await workspaceDeploy(ctx.config.baseUrl, ctx.repoName, 'wide-ws', 'wide-pkg@1.0.0', opts);
+        return ctx;
+    };
+    const withSlow = async (t) => {
+        const ctx = await setup(t);
+        const opts = await ctx.opts();
+        const zipPath = await createSlowPackageZip(ctx.tempDir, 'slow-pkg', '1.0.0', 30);
+        const packageZip = readFileSync(zipPath);
+        await packageImport(ctx.config.baseUrl, ctx.repoName, packageZip, opts);
+        await workspaceCreate(ctx.config.baseUrl, ctx.repoName, 'slow-ws', opts);
+        await workspaceDeploy(ctx.config.baseUrl, ctx.repoName, 'slow-ws', 'slow-pkg@1.0.0', opts);
+        return ctx;
+    };
+    const withNoExec = withDeployed(setup, createPackageZip, 'noexec-pkg', 'noexec-ws');
+    const withCache = withDeployed(setup, createPackageZip, 'cache-pkg', 'cache-ws');
+    const withFilter = withDeployed(setup, createDiamondPackageZip, 'filter-pkg', 'filter-ws');
+    const withGraph = withDeployed(setup, createDiamondPackageZip, 'graph-pkg', 'graph-ws');
+    const withLogPag = withDeployed(setup, createPackageZip, 'logpag-pkg', 'logpag-ws');
+    const withEvtPag = withDeployed(setup, createDiamondPackageZip, 'evtpag-pkg', 'evtpag-ws');
+    describe('dataflow', { concurrency: true }, () => {
+        describe('simple execution', { concurrency: true }, () => {
+            it('dataflowExecute runs tasks and returns result (blocking)', async (t) => {
+                const ctx = await withSimpleExec(t);
                 const opts = await ctx.opts();
                 const result = await dataflowExecute(ctx.config.baseUrl, ctx.repoName, 'exec-ws', { force: true }, opts);
                 // Verify execution result
@@ -50,8 +84,8 @@ export function dataflowTests(getContext) {
                 assert.ok(outputDataset, 'Output dataset .tasks.compute.output should exist');
                 assert.strictEqual(outputDataset.status.type, 'up-to-date');
             });
-            it('dataflowStart triggers execution (non-blocking)', async () => {
-                const ctx = getContext();
+            it('dataflowStart triggers execution (non-blocking)', async (t) => {
+                const ctx = await withSimpleExec(t);
                 const opts = await ctx.opts();
                 // Should return immediately
                 await dataflowStart(ctx.config.baseUrl, ctx.repoName, 'exec-ws', { force: true }, opts);
@@ -71,8 +105,8 @@ export function dataflowTests(getContext) {
                 // Verify execution completed
                 assert.strictEqual(status.tasks[0].status.type, 'up-to-date');
             });
-            it('dataflowExecution returns execution state', async () => {
-                const ctx = getContext();
+            it('dataflowExecution returns execution state', async (t) => {
+                const ctx = await withSimpleExec(t);
                 const opts = await ctx.opts();
                 // Start execution
                 await dataflowStart(ctx.config.baseUrl, ctx.repoName, 'exec-ws', { force: true }, opts);
@@ -97,8 +131,8 @@ export function dataflowTests(getContext) {
                 }
                 assert.fail('Execution did not complete in time');
             });
-            it('taskLogs returns logs after execution', async () => {
-                const ctx = getContext();
+            it('taskLogs returns logs after execution', async (t) => {
+                const ctx = await withSimpleExec(t);
                 const opts = await ctx.opts();
                 // Execute first
                 await dataflowExecute(ctx.config.baseUrl, ctx.repoName, 'exec-ws', { force: true }, opts);
@@ -112,19 +146,9 @@ export function dataflowTests(getContext) {
                 assert.ok(typeof logs.complete === 'boolean');
             });
         });
-        describe('diamond dependency execution', () => {
-            beforeEach(async () => {
-                const ctx = getContext();
-                const opts = await ctx.opts();
-                // Create and import diamond package (left, right, merge tasks)
-                const zipPath = await createDiamondPackageZip(ctx.tempDir, 'diamond-pkg', '1.0.0');
-                const packageZip = readFileSync(zipPath);
-                await packageImport(ctx.config.baseUrl, ctx.repoName, packageZip, opts);
-                await workspaceCreate(ctx.config.baseUrl, ctx.repoName, 'diamond-ws', opts);
-                await workspaceDeploy(ctx.config.baseUrl, ctx.repoName, 'diamond-ws', 'diamond-pkg@1.0.0', opts);
-            });
-            it('executes diamond dependency graph correctly', async () => {
-                const ctx = getContext();
+        describe('diamond dependency execution', { concurrency: true }, () => {
+            it('executes diamond dependency graph correctly', async (t) => {
+                const ctx = await withDiamond(t);
                 const opts = await ctx.opts();
                 const result = await dataflowExecute(ctx.config.baseUrl, ctx.repoName, 'diamond-ws', { force: true }, opts);
                 // Should execute all three tasks
@@ -137,8 +161,8 @@ export function dataflowTests(getContext) {
                     assert.strictEqual(task.state.type, 'success', `Task ${task.name} should succeed`);
                 }
             });
-            it('tracks events during execution', async () => {
-                const ctx = getContext();
+            it('tracks events during execution', async (t) => {
+                const ctx = await withDiamond(t);
                 const opts = await ctx.opts();
                 // Start execution
                 await dataflowStart(ctx.config.baseUrl, ctx.repoName, 'diamond-ws', { force: true }, opts);
@@ -162,19 +186,9 @@ export function dataflowTests(getContext) {
                 assert.ok(completeEvents.length >= 3, `Expected at least 3 complete events, got ${completeEvents.length}`);
             });
         });
-        describe('failed execution', () => {
-            beforeEach(async () => {
-                const ctx = getContext();
-                const opts = await ctx.opts();
-                // Create and import a package with a failing task
-                const zipPath = await createFailingPackageZip(ctx.tempDir, 'fail-pkg', '1.0.0');
-                const packageZip = readFileSync(zipPath);
-                await packageImport(ctx.config.baseUrl, ctx.repoName, packageZip, opts);
-                await workspaceCreate(ctx.config.baseUrl, ctx.repoName, 'fail-ws', opts);
-                await workspaceDeploy(ctx.config.baseUrl, ctx.repoName, 'fail-ws', 'fail-pkg@1.0.0', opts);
-            });
-            it('dataflowExecute returns failure result when task fails', async () => {
-                const ctx = getContext();
+        describe('failed execution', { concurrency: true }, () => {
+            it('dataflowExecute returns failure result when task fails', async (t) => {
+                const ctx = await withFailing(t);
                 const opts = await ctx.opts();
                 const result = await dataflowExecute(ctx.config.baseUrl, ctx.repoName, 'fail-ws', { force: true }, opts);
                 // Execution should report failure
@@ -185,8 +199,8 @@ export function dataflowTests(getContext) {
                 assert.strictEqual(result.tasks[0].name, 'failing');
                 assert.strictEqual(result.tasks[0].state.type, 'failed');
             });
-            it('dataflowExecution shows failed status after task failure', async () => {
-                const ctx = getContext();
+            it('dataflowExecution shows failed status after task failure', async (t) => {
+                const ctx = await withFailing(t);
                 const opts = await ctx.opts();
                 // Start execution
                 await dataflowStart(ctx.config.baseUrl, ctx.repoName, 'fail-ws', { force: true }, opts);
@@ -210,8 +224,8 @@ export function dataflowTests(getContext) {
                 }
                 assert.fail('Execution did not complete in time');
             });
-            it('can restart execution after failure', async () => {
-                const ctx = getContext();
+            it('can restart execution after failure', async (t) => {
+                const ctx = await withFailing(t);
                 const opts = await ctx.opts();
                 // First execution - should fail
                 const result1 = await dataflowExecute(ctx.config.baseUrl, ctx.repoName, 'fail-ws', { force: true }, opts);
@@ -222,19 +236,10 @@ export function dataflowTests(getContext) {
                 assert.strictEqual(result2.failed, 1n);
             });
         });
-        describe('parallel task failures', () => {
-            describe('mixed success/failure', () => {
-                beforeEach(async () => {
-                    const ctx = getContext();
-                    const opts = await ctx.opts();
-                    const zipPath = await createParallelMixedPackageZip(ctx.tempDir, 'mixed-pkg', '1.0.0');
-                    const packageZip = readFileSync(zipPath);
-                    await packageImport(ctx.config.baseUrl, ctx.repoName, packageZip, opts);
-                    await workspaceCreate(ctx.config.baseUrl, ctx.repoName, 'mixed-ws', opts);
-                    await workspaceDeploy(ctx.config.baseUrl, ctx.repoName, 'mixed-ws', 'mixed-pkg@1.0.0', opts);
-                });
-                it('parallel tasks with mixed success/failure complete without stalling', async () => {
-                    const ctx = getContext();
+        describe('parallel task failures', { concurrency: true }, () => {
+            describe('mixed success/failure', { concurrency: true }, () => {
+                it('parallel tasks with mixed success/failure complete without stalling', async (t) => {
+                    const ctx = await withMixed(t);
                     const opts = await ctx.opts();
                     const result = await dataflowExecute(ctx.config.baseUrl, ctx.repoName, 'mixed-ws', { force: true }, opts);
                     // Dataflow should complete (not stall) and report failure
@@ -245,16 +250,14 @@ export function dataflowTests(getContext) {
                     assert.ok(failC, 'fail_c task should be in results');
                     assert.strictEqual(failC.state.type, 'failed');
                     // Tasks that did execute should have succeeded
-                    // (orchestrator may stop launching new tasks after a failure,
-                    //  so not all succeed tasks are guaranteed to have run)
                     for (const task of result.tasks) {
                         if (task.name !== 'fail_c') {
                             assert.strictEqual(task.state.type, 'success', `Task ${task.name} should succeed`);
                         }
                     }
                 });
-                it('failed task logs are accessible', async () => {
-                    const ctx = getContext();
+                it('failed task logs are accessible', async (t) => {
+                    const ctx = await withMixed(t);
                     const opts = await ctx.opts();
                     // Execute first to generate logs
                     await dataflowExecute(ctx.config.baseUrl, ctx.repoName, 'mixed-ws', { force: true }, opts);
@@ -263,8 +266,8 @@ export function dataflowTests(getContext) {
                     assert.ok(typeof logs.data === 'string', 'logs.data should be a string');
                     assert.ok(typeof logs.complete === 'boolean', 'logs.complete should be a boolean');
                 });
-                it('workspace status reflects failed tasks correctly', async () => {
-                    const ctx = getContext();
+                it('workspace status reflects failed tasks correctly', async (t) => {
+                    const ctx = await withMixed(t);
                     const opts = await ctx.opts();
                     await dataflowExecute(ctx.config.baseUrl, ctx.repoName, 'mixed-ws', { force: true }, opts);
                     const status = await workspaceStatus(ctx.config.baseUrl, ctx.repoName, 'mixed-ws', opts);
@@ -278,18 +281,9 @@ export function dataflowTests(getContext) {
                     }
                 });
             });
-            describe('diamond with upstream failure', () => {
-                beforeEach(async () => {
-                    const ctx = getContext();
-                    const opts = await ctx.opts();
-                    const zipPath = await createFailingDiamondPackageZip(ctx.tempDir, 'fdiamond-pkg', '1.0.0');
-                    const packageZip = readFileSync(zipPath);
-                    await packageImport(ctx.config.baseUrl, ctx.repoName, packageZip, opts);
-                    await workspaceCreate(ctx.config.baseUrl, ctx.repoName, 'fdiamond-ws', opts);
-                    await workspaceDeploy(ctx.config.baseUrl, ctx.repoName, 'fdiamond-ws', 'fdiamond-pkg@1.0.0', opts);
-                });
-                it('diamond with upstream failure skips dependents', async () => {
-                    const ctx = getContext();
+            describe('diamond with upstream failure', { concurrency: true }, () => {
+                it('diamond with upstream failure skips dependents', async (t) => {
+                    const ctx = await withFailingDiamond(t);
                     const opts = await ctx.opts();
                     const result = await dataflowExecute(ctx.config.baseUrl, ctx.repoName, 'fdiamond-ws', { force: true }, opts);
                     assert.strictEqual(result.success, false);
@@ -306,8 +300,8 @@ export function dataflowTests(getContext) {
                     assert.strictEqual(rightTask.state.type, 'failed');
                     assert.strictEqual(mergeTask.state.type, 'skipped');
                 });
-                it('taskLogs returns execution_not_found for skipped task', async () => {
-                    const ctx = getContext();
+                it('taskLogs returns execution_not_found for skipped task', async (t) => {
+                    const ctx = await withFailingDiamond(t);
                     const opts = await ctx.opts();
                     // Execute — merge will be skipped because right fails
                     await dataflowExecute(ctx.config.baseUrl, ctx.repoName, 'fdiamond-ws', { force: true }, opts);
@@ -321,18 +315,9 @@ export function dataflowTests(getContext) {
                     }
                 });
             });
-            describe('wide parallel execution', () => {
-                beforeEach(async () => {
-                    const ctx = getContext();
-                    const opts = await ctx.opts();
-                    const zipPath = await createWideParallelPackageZip(ctx.tempDir, 'wide-pkg', '1.0.0', 6);
-                    const packageZip = readFileSync(zipPath);
-                    await packageImport(ctx.config.baseUrl, ctx.repoName, packageZip, opts);
-                    await workspaceCreate(ctx.config.baseUrl, ctx.repoName, 'wide-ws', opts);
-                    await workspaceDeploy(ctx.config.baseUrl, ctx.repoName, 'wide-ws', 'wide-pkg@1.0.0', opts);
-                });
-                it('wide parallel execution completes correctly', async () => {
-                    const ctx = getContext();
+            describe('wide parallel execution', { concurrency: true }, () => {
+                it('wide parallel execution completes correctly', async (t) => {
+                    const ctx = await withWideParallel(t);
                     const opts = await ctx.opts();
                     const result = await dataflowExecute(ctx.config.baseUrl, ctx.repoName, 'wide-ws', { force: true }, opts);
                     assert.strictEqual(result.success, true);
@@ -345,19 +330,11 @@ export function dataflowTests(getContext) {
                 });
             });
         });
+        // Concurrent execution tests must remain serial within their describe
+        // because they test locking behavior with timing-sensitive operations
         describe('concurrent execution', () => {
-            beforeEach(async () => {
-                const ctx = getContext();
-                const opts = await ctx.opts();
-                // Create and import a slow package
-                const zipPath = await createSlowPackageZip(ctx.tempDir, 'slow-pkg', '1.0.0', 30);
-                const packageZip = readFileSync(zipPath);
-                await packageImport(ctx.config.baseUrl, ctx.repoName, packageZip, opts);
-                await workspaceCreate(ctx.config.baseUrl, ctx.repoName, 'slow-ws', opts);
-                await workspaceDeploy(ctx.config.baseUrl, ctx.repoName, 'slow-ws', 'slow-pkg@1.0.0', opts);
-            });
-            it('rejects second dataflowStart while execution is running', async () => {
-                const ctx = getContext();
+            it('rejects second dataflowStart while execution is running', async (t) => {
+                const ctx = await withSlow(t);
                 const opts = await ctx.opts();
                 // Start first execution (non-blocking)
                 await dataflowStart(ctx.config.baseUrl, ctx.repoName, 'slow-ws', { force: true }, opts);
@@ -375,8 +352,8 @@ export function dataflowTests(getContext) {
                     assert.ok(message.includes('lock') || message.includes('running') || message.includes('busy'), `Expected lock-related error, got: ${err.message}`);
                 }
             });
-            it('rejects dataflowExecute while execution is running', async () => {
-                const ctx = getContext();
+            it('rejects dataflowExecute while execution is running', async (t) => {
+                const ctx = await withSlow(t);
                 const opts = await ctx.opts();
                 // Start first execution (non-blocking)
                 await dataflowStart(ctx.config.baseUrl, ctx.repoName, 'slow-ws', { force: true }, opts);
@@ -393,8 +370,8 @@ export function dataflowTests(getContext) {
                     assert.ok(message.includes('lock') || message.includes('running') || message.includes('busy'), `Expected lock-related error, got: ${err.message}`);
                 }
             });
-            it('dataflowCancel stops a running execution', async () => {
-                const ctx = getContext();
+            it('dataflowCancel stops a running execution', async (t) => {
+                const ctx = await withSlow(t);
                 const opts = await ctx.opts();
                 // Start slow execution
                 await dataflowStart(ctx.config.baseUrl, ctx.repoName, 'slow-ws', { force: true }, opts);
@@ -406,8 +383,8 @@ export function dataflowTests(getContext) {
                 const state = await dataflowExecution(ctx.config.baseUrl, ctx.repoName, 'slow-ws', {}, opts);
                 assert.strictEqual(state.status.type, 'aborted');
             });
-            it('dataflowCancel returns error when no execution is running', async () => {
-                const ctx = getContext();
+            it('dataflowCancel returns error when no execution is running', async (t) => {
+                const ctx = await withSlow(t);
                 const opts = await ctx.opts();
                 // Try to cancel when nothing is running
                 try {
@@ -420,19 +397,9 @@ export function dataflowTests(getContext) {
                 }
             });
         });
-        describe('execution not found', () => {
-            beforeEach(async () => {
-                const ctx = getContext();
-                const opts = await ctx.opts();
-                // Create and import a simple package, deploy but do NOT execute
-                const zipPath = await createPackageZip(ctx.tempDir, 'noexec-pkg', '1.0.0');
-                const packageZip = readFileSync(zipPath);
-                await packageImport(ctx.config.baseUrl, ctx.repoName, packageZip, opts);
-                await workspaceCreate(ctx.config.baseUrl, ctx.repoName, 'noexec-ws', opts);
-                await workspaceDeploy(ctx.config.baseUrl, ctx.repoName, 'noexec-ws', 'noexec-pkg@1.0.0', opts);
-            });
-            it('taskLogs returns execution_not_found for never-executed task', async () => {
-                const ctx = getContext();
+        describe('execution not found', { concurrency: true }, () => {
+            it('taskLogs returns execution_not_found for never-executed task', async (t) => {
+                const ctx = await withNoExec(t);
                 const opts = await ctx.opts();
                 try {
                     await taskLogs(ctx.config.baseUrl, ctx.repoName, 'noexec-ws', 'compute', { stream: 'stdout' }, opts);
@@ -443,8 +410,8 @@ export function dataflowTests(getContext) {
                     assert.strictEqual(err.code, 'execution_not_found');
                 }
             });
-            it('taskLogs returns task_not_found for non-existent task', async () => {
-                const ctx = getContext();
+            it('taskLogs returns task_not_found for non-existent task', async (t) => {
+                const ctx = await withNoExec(t);
                 const opts = await ctx.opts();
                 try {
                     await taskLogs(ctx.config.baseUrl, ctx.repoName, 'noexec-ws', 'no_such_task', { stream: 'stdout' }, opts);
@@ -455,8 +422,8 @@ export function dataflowTests(getContext) {
                     assert.strictEqual(err.code, 'task_not_found');
                 }
             });
-            it('taskLogs returns workspace_not_found for non-existent workspace', async () => {
-                const ctx = getContext();
+            it('taskLogs returns workspace_not_found for non-existent workspace', async (t) => {
+                const ctx = await withNoExec(t);
                 const opts = await ctx.opts();
                 try {
                     await taskLogs(ctx.config.baseUrl, ctx.repoName, 'no_such_ws', 'compute', { stream: 'stdout' }, opts);
@@ -468,9 +435,9 @@ export function dataflowTests(getContext) {
                 }
             });
         });
-        describe('workspace error handling', () => {
-            it('dataflowExecute returns error for non-existent workspace', async () => {
-                const ctx = getContext();
+        describe('workspace error handling', { concurrency: true }, () => {
+            it('dataflowExecute returns error for non-existent workspace', async (t) => {
+                const ctx = await setup(t);
                 const opts = await ctx.opts();
                 try {
                     await dataflowExecute(ctx.config.baseUrl, ctx.repoName, 'no_such_ws', { force: true }, opts);
@@ -481,8 +448,8 @@ export function dataflowTests(getContext) {
                     assert.ok(err.code === 'workspace_not_found' || err.code === 'workspace_not_deployed', `Expected workspace_not_found or workspace_not_deployed, got ${err.code}`);
                 }
             });
-            it('dataflowGraph returns error for non-existent workspace', async () => {
-                const ctx = getContext();
+            it('dataflowGraph returns error for non-existent workspace', async (t) => {
+                const ctx = await setup(t);
                 const opts = await ctx.opts();
                 try {
                     await dataflowGraph(ctx.config.baseUrl, ctx.repoName, 'no_such_ws', opts);
@@ -493,8 +460,8 @@ export function dataflowTests(getContext) {
                     assert.ok(err.code === 'workspace_not_found' || err.code === 'workspace_not_deployed', `Expected workspace_not_found or workspace_not_deployed, got ${err.code}`);
                 }
             });
-            it('workspaceStatus returns error for non-existent workspace', async () => {
-                const ctx = getContext();
+            it('workspaceStatus returns error for non-existent workspace', async (t) => {
+                const ctx = await setup(t);
                 const opts = await ctx.opts();
                 try {
                     await workspaceStatus(ctx.config.baseUrl, ctx.repoName, 'no_such_ws', opts);
@@ -506,18 +473,9 @@ export function dataflowTests(getContext) {
                 }
             });
         });
-        describe('cache behavior', () => {
-            beforeEach(async () => {
-                const ctx = getContext();
-                const opts = await ctx.opts();
-                const zipPath = await createPackageZip(ctx.tempDir, 'cache-pkg', '1.0.0');
-                const packageZip = readFileSync(zipPath);
-                await packageImport(ctx.config.baseUrl, ctx.repoName, packageZip, opts);
-                await workspaceCreate(ctx.config.baseUrl, ctx.repoName, 'cache-ws', opts);
-                await workspaceDeploy(ctx.config.baseUrl, ctx.repoName, 'cache-ws', 'cache-pkg@1.0.0', opts);
-            });
-            it('second execution uses cached results', async () => {
-                const ctx = getContext();
+        describe('cache behavior', { concurrency: true }, () => {
+            it('second execution uses cached results', async (t) => {
+                const ctx = await withCache(t);
                 const opts = await ctx.opts();
                 // First execution - should execute the task
                 const result1 = await dataflowExecute(ctx.config.baseUrl, ctx.repoName, 'cache-ws', { force: false }, opts);
@@ -529,8 +487,8 @@ export function dataflowTests(getContext) {
                 assert.ok(result2.cached > 0n, `Expected cached > 0, got ${result2.cached}`);
                 assert.strictEqual(result2.executed, 0n);
             });
-            it('force bypasses cache', async () => {
-                const ctx = getContext();
+            it('force bypasses cache', async (t) => {
+                const ctx = await withCache(t);
                 const opts = await ctx.opts();
                 // First execution
                 await dataflowExecute(ctx.config.baseUrl, ctx.repoName, 'cache-ws', { force: false }, opts);
@@ -540,18 +498,9 @@ export function dataflowTests(getContext) {
                 assert.ok(result.executed > 0n, `Expected executed > 0, got ${result.executed}`);
             });
         });
-        describe('task filter', () => {
-            beforeEach(async () => {
-                const ctx = getContext();
-                const opts = await ctx.opts();
-                const zipPath = await createDiamondPackageZip(ctx.tempDir, 'filter-pkg', '1.0.0');
-                const packageZip = readFileSync(zipPath);
-                await packageImport(ctx.config.baseUrl, ctx.repoName, packageZip, opts);
-                await workspaceCreate(ctx.config.baseUrl, ctx.repoName, 'filter-ws', opts);
-                await workspaceDeploy(ctx.config.baseUrl, ctx.repoName, 'filter-ws', 'filter-pkg@1.0.0', opts);
-            });
-            it('filter runs only the specified task', async () => {
-                const ctx = getContext();
+        describe('task filter', { concurrency: true }, () => {
+            it('filter runs only the specified task', async (t) => {
+                const ctx = await withFilter(t);
                 const opts = await ctx.opts();
                 const result = await dataflowExecute(ctx.config.baseUrl, ctx.repoName, 'filter-ws', { force: true, filter: 'left' }, opts);
                 assert.strictEqual(result.success, true);
@@ -560,8 +509,8 @@ export function dataflowTests(getContext) {
                 assert.strictEqual(executedTasks.length, 1, `Expected 1 executed task, got ${executedTasks.length}`);
                 assert.strictEqual(executedTasks[0].name, 'left');
             });
-            it('filter with non-existent task returns error', async () => {
-                const ctx = getContext();
+            it('filter with non-existent task returns error', async (t) => {
+                const ctx = await withFilter(t);
                 const opts = await ctx.opts();
                 try {
                     await dataflowExecute(ctx.config.baseUrl, ctx.repoName, 'filter-ws', { force: true, filter: 'no_such_task' }, opts);
@@ -573,18 +522,9 @@ export function dataflowTests(getContext) {
                 }
             });
         });
-        describe('dependency graph', () => {
-            beforeEach(async () => {
-                const ctx = getContext();
-                const opts = await ctx.opts();
-                const zipPath = await createDiamondPackageZip(ctx.tempDir, 'graph-pkg', '1.0.0');
-                const packageZip = readFileSync(zipPath);
-                await packageImport(ctx.config.baseUrl, ctx.repoName, packageZip, opts);
-                await workspaceCreate(ctx.config.baseUrl, ctx.repoName, 'graph-ws', opts);
-                await workspaceDeploy(ctx.config.baseUrl, ctx.repoName, 'graph-ws', 'graph-pkg@1.0.0', opts);
-            });
-            it('dataflowGraph returns correct structure', async () => {
-                const ctx = getContext();
+        describe('dependency graph', { concurrency: true }, () => {
+            it('dataflowGraph returns correct structure', async (t) => {
+                const ctx = await withGraph(t);
                 const opts = await ctx.opts();
                 const graph = await dataflowGraph(ctx.config.baseUrl, ctx.repoName, 'graph-ws', opts);
                 // Should have 3 tasks: left, right, merge
@@ -604,18 +544,9 @@ export function dataflowTests(getContext) {
                 assert.strictEqual(merge.dependsOn.length, 2);
             });
         });
-        describe('log pagination', () => {
-            beforeEach(async () => {
-                const ctx = getContext();
-                const opts = await ctx.opts();
-                const zipPath = await createPackageZip(ctx.tempDir, 'logpag-pkg', '1.0.0');
-                const packageZip = readFileSync(zipPath);
-                await packageImport(ctx.config.baseUrl, ctx.repoName, packageZip, opts);
-                await workspaceCreate(ctx.config.baseUrl, ctx.repoName, 'logpag-ws', opts);
-                await workspaceDeploy(ctx.config.baseUrl, ctx.repoName, 'logpag-ws', 'logpag-pkg@1.0.0', opts);
-            });
-            it('taskLogs supports offset and limit', async () => {
-                const ctx = getContext();
+        describe('log pagination', { concurrency: true }, () => {
+            it('taskLogs supports offset and limit', async (t) => {
+                const ctx = await withLogPag(t);
                 const opts = await ctx.opts();
                 // Execute to generate logs
                 await dataflowExecute(ctx.config.baseUrl, ctx.repoName, 'logpag-ws', { force: true }, opts);
@@ -635,18 +566,9 @@ export function dataflowTests(getContext) {
                 assert.strictEqual(chunk2.data, full.data.slice(5));
             });
         });
-        describe('event pagination', () => {
-            beforeEach(async () => {
-                const ctx = getContext();
-                const opts = await ctx.opts();
-                const zipPath = await createDiamondPackageZip(ctx.tempDir, 'evtpag-pkg', '1.0.0');
-                const packageZip = readFileSync(zipPath);
-                await packageImport(ctx.config.baseUrl, ctx.repoName, packageZip, opts);
-                await workspaceCreate(ctx.config.baseUrl, ctx.repoName, 'evtpag-ws', opts);
-                await workspaceDeploy(ctx.config.baseUrl, ctx.repoName, 'evtpag-ws', 'evtpag-pkg@1.0.0', opts);
-            });
-            it('dataflowExecution supports event offset and limit', async () => {
-                const ctx = getContext();
+        describe('event pagination', { concurrency: true }, () => {
+            it('dataflowExecution supports event offset and limit', async (t) => {
+                const ctx = await withEvtPag(t);
                 const opts = await ctx.opts();
                 // Execute and wait for completion
                 await dataflowExecute(ctx.config.baseUrl, ctx.repoName, 'evtpag-ws', { force: true }, opts);