agentic-workflow-manager 9.20.4 → 9.22.0

package/dist/tests/commands/sensors/result-cache.test.js

@@ -0,0 +1,352 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const result_cache_1 = require("../../../src/commands/sensors/result-cache");
+const result_1 = require("../../../src/commands/sensors/result");
+const baseline_1 = require("../../../src/commands/sensors/baseline");
+const exec_fixtures_1 = require("./exec-fixtures");
+function prepared(overrides = {}) {
+    return {
+        name: 'lint',
+        formatter: 'eslint-llm',
+        timeoutMs: 30_000,
+        timeoutSource: 'project',
+        requestedScope: 'full',
+        effectiveScope: 'full',
+        command: { kind: 'structured', value: { executable: 'eslint', resolution: 'path', args: ['.'] } },
+        ...overrides,
+    };
+}
+function sampleRaw(overrides = {}) {
+    return {
+        name: 'lint',
+        status: 'pass',
+        errors: [],
+        ...overrides,
+    };
+}
+describe('result cache helpers (RF-2.4, RF-2.10, RF-2.15)', () => {
+    const roots = [];
+    afterEach(() => {
+        for (const root of roots.splice(0))
+            fs_1.default.rmSync(root, { recursive: true, force: true });
+    });
+    it('sets failureKind findings|missing-binary|exit-code on fail results (RF-2.4)', () => {
+        const findings = (0, result_1.interpretResult)(prepared(), (0, exec_fixtures_1.exited)(1, JSON.stringify([{
+                filePath: 'a.ts',
+                messages: [{ line: 1, column: 1, message: 'x', ruleId: 'no-x', severity: 2 }],
+            }])));
+        expect(findings.status).toBe('fail');
+        expect(findings.failureKind).toBe('findings');
+        // Name `security` selects the semgrep formatter (no invented findings from shell noise).
+        const missing = (0, result_1.interpretResult)(prepared({ name: 'security', formatter: undefined }), (0, exec_fixtures_1.exited)(127, '', 'command not found'));
+        expect(missing.status).toBe('fail');
+        expect(missing.failureKind).toBe('missing-binary');
+        const spawn = (0, result_1.interpretResult)(prepared({ formatter: 'exit-code' }), (0, exec_fixtures_1.spawnFailed)('ENOENT'));
+        expect(spawn.status).toBe('fail');
+        expect(spawn.failureKind).toBe('missing-binary');
+        const exitCode = (0, result_1.interpretResult)(prepared({ formatter: 'exit-code', name: 'iac' }), (0, exec_fixtures_1.exited)(1, 'drift\n'));
+        expect(exitCode.status).toBe('fail');
+        expect(exitCode.failureKind).toBe('exit-code');
+    });
+    it('canCacheRawResult allows pass and findings-fail with errors; rejects exit-code/missing-binary/incomplete (RF-2.4)', () => {
+        expect((0, result_cache_1.canCacheRawResult)(sampleRaw({ status: 'pass' }))).toBe(true);
+        expect((0, result_cache_1.canCacheRawResult)(sampleRaw({
+            status: 'fail',
+            failureKind: 'findings',
+            errors: [{ message: 'x', file: 'a.ts', rule: 'r' }],
+        }))).toBe(true);
+        expect((0, result_cache_1.canCacheRawResult)(sampleRaw({ status: 'fail', failureKind: 'exit-code', errors: [{ message: 'exit 1' }] }))).toBe(false);
+        expect((0, result_cache_1.canCacheRawResult)(sampleRaw({ status: 'fail', failureKind: 'missing-binary', errors: [{ message: 'gone' }] }))).toBe(false);
+        expect((0, result_cache_1.canCacheRawResult)(sampleRaw({ status: 'fail', failureKind: 'findings', errors: [] }))).toBe(false);
+        expect((0, result_cache_1.canCacheRawResult)(sampleRaw({ status: 'inconclusive', errors: [], skipReason: 'timeout' }))).toBe(false);
+        expect((0, result_cache_1.canCacheRawResult)(sampleRaw({
+            status: 'fail',
+            failureKind: 'findings',
+            errors: [{ message: 'x' }],
+            incomplete: 'timeout after 1ms',
+        }))).toBe(false);
+        expect((0, result_cache_1.canCacheRawResult)((0, result_1.interpretResult)(prepared({ formatter: 'exit-code' }), (0, exec_fixtures_1.exited)(1, 'x')))).toBe(false);
+        expect((0, result_cache_1.canCacheRawResult)((0, result_1.interpretResult)(prepared({ name: 'security', formatter: undefined }), (0, exec_fixtures_1.exited)(127, '', 'command not found')))).toBe(false);
+        expect((0, result_cache_1.canCacheRawResult)((0, result_1.interpretResult)(prepared(), (0, exec_fixtures_1.ok)()))).toBe(true);
+    });
+    it('canCacheRawResult / planted pass+errors or pass+failureKind is a miss (not cacheable)', () => {
+        expect((0, result_cache_1.canCacheRawResult)(sampleRaw({
+            status: 'pass',
+            errors: [{ message: 'planted finding' }],
+        }))).toBe(false);
+        expect((0, result_cache_1.canCacheRawResult)(sampleRaw({
+            status: 'pass',
+            failureKind: 'findings',
+            errors: [],
+        }))).toBe(false);
+        expect((0, result_cache_1.canCacheRawResult)(sampleRaw({
+            status: 'pass',
+            failureKind: 'exit-code',
+            errors: [{ message: 'x' }],
+        }))).toBe(false);
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-rcache-pass-errors-'));
+        roots.push(root);
+        const base = {
+            schema: 1,
+            sensorId: 'lint',
+            projectKey: 'proj',
+            sensorFingerprint: 'sha256:' + 'a'.repeat(64),
+            inputDigest: 'sha256:' + 'b'.repeat(64),
+            originCommit: 'c'.repeat(40),
+            originDirty: false,
+        };
+        const lookup = {
+            sensorId: 'lint',
+            projectKey: 'proj',
+            sensorFingerprint: base.sensorFingerprint,
+            inputDigest: base.inputDigest,
+        };
+        const { cacheFileName } = require('../../../src/commands/sensors/result-cache');
+        const dir = path_1.default.join(root, '.awm', 'sensors', 'runs');
+        fs_1.default.mkdirSync(dir, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(dir, cacheFileName(lookup)), JSON.stringify({
+            ...base,
+            raw: { name: 'lint', status: 'pass', errors: [{ message: 'planted' }] },
+        }, null, 2) + '\n');
+        expect((0, result_cache_1.readResultCache)(root, lookup)).toBeNull();
+        expect(() => (0, result_cache_1.writeResultCache)(root, {
+            ...base,
+            raw: { name: 'lint', status: 'pass', errors: [{ message: 'planted' }] },
+        })).toThrow(/cacheable|refuse|uncacheable|RF-2\.4|errors|failureKind/i);
+    });
+    it('binds raw.name to sensorId on write and read; mismatch refuses write / misses on read', () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-rcache-name-bind-'));
+        roots.push(root);
+        const base = {
+            schema: 1,
+            sensorId: 'lint',
+            projectKey: 'proj',
+            sensorFingerprint: 'sha256:' + 'a'.repeat(64),
+            inputDigest: 'sha256:' + 'b'.repeat(64),
+            originCommit: 'c'.repeat(40),
+            originDirty: false,
+        };
+        expect(() => (0, result_cache_1.writeResultCache)(root, {
+            ...base,
+            raw: { name: 'typecheck', status: 'pass', errors: [] },
+        })).toThrow(/name|sensorId|mismatch|bind/i);
+        (0, result_cache_1.writeResultCache)(root, {
+            ...base,
+            raw: { name: 'lint', status: 'pass', errors: [] },
+        });
+        const lookup = {
+            sensorId: 'lint',
+            projectKey: 'proj',
+            sensorFingerprint: base.sensorFingerprint,
+            inputDigest: base.inputDigest,
+        };
+        const { cacheFileName } = require('../../../src/commands/sensors/result-cache');
+        const dir = path_1.default.join(root, '.awm', 'sensors', 'runs');
+        const cachePath = path_1.default.join(dir, cacheFileName(lookup));
+        const record = JSON.parse(fs_1.default.readFileSync(cachePath, 'utf8'));
+        record.raw.name = 'typecheck';
+        fs_1.default.writeFileSync(cachePath, JSON.stringify(record, null, 2) + '\n');
+        expect((0, result_cache_1.readResultCache)(root, lookup)).toBeNull();
+    });
+    it('constrains cached SensorError message/file to single-line strings', () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-rcache-error-line-'));
+        roots.push(root);
+        const base = {
+            schema: 1,
+            sensorId: 'lint',
+            projectKey: 'proj',
+            sensorFingerprint: 'sha256:' + 'a'.repeat(64),
+            inputDigest: 'sha256:' + 'b'.repeat(64),
+            originCommit: 'c'.repeat(40),
+            originDirty: false,
+        };
+        expect(() => (0, result_cache_1.writeResultCache)(root, {
+            ...base,
+            raw: {
+                name: 'lint',
+                status: 'fail',
+                failureKind: 'findings',
+                errors: [{ message: 'bad\nline', file: 'a.ts' }],
+            },
+        })).toThrow(/single.?line|message|errors/i);
+        expect(() => (0, result_cache_1.writeResultCache)(root, {
+            ...base,
+            raw: {
+                name: 'lint',
+                status: 'fail',
+                failureKind: 'findings',
+                errors: [{ message: 'ok', file: 'a\nts' }],
+            },
+        })).toThrow(/single.?line|file|errors/i);
+    });
+    it('computeSensorFingerprint returns null without live tool/runtime versions (RF-2.10)', () => {
+        expect((0, result_cache_1.computeSensorFingerprint)({
+            variantId: 'eslint-10',
+            command: { executable: 'eslint', args: ['.'] },
+            cliVersion: '9.21.0',
+            inputs: ['**/*.ts'],
+            toolVersion: null,
+            runtimeVersion: '22.0.0',
+        })).toBeNull();
+        expect((0, result_cache_1.computeSensorFingerprint)({
+            variantId: null,
+            command: { executable: 'node', args: ['x'] },
+            cliVersion: '9.21.0',
+            inputs: ['**/*.ts'],
+            toolVersion: undefined,
+            runtimeVersion: undefined,
+        })).toBeNull();
+        const fp = (0, result_cache_1.computeSensorFingerprint)({
+            variantId: 'eslint-10',
+            command: { executable: 'eslint', args: ['.'] },
+            cliVersion: '9.21.0',
+            inputs: ['**/*.ts'],
+            toolVersion: '10.0.0',
+            runtimeVersion: '22.0.0',
+        });
+        expect(fp).toMatch(/^sha256:[0-9a-f]{64}$/);
+        const changedTool = (0, result_cache_1.computeSensorFingerprint)({
+            variantId: 'eslint-10',
+            command: { executable: 'eslint', args: ['.'] },
+            cliVersion: '9.21.0',
+            inputs: ['**/*.ts'],
+            toolVersion: '10.1.0',
+            runtimeVersion: '22.0.0',
+        });
+        expect(changedTool).not.toBe(fp);
+    });
+    it('validates cache reads recursively; tamper or symlink yields miss (RF-2.15, RF-E.1)', () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-rcache-'));
+        roots.push(root);
+        const record = {
+            schema: 1,
+            sensorId: 'lint',
+            projectKey: 'proj',
+            sensorFingerprint: 'sha256:' + 'a'.repeat(64),
+            inputDigest: 'sha256:' + 'b'.repeat(64),
+            originCommit: 'c'.repeat(40),
+            originDirty: false,
+            raw: { name: 'lint', status: 'pass', errors: [] },
+        };
+        (0, result_cache_1.writeResultCache)(root, record);
+        const hit = (0, result_cache_1.readResultCache)(root, {
+            sensorId: 'lint',
+            projectKey: 'proj',
+            sensorFingerprint: record.sensorFingerprint,
+            inputDigest: record.inputDigest,
+        });
+        expect(hit).toEqual(record);
+        const file = path_1.default.join(root, '.awm', 'sensors', 'runs', hit ? path_1.default.basename(
+        // discover written file
+        fs_1.default.readdirSync(path_1.default.join(root, '.awm', 'sensors', 'runs')).find((n) => n.startsWith('cache-'))) : '');
+        const cacheDir = path_1.default.join(root, '.awm', 'sensors', 'runs');
+        const cacheFiles = fs_1.default.readdirSync(cacheDir).filter((n) => n.startsWith('cache-'));
+        expect(cacheFiles).toHaveLength(1);
+        const cachePath = path_1.default.join(cacheDir, cacheFiles[0]);
+        fs_1.default.writeFileSync(cachePath, JSON.stringify({ ...record, raw: { status: 'pass' } }));
+        expect((0, result_cache_1.readResultCache)(root, {
+            sensorId: 'lint',
+            projectKey: 'proj',
+            sensorFingerprint: record.sensorFingerprint,
+            inputDigest: record.inputDigest,
+        })).toBeNull();
+        fs_1.default.writeFileSync(cachePath, JSON.stringify(record));
+        fs_1.default.unlinkSync(cachePath);
+        fs_1.default.symlinkSync('/tmp/evil', cachePath);
+        expect((0, result_cache_1.readResultCache)(root, {
+            sensorId: 'lint',
+            projectKey: 'proj',
+            sensorFingerprint: record.sensorFingerprint,
+            inputDigest: record.inputDigest,
+        })).toBeNull();
+        void file;
+    });
+    it('rejects cache reads whose raw would fail canCacheRawResult (RF-2.15/2.4)', () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-rcache-uncacheable-'));
+        roots.push(root);
+        const base = {
+            schema: 1,
+            sensorId: 'lint',
+            projectKey: 'proj',
+            sensorFingerprint: 'sha256:' + 'a'.repeat(64),
+            inputDigest: 'sha256:' + 'b'.repeat(64),
+            originCommit: 'c'.repeat(40),
+            originDirty: false,
+        };
+        const lookup = {
+            sensorId: 'lint',
+            projectKey: 'proj',
+            sensorFingerprint: base.sensorFingerprint,
+            inputDigest: base.inputDigest,
+        };
+        const plant = (raw) => {
+            // Bypass writeResultCache so uncacheable raw can be planted on disk.
+            const dir = path_1.default.join(root, '.awm', 'sensors', 'runs');
+            fs_1.default.mkdirSync(dir, { recursive: true });
+            const { cacheFileName } = require('../../../src/commands/sensors/result-cache');
+            fs_1.default.writeFileSync(path_1.default.join(dir, cacheFileName(lookup)), JSON.stringify({ ...base, raw }, null, 2) + '\n');
+        };
+        plant({ name: 'lint', status: 'fail', failureKind: 'exit-code', errors: [{ message: 'exit 1' }] });
+        expect((0, result_cache_1.readResultCache)(root, lookup)).toBeNull();
+        plant({ name: 'lint', status: 'fail', failureKind: 'missing-binary', errors: [{ message: 'gone' }] });
+        expect((0, result_cache_1.readResultCache)(root, lookup)).toBeNull();
+        plant({ name: 'lint', status: 'fail', failureKind: 'findings', errors: [] });
+        expect((0, result_cache_1.readResultCache)(root, lookup)).toBeNull();
+        plant({
+            name: 'lint',
+            status: 'fail',
+            failureKind: 'findings',
+            errors: [{ message: 'x', file: 'a.ts', rule: 'r' }],
+            incomplete: 'timeout after 1ms',
+        });
+        expect((0, result_cache_1.readResultCache)(root, lookup)).toBeNull();
+        plant({
+            name: 'lint',
+            status: 'fail',
+            failureKind: 'findings',
+            errors: [{ message: 'x', file: 'a.ts', rule: 'r' }],
+        });
+        expect((0, result_cache_1.readResultCache)(root, lookup)).toMatchObject({
+            raw: { status: 'fail', failureKind: 'findings' },
+        });
+    });
+    it('writeResultCache refuses uncacheable raw; toCacheRaw does not coerce skipped/inconclusive to pass (QA-3)', () => {
+        const root = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-rcache-write-gate-'));
+        roots.push(root);
+        const base = {
+            schema: 1,
+            sensorId: 'lint',
+            projectKey: 'proj',
+            sensorFingerprint: 'sha256:' + 'a'.repeat(64),
+            inputDigest: 'sha256:' + 'b'.repeat(64),
+            originCommit: 'c'.repeat(40),
+            originDirty: false,
+        };
+        expect(() => (0, result_cache_1.writeResultCache)(root, {
+            ...base,
+            raw: { name: 'lint', status: 'fail', failureKind: 'exit-code', errors: [{ message: 'exit 1' }] },
+        })).toThrow(/cacheable|refuse|uncacheable|RF-2\.4/i);
+        expect(() => (0, result_cache_1.toCacheRaw)(sampleRaw({ status: 'skipped', skipReason: 'disabled' }))).toThrow(/pass|fail|cache/i);
+        expect(() => (0, result_cache_1.toCacheRaw)(sampleRaw({ status: 'inconclusive', skipReason: 'timeout' }))).toThrow(/pass|fail|cache/i);
+        expect((0, result_cache_1.toCacheRaw)(sampleRaw({ status: 'pass' }))).toMatchObject({ status: 'pass', errors: [] });
+    });
+    it('strips failureKind when applyBaseline yields pass (QA-4)', () => {
+        const err = { file: 'a.ts', line: 1, column: 1, message: 'no-x', rule: 'no-x' };
+        const raw = {
+            name: 'lint',
+            status: 'fail',
+            failureKind: 'findings',
+            errors: [err],
+        };
+        const suppressed = (0, result_1.applyBaseline)(raw, [(0, baseline_1.fingerprint)('lint', err)]);
+        expect(suppressed.status).toBe('pass');
+        expect(suppressed.failureKind).toBeUndefined();
+        expect(suppressed.errors).toEqual([]);
+    });
+});