@divmain/jdm-asm 0.2.0

package/tests/unit/compiler/cache.test.ts

@@ -0,0 +1,238 @@
+/**
+ * WASM Compilation Cache Tests
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import {
+  computeCacheKey,
+  readCacheFromDisk,
+  writeCacheToDisk,
+  clearCache,
+  getCacheStats,
+  isCacheEnabled,
+  getCacheDirectory,
+  getCacheHealth,
+} from '../../../src/compiler/cache';
+import { join } from 'path';
+
+describe('WASM Compilation Cache', () => {
+  const testCacheDir = join(process.cwd(), 'node_modules', '.cache', 'jdm-asm');
+
+  beforeEach(() => {
+    // Clear cache before each test
+    clearCache();
+  });
+
+  describe('computeCacheKey', () => {
+    it('should produce consistent hash for same inputs', () => {
+      const code = 'export function evaluate(): i32 { return 42; }';
+      const options = { optimize: true, debug: false };
+
+      const key1 = computeCacheKey(code, options);
+      const key2 = computeCacheKey(code, options);
+
+      expect(key1).toBe(key2);
+      expect(key1.length).toBe(32); // 128-bit hex
+    });
+
+    it('should produce different hash for different code', () => {
+      const options = { optimize: true, debug: false };
+
+      const key1 = computeCacheKey('export function a(): i32 { return 1; }', options);
+      const key2 = computeCacheKey('export function b(): i32 { return 2; }', options);
+
+      expect(key1).not.toBe(key2);
+    });
+
+    it('should produce different hash for different options', () => {
+      const code = 'export function evaluate(): i32 { return 42; }';
+
+      const key1 = computeCacheKey(code, { optimize: true, debug: false });
+      const key2 = computeCacheKey(code, { optimize: false, debug: false });
+      const key3 = computeCacheKey(code, { optimize: true, debug: true });
+
+      expect(key1).not.toBe(key2);
+      expect(key1).not.toBe(key3);
+      expect(key2).not.toBe(key3);
+    });
+  });
+
+  describe('readCacheFromDisk / writeCacheToDisk', () => {
+    it('should store and retrieve cache entry', () => {
+      const cacheKey = 'test_key_' + Date.now().toString(16);
+      const testBinary = new Uint8Array([0x00, 0x61, 0x73, 0x6d]); // WASM magic
+      const testWat = '(module)';
+
+      writeCacheToDisk(cacheKey, { binary: testBinary, wat: testWat });
+
+      const result = readCacheFromDisk(cacheKey);
+      expect(result).not.toBeNull();
+      expect(result!.binary).toEqual(testBinary);
+      expect(result!.wat).toBe(testWat);
+    });
+  });
+
+  describe('getCacheStats', () => {
+    it('should count cache entries', () => {
+      const binary = new Uint8Array([0x00, 0x61, 0x73, 0x6d]);
+
+      writeCacheToDisk('test_key_1', { binary, wat: '(module)' });
+      writeCacheToDisk('test_key_2', { binary, wat: '(module)' });
+
+      const stats = getCacheStats();
+      expect(stats.entries).toBe(2);
+      expect(stats.totalSize).toBeGreaterThan(0);
+    });
+  });
+
+  describe('clearCache', () => {
+    it('should remove all cache entries', () => {
+      const binary = new Uint8Array([0x00, 0x61, 0x73, 0x6d]);
+
+      writeCacheToDisk('test_key_1', { binary, wat: '(module)' });
+      writeCacheToDisk('test_key_2', { binary, wat: '(module)' });
+
+      let stats = getCacheStats();
+      expect(stats.entries).toBe(2);
+
+      clearCache();
+
+      stats = getCacheStats();
+      expect(stats.entries).toBe(0);
+    });
+  });
+
+  describe('isCacheEnabled', () => {
+    it('should be enabled by default', () => {
+      const originalEnv = process.env.JDM_ASM_NO_CACHE;
+      delete process.env.JDM_ASM_NO_CACHE;
+
+      expect(isCacheEnabled()).toBe(true);
+
+      // Restore
+      if (originalEnv !== undefined) {
+        process.env.JDM_ASM_NO_CACHE = originalEnv;
+      }
+    });
+
+    it('should be disabled with JDM_ASM_NO_CACHE=1', () => {
+      const originalEnv = process.env.JDM_ASM_NO_CACHE;
+      process.env.JDM_ASM_NO_CACHE = '1';
+
+      expect(isCacheEnabled()).toBe(false);
+
+      // Restore
+      if (originalEnv !== undefined) {
+        process.env.JDM_ASM_NO_CACHE = originalEnv;
+      } else {
+        delete process.env.JDM_ASM_NO_CACHE;
+      }
+    });
+  });
+
+  describe('getCacheDirectory', () => {
+    it('should return cache directory path', () => {
+      const dir = getCacheDirectory();
+      expect(dir).toBe(testCacheDir);
+      expect(dir).toContain('node_modules/.cache/jdm-asm');
+    });
+  });
+
+  describe('getCacheHealth', () => {
+    it('should report health when cache is enabled and empty', () => {
+      const originalEnv = process.env.JDM_ASM_NO_CACHE;
+      delete process.env.JDM_ASM_NO_CACHE;
+
+      const health = getCacheHealth();
+
+      expect(health.enabled).toBe(true);
+      expect(health.directory).toBe(testCacheDir);
+      expect(health.stats.entries).toBe(0);
+
+      // Restore
+      if (originalEnv !== undefined) {
+        process.env.JDM_ASM_NO_CACHE = originalEnv;
+      }
+    });
+
+    it('should report health when cache is disabled', () => {
+      const originalEnv = process.env.JDM_ASM_NO_CACHE;
+      process.env.JDM_ASM_NO_CACHE = '1';
+
+      const health = getCacheHealth();
+
+      expect(health.enabled).toBe(false);
+      expect(health.issues).toContain(
+        'Cache is disabled via JDM_ASM_NO_CACHE environment variable',
+      );
+
+      // Restore
+      if (originalEnv !== undefined) {
+        process.env.JDM_ASM_NO_CACHE = originalEnv;
+      } else {
+        delete process.env.JDM_ASM_NO_CACHE;
+      }
+    });
+
+    it('should report stats when cache has entries', () => {
+      const originalEnv = process.env.JDM_ASM_NO_CACHE;
+      delete process.env.JDM_ASM_NO_CACHE;
+
+      const binary = new Uint8Array([0x00, 0x61, 0x73, 0x6d]);
+      writeCacheToDisk('test_key_1', { binary, wat: '(module)' });
+      writeCacheToDisk('test_key_2', { binary, wat: '(module)' });
+
+      const health = getCacheHealth();
+
+      expect(health.enabled).toBe(true);
+      expect(health.accessible).toBe(true);
+      expect(health.stats.entries).toBe(2);
+      expect(health.stats.totalSize).toBeGreaterThan(0);
+
+      // Restore
+      if (originalEnv !== undefined) {
+        process.env.JDM_ASM_NO_CACHE = originalEnv;
+      }
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle cache write failures gracefully', () => {
+      // Create console.warn spy to verify warning is logged
+      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+      const binary = new Uint8Array([0x00, 0x61, 0x73, 0x6d]);
+
+      // Try to write to an invalid path by using a cache key with invalid characters
+      // This should not throw but should log a warning
+      writeCacheToDisk('/invalid:key*with?bad<chars>', { binary, wat: '(module)' });
+
+      // Note: On some systems this might actually succeed, so we don't assert on the warning
+      // The important part is that it doesn't throw
+
+      warnSpy.mockRestore();
+    });
+
+    it('should return null when reading non-existent cache file', () => {
+      const result = readCacheFromDisk('nonexistent_key_12345');
+      expect(result).toBeNull();
+    });
+
+    it('should handle corrupted cache files gracefully', () => {
+      const cacheKey = 'test_corrupted_' + Date.now().toString(16);
+
+      // Write a valid cache entry first
+      const binary = new Uint8Array([0x00, 0x61, 0x73, 0x6d]);
+      writeCacheToDisk(cacheKey, { binary, wat: '(module)' });
+
+      // Corrupt the cache file by writing invalid JSON
+      const fs = require('fs');
+      const cachePath = join(testCacheDir, `${cacheKey}.json`);
+      fs.writeFileSync(cachePath, '{ invalid json }', 'utf-8');
+
+      // Should return null and not throw
+      const result = readCacheFromDisk(cacheKey);
+      expect(result).toBeNull();
+    });
+  });
+});

package/tests/unit/compiler/errors.test.ts

@@ -0,0 +1,316 @@
+import { describe, it, expect } from 'vitest';
+import {
+  CompilationError,
+  ErrorCode,
+  type SourceLocation,
+  ErrorCollector,
+  isCompilationError,
+  isStructuralError,
+  isFeatureError,
+  isExpressionError,
+} from '../../../src/compiler/errors';
+
+describe('Error Handling Infrastructure', () => {
+  describe('SourceLocation', () => {
+    it('should accept minimal location information', () => {
+      const location: SourceLocation = { nodeId: 'node-1' };
+      expect(location.nodeId).toBe('node-1');
+      expect(location.nodeName).toBeUndefined();
+      expect(location.line).toBeUndefined();
+    });
+
+    it('should accept complete location information', () => {
+      const location: SourceLocation = {
+        nodeId: 'node-1',
+        nodeName: 'AgeCheck',
+        field: 'expression',
+        line: 10,
+        column: 15,
+      };
+      expect(location.nodeId).toBe('node-1');
+      expect(location.nodeName).toBe('AgeCheck');
+      expect(location.field).toBe('expression');
+      expect(location.line).toBe(10);
+      expect(location.column).toBe(15);
+    });
+  });
+
+  describe('ErrorCode', () => {
+    it('should have all structural error codes', () => {
+      expect(ErrorCode.INVALID_JSON).toBe('INVALID_JSON');
+      expect(ErrorCode.MISSING_INPUT_NODE).toBe('MISSING_INPUT_NODE');
+      expect(ErrorCode.MISSING_OUTPUT_NODE).toBe('MISSING_OUTPUT_NODE');
+      expect(ErrorCode.MULTIPLE_INPUT_NODES).toBe('MULTIPLE_INPUT_NODES');
+      expect(ErrorCode.CYCLE_DETECTED).toBe('CYCLE_DETECTED');
+      expect(ErrorCode.INVALID_EDGE).toBe('INVALID_EDGE');
+    });
+
+    it('should have all feature error codes', () => {
+      expect(ErrorCode.UNSUPPORTED_FUNCTION_NODE).toBe('UNSUPPORTED_FUNCTION_NODE');
+      expect(ErrorCode.UNSUPPORTED_EXPRESSION).toBe('UNSUPPORTED_EXPRESSION');
+    });
+
+    it('should have all expression error codes', () => {
+      expect(ErrorCode.PARSE_ERROR).toBe('PARSE_ERROR');
+      expect(ErrorCode.UNKNOWN_FUNCTION).toBe('UNKNOWN_FUNCTION');
+      expect(ErrorCode.TYPE_MISMATCH).toBe('TYPE_MISMATCH');
+      expect(ErrorCode.UNKNOWN_FIELD).toBe('UNKNOWN_FIELD');
+    });
+
+    it('should have all schema error codes', () => {
+      expect(ErrorCode.SCHEMA_MISMATCH).toBe('SCHEMA_MISMATCH');
+      expect(ErrorCode.INVALID_SCHEMA).toBe('INVALID_SCHEMA');
+    });
+  });
+
+  describe('CompilationError', () => {
+    it('should create error with mandatory fields', () => {
+      const error = new CompilationError('Test error', ErrorCode.PARSE_ERROR);
+      expect(error.message).toBe('Test error');
+      expect(error.code).toBe(ErrorCode.PARSE_ERROR);
+      expect(error.name).toBe('CompilationError');
+      expect(error.location).toBeUndefined();
+      expect(error.context).toBeUndefined();
+    });
+
+    it('should create error with location', () => {
+      const location: SourceLocation = { nodeName: 'MyNode', line: 10, column: 5 };
+      const error = new CompilationError('Test error', ErrorCode.UNKNOWN_FIELD, location);
+      expect(error.message).toBe('Test error');
+      expect(error.code).toBe(ErrorCode.UNKNOWN_FIELD);
+      expect(error.location).toEqual(location);
+    });
+
+    it('should create error with context', () => {
+      const context = { variable: 'age', expectedType: 'number', actualType: 'string' };
+      const error = new CompilationError(
+        'Type mismatch',
+        ErrorCode.TYPE_MISMATCH,
+        undefined,
+        context,
+      );
+      expect(error.context).toEqual(context);
+    });
+
+    it('should create error with both location and context', () => {
+      const location: SourceLocation = { nodeName: 'MyNode', field: 'expression' };
+      const context = { expression: 'age + "hello"' };
+      const error = new CompilationError('Type error', ErrorCode.TYPE_MISMATCH, location, context);
+      expect(error.location).toEqual(location);
+      expect(error.context).toEqual(context);
+    });
+
+    it('should format message without location', () => {
+      const error = new CompilationError('Test error', ErrorCode.PARSE_ERROR);
+      expect(error.getFormattedMessage()).toBe('[PARSE_ERROR] Test error');
+    });
+
+    it('should format message with nodeName', () => {
+      const location: SourceLocation = { nodeName: 'AgeCheck' };
+      const error = new CompilationError('Test error', ErrorCode.PARSE_ERROR, location);
+      expect(error.getFormattedMessage()).toBe('[AgeCheck] [PARSE_ERROR] Test error');
+    });
+
+    it('should format message with nodeId', () => {
+      const location: SourceLocation = { nodeId: 'node-123' };
+      const error = new CompilationError('Test error', ErrorCode.PARSE_ERROR, location);
+      expect(error.getFormattedMessage()).toBe('[(id: node-123)] [PARSE_ERROR] Test error');
+    });
+
+    it('should format message with field', () => {
+      const location: SourceLocation = { nodeName: 'MyNode', field: 'condition' };
+      const error = new CompilationError('Test error', ErrorCode.PARSE_ERROR, location);
+      expect(error.getFormattedMessage()).toBe('[MyNode .condition] [PARSE_ERROR] Test error');
+    });
+
+    it('should format message with line and column', () => {
+      const location: SourceLocation = { line: 10, column: 5 };
+      const error = new CompilationError('Test error', ErrorCode.PARSE_ERROR, location);
+      expect(error.getFormattedMessage()).toBe('[@10:5] [PARSE_ERROR] Test error');
+    });
+
+    it('should format message with all location fields', () => {
+      const location: SourceLocation = {
+        nodeId: 'node-1',
+        nodeName: 'MyNode',
+        field: 'expression',
+        line: 10,
+        column: 5,
+      };
+      const error = new CompilationError('Test error', ErrorCode.PARSE_ERROR, location);
+      expect(error.getFormattedMessage()).toBe(
+        '[MyNode (id: node-1) .expression @10:5] [PARSE_ERROR] Test error',
+      );
+    });
+  });
+
+  describe('ErrorCollector', () => {
+    it('should start with no errors', () => {
+      const collector = new ErrorCollector();
+      expect(collector.hasErrors()).toBe(false);
+    });
+
+    it('should add single error', () => {
+      const collector = new ErrorCollector();
+      const error = new CompilationError('Test error', ErrorCode.PARSE_ERROR);
+      collector.add(error);
+
+      expect(collector.hasErrors()).toBe(true);
+    });
+
+    it('should add multiple errors', () => {
+      const collector = new ErrorCollector();
+      const error1 = new CompilationError('Error 1', ErrorCode.UNKNOWN_FIELD);
+      const error2 = new CompilationError('Error 2', ErrorCode.TYPE_MISMATCH);
+      const error3 = new CompilationError('Error 3', ErrorCode.UNKNOWN_FUNCTION);
+
+      collector.add(error1);
+      collector.add(error2);
+      collector.add(error3);
+
+      expect(collector.hasErrors()).toBe(true);
+    });
+
+    it('should not throw when throwIfErrors called with no errors', () => {
+      const collector = new ErrorCollector();
+      expect(() => collector.throwIfErrors()).not.toThrow();
+    });
+
+    it('should throw single error directly', () => {
+      const collector = new ErrorCollector();
+      const error = new CompilationError('Single error', ErrorCode.PARSE_ERROR);
+      collector.add(error);
+
+      expect(() => collector.throwIfErrors()).toThrow('Single error');
+    });
+
+    it('should throw aggregated error for multiple errors', () => {
+      const collector = new ErrorCollector();
+      collector.add(new CompilationError('Error 1', ErrorCode.UNKNOWN_FIELD));
+      collector.add(new CompilationError('Error 2', ErrorCode.TYPE_MISMATCH));
+
+      expect(() => collector.throwIfErrors()).toThrow('2 compilation errors');
+    });
+
+    it('should include all errors in aggregated message', () => {
+      const collector = new ErrorCollector();
+      collector.add(new CompilationError('First error', ErrorCode.UNKNOWN_FIELD));
+      collector.add(new CompilationError('Second error', ErrorCode.TYPE_MISMATCH));
+      collector.add(new CompilationError('Third error', ErrorCode.UNKNOWN_FUNCTION));
+
+      expect(() => collector.throwIfErrors()).toThrow();
+      try {
+        collector.throwIfErrors();
+      } catch (e) {
+        if (e instanceof CompilationError) {
+          expect(e.message).toContain('3 compilation errors');
+          expect(e.message).toContain('1. UNKNOWN_FIELD: First error');
+          expect(e.message).toContain('2. TYPE_MISMATCH: Second error');
+          expect(e.message).toContain('3. UNKNOWN_FUNCTION: Third error');
+        }
+      }
+    });
+  });
+
+  describe('isCompilationError', () => {
+    it('should return true for CompilationError instance', () => {
+      const error = new CompilationError('Test', ErrorCode.PARSE_ERROR);
+      expect(isCompilationError(error)).toBe(true);
+    });
+
+    it('should return false for regular Error', () => {
+      const error = new Error('Test');
+      expect(isCompilationError(error)).toBe(false);
+    });
+  });
+
+  describe('isStructuralError', () => {
+    it('should return true for structural error codes', () => {
+      expect(isStructuralError(ErrorCode.INVALID_JSON)).toBe(true);
+      expect(isStructuralError(ErrorCode.MISSING_INPUT_NODE)).toBe(true);
+      expect(isStructuralError(ErrorCode.MISSING_OUTPUT_NODE)).toBe(true);
+      expect(isStructuralError(ErrorCode.MULTIPLE_INPUT_NODES)).toBe(true);
+      expect(isStructuralError(ErrorCode.CYCLE_DETECTED)).toBe(true);
+      expect(isStructuralError(ErrorCode.INVALID_EDGE)).toBe(true);
+    });
+
+    it('should return false for non-structural error codes', () => {
+      expect(isStructuralError(ErrorCode.PARSE_ERROR)).toBe(false);
+      expect(isStructuralError(ErrorCode.UNKNOWN_FUNCTION)).toBe(false);
+      expect(isStructuralError(ErrorCode.TYPE_MISMATCH)).toBe(false);
+      expect(isStructuralError(ErrorCode.UNKNOWN_FIELD)).toBe(false);
+      expect(isStructuralError(ErrorCode.UNSUPPORTED_FUNCTION_NODE)).toBe(false);
+      expect(isStructuralError(ErrorCode.SCHEMA_MISMATCH)).toBe(false);
+    });
+  });
+
+  describe('isFeatureError', () => {
+    it('should return true for feature error codes', () => {
+      expect(isFeatureError(ErrorCode.UNSUPPORTED_FUNCTION_NODE)).toBe(true);
+      expect(isFeatureError(ErrorCode.UNSUPPORTED_EXPRESSION)).toBe(true);
+    });
+
+    it('should return false for non-feature error codes', () => {
+      expect(isFeatureError(ErrorCode.PARSE_ERROR)).toBe(false);
+      expect(isFeatureError(ErrorCode.INVALID_JSON)).toBe(false);
+      expect(isFeatureError(ErrorCode.SCHEMA_MISMATCH)).toBe(false);
+    });
+  });
+
+  describe('isExpressionError', () => {
+    it('should return true for expression error codes', () => {
+      expect(isExpressionError(ErrorCode.PARSE_ERROR)).toBe(true);
+      expect(isExpressionError(ErrorCode.UNKNOWN_FUNCTION)).toBe(true);
+      expect(isExpressionError(ErrorCode.TYPE_MISMATCH)).toBe(true);
+      expect(isExpressionError(ErrorCode.UNKNOWN_FIELD)).toBe(true);
+    });
+
+    it('should return false for non-expression error codes', () => {
+      expect(isExpressionError(ErrorCode.INVALID_JSON)).toBe(false);
+      expect(isExpressionError(ErrorCode.CYCLE_DETECTED)).toBe(false);
+      expect(isExpressionError(ErrorCode.UNSUPPORTED_FUNCTION_NODE)).toBe(false);
+      expect(isExpressionError(ErrorCode.SCHEMA_MISMATCH)).toBe(false);
+    });
+  });
+
+  describe('Integration: ErrorCollector workflow', () => {
+    it('should support typical expression parsing workflow', () => {
+      const collector = new ErrorCollector();
+
+      // Simulate collecting errors during parsing
+      collector.add(new CompilationError('Unknown variable', ErrorCode.UNKNOWN_FIELD));
+      collector.add(new CompilationError('Type mismatch', ErrorCode.TYPE_MISMATCH));
+
+      // Check if any errors were collected
+      expect(collector.hasErrors()).toBe(true);
+
+      // Throw all errors at once
+      expect(() => collector.throwIfErrors()).toThrow();
+      try {
+        collector.throwIfErrors();
+      } catch (e) {
+        expect(isCompilationError(e)).toBe(true);
+        if (e instanceof CompilationError) {
+          expect(e.message).toContain('2 compilation errors');
+        }
+      }
+    });
+
+    it('should support batched validation then clean throw', () => {
+      const collector = new ErrorCollector();
+
+      const location1: SourceLocation = { nodeName: 'Node1', field: 'expression' };
+      const location2: SourceLocation = { nodeName: 'Node2', field: 'expression' };
+
+      collector.add(new CompilationError('Invalid syntax', ErrorCode.PARSE_ERROR, location1));
+      collector.add(
+        new CompilationError('Unknown function', ErrorCode.UNKNOWN_FUNCTION, location2),
+      );
+
+      expect(collector.hasErrors()).toBe(true);
+
+      // Should throw with aggregated message
+      expect(() => collector.throwIfErrors()).toThrow('2 compilation errors');
+    });
+  });
+});