ai-tests 2.0.2 → 2.1.1

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/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' }
+            }
+        }
+    }
+});