Files
dxdesigner-part-replacement/tests/dsh/test_decision_log.py

131 lines
5.4 KiB
Python

import json
from concurrent.futures import ThreadPoolExecutor
from hashlib import sha256
import pytest
from dx_productivity.dsh.decision_log import DecisionLog
def _row(incident='a' * 24, outcome='pending_issue'):
return {'incident_id': incident, 'trigger': 'execution_failed', 'evidence_refs': ['dsh/incidents/x/gates.json'],
'gates': {'execution_authorized': True, 'retry_budget_available': False},
'candidate_action': 'none', 'authorized_scope': {'task_ids': ['task-1']}, 'outcome': outcome,
'human_takeover': False}
def test_decision_log_is_hash_linked_and_survives_restart(tmp_path):
store = DecisionLog(tmp_path)
first = store.append(_row())
second = DecisionLog(tmp_path).append(_row('b' * 24, 'resolved'))
assert first['sequence'] == 1
assert second['previous_hash'] == first['record_hash']
assert DecisionLog(tmp_path).verify()['valid'] is True
assert [row['sequence'] for row in DecisionLog(tmp_path).list()] == [1, 2]
def test_decision_log_detects_tampering_and_bounds_text(tmp_path):
store = DecisionLog(tmp_path)
store.append(_row())
path = tmp_path / 'dsh' / 'decisions.jsonl'
raw = path.read_text(encoding='utf8').replace('execution_failed', 'x' * 5000)
path.write_text(raw, encoding='utf8')
assert DecisionLog(tmp_path).verify()['valid'] is False
with pytest.raises(ValueError, match='incident_id'):
store.append(_row('bad'))
def _seal(record):
body = {key: value for key, value in record.items() if key != 'record_hash'}
payload = json.dumps(body, ensure_ascii=False, sort_keys=True, separators=(',', ':'))
return body | {'record_hash': sha256(payload.encode('utf8')).hexdigest()}
@pytest.fixture
def long_log(tmp_path):
# Seed a valid historical log without thousands of quadratic append calls.
path = tmp_path / 'dsh' / 'decisions.jsonl'
path.parent.mkdir()
previous = ''
with path.open('w', encoding='utf8') as stream:
for sequence in range(1, 2002):
last = _seal(_row() | {'sequence': sequence, 'at_utc': '2026-10-31T00:00:00+00:00',
'previous_hash': previous})
stream.write(json.dumps(last) + '\n')
previous = last['record_hash']
return DecisionLog(tmp_path), last
def test_append_after_2000_records_uses_actual_tail_and_verifies_entire_chain(long_log):
store, previous = long_log
result = store.append(_row('b' * 24))
assert result['sequence'] == 2002
assert result['previous_hash'] == previous['record_hash']
reopened = DecisionLog(store.path.parent.parent)
assert reopened.verify() == {'valid': True, 'checked': 2002, 'last_hash': result['record_hash']}
def test_verify_detects_tampering_past_2000_records(long_log):
store, last = long_log
lines = store.path.read_text(encoding='utf8').splitlines()
lines[-1] = json.dumps(last | {'outcome': 'resolved'})
store.path.write_text('\n'.join(lines) + '\n', encoding='utf8')
assert store.verify(sequence=2000)['valid'] is True
result = store.verify()
assert result['valid'] is False and result['checked'] == 2000
before = store.path.read_bytes()
with pytest.raises(ValueError, match='decision_log_corrupt'):
store.append(_row('b' * 24))
assert store.path.read_bytes() == before
def test_verify_rejects_duplicate_sequence_even_with_valid_hash_links(long_log):
store, last = long_log
duplicate = _seal(last | {'previous_hash': last['record_hash']})
with store.path.open('a', encoding='utf8') as stream:
stream.write(json.dumps(duplicate) + '\n')
result = store.verify()
assert result['valid'] is False and result['checked'] == 2001
@pytest.mark.parametrize('tail', ['{incomplete', '{"incident_id":', '[]\n', '\n'])
def test_corrupt_tail_is_reported_and_append_preserves_original_bytes(tmp_path, tail):
store = DecisionLog(tmp_path)
store.append(_row())
with store.path.open('a', encoding='utf8') as stream:
stream.write(tail)
before = store.path.read_bytes()
assert store.verify()['valid'] is False
with pytest.raises(ValueError, match='decision_log_corrupt'):
store.list()
with pytest.raises(ValueError, match='decision_log_corrupt'):
store.append(_row('b' * 24))
assert store.path.read_bytes() == before
def test_listing_remains_bounded_and_shows_recent_records(long_log):
store, _ = long_log
assert [row['sequence'] for row in store.list(limit=3)] == [1999, 2000, 2001]
assert len(store.list(limit=100000)) == 2000
def test_append_after_complete_json_without_newline_keeps_records_separate(tmp_path):
store = DecisionLog(tmp_path)
first = store.append(_row())
store.path.write_bytes(store.path.read_bytes().rstrip(b'\r\n'))
second = store.append(_row('b' * 24))
assert len(store.path.read_text(encoding='utf8').splitlines()) == 2
assert second['previous_hash'] == first['record_hash']
assert store.verify()['checked'] == 2 and store.verify()['valid'] is True
def test_concurrent_instances_append_one_ordered_chain(tmp_path):
def append(index):
return DecisionLog(tmp_path).append(_row(f'{index:024x}'))
with ThreadPoolExecutor(max_workers=4) as pool:
results = list(pool.map(append, range(20)))
assert sorted(row['sequence'] for row in results) == list(range(1, 21))
assert DecisionLog(tmp_path).verify()['valid'] is True
assert DecisionLog(tmp_path).verify()['checked'] == 20