@telorun/test 0.1.0

package/dist/suite.d.ts

@@ -0,0 +1,20 @@
+import type { ResourceContext, Runnable } from "@telorun/sdk";
+import { Static } from "@sinclair/typebox";
+export declare const args: {
+    filter: {
+        type: "string";
+        alias: string;
+        description: string;
+    };
+};
+export declare const schema: import("@sinclair/typebox").TObject<{
+    metadata: import("@sinclair/typebox").TObject<{
+        name: import("@sinclair/typebox").TString;
+    }>;
+    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>;
+}>;
+type SuiteManifest = Static<typeof schema>;
+export declare function create(manifest: SuiteManifest, ctx: ResourceContext): Promise<Runnable>;
+export {};

package/dist/suite.js

@@ -0,0 +1,188 @@
+import { Kernel } from "@telorun/kernel";
+import { Type } from "@sinclair/typebox";
+import * as fs from "fs";
+import * as path from "path";
+import { Writable } from "stream";
+import { fileURLToPath } from "url";
+class BufferedWritable extends Writable {
+    chunks = [];
+    _write(chunk, _encoding, cb) {
+        this.chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+        cb();
+    }
+    get content() {
+        return Buffer.concat(this.chunks).toString("utf8");
+    }
+}
+export const args = {
+    filter: { type: "string", alias: "f", description: "Filter tests by name substring" },
+};
+export const schema = Type.Object({
+    metadata: Type.Object({
+        name: Type.String(),
+    }),
+    include: Type.Optional(Type.Array(Type.String())),
+    exclude: Type.Optional(Type.Array(Type.String())),
+    filter: Type.Optional(Type.String()),
+});
+function createColors(stream) {
+    const useColor = stream.isTTY ?? false;
+    const c = (code, text) => (useColor ? `\x1b[${code}m${text}\x1b[0m` : text);
+    return {
+        bold: (t) => c("1", t),
+        red: (t) => c("31", t),
+        green: (t) => c("32", t),
+        yellow: (t) => c("33", t),
+        dim: (t) => c("2", t),
+    };
+}
+function globToRegex(pattern) {
+    const re = pattern
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+        .replace(/\*\*\//g, "(.+/)?")
+        .replace(/\*/g, "[^/]+");
+    return new RegExp(`^${re}$`);
+}
+function discoverTests(baseDir, include, exclude, filter) {
+    const entries = fs.readdirSync(baseDir, { recursive: true, encoding: "utf8" });
+    const includeRe = include.map(globToRegex);
+    const excludeRe = exclude.map(globToRegex);
+    const results = [];
+    for (const entry of entries) {
+        const normalized = entry.replace(/\\/g, "/");
+        if (normalized.includes("node_modules/"))
+            continue;
+        if (!includeRe.some((re) => re.test(normalized)))
+            continue;
+        if (excludeRe.some((re) => re.test(normalized)))
+            continue;
+        if (filter && !normalized.includes(filter))
+            continue;
+        results.push(path.resolve(baseDir, entry));
+    }
+    results.sort();
+    return results;
+}
+function labelFor(testPath, baseDir) {
+    return path.relative(baseDir, testPath);
+}
+/**
+ * Parse a .env file into a key-value map.
+ * Supports KEY=VALUE lines, ignores comments and blank lines.
+ */
+function parseEnvFile(content) {
+    const result = {};
+    for (const line of content.split("\n")) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const eq = trimmed.indexOf("=");
+        if (eq === -1)
+            continue;
+        const key = trimmed.slice(0, eq).trim();
+        let value = trimmed.slice(eq + 1).trim();
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        result[key] = value;
+    }
+    return result;
+}
+function tryReadFile(filePath) {
+    try {
+        return fs.readFileSync(filePath, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * Build an env object for a test manifest by layering .env and .env.local
+ * from the manifest's directory on top of the current process.env.
+ * Keys already present in process.env take precedence (same as CLI behaviour).
+ */
+function buildEnvForManifest(manifestPath) {
+    const dir = path.dirname(path.resolve(manifestPath));
+    const base = parseEnvFile(tryReadFile(path.join(dir, ".env")));
+    const local = parseEnvFile(tryReadFile(path.join(dir, ".env.local")));
+    return { ...base, ...local, ...process.env };
+}
+async function runOneTest(testPath, captureOutput, parentStdout, parentStderr) {
+    const start = Date.now();
+    const stdout = captureOutput ? new BufferedWritable() : parentStdout;
+    const stderr = captureOutput ? new BufferedWritable() : parentStderr;
+    try {
+        const kernel = new Kernel({ env: buildEnvForManifest(testPath), stdout, stderr });
+        await kernel.loadFromConfig(testPath);
+        await kernel.start();
+        return {
+            path: testPath,
+            label: "",
+            passed: kernel.exitCode === 0,
+            durationMs: Date.now() - start,
+            output: captureOutput ? stdout.content + stderr.content : undefined,
+        };
+    }
+    catch (err) {
+        return {
+            path: testPath,
+            label: "",
+            passed: false,
+            durationMs: Date.now() - start,
+            error: err instanceof Error ? err.message : String(err),
+            output: captureOutput ? stdout.content + stderr.content : undefined,
+        };
+    }
+}
+export async function create(manifest, ctx) {
+    const { bold, red, green, yellow, dim } = createColors(ctx.stderr);
+    return {
+        run: async () => {
+            const sourceUrl = ctx.moduleContext.source;
+            const baseDir = sourceUrl.startsWith("file://")
+                ? path.dirname(fileURLToPath(sourceUrl))
+                : process.cwd();
+            const include = manifest.include ?? ["**/tests/*.yaml"];
+            const exclude = manifest.exclude ?? ["**/__fixtures__/**"];
+            const filter = ctx.args.filter || ctx.args._[0] || manifest.filter;
+            const tests = discoverTests(baseDir, include, exclude, filter);
+            if (tests.length === 0) {
+                ctx.stderr.write(bold(yellow(`Test.Suite.${manifest.metadata.name}: no tests found`)) + "\n");
+                return;
+            }
+            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);
+                    }
+                    if (result.error) {
+                        ctx.stderr.write(dim(`  ${result.error}`) + "\n");
+                    }
+                }
+            }
+            const passed = results.filter((r) => r.passed);
+            const failed = results.filter((r) => !r.passed);
+            if (!singleTest) {
+                ctx.stdout.write("\n" + bold("Test Suite Results") + "\n");
+                ctx.stdout.write(green(`  Passed: ${passed.length}`) +
+                    (failed.length > 0 ? "  " + red(`Failed: ${failed.length}`) : "") +
+                    "  " +
+                    dim(`Total: ${results.length}`) +
+                    "\n");
+            }
+            if (failed.length > 0) {
+                ctx.requestExit(1);
+            }
+        },
+    };
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@telorun/test",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    "./suite": {
+      "source": "./src/suite.ts",
+      "bun": "./src/suite.ts",
+      "import": "./dist/suite.js",
+      "default": "./dist/suite.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.lib.json"
+  },
+  "files": [
+    "dist",
+    "src/**"
+  ],
+  "dependencies": {
+    "@sinclair/typebox": "^0.34.48",
+    "@telorun/kernel": "workspace:*",
+    "@telorun/sdk": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  }
+}

package/src/suite.ts

@@ -0,0 +1,236 @@
+import { Kernel } from "@telorun/kernel";
+import type { ResourceContext, Runnable } from "@telorun/sdk";
+import { Static, Type } from "@sinclair/typebox";
+import * as fs from "fs";
+import * as path from "path";
+import { Writable } from "stream";
+import { fileURLToPath } from "url";
+
+class BufferedWritable extends Writable {
+  private chunks: Buffer[] = [];
+
+  _write(chunk: Buffer | string, _encoding: string, cb: () => void) {
+    this.chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    cb();
+  }
+
+  get content(): string {
+    return Buffer.concat(this.chunks).toString("utf8");
+  }
+}
+
+export const args = {
+  filter: { type: "string" as const, alias: "f", description: "Filter tests by name substring" },
+};
+
+export const schema = Type.Object({
+  metadata: Type.Object({
+    name: Type.String(),
+  }),
+  include: Type.Optional(
+    Type.Array(Type.String()),
+  ),
+  exclude: Type.Optional(
+    Type.Array(Type.String()),
+  ),
+  filter: Type.Optional(Type.String()),
+});
+
+type SuiteManifest = Static<typeof schema>;
+
+interface TestResult {
+  path: string;
+  label: string;
+  passed: boolean;
+  durationMs: number;
+  error?: string;
+  output?: string;
+}
+
+function createColors(stream: NodeJS.WritableStream) {
+  const useColor = (stream as any).isTTY ?? false;
+  const c = (code: string, text: string) => (useColor ? `\x1b[${code}m${text}\x1b[0m` : text);
+  return {
+    bold: (t: string) => c("1", t),
+    red: (t: string) => c("31", t),
+    green: (t: string) => c("32", t),
+    yellow: (t: string) => c("33", t),
+    dim: (t: string) => c("2", t),
+  };
+}
+
+function globToRegex(pattern: string): RegExp {
+  const re = pattern
+    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+    .replace(/\*\*\//g, "(.+/)?")
+    .replace(/\*/g, "[^/]+");
+  return new RegExp(`^${re}$`);
+}
+
+function discoverTests(
+  baseDir: string,
+  include: string[],
+  exclude: string[],
+  filter?: string,
+): string[] {
+  const entries = fs.readdirSync(baseDir, { recursive: true, encoding: "utf8" });
+  const includeRe = include.map(globToRegex);
+  const excludeRe = exclude.map(globToRegex);
+
+  const results: string[] = [];
+  for (const entry of entries) {
+    const normalized = entry.replace(/\\/g, "/");
+    if (normalized.includes("node_modules/")) continue;
+    if (!includeRe.some((re) => re.test(normalized))) continue;
+    if (excludeRe.some((re) => re.test(normalized))) continue;
+    if (filter && !normalized.includes(filter)) continue;
+    results.push(path.resolve(baseDir, entry));
+  }
+
+  results.sort();
+  return results;
+}
+
+function labelFor(testPath: string, baseDir: string): string {
+  return path.relative(baseDir, testPath);
+}
+
+/**
+ * Parse a .env file into a key-value map.
+ * Supports KEY=VALUE lines, ignores comments and blank lines.
+ */
+function parseEnvFile(content: string): Record<string, string> {
+  const result: Record<string, string> = {};
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eq = trimmed.indexOf("=");
+    if (eq === -1) continue;
+    const key = trimmed.slice(0, eq).trim();
+    let value = trimmed.slice(eq + 1).trim();
+    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+    result[key] = value;
+  }
+  return result;
+}
+
+function tryReadFile(filePath: string): string {
+  try {
+    return fs.readFileSync(filePath, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Build an env object for a test manifest by layering .env and .env.local
+ * from the manifest's directory on top of the current process.env.
+ * Keys already present in process.env take precedence (same as CLI behaviour).
+ */
+function buildEnvForManifest(manifestPath: string): Record<string, string | undefined> {
+  const dir = path.dirname(path.resolve(manifestPath));
+  const base = parseEnvFile(tryReadFile(path.join(dir, ".env")));
+  const local = parseEnvFile(tryReadFile(path.join(dir, ".env.local")));
+  return { ...base, ...local, ...process.env };
+}
+
+async function runOneTest(
+  testPath: string,
+  captureOutput: boolean,
+  parentStdout: NodeJS.WritableStream,
+  parentStderr: NodeJS.WritableStream,
+): Promise<TestResult> {
+  const start = Date.now();
+  const stdout = captureOutput ? new BufferedWritable() : parentStdout;
+  const stderr = captureOutput ? new BufferedWritable() : parentStderr;
+  try {
+    const kernel = new Kernel({ env: buildEnvForManifest(testPath), stdout, stderr });
+    await kernel.loadFromConfig(testPath);
+    await kernel.start();
+    return {
+      path: testPath,
+      label: "",
+      passed: kernel.exitCode === 0,
+      durationMs: Date.now() - start,
+      output: captureOutput ? (stdout as BufferedWritable).content + (stderr as BufferedWritable).content : undefined,
+    };
+  } catch (err) {
+    return {
+      path: testPath,
+      label: "",
+      passed: false,
+      durationMs: Date.now() - start,
+      error: err instanceof Error ? err.message : String(err),
+      output: captureOutput ? (stdout as BufferedWritable).content + (stderr as BufferedWritable).content : undefined,
+    };
+  }
+}
+
+export async function create(
+  manifest: SuiteManifest,
+  ctx: ResourceContext,
+): Promise<Runnable> {
+  const { bold, red, green, yellow, dim } = createColors(ctx.stderr);
+
+  return {
+    run: async () => {
+      const sourceUrl = ctx.moduleContext.source;
+      const baseDir = sourceUrl.startsWith("file://")
+        ? path.dirname(fileURLToPath(sourceUrl))
+        : process.cwd();
+
+      const include = manifest.include ?? ["**/tests/*.yaml"];
+      const exclude = manifest.exclude ?? ["**/__fixtures__/**"];
+      const filter = (ctx.args.filter as string) || (ctx.args._[0] as string) || manifest.filter;
+
+      const tests = discoverTests(baseDir, include, exclude, filter);
+
+      if (tests.length === 0) {
+        ctx.stderr.write(bold(yellow(`Test.Suite.${manifest.metadata.name}: no tests found`)) + "\n");
+        return;
+      }
+
+      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);
+
+        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");
+          }
+        }
+      }
+
+      const passed = results.filter((r) => r.passed);
+      const failed = results.filter((r) => !r.passed);
+
+      if (!singleTest) {
+        ctx.stdout.write("\n" + bold("Test Suite Results") + "\n");
+        ctx.stdout.write(
+          green(`  Passed: ${passed.length}`) +
+            (failed.length > 0 ? "  " + red(`Failed: ${failed.length}`) : "") +
+            "  " +
+            dim(`Total: ${results.length}`) +
+            "\n",
+        );
+      }
+
+      if (failed.length > 0) {
+        ctx.requestExit(1);
+      }
+    },
+  };
+}