@telorun/test 0.2.1 → 0.3.1

package/README.md

@@ -1,6 +1,21 @@
-# ⚡ Telo
-
-Runtime for declarative backends.
+<p align="center">
+  <img src="./assets/telo.png" alt="Telo" width="200" />
+</p>
+
+<h1 align="center">Telo</h1>
+
+<p align="center">Runtime for declarative backends.</p>
+
+<p align="center">
+  <a href="https://github.com/telorun/telo/actions/workflows/test.yml"><img alt="Tests" src="https://github.com/telorun/telo/actions/workflows/test.yml/badge.svg" /></a>
+  <a href="https://www.npmjs.com/package/@telorun/cli"><img alt="node" src="https://img.shields.io/node/v/@telorun/cli" /></a>
+  <br />
+  <a href="https://github.com/telorun/telo/commits/main"><img alt="Last commit" src="https://img.shields.io/github/last-commit/telorun/telo" /></a>
+  <a href="https://github.com/telorun/telo/issues"><img alt="Issues" src="https://img.shields.io/github/issues/telorun/telo" /></a>
+  <a href="https://github.com/telorun/telo/pulls"><img alt="Pull requests" src="https://img.shields.io/github/issues-pr/telorun/telo" /></a>
+  <br />
+  <img alt="Changesets" src="https://img.shields.io/badge/maintained%20with-changesets-176de3" />
+</p>
 
 Telo is an execution engine (Micro-Kernel) that runs logic defined entirely in YAML manifests. Instead of writing imperative backend code, you define your routes, databases, schemas, and AI workflows as atomic, interconnected YAML documents. Telo takes those manifests and runs them.
 

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.1",
+  "version": "0.3.1",
   "description": "Telo Test module - Test runner for Telo manifests.",
   "keywords": [
     "telo",
@@ -33,8 +33,8 @@
   ],
   "dependencies": {
     "@sinclair/typebox": "^0.34.48",
-    "@telorun/sdk": "0.6.0",
-    "@telorun/kernel": "0.6.1"
+    "@telorun/kernel": "0.7.1",
+    "@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);