llm-security/tests/lib/policy-loader.test.mjs

// policy-loader.test.mjs — Tests for policy-as-code loader

import { describe, it, beforeEach, afterEach } from 'node:test';
import assert from 'node:assert/strict';
import { writeFileSync, mkdirSync, rmSync, existsSync } from 'node:fs';
import { join } from 'node:path';
import { homedir } from 'node:os';
import { loadPolicy, getPolicyValue, getDefaultPolicy, _resetCacheForTest } from '../../scanners/lib/policy-loader.mjs';

// S3c: an explicit root is read only when it is the caller's own working
// tree (under cwd, never under os.tmpdir()) — see tests/helpers/own-tree.mjs.
const TEST_ROOT = join(homedir(), `.llm-security-policy-test-${Date.now()}`);
const POLICY_DIR = join(TEST_ROOT, '.llm-security');
const POLICY_FILE = join(POLICY_DIR, 'policy.json');

describe('policy-loader', () => {
  let prevCwd;

  beforeEach(() => {
    _resetCacheForTest();
    mkdirSync(POLICY_DIR, { recursive: true });
    prevCwd = process.cwd();
    process.chdir(TEST_ROOT);
  });

  afterEach(() => {
    process.chdir(prevCwd);
    _resetCacheForTest();
    try { rmSync(TEST_ROOT, { recursive: true }); } catch {}
  });

  it('returns defaults when no policy file exists', () => {
    rmSync(POLICY_FILE, { force: true });
    const policy = loadPolicy(TEST_ROOT);
    assert.equal(policy.version, '1.0');
    assert.equal(policy.injection.mode, 'block');
    assert.equal(policy.trifecta.mode, 'warn');
    assert.equal(policy.trifecta.window_size, 20);
  });

  it('reads and merges valid policy file', () => {
    writeFileSync(POLICY_FILE, JSON.stringify({
      version: '1.0',
      trifecta: { mode: 'off' },
    }));
    const policy = loadPolicy(TEST_ROOT);
    assert.equal(policy.trifecta.mode, 'off');
    // Other defaults preserved
    assert.equal(policy.trifecta.window_size, 20);
    assert.equal(policy.injection.mode, 'block');
  });

  it('handles partial policy (deep merge preserves defaults)', () => {
    writeFileSync(POLICY_FILE, JSON.stringify({
      secrets: { additional_patterns: ['CUSTOM_SECRET=\\w+'] },
    }));
    const policy = loadPolicy(TEST_ROOT);
    assert.deepEqual(policy.secrets.additional_patterns, ['CUSTOM_SECRET=\\w+']);
    assert.deepEqual(policy.secrets.allowed_paths, []); // default preserved
  });

  it('caches policy per root', () => {
    writeFileSync(POLICY_FILE, JSON.stringify({ trifecta: { mode: 'block' } }));
    const p1 = loadPolicy(TEST_ROOT);
    // Modify file — should still return cached
    writeFileSync(POLICY_FILE, JSON.stringify({ trifecta: { mode: 'off' } }));
    const p2 = loadPolicy(TEST_ROOT);
    assert.equal(p1, p2); // same reference (cached)
    assert.equal(p2.trifecta.mode, 'block'); // original value
  });

  it('getPolicyValue returns correct values', () => {
    writeFileSync(POLICY_FILE, JSON.stringify({
      mcp: { volume_threshold_bytes: 500_000 },
    }));
    const val = getPolicyValue('mcp', 'volume_threshold_bytes', 100_000, TEST_ROOT);
    assert.equal(val, 500_000);
  });

  it('getPolicyValue returns default when key not in policy', () => {
    writeFileSync(POLICY_FILE, JSON.stringify({ version: '1.0' }));
    const val = getPolicyValue('mcp', 'nonexistent_key', 42, TEST_ROOT);
    assert.equal(val, 42);
  });

  it('handles invalid JSON gracefully', () => {
    writeFileSync(POLICY_FILE, 'not valid json!!!');
    const policy = loadPolicy(TEST_ROOT);
    // Should return defaults without crashing
    assert.equal(policy.version, '1.0');
    assert.equal(policy.injection.mode, 'block');
  });

  it('getDefaultPolicy returns a copy', () => {
    const d1 = getDefaultPolicy();
    const d2 = getDefaultPolicy();
    assert.deepEqual(d1, d2);
    assert.notEqual(d1, d2); // different references
  });

  it('default policy matches existing hardcoded values', () => {
    const defaults = getDefaultPolicy();
    // These must match the hardcoded values in hooks
    assert.equal(defaults.injection.mode, 'block');
    assert.equal(defaults.trifecta.mode, 'warn');
    assert.equal(defaults.trifecta.window_size, 20);
    assert.equal(defaults.trifecta.long_horizon_window, 100);
    assert.equal(defaults.mcp.volume_threshold_bytes, 100_000);
  });

  it('default policy includes ci section with null/false defaults', () => {
    const defaults = getDefaultPolicy();
    assert.equal(defaults.ci.failOn, null);
    assert.equal(defaults.ci.compact, false);
  });

  it('ci section merges correctly from policy file', () => {
    writeFileSync(POLICY_FILE, JSON.stringify({
      ci: { failOn: 'high' },
    }));
    const policy = loadPolicy(TEST_ROOT);
    assert.equal(policy.ci.failOn, 'high');
    assert.equal(policy.ci.compact, false); // default preserved
  });

  it('ci section allows compact override', () => {
    writeFileSync(POLICY_FILE, JSON.stringify({
      ci: { failOn: 'critical', compact: true },
    }));
    const policy = loadPolicy(TEST_ROOT);
    assert.equal(policy.ci.failOn, 'critical');
    assert.equal(policy.ci.compact, true);
  });

  it('default policy includes trifecta.escalation_window=5 (D3)', () => {
    const defaults = getDefaultPolicy();
    assert.equal(defaults.trifecta.escalation_window, 5);
  });

  it('getPolicyValue survives a scalar section override without throwing (#26)', () => {
    // A user writing {"injection": "block"} (scalar instead of object) must
    // not crash the "key in sectionObj" lookup with a TypeError.
    writeFileSync(POLICY_FILE, JSON.stringify({ injection: 'block' }));
    const val = getPolicyValue('injection', 'mode', 'warn', TEST_ROOT);
    assert.equal(val, 'warn');
  });
});