Files
dxdesigner-part-replacement/tests/dsh/test_scheduling.py
T

284 lines
14 KiB
Python

from concurrent.futures import ThreadPoolExecutor
from datetime import datetime, timezone
import pytest
from dx_productivity.dsh.scheduling import ScheduleStore
from dx_productivity.trial_task_center.errors import TaskCenterError
from dx_productivity.trial_task_center.models import TaskStatus
from test_run_journal import project_service, evidence
NOW = datetime(2026, 10, 30, 12, tzinfo=timezone.utc)
def spec(ids, **extra):
return {'task_ids': ids, 'priority': 'normal', 'not_before': '2026-10-30T20:00:00+08:00', **extra}
def test_save_normalizes_utc_and_preserves_frozen_scope_across_restart(project_service):
_, _, data, ids, hashes = project_service
row = ScheduleStore(data).save(spec(ids), hashes)
assert row['not_before'] == '2026-10-30T12:00:00+00:00'
assert row['status'] == 'pending' and row['auto_start'] is False and row['idle_only'] is True
assert ScheduleStore(data).get(row['schedule_id']) == row
def test_preview_normalizes_native_draft_without_persisting_or_granting_authority(project_service):
_, _, data, ids, hashes = project_service
schedules = ScheduleStore(data)
result = schedules.preview(spec(ids, auto_start=True), hashes)
assert result == {'task_ids': ids, 'priority': 'normal', 'not_before': '2026-10-30T12:00:00+00:00',
'due_at': None, 'dependencies': [], 'auto_start': True, 'idle_only': True, 'title': ''}
assert schedules.list_schedules() == []
@pytest.mark.parametrize('extra', [{'confirmed': True}, {'priority': 'highest'}, {'not_before': '2026-10-30T12:00:00'},
{'auto_start': 'true'}, {'dependencies': ['../bad']}, {'task_ids': []}, {'title': '\x00bad'},
{'due_at': '2026-10-29T00:00:00Z'}])
def test_save_rejects_untrusted_or_invalid_specs(project_service, extra):
_, _, data, ids, hashes = project_service
with pytest.raises(TaskCenterError):
ScheduleStore(data).save(spec(ids, **extra), hashes)
def test_due_order_and_manual_confirmation_without_execution(project_service):
service, _, data, ids, hashes = project_service
schedules = ScheduleStore(data)
normal = schedules.save(spec(ids), hashes)
urgent = schedules.save(spec(ids, priority='urgent', auto_start=True), hashes)
rows = schedules.evaluate(service, now=NOW)
assert [row['schedule_id'] for row in rows] == [urgent['schedule_id'], normal['schedule_id']]
assert rows[0]['ready'] and rows[0]['requires_confirmation'] is False
assert rows[0]['dispatchable'] is True # save follows native future-run authorization
assert rows[0]['dispatch_authority'] == 'native_future_authorization'
assert rows[1]['requires_confirmation'] and not rows[1]['dispatchable']
assert not list(data.rglob('command.tsv'))
assert all('worker_busy' in row['blockers'] for row in schedules.evaluate(service, now=NOW, busy=True))
def test_dispatch_and_result_audit_are_durable_and_automatic_claim_needs_authority(project_service):
_, _, data, ids, hashes = project_service
schedules = ScheduleStore(data)
manual = schedules.save(spec(ids), hashes)
with pytest.raises(TaskCenterError, match='schedule_authority'):
schedules.claim(manual['schedule_id'], automatic=True, run_id='a' * 32)
assert schedules.get(manual['schedule_id'])['status'] == 'pending'
assert schedules.events() == []
row = schedules.save(spec(ids, auto_start=True), hashes)
schedules.claim(row['schedule_id'], automatic=True, run_id='b' * 32)
schedules.finish(row['schedule_id'], 'completed', run_id='b' * 32, receipt={'status': 'completed'})
events = ScheduleStore(data).events()
assert [e['event'] for e in reversed(events)] == ['dispatch', 'result']
assert events[1]['payload']['scope'] == {'task_ids': ids, 'plan_hashes': hashes}
assert events[1]['payload']['authority'] == 'native_future_authorization'
assert events[0]['payload']['receipt']['status'] == 'completed'
assert all(e['run_id'] == 'b' * 32 for e in events)
def test_audit_insert_failure_rolls_back_claim_before_execution(project_service):
import sqlite3
_, _, data, ids, hashes = project_service
schedules = ScheduleStore(data)
row = schedules.save(spec(ids, auto_start=True), hashes)
with sqlite3.connect(schedules.path) as db:
db.execute("CREATE TRIGGER reject_event BEFORE INSERT ON schedule_events BEGIN SELECT RAISE(ABORT, 'controlled audit fault'); END")
with pytest.raises(sqlite3.IntegrityError):
schedules.claim(row['schedule_id'], automatic=True, run_id='b' * 32)
assert ScheduleStore(data).get(row['schedule_id'])['status'] == 'pending'
def test_future_and_changed_plans_do_not_become_ready(project_service):
service, _, data, ids, hashes = project_service
schedules = ScheduleStore(data)
schedules.save(spec(ids, not_before='2026-10-31T12:00:00Z'), hashes)
assert 'not_due' in schedules.evaluate(service, now=NOW)[0]['blockers']
rule = service.rules(ids[0])[0]
service.update_rule(rule.rule_id, old_part_number='OLD', new_part_number='CHANGED', enabled=True)
assert 'plan_changed' in schedules.evaluate(service, now=NOW)[0]['blockers']
def test_preflight_blocks_missing_project_and_unreconciled_saved_result(project_service):
service, _, data, ids, hashes = project_service
schedules = ScheduleStore(data)
schedules.save(spec(ids), hashes)
evidence(service, ids[0], 'batch_saved_unverified', '')
row = schedules.evaluate(service, now=NOW)[0]
assert not row['ready'] and 'preflight_blocked' in row['blockers']
service.task_context(ids[1]).project.path.unlink()
assert not schedules.evaluate(service, now=NOW)[0]['ready']
def test_paused_task_requires_explicit_manual_resume(project_service):
service, store, data, ids, hashes = project_service
schedules = ScheduleStore(data)
schedules.save(spec(ids, auto_start=True), hashes)
store.set_task_status(ids[0], TaskStatus.READY)
store.set_task_status(ids[0], TaskStatus.RUNNING)
store.set_task_status(ids[0], TaskStatus.PAUSED)
row = schedules.evaluate(service, now=NOW)[0]
assert not row['ready'] and 'task_paused' in row['blockers']
def test_multiple_schedules_for_a_task_cannot_hide_dependency_cycle(project_service):
_, _, data, ids, hashes = project_service
schedules = ScheduleStore(data)
schedules.save(spec(ids[:1], dependencies=ids[1:2]), {ids[0]: hashes[ids[0]]})
schedules.save(spec(ids[:1], dependencies=[]), {ids[0]: hashes[ids[0]]})
with pytest.raises(TaskCenterError):
schedules.save(spec(ids[1:2], dependencies=ids[:1]), {ids[1]: hashes[ids[1]]})
def test_dependencies_require_real_completion_and_verified_evidence(project_service):
service, store, data, ids, hashes = project_service
schedules = ScheduleStore(data)
schedules.save(spec(ids[:1], dependencies=ids[1:2]), {ids[0]: hashes[ids[0]]})
assert 'dependency_incomplete' in schedules.evaluate(service, now=NOW)[0]['blockers']
store.set_task_status(ids[1], TaskStatus.READY)
store.set_task_status(ids[1], TaskStatus.RUNNING)
store.set_task_status(ids[1], TaskStatus.COMPLETED)
assert 'dependency_incomplete' in schedules.evaluate(service, now=NOW)[0]['blockers']
evidence(service, ids[1])
assert schedules.evaluate(service, now=NOW)[0]['ready']
evidence(service, ids[1], 'batch_saved_unverified', '')
assert 'dependency_incomplete' in schedules.evaluate(service, now=NOW)[0]['blockers']
def test_self_dependency_and_cross_schedule_cycles_are_rejected(project_service):
_, _, data, ids, hashes = project_service
schedules = ScheduleStore(data)
with pytest.raises(TaskCenterError):
schedules.save(spec(ids[:1], dependencies=ids[:1]), {ids[0]: hashes[ids[0]]})
schedules.save(spec(ids[:1], dependencies=ids[1:2]), {ids[0]: hashes[ids[0]]})
with pytest.raises(TaskCenterError):
schedules.save(spec(ids[1:2], dependencies=ids[:1]), {ids[1]: hashes[ids[1]]})
def test_claim_is_exclusive_and_never_replayed_after_restart(project_service):
service, _, data, ids, hashes = project_service
schedules = ScheduleStore(data)
row = schedules.save(spec(ids), hashes)
def claim(_):
try:
return ScheduleStore(data).claim(row['schedule_id'])
except TaskCenterError:
return None
with ThreadPoolExecutor(max_workers=4) as pool:
assert sum(value is not None for value in pool.map(claim, range(4))) == 1
reopened = ScheduleStore(data)
assert reopened.get(row['schedule_id'])['status'] == 'claimed'
assert 'already_claimed' in reopened.evaluate(service, now=NOW)[0]['blockers']
with pytest.raises(TaskCenterError):
reopened.claim(row['schedule_id'])
reopened.finish(row['schedule_id'], 'completed', run_id='a' * 32)
assert reopened.get(row['schedule_id'])['run_id'] == 'a' * 32
def test_cancel_is_durable_and_cannot_cancel_an_owned_claim(project_service):
_, _, data, ids, hashes = project_service
schedules = ScheduleStore(data)
row = schedules.save(spec(ids), hashes)
schedules.cancel(row['schedule_id'])
assert ScheduleStore(data).get(row['schedule_id'])['status'] == 'cancelled'
with pytest.raises(TaskCenterError):
schedules.claim(row['schedule_id'])
claimed = schedules.save(spec(ids), hashes)
schedules.claim(claimed['schedule_id'])
with pytest.raises(TaskCenterError):
schedules.cancel(claimed['schedule_id'])
@pytest.mark.parametrize('run_state', [None, 'running', 'completed', 'paused', 'failed'])
def test_reconcile_orphan_claim_preserves_original_run_and_never_replays(project_service, run_state):
from dx_productivity.dsh.run_journal import RunJournal
service, _, data, ids, hashes = project_service
schedules = ScheduleStore(data)
row = schedules.save(spec(ids, auto_start=True), hashes)
run_id = 'c' * 32
schedules.claim(row['schedule_id'], run_id=run_id, automatic=True)
journal = RunJournal(data)
if run_state:
journal.begin(run_id, ids, hashes, schedule_id=row['schedule_id'])
if run_state != 'running':
journal.finish(run_id, {'status': run_state, 'tasks': [], 'entries': []})
before = journal.get(run_id)
reopened = ScheduleStore(data)
result = reopened.reconcile_claim(service, row['schedule_id'])
expected = run_state if run_state in {'completed', 'failed'} else 'interrupted'
assert result['status'] == expected and result['run_id'] == run_id
assert journal.get(run_id) == before
assert result['result']['reconciled'] is True
assert reopened.events()[0]['event'] == 'result'
assert reopened.events()[0]['payload']['reconciled'] is True
assert not reopened.evaluate(service, now=NOW)[0]['dispatchable']
assert not list(data.rglob('command.tsv'))
def test_reconcile_refuses_active_owner_and_pending_resources(project_service, monkeypatch):
service, _, data, ids, hashes = project_service
schedules = ScheduleStore(data)
row = schedules.save(spec(ids), hashes)
schedules.claim(row['schedule_id'], run_id='d' * 32)
with schedules.execution_lease(row['schedule_id']):
with pytest.raises(TaskCenterError, match='schedule_busy'):
ScheduleStore(data).reconcile_claim(service, row['schedule_id'])
monkeypatch.setattr(service, 'pending_batch_resources', lambda: [object()])
with pytest.raises(TaskCenterError, match='schedule_busy'):
schedules.reconcile_claim(service, row['schedule_id'])
assert schedules.get(row['schedule_id'])['status'] == 'claimed'
assert len(schedules.events()) == 1
def test_reconcile_audit_failure_leaves_claim_unchanged(project_service):
import sqlite3
service, _, data, ids, hashes = project_service
schedules = ScheduleStore(data)
row = schedules.save(spec(ids), hashes)
schedules.claim(row['schedule_id'])
with sqlite3.connect(schedules.path) as db:
db.execute("CREATE TRIGGER reject_result BEFORE INSERT ON schedule_events BEGIN SELECT RAISE(ABORT, 'controlled fault'); END")
with pytest.raises(sqlite3.IntegrityError):
schedules.reconcile_claim(service, row['schedule_id'])
assert schedules.get(row['schedule_id'])['status'] == 'claimed'
def test_hard_process_exit_releases_schedule_lease_for_native_reconciliation(project_service):
import subprocess
import sys
from pathlib import Path
service, _, data, ids, hashes = project_service
schedules = ScheduleStore(data)
row = schedules.save(spec(ids, auto_start=True), hashes)
child = subprocess.run([sys.executable, '-c',
"import os,sys; sys.path.insert(0, 'src'); from dx_productivity.dsh.scheduling import ScheduleStore; "
"s=ScheduleStore(sys.argv[1]); lease=s.execution_lease(sys.argv[2]); lease.__enter__(); "
"s.claim(sys.argv[2],run_id='e'*32,automatic=True); os._exit(19)", str(data), row['schedule_id']],
cwd=Path(__file__).resolve().parents[2], capture_output=True, timeout=20)
assert child.returncode == 19, child.stderr.decode('utf8', 'replace')
assert ScheduleStore(data).get(row['schedule_id'])['status'] == 'claimed'
result = ScheduleStore(data).reconcile_claim(service, row['schedule_id'])
assert result['status'] == 'interrupted' and result['run_id'] == 'e' * 32
def test_active_claim_in_another_process_cannot_be_reconciled(project_service):
import subprocess
import sys
from pathlib import Path
service, _, data, ids, hashes = project_service
schedules = ScheduleStore(data)
row = schedules.save(spec(ids, auto_start=True), hashes)
child = subprocess.Popen([sys.executable, '-c',
"import sys; sys.path.insert(0,'src'); from dx_productivity.dsh.scheduling import ScheduleStore; "
"s=ScheduleStore(sys.argv[1]); lease=s.execution_lease(sys.argv[2]); lease.__enter__(); "
"s.claim(sys.argv[2],run_id='f'*32,automatic=True); print('ready',flush=True); "
"sys.stdin.buffer.read(1); lease.__exit__(None,None,None)", str(data), row['schedule_id']],
cwd=Path(__file__).resolve().parents[2], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
try:
assert child.stdout.readline().strip() == b'ready'
with pytest.raises(TaskCenterError, match='schedule_busy'):
schedules.reconcile_claim(service, row['schedule_id'])
assert schedules.get(row['schedule_id'])['status'] == 'claimed'
finally:
child.communicate(input=b'q', timeout=10)
assert child.returncode == 0