@divmain/jdm-asm 0.2.0 → 0.2.3

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

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