@divmain/jdm-asm 0.2.1 → 0.2.3

package/tests/unit/compiler/runtime-validation.test.ts

@@ -1,303 +0,0 @@
-/**
- * Runtime Schema Validation Tests
- *
- * Tests for runtime schema validation:
- * - Loading generated validation code
- * - Validating input data
- * - Error messages with field paths
- */
-
-import { describe, it, expect } from 'vitest';
-import { generateValidationCode } from '../../../src/compiler/marshal-gen';
-import { Type } from '@sinclair/typebox';
-import { loadGeneratedValidation } from '../../../src/compiler/runtime';
-
-describe('Runtime Schema Validation', () => {
-  it('should load generated validation code as executable function', async () => {
-    const schema = Type.Object({
-      name: Type.String(),
-      age: Type.Number(),
-      active: Type.Boolean(),
-    });
-
-    const validationCode = generateValidationCode(schema);
-    const validate = await loadGeneratedValidation(validationCode);
-
-    expect(typeof validate).toBe('function');
-  });
-
-  it('should accept valid data that matches schema', async () => {
-    const schema = Type.Object({
-      name: Type.String(),
-      age: Type.Number(),
-      active: Type.Boolean(),
-    });
-
-    const validationCode = generateValidationCode(schema);
-    const validate = await loadGeneratedValidation(validationCode);
-
-    const validData = {
-      name: 'Alice',
-      age: 30,
-      active: true,
-    };
-
-    // Should not throw
-    expect(() => validate(validData)).not.toThrow();
-  });
-
-  it('should reject data with wrong type', async () => {
-    const schema = Type.Object({
-      name: Type.String(),
-      age: Type.Number(),
-      active: Type.Boolean(),
-    });
-
-    const validationCode = generateValidationCode(schema);
-    const validate = await loadGeneratedValidation(validationCode);
-
-    const invalidData = {
-      name: 'Alice',
-      age: '30', // Should be number
-      active: true,
-    };
-
-    expect(() => validate(invalidData)).toThrow();
-  });
-
-  it('should reject data with missing required field', async () => {
-    const schema = Type.Object({
-      name: Type.String(),
-      age: Type.Number(),
-      active: Type.Boolean(),
-    });
-
-    const validationCode = generateValidationCode(schema);
-    const validate = await loadGeneratedValidation(validationCode);
-
-    const invalidData = {
-      name: 'Alice',
-      // age is missing
-      active: true,
-    };
-
-    expect(() => validate(invalidData)).toThrow();
-  });
-
-  it('should provide detailed error messages with field paths', async () => {
-    const schema = Type.Object({
-      user: Type.Object({
-        name: Type.String(),
-        age: Type.Number(),
-      }),
-      tags: Type.Array(Type.String()),
-    });
-
-    const validationCode = generateValidationCode(schema);
-    const validate = await loadGeneratedValidation(validationCode);
-
-    const invalidData = {
-      user: {
-        name: 'Alice',
-        age: '30', // Should be number
-      },
-      tags: ['tag1', 123], // Second element should be string
-    };
-
-    try {
-      validate(invalidData);
-      throw new Error('Expected validation to fail');
-    } catch (error) {
-      expect(error).toBeInstanceOf(Error);
-      const message = (error as Error).message;
-      // Error should include field paths
-      expect(message).toMatch(/Invalid input data/);
-      expect(message).toMatch(/user\.age|tags\/1/);
-    }
-  });
-
-  it('should handle nested object validation', async () => {
-    const schema = Type.Object({
-      customer: Type.Object({
-        name: Type.String(),
-        contact: Type.Object({
-          email: Type.String(),
-          phone: Type.Optional(Type.String()),
-        }),
-      }),
-    });
-
-    const validationCode = generateValidationCode(schema);
-    const validate = await loadGeneratedValidation(validationCode);
-
-    const validData = {
-      customer: {
-        name: 'Alice',
-        contact: {
-          email: 'alice@example.com',
-        },
-      },
-    };
-
-    const invalidData = {
-      customer: {
-        name: 'Alice',
-        contact: {
-          email: 123, // Should be string
-        },
-      },
-    };
-
-    expect(() => validate(validData)).not.toThrow();
-    expect(() => validate(invalidData)).toThrow();
-  });
-
-  it('should handle array validation', async () => {
-    const schema = Type.Object({
-      items: Type.Array(Type.Number()),
-    });
-
-    const validationCode = generateValidationCode(schema);
-    const validate = await loadGeneratedValidation(validationCode);
-
-    const validData = {
-      items: [1, 2, 3, 4],
-    };
-
-    const invalidData = {
-      items: [1, '2', 3, 4], // Second element should be number
-    };
-
-    expect(() => validate(validData)).not.toThrow();
-    expect(() => validate(invalidData)).toThrow();
-  });
-
-  it('should handle optional fields', async () => {
-    const schema = Type.Object({
-      name: Type.String(),
-      age: Type.Optional(Type.Number()),
-      email: Type.Optional(Type.String()),
-    });
-
-    const validationCode = generateValidationCode(schema);
-    const validate = await loadGeneratedValidation(validationCode);
-
-    const data1 = {
-      name: 'Alice',
-    };
-
-    const data2 = {
-      name: 'Bob',
-      age: 30,
-    };
-
-    const data3 = {
-      name: 'Carol',
-      email: 'carol@example.com',
-    };
-
-    expect(() => validate(data1)).not.toThrow();
-    expect(() => validate(data2)).not.toThrow();
-    expect(() => validate(data3)).not.toThrow();
-  });
-
-  it('should provide clear error messages for multiple validation errors', async () => {
-    const schema = Type.Object({
-      name: Type.String(),
-      age: Type.Number(),
-      email: Type.String(),
-    });
-
-    const validationCode = generateValidationCode(schema);
-    const validate = await loadGeneratedValidation(validationCode);
-
-    const invalidData = {
-      name: 123, // Should be string
-      age: '30', // Should be number
-      email: 456, // Should be string
-    };
-
-    try {
-      validate(invalidData);
-      throw new Error('Expected validation to fail');
-    } catch (error) {
-      expect(error).toBeInstanceOf(Error);
-      const message = (error as Error).message;
-      // Error should include multiple field paths
-      expect(message).toMatch(/Invalid input data/);
-      expect(message).toMatch(/name/);
-      expect(message).toMatch(/age/);
-      expect(message).toMatch(/email/);
-    }
-  });
-
-  describe('Acceptance Criteria for Ticket ja-fff6', () => {
-    it('AC1: Input type mismatches are caught', async () => {
-      const schema = Type.Object({
-        age: Type.Number(),
-        name: Type.String(),
-      });
-
-      const validationCode = generateValidationCode(schema);
-      const validate = await loadGeneratedValidation(validationCode);
-
-      const validInput = { age: 30, name: 'Alice' };
-      const invalidInput = { age: 'not a number', name: 'Alice' };
-
-      expect(() => validate(validInput)).not.toThrow();
-      expect(() => validate(invalidInput)).toThrow(/age/);
-    });
-
-    it('AC2: Missing required fields are reported', async () => {
-      const schema = Type.Object({
-        age: Type.Number(),
-        name: Type.String(),
-        email: Type.String(),
-      });
-
-      const validationCode = generateValidationCode(schema);
-      const validate = await loadGeneratedValidation(validationCode);
-
-      const invalidInput = { age: 30, name: 'Alice' }; // Missing email
-
-      try {
-        validate(invalidInput);
-        throw new Error('Expected validation to fail');
-      } catch (error) {
-        const message = (error as Error).message;
-        expect(message).toMatch(/Invalid input data/);
-        expect(message).toMatch(/email/);
-      }
-    });
-
-    it('AC3: Validation errors include field paths', async () => {
-      const schema = Type.Object({
-        level1: Type.Object({
-          level2: Type.Object({
-            value: Type.Number(),
-          }),
-        }),
-      });
-
-      const validationCode = generateValidationCode(schema);
-      const validate = await loadGeneratedValidation(validationCode);
-
-      const invalidInput = {
-        level1: {
-          level2: {
-            value: 'not a number',
-          },
-        },
-      };
-
-      try {
-        validate(invalidInput);
-        throw new Error('Expected validation to fail');
-      } catch (error) {
-        const message = (error as Error).message;
-        // Error should include the full field path
-        expect(message).toMatch(/level1/);
-      }
-    });
-  });
-});

package/tests/unit/compiler/runtime.test.ts

@@ -1,221 +0,0 @@
-// src/compiler/__tests__/runtime.test.ts
-// Tests for the CompiledDecision class and runtime support
-
-import { describe, it, expect, vi } from 'vitest';
-import { CompiledDecision, RuntimeError, ensureMemory } from '../../../src/compiler/runtime';
-
-describe('CompiledDecision', () => {
-  const mockWasm = new Uint8Array([
-    0x00,
-    0x61,
-    0x73,
-    0x6d,
-    0x01,
-    0x00,
-    0x00,
-    0x00, // WASM magic + version
-  ]);
-
-  const mockMarshal = vi.fn(() => 4);
-  const mockUnmarshal = vi.fn(() => ({ result: 'test' }));
-  const mockValidate = vi.fn();
-
-  it('should create a CompiledDecision instance', () => {
-    const decision = new CompiledDecision({
-      wasm: mockWasm,
-      schemaHash: 123n,
-      marshal: mockMarshal,
-      unmarshal: mockUnmarshal,
-      validate: mockValidate,
-    });
-
-    expect(decision).toBeInstanceOf(CompiledDecision);
-    // Memory is null before first evaluation (lazy initialization)
-    expect(decision.getMemory()).toBeNull();
-  });
-
-  it('should throw RuntimeError if MARSHAL returns invalid pointer', async () => {
-    const invalidMarshal = vi.fn(() => 0); // Invalid pointer (must be >= 4)
-
-    const decision = new CompiledDecision({
-      wasm: mockWasm,
-      schemaHash: 123n,
-      marshal: invalidMarshal,
-      unmarshal: mockUnmarshal,
-    });
-
-    await expect(decision.evaluate({ test: 'value' })).rejects.toThrow(RuntimeError);
-  });
-
-  it('should fail on invalid mock WASM during evaluation', async () => {
-    const mockValidate = vi.fn((data) => {
-      if (!data || typeof data !== 'object') {
-        throw new Error('Invalid input');
-      }
-    });
-
-    const decision = new CompiledDecision({
-      wasm: mockWasm,
-      schemaHash: 123n,
-      marshal: mockMarshal,
-      unmarshal: mockUnmarshal,
-      validate: mockValidate,
-    });
-
-    // The mock WASM module doesn't export 'memory', so instantiation succeeds
-    // but the memory will be undefined, causing the instance check to fail.
-    // Note: Real validation testing requires a valid WASM module.
-    await expect(decision.evaluate({ test: 'value' })).rejects.toThrow();
-  });
-
-  it('should get memory stats', () => {
-    const decision = new CompiledDecision({
-      wasm: mockWasm,
-      schemaHash: 123n,
-      marshal: mockMarshal,
-      unmarshal: mockUnmarshal,
-      initialMemoryPages: 2,
-      maximumMemoryPages: 10,
-    });
-
-    // Before initialization, current/used are 0
-    const stats = decision.getMemoryStats();
-    expect(stats.current).toBe(0); // Not initialized yet
-    expect(stats.maximum).toBe(65536 * 10); // 10 pages * 64KB
-    expect(stats.used).toBe(0);
-  });
-
-  it('should dispose of the instance', () => {
-    const decision = new CompiledDecision({
-      wasm: mockWasm,
-      schemaHash: 123n,
-      marshal: mockMarshal,
-      unmarshal: mockUnmarshal,
-    });
-
-    decision.dispose();
-    expect(decision.getInstance()).toBe(null);
-  });
-
-  it('should throw RuntimeError when getInputBuffer called before initialization', () => {
-    const decision = new CompiledDecision({
-      wasm: mockWasm,
-      schemaHash: 123n,
-      marshal: mockMarshal,
-      unmarshal: mockUnmarshal,
-    });
-
-    // Memory is not initialized until evaluate() is called
-    expect(() => {
-      decision.getInputBuffer(1024);
-    }).toThrow(RuntimeError);
-  });
-
-  it('should throw RuntimeError with correct error code when buffer cannot be obtained', () => {
-    const decision = new CompiledDecision({
-      wasm: mockWasm,
-      schemaHash: 123n,
-      marshal: mockMarshal,
-      unmarshal: mockUnmarshal,
-      initialMemoryPages: 1,
-      maximumMemoryPages: 1,
-    });
-
-    try {
-      decision.getInputBuffer(100000);
-      throw new Error('Should have thrown RuntimeError');
-    } catch (error) {
-      if (error instanceof RuntimeError) {
-        expect(error.code).toBe(5); // OUT_OF_MEMORY
-      } else {
-        throw error;
-      }
-    }
-  });
-});
-
-describe('RuntimeError', () => {
-  it('should create a RuntimeError with message and code', () => {
-    const error = new RuntimeError('Test error', 1, { context: 'data' });
-
-    expect(error).toBeInstanceOf(Error);
-    expect(error.name).toBe('RuntimeError');
-    expect(error.message).toBe('Test error');
-    expect(error.code).toBe(1);
-    expect(error.context).toEqual({ context: 'data' });
-  });
-
-  it('should have default code -1 if not specified', () => {
-    const error = new RuntimeError('Test error');
-    expect(error.code).toBe(-1);
-    expect(error.context).toBeUndefined();
-  });
-});
-
-describe('ensureMemory', () => {
-  it('should not grow memory if required size is within current buffer', () => {
-    const memory = new WebAssembly.Memory({ initial: 1 }); // 64KB
-    const initialSize = memory.buffer.byteLength;
-
-    ensureMemory(memory, 60000); // Less than current size
-
-    expect(memory.buffer.byteLength).toBe(initialSize);
-  });
-
-  it('should grow memory when required size exceeds current buffer', () => {
-    const memory = new WebAssembly.Memory({ initial: 1, maximum: 10 }); // 64KB initial, max 640KB
-    const initialSize = memory.buffer.byteLength;
-
-    ensureMemory(memory, 80000); // More than 64KB, need 2 pages = 128KB
-
-    expect(memory.buffer.byteLength).toBeGreaterThan(initialSize);
-    expect(memory.buffer.byteLength).toBe(131072); // 2 pages * 64KB
-  });
-
-  it('should grow memory by exact required pages', () => {
-    const memory = new WebAssembly.Memory({ initial: 1, maximum: 10 });
-
-    // Request 200KB - initial 64KB = 136KB needed, rounds up to 3 pages = 192KB added
-    // Total should be 256KB (4 pages)
-    ensureMemory(memory, 200000);
-
-    expect(memory.buffer.byteLength).toBe(262144); // 4 pages * 64KB
-  });
-
-  it('should handle large memory growth requests', () => {
-    const memory = new WebAssembly.Memory({ initial: 1, maximum: 10 });
-
-    ensureMemory(memory, 500000); // 500KB request
-
-    expect(memory.buffer.byteLength).toBe(524288); // 8 pages * 64KB = 512KB
-  });
-
-  it('should throw error when memory cannot be grown beyond maximum', () => {
-    const memory = new WebAssembly.Memory({ initial: 1, maximum: 2 }); // Max 128KB
-
-    expect(() => {
-      ensureMemory(memory, 500000); // Request 500KB, but max is 128KB
-    }).toThrow(/Cannot grow WASM memory/);
-  });
-
-  it('should handle exact page boundary requests', () => {
-    const memory = new WebAssembly.Memory({ initial: 1, maximum: 5 });
-
-    // Request exactly 128KB (2 pages)
-    ensureMemory(memory, 131072);
-
-    expect(memory.buffer.byteLength).toBe(131072);
-  });
-
-  it('should not grow memory when required size equals current size', () => {
-    const memory = new WebAssembly.Memory({ initial: 2 }); // 128KB
-    const initialSize = memory.buffer.byteLength;
-
-    ensureMemory(memory, initialSize);
-
-    expect(memory.buffer.byteLength).toBe(initialSize);
-  });
-});
-
-// Note: Full integration tests for createCompiledDecision would be added
-// in future tickets when we have actual functional WASM modules