tractatus/tests/unit/BoundaryEnforcer.test.js

/**
 * Unit Tests for BoundaryEnforcer
 * Tests Tractatus philosophical boundaries (12.1-12.7) enforcement
 */

const enforcer = require('../../src/services/BoundaryEnforcer.service');

describe('BoundaryEnforcer', () => {
  beforeEach(() => {
    // Enforcer is a singleton instance
  });

  describe('Tractatus 12.1 - Values Boundary', () => {
    test('should require human judgment for values decisions', () => {
      const decision = {
        type: 'values_change',
        description: 'Change privacy policy to prioritize convenience',
        domain: 'values'
      };

      const result = enforcer.enforce(decision);

      expect(result.allowed).toBe(false);
      expect(result.human_required).toBe(true);
      expect(result.boundary).toBe('VALUES');
      expect(result.tractatus_section).toBe('12.1');
      expect(result.reason).toContain('Values cannot be automated');
    });

    test('should block AI from making values trade-offs', () => {
      const decision = {
        type: 'trade_off',
        description: 'Trade user privacy for performance',
        involves_values: true
      };

      const result = enforcer.enforce(decision);

      expect(result.allowed).toBe(false);
      expect(result.human_required).toBe(true);
    });

    test('should allow AI to verify alignment with existing values', () => {
      const decision = {
        type: 'verify_alignment',
        description: 'Check if action aligns with privacy values',
        domain: 'verification'
      };

      const result = enforcer.enforce(decision);

      expect(result.allowed).toBe(true);
      expect(result.human_required).toBe(false);
    });
  });

  describe('Tractatus 12.2 - Innovation Boundary', () => {
    test('should require human judgment for novel architectural decisions', () => {
      const decision = {
        type: 'architecture',
        description: 'Propose entirely new approach to authentication',
        novelty: 'high',
        domain: 'innovation'
      };

      const result = enforcer.enforce(decision);

      expect(result.allowed).toBe(false);
      expect(result.human_required).toBe(true);
      expect(result.boundary).toBe('INNOVATION');
    });

    test('should allow AI to facilitate innovation within approved patterns', () => {
      const decision = {
        type: 'optimization',
        description: 'Optimize existing authentication flow',
        novelty: 'low'
      };

      const result = enforcer.enforce(decision);

      expect(result.allowed).toBe(true);
    });
  });

  describe('Tractatus 12.3 - Wisdom Boundary', () => {
    test('should require human judgment for strategic direction changes', () => {
      const decision = {
        type: 'strategic_direction',
        description: 'Shift product focus to new market segment',
        domain: 'wisdom'
      };

      const result = enforcer.enforce(decision);

      expect(result.allowed).toBe(false);
      expect(result.human_required).toBe(true);
      expect(result.boundary).toBe('WISDOM');
      expect(result.tractatus_section).toBe('12.3');
    });

    test('should allow AI to support wisdom with data analysis', () => {
      const decision = {
        type: 'data_analysis',
        description: 'Analyze market trends to inform strategy',
        domain: 'support'
      };

      const result = enforcer.enforce(decision);

      expect(result.allowed).toBe(true);
    });
  });

  describe('Tractatus 12.4 - Purpose Boundary', () => {
    test('should require human judgment for defining project purpose', () => {
      const decision = {
        type: 'define_purpose',
        description: 'Define the core mission of the project',
        domain: 'purpose'
      };

      const result = enforcer.enforce(decision);

      expect(result.allowed).toBe(false);
      expect(result.human_required).toBe(true);
      expect(result.boundary).toBe('PURPOSE');
    });

    test('should allow AI to preserve existing purpose in implementations', () => {
      const decision = {
        type: 'implementation',
        description: 'Implement feature according to stated purpose',
        domain: 'preservation'
      };

      const result = enforcer.enforce(decision);

      expect(result.allowed).toBe(true);
    });
  });

  describe('Tractatus 12.5 - Meaning Boundary', () => {
    test('should require human judgment for determining significance', () => {
      const decision = {
        type: 'significance',
        description: 'Decide what makes this project meaningful',
        domain: 'meaning'
      };

      const result = enforcer.enforce(decision);

      expect(result.allowed).toBe(false);
      expect(result.human_required).toBe(true);
      expect(result.boundary).toBe('MEANING');
    });

    test('should allow AI to recognize patterns related to meaning', () => {
      const decision = {
        type: 'pattern_recognition',
        description: 'Identify user engagement patterns',
        domain: 'recognition'
      };

      const result = enforcer.enforce(decision);

      expect(result.allowed).toBe(true);
    });
  });

  describe('Tractatus 12.6 - Agency Boundary', () => {
    test('should require human judgment for decisions affecting human agency', () => {
      const decision = {
        type: 'agency_affecting',
        description: 'Automatically approve user requests',
        domain: 'agency',
        affects_human_choice: true
      };

      const result = enforcer.enforce(decision);

      expect(result.allowed).toBe(false);
      expect(result.human_required).toBe(true);
      expect(result.boundary).toBe('AGENCY');
      expect(result.tractatus_section).toBe('12.6');
    });

    test('should allow AI to respect human agency through notification', () => {
      const decision = {
        type: 'notify',
        description: 'Notify user of available options',
        respects_agency: true
      };

      const result = enforcer.enforce(decision);

      expect(result.allowed).toBe(true);
    });
  });

  describe('Boundary Detection', () => {
    test('should detect values-related keywords in decisions', () => {
      const decision = {
        description: 'Change our core values to prioritize speed'
      };

      const result = enforcer.enforce(decision);

      expect(result.human_required).toBe(true);
      expect(result.boundary).toBe('VALUES');
    });

    test('should detect wisdom-related keywords', () => {
      const decision = {
        description: 'Make strategic decision about company direction'
      };

      const result = enforcer.enforce(decision);

      expect(result.human_required).toBe(true);
      expect(['WISDOM', 'VALUES']).toContain(result.boundary);
    });

    test('should detect agency-affecting keywords', () => {
      const decision = {
        description: 'Remove user choice and automate approval'
      };

      const result = enforcer.enforce(decision);

      expect(result.human_required).toBe(true);
      expect(result.boundary).toBe('AGENCY');
    });
  });

  describe('Multi-Boundary Violations', () => {
    test('should detect when decision crosses multiple boundaries', () => {
      const decision = {
        type: 'major_change',
        description: 'Redefine project purpose and change core values',
        domain: ['purpose', 'values']
      };

      const result = enforcer.enforce(decision);

      expect(result.allowed).toBe(false);
      expect(result.human_required).toBe(true);
      expect(result.violated_boundaries.length).toBeGreaterThan(1);
    });

    test('should require most restrictive boundary when multiple apply', () => {
      const decision = {
        description: 'Strategic values decision affecting user agency'
      };

      const result = enforcer.enforce(decision);

      expect(result.allowed).toBe(false);
      expect(result.human_required).toBe(true);
      expect(result.violated_boundaries.length).toBeGreaterThan(0);
    });
  });

  describe('Safe AI Operations', () => {
    test('should allow technical implementation decisions', () => {
      const decision = {
        type: 'technical',
        description: 'Optimize database query performance',
        domain: 'system'
      };

      const result = enforcer.enforce(decision);

      expect(result.allowed).toBe(true);
      expect(result.human_required).toBe(false);
    });

    test('should allow code generation within approved patterns', () => {
      const decision = {
        type: 'code_generation',
        description: 'Generate CRUD endpoints following existing patterns',
        domain: 'system'
      };

      const result = enforcer.enforce(decision);

      expect(result.allowed).toBe(true);
    });

    test('should allow data analysis and recommendations', () => {
      const decision = {
        type: 'analysis',
        description: 'Analyze logs and recommend optimizations',
        domain: 'support'
      };

      const result = enforcer.enforce(decision);

      expect(result.allowed).toBe(true);
    });

    test('should allow documentation improvements', () => {
      const decision = {
        type: 'documentation',
        description: 'Improve API documentation clarity',
        domain: 'support'
      };

      const result = enforcer.enforce(decision);

      expect(result.allowed).toBe(true);
    });
  });

  describe('Boundary Enforcement with Context', () => {
    test('should consider user role in enforcement', () => {
      const decision = {
        type: 'values_change',
        description: 'Update privacy policy',
        domain: 'values'
      };

      const context = {
        user_role: 'admin',
        approval_status: 'approved'
      };

      const result = enforcer.enforce(decision, context);

      // Still requires human judgment, but context is noted
      expect(result.human_required).toBe(true);
      expect(result.context).toBeDefined();
    });

    test('should escalate dangerous operations regardless of context', () => {
      const decision = {
        type: 'values_change',
        description: 'Completely rewrite core values',
        domain: 'values'
      };

      const context = {
        pressure_level: 'CRITICAL'
      };

      const result = enforcer.enforce(decision, context);

      expect(result.allowed).toBe(false);
      expect(result.human_required).toBe(true);
      expect(result.escalation_required).toBe(true);
    });
  });

  describe('Boundary Explanations', () => {
    test('should provide clear explanation for VALUES boundary', () => {
      const decision = {
        domain: 'values',
        description: 'Change privacy settings'
      };

      const result = enforcer.enforce(decision);

      expect(result.reason).toContain('Values cannot be automated');
      expect(result.explanation).toBeDefined();
    });

    test('should provide Tractatus section reference', () => {
      const decision = {
        domain: 'agency',
        description: 'Remove user consent requirement'
      };

      const result = enforcer.enforce(decision);

      expect(result.tractatus_section).toBe('12.6');
      expect(result.principle).toContain('Agency cannot be simulated');
    });

    test('should suggest alternative approaches', () => {
      const decision = {
        domain: 'values',
        description: 'Automatically decide privacy policy'
      };

      const result = enforcer.enforce(decision);

      expect(result.alternatives).toBeDefined();
      expect(result.alternatives.length).toBeGreaterThan(0);
    });
  });

  describe('Edge Cases', () => {
    test('should handle decisions with no clear boundary', () => {
      const decision = {
        type: 'routine',
        description: 'Restart development server'
      };

      const result = enforcer.enforce(decision);

      expect(result.allowed).toBe(true);
      expect(result.boundary).toBeNull();
    });

    test('should handle null or undefined decision gracefully', () => {
      expect(() => {
        enforcer.enforce(null);
      }).not.toThrow();

      const result = enforcer.enforce(null);
      expect(result.allowed).toBe(false);
    });

    test('should handle decision with empty description', () => {
      const decision = {
        description: ''
      };

      const result = enforcer.enforce(decision);

      expect(result).toBeDefined();
    });
  });

  describe('Pre-approved Exceptions', () => {
    test('should allow pre-approved operations even if boundary-adjacent', () => {
      const decision = {
        domain: 'values',
        description: 'Verify compliance with stated values',
        pre_approved: true
      };

      const result = enforcer.enforce(decision);

      // Verification is allowed, modification is not
      expect(result.allowed).toBe(true);
    });

    test('should not allow modifications under pre-approval', () => {
      const decision = {
        domain: 'values',
        description: 'Modify core values',
        pre_approved: true
      };

      const result = enforcer.enforce(decision);

      expect(result.allowed).toBe(false);
      expect(result.human_required).toBe(true);
    });
  });

  describe('Audit Trail', () => {
    test('should create audit record for boundary violations', () => {
      const decision = {
        domain: 'values',
        description: 'Change security policy'
      };

      const result = enforcer.enforce(decision);

      expect(result.audit_record).toBeDefined();
      expect(result.audit_record.timestamp).toBeDefined();
      expect(result.audit_record.boundary_violated).toBe('VALUES');
    });

    test('should track all enforcement decisions', () => {
      enforcer.enforce({ type: 'test1' });
      enforcer.enforce({ type: 'test2' });

      const stats = enforcer.getStats();

      expect(stats.total_enforcements).toBeGreaterThanOrEqual(2);
    });
  });

  describe('Integration with Classification', () => {
    test('should respect STRATEGIC quadrant as potential boundary violation', () => {
      const decision = {
        classification: {
          quadrant: 'STRATEGIC',
          persistence: 'HIGH'
        },
        description: 'Define long-term project direction'
      };

      const result = enforcer.enforce(decision);

      expect(result.human_required).toBe(true);
    });

    test('should allow SYSTEM and TACTICAL quadrants without boundary concerns', () => {
      const decision = {
        classification: {
          quadrant: 'SYSTEM',
          persistence: 'MEDIUM'
        },
        description: 'Optimize database indexes'
      };

      const result = enforcer.enforce(decision);

      expect(result.allowed).toBe(true);
    });
  });

  describe('Singleton Pattern', () => {
    test('should export singleton instance with required methods', () => {
      expect(typeof enforcer.enforce).toBe('function');
      expect(typeof enforcer.getStats).toBe('function');
    });

    test('should maintain enforcement history across calls', () => {
      const beforeCount = enforcer.getStats().total_enforcements;

      enforcer.enforce({ type: 'test' });

      const afterCount = enforcer.getStats().total_enforcements;

      expect(afterCount).toBe(beforeCount + 1);
    });
  });

  describe('Statistics Tracking', () => {
    test('should track enforcement statistics', () => {
      const stats = enforcer.getStats();

      expect(stats).toHaveProperty('total_enforcements');
      expect(stats).toHaveProperty('boundaries_violated');
      expect(stats).toHaveProperty('human_required_count');
    });

    test('should track violations by boundary type', () => {
      enforcer.enforce({ domain: 'values', description: 'test1' });
      enforcer.enforce({ domain: 'agency', description: 'test2' });

      const stats = enforcer.getStats();

      expect(stats.by_boundary).toHaveProperty('VALUES');
      expect(stats.by_boundary).toHaveProperty('AGENCY');
    });

    test('should increment enforcement count after enforce()', () => {
      const before = enforcer.getStats().total_enforcements;

      enforcer.enforce({ type: 'test' });

      const after = enforcer.getStats().total_enforcements;

      expect(after).toBe(before + 1);
    });
  });

  describe('Safe Escalation Paths', () => {
    test('should provide escalation path for blocked decisions', () => {
      const decision = {
        domain: 'values',
        description: 'Redefine privacy policy',
        urgency: 'high'
      };

      const result = enforcer.enforce(decision);

      expect(result.escalation_path).toBeDefined();
      expect(result.escalation_path).toContain('human approval');
    });

    test('should suggest deferred execution for strategic decisions', () => {
      const decision = {
        classification: { quadrant: 'STRATEGIC' },
        description: 'Major architectural change'
      };

      const result = enforcer.enforce(decision);

      expect(result.suggested_action).toContain('defer');
    });
  });
});