@divmain/jdm-asm 0.2.0

package/tests/unit/compiler/runtime-error-cleanup.test.ts

@@ -0,0 +1,426 @@
+// tests/unit/compiler/runtime-error-cleanup.test.ts
+// Tests for error state cleanup in CompiledDecision to ensure error state
+// does not persist between evaluations (ERR-2592)
+
+import { describe, it, expect, vi } from 'vitest';
+import { CompiledDecision } from '../../../src/compiler/runtime';
+
+describe('CompiledDecision Error State Cleanup', () => {
+  // Shared memory for mock instances (768KB to match real requirements)
+  const mockMemory = new WebAssembly.Memory({ initial: 12, maximum: 256 });
+
+  // Helper to create a mock WebAssembly instance with full exports
+  const createMockInstance = (
+    options: {
+      clearLastErrorFn?: () => void;
+      getLastErrorFn?: () => number;
+      resetHeapFn?: () => void;
+      evaluateFn?: (ptr: number) => number;
+    } = {},
+  ) => {
+    return {
+      exports: {
+        memory: mockMemory,
+        clearLastError: options.clearLastErrorFn ?? (() => {}),
+        getLastError: options.getLastErrorFn ?? (() => 0),
+        resetHeap: options.resetHeapFn ?? (() => {}),
+        evaluate: options.evaluateFn ?? ((_ptr: number) => 100),
+      },
+    } as unknown as WebAssembly.Instance;
+  };
+
+  // Helper to create a minimal valid WASM module
+  const createMockWasm = () =>
+    new Uint8Array([
+      0x00,
+      0x61,
+      0x73,
+      0x6d, // WASM magic
+      0x01,
+      0x00,
+      0x00,
+      0x00, // version
+    ]);
+
+  describe('Error State Isolation Between Evaluations', () => {
+    it('should call clearLastError at start and end of evaluation', async () => {
+      let clearLastErrorCallCount = 0;
+      const mockMarshal = vi.fn(() => 4);
+      const mockUnmarshal = vi.fn(() => ({ result: 'success' }));
+
+      const decision = new CompiledDecision({
+        wasm: createMockWasm(),
+        schemaHash: 123n,
+        marshal: mockMarshal,
+        unmarshal: mockUnmarshal,
+      });
+
+      // Mock the WebAssembly.instantiate to return our mock instance
+      vi.spyOn(WebAssembly, 'instantiate').mockImplementation(async (_module, _imports) => {
+        return createMockInstance({
+          clearLastErrorFn: () => {
+            clearLastErrorCallCount++;
+          },
+        });
+      });
+
+      try {
+        await decision.evaluate({ test: 'value' });
+
+        // clearLastError should be called twice: once at start, once in finally
+        expect(clearLastErrorCallCount).toBe(2);
+      } finally {
+        // Restore original
+        vi.spyOn(WebAssembly, 'instantiate').mockRestore();
+      }
+    });
+
+    it('should clear error state even when marshal throws', async () => {
+      let clearLastErrorCallCount = 0;
+      const mockMarshal = vi.fn(() => {
+        throw new Error('Marshal failed');
+      });
+      const mockUnmarshal = vi.fn(() => ({ result: 'success' }));
+
+      const decision = new CompiledDecision({
+        wasm: createMockWasm(),
+        schemaHash: 123n,
+        marshal: mockMarshal,
+        unmarshal: mockUnmarshal,
+      });
+
+      // Mock the WebAssembly.instantiate
+      vi.spyOn(WebAssembly, 'instantiate').mockImplementation(async (_module, _imports) => {
+        return createMockInstance({
+          clearLastErrorFn: () => {
+            clearLastErrorCallCount++;
+          },
+        });
+      });
+
+      try {
+        await expect(decision.evaluate({ test: 'value' })).rejects.toThrow('Marshal failed');
+
+        // clearLastError should still be called: once at start, once in finally
+        expect(clearLastErrorCallCount).toBe(2);
+      } finally {
+        vi.spyOn(WebAssembly, 'instantiate').mockRestore();
+      }
+    });
+
+    it('should clear error state when evaluation fails with error code', async () => {
+      const mockMarshal = vi.fn(() => 4);
+      const mockUnmarshal = vi.fn(() => ({ result: 'success' }));
+      let clearLastErrorCallCount = 0;
+      let lastErrorCode = 0;
+      let evaluationCount = 0;
+
+      const decision = new CompiledDecision({
+        wasm: createMockWasm(),
+        schemaHash: 123n,
+        marshal: mockMarshal,
+        unmarshal: mockUnmarshal,
+      });
+
+      // Mock the WebAssembly.instantiate
+      vi.spyOn(WebAssembly, 'instantiate').mockImplementation(async (_module, _imports) => {
+        return createMockInstance({
+          clearLastErrorFn: () => {
+            clearLastErrorCallCount++;
+            lastErrorCode = 0; // Simulate clearing
+          },
+          getLastErrorFn: () => lastErrorCode,
+          evaluateFn: () => {
+            evaluationCount++;
+            // First evaluation sets error, second doesn't
+            if (evaluationCount === 1) {
+              lastErrorCode = 1; // SCHEMA_MISMATCH
+            }
+            return 100;
+          },
+        });
+      });
+
+      try {
+        // First evaluation: simulate WASM error (schema mismatch)
+        await expect(decision.evaluate({ test: 'value' })).rejects.toThrow('Schema mismatch');
+
+        // Verify error was cleared in finally block
+        expect(lastErrorCode).toBe(0); // Should be cleared by clearLastError
+        expect(clearLastErrorCallCount).toBe(2); // Start + finally
+
+        // Second evaluation: should succeed without seeing old error
+        const result = await decision.evaluate({ test: 'value' });
+
+        // Should succeed
+        expect(result).toEqual({ result: 'success' });
+        expect(clearLastErrorCallCount).toBe(4); // 2 more calls for second evaluation
+      } finally {
+        vi.spyOn(WebAssembly, 'instantiate').mockRestore();
+      }
+    });
+
+    it('should clear error state even when unmarshal throws', async () => {
+      const mockMarshal = vi.fn(() => 4);
+      const mockUnmarshal = vi.fn(() => {
+        throw new Error('Unmarshal failed');
+      });
+      let clearLastErrorCallCount = 0;
+
+      const decision = new CompiledDecision({
+        wasm: createMockWasm(),
+        schemaHash: 123n,
+        marshal: mockMarshal,
+        unmarshal: mockUnmarshal,
+      });
+
+      // Mock the WebAssembly.instantiate
+      vi.spyOn(WebAssembly, 'instantiate').mockImplementation(async (_module, _imports) => {
+        return createMockInstance({
+          clearLastErrorFn: () => {
+            clearLastErrorCallCount++;
+          },
+        });
+      });
+
+      try {
+        // Evaluation: unmarshal throws
+        await expect(decision.evaluate({ test: 'value' })).rejects.toThrow('Unmarshal failed');
+
+        // clearLastError should still be called in finally block
+        expect(clearLastErrorCallCount).toBe(2); // Start + finally
+      } finally {
+        vi.spyOn(WebAssembly, 'instantiate').mockRestore();
+      }
+    });
+
+    it('should handle clearLastError not being exported gracefully', async () => {
+      const mockMarshal = vi.fn(() => 4);
+      const mockUnmarshal = vi.fn(() => ({ result: 'success' }));
+
+      const decision = new CompiledDecision({
+        wasm: createMockWasm(),
+        schemaHash: 123n,
+        marshal: mockMarshal,
+        unmarshal: mockUnmarshal,
+      });
+
+      // Mock the WebAssembly.instantiate WITHOUT clearLastError export (older WASM modules)
+      vi.spyOn(WebAssembly, 'instantiate').mockImplementation(async (_module, _imports) => {
+        return {
+          exports: {
+            memory: mockMemory,
+            getLastError: () => 0,
+            resetHeap: () => {},
+            evaluate: () => 100,
+            // Note: clearLastError is NOT exported
+          },
+        } as unknown as WebAssembly.Instance;
+      });
+
+      try {
+        // Should not throw even though clearLastError is missing
+        const result = await decision.evaluate({ test: 'value' });
+        expect(result).toEqual({ result: 'success' });
+      } finally {
+        vi.spyOn(WebAssembly, 'instantiate').mockRestore();
+      }
+    });
+  });
+
+  describe('Multiple Consecutive Evaluations', () => {
+    it('should maintain clean error state across multiple successful evaluations', async () => {
+      const mockMarshal = vi.fn(() => 4);
+      const mockUnmarshal = vi.fn(() => ({ result: 'success' }));
+      let clearLastErrorCallCount = 0;
+
+      const decision = new CompiledDecision({
+        wasm: createMockWasm(),
+        schemaHash: 123n,
+        marshal: mockMarshal,
+        unmarshal: mockUnmarshal,
+      });
+
+      // Mock the WebAssembly.instantiate
+      vi.spyOn(WebAssembly, 'instantiate').mockImplementation(async (_module, _imports) => {
+        return createMockInstance({
+          clearLastErrorFn: () => {
+            clearLastErrorCallCount++;
+          },
+        });
+      });
+
+      try {
+        // Run multiple evaluations
+        for (let i = 0; i < 5; i++) {
+          const result = await decision.evaluate({ iteration: i });
+          expect(result).toEqual({ result: 'success' });
+        }
+
+        // clearLastError should be called for each evaluation (start + finally)
+        expect(clearLastErrorCallCount).toBe(10); // 2 calls per evaluation * 5 evaluations
+      } finally {
+        vi.spyOn(WebAssembly, 'instantiate').mockRestore();
+      }
+    });
+
+    it('should recover after multiple consecutive errors', async () => {
+      const mockMarshal = vi.fn(() => 4);
+      const mockUnmarshal = vi.fn(() => ({ result: 'success' }));
+      let clearLastErrorCallCount = 0;
+      let evaluationCount = 0;
+      let lastErrorCode = 0;
+
+      const decision = new CompiledDecision({
+        wasm: createMockWasm(),
+        schemaHash: 123n,
+        marshal: mockMarshal,
+        unmarshal: mockUnmarshal,
+      });
+
+      // Mock the WebAssembly.instantiate
+      vi.spyOn(WebAssembly, 'instantiate').mockImplementation(async (_module, _imports) => {
+        return createMockInstance({
+          clearLastErrorFn: () => {
+            clearLastErrorCallCount++;
+            lastErrorCode = 0; // Clear error
+          },
+          getLastErrorFn: () => lastErrorCode,
+          evaluateFn: () => {
+            evaluationCount++;
+            // First 3 evaluations set error, 4th doesn't
+            if (evaluationCount <= 3) {
+              lastErrorCode = 4; // EVALUATION_ERROR
+            }
+            return 100;
+          },
+        });
+      });
+
+      try {
+        // Multiple failing evaluations
+        for (let i = 0; i < 3; i++) {
+          await expect(decision.evaluate({ iteration: i })).rejects.toThrow('Evaluation error');
+        }
+
+        // Then a successful evaluation
+        const result = await decision.evaluate({ final: true });
+        expect(result).toEqual({ result: 'success' });
+
+        // clearLastError should be called for all evaluations
+        expect(clearLastErrorCallCount).toBe(8); // 2 calls * 4 evaluations
+      } finally {
+        vi.spyOn(WebAssembly, 'instantiate').mockRestore();
+      }
+    });
+
+    it('should alternate between success and failure cleanly', async () => {
+      const mockMarshal = vi.fn(() => 4);
+      const mockUnmarshal = vi.fn(() => ({ result: 'success' }));
+      let clearLastErrorCallCount = 0;
+      let evaluationCount = 0;
+      let lastErrorCode = 0;
+
+      const decision = new CompiledDecision({
+        wasm: createMockWasm(),
+        schemaHash: 123n,
+        marshal: mockMarshal,
+        unmarshal: mockUnmarshal,
+      });
+
+      // Mock the WebAssembly.instantiate
+      vi.spyOn(WebAssembly, 'instantiate').mockImplementation(async (_module, _imports) => {
+        return createMockInstance({
+          clearLastErrorFn: () => {
+            clearLastErrorCallCount++;
+            lastErrorCode = 0; // Clear error
+          },
+          getLastErrorFn: () => lastErrorCode,
+          evaluateFn: () => {
+            evaluationCount++;
+            // Alternate: even evaluations (1st, 3rd, 5th...) fail, odd succeed
+            if (evaluationCount % 2 === 1) {
+              lastErrorCode = 1; // SCHEMA_MISMATCH
+            }
+            return 100;
+          },
+        });
+      });
+
+      try {
+        // Alternate between success and failure
+        for (let i = 0; i < 10; i++) {
+          const shouldFail = i % 2 === 0;
+
+          if (shouldFail) {
+            await expect(decision.evaluate({ iteration: i })).rejects.toThrow();
+          } else {
+            const result = await decision.evaluate({ iteration: i });
+            expect(result).toEqual({ result: 'success' });
+          }
+        }
+
+        // clearLastError should be called for all evaluations
+        expect(clearLastErrorCallCount).toBe(20); // 2 calls * 10 evaluations
+      } finally {
+        vi.spyOn(WebAssembly, 'instantiate').mockRestore();
+      }
+    });
+  });
+
+  describe('Error State Documentation', () => {
+    it('demonstrates that error state is local to each evaluation', async () => {
+      // This test serves as documentation for the fix to ERR-2592
+      const mockMarshal = vi.fn(() => 4);
+      const mockUnmarshal = vi.fn(() => ({ result: 'success' }));
+      const errorStates: number[] = [];
+      let currentError = 0;
+      let evaluationCount = 0;
+
+      const decision = new CompiledDecision({
+        wasm: createMockWasm(),
+        schemaHash: 123n,
+        marshal: mockMarshal,
+        unmarshal: mockUnmarshal,
+      });
+
+      // Mock the WebAssembly.instantiate
+      vi.spyOn(WebAssembly, 'instantiate').mockImplementation(async (_module, _imports) => {
+        return createMockInstance({
+          clearLastErrorFn: () => {
+            currentError = 0; // Clear error
+          },
+          getLastErrorFn: () => {
+            errorStates.push(currentError);
+            return currentError;
+          },
+          evaluateFn: () => {
+            evaluationCount++;
+            // Simulate an error on first evaluation only
+            if (evaluationCount === 1) {
+              currentError = 1; // SCHEMA_MISMATCH
+            }
+            return 100;
+          },
+        });
+      });
+
+      try {
+        // First evaluation fails with error
+        await expect(decision.evaluate({ test: 1 })).rejects.toThrow();
+
+        // Second evaluation should see clean error state (0)
+        // This is the key fix: error state is cleared after first evaluation
+        await decision.evaluate({ test: 2 });
+
+        // Verify error state was cleared between evaluations
+        // errorStates[0] = first evaluation's error check (= 1)
+        // errorStates[1] = second evaluation's error check (should be 0)
+        expect(errorStates[0]).toBe(1); // First evaluation had error
+        expect(errorStates[1]).toBe(0); // Second evaluation sees clean state
+      } finally {
+        vi.spyOn(WebAssembly, 'instantiate').mockRestore();
+      }
+    });
+  });
+});