@longarc/mdash 3.1.1 → 3.1.3

package/src/context/__tests__/integration.test.ts

@@ -0,0 +1,356 @@
+/**
+ * mdash v3.1 - Context Module Integration Tests
+ * Validates the Caret → mdash merge
+ * 
+ * @version 3.1.0
+ */
+
+import { describe, it, expect, beforeAll } from 'vitest';
+
+// These imports validate the merge structure
+import type {
+  ContextFragment,
+  InfluenceBudget,
+  InfluenceConstraint,
+  Manifold,
+  Outcome,
+  Hash,
+  FragmentId,
+  Seal,
+  Timestamp,
+  Attribution,
+  MdashActionCode,
+} from '../types.js';
+
+import {
+  isHash,
+  isFragmentId,
+  isTimestamp,
+  isTrustLevel,
+  isTokenCount,
+  isContextFragment,
+  isValidInfluenceBudget,
+  sumInfluence,
+  isMdashActionCode,
+  DEFAULT_TRUST_LEVELS,
+  DEFAULT_MCCA_BUDGET,
+} from '../types.js';
+
+import {
+  maxAge,
+  notBefore,
+  notAfter,
+  allowDomains,
+  requireTrust,
+  requireSignature,
+  requireInfluence,
+  requireMCCA,
+  VERSION,
+  FORMERLY,
+} from '../index.js';
+
+describe('Context Module Integration', () => {
+  
+  describe('Version Info', () => {
+    it('exports correct version', () => {
+      expect(VERSION).toBe('3.1.0');
+    });
+    
+    it('acknowledges Caret heritage', () => {
+      expect(FORMERLY).toBe('Caret v0.2.0');
+    });
+  });
+  
+  describe('Type Guards', () => {
+    it('validates Hash format', () => {
+      const validHash = 'a'.repeat(64);
+      const invalidHash = 'short';
+      
+      expect(isHash(validHash)).toBe(true);
+      expect(isHash(invalidHash)).toBe(false);
+    });
+    
+    it('validates FragmentId format (UUID v4)', () => {
+      const validId = '123e4567-e89b-4d3c-8456-426614174000';
+      const invalidId = 'not-a-uuid';
+      
+      expect(isFragmentId(validId)).toBe(true);
+      expect(isFragmentId(invalidId)).toBe(false);
+    });
+    
+    it('validates Timestamp format (ISO-8601)', () => {
+      const validTs = '2026-01-28T12:00:00.000Z';
+      const invalidTs = 'not-a-date';
+      
+      expect(isTimestamp(validTs)).toBe(true);
+      expect(isTimestamp(invalidTs)).toBe(false);
+    });
+    
+    it('validates TrustLevel range (0-100)', () => {
+      expect(isTrustLevel(50)).toBe(true);
+      expect(isTrustLevel(0)).toBe(true);
+      expect(isTrustLevel(100)).toBe(true);
+      expect(isTrustLevel(-1)).toBe(false);
+      expect(isTrustLevel(101)).toBe(false);
+    });
+    
+    it('validates MdashActionCode', () => {
+      expect(isMdashActionCode('INVOKE')).toBe(true);
+      expect(isMdashActionCode('APPROVE')).toBe(true);
+      expect(isMdashActionCode('ATTEST')).toBe(true);
+      expect(isMdashActionCode('REVOKE')).toBe(true);
+      expect(isMdashActionCode('CHECKPOINT')).toBe(true);
+      expect(isMdashActionCode('ESCALATE')).toBe(true);
+      expect(isMdashActionCode('TERMINATE')).toBe(true);
+      expect(isMdashActionCode('INVALID')).toBe(false);
+    });
+  });
+  
+  describe('MCCA Influence Budget', () => {
+    it('exports default MCCA budget', () => {
+      expect(DEFAULT_MCCA_BUDGET).toEqual({
+        system: 0.45,
+        user: 0.30,
+        environment: 0.15,
+        assistant: 0.10,
+      });
+    });
+    
+    it('validates compliant budget', () => {
+      const compliant: InfluenceBudget = {
+        system: 0.45,
+        user: 0.30,
+        environment: 0.15,
+        assistant: 0.10,
+      };
+      
+      expect(isValidInfluenceBudget(compliant)).toBe(true);
+      expect(sumInfluence(compliant)).toBeCloseTo(1.0);
+    });
+    
+    it('rejects non-compliant budget (system too low)', () => {
+      const nonCompliant: InfluenceBudget = {
+        system: 0.30, // Below 0.40 minimum
+        user: 0.40,
+        environment: 0.20,
+        assistant: 0.10,
+      };
+      
+      expect(isValidInfluenceBudget(nonCompliant)).toBe(false);
+    });
+    
+    it('rejects non-compliant budget (user too high)', () => {
+      const nonCompliant: InfluenceBudget = {
+        system: 0.40,
+        user: 0.40, // Above 0.35 maximum
+        environment: 0.10,
+        assistant: 0.10,
+      };
+      
+      expect(isValidInfluenceBudget(nonCompliant)).toBe(false);
+    });
+    
+    it('rejects non-compliant budget (does not sum to 1.0)', () => {
+      const nonCompliant: InfluenceBudget = {
+        system: 0.50,
+        user: 0.30,
+        environment: 0.15,
+        assistant: 0.10,
+      };
+      
+      expect(sumInfluence(nonCompliant)).toBeCloseTo(1.05);
+      expect(isValidInfluenceBudget(nonCompliant)).toBe(false);
+    });
+  });
+  
+  describe('Constraint Builders', () => {
+    it('builds maxAge constraint', () => {
+      const constraint = maxAge(3600000);
+      
+      expect(constraint.kind).toBe('time');
+      expect(constraint.max_age_ms).toBe(3600000);
+    });
+    
+    it('builds notBefore constraint', () => {
+      const ts = '2026-01-28T00:00:00.000Z';
+      const constraint = notBefore(ts);
+      
+      expect(constraint.kind).toBe('time');
+      expect(constraint.not_before).toBe(ts);
+    });
+    
+    it('builds notAfter constraint', () => {
+      const ts = '2026-12-31T23:59:59.999Z';
+      const constraint = notAfter(ts);
+      
+      expect(constraint.kind).toBe('time');
+      expect(constraint.not_after).toBe(ts);
+    });
+    
+    it('builds allowDomains constraint', () => {
+      const constraint = allowDomains('mdash.sh', 'longarcstudios.com');
+      
+      expect(constraint.kind).toBe('scope');
+      expect(constraint.allowed_domains).toEqual(['mdash.sh', 'longarcstudios.com']);
+    });
+    
+    it('builds requireTrust constraint', () => {
+      const constraint = requireTrust(70);
+      
+      expect(constraint.kind).toBe('trust');
+      expect(constraint.minimum_trust).toBe(70);
+    });
+    
+    it('builds requireSignature constraint', () => {
+      const constraint = requireSignature(['signer1', 'signer2']);
+      
+      expect(constraint.kind).toBe('signature');
+      expect(constraint.required).toBe(true);
+      expect(constraint.allowed_signers).toEqual(['signer1', 'signer2']);
+    });
+    
+    it('builds requireInfluence constraint', () => {
+      const budget: InfluenceBudget = {
+        system: 0.45,
+        user: 0.30,
+        environment: 0.15,
+        assistant: 0.10,
+      };
+      const constraint = requireInfluence(budget, 'strict');
+      
+      expect(constraint.kind).toBe('influence');
+      expect(constraint.budget).toEqual(budget);
+      expect(constraint.enforcement).toBe('strict');
+    });
+    
+    it('builds requireMCCA constraint with defaults', () => {
+      const constraint = requireMCCA();
+      
+      expect(constraint.kind).toBe('influence');
+      expect(constraint.budget.system).toBe(0.45);
+      expect(constraint.budget.user).toBe(0.30);
+      expect(constraint.budget.environment).toBe(0.15);
+      expect(constraint.budget.assistant).toBe(0.10);
+      expect(constraint.enforcement).toBe('strict');
+    });
+    
+    it('builds requireMCCA constraint with overrides', () => {
+      const constraint = requireMCCA({ system: 0.50, user: 0.25 });
+      
+      expect(constraint.budget.system).toBe(0.50);
+      expect(constraint.budget.user).toBe(0.25);
+      expect(constraint.budget.environment).toBe(0.15);
+      expect(constraint.budget.assistant).toBe(0.10);
+    });
+  });
+  
+  describe('Trust Levels', () => {
+    it('exports default trust levels', () => {
+      expect(DEFAULT_TRUST_LEVELS.system).toBe(100);
+      expect(DEFAULT_TRUST_LEVELS.operator).toBe(90);
+      expect(DEFAULT_TRUST_LEVELS.user).toBe(70);
+      expect(DEFAULT_TRUST_LEVELS.derived).toBe(60);
+      expect(DEFAULT_TRUST_LEVELS.agent).toBe(50);
+      expect(DEFAULT_TRUST_LEVELS.external).toBe(30);
+    });
+  });
+  
+  describe('ContextFragment Validation', () => {
+    it('validates complete fragment structure', () => {
+      const validFragment = {
+        id: '123e4567-e89b-4d3c-8456-426614174000',
+        hash: 'a'.repeat(64),
+        content: {
+          type: 'text',
+          data: 'Hello, world!',
+          token_count: 3,
+        },
+        provenance: {
+          source: 'test://example',
+          attribution: 'system',
+          trust_level: 100,
+          timestamp: '2026-01-28T12:00:00.000Z',
+          parent_hash: null,
+        },
+        sealed_at: '2026-01-28T12:00:00.000Z',
+        seal: 'seal-value',
+        constraints: [],
+        version: 'v3.1',
+      };
+      
+      expect(isContextFragment(validFragment)).toBe(true);
+    });
+    
+    it('rejects fragment with invalid hash', () => {
+      const invalidFragment = {
+        id: '123e4567-e89b-4d3c-8456-426614174000',
+        hash: 'short',
+        content: {},
+        provenance: {},
+        sealed_at: '2026-01-28T12:00:00.000Z',
+        seal: 'seal',
+        constraints: [],
+        version: 'v3.1',
+      };
+      
+      expect(isContextFragment(invalidFragment)).toBe(false);
+    });
+  });
+});
+
+describe('Security Invariants', () => {
+  
+  describe('INV-005: MCCA bounds are hard limits', () => {
+    it('system influence must be >= 0.40', () => {
+      const lowSystem: InfluenceBudget = {
+        system: 0.39,
+        user: 0.31,
+        environment: 0.20,
+        assistant: 0.10,
+      };
+      
+      expect(isValidInfluenceBudget(lowSystem)).toBe(false);
+    });
+    
+    it('user influence must be <= 0.35', () => {
+      const highUser: InfluenceBudget = {
+        system: 0.40,
+        user: 0.36,
+        environment: 0.14,
+        assistant: 0.10,
+      };
+      
+      expect(isValidInfluenceBudget(highUser)).toBe(false);
+    });
+    
+    it('environment influence must be <= 0.20', () => {
+      const highEnv: InfluenceBudget = {
+        system: 0.40,
+        user: 0.28,
+        environment: 0.22,
+        assistant: 0.10,
+      };
+      
+      expect(isValidInfluenceBudget(highEnv)).toBe(false);
+    });
+    
+    it('assistant influence must be <= 0.25', () => {
+      const highAst: InfluenceBudget = {
+        system: 0.40,
+        user: 0.23,
+        environment: 0.11,
+        assistant: 0.26,
+      };
+      
+      expect(isValidInfluenceBudget(highAst)).toBe(false);
+    });
+  });
+  
+  describe('INV-008: Tool outputs never become system context', () => {
+    it('tool attribution has lower trust than system', () => {
+      // In the unified model, tool maps to 'external' or environment influence
+      // External trust: 30, System trust: 100
+      expect(DEFAULT_TRUST_LEVELS.external).toBeLessThan(DEFAULT_TRUST_LEVELS.system);
+    });
+  });
+});