ai-evaluate 2.1.8 → 2.2.0

package/test/shared.test.ts

@@ -1,105 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { matchesDomainPattern, isDomainAllowed, generateDomainCheckCode } from '../src/shared.js'
-
-describe('domain matching utilities', () => {
-  describe('matchesDomainPattern', () => {
-    describe('exact matching', () => {
-      it('matches exact domain', () => {
-        expect(matchesDomainPattern('api.example.com', 'api.example.com')).toBe(true)
-      })
-
-      it('does not match different domains', () => {
-        expect(matchesDomainPattern('api.example.com', 'other.example.com')).toBe(false)
-      })
-
-      it('is case-insensitive', () => {
-        expect(matchesDomainPattern('API.EXAMPLE.COM', 'api.example.com')).toBe(true)
-        expect(matchesDomainPattern('api.example.com', 'API.EXAMPLE.COM')).toBe(true)
-      })
-    })
-
-    describe('wildcard matching', () => {
-      it('matches subdomain with wildcard pattern', () => {
-        expect(matchesDomainPattern('api.example.com', '*.example.com')).toBe(true)
-        expect(matchesDomainPattern('data.example.com', '*.example.com')).toBe(true)
-        expect(matchesDomainPattern('nested.api.example.com', '*.example.com')).toBe(true)
-      })
-
-      it('matches root domain with wildcard pattern', () => {
-        // Wildcard also matches the root domain itself
-        expect(matchesDomainPattern('example.com', '*.example.com')).toBe(true)
-      })
-
-      it('does not match unrelated domains with wildcard', () => {
-        expect(matchesDomainPattern('api.other.com', '*.example.com')).toBe(false)
-        expect(matchesDomainPattern('example.com.evil.com', '*.example.com')).toBe(false)
-      })
-
-      it('wildcard is case-insensitive', () => {
-        expect(matchesDomainPattern('API.EXAMPLE.COM', '*.example.com')).toBe(true)
-        expect(matchesDomainPattern('api.example.com', '*.EXAMPLE.COM')).toBe(true)
-      })
-    })
-  })
-
-  describe('isDomainAllowed', () => {
-    it('returns true for allowed exact domain', () => {
-      expect(isDomainAllowed('https://api.example.com/path', ['api.example.com'])).toBe(true)
-    })
-
-    it('returns false for non-allowed domain', () => {
-      expect(isDomainAllowed('https://blocked.com/path', ['api.example.com'])).toBe(false)
-    })
-
-    it('returns true for domain matching wildcard', () => {
-      expect(isDomainAllowed('https://api.example.com/path', ['*.example.com'])).toBe(true)
-    })
-
-    it('supports multiple allowed domains', () => {
-      const allowed = ['api.example.com', '*.trusted.com', 'data.org']
-      expect(isDomainAllowed('https://api.example.com/path', allowed)).toBe(true)
-      expect(isDomainAllowed('https://any.trusted.com/path', allowed)).toBe(true)
-      expect(isDomainAllowed('https://data.org/path', allowed)).toBe(true)
-      expect(isDomainAllowed('https://blocked.com/path', allowed)).toBe(false)
-    })
-
-    it('returns false for invalid URLs', () => {
-      expect(isDomainAllowed('not-a-url', ['api.example.com'])).toBe(false)
-    })
-
-    it('returns false for empty allowlist', () => {
-      expect(isDomainAllowed('https://example.com', [])).toBe(false)
-    })
-
-    it('handles URLs with ports', () => {
-      expect(isDomainAllowed('https://api.example.com:8080/path', ['api.example.com'])).toBe(true)
-    })
-
-    it('handles URLs with authentication', () => {
-      expect(isDomainAllowed('https://user:pass@api.example.com/path', ['api.example.com'])).toBe(
-        true
-      )
-    })
-  })
-
-  describe('generateDomainCheckCode', () => {
-    it('generates valid JavaScript code', () => {
-      const code = generateDomainCheckCode(['api.example.com', '*.trusted.com'])
-      expect(code).toContain('__allowedDomains__')
-      expect(code).toContain('__matchesDomainPattern__')
-      expect(code).toContain('__isDomainAllowed__')
-      expect(code).toContain('globalThis.fetch')
-    })
-
-    it('includes the allowed domains in the generated code', () => {
-      const code = generateDomainCheckCode(['api.example.com', '*.trusted.com'])
-      expect(code).toContain('api.example.com')
-      expect(code).toContain('*.trusted.com')
-    })
-
-    it('generates code that throws for blocked domains', () => {
-      const code = generateDomainCheckCode(['api.example.com'])
-      expect(code).toContain('not in allowlist')
-    })
-  })
-})

package/test/type-guards.test.ts

@@ -1,303 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { isEvaluateResult, assertEvaluateResult } from '../src/type-guards.js'
-
-describe('type guards', () => {
-  describe('isEvaluateResult', () => {
-    it('returns true for valid EvaluateResult', () => {
-      const result = {
-        success: true,
-        duration: 100,
-        logs: [],
-      }
-      expect(isEvaluateResult(result)).toBe(true)
-    })
-
-    it('returns true for valid EvaluateResult with value', () => {
-      const result = {
-        success: true,
-        duration: 100,
-        logs: [],
-        value: 42,
-      }
-      expect(isEvaluateResult(result)).toBe(true)
-    })
-
-    it('returns true for valid EvaluateResult with error', () => {
-      const result = {
-        success: false,
-        duration: 100,
-        logs: [],
-        error: 'Something went wrong',
-      }
-      expect(isEvaluateResult(result)).toBe(true)
-    })
-
-    it('returns true for valid EvaluateResult with logs', () => {
-      const result = {
-        success: true,
-        duration: 100,
-        logs: [
-          { level: 'log' as const, message: 'hello', timestamp: 1234567890 },
-          { level: 'error' as const, message: 'oops', timestamp: 1234567891 },
-        ],
-      }
-      expect(isEvaluateResult(result)).toBe(true)
-    })
-
-    it('returns true for valid EvaluateResult with testResults', () => {
-      const result = {
-        success: true,
-        duration: 100,
-        logs: [],
-        testResults: {
-          total: 2,
-          passed: 1,
-          failed: 1,
-          skipped: 0,
-          duration: 50,
-          tests: [
-            { name: 'test1', passed: true, duration: 25 },
-            { name: 'test2', passed: false, duration: 25, error: 'failed' },
-          ],
-        },
-      }
-      expect(isEvaluateResult(result)).toBe(true)
-    })
-
-    it('returns false for null', () => {
-      expect(isEvaluateResult(null)).toBe(false)
-    })
-
-    it('returns false for non-object', () => {
-      expect(isEvaluateResult('string')).toBe(false)
-      expect(isEvaluateResult(123)).toBe(false)
-      expect(isEvaluateResult(undefined)).toBe(false)
-    })
-
-    it('returns false for missing success', () => {
-      const result = {
-        duration: 100,
-        logs: [],
-      }
-      expect(isEvaluateResult(result)).toBe(false)
-    })
-
-    it('returns false for missing duration', () => {
-      const result = {
-        success: true,
-        logs: [],
-      }
-      expect(isEvaluateResult(result)).toBe(false)
-    })
-
-    it('returns false for missing logs', () => {
-      const result = {
-        success: true,
-        duration: 100,
-      }
-      expect(isEvaluateResult(result)).toBe(false)
-    })
-
-    it('returns false for wrong type success', () => {
-      const result = {
-        success: 'true',
-        duration: 100,
-        logs: [],
-      }
-      expect(isEvaluateResult(result)).toBe(false)
-    })
-
-    it('returns false for wrong type duration', () => {
-      const result = {
-        success: true,
-        duration: '100',
-        logs: [],
-      }
-      expect(isEvaluateResult(result)).toBe(false)
-    })
-
-    it('returns false for logs not being array', () => {
-      const result = {
-        success: true,
-        duration: 100,
-        logs: {},
-      }
-      expect(isEvaluateResult(result)).toBe(false)
-    })
-
-    it('returns false for invalid log entry', () => {
-      const result = {
-        success: true,
-        duration: 100,
-        logs: [{ level: 'invalid', message: 'hello', timestamp: 1234 }],
-      }
-      expect(isEvaluateResult(result)).toBe(false)
-    })
-
-    it('returns false for error being wrong type', () => {
-      const result = {
-        success: false,
-        duration: 100,
-        logs: [],
-        error: 123,
-      }
-      expect(isEvaluateResult(result)).toBe(false)
-    })
-
-    it('returns false for invalid testResults', () => {
-      const result = {
-        success: true,
-        duration: 100,
-        logs: [],
-        testResults: {
-          total: 'not a number',
-          passed: 0,
-          failed: 0,
-          skipped: 0,
-          duration: 0,
-          tests: [],
-        },
-      }
-      expect(isEvaluateResult(result)).toBe(false)
-    })
-  })
-
-  describe('assertEvaluateResult', () => {
-    it('does not throw for valid EvaluateResult', () => {
-      const result = {
-        success: true,
-        duration: 100,
-        logs: [],
-      }
-      expect(() => assertEvaluateResult(result)).not.toThrow()
-    })
-
-    it('throws for null', () => {
-      expect(() => assertEvaluateResult(null)).toThrow(
-        'Invalid EvaluateResult: expected object, got null'
-      )
-    })
-
-    it('throws for non-object', () => {
-      expect(() => assertEvaluateResult('string')).toThrow(
-        'Invalid EvaluateResult: expected object, got string'
-      )
-    })
-
-    it('throws for missing success', () => {
-      const result = { duration: 100, logs: [] }
-      expect(() => assertEvaluateResult(result)).toThrow(
-        "Invalid EvaluateResult: 'success' must be a boolean, got undefined"
-      )
-    })
-
-    it('throws for missing duration', () => {
-      const result = { success: true, logs: [] }
-      expect(() => assertEvaluateResult(result)).toThrow(
-        "Invalid EvaluateResult: 'duration' must be a number, got undefined"
-      )
-    })
-
-    it('throws for missing logs', () => {
-      const result = { success: true, duration: 100 }
-      expect(() => assertEvaluateResult(result)).toThrow(
-        "Invalid EvaluateResult: 'logs' must be an array, got undefined"
-      )
-    })
-
-    it('throws for invalid log entry level', () => {
-      const result = {
-        success: true,
-        duration: 100,
-        logs: [{ level: 'invalid', message: 'hello', timestamp: 1234 }],
-      }
-      expect(() => assertEvaluateResult(result)).toThrow(
-        'Invalid EvaluateResult: logs[0].level must be one of log, warn, error, info, debug'
-      )
-    })
-
-    it('throws for invalid log entry message', () => {
-      const result = {
-        success: true,
-        duration: 100,
-        logs: [{ level: 'log', message: 123, timestamp: 1234 }],
-      }
-      expect(() => assertEvaluateResult(result)).toThrow(
-        'Invalid EvaluateResult: logs[0].message must be a string'
-      )
-    })
-
-    it('throws for invalid log entry timestamp', () => {
-      const result = {
-        success: true,
-        duration: 100,
-        logs: [{ level: 'log', message: 'hello', timestamp: 'not a number' }],
-      }
-      expect(() => assertEvaluateResult(result)).toThrow(
-        'Invalid EvaluateResult: logs[0].timestamp must be a number'
-      )
-    })
-
-    it('throws for invalid error type', () => {
-      const result = {
-        success: false,
-        duration: 100,
-        logs: [],
-        error: 123,
-      }
-      expect(() => assertEvaluateResult(result)).toThrow(
-        "Invalid EvaluateResult: 'error' must be a string if present"
-      )
-    })
-
-    it('throws for invalid testResults.total', () => {
-      const result = {
-        success: true,
-        duration: 100,
-        logs: [],
-        testResults: {
-          total: 'not a number',
-          passed: 0,
-          failed: 0,
-          skipped: 0,
-          duration: 0,
-          tests: [],
-        },
-      }
-      expect(() => assertEvaluateResult(result)).toThrow(
-        'Invalid EvaluateResult: testResults.total must be a number'
-      )
-    })
-
-    it('throws for invalid test result', () => {
-      const result = {
-        success: true,
-        duration: 100,
-        logs: [],
-        testResults: {
-          total: 1,
-          passed: 0,
-          failed: 1,
-          skipped: 0,
-          duration: 50,
-          tests: [{ name: 'test1', passed: 'not a boolean', duration: 25 }],
-        },
-      }
-      expect(() => assertEvaluateResult(result)).toThrow(
-        'Invalid EvaluateResult: testResults.tests[0].passed must be a boolean'
-      )
-    })
-
-    it('validates all log level types', () => {
-      const levels = ['log', 'warn', 'error', 'info', 'debug'] as const
-      for (const level of levels) {
-        const result = {
-          success: true,
-          duration: 100,
-          logs: [{ level, message: 'test', timestamp: 1234 }],
-        }
-        expect(() => assertEvaluateResult(result)).not.toThrow()
-      }
-    })
-  })
-})

package/test/validation.test.ts

@@ -1,240 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import {
-  validateOptions,
-  ValidationError,
-  MAX_SCRIPT_SIZE,
-  MAX_IMPORTS,
-  MAX_TIMEOUT,
-  DEFAULT_TIMEOUT,
-} from '../src/validation.js'
-
-describe('validation', () => {
-  describe('constants', () => {
-    it('exports expected constant values', () => {
-      expect(MAX_SCRIPT_SIZE).toBe(1024 * 1024) // 1MB
-      expect(MAX_IMPORTS).toBe(100)
-      expect(MAX_TIMEOUT).toBe(60000) // 60s
-      expect(DEFAULT_TIMEOUT).toBe(5000) // 5s
-    })
-  })
-
-  describe('validateOptions', () => {
-    describe('valid options', () => {
-      it('accepts empty options', () => {
-        expect(() => validateOptions({})).not.toThrow()
-      })
-
-      it('accepts valid script', () => {
-        expect(() => validateOptions({ script: 'return 1 + 1' })).not.toThrow()
-      })
-
-      it('accepts valid module', () => {
-        expect(() => validateOptions({ module: 'export const x = 1' })).not.toThrow()
-      })
-
-      it('accepts valid tests', () => {
-        expect(() => validateOptions({ tests: 'it("works", () => {})' })).not.toThrow()
-      })
-
-      it('accepts valid timeout', () => {
-        expect(() => validateOptions({ timeout: 5000 })).not.toThrow()
-        expect(() => validateOptions({ timeout: 1 })).not.toThrow()
-        expect(() => validateOptions({ timeout: MAX_TIMEOUT })).not.toThrow()
-      })
-
-      it('accepts valid imports array', () => {
-        expect(() => validateOptions({ imports: ['https://esm.sh/lodash'] })).not.toThrow()
-        expect(() =>
-          validateOptions({ imports: ['http://localhost:3000/module.js'] })
-        ).not.toThrow()
-      })
-
-      it('accepts undefined values', () => {
-        expect(() =>
-          validateOptions({
-            script: undefined,
-            module: undefined,
-            tests: undefined,
-            timeout: undefined,
-            imports: undefined,
-          })
-        ).not.toThrow()
-      })
-    })
-
-    describe('timeout validation', () => {
-      it('rejects non-number timeout', () => {
-        expect(() => validateOptions({ timeout: '5000' as unknown as number })).toThrow(
-          ValidationError
-        )
-        expect(() => validateOptions({ timeout: '5000' as unknown as number })).toThrow(
-          'timeout must be a number'
-        )
-      })
-
-      it('rejects non-finite timeout', () => {
-        expect(() => validateOptions({ timeout: Infinity })).toThrow(ValidationError)
-        expect(() => validateOptions({ timeout: Infinity })).toThrow(
-          'timeout must be a finite number'
-        )
-        expect(() => validateOptions({ timeout: NaN })).toThrow('timeout must be a finite number')
-      })
-
-      it('rejects zero timeout', () => {
-        expect(() => validateOptions({ timeout: 0 })).toThrow(ValidationError)
-        expect(() => validateOptions({ timeout: 0 })).toThrow('timeout must be a positive number')
-      })
-
-      it('rejects negative timeout', () => {
-        expect(() => validateOptions({ timeout: -1000 })).toThrow(ValidationError)
-        expect(() => validateOptions({ timeout: -1000 })).toThrow(
-          'timeout must be a positive number'
-        )
-      })
-
-      it('rejects timeout exceeding maximum', () => {
-        expect(() => validateOptions({ timeout: MAX_TIMEOUT + 1 })).toThrow(ValidationError)
-        expect(() => validateOptions({ timeout: MAX_TIMEOUT + 1 })).toThrow(
-          `timeout exceeds maximum allowed value of ${MAX_TIMEOUT}ms`
-        )
-      })
-    })
-
-    describe('script validation', () => {
-      it('rejects non-string script', () => {
-        expect(() => validateOptions({ script: 123 as unknown as string })).toThrow(ValidationError)
-        expect(() => validateOptions({ script: 123 as unknown as string })).toThrow(
-          'script must be a string'
-        )
-      })
-
-      it('rejects script exceeding size limit', () => {
-        const largeScript = 'a'.repeat(MAX_SCRIPT_SIZE + 1)
-        expect(() => validateOptions({ script: largeScript })).toThrow(ValidationError)
-        expect(() => validateOptions({ script: largeScript })).toThrow(
-          /script size.*exceeds maximum allowed size/
-        )
-      })
-
-      it('accepts script at exact size limit', () => {
-        const maxScript = 'a'.repeat(MAX_SCRIPT_SIZE)
-        expect(() => validateOptions({ script: maxScript })).not.toThrow()
-      })
-    })
-
-    describe('module validation', () => {
-      it('rejects non-string module', () => {
-        expect(() => validateOptions({ module: {} as unknown as string })).toThrow(ValidationError)
-        expect(() => validateOptions({ module: {} as unknown as string })).toThrow(
-          'module must be a string'
-        )
-      })
-
-      it('rejects module exceeding size limit', () => {
-        const largeModule = 'a'.repeat(MAX_SCRIPT_SIZE + 1)
-        expect(() => validateOptions({ module: largeModule })).toThrow(ValidationError)
-        expect(() => validateOptions({ module: largeModule })).toThrow(
-          /module size.*exceeds maximum allowed size/
-        )
-      })
-    })
-
-    describe('tests validation', () => {
-      it('rejects non-string tests', () => {
-        expect(() => validateOptions({ tests: [] as unknown as string })).toThrow(ValidationError)
-        expect(() => validateOptions({ tests: [] as unknown as string })).toThrow(
-          'tests must be a string'
-        )
-      })
-
-      it('rejects tests exceeding size limit', () => {
-        const largeTests = 'a'.repeat(MAX_SCRIPT_SIZE + 1)
-        expect(() => validateOptions({ tests: largeTests })).toThrow(ValidationError)
-        expect(() => validateOptions({ tests: largeTests })).toThrow(
-          /tests size.*exceeds maximum allowed size/
-        )
-      })
-    })
-
-    describe('imports validation', () => {
-      it('rejects non-array imports', () => {
-        expect(() =>
-          validateOptions({ imports: 'https://esm.sh/lodash' as unknown as string[] })
-        ).toThrow(ValidationError)
-        expect(() =>
-          validateOptions({ imports: 'https://esm.sh/lodash' as unknown as string[] })
-        ).toThrow('imports must be an array')
-      })
-
-      it('rejects imports exceeding count limit', () => {
-        const tooManyImports = Array(MAX_IMPORTS + 1).fill('https://esm.sh/lodash')
-        expect(() => validateOptions({ imports: tooManyImports })).toThrow(ValidationError)
-        expect(() => validateOptions({ imports: tooManyImports })).toThrow(
-          `imports count (${MAX_IMPORTS + 1}) exceeds maximum allowed count of ${MAX_IMPORTS}`
-        )
-      })
-
-      it('accepts imports at exact count limit', () => {
-        const maxImports = Array(MAX_IMPORTS).fill('https://esm.sh/lodash')
-        expect(() => validateOptions({ imports: maxImports })).not.toThrow()
-      })
-
-      it('rejects non-string import entries', () => {
-        expect(() => validateOptions({ imports: [123 as unknown as string] })).toThrow(
-          ValidationError
-        )
-        expect(() => validateOptions({ imports: [123 as unknown as string] })).toThrow(
-          'imports[0] must be a string'
-        )
-      })
-
-      it('rejects invalid URLs', () => {
-        expect(() => validateOptions({ imports: ['not-a-url'] })).toThrow(ValidationError)
-        expect(() => validateOptions({ imports: ['not-a-url'] })).toThrow(
-          'imports[0] is not a valid URL: not-a-url'
-        )
-      })
-
-      it('rejects non-http/https URLs', () => {
-        expect(() => validateOptions({ imports: ['file:///etc/passwd'] })).toThrow(ValidationError)
-        expect(() => validateOptions({ imports: ['file:///etc/passwd'] })).toThrow(
-          'imports[0] is not a valid URL: file:///etc/passwd'
-        )
-      })
-
-      it('accepts both http and https URLs', () => {
-        expect(() =>
-          validateOptions({
-            imports: ['https://esm.sh/lodash', 'http://localhost:3000/module.js'],
-          })
-        ).not.toThrow()
-      })
-
-      it('reports correct index for invalid import', () => {
-        expect(() =>
-          validateOptions({
-            imports: ['https://esm.sh/lodash', 'invalid-url', 'https://esm.sh/react'],
-          })
-        ).toThrow('imports[1] is not a valid URL: invalid-url')
-      })
-    })
-  })
-
-  describe('ValidationError', () => {
-    it('is an instance of Error', () => {
-      const error = new ValidationError('test message')
-      expect(error).toBeInstanceOf(Error)
-      expect(error).toBeInstanceOf(ValidationError)
-    })
-
-    it('has correct name', () => {
-      const error = new ValidationError('test message')
-      expect(error.name).toBe('ValidationError')
-    })
-
-    it('has correct message', () => {
-      const error = new ValidationError('test message')
-      expect(error.message).toBe('test message')
-    })
-  })
-})