ai-evaluate 2.1.8 → 2.2.0

package/test/evaluate.test.ts

@@ -1,253 +0,0 @@
-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)
-    })
-  })
-})

package/test/index.test.js

@@ -1,77 +0,0 @@
-import { describe, it, expect } from 'vitest';
-describe('index exports', () => {
-    it('exports evaluate function', async () => {
-        const { evaluate } = await import('../src/index.js');
-        expect(typeof evaluate).toBe('function');
-    });
-    it('exports createEvaluator function', async () => {
-        const { createEvaluator } = await import('../src/index.js');
-        expect(typeof createEvaluator).toBe('function');
-    });
-    it('exports types', async () => {
-        // Types are compile-time only, so we just check the module loads
-        await import('../src/index.js');
-    });
-});
-describe('types', () => {
-    it('EvaluateOptions interface is usable', async () => {
-        const { evaluate } = await import('../src/index.js');
-        // Test that options conform to EvaluateOptions
-        const options = {
-            module: 'exports.x = 1;',
-            tests: 'it("test", () => {});',
-            script: 'return 1;',
-            timeout: 5000,
-            env: { FOO: 'bar' },
-            fetch: null
-        };
-        const result = await evaluate(options);
-        expect(result).toHaveProperty('success');
-    });
-    it('EvaluateResult has correct shape', async () => {
-        const { evaluate } = await import('../src/index.js');
-        const result = await evaluate({ script: 'return 42;' });
-        expect(result).toHaveProperty('success');
-        expect(result).toHaveProperty('logs');
-        expect(result).toHaveProperty('duration');
-        expect(typeof result.success).toBe('boolean');
-        expect(Array.isArray(result.logs)).toBe(true);
-        expect(typeof result.duration).toBe('number');
-    });
-    it('LogEntry has correct shape', async () => {
-        const { evaluate } = await import('../src/index.js');
-        const result = await evaluate({
-            script: 'console.log("test"); return true;'
-        });
-        const log = result.logs[0];
-        expect(log).toHaveProperty('level');
-        expect(log).toHaveProperty('message');
-        expect(log).toHaveProperty('timestamp');
-        expect(['log', 'warn', 'error', 'info', 'debug']).toContain(log.level);
-    });
-    it('TestResults has correct shape when tests provided', async () => {
-        const { evaluate } = await import('../src/index.js');
-        const result = await evaluate({
-            tests: 'it("test", () => { expect(1).toBe(1); });'
-        });
-        expect(result.testResults).toBeDefined();
-        expect(result.testResults).toHaveProperty('total');
-        expect(result.testResults).toHaveProperty('passed');
-        expect(result.testResults).toHaveProperty('failed');
-        expect(result.testResults).toHaveProperty('skipped');
-        expect(result.testResults).toHaveProperty('tests');
-        expect(result.testResults).toHaveProperty('duration');
-    });
-    it('TestResult has correct shape', async () => {
-        const { evaluate } = await import('../src/index.js');
-        const result = await evaluate({
-            tests: 'it("my test", () => {});'
-        });
-        const test = result.testResults?.tests[0];
-        expect(test).toHaveProperty('name');
-        expect(test).toHaveProperty('passed');
-        expect(test).toHaveProperty('duration');
-        expect(test?.name).toBe('my test');
-        expect(test?.passed).toBe(true);
-    });
-});

package/test/index.test.ts

@@ -1,95 +0,0 @@
-import { describe, it, expect } from 'vitest'
-
-describe('index exports', () => {
-  it('exports evaluate function', async () => {
-    const { evaluate } = await import('../src/index.js')
-    expect(typeof evaluate).toBe('function')
-  })
-
-  it('exports createEvaluator function', async () => {
-    const { createEvaluator } = await import('../src/index.js')
-    expect(typeof createEvaluator).toBe('function')
-  })
-
-  it('exports types', async () => {
-    // Types are compile-time only, so we just check the module loads
-    await import('../src/index.js')
-  })
-})
-
-describe('types', () => {
-  it('EvaluateOptions interface is usable', async () => {
-    const { evaluate } = await import('../src/index.js')
-
-    // Test that options conform to EvaluateOptions
-    const options = {
-      module: 'exports.x = 1;',
-      tests: 'it("test", () => {});',
-      script: 'return 1;',
-      timeout: 5000,
-      env: { FOO: 'bar' },
-      fetch: null as null
-    }
-
-    const result = await evaluate(options)
-    expect(result).toHaveProperty('success')
-  })
-
-  it('EvaluateResult has correct shape', async () => {
-    const { evaluate } = await import('../src/index.js')
-
-    const result = await evaluate({ script: 'return 42;' })
-
-    expect(result).toHaveProperty('success')
-    expect(result).toHaveProperty('logs')
-    expect(result).toHaveProperty('duration')
-    expect(typeof result.success).toBe('boolean')
-    expect(Array.isArray(result.logs)).toBe(true)
-    expect(typeof result.duration).toBe('number')
-  })
-
-  it('LogEntry has correct shape', async () => {
-    const { evaluate } = await import('../src/index.js')
-
-    const result = await evaluate({
-      script: 'console.log("test"); return true;'
-    })
-
-    const log = result.logs[0]
-    expect(log).toHaveProperty('level')
-    expect(log).toHaveProperty('message')
-    expect(log).toHaveProperty('timestamp')
-    expect(['log', 'warn', 'error', 'info', 'debug']).toContain(log.level)
-  })
-
-  it('TestResults has correct shape when tests provided', async () => {
-    const { evaluate } = await import('../src/index.js')
-
-    const result = await evaluate({
-      tests: 'it("test", () => { expect(1).toBe(1); });'
-    })
-
-    expect(result.testResults).toBeDefined()
-    expect(result.testResults).toHaveProperty('total')
-    expect(result.testResults).toHaveProperty('passed')
-    expect(result.testResults).toHaveProperty('failed')
-    expect(result.testResults).toHaveProperty('skipped')
-    expect(result.testResults).toHaveProperty('tests')
-    expect(result.testResults).toHaveProperty('duration')
-  })
-
-  it('TestResult has correct shape', async () => {
-    const { evaluate } = await import('../src/index.js')
-
-    const result = await evaluate({
-      tests: 'it("my test", () => {});'
-    })
-
-    const test = result.testResults?.tests[0]
-    expect(test).toHaveProperty('name')
-    expect(test).toHaveProperty('passed')
-    expect(test).toHaveProperty('duration')
-    expect(test?.name).toBe('my test')
-    expect(test?.passed).toBe(true)
-  })
-})

package/test/miniflare-pool.test.ts

@@ -1,246 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest'
-import {
-  configurePool,
-  getPoolConfig,
-  getPoolStats,
-  warmPool,
-  disposePool,
-  resetPool,
-} from '../src/miniflare-pool.js'
-import { evaluate } from '../src/node.js'
-
-describe('Miniflare Pool', () => {
-  // Reset pool state between tests
-  beforeEach(async () => {
-    await resetPool()
-  })
-
-  afterEach(async () => {
-    await disposePool()
-  })
-
-  describe('configurePool', () => {
-    it('sets pool size', () => {
-      configurePool({ size: 5 })
-      const config = getPoolConfig()
-      expect(config.size).toBe(5)
-    })
-
-    it('sets maxIdleTime', () => {
-      configurePool({ maxIdleTime: 60000 })
-      const config = getPoolConfig()
-      expect(config.maxIdleTime).toBe(60000)
-    })
-
-    it('preserves existing values when not specified', () => {
-      configurePool({ size: 5 })
-      configurePool({ maxIdleTime: 60000 })
-      const config = getPoolConfig()
-      expect(config.size).toBe(5)
-      expect(config.maxIdleTime).toBe(60000)
-    })
-  })
-
-  describe('getPoolConfig', () => {
-    it('returns default configuration', () => {
-      const config = getPoolConfig()
-      expect(config.size).toBe(3)
-      expect(config.maxIdleTime).toBe(30000)
-    })
-
-    it('returns a copy of configuration', () => {
-      const config1 = getPoolConfig()
-      const config2 = getPoolConfig()
-      expect(config1).not.toBe(config2)
-      expect(config1).toEqual(config2)
-    })
-  })
-
-  describe('getPoolStats', () => {
-    it('returns initial empty stats', () => {
-      const stats = getPoolStats()
-      expect(stats.size).toBe(0)
-      expect(stats.available).toBe(0)
-      expect(stats.inUse).toBe(0)
-    })
-
-    it('shows correct stats after warming', async () => {
-      await warmPool(2)
-      const stats = getPoolStats()
-      expect(stats.size).toBe(2)
-      expect(stats.available).toBe(2)
-      expect(stats.inUse).toBe(0)
-    })
-  })
-
-  describe('warmPool', () => {
-    it('creates specified number of instances', async () => {
-      await warmPool(2)
-      const stats = getPoolStats()
-      expect(stats.size).toBe(2)
-    })
-
-    it('respects pool size limit', async () => {
-      configurePool({ size: 2 })
-      await warmPool(5)
-      const stats = getPoolStats()
-      // warmPool creates up to the requested count, but pool won't grow beyond size
-      // when new instances are acquired
-      expect(stats.size).toBeLessThanOrEqual(5)
-    })
-
-    it('does not create duplicates when called multiple times', async () => {
-      await warmPool(2)
-      await warmPool(2)
-      const stats = getPoolStats()
-      expect(stats.size).toBe(2)
-    })
-  })
-
-  describe('disposePool', () => {
-    it('disposes all instances', async () => {
-      await warmPool(3)
-      await disposePool()
-      const stats = getPoolStats()
-      expect(stats.size).toBe(0)
-    })
-
-    it('can be called multiple times safely', async () => {
-      await warmPool(2)
-      await disposePool()
-      await disposePool()
-      const stats = getPoolStats()
-      expect(stats.size).toBe(0)
-    })
-  })
-
-  describe('resetPool', () => {
-    it('disposes instances and resets config', async () => {
-      configurePool({ size: 10, maxIdleTime: 60000 })
-      await warmPool(3)
-      await resetPool()
-      const stats = getPoolStats()
-      const config = getPoolConfig()
-      expect(stats.size).toBe(0)
-      expect(config.size).toBe(3)
-      expect(config.maxIdleTime).toBe(30000)
-    })
-  })
-
-  describe('pool integration with evaluate', () => {
-    it('reuses instances across evaluations', async () => {
-      // Warm the pool
-      await warmPool(1)
-
-      // Run multiple evaluations
-      const results = await Promise.all([
-        evaluate({ script: 'return 1' }),
-        evaluate({ script: 'return 2' }),
-        evaluate({ script: 'return 3' }),
-      ])
-
-      expect(results[0].success).toBe(true)
-      expect(results[0].value).toBe(1)
-      expect(results[1].success).toBe(true)
-      expect(results[1].value).toBe(2)
-      expect(results[2].success).toBe(true)
-      expect(results[2].value).toBe(3)
-
-      // Pool should have created instances as needed
-      const stats = getPoolStats()
-      expect(stats.size).toBeGreaterThan(0)
-    })
-
-    it('returns instances to pool after evaluation', async () => {
-      // This test verifies the pool reuses instances by running multiple
-      // sequential evaluations. If pooling weren't working, each evaluation
-      // would be slower due to creating new Miniflare instances.
-      configurePool({ size: 1 })
-
-      // Run sequential evaluations with same pool size
-      const result1 = await evaluate({ script: 'return 1' })
-      expect(result1.success).toBe(true)
-      expect(result1.value).toBe(1)
-
-      const result2 = await evaluate({ script: 'return 2' })
-      expect(result2.success).toBe(true)
-      expect(result2.value).toBe(2)
-
-      const result3 = await evaluate({ script: 'return 3' })
-      expect(result3.success).toBe(true)
-      expect(result3.value).toBe(3)
-
-      // All evaluations should succeed, demonstrating instance reuse
-      // (If instances weren't being released, pool would exhaust quickly
-      // with size=1 and sequential evaluations would fail)
-    })
-
-    it('creates temporary instances when pool is exhausted', async () => {
-      configurePool({ size: 1 })
-      await warmPool(1)
-
-      // Start multiple concurrent evaluations
-      const evaluationPromises = [
-        evaluate({ script: 'return 1' }),
-        evaluate({ script: 'return 2' }),
-        evaluate({ script: 'return 3' }),
-      ]
-
-      const results = await Promise.all(evaluationPromises)
-
-      // All should succeed (some using temporary instances)
-      expect(results.every((r) => r.success)).toBe(true)
-    })
-
-    it('handles errors without leaking instances', async () => {
-      configurePool({ size: 1 })
-
-      // Run an evaluation that throws
-      const result = await evaluate({
-        script: 'throw new Error("test error")',
-      })
-
-      expect(result.success).toBe(false)
-      expect(result.error).toContain('test error')
-
-      // Instance should still be returned to pool
-      const stats = getPoolStats()
-      expect(stats.inUse).toBe(0)
-    })
-
-    it('handles timeouts without leaking instances', async () => {
-      configurePool({ size: 1 })
-
-      // Run an evaluation that times out
-      const result = await evaluate({
-        script: 'while(true) {}',
-        timeout: 100,
-      })
-
-      expect(result.success).toBe(false)
-      expect(result.error).toContain('Timeout')
-
-      // Instance should still be returned to pool
-      const stats = getPoolStats()
-      expect(stats.inUse).toBe(0)
-    })
-
-    it('maintains isolation between evaluations', async () => {
-      configurePool({ size: 1 })
-
-      // First evaluation sets a global
-      const result1 = await evaluate({
-        script: 'globalThis.testValue = 42; return globalThis.testValue;',
-      })
-      expect(result1.success).toBe(true)
-      expect(result1.value).toBe(42)
-
-      // Second evaluation should not see the global (new worker script)
-      const result2 = await evaluate({
-        script: 'return globalThis.testValue;',
-      })
-      expect(result2.success).toBe(true)
-      expect(result2.value).toBeUndefined()
-    })
-  })
-})