ai-tests 2.0.2 → 2.1.3

package/src/cli.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+/**
+ * ai-tests CLI
+ *
+ * Simple CLI for deploying and managing the ai-tests worker.
+ *
+ * Usage:
+ *   npx ai-tests deploy     Deploy to Cloudflare Workers
+ *   npx ai-tests dev        Start local dev server
+ *   npx ai-tests --help     Show help
+ */
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageRoot = join(__dirname, '..');
+const commands = {
+    deploy: {
+        description: 'Deploy ai-tests worker to Cloudflare',
+        args: ['wrangler', 'deploy']
+    },
+    dev: {
+        description: 'Start local development server',
+        args: ['wrangler', 'dev']
+    }
+};
+function showHelp() {
+    console.log(`
+ai-tests - Test utilities worker for Cloudflare Workers
+
+Usage:
+  npx ai-tests <command>
+
+Commands:
+  deploy    Deploy to Cloudflare Workers
+  dev       Start local development server
+  help      Show this help message
+
+Examples:
+  npx ai-tests deploy
+  npx ai-tests dev
+
+After deploying, bind the worker to your sandbox worker:
+  # In your wrangler.toml:
+  [[services]]
+  binding = "TEST"
+  service = "ai-tests"
+`);
+}
+async function run() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    if (!command || command === 'help' || command === '--help' || command === '-h') {
+        showHelp();
+        process.exit(0);
+    }
+    const cmd = commands[command];
+    if (!cmd) {
+        console.error(`Unknown command: ${command}`);
+        showHelp();
+        process.exit(1);
+    }
+    console.log(`Running: ${cmd.args.join(' ')}`);
+    const child = spawn('npx', cmd.args, {
+        cwd: packageRoot,
+        stdio: 'inherit',
+        shell: true
+    });
+    child.on('close', (code) => {
+        process.exit(code ?? 0);
+    });
+}
+run().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/src/index.js

@@ -0,0 +1,18 @@
+/**
+ * ai-tests - Test utilities via RPC
+ *
+ * Provides expect, should, assert, and a test runner that can be:
+ * - Deployed as a Cloudflare Worker
+ * - Run locally via Miniflare
+ * - Called via Workers RPC from other workers (like ai-sandbox)
+ *
+ * @packageDocumentation
+ */
+// Export assertion utilities
+export { Assertion, expect, should, assert } from './assertions.js';
+// Export test runner
+export { TestRunner, createRunner } from './runner.js';
+// Export worker service (WorkerEntrypoint and RpcTarget)
+export { TestService, TestService as TestWorker, TestServiceCore } from './worker.js';
+// Export the default WorkerEntrypoint class
+export { default } from './worker.js';

package/src/local.js

@@ -0,0 +1,62 @@
+/**
+ * Local development helpers for ai-tests
+ *
+ * Run the test worker via Miniflare for local development and Node.js usage.
+ */
+import { TestServiceCore } from './worker.js';
+let miniflareInstance = null;
+let localService = null;
+/**
+ * Get a local TestServiceCore instance
+ *
+ * For local development, this creates a direct instance.
+ * The RPC serialization happens when called via worker bindings.
+ */
+export function getLocalTestService() {
+    if (!localService) {
+        localService = new TestServiceCore();
+    }
+    return localService;
+}
+/**
+ * Start a Miniflare instance running the test worker
+ *
+ * This is useful for testing the RPC interface locally.
+ */
+export async function startTestWorker(options) {
+    const { Miniflare } = await import('miniflare');
+    // Build worker script inline
+    const workerScript = `
+    import { TestService } from './index.js';
+    export { TestService };
+    export default {
+      async fetch(request) {
+        return new Response('ai-tests worker running');
+      }
+    };
+  `;
+    miniflareInstance = new Miniflare({
+        modules: true,
+        script: workerScript,
+        port: options?.port,
+        compatibilityDate: '2024-12-01',
+    });
+    const url = await miniflareInstance.ready;
+    return {
+        url: url.toString(),
+        stop: async () => {
+            if (miniflareInstance) {
+                await miniflareInstance.dispose();
+                miniflareInstance = null;
+            }
+        }
+    };
+}
+/**
+ * Create a test service that can be used as a service binding
+ *
+ * For use in Miniflare configurations when testing sandbox workers.
+ */
+export function createTestServiceBinding() {
+    return new TestServiceCore();
+}

package/src/runner.js

@@ -0,0 +1,214 @@
+/**
+ * Test runner - describe, it, test, hooks
+ *
+ * Provides vitest-compatible test runner API via RPC.
+ */
+import { RpcTarget } from 'cloudflare:workers';
+/**
+ * Test runner that collects and runs tests
+ */
+export class TestRunner extends RpcTarget {
+    tests = [];
+    currentSuite = '';
+    beforeEachHooks = [];
+    afterEachHooks = [];
+    beforeAllHooks = [];
+    afterAllHooks = [];
+    /**
+     * Define a test suite
+     */
+    describe(name, fn) {
+        const prevSuite = this.currentSuite;
+        const prevBeforeEach = [...this.beforeEachHooks];
+        const prevAfterEach = [...this.afterEachHooks];
+        this.currentSuite = this.currentSuite ? `${this.currentSuite} > ${name}` : name;
+        try {
+            fn();
+        }
+        finally {
+            this.currentSuite = prevSuite;
+            this.beforeEachHooks = prevBeforeEach;
+            this.afterEachHooks = prevAfterEach;
+        }
+    }
+    /**
+     * Define a test
+     */
+    it(name, fn) {
+        const fullName = this.currentSuite ? `${this.currentSuite} > ${name}` : name;
+        this.tests.push({
+            name: fullName,
+            fn,
+            hooks: {
+                before: [...this.beforeEachHooks],
+                after: [...this.afterEachHooks]
+            }
+        });
+    }
+    /**
+     * Alias for it
+     */
+    test(name, fn) {
+        this.it(name, fn);
+    }
+    /**
+     * Skip a test
+     */
+    skip(name, _fn) {
+        const fullName = this.currentSuite ? `${this.currentSuite} > ${name}` : name;
+        this.tests.push({
+            name: fullName,
+            fn: null,
+            hooks: { before: [], after: [] },
+            skip: true
+        });
+    }
+    /**
+     * Run only this test
+     */
+    only(name, fn) {
+        const fullName = this.currentSuite ? `${this.currentSuite} > ${name}` : name;
+        this.tests.push({
+            name: fullName,
+            fn,
+            hooks: {
+                before: [...this.beforeEachHooks],
+                after: [...this.afterEachHooks]
+            },
+            only: true
+        });
+    }
+    /**
+     * Register a beforeEach hook
+     */
+    beforeEach(fn) {
+        this.beforeEachHooks.push(fn);
+    }
+    /**
+     * Register an afterEach hook
+     */
+    afterEach(fn) {
+        this.afterEachHooks.push(fn);
+    }
+    /**
+     * Register a beforeAll hook
+     */
+    beforeAll(fn) {
+        this.beforeAllHooks.push(fn);
+    }
+    /**
+     * Register an afterAll hook
+     */
+    afterAll(fn) {
+        this.afterAllHooks.push(fn);
+    }
+    /**
+     * Run all registered tests and return results
+     */
+    async run() {
+        const startTime = Date.now();
+        const results = [];
+        // Check for .only tests
+        const hasOnly = this.tests.some(t => t.only);
+        const testsToRun = hasOnly
+            ? this.tests.filter(t => t.only || t.skip)
+            : this.tests;
+        // Run beforeAll hooks
+        for (const hook of this.beforeAllHooks) {
+            try {
+                await hook();
+            }
+            catch (e) {
+                // If beforeAll fails, fail all tests
+                const error = e instanceof Error ? e.message : String(e);
+                for (const test of testsToRun) {
+                    results.push({
+                        name: test.name,
+                        passed: false,
+                        error: `beforeAll hook failed: ${error}`,
+                        duration: 0
+                    });
+                }
+                return this.buildResults(results, startTime);
+            }
+        }
+        // Run each test
+        for (const test of testsToRun) {
+            if (test.skip) {
+                results.push({
+                    name: test.name,
+                    passed: true,
+                    skipped: true,
+                    duration: 0
+                });
+                continue;
+            }
+            const testStart = Date.now();
+            try {
+                // Run beforeEach hooks
+                for (const hook of test.hooks.before) {
+                    await hook();
+                }
+                // Run the test
+                if (test.fn) {
+                    await test.fn();
+                }
+                // Run afterEach hooks
+                for (const hook of test.hooks.after) {
+                    await hook();
+                }
+                results.push({
+                    name: test.name,
+                    passed: true,
+                    duration: Date.now() - testStart
+                });
+            }
+            catch (e) {
+                results.push({
+                    name: test.name,
+                    passed: false,
+                    error: e instanceof Error ? e.message : String(e),
+                    duration: Date.now() - testStart
+                });
+            }
+        }
+        // Run afterAll hooks
+        for (const hook of this.afterAllHooks) {
+            try {
+                await hook();
+            }
+            catch (e) {
+                // Log but don't fail tests
+                console.error('afterAll hook failed:', e);
+            }
+        }
+        return this.buildResults(results, startTime);
+    }
+    /**
+     * Clear all registered tests and hooks
+     */
+    reset() {
+        this.tests = [];
+        this.currentSuite = '';
+        this.beforeEachHooks = [];
+        this.afterEachHooks = [];
+        this.beforeAllHooks = [];
+        this.afterAllHooks = [];
+    }
+    buildResults(results, startTime) {
+        return {
+            total: results.length,
+            passed: results.filter(r => r.passed && !r.skipped).length,
+            failed: results.filter(r => !r.passed).length,
+            skipped: results.filter(r => r.skipped).length,
+            tests: results,
+            duration: Date.now() - startTime
+        };
+    }
+}
+/**
+ * Create a new test runner instance
+ */
+export function createRunner() {
+    return new TestRunner();
+}

package/src/types.js

@@ -0,0 +1,4 @@
+/**
+ * Types for ai-test
+ */
+export {};

package/src/worker.js

@@ -0,0 +1,91 @@
+/**
+ * Test Worker - provides test utilities via RPC
+ *
+ * This worker can be deployed to Cloudflare Workers or run locally via Miniflare.
+ * It exposes expect, should, assert, and a test runner via Workers RPC.
+ *
+ * Uses Cloudflare Workers RPC (WorkerEntrypoint, RpcTarget) for communication.
+ */
+import { WorkerEntrypoint, RpcTarget } from 'cloudflare:workers';
+import { expect, should, assert } from './assertions.js';
+import { createRunner } from './runner.js';
+/**
+ * Core test service - extends RpcTarget so it can be passed over RPC
+ *
+ * Contains all test functionality: assertions (expect, should, assert)
+ * and test runner (describe, it, test, hooks)
+ */
+export class TestServiceCore extends RpcTarget {
+    runner;
+    constructor() {
+        super();
+        this.runner = createRunner();
+    }
+    expect(value, message) {
+        return expect(value, message);
+    }
+    should(value) {
+        return should(value);
+    }
+    get assert() {
+        return assert;
+    }
+    describe(name, fn) {
+        this.runner.describe(name, fn);
+    }
+    it(name, fn) {
+        this.runner.it(name, fn);
+    }
+    test(name, fn) {
+        this.runner.test(name, fn);
+    }
+    skip(name, fn) {
+        this.runner.skip(name, fn);
+    }
+    only(name, fn) {
+        this.runner.only(name, fn);
+    }
+    beforeEach(fn) {
+        this.runner.beforeEach(fn);
+    }
+    afterEach(fn) {
+        this.runner.afterEach(fn);
+    }
+    beforeAll(fn) {
+        this.runner.beforeAll(fn);
+    }
+    afterAll(fn) {
+        this.runner.afterAll(fn);
+    }
+    async run() {
+        return this.runner.run();
+    }
+    reset() {
+        this.runner.reset();
+    }
+    createRunner() {
+        return createRunner();
+    }
+}
+/**
+ * Main test service exposed via RPC as WorkerEntrypoint
+ *
+ * Usage:
+ *   const tests = await env.TEST.connect()
+ *   tests.expect(1).to.equal(1)
+ *   tests.describe('suite', () => { ... })
+ *   const results = await tests.run()
+ */
+export class TestService extends WorkerEntrypoint {
+    /**
+     * Get a test service instance - returns an RpcTarget that can be used directly
+     * This avoids boilerplate delegation and allows using `test` method name
+     */
+    connect() {
+        return new TestServiceCore();
+    }
+}
+// Export as default for WorkerEntrypoint pattern
+export default TestService;
+// Export aliases
+export { TestService as TestWorker };