@divmain/jdm-asm 0.2.1 → 0.2.3

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

@@ -1,325 +0,0 @@
-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,
-};