@divmain/jdm-asm 0.2.0

package/tests/integration/sub-decisions.test.ts

@@ -0,0 +1,108 @@
+/**
+ * Sub-Decision Tests
+ *
+ * Test suite for sub-decision nodes (multiple decision nodes in a single graph),
+ * organized by complexity:
+ * - Basic: Simple parent-child relationships
+ * - Simple Multi: 3-5 decision nodes
+ * - Complex Multi: 5+ decision nodes
+ *
+ * Sub-decisions allow decomposition of complex logic into reusable decision components.
+ */
+
+import { describe, it } from 'vitest';
+import { readFileSync } from 'fs';
+import { runSimpleCompatibilityTest, type SimpleTestConfig } from '../helpers/test-harness';
+
+/**
+ * Load a test fixture from file
+ */
+function loadFixture(filePath: string): string {
+  const content = readFileSync(filePath, 'utf-8');
+  return content;
+}
+
+/**
+ * Load a complete test configuration including input and expected values
+ */
+function loadTestWithFixture(
+  fixturePath: string,
+  input?: Record<string, unknown>,
+  expected?: Record<string, unknown>,
+  unsupported?: string[],
+): SimpleTestConfig {
+  const jdm = loadFixture(fixturePath);
+  return {
+    name: fixturePath.split('/').pop() || 'unknown',
+    jdm,
+    input,
+    expected,
+    unsupported,
+  };
+}
+
+describe('Sub-Decision Nodes', () => {
+  // Basic Sub-Decisions
+  describe('Basic Sub-Decisions', () => {
+    const testDir = 'test-data/sub-decisions/basic';
+
+    describe('Parent-Child Relationships', () => {
+      // Tests with simple decision node hierarchies
+
+      it('should evaluate basic parent-child sub-decisions', async () => {
+        const test = loadTestWithFixture(
+          `${testDir}/$nodes-parent.json`,
+          {
+            input: 42,
+          },
+          {},
+        );
+        await runSimpleCompatibilityTest(test);
+      });
+    });
+
+    describe('Decision Reuse', () => {
+      // Tests demonstrating decision node reuse across the graph
+
+      it('should reuse decision nodes efficiently', async () => {
+        const test = loadTestWithFixture(
+          'test-data/sub-decisions/diamond/diamond-pattern.json',
+          {
+            input: 42,
+          },
+          {},
+        );
+        await runSimpleCompatibilityTest(test);
+      });
+    });
+  });
+
+  // Complex Multi-Decision Scenarios
+  describe('Complex Multi-Decisions (5+ nodes)', () => {
+    const testDir = 'test-data/sub-decisions/complex-multi';
+
+    // Complex decision graphs with many interconnected decision nodes
+
+    it('should evaluate large decision graphs', async () => {
+      const test = loadTestWithFixture(
+        `${testDir}/linear-chain.json`,
+        {
+          input: 42,
+        },
+        {},
+      );
+      await runSimpleCompatibilityTest(test);
+    });
+
+    it('should maintain performance with many decision nodes', async () => {
+      const test = loadTestWithFixture(
+        `${testDir}/complex-dag.json`,
+        {
+          input: 42,
+        },
+        {},
+      );
+      await runSimpleCompatibilityTest(test);
+    });
+  });
+});

package/tests/integration/switch-nodes.test.ts

@@ -0,0 +1,399 @@
+/**
+ * Switch Node Tests
+ *
+ * Test suite for switch node evaluation, organized by:
+ * - Basic switch nodes (single dispatch)
+ * - Collect mode switch nodes (multiple matches)
+ */
+
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'fs';
+import { runSimpleCompatibilityTest, type SimpleTestConfig } from '../helpers/test-harness';
+
+/**
+ * Load a test fixture from file
+ */
+function loadFixture(filePath: string): string {
+  const content = readFileSync(filePath, 'utf-8');
+  return content;
+}
+
+/**
+ * Load a complete test configuration including input and expected values
+ */
+function loadTestWithFixture(
+  fixturePath: string,
+  input?: Record<string, unknown>,
+  expected?: Record<string, unknown>,
+  unsupported?: string[],
+): SimpleTestConfig {
+  const jdm = loadFixture(fixturePath);
+  return {
+    name: fixturePath.split('/').pop() || 'unknown',
+    jdm,
+    input,
+    expected,
+    unsupported,
+  };
+}
+
+describe('Switch Nodes', () => {
+  // Basic Switch Nodes
+  describe('Basic Switch Nodes', () => {
+    const testDir = 'test-data/switch-nodes/basic';
+
+    describe('Value-based Switching', () => {
+      // Switch based on exact value matches
+
+      it('should evaluate set fee based on type', async () => {
+        const test = loadTestWithFixture(
+          `${testDir}/set-fee.json`,
+          {
+            serviceType: 'premium',
+            duration: 30,
+          },
+          {
+            fee: 50,
+          },
+        );
+        await runSimpleCompatibilityTest(test);
+      });
+    });
+
+    describe('Condition-based Switching', () => {
+      // Switch based on expressions/conditions
+
+      it('should evaluate loan approval decisions', async () => {
+        const test = loadTestWithFixture(
+          `${testDir}/loan-approval.json`,
+          {
+            creditScore: 720,
+            income: 75000,
+            debtToIncomeRatio: 0.35,
+            employmentYears: 5,
+          },
+          {
+            approved: true,
+            interestRate: expect.any(Number),
+          },
+        );
+        await runSimpleCompatibilityTest(test);
+      });
+
+      it('should evaluate account dormancy management', async () => {
+        const test = loadTestWithFixture(
+          `${testDir}/account-dormancy-management.json`,
+          {
+            lastActivityDays: 365,
+            accountType: 'savings',
+            balance: 5000,
+          },
+          {
+            status: expect.any(String),
+            actionRequired: expect.any(String),
+          },
+        );
+        await runSimpleCompatibilityTest(test);
+      });
+
+      it('should evaluate application risk assessment', async () => {
+        const test = loadTestWithFixture(
+          `${testDir}/application-risk-assessment.json`,
+          {
+            applicantScore: 85,
+            deviceFingerprint: 'trusted',
+            ipReputation: 'clean',
+            transactionHistory: 'clean',
+          },
+          {
+            riskLevel: expect.any(String),
+            fraudScore: expect.any(Number),
+          },
+        );
+        await runSimpleCompatibilityTest(test);
+      });
+    });
+
+    describe('Routing & Workflow Selection', () => {
+      // Switch-based routing scenarios
+
+      it('should evaluate shipping carrier selection', async () => {
+        const test = loadTestWithFixture(
+          `${testDir}/shipping-carrier-selector.json`,
+          {
+            destination: 'international',
+            weight: 5.5,
+            priority: 'express',
+            serviceLevel: 'premium',
+          },
+          {
+            selectedCarrier: expect.any(String),
+            estimatedDelivery: expect.any(String),
+          },
+        );
+        await runSimpleCompatibilityTest(test);
+      });
+
+      it('should evaluate seller approval workflow', async () => {
+        const test = loadTestWithFixture(
+          `${testDir}/seller-approval-workflow.json`,
+          {
+            sellerRating: 4.8,
+            totalSales: 10000,
+            category: 'electronics',
+            verificationStatus: 'verified',
+          },
+          {
+            approvalStatus: expect.any(String),
+            reviewPath: expect.any(String),
+          },
+        );
+        await runSimpleCompatibilityTest(test);
+      });
+
+      it('should evaluate order consolidation system', async () => {
+        const test = loadTestWithFixture(
+          `${testDir}/order-consolidation-system.json`,
+          {
+            orderId: 'ORD-123',
+            items: [
+              { productId: 'P1', warehouse: 'W1', quantity: 2 },
+              { productId: 'P2', warehouse: 'W2', quantity: 1 },
+            ],
+          },
+          {
+            consolidationStrategy: expect.any(String),
+            shippingFrom: expect.any(Array),
+          },
+        );
+        await runSimpleCompatibilityTest(test);
+      });
+
+      it('should evaluate last mile delivery assignment', async () => {
+        const test = loadTestWithFixture(
+          `${testDir}/last-mile-delivery-assignment.json`,
+          {
+            deliveryAddress: {
+              zipCode: '12345',
+              zone: 'urban',
+              access: 'standard',
+            },
+            packageSize: 'medium',
+            timeWindow: 'morning',
+          },
+          {
+            assignedDriver: expect.any(String),
+            estimatedETA: expect.any(String),
+          },
+        );
+        await runSimpleCompatibilityTest(test);
+      });
+    });
+
+    describe('Clinical & Healthcare Workflows', () => {
+      // Medical decision routing
+
+      it('should evaluate clinical pathway selection', async () => {
+        const test = loadTestWithFixture(
+          `${testDir}/clinical-pathway-selection.json`,
+          {
+            patientCondition: 'diabetes',
+            severity: 'type 2',
+            comorbidities: ['hypertension'],
+            age: 55,
+          },
+          {
+            recommendedPathway: expect.any(String),
+            requiredSpecialists: expect.any(Array),
+          },
+        );
+        await runSimpleCompatibilityTest(test);
+      });
+
+      it('should evaluate insurance prior authorization', async () => {
+        const test = loadTestWithFixture(
+          `${testDir}/insurance-prior-authorization.json`,
+          {
+            procedure: 'MRI scan',
+            diagnosis: 'headache',
+            medicalNecessity: true,
+            alternativeTried: false,
+          },
+          {
+            authorizationRequired: expect.any(Boolean),
+            reviewLevel: expect.any(String),
+          },
+        );
+        await runSimpleCompatibilityTest(test);
+      });
+    });
+
+    describe('Business Process Triggers', () => {
+      // Event-based switching
+
+      it('should evaluate online check-in eligibility', async () => {
+        const test = loadTestWithFixture(
+          `${testDir}/online-checkin-eligibility.json`,
+          {
+            flightDate: '2026-01-15',
+            bookingClass: 'economy',
+            hasSpecialAssistance: false,
+            visaStatus: 'valid',
+          },
+          {
+            eligibleForOnlineCheckin: expect.any(Boolean),
+            checkinTimeWindow: expect.any(String),
+          },
+        );
+        await runSimpleCompatibilityTest(test);
+      });
+
+      it('should evaluate tax exemption eligibility', async () => {
+        const test = loadTestWithFixture(
+          `${testDir}/tax-exemption.json`,
+          {
+            entityType: 'nonprofit',
+            country: 'US',
+            documentationStatus: 'complete',
+            annualRevenue: 500000,
+          },
+          {
+            taxExempt: expect.any(Boolean),
+            exemptionType: expect.any(String),
+          },
+        );
+        await runSimpleCompatibilityTest(test);
+      });
+
+      it('should evaluate warehouse cross-docking', async () => {
+        const test = loadTestWithFixture(
+          `${testDir}/warehouse-cross-docking.json`,
+          {
+            productCategory: 'perishable',
+            inboundCarrier: 'express',
+            outboundCarrier: 'same',
+            timeWindow: 4,
+          },
+          {
+            crossDockRequired: expect.any(Boolean),
+            processingArea: expect.any(String),
+          },
+        );
+        await runSimpleCompatibilityTest(test);
+      });
+
+      it('should evaluate cellular data rollover system', async () => {
+        const test = loadTestWithFixture(
+          `${testDir}/cellular-data-rollover-system.json`,
+          {
+            planType: 'unlimited',
+            currentDataUsage: 25,
+            billingCycleDay: 28,
+          },
+          {
+            rolloverEligible: expect.any(Boolean),
+            rolledOverAmount: expect.any(Number),
+          },
+        );
+        await runSimpleCompatibilityTest(test);
+      });
+    });
+
+    describe('Complex Switch Scenarios', () => {
+      // Multiple switches and nested logic
+
+      it('should evaluate multi-switch system', async () => {
+        const test = loadTestWithFixture(
+          `${testDir}/multi-switch.json`,
+          {
+            order: {
+              value: 1500,
+              category: 'electronics',
+              customer: {
+                tier: 'gold',
+                location: 'US',
+              },
+            },
+          },
+          {
+            shippingMethod: expect.any(String),
+            discount: expect.any(Number),
+            handlingPriority: expect.any(String),
+          },
+        );
+        await runSimpleCompatibilityTest(test);
+      });
+    });
+
+    describe('Performance & Edge Cases', () => {
+      // Performance benchmarks and boundary conditions
+
+      it('should evaluate basic switch performance test', async () => {
+        const test = loadTestWithFixture(
+          `${testDir}/switch-performance.json`,
+          {
+            input: 'value1',
+          },
+          {
+            input: 'value1',
+          },
+        );
+        await runSimpleCompatibilityTest(test);
+      });
+
+      it('should evaluate switch performance test 2', async () => {
+        const test = loadTestWithFixture(
+          `${testDir}/switch-performance-2.json`,
+          {
+            input: 'value2',
+          },
+          {
+            input: 'value2',
+          },
+        );
+        await runSimpleCompatibilityTest(test);
+      });
+
+      it('should use default case when no match', async () => {
+        const test = loadTestWithFixture(
+          `${testDir}/../default-cases/switch-with-default.json`,
+          {
+            color: 'blue',
+          },
+          {
+            result: 'default',
+          },
+        );
+        await runSimpleCompatibilityTest(test);
+      });
+
+      it('should handle no matching cases', async () => {
+        const test = loadTestWithFixture(
+          `${testDir}/../default-cases/switch-with-default.json`,
+          {
+            color: 'yellow',
+          },
+          {
+            result: 'matched',
+          },
+        );
+        await runSimpleCompatibilityTest(test);
+      });
+    });
+
+    describe('Simple Switch Test', () => {
+      it('should evaluate basic switch node', async () => {
+        const test = loadTestWithFixture(
+          `${testDir}/switch-node.json`,
+          {
+            mode: 'mode1',
+          },
+          {
+            path3: true,
+          },
+        );
+        await runSimpleCompatibilityTest(test);
+      });
+    });
+  });
+});

package/tests/integration/unary-or-matching.test.ts

@@ -0,0 +1,53 @@
+import { describe, it } from 'vitest';
+import { runSimpleCompatibilityTest } from '../helpers/test-harness';
+
+describe('Unary OR Matching', () => {
+  it('should match comma-separated values in decision table unary cells', async () => {
+    const jdm = {
+      tests: [
+        { input: { status: 'excellent' }, output: { tier: 'gold' } },
+        { input: { status: 'good' }, output: { tier: 'gold' } },
+        { input: { status: 'fair' }, output: { tier: 'bronze' } },
+      ],
+      nodes: [
+        {
+          type: 'inputNode',
+          id: 'input',
+          name: 'Request',
+          position: { x: 100, y: 100 },
+          content: {},
+        },
+        {
+          type: 'decisionTableNode',
+          id: 'decision',
+          name: 'Test',
+          position: { x: 300, y: 100 },
+          content: {
+            hitPolicy: 'first',
+            rules: [
+              {
+                _id: 'r1',
+                i1: "'excellent', 'good'",
+                o1: '"gold"',
+              },
+              {
+                _id: 'r2',
+                i1: '',
+                o1: '"bronze"',
+              },
+            ],
+            inputs: [{ id: 'i1', name: 'Status', field: 'status' }],
+            outputs: [{ id: 'o1', name: 'Tier', field: 'tier' }],
+            passThrough: false,
+          },
+        },
+      ],
+      edges: [{ id: 'e1', sourceId: 'input', targetId: 'decision' }],
+    };
+
+    await runSimpleCompatibilityTest({
+      name: 'unary-or-matching',
+      jdm,
+    });
+  });
+});