@divmain/jdm-asm 0.2.0

package/tests/helpers/test-harness-comparison.ts

@@ -0,0 +1,325 @@
+import { ZenEngine } from '@gorules/zen-engine';
+import type { TSchema } from '@sinclair/typebox';
+import path from 'path';
+import { readFileSync } from 'fs';
+import { compile as compileWasm, type CompilationResult } from '../../src/compiler';
+import { evaluateCompiled, inferSchema } from './test-harness-wasm';
+
+export { compileWasm as compile };
+
+// Find the root directory based on current file location
+const testDataRoot = path.join(process.cwd(), 'test-data');
+
+// Create loader for sub-decision references
+//
+// Test fixtures are organized by feature (sub-decisions/basic, sub-decisions/diamond)
+// and by source (zen-reference for ported tests). Multiple paths allow tests to reference
+// sub-decisions without knowing their exact location.
+const loader = async (key: string): Promise<Buffer> => {
+  const possiblePaths = [
+    path.join(testDataRoot, key),
+    path.join(testDataRoot, 'zen-reference', key),
+    path.join(testDataRoot, 'sub-decisions/basic', key),
+    path.join(testDataRoot, 'sub-decisions/diamond', key),
+    path.join(testDataRoot, 'sub-decisions/complex-multi', key),
+  ];
+
+  for (const filePath of possiblePaths) {
+    try {
+      const content = readFileSync(filePath);
+      return content;
+    } catch {
+      // Try next path
+    }
+  }
+  throw new Error(
+    `Failed to load ${key}: not found in any search path (${possiblePaths.join(', ')})`,
+  );
+};
+
+// Create a new ZenEngine for each test to avoid state issues
+function createZenEngine() {
+  return new ZenEngine({ loader });
+}
+
+/**
+ * Compare actual result against expected, but only check keys present in expected.
+ * This allows actual to have extra fields (e.g., passthrough fields).
+ *
+ * This preserves the behavior of the original assertDeepEqual which only validated
+ * keys that existed in the expected object.
+ */
+function expectPartialMatch(actual: unknown, expected: unknown, message: string): void {
+  if (expected === actual) {
+    return;
+  }
+
+  // Handle matchers
+  if (isAnything(expected)) {
+    return;
+  }
+  if (isAny(expected)) {
+    return;
+  }
+
+  if (typeof expected !== typeof actual) {
+    throw new Error(
+      `${message}: type mismatch (expected ${typeof expected}, got ${typeof actual})`,
+    );
+  }
+
+  if (expected === null || actual === null) {
+    if (expected !== actual) {
+      throw new Error(`${message}: null mismatch`);
+    }
+    return;
+  }
+
+  if (Array.isArray(expected)) {
+    if (!Array.isArray(actual)) {
+      throw new Error(`${message}: expected array, got ${typeof actual}`);
+    }
+    if (expected.length !== actual.length) {
+      throw new Error(`${message}: array length mismatch (${expected.length} vs ${actual.length})`);
+    }
+    for (let i = 0; i < expected.length; i++) {
+      expectPartialMatch(actual[i], expected[i], `${message}[${i}]`);
+    }
+    return;
+  }
+
+  if (typeof expected === 'object') {
+    if (typeof actual !== 'object') {
+      throw new Error(`${message}: expected object, got ${typeof actual}`);
+    }
+    const expectedKeys = Object.keys(expected);
+
+    for (const key of expectedKeys) {
+      const expectedValue = (expected as Record<string, unknown>)[key];
+      if (isAnything(expectedValue) || isAny(expectedValue)) {
+        // If expected is anything or any(Constructor), we don't need to check if the key exists in actual
+        continue;
+      }
+      if (!(key in (actual as object))) {
+        throw new Error(`${message}: missing key "${key}"`);
+      }
+      expectPartialMatch(
+        (actual as Record<string, unknown>)[key],
+        expectedValue,
+        `${message}.${key}`,
+      );
+    }
+    return;
+  }
+
+  // Primitive comparison
+  if (expected !== actual) {
+    // Check if this looks like a timestamp comparison (Unix timestamps are large numbers)
+    const expectedNum = typeof expected === 'number';
+    const actualNum = typeof actual === 'number';
+    const isTimestamp =
+      expectedNum && actualNum && expected > 1_000_000_000 && actual > 1_000_000_000;
+
+    if (isTimestamp) {
+      // Skip exact timestamp comparison - just verify both are timestamps
+      return;
+    }
+
+    // For floating point numbers, allow small precision differences
+    // This handles differences in the last digits due to floating point representation
+    if (expectedNum && actualNum) {
+      const relativeError =
+        Math.abs((expected as number) - (actual as number)) /
+        Math.max(Math.abs(expected as number), Math.abs(actual as number), 1e-15);
+      if (relativeError < 1e-14) {
+        // Within floating point tolerance
+        return;
+      }
+    }
+
+    throw new Error(`${message}: value mismatch (expected ${expected}, got ${actual})`);
+  }
+}
+
+function isAnything(value: unknown): boolean {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    '_is_Anything' in (value as Record<string, unknown>)
+  );
+}
+
+function isAny(value: unknown): boolean {
+  return (
+    typeof value === 'object' && value !== null && '_is_Any' in (value as Record<string, unknown>)
+  );
+}
+
+/**
+ * Run test against both zen-engine and jdm-asm
+ */
+export interface TestConfig {
+  skipZen?: boolean; // Skip zen-engine testing
+  name: string;
+  jdm: string | object; // JDM JSON content (string or object)
+  inputSchema: TSchema; // TypeBox schema for input
+  outputSchema: TSchema; // TypeBox schema for output
+  input?: Record<string, unknown>; // Optional - use tests array from JDM if not provided
+  expected?: Record<string, unknown> | unknown[]; // Optional - use tests array from JDM if not provided. Can be array for COLLECT hit policies.
+  unsupported?: string[]; // Features not yet implemented
+}
+
+/**
+ * Simplified test config for tests that don't need schema.
+ * Schemas are inferred from input/expected shapes.
+ */
+export interface SimpleTestConfig {
+  skipZen?: boolean; // Skip zen-engine testing
+  name: string;
+  jdm: string | object;
+  input?: Record<string, unknown>; // Optional - use tests array from JDM if not provided
+  expected?: Record<string, unknown> | unknown[]; // Optional - use tests array from JDM if not provided. Can be array for COLLECT hit policies.
+  unsupported?: string[];
+}
+
+export async function runCompatibilityTest(config: TestConfig): Promise<void> {
+  // Skip if tests reference unsupported features
+  if (config.unsupported?.length) {
+    console.log(`⏭️  Skipping ${config.name} (unsupported: ${config.unsupported.join(', ')})`);
+    return;
+  }
+
+  // Convert string JDM to object if needed
+  const jdmContent = typeof config.jdm === 'string' ? JSON.parse(config.jdm) : config.jdm;
+
+  type TestCase = {
+    input: Record<string, unknown>;
+    output: Record<string, unknown>;
+  };
+
+  type JDMWithTests = typeof jdmContent & { tests?: TestCase[] };
+
+  const jdm = jdmContent as JDMWithTests;
+
+  // If JDM has embedded tests array, use those
+  const testCases = jdm.tests
+    ? jdm.tests
+    : config.input && config.expected
+      ? [{ input: config.input, output: config.expected }]
+      : [];
+
+  if (testCases.length === 0) {
+    console.log(`⏭️  Skipping ${config.name} (no test cases)`);
+    return;
+  }
+
+  // Run with zen-engine (golden standard) - create fresh engine to avoid state issues
+  const zenDecision = config.skipZen ? null : createZenEngine().createDecision(jdm);
+
+  // WASM compilation takes ~250ms per decision, so compiling once and reusing the module
+  // for all test cases dramatically speeds up test execution (seconds vs minutes).
+  let compiled: CompilationResult | null = null;
+  let compilationError: Error | null = null;
+  try {
+    compiled = await compileWasm({
+      jdm: config.jdm as any,
+      inputSchema: config.inputSchema,
+      outputSchema: config.outputSchema,
+      debug: true,
+    });
+    // Debug: dump generated code for specific tests
+    if (config.name.includes('customer-eligibility') && compiled.assemblyScript) {
+      require('fs').writeFileSync('/tmp/eligibility-debug.ts', compiled.assemblyScript);
+    }
+  } catch (error: unknown) {
+    compilationError = error instanceof Error ? error : new Error(String(error));
+  }
+
+  for (let i = 0; i < testCases.length; i++) {
+    const testCase = testCases[i];
+    const testName = jdm.tests ? `${config.name} [test ${i + 1}/${testCases.length}]` : config.name;
+
+    const zenResult = config.skipZen ? null : await zenDecision!.evaluate(testCase.input);
+
+    // Run with our implementation
+    try {
+      // Handle compilation errors
+      if (compilationError) {
+        const message = compilationError.message;
+        if (message.includes('Function node')) {
+          console.log(`⏭️  Skipping ${testName} (function node not yet supported)`);
+          continue;
+        } else if (message.includes('compile() not yet implemented')) {
+          // Compilation not yet available
+          if (!config.skipZen && zenResult) {
+            expectPartialMatch(
+              zenResult.result,
+              testCase.output,
+              `${testName} - zen-engine mismatch`,
+            );
+          }
+          console.log(`⏭️  Skipping ${testName} (compile() not yet implemented)`);
+          continue;
+        } else {
+          throw compilationError;
+        }
+      }
+
+      const asmResult = await evaluateCompiled(compiled!, testCase.input);
+
+      // Compare results - only check keys that exist in expected output (allows passthrough fields)
+      if (!config.skipZen && zenResult) {
+        expectPartialMatch(zenResult.result, testCase.output, `${testName} - zen-engine mismatch`);
+      }
+      expectPartialMatch(asmResult, testCase.output, `${testName} - jdm-asm mismatch`);
+      console.log(`✅ ${testName}`);
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.includes('Function node')) {
+        console.log(`⏭️  Skipping ${testName} (function node not yet supported)`);
+      } else if (message.includes('compile() not yet implemented')) {
+        // Compilation not yet available
+        if (!config.skipZen && zenResult) {
+          expectPartialMatch(
+            zenResult.result,
+            testCase.output,
+            `${testName} - zen-engine mismatch`,
+          );
+        }
+        console.log(`⏭️  Skipping ${testName} (compile() not yet implemented)`);
+      } else {
+        throw error;
+      }
+    }
+  }
+}
+
+/**
+ * Convenience wrapper for tests without explicit schemas.
+ * Infers schemas from the input/expected shapes (less type-safe).
+ */
+export async function runSimpleCompatibilityTest(config: SimpleTestConfig): Promise<void> {
+  const inputSchema = inferSchema(config.input || {});
+  const outputSchema = inferSchema(config.expected || {});
+
+  return runCompatibilityTest({
+    ...config,
+    inputSchema,
+    outputSchema,
+  });
+}
+
+/**
+ * Test helpers for matching any value
+ */
+export const matchers = {
+  /**
+   * Matches any value (like expect.anything())
+   */
+  anything: () => ({ _is_Anything: true }) as const,
+
+  /**
+   * Matches any value of the given constructor type (like expect.any(Constructor))
+   */
+  any: (_: unknown) => ({ _is_Any: true }) as const,
+};