@divmain/jdm-asm 0.2.1 → 0.2.3

package/tests/integration/wasm-data-types.test.ts

@@ -1,398 +0,0 @@
-/**
- * WASM Data Types Round-Trip Tests
- *
- * Tests for marshaling and unmarshaling different data types between
- * JavaScript and WASM. Verifies that values are correctly converted in both directions.
- *
- * This is Phase 6 of the test improvement plan - comprehensive data type testing.
- */
-
-import { describe, it } from 'vitest';
-import { type JDMDecision } from '../../src/compiler';
-import { runSimpleCompatibilityTest } from '../helpers/test-harness';
-
-/**
- * Create a pass-through JDM that returns input as output
- */
-function createPassthroughJDM(field: string): JDMDecision {
-  return {
-    nodes: [
-      {
-        id: 'input-1',
-        type: 'inputNode' as any,
-        position: { x: 0, y: 0 },
-        name: 'Request',
-      },
-      {
-        id: 'expr-1',
-        type: 'expressionNode' as any,
-        position: { x: 200, y: 0 },
-        name: 'Expression',
-        content: {
-          expressions: [{ id: 'e1', key: 'result', value: field }],
-        },
-      },
-      {
-        id: 'output-1',
-        type: 'outputNode' as any,
-        position: { x: 400, y: 0 },
-        name: 'Response',
-      },
-    ],
-    edges: [
-      { id: 'edge-1', sourceId: 'input-1', targetId: 'expr-1', type: 'edge' },
-      { id: 'edge-2', sourceId: 'expr-1', targetId: 'output-1', type: 'edge' },
-    ],
-  };
-}
-
-/**
- * Create a JDM that transforms input
- */
-function createTransformJDM(expression: string): JDMDecision {
-  return {
-    nodes: [
-      {
-        id: 'input-1',
-        type: 'inputNode' as any,
-        position: { x: 0, y: 0 },
-        name: 'Request',
-      },
-      {
-        id: 'expr-1',
-        type: 'expressionNode' as any,
-        position: { x: 200, y: 0 },
-        name: 'Expression',
-        content: {
-          expressions: [{ id: 'e1', key: 'result', value: expression }],
-        },
-      },
-      {
-        id: 'output-1',
-        type: 'outputNode' as any,
-        position: { x: 400, y: 0 },
-        name: 'Response',
-      },
-    ],
-    edges: [
-      { id: 'edge-1', sourceId: 'input-1', targetId: 'expr-1', type: 'edge' },
-      { id: 'edge-2', sourceId: 'expr-1', targetId: 'output-1', type: 'edge' },
-    ],
-  };
-}
-
-describe('WASM Data Types Round-Trip Tests', () => {
-  describe('Boolean Values', () => {
-    it('should handle true value', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'boolean-true',
-        jdm: createPassthroughJDM('value'),
-        input: { value: true },
-        expected: { result: true },
-        skipZen: true,
-      });
-    });
-
-    it('should handle false value', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'boolean-false',
-        jdm: createPassthroughJDM('value'),
-        input: { value: false },
-        expected: { result: false },
-        skipZen: true,
-      });
-    });
-
-    it('should handle boolean logical operations', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'boolean-and',
-        jdm: createTransformJDM('a and b'),
-        input: { a: true, b: true },
-        expected: { result: true },
-        skipZen: true,
-      });
-
-      await runSimpleCompatibilityTest({
-        name: 'boolean-and-false',
-        jdm: createTransformJDM('a and b'),
-        input: { a: true, b: false },
-        expected: { result: false },
-        skipZen: true,
-      });
-    });
-  });
-
-  describe('Integer Values', () => {
-    it('should handle positive integers', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'integer-positive',
-        jdm: createPassthroughJDM('value'),
-        input: { value: 42 },
-        expected: { result: 42 },
-        skipZen: true,
-      });
-    });
-
-    it('should handle negative integers', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'integer-negative',
-        jdm: createPassthroughJDM('value'),
-        input: { value: -123 },
-        expected: { result: -123 },
-        skipZen: true,
-      });
-    });
-
-    it('should handle zero', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'integer-zero',
-        jdm: createPassthroughJDM('value'),
-        input: { value: 0 },
-        expected: { result: 0 },
-        skipZen: true,
-      });
-    });
-
-    it('should handle large integers', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'integer-large',
-        jdm: createPassthroughJDM('value'),
-        input: { value: 1000000000 },
-        expected: { result: 1000000000 },
-        skipZen: true,
-      });
-    });
-  });
-
-  describe('Float Values', () => {
-    it('should handle simple decimals', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'float-simple',
-        jdm: createPassthroughJDM('value'),
-        input: { value: 3.14159 },
-        expected: { result: 3.14159 },
-        skipZen: true,
-      });
-    });
-
-    it('should handle very small decimals', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'float-small',
-        jdm: createPassthroughJDM('value'),
-        input: { value: 0.0000001 },
-        expected: { result: 0.0000001 },
-        skipZen: true,
-      });
-    });
-
-    it('should handle negative decimals', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'float-negative',
-        jdm: createPassthroughJDM('value'),
-        input: { value: -2.718 },
-        expected: { result: -2.718 },
-        skipZen: true,
-      });
-    });
-  });
-
-  describe('String Values', () => {
-    it('should handle empty string', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'string-empty',
-        jdm: createPassthroughJDM('value'),
-        input: { value: '' },
-        expected: { result: '' },
-        skipZen: true,
-      });
-    });
-
-    it('should handle simple ASCII string', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'string-ascii',
-        jdm: createPassthroughJDM('value'),
-        input: { value: 'hello world' },
-        expected: { result: 'hello world' },
-        skipZen: true,
-      });
-    });
-
-    it('should handle Unicode characters', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'string-unicode',
-        jdm: createPassthroughJDM('value'),
-        input: { value: 'Hello, 世界!' },
-        expected: { result: 'Hello, 世界!' },
-        skipZen: true,
-      });
-    });
-
-    it('should handle string concatenation', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'string-concat',
-        jdm: createTransformJDM('first + " " + last'),
-        input: { first: 'John', last: 'Doe' },
-        expected: { result: 'John Doe' },
-        skipZen: true,
-      });
-    });
-  });
-
-  describe('Array Values', () => {
-    it('should handle empty array', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'array-empty',
-        jdm: createPassthroughJDM('items'),
-        input: { items: [] },
-        expected: { result: [] },
-        skipZen: true,
-      });
-    });
-
-    it('should handle array of numbers', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'array-numbers',
-        jdm: createPassthroughJDM('items'),
-        input: { items: [1, 2, 3, 4, 5] },
-        expected: { result: [1, 2, 3, 4, 5] },
-        skipZen: true,
-      });
-    });
-
-    it('should handle large arrays', async () => {
-      const items = Array.from({ length: 100 }, (_, i) => i + 1);
-      await runSimpleCompatibilityTest({
-        name: 'array-large',
-        jdm: createTransformJDM('sum(items)'),
-        input: { items },
-        // Sum of 1 to 100 = 5050
-        expected: { result: 5050 },
-        skipZen: true,
-      });
-    });
-
-    it('should handle array operations (map)', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'array-map',
-        jdm: createTransformJDM('map(items, # * 2)'),
-        input: { items: [1, 2, 3] },
-        expected: { result: [2, 4, 6] },
-        skipZen: true,
-      });
-    });
-
-    it('should handle array operations (filter)', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'array-filter',
-        jdm: createTransformJDM('filter(items, # > 5)'),
-        input: { items: [1, 5, 10, 15, 20] },
-        expected: { result: [10, 15, 20] },
-        skipZen: true,
-      });
-    });
-  });
-
-  describe('Object Values', () => {
-    it('should handle simple flat object', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'object-flat',
-        jdm: createTransformJDM('obj.name'),
-        input: { obj: { name: 'test' } },
-        expected: { result: 'test' },
-        skipZen: true,
-      });
-    });
-
-    it('should handle nested objects', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'object-nested',
-        jdm: createTransformJDM('user.profile.name'),
-        input: { user: { profile: { name: 'Alice' } } },
-        expected: { result: 'Alice' },
-        skipZen: true,
-      });
-    });
-
-    it('should handle object with multiple fields', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'object-multiple-fields',
-        jdm: createTransformJDM('person.age + 10'),
-        input: { person: { name: 'Bob', age: 25, active: true } },
-        expected: { result: 35 },
-        skipZen: true,
-      });
-    });
-
-    it('should handle object with array field', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'object-array-field',
-        jdm: createTransformJDM('sum(obj.scores)'),
-        input: { obj: { name: 'Test', scores: [10, 20, 30] } },
-        expected: { result: 60 },
-        skipZen: true,
-      });
-    });
-  });
-
-  describe('Mixed Types', () => {
-    it('should handle complex input with all types', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'mixed-complex',
-        jdm: createTransformJDM('config.count * 2'),
-        input: {
-          config: {
-            name: 'test',
-            count: 21,
-            enabled: true,
-            tags: ['a', 'b'],
-          },
-        },
-        expected: { result: 42 },
-        skipZen: true,
-      });
-    });
-
-    it('should handle multiple outputs of different types', async () => {
-      const jdm: JDMDecision = {
-        nodes: [
-          {
-            id: 'input-1',
-            type: 'inputNode' as any,
-            position: { x: 0, y: 0 },
-            name: 'Request',
-          },
-          {
-            id: 'expr-1',
-            type: 'expressionNode' as any,
-            position: { x: 200, y: 0 },
-            name: 'Expression',
-            content: {
-              expressions: [
-                { id: 'e1', key: 'doubled', value: 'x * 2' },
-                { id: 'e2', key: 'isPositive', value: 'x > 0' },
-              ],
-            },
-          },
-          {
-            id: 'output-1',
-            type: 'outputNode' as any,
-            position: { x: 400, y: 0 },
-            name: 'Response',
-          },
-        ],
-        edges: [
-          { id: 'edge-1', sourceId: 'input-1', targetId: 'expr-1', type: 'edge' },
-          { id: 'edge-2', sourceId: 'expr-1', targetId: 'output-1', type: 'edge' },
-        ],
-      };
-
-      await runSimpleCompatibilityTest({
-        name: 'multiple-outputs',
-        jdm,
-        input: { x: 5 },
-        expected: { doubled: 10, isPositive: true },
-        skipZen: true,
-      });
-    });
-  });
-});

package/tests/integration/wasm-errors.test.ts

@@ -1,199 +0,0 @@
-/**
- * WASM Error Handling Tests
- *
- * Tests for error handling in compiled WASM modules.
- * Verifies that errors are properly detected, reported, and don't corrupt state.
- *
- * This is Phase 6 of the test improvement plan - testing error scenarios.
- */
-
-import { describe, it, expect } from 'vitest';
-import { Type } from '@sinclair/typebox';
-import { compile, type JDMDecision } from '../../src/compiler';
-import { runSimpleCompatibilityTest } from '../helpers/test-harness';
-
-/**
- * Create a minimal JDM decision for testing
- */
-function createTestJDM(expression: string): JDMDecision {
-  return {
-    nodes: [
-      {
-        id: 'input-1',
-        type: 'inputNode' as any,
-        position: { x: 0, y: 0 },
-        name: 'Request',
-      },
-      {
-        id: 'expr-1',
-        type: 'expressionNode' as any,
-        position: { x: 200, y: 0 },
-        name: 'Expression',
-        content: {
-          expressions: [{ id: 'e1', key: 'result', value: expression }],
-        },
-      },
-      {
-        id: 'output-1',
-        type: 'outputNode' as any,
-        position: { x: 400, y: 0 },
-        name: 'Response',
-      },
-    ],
-    edges: [
-      { id: 'edge-1', sourceId: 'input-1', targetId: 'expr-1', type: 'edge' },
-      { id: 'edge-2', sourceId: 'expr-1', targetId: 'output-1', type: 'edge' },
-    ],
-  };
-}
-
-describe('WASM Error Handling Tests', () => {
-  describe('Compilation Errors', () => {
-    it('should throw CompilationError for invalid syntax in expressions', async () => {
-      const jdm = createTestJDM('x + + y'); // Invalid syntax
-      const inputSchema = Type.Object({ x: Type.Number(), y: Type.Number() });
-      const outputSchema = Type.Object({ result: Type.Number() });
-
-      await expect(compile({ jdm, inputSchema, outputSchema })).rejects.toThrow();
-    });
-
-    it('should throw error for unsupported function nodes', async () => {
-      const jdm: JDMDecision = {
-        nodes: [
-          {
-            id: 'input-1',
-            type: 'inputNode' as any,
-            position: { x: 0, y: 0 },
-            name: 'Request',
-          },
-          {
-            id: 'func-1',
-            type: 'functionNode' as any,
-            position: { x: 200, y: 0 },
-            name: 'CustomFunction',
-            content: { source: 'return input.x * 2;' },
-          },
-          {
-            id: 'output-1',
-            type: 'outputNode' as any,
-            position: { x: 400, y: 0 },
-            name: 'Response',
-          },
-        ],
-        edges: [
-          { id: 'edge-1', sourceId: 'input-1', targetId: 'func-1', type: 'edge' },
-          { id: 'edge-2', sourceId: 'func-1', targetId: 'output-1', type: 'edge' },
-        ],
-      };
-
-      const inputSchema = Type.Object({ x: Type.Number() });
-      const outputSchema = Type.Object({ result: Type.Number() });
-
-      await expect(compile({ jdm, inputSchema, outputSchema })).rejects.toThrow(/function/i);
-    });
-
-    it('should throw for unclosed parentheses', async () => {
-      const jdm = createTestJDM('(x + y'); // Unclosed paren
-      const inputSchema = Type.Object({ x: Type.Number(), y: Type.Number() });
-      const outputSchema = Type.Object({ result: Type.Number() });
-
-      await expect(compile({ jdm, inputSchema, outputSchema })).rejects.toThrow();
-    });
-
-    it('should throw for unknown function', async () => {
-      const jdm = createTestJDM('unknownBuiltin(x)'); // Unknown built-in function
-      const inputSchema = Type.Object({ x: Type.Number() });
-      const outputSchema = Type.Object({ result: Type.Number() });
-
-      // Note: This may not throw during compilation but at runtime
-      // The behavior depends on the expression parser implementation
-      try {
-        const compiled = await compile({ jdm, inputSchema, outputSchema });
-        // If it compiles, the test still passes - some parsers are lenient
-        expect(compiled.wasm).toBeInstanceOf(Uint8Array);
-      } catch (e) {
-        // Expected - unknown function causes compilation error
-        expect(e).toBeDefined();
-      }
-    });
-  });
-
-  describe('Runtime Arithmetic Edge Cases', () => {
-    it('should compile expressions with potential division by zero', async () => {
-      // Division by zero is a runtime concern - we just verify compilation works
-      const jdm = createTestJDM('x / y');
-      const inputSchema = Type.Object({ x: Type.Number(), y: Type.Number() });
-      const outputSchema = Type.Object({ result: Type.Number() });
-
-      const compiled = await compile({ jdm, inputSchema, outputSchema, debug: true });
-      expect(compiled.wasm).toBeInstanceOf(Uint8Array);
-      // IEEE 754 floating point handles division by zero:
-      // - positive / 0 = Infinity
-      // - negative / 0 = -Infinity
-      // - 0 / 0 = NaN
-      // The actual behavior is verified at runtime
-    });
-
-    it('should handle very large numbers', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'large-numbers',
-        jdm: createTestJDM('x * 2'),
-        input: { x: Number.MAX_SAFE_INTEGER },
-        expected: { result: Number.MAX_SAFE_INTEGER * 2 },
-        skipZen: true,
-      });
-    });
-
-    it('should handle very small numbers', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'small-numbers',
-        jdm: createTestJDM('x * 2'),
-        input: { x: Number.MIN_VALUE },
-        expected: { result: Number.MIN_VALUE * 2 },
-        skipZen: true,
-      });
-    });
-
-    it('should handle negative numbers', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'negative-numbers',
-        jdm: createTestJDM('x * -1'),
-        input: { x: -42 },
-        expected: { result: 42 },
-        skipZen: true,
-      });
-    });
-
-    it('should handle special float values (Infinity)', async () => {
-      await runSimpleCompatibilityTest({
-        name: 'infinity',
-        jdm: createTestJDM('x + 1'),
-        input: { x: Infinity },
-        expected: { result: Infinity },
-        skipZen: true,
-      });
-    });
-  });
-
-  describe('Recovery After Edge Cases', () => {
-    it('should continue working after arithmetic edge cases', async () => {
-      // First test with infinity
-      await runSimpleCompatibilityTest({
-        name: 'recovery-1',
-        jdm: createTestJDM('x + 1'),
-        input: { x: Infinity },
-        expected: { result: Infinity },
-        skipZen: true,
-      });
-
-      // Should still work with normal values
-      await runSimpleCompatibilityTest({
-        name: 'recovery-2',
-        jdm: createTestJDM('x + 1'),
-        input: { x: 5 },
-        expected: { result: 6 },
-        skipZen: true,
-      });
-    });
-  });
-});