ai-tests 2.0.2 → 2.1.3

package/test/runner.test.js

@@ -0,0 +1,315 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { TestRunner, createRunner } from '../src/runner.js';
+describe('TestRunner', () => {
+    let runner;
+    beforeEach(() => {
+        runner = createRunner();
+    });
+    describe('createRunner()', () => {
+        it('creates a new TestRunner instance', () => {
+            expect(runner).toBeInstanceOf(TestRunner);
+        });
+    });
+    describe('describe()', () => {
+        it('groups tests with a suite name', async () => {
+            runner.describe('math', () => {
+                runner.it('adds', () => { });
+            });
+            const results = await runner.run();
+            expect(results.tests[0].name).toBe('math > adds');
+        });
+        it('supports nested describes', async () => {
+            runner.describe('outer', () => {
+                runner.describe('inner', () => {
+                    runner.it('test', () => { });
+                });
+            });
+            const results = await runner.run();
+            expect(results.tests[0].name).toBe('outer > inner > test');
+        });
+        it('restores previous suite after describe', async () => {
+            runner.describe('first', () => {
+                runner.it('test1', () => { });
+            });
+            runner.it('standalone', () => { });
+            const results = await runner.run();
+            expect(results.tests[0].name).toBe('first > test1');
+            expect(results.tests[1].name).toBe('standalone');
+        });
+    });
+    describe('it()', () => {
+        it('registers a test', async () => {
+            runner.it('my test', () => { });
+            const results = await runner.run();
+            expect(results.total).toBe(1);
+            expect(results.tests[0].name).toBe('my test');
+        });
+        it('test() is alias for it()', async () => {
+            runner.test('my test', () => { });
+            const results = await runner.run();
+            expect(results.total).toBe(1);
+        });
+        it('passes for successful tests', async () => {
+            runner.it('passes', () => {
+                // No error
+            });
+            const results = await runner.run();
+            expect(results.passed).toBe(1);
+            expect(results.failed).toBe(0);
+        });
+        it('fails for throwing tests', async () => {
+            runner.it('fails', () => {
+                throw new Error('test error');
+            });
+            const results = await runner.run();
+            expect(results.passed).toBe(0);
+            expect(results.failed).toBe(1);
+            expect(results.tests[0].error).toContain('test error');
+        });
+        it('supports async tests', async () => {
+            runner.it('async', async () => {
+                await new Promise(resolve => setTimeout(resolve, 10));
+            });
+            const results = await runner.run();
+            expect(results.passed).toBe(1);
+        });
+        it('catches async errors', async () => {
+            runner.it('async fail', async () => {
+                await Promise.reject(new Error('async error'));
+            });
+            const results = await runner.run();
+            expect(results.failed).toBe(1);
+            expect(results.tests[0].error).toContain('async error');
+        });
+    });
+    describe('skip()', () => {
+        it('marks test as skipped', async () => {
+            runner.skip('skipped test', () => {
+                throw new Error('should not run');
+            });
+            const results = await runner.run();
+            expect(results.total).toBe(1);
+            expect(results.skipped).toBe(1);
+            expect(results.passed).toBe(0);
+            expect(results.failed).toBe(0);
+            expect(results.tests[0].skipped).toBe(true);
+        });
+        it('works without fn argument', async () => {
+            runner.skip('skipped');
+            const results = await runner.run();
+            expect(results.skipped).toBe(1);
+        });
+    });
+    describe('only()', () => {
+        it('runs only marked tests', async () => {
+            runner.it('normal', () => { });
+            runner.only('only', () => { });
+            const results = await runner.run();
+            expect(results.total).toBe(1);
+            expect(results.tests[0].name).toBe('only');
+        });
+        it('still includes skipped tests when only is used', async () => {
+            runner.it('normal', () => { });
+            runner.only('only', () => { });
+            runner.skip('skipped', () => { });
+            const results = await runner.run();
+            expect(results.total).toBe(2);
+            expect(results.tests.find(t => t.name === 'only')).toBeDefined();
+            expect(results.tests.find(t => t.name === 'skipped')).toBeDefined();
+        });
+    });
+    describe('beforeEach()', () => {
+        it('runs before each test', async () => {
+            let count = 0;
+            runner.beforeEach(() => {
+                count++;
+            });
+            runner.it('test1', () => { });
+            runner.it('test2', () => { });
+            await runner.run();
+            expect(count).toBe(2);
+        });
+        it('hooks are scoped to describe blocks', async () => {
+            let count = 0;
+            runner.describe('suite', () => {
+                runner.beforeEach(() => {
+                    count++;
+                });
+                runner.it('inside', () => { });
+            });
+            runner.it('outside', () => { });
+            await runner.run();
+            expect(count).toBe(1);
+        });
+        it('supports async hooks', async () => {
+            let value = 0;
+            runner.beforeEach(async () => {
+                await new Promise(resolve => setTimeout(resolve, 1));
+                value = 42;
+            });
+            runner.it('test', () => {
+                if (value !== 42)
+                    throw new Error('hook did not run');
+            });
+            const results = await runner.run();
+            expect(results.passed).toBe(1);
+        });
+    });
+    describe('afterEach()', () => {
+        it('runs after each test', async () => {
+            let count = 0;
+            runner.afterEach(() => {
+                count++;
+            });
+            runner.it('test1', () => { });
+            runner.it('test2', () => { });
+            await runner.run();
+            expect(count).toBe(2);
+        });
+        it('runs only for passing tests (current behavior)', async () => {
+            let count = 0;
+            runner.afterEach(() => {
+                count++;
+            });
+            runner.it('passing', () => { });
+            runner.it('failing', () => {
+                throw new Error('fail');
+            });
+            await runner.run();
+            // Currently afterEach only runs for passing tests
+            expect(count).toBe(1);
+        });
+    });
+    describe('beforeAll()', () => {
+        it('runs once before all tests', async () => {
+            let count = 0;
+            runner.beforeAll(() => {
+                count++;
+            });
+            runner.it('test1', () => { });
+            runner.it('test2', () => { });
+            await runner.run();
+            expect(count).toBe(1);
+        });
+        it('fails all tests if beforeAll throws', async () => {
+            runner.beforeAll(() => {
+                throw new Error('setup failed');
+            });
+            runner.it('test1', () => { });
+            runner.it('test2', () => { });
+            const results = await runner.run();
+            expect(results.failed).toBe(2);
+            expect(results.tests[0].error).toContain('beforeAll hook failed');
+            expect(results.tests[1].error).toContain('beforeAll hook failed');
+        });
+        it('supports async hooks', async () => {
+            let value = 0;
+            runner.beforeAll(async () => {
+                await new Promise(resolve => setTimeout(resolve, 1));
+                value = 42;
+            });
+            runner.it('test', () => {
+                if (value !== 42)
+                    throw new Error('hook did not run');
+            });
+            const results = await runner.run();
+            expect(results.passed).toBe(1);
+        });
+    });
+    describe('afterAll()', () => {
+        it('runs once after all tests', async () => {
+            let count = 0;
+            runner.afterAll(() => {
+                count++;
+            });
+            runner.it('test1', () => { });
+            runner.it('test2', () => { });
+            await runner.run();
+            expect(count).toBe(1);
+        });
+        it('runs even if tests fail', async () => {
+            let ran = false;
+            runner.afterAll(() => {
+                ran = true;
+            });
+            runner.it('failing', () => {
+                throw new Error('fail');
+            });
+            await runner.run();
+            expect(ran).toBe(true);
+        });
+        it('does not fail tests if afterAll throws', async () => {
+            const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => { });
+            runner.it('test', () => { });
+            runner.afterAll(() => {
+                throw new Error('cleanup failed');
+            });
+            const results = await runner.run();
+            expect(results.passed).toBe(1);
+            expect(results.failed).toBe(0);
+            consoleSpy.mockRestore();
+        });
+    });
+    describe('reset()', () => {
+        it('clears all tests', async () => {
+            runner.it('test', () => { });
+            runner.reset();
+            const results = await runner.run();
+            expect(results.total).toBe(0);
+        });
+        it('clears all hooks', async () => {
+            let count = 0;
+            runner.beforeEach(() => { count++; });
+            runner.afterEach(() => { count++; });
+            runner.beforeAll(() => { count++; });
+            runner.afterAll(() => { count++; });
+            runner.reset();
+            runner.it('test', () => { });
+            await runner.run();
+            expect(count).toBe(0);
+        });
+        it('clears current suite', async () => {
+            runner.describe('suite', () => {
+                runner.reset();
+                runner.it('test', () => { });
+            });
+            const results = await runner.run();
+            expect(results.tests[0].name).toBe('test');
+        });
+    });
+    describe('run()', () => {
+        it('returns correct totals', async () => {
+            runner.it('pass1', () => { });
+            runner.it('pass2', () => { });
+            runner.it('fail', () => { throw new Error(); });
+            runner.skip('skip', () => { });
+            const results = await runner.run();
+            expect(results.total).toBe(4);
+            expect(results.passed).toBe(2);
+            expect(results.failed).toBe(1);
+            expect(results.skipped).toBe(1);
+        });
+        it('tracks test durations', async () => {
+            runner.it('test', async () => {
+                await new Promise(resolve => setTimeout(resolve, 10));
+            });
+            const results = await runner.run();
+            expect(results.tests[0].duration).toBeGreaterThanOrEqual(10);
+        });
+        it('tracks total duration', async () => {
+            runner.it('test', async () => {
+                await new Promise(resolve => setTimeout(resolve, 10));
+            });
+            const results = await runner.run();
+            expect(results.duration).toBeGreaterThanOrEqual(10);
+        });
+        it('returns empty results for no tests', async () => {
+            const results = await runner.run();
+            expect(results.total).toBe(0);
+            expect(results.passed).toBe(0);
+            expect(results.failed).toBe(0);
+            expect(results.skipped).toBe(0);
+            expect(results.tests).toEqual([]);
+        });
+    });
+});

package/test/type-safety-assertions.test.ts

@@ -0,0 +1,201 @@
+/**
+ * Type safety tests for assertions.ts
+ *
+ * These tests verify proper TypeScript type inference and type safety
+ * for the assertion functions, particularly around the areas that
+ * previously used `as any` casts.
+ */
+import { describe, it, expectTypeOf, expect as vitestExpect } from 'vitest'
+import { expect, Assertion } from '../src/assertions.js'
+
+describe('Type Safety: Assertion', () => {
+  describe('instanceof type handling', () => {
+    it('accepts constructor functions', () => {
+      // Should accept class constructors
+      class MyClass {}
+      const assertion = expect(new MyClass()).instanceof(MyClass)
+      expectTypeOf(assertion).toEqualTypeOf<Assertion>()
+    })
+
+    it('accepts built-in constructors', () => {
+      // Should accept Error constructor
+      const assertion = expect(new Error()).instanceof(Error)
+      expectTypeOf(assertion).toEqualTypeOf<Assertion>()
+    })
+
+    it('accepts ErrorConstructor types', () => {
+      // Should work with various error types
+      const assertion1 = expect(new TypeError()).instanceof(TypeError)
+      const assertion2 = expect(new RangeError()).instanceof(RangeError)
+      expectTypeOf(assertion1).toEqualTypeOf<Assertion>()
+      expectTypeOf(assertion2).toEqualTypeOf<Assertion>()
+    })
+  })
+
+  describe('instanceOf type handling (alias)', () => {
+    it('accepts constructor functions', () => {
+      class MyClass {}
+      const assertion = expect(new MyClass()).instanceOf(MyClass)
+      expectTypeOf(assertion).toEqualTypeOf<Assertion>()
+    })
+  })
+
+  describe('toBeInstanceOf type handling', () => {
+    it('accepts constructor functions', () => {
+      class MyClass {}
+      const assertion = expect(new MyClass()).toBeInstanceOf(MyClass)
+      expectTypeOf(assertion).toEqualTypeOf<Assertion>()
+    })
+
+    it('accepts built-in constructors', () => {
+      const assertion = expect(new Error()).toBeInstanceOf(Error)
+      expectTypeOf(assertion).toEqualTypeOf<Assertion>()
+    })
+  })
+
+  describe('throw type handling', () => {
+    it('accepts no arguments', () => {
+      const assertion = expect(() => { throw new Error() }).throw()
+      expectTypeOf(assertion).toEqualTypeOf<Assertion>()
+    })
+
+    it('accepts string error message', () => {
+      const assertion = expect(() => { throw new Error('test') }).throw('test')
+      expectTypeOf(assertion).toEqualTypeOf<Assertion>()
+    })
+
+    it('accepts RegExp pattern', () => {
+      const assertion = expect(() => { throw new Error('test') }).throw(/test/)
+      expectTypeOf(assertion).toEqualTypeOf<Assertion>()
+    })
+
+    it('accepts Error instance', () => {
+      const err = new Error('test')
+      const assertion = expect(() => { throw err }).throw(err)
+      expectTypeOf(assertion).toEqualTypeOf<Assertion>()
+    })
+
+    it('accepts Error constructor', () => {
+      const assertion = expect(() => { throw new TypeError() }).throw(TypeError)
+      expectTypeOf(assertion).toEqualTypeOf<Assertion>()
+    })
+
+    it('accepts Error constructor with message pattern', () => {
+      const assertion = expect(() => { throw new Error('test') }).throw(Error, /test/)
+      expectTypeOf(assertion).toEqualTypeOf<Assertion>()
+    })
+  })
+
+  describe('throws type handling (alias)', () => {
+    it('accepts Error constructor', () => {
+      const assertion = expect(() => { throw new TypeError() }).throws(TypeError)
+      expectTypeOf(assertion).toEqualTypeOf<Assertion>()
+    })
+  })
+
+  describe('Throw type handling (alias)', () => {
+    it('accepts Error constructor', () => {
+      const assertion = expect(() => { throw new TypeError() }).Throw(TypeError)
+      expectTypeOf(assertion).toEqualTypeOf<Assertion>()
+    })
+  })
+
+  describe('toThrow type handling', () => {
+    it('accepts no arguments', () => {
+      const assertion = expect(() => { throw new Error() }).toThrow()
+      expectTypeOf(assertion).toEqualTypeOf<Assertion>()
+    })
+
+    it('accepts string error message', () => {
+      const assertion = expect(() => { throw new Error('test') }).toThrow('test')
+      expectTypeOf(assertion).toEqualTypeOf<Assertion>()
+    })
+
+    it('accepts RegExp pattern', () => {
+      const assertion = expect(() => { throw new Error('test') }).toThrow(/test/)
+      expectTypeOf(assertion).toEqualTypeOf<Assertion>()
+    })
+
+    it('accepts Error instance', () => {
+      const err = new Error('test')
+      const assertion = expect(() => { throw err }).toThrow(err)
+      expectTypeOf(assertion).toEqualTypeOf<Assertion>()
+    })
+  })
+
+  describe('Assertion class internal type safety', () => {
+    it('returns correct Assertion type from expect', () => {
+      const assertion = expect(42)
+      expectTypeOf(assertion).toEqualTypeOf<Assertion>()
+    })
+
+    it('chains return Assertion type', () => {
+      const assertion = expect(42).to.be.a('number')
+      expectTypeOf(assertion).toEqualTypeOf<Assertion>()
+    })
+
+    it('negation returns Assertion type', () => {
+      const assertion = expect(42).not
+      expectTypeOf(assertion).toEqualTypeOf<Assertion>()
+    })
+
+    it('deep flag returns Assertion type', () => {
+      const assertion = expect({ a: 1 }).deep
+      expectTypeOf(assertion).toEqualTypeOf<Assertion>()
+    })
+  })
+})
+
+describe('Runtime Type Safety', () => {
+  describe('instanceof runtime behavior', () => {
+    it('works with custom classes at runtime', () => {
+      class CustomError extends Error {
+        constructor(message: string) {
+          super(message)
+          this.name = 'CustomError'
+        }
+      }
+      vitestExpect(() => expect(new CustomError('test')).instanceof(CustomError)).not.toThrow()
+    })
+
+    it('works with inheritance chains', () => {
+      vitestExpect(() => expect(new TypeError()).instanceof(Error)).not.toThrow()
+    })
+  })
+
+  describe('throw runtime behavior with typed constructors', () => {
+    it('works with Error constructor', () => {
+      vitestExpect(() =>
+        expect(() => { throw new Error('test') }).throw(Error)
+      ).not.toThrow()
+    })
+
+    it('works with specific error types', () => {
+      vitestExpect(() =>
+        expect(() => { throw new TypeError('test') }).throw(TypeError)
+      ).not.toThrow()
+    })
+
+    it('works with Error constructor and message', () => {
+      vitestExpect(() =>
+        expect(() => { throw new Error('test message') }).throw(Error, /test/)
+      ).not.toThrow()
+    })
+  })
+
+  describe('toBeInstanceOf runtime behavior', () => {
+    it('works with built-in types', () => {
+      vitestExpect(() => expect([]).toBeInstanceOf(Array)).not.toThrow()
+      vitestExpect(() => expect(new Map()).toBeInstanceOf(Map)).not.toThrow()
+      vitestExpect(() => expect(new Set()).toBeInstanceOf(Set)).not.toThrow()
+    })
+  })
+
+  describe('toThrow runtime behavior', () => {
+    it('works with Error type', () => {
+      vitestExpect(() =>
+        expect(() => { throw new Error('test') }).toThrow(Error)
+      ).not.toThrow()
+    })
+  })
+})

package/test/worker.test.js

@@ -0,0 +1,162 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { TestServiceCore, TestService } from '../src/worker.js';
+import { Assertion } from '../src/assertions.js';
+import { TestRunner } from '../src/runner.js';
+describe('TestServiceCore', () => {
+    let service;
+    beforeEach(() => {
+        service = new TestServiceCore();
+    });
+    describe('constructor', () => {
+        it('creates a new TestServiceCore instance', () => {
+            expect(service).toBeInstanceOf(TestServiceCore);
+        });
+    });
+    describe('expect()', () => {
+        it('returns an Assertion', () => {
+            const assertion = service.expect(42);
+            expect(assertion).toBeInstanceOf(Assertion);
+        });
+        it('accepts optional message', () => {
+            const assertion = service.expect(42, 'custom message');
+            expect(assertion).toBeInstanceOf(Assertion);
+        });
+    });
+    describe('should()', () => {
+        it('returns an Assertion', () => {
+            const assertion = service.should(42);
+            expect(assertion).toBeInstanceOf(Assertion);
+        });
+    });
+    describe('assert', () => {
+        it('returns chai assert object', () => {
+            expect(service.assert).toBeDefined();
+            expect(typeof service.assert.equal).toBe('function');
+        });
+    });
+    describe('describe()', () => {
+        it('delegates to runner', async () => {
+            service.describe('suite', () => {
+                service.it('test', () => { });
+            });
+            const results = await service.run();
+            expect(results.tests[0].name).toBe('suite > test');
+        });
+    });
+    describe('it()', () => {
+        it('delegates to runner', async () => {
+            service.it('test', () => { });
+            const results = await service.run();
+            expect(results.total).toBe(1);
+        });
+    });
+    describe('test()', () => {
+        it('is alias for it', async () => {
+            service.test('test', () => { });
+            const results = await service.run();
+            expect(results.total).toBe(1);
+        });
+    });
+    describe('skip()', () => {
+        it('delegates to runner', async () => {
+            service.skip('skipped', () => { });
+            const results = await service.run();
+            expect(results.skipped).toBe(1);
+        });
+    });
+    describe('only()', () => {
+        it('delegates to runner', async () => {
+            service.it('normal', () => { });
+            service.only('only', () => { });
+            const results = await service.run();
+            expect(results.total).toBe(1);
+            expect(results.tests[0].name).toBe('only');
+        });
+    });
+    describe('beforeEach()', () => {
+        it('delegates to runner', async () => {
+            let count = 0;
+            service.beforeEach(() => { count++; });
+            service.it('test1', () => { });
+            service.it('test2', () => { });
+            await service.run();
+            expect(count).toBe(2);
+        });
+    });
+    describe('afterEach()', () => {
+        it('delegates to runner', async () => {
+            let count = 0;
+            service.afterEach(() => { count++; });
+            service.it('test1', () => { });
+            service.it('test2', () => { });
+            await service.run();
+            expect(count).toBe(2);
+        });
+    });
+    describe('beforeAll()', () => {
+        it('delegates to runner', async () => {
+            let count = 0;
+            service.beforeAll(() => { count++; });
+            service.it('test1', () => { });
+            service.it('test2', () => { });
+            await service.run();
+            expect(count).toBe(1);
+        });
+    });
+    describe('afterAll()', () => {
+        it('delegates to runner', async () => {
+            let count = 0;
+            service.afterAll(() => { count++; });
+            service.it('test1', () => { });
+            service.it('test2', () => { });
+            await service.run();
+            expect(count).toBe(1);
+        });
+    });
+    describe('run()', () => {
+        it('returns test results', async () => {
+            service.it('pass', () => { });
+            service.it('fail', () => { throw new Error('fail'); });
+            const results = await service.run();
+            expect(results.total).toBe(2);
+            expect(results.passed).toBe(1);
+            expect(results.failed).toBe(1);
+        });
+    });
+    describe('reset()', () => {
+        it('clears all tests and hooks', async () => {
+            service.it('test', () => { });
+            service.beforeEach(() => { });
+            service.reset();
+            const results = await service.run();
+            expect(results.total).toBe(0);
+        });
+    });
+    describe('createRunner()', () => {
+        it('returns a new TestRunner', () => {
+            const runner = service.createRunner();
+            expect(runner).toBeInstanceOf(TestRunner);
+        });
+        it('returns independent runner', async () => {
+            service.it('service test', () => { });
+            const runner = service.createRunner();
+            runner.it('runner test', () => { });
+            const serviceResults = await service.run();
+            const runnerResults = await runner.run();
+            expect(serviceResults.total).toBe(1);
+            expect(runnerResults.total).toBe(1);
+            expect(serviceResults.tests[0].name).toBe('service test');
+            expect(runnerResults.tests[0].name).toBe('runner test');
+        });
+    });
+});
+describe('TestService (WorkerEntrypoint)', () => {
+    it('exports TestService class', async () => {
+        const { default: TestServiceClass } = await import('../src/worker.js');
+        expect(TestServiceClass).toBeDefined();
+        expect(typeof TestServiceClass).toBe('function');
+    });
+    it('TestService has connect method in prototype', () => {
+        expect(typeof TestService.prototype.connect).toBe('function');
+    });
+});

package/vitest.config.js

@@ -0,0 +1,10 @@
+import { defineWorkersConfig } from '@cloudflare/vitest-pool-workers/config';
+export default defineWorkersConfig({
+    test: {
+        poolOptions: {
+            workers: {
+                wrangler: { configPath: './wrangler.toml' }
+            }
+        }
+    }
+});