ai-tests 2.0.1

package/src/runner.ts

@@ -0,0 +1,238 @@
+/**
+ * Test runner - describe, it, test, hooks
+ *
+ * Provides vitest-compatible test runner API via RPC.
+ */
+
+import { RpcTarget } from 'cloudflare:workers'
+import type { TestResult, TestResults, TestFn, HookFn, RegisteredTest } from './types.js'
+
+/**
+ * Test runner that collects and runs tests
+ */
+export class TestRunner extends RpcTarget {
+  private tests: RegisteredTest[] = []
+  private currentSuite: string = ''
+  private beforeEachHooks: HookFn[] = []
+  private afterEachHooks: HookFn[] = []
+  private beforeAllHooks: HookFn[] = []
+  private afterAllHooks: HookFn[] = []
+
+  /**
+   * Define a test suite
+   */
+  describe(name: string, fn: () => void): void {
+    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: string, fn: TestFn): void {
+    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: string, fn: TestFn): void {
+    this.it(name, fn)
+  }
+
+  /**
+   * Skip a test
+   */
+  skip(name: string, _fn?: TestFn): void {
+    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: string, fn: TestFn): void {
+    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: HookFn): void {
+    this.beforeEachHooks.push(fn)
+  }
+
+  /**
+   * Register an afterEach hook
+   */
+  afterEach(fn: HookFn): void {
+    this.afterEachHooks.push(fn)
+  }
+
+  /**
+   * Register a beforeAll hook
+   */
+  beforeAll(fn: HookFn): void {
+    this.beforeAllHooks.push(fn)
+  }
+
+  /**
+   * Register an afterAll hook
+   */
+  afterAll(fn: HookFn): void {
+    this.afterAllHooks.push(fn)
+  }
+
+  /**
+   * Run all registered tests and return results
+   */
+  async run(): Promise<TestResults> {
+    const startTime = Date.now()
+    const results: TestResult[] = []
+
+    // 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(): void {
+    this.tests = []
+    this.currentSuite = ''
+    this.beforeEachHooks = []
+    this.afterEachHooks = []
+    this.beforeAllHooks = []
+    this.afterAllHooks = []
+  }
+
+  private buildResults(results: TestResult[], startTime: number): TestResults {
+    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(): TestRunner {
+  return new TestRunner()
+}

package/src/types.ts

@@ -0,0 +1,68 @@
+/**
+ * Types for ai-test
+ */
+
+/**
+ * Test result for a single test
+ */
+export interface TestResult {
+  name: string
+  passed: boolean
+  skipped?: boolean
+  error?: string
+  duration: number
+}
+
+/**
+ * Aggregated test results
+ */
+export interface TestResults {
+  total: number
+  passed: number
+  failed: number
+  skipped: number
+  tests: TestResult[]
+  duration: number
+}
+
+/**
+ * Test function
+ */
+export type TestFn = () => void | Promise<void>
+
+/**
+ * Hook function (beforeEach, afterEach, etc.)
+ */
+export type HookFn = () => void | Promise<void>
+
+/**
+ * Registered test
+ */
+export interface RegisteredTest {
+  name: string
+  fn: TestFn | null
+  hooks: {
+    before: HookFn[]
+    after: HookFn[]
+  }
+  skip?: boolean
+  only?: boolean
+}
+
+/**
+ * Test suite context
+ */
+export interface SuiteContext {
+  name: string
+  beforeEach: HookFn[]
+  afterEach: HookFn[]
+  beforeAll: HookFn[]
+  afterAll: HookFn[]
+}
+
+/**
+ * Environment with test worker binding
+ */
+export interface TestEnv {
+  TEST?: unknown
+}

package/src/worker.ts

@@ -0,0 +1,112 @@
+/**
+ * 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 { Assertion, expect, should, assert } from './assertions.js'
+import { TestRunner, 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 {
+  protected runner: TestRunner
+
+  constructor() {
+    super()
+    this.runner = createRunner()
+  }
+
+  expect(value: unknown, message?: string): Assertion {
+    return expect(value, message)
+  }
+
+  should(value: unknown): Assertion {
+    return should(value)
+  }
+
+  get assert() {
+    return assert
+  }
+
+  describe(name: string, fn: () => void): void {
+    this.runner.describe(name, fn)
+  }
+
+  it(name: string, fn: () => void | Promise<void>): void {
+    this.runner.it(name, fn)
+  }
+
+  test(name: string, fn: () => void | Promise<void>): void {
+    this.runner.test(name, fn)
+  }
+
+  skip(name: string, fn?: () => void | Promise<void>): void {
+    this.runner.skip(name, fn)
+  }
+
+  only(name: string, fn: () => void | Promise<void>): void {
+    this.runner.only(name, fn)
+  }
+
+  beforeEach(fn: () => void | Promise<void>): void {
+    this.runner.beforeEach(fn)
+  }
+
+  afterEach(fn: () => void | Promise<void>): void {
+    this.runner.afterEach(fn)
+  }
+
+  beforeAll(fn: () => void | Promise<void>): void {
+    this.runner.beforeAll(fn)
+  }
+
+  afterAll(fn: () => void | Promise<void>): void {
+    this.runner.afterAll(fn)
+  }
+
+  async run() {
+    return this.runner.run()
+  }
+
+  reset(): void {
+    this.runner.reset()
+  }
+
+  createRunner(): TestRunner {
+    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(): TestServiceCore {
+    return new TestServiceCore()
+  }
+}
+
+// Export as default for WorkerEntrypoint pattern
+export default TestService
+
+// Export aliases
+export { TestService as TestWorker }