@telorun/test 0.2.0 → 0.3.0

package/dist/suite.d.ts

@@ -14,6 +14,7 @@ export declare const schema: import("@sinclair/typebox").TObject<{
     include: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
     exclude: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
     filter: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    concurrency: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TInteger>;
 }>;
 type SuiteManifest = Static<typeof schema>;
 export declare function create(manifest: SuiteManifest, ctx: ResourceContext): Promise<Runnable>;

package/dist/suite.js

@@ -4,6 +4,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { Writable } from "stream";
 import { fileURLToPath } from "url";
+const DEFAULT_CONCURRENCY = 3;
 class BufferedWritable extends Writable {
     chunks = [];
     _write(chunk, _encoding, cb) {
@@ -24,6 +25,7 @@ export const schema = Type.Object({
     include: Type.Optional(Type.Array(Type.String())),
     exclude: Type.Optional(Type.Array(Type.String())),
     filter: Type.Optional(Type.String()),
+    concurrency: Type.Optional(Type.Integer({ minimum: 1 })),
 });
 function createColors(stream) {
     const useColor = stream.isTTY ?? false;
@@ -177,24 +179,36 @@ export async function create(manifest, ctx) {
             }
             const singleTest = tests.length === 1;
             const results = [];
-            for (const testPath of tests) {
-                const label = labelFor(testPath, baseDir);
-                const result = await runOneTest(testPath, !singleTest, ctx.stdout, ctx.stderr);
-                result.label = label;
-                results.push(result);
-                if (result.passed) {
-                    ctx.stdout.write(green("PASS") + " " + dim(label) + " " + dim(`(${result.durationMs}ms)`) + "\n");
-                }
-                else {
-                    ctx.stderr.write(red("FAIL") + " " + label + " " + dim(`(${result.durationMs}ms)`) + "\n");
-                    if (result.output) {
-                        ctx.stderr.write(result.output);
+            const requestedConcurrency = manifest.concurrency ?? DEFAULT_CONCURRENCY;
+            const concurrency = singleTest ? 1 : Math.max(1, Math.min(requestedConcurrency, tests.length));
+            let nextIdx = 0;
+            const worker = async () => {
+                while (true) {
+                    const i = nextIdx++;
+                    if (i >= tests.length)
+                        return;
+                    const testPath = tests[i];
+                    const label = labelFor(testPath, baseDir);
+                    const result = await runOneTest(testPath, !singleTest, ctx.stdout, ctx.stderr);
+                    result.label = label;
+                    results.push(result);
+                    if (result.passed) {
+                        ctx.stdout.write(green("PASS") + " " + dim(label) + " " + dim(`(${result.durationMs}ms)`) + "\n");
                     }
-                    if (result.error) {
-                        ctx.stderr.write(dim(`  ${result.error}`) + "\n");
+                    else {
+                        // Compose the whole FAIL block into one write so a parallel
+                        // worker's output can't interleave between the header, captured
+                        // output, and error line on stderr.
+                        let block = red("FAIL") + " " + label + " " + dim(`(${result.durationMs}ms)`) + "\n";
+                        if (result.output)
+                            block += result.output;
+                        if (result.error)
+                            block += dim(`  ${result.error}`) + "\n";
+                        ctx.stderr.write(block);
                     }
                 }
-            }
+            };
+            await Promise.all(Array.from({ length: concurrency }, () => worker()));
             const passed = results.filter((r) => r.passed);
             const failed = results.filter((r) => !r.passed);
             if (!singleTest) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telorun/test",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Telo Test module - Test runner for Telo manifests.",
   "keywords": [
     "telo",
@@ -33,8 +33,8 @@
   ],
   "dependencies": {
     "@sinclair/typebox": "^0.34.48",
-    "@telorun/kernel": "0.6.0",
-    "@telorun/sdk": "0.6.0"
+    "@telorun/kernel": "0.7.0",
+    "@telorun/sdk": "0.7.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",

package/src/suite.ts

@@ -6,6 +6,8 @@ import * as path from "path";
 import { Writable } from "stream";
 import { fileURLToPath } from "url";
 
+const DEFAULT_CONCURRENCY = 3;
+
 class BufferedWritable extends Writable {
   private chunks: Buffer[] = [];
 
@@ -34,6 +36,7 @@ export const schema = Type.Object({
     Type.Array(Type.String()),
   ),
   filter: Type.Optional(Type.String()),
+  concurrency: Type.Optional(Type.Integer({ minimum: 1 })),
 });
 
 type SuiteManifest = Static<typeof schema>;
@@ -219,24 +222,35 @@ export async function create(
       const singleTest = tests.length === 1;
       const results: TestResult[] = [];
 
-      for (const testPath of tests) {
-        const label = labelFor(testPath, baseDir);
-        const result = await runOneTest(testPath, !singleTest, ctx.stdout, ctx.stderr);
-        result.label = label;
-        results.push(result);
+      const requestedConcurrency = manifest.concurrency ?? DEFAULT_CONCURRENCY;
+      const concurrency = singleTest ? 1 : Math.max(1, Math.min(requestedConcurrency, tests.length));
 
-        if (result.passed) {
-          ctx.stdout.write(green("PASS") + " " + dim(label) + " " + dim(`(${result.durationMs}ms)`) + "\n");
-        } else {
-          ctx.stderr.write(red("FAIL") + " " + label + " " + dim(`(${result.durationMs}ms)`) + "\n");
-          if (result.output) {
-            ctx.stderr.write(result.output);
-          }
-          if (result.error) {
-            ctx.stderr.write(dim(`  ${result.error}`) + "\n");
+      let nextIdx = 0;
+      const worker = async () => {
+        while (true) {
+          const i = nextIdx++;
+          if (i >= tests.length) return;
+          const testPath = tests[i];
+          const label = labelFor(testPath, baseDir);
+          const result = await runOneTest(testPath, !singleTest, ctx.stdout, ctx.stderr);
+          result.label = label;
+          results.push(result);
+
+          if (result.passed) {
+            ctx.stdout.write(green("PASS") + " " + dim(label) + " " + dim(`(${result.durationMs}ms)`) + "\n");
+          } else {
+            // Compose the whole FAIL block into one write so a parallel
+            // worker's output can't interleave between the header, captured
+            // output, and error line on stderr.
+            let block = red("FAIL") + " " + label + " " + dim(`(${result.durationMs}ms)`) + "\n";
+            if (result.output) block += result.output;
+            if (result.error) block += dim(`  ${result.error}`) + "\n";
+            ctx.stderr.write(block);
           }
         }
-      }
+      };
+
+      await Promise.all(Array.from({ length: concurrency }, () => worker()));
 
       const passed = results.filter((r) => r.passed);
       const failed = results.filter((r) => !r.passed);