ai-evaluate 0.1.0

package/test/evaluate-extended.test.ts

@@ -0,0 +1,469 @@
+import { describe, it, expect } from 'vitest'
+import { evaluate, createEvaluator } from '../src/index.js'
+
+describe('evaluate - extended tests', () => {
+  describe('edge cases', () => {
+    it('handles empty options', async () => {
+      const result = await evaluate({})
+      expect(result.success).toBe(true)
+      expect(result.logs).toEqual([])
+    })
+
+    it('handles undefined return', async () => {
+      const result = await evaluate({
+        script: 'const x = 1;'
+      })
+      expect(result.success).toBe(true)
+      expect(result.value).toBeUndefined()
+    })
+
+    it('handles null return', async () => {
+      const result = await evaluate({
+        script: 'return null;'
+      })
+      expect(result.success).toBe(true)
+      expect(result.value).toBeNull()
+    })
+
+    it('handles complex object return', async () => {
+      const result = await evaluate({
+        script: 'return { nested: { value: [1, 2, { a: 3 }] } };'
+      })
+      expect(result.success).toBe(true)
+      expect(result.value).toEqual({ nested: { value: [1, 2, { a: 3 }] } })
+    })
+
+    it('handles array return', async () => {
+      const result = await evaluate({
+        script: 'return [1, "two", true, null];'
+      })
+      expect(result.success).toBe(true)
+      expect(result.value).toEqual([1, 'two', true, null])
+    })
+  })
+
+  describe('module errors', () => {
+    it('fails on module syntax errors', async () => {
+      const result = await evaluate({
+        module: 'exports.foo = {;'
+      })
+      // Syntax errors cause the entire worker to fail to parse
+      expect(result.success).toBe(false)
+      expect(result.error).toBeDefined()
+    })
+
+    it('captures module runtime errors', async () => {
+      const result = await evaluate({
+        module: 'throw new Error("module error");'
+      })
+      expect(result.logs.some(l => l.message.includes('Module error'))).toBe(true)
+    })
+  })
+
+  describe('console methods', () => {
+    it('captures console.info', async () => {
+      const result = await evaluate({
+        script: 'console.info("info message"); return true;'
+      })
+      expect(result.logs).toContainEqual(expect.objectContaining({
+        level: 'info',
+        message: 'info message'
+      }))
+    })
+
+    it('captures console.debug', async () => {
+      const result = await evaluate({
+        script: 'console.debug("debug message"); return true;'
+      })
+      expect(result.logs).toContainEqual(expect.objectContaining({
+        level: 'debug',
+        message: 'debug message'
+      }))
+    })
+
+    it('stringifies objects in console output', async () => {
+      const result = await evaluate({
+        script: 'console.log({ a: 1 }); return true;'
+      })
+      expect(result.logs[0].message).toBe('{"a":1}')
+    })
+
+    it('joins multiple console arguments', async () => {
+      const result = await evaluate({
+        script: 'console.log("a", "b", "c"); return true;'
+      })
+      expect(result.logs[0].message).toBe('a b c')
+    })
+  })
+
+  describe('async scripts', () => {
+    it('handles Promise return values', async () => {
+      const result = await evaluate({
+        script: `
+          return Promise.resolve(42).then(v => v * 2);
+        `
+      })
+      expect(result.success).toBe(true)
+      expect(result.value).toBe(84)
+    })
+
+    it('handles Promise rejection in script', async () => {
+      const result = await evaluate({
+        script: 'return Promise.reject(new Error("async error"));'
+      })
+      expect(result.success).toBe(false)
+      expect(result.error).toContain('async error')
+    })
+
+    it('handles async IIFE', async () => {
+      const result = await evaluate({
+        script: `
+          return (async () => {
+            const value = await Promise.resolve(42);
+            return value * 2;
+          })();
+        `
+      })
+      expect(result.success).toBe(true)
+      expect(result.value).toBe(84)
+    })
+  })
+
+  describe('test framework - additional matchers', () => {
+    it('toBeTruthy', async () => {
+      const result = await evaluate({
+        tests: `
+          it('truthy values', () => {
+            expect(1).toBeTruthy();
+            expect("a").toBeTruthy();
+            expect({}).toBeTruthy();
+            expect([]).toBeTruthy();
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('toBeFalsy', async () => {
+      const result = await evaluate({
+        tests: `
+          it('falsy values', () => {
+            expect(0).toBeFalsy();
+            expect("").toBeFalsy();
+            expect(null).toBeFalsy();
+            expect(undefined).toBeFalsy();
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('toBeNull', async () => {
+      const result = await evaluate({
+        tests: `
+          it('null check', () => {
+            expect(null).toBeNull();
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('toBeUndefined', async () => {
+      const result = await evaluate({
+        tests: `
+          it('undefined check', () => {
+            expect(undefined).toBeUndefined();
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('toBeDefined', async () => {
+      const result = await evaluate({
+        tests: `
+          it('defined check', () => {
+            expect(0).toBeDefined();
+            expect("").toBeDefined();
+            expect(null).toBeDefined();
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('toBeNaN', async () => {
+      const result = await evaluate({
+        tests: `
+          it('NaN check', () => {
+            expect(NaN).toBeNaN();
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('toContainEqual', async () => {
+      const result = await evaluate({
+        tests: `
+          it('containEqual check', () => {
+            expect([{ a: 1 }, { b: 2 }]).toContainEqual({ a: 1 });
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('toStrictEqual', async () => {
+      const result = await evaluate({
+        tests: `
+          it('strict equal check', () => {
+            expect({ a: 1, b: 2 }).toStrictEqual({ a: 1, b: 2 });
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('toBeGreaterThan', async () => {
+      const result = await evaluate({
+        tests: `
+          it('greater than check', () => {
+            expect(10).toBeGreaterThan(5);
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('toBeLessThan', async () => {
+      const result = await evaluate({
+        tests: `
+          it('less than check', () => {
+            expect(5).toBeLessThan(10);
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('toBeGreaterThanOrEqual', async () => {
+      const result = await evaluate({
+        tests: `
+          it('greater or equal check', () => {
+            expect(10).toBeGreaterThanOrEqual(10);
+            expect(10).toBeGreaterThanOrEqual(5);
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('toBeLessThanOrEqual', async () => {
+      const result = await evaluate({
+        tests: `
+          it('less or equal check', () => {
+            expect(10).toBeLessThanOrEqual(10);
+            expect(5).toBeLessThanOrEqual(10);
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('toMatch with string', async () => {
+      const result = await evaluate({
+        tests: `
+          it('match check', () => {
+            expect("hello world").toMatch("world");
+            expect("hello world").toMatch(/world/);
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('toBeInstanceOf', async () => {
+      const result = await evaluate({
+        tests: `
+          it('instanceof check', () => {
+            expect(new Error()).toBeInstanceOf(Error);
+            expect([]).toBeInstanceOf(Array);
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('toBeTypeOf', async () => {
+      const result = await evaluate({
+        tests: `
+          it('typeof check', () => {
+            expect("hello").toBeTypeOf("string");
+            expect(42).toBeTypeOf("number");
+            expect(true).toBeTypeOf("boolean");
+            expect({}).toBeTypeOf("object");
+            expect(() => {}).toBeTypeOf("function");
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+    })
+  })
+
+  describe('test framework - hooks', () => {
+    it('afterEach', async () => {
+      const result = await evaluate({
+        tests: `
+          let cleanupCount = 0;
+          afterEach(() => {
+            cleanupCount++;
+          });
+          it('first', () => {
+            expect(cleanupCount).toBe(0);
+          });
+          it('second', () => {
+            expect(cleanupCount).toBe(1);
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+      expect(result.testResults?.passed).toBe(2)
+    })
+
+    it('nested describes with hooks', async () => {
+      const result = await evaluate({
+        tests: `
+          let outer = 0;
+          let inner = 0;
+          describe('outer', () => {
+            beforeEach(() => { outer++; });
+            it('outer test', () => {
+              expect(outer).toBe(1);
+              expect(inner).toBe(0);
+            });
+            describe('inner', () => {
+              beforeEach(() => { inner++; });
+              it('inner test', () => {
+                expect(outer).toBe(2);
+                expect(inner).toBe(1);
+              });
+            });
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+      expect(result.testResults?.passed).toBe(2)
+    })
+  })
+
+  describe('test framework - only', () => {
+    it('runs only marked tests', async () => {
+      const result = await evaluate({
+        tests: `
+          it('should not run', () => {
+            expect(1).toBe(2); // would fail
+          });
+          it.only('should run', () => {
+            expect(1).toBe(1);
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+      expect(result.testResults?.total).toBe(1)
+    })
+
+    it('test.only works', async () => {
+      const result = await evaluate({
+        tests: `
+          test('should not run', () => {
+            expect(1).toBe(2);
+          });
+          test.only('should run', () => {
+            expect(1).toBe(1);
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+      expect(result.testResults?.total).toBe(1)
+    })
+  })
+
+  describe('test framework - resolves/rejects', () => {
+    it('resolves matcher', async () => {
+      const result = await evaluate({
+        tests: `
+          it('resolves', async () => {
+            await expect(Promise.resolve(42)).resolves.toBe(42);
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('rejects matcher', async () => {
+      const result = await evaluate({
+        tests: `
+          it('rejects', async () => {
+            await expect(Promise.reject(new Error('fail'))).rejects.toBeInstanceOf(Error);
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+    })
+  })
+
+  describe('test framework - error messages', () => {
+    it('provides descriptive error for toBe failure', async () => {
+      const result = await evaluate({
+        tests: `
+          it('fails', () => {
+            expect(1).toBe(2);
+          });
+        `
+      })
+      expect(result.success).toBe(false)
+      expect(result.testResults?.tests[0].error).toContain('Expected')
+      expect(result.testResults?.tests[0].error).toContain('2')
+    })
+
+    it('provides descriptive error for toEqual failure', async () => {
+      const result = await evaluate({
+        tests: `
+          it('fails', () => {
+            expect({ a: 1 }).toEqual({ a: 2 });
+          });
+        `
+      })
+      expect(result.success).toBe(false)
+      expect(result.testResults?.tests[0].error).toBeDefined()
+    })
+
+    it('provides descriptive error for toContain failure', async () => {
+      const result = await evaluate({
+        tests: `
+          it('fails', () => {
+            expect([1, 2, 3]).toContain(4);
+          });
+        `
+      })
+      expect(result.success).toBe(false)
+      expect(result.testResults?.tests[0].error).toContain('contain')
+    })
+  })
+})
+
+describe('createEvaluator', () => {
+  it('returns a function', () => {
+    const evaluator = createEvaluator({})
+    expect(typeof evaluator).toBe('function')
+  })
+
+  it('returned function works like evaluate', async () => {
+    const evaluator = createEvaluator({})
+    const result = await evaluator({ script: 'return 42;' })
+    expect(result.success).toBe(true)
+    expect(result.value).toBe(42)
+  })
+})

package/test/evaluate.test.ts

@@ -0,0 +1,253 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest'
+import { evaluate } from '../src/index.js'
+
+describe('evaluate', () => {
+  describe('script execution', () => {
+    it('executes simple expressions', async () => {
+      const result = await evaluate({
+        script: 'return 1 + 1'
+      })
+      expect(result.success).toBe(true)
+      expect(result.value).toBe(2)
+    })
+
+    it('captures console output', async () => {
+      const result = await evaluate({
+        script: `
+          console.log('hello');
+          console.warn('warning');
+          console.error('error');
+          return 'done';
+        `
+      })
+      expect(result.success).toBe(true)
+      expect(result.value).toBe('done')
+      expect(result.logs).toHaveLength(3)
+      expect(result.logs[0].level).toBe('log')
+      expect(result.logs[0].message).toBe('hello')
+      expect(result.logs[1].level).toBe('warn')
+      expect(result.logs[2].level).toBe('error')
+    })
+
+    it('handles script errors', async () => {
+      const result = await evaluate({
+        script: 'throw new Error("test error")'
+      })
+      expect(result.success).toBe(false)
+      expect(result.error).toContain('test error')
+    })
+  })
+
+  describe('module exports', () => {
+    it('exposes exports to script', async () => {
+      const result = await evaluate({
+        module: `
+          exports.add = (a, b) => a + b;
+          exports.multiply = (a, b) => a * b;
+        `,
+        script: 'return add(2, 3) + multiply(4, 5)'
+      })
+      expect(result.success).toBe(true)
+      expect(result.value).toBe(25) // 5 + 20
+    })
+
+    it('exposes exports to tests', async () => {
+      const result = await evaluate({
+        module: `
+          exports.double = (n) => n * 2;
+        `,
+        tests: `
+          describe('double', () => {
+            it('doubles a number', () => {
+              expect(double(5)).toBe(10);
+            });
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+      expect(result.testResults?.total).toBe(1)
+      expect(result.testResults?.passed).toBe(1)
+    })
+  })
+
+  describe('test framework', () => {
+    it('runs passing tests', async () => {
+      const result = await evaluate({
+        tests: `
+          describe('math', () => {
+            it('adds', () => {
+              expect(1 + 1).toBe(2);
+            });
+            it('subtracts', () => {
+              expect(5 - 3).toBe(2);
+            });
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+      expect(result.testResults?.total).toBe(2)
+      expect(result.testResults?.passed).toBe(2)
+      expect(result.testResults?.failed).toBe(0)
+    })
+
+    it('reports failing tests', async () => {
+      const result = await evaluate({
+        tests: `
+          it('fails', () => {
+            expect(1).toBe(2);
+          });
+        `
+      })
+      expect(result.success).toBe(false)
+      expect(result.testResults?.total).toBe(1)
+      expect(result.testResults?.failed).toBe(1)
+      expect(result.testResults?.tests[0].error).toContain('Expected 2')
+    })
+
+    it('supports skipped tests', async () => {
+      const result = await evaluate({
+        tests: `
+          it.skip('skipped', () => {
+            expect(1).toBe(2);
+          });
+          it('runs', () => {
+            expect(1).toBe(1);
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+      expect(result.testResults?.total).toBe(2)
+      expect(result.testResults?.passed).toBe(1)
+      expect(result.testResults?.skipped).toBe(1)
+    })
+
+    it('supports beforeEach hooks', async () => {
+      const result = await evaluate({
+        tests: `
+          let count = 0;
+          beforeEach(() => {
+            count++;
+          });
+          it('first', () => {
+            expect(count).toBe(1);
+          });
+          it('second', () => {
+            expect(count).toBe(2);
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+      expect(result.testResults?.passed).toBe(2)
+    })
+
+    it('supports async tests', async () => {
+      const result = await evaluate({
+        tests: `
+          it('async test', async () => {
+            const value = await Promise.resolve(42);
+            expect(value).toBe(42);
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+      expect(result.testResults?.passed).toBe(1)
+    })
+  })
+
+  describe('expect matchers', () => {
+    it('toBe', async () => {
+      const result = await evaluate({
+        tests: `
+          it('works', () => {
+            expect(1).toBe(1);
+            expect('a').toBe('a');
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('toEqual', async () => {
+      const result = await evaluate({
+        tests: `
+          it('works', () => {
+            expect({ a: 1 }).toEqual({ a: 1 });
+            expect([1, 2]).toEqual([1, 2]);
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('toContain', async () => {
+      const result = await evaluate({
+        tests: `
+          it('works', () => {
+            expect([1, 2, 3]).toContain(2);
+            expect('hello').toContain('ell');
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('toThrow', async () => {
+      const result = await evaluate({
+        tests: `
+          it('works', () => {
+            expect(() => { throw new Error('boom'); }).toThrow('boom');
+            expect(() => { throw new Error('boom'); }).toThrow(/boom/);
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('toHaveProperty', async () => {
+      const result = await evaluate({
+        tests: `
+          it('works', () => {
+            expect({ a: { b: 1 } }).toHaveProperty('a.b');
+            expect({ a: { b: 1 } }).toHaveProperty('a.b', 1);
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('toMatchObject', async () => {
+      const result = await evaluate({
+        tests: `
+          it('works', () => {
+            expect({ a: 1, b: 2 }).toMatchObject({ a: 1 });
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('not matchers', async () => {
+      const result = await evaluate({
+        tests: `
+          it('works', () => {
+            expect(1).not.toBe(2);
+            expect({ a: 1 }).not.toEqual({ a: 2 });
+            expect([1, 2]).not.toContain(3);
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+    })
+
+    it('toBeCloseTo', async () => {
+      const result = await evaluate({
+        tests: `
+          it('works', () => {
+            expect(0.1 + 0.2).toBeCloseTo(0.3);
+          });
+        `
+      })
+      expect(result.success).toBe(true)
+    })
+  })
+})