@divmain/jdm-asm 0.2.0

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

@@ -0,0 +1,303 @@
+/**
+ * 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

@@ -0,0 +1,221 @@
+// 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