@divmain/jdm-asm 0.2.0

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

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

@@ -0,0 +1,199 @@
+/**
+ * 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,
+      });
+    });
+  });
+});