200 lines
9.1 KiB
Python
200 lines
9.1 KiB
Python
import json
|
|
import os
|
|
|
|
import pytest
|
|
|
|
from dx_productivity.trial_task_center import batch_attempt as attempts
|
|
|
|
|
|
@pytest.fixture
|
|
def prepared(tmp_path, monkeypatch):
|
|
path = tmp_path / 'job.json'
|
|
record = attempts.prepare_attempt(path, session_id='session-a', generation=1,
|
|
task_id='task-a', job_id='job-a', project_path=tmp_path / 'board.prj')
|
|
monkeypatch.setenv('DXPART_ATTEMPT_FILE', str(path))
|
|
monkeypatch.setenv('DXPART_BATCH_SESSION_ID', 'session-a')
|
|
monkeypatch.setenv('DXPART_BATCH_GENERATION', '1')
|
|
monkeypatch.setenv('DXPART_ATTEMPT_ID', record['attempt_id'])
|
|
monkeypatch.setenv('DXPART_TASK_ID', 'task-a')
|
|
monkeypatch.setenv('DXPART_JOB_ID', 'job-a')
|
|
return path, record
|
|
|
|
|
|
def test_only_current_prepared_attempt_can_retry(prepared):
|
|
path, expected = prepared
|
|
assert attempts.can_retry_attempt(path, expected)
|
|
attempts.mark_mutation_possible(job_id='job-a')
|
|
assert attempts.read_attempt(path)['state'] == 'mutation_possible'
|
|
assert not attempts.can_retry_attempt(path, expected)
|
|
|
|
|
|
@pytest.mark.parametrize('field,value', [('session_id', 'old'), ('generation', 2),
|
|
('attempt_id', '0' * 32), ('task_id', 'old'), ('job_id', 'old'),
|
|
('project_path', 'other.prj')])
|
|
def test_retry_rejects_stale_identity(prepared, field, value):
|
|
path, expected = prepared
|
|
assert not attempts.can_retry_attempt(path, dict(expected, **{field: value}))
|
|
|
|
|
|
@pytest.mark.parametrize('contents', [None, '{truncated', '{}', '[]'])
|
|
def test_unreadable_or_incomplete_proof_never_allows_retry(prepared, contents):
|
|
path, expected = prepared
|
|
if contents is None:
|
|
path.unlink()
|
|
else:
|
|
path.write_text(contents)
|
|
assert not attempts.can_retry_attempt(path, expected)
|
|
with pytest.raises((OSError, ValueError)):
|
|
attempts.mark_mutation_possible(job_id='job-a')
|
|
|
|
|
|
@pytest.mark.parametrize('name,value', [('DXPART_BATCH_SESSION_ID', 'old'),
|
|
('DXPART_BATCH_GENERATION', '2'), ('DXPART_ATTEMPT_ID', '0' * 32),
|
|
('DXPART_TASK_ID', 'old'), ('DXPART_JOB_ID', 'old')])
|
|
def test_marker_blocks_stale_process_identity(prepared, monkeypatch, name, value):
|
|
path, _ = prepared
|
|
monkeypatch.setenv(name, value)
|
|
with pytest.raises(ValueError):
|
|
attempts.mark_mutation_possible(job_id='job-a')
|
|
assert attempts.read_attempt(path)['state'] == 'prepared'
|
|
|
|
|
|
def test_marker_fsync_failure_blocks_caller_without_publishing_mutation(prepared, monkeypatch):
|
|
path, _ = prepared
|
|
def fail(_):
|
|
raise OSError('durability failed')
|
|
monkeypatch.setattr(os, 'fsync', fail)
|
|
with pytest.raises(OSError, match='durability failed'):
|
|
attempts.mark_mutation_possible(job_id='job-a')
|
|
assert json.loads(path.read_text())['state'] == 'prepared'
|
|
|
|
|
|
def test_legacy_no_environment_remains_supported(monkeypatch):
|
|
for name in tuple(os.environ):
|
|
if name.startswith('DXPART_') and ('ATTEMPT' in name or 'BATCH_' in name):
|
|
monkeypatch.delenv(name)
|
|
assert attempts.mark_mutation_possible() is None
|
|
|
|
|
|
def test_blank_batch_path_is_not_legacy(monkeypatch):
|
|
monkeypatch.setenv('DXPART_ATTEMPT_FILE', '')
|
|
with pytest.raises(ValueError):
|
|
attempts.mark_mutation_possible()
|
|
|
|
|
|
def test_preparation_is_durable_before_return(tmp_path, monkeypatch):
|
|
fsynced = []
|
|
real_fsync = os.fsync
|
|
def fsync(fd):
|
|
fsynced.append(True)
|
|
return real_fsync(fd)
|
|
monkeypatch.setattr(os, 'fsync', fsync)
|
|
path = tmp_path / 'attempt.json'
|
|
first = attempts.prepare_attempt(path, session_id='s', generation=1,
|
|
task_id='t', job_id='j', project_path=tmp_path / 'board.prj')
|
|
assert fsynced and attempts.read_attempt(path)['state'] == 'prepared'
|
|
second = attempts.prepare_attempt(tmp_path / 'second.json', session_id='s', generation=1,
|
|
task_id='t', job_id='j', project_path=tmp_path / 'board.prj')
|
|
assert first['attempt_id'] != second['attempt_id']
|
|
|
|
|
|
def test_reused_worker_marks_each_logical_job(tmp_path, monkeypatch):
|
|
directory = tmp_path / 'attempt'
|
|
for job in ('job-a', 'job-b'):
|
|
attempts.prepare_attempt(directory / f'{job}.json', session_id='session-a', generation=1,
|
|
task_id='task-a', job_id=job, project_path=tmp_path / 'board.prj', attempt_id='a' * 32)
|
|
monkeypatch.setenv('DXPART_ATTEMPT_FILE', str(directory))
|
|
monkeypatch.setenv('DXPART_BATCH_SESSION_ID', 'session-a')
|
|
monkeypatch.setenv('DXPART_BATCH_GENERATION', '1')
|
|
monkeypatch.setenv('DXPART_ATTEMPT_ID', 'a' * 32)
|
|
for job in ('job-a', 'job-b'):
|
|
attempts.mark_mutation_possible(job_id=job, task_id='task-a', project_path=tmp_path / 'board.prj')
|
|
assert attempts.read_attempt(directory / f'{job}.json')['state'] == 'mutation_possible'
|
|
|
|
|
|
def test_native_guard_binds_snapshot_to_command_and_current_attempt(prepared, tmp_path):
|
|
from dx_productivity.trial_task_center.native_helper import mark_snapshot_mutation
|
|
path, _ = prepared
|
|
snapshot = tmp_path / 'snapshot-job-a.tsv'
|
|
snapshot.write_text(f'M\t{tmp_path / "board.prj"}\tOLD\tNEW\tsheet:1\nC\tu1\tR1\t0\t0\t0\t0\t0\n')
|
|
(tmp_path / 'command.tsv').write_text('task_id\tjob_id\tproject_path\n'
|
|
f'task-a\tjob-a\t{tmp_path / "board.prj"}\n')
|
|
assert mark_snapshot_mutation(snapshot)['state'] == 'mutation_possible'
|
|
assert attempts.read_attempt(path)['state'] == 'mutation_possible'
|
|
|
|
|
|
def test_native_guard_rejects_other_project_before_marking(prepared, tmp_path):
|
|
from dx_productivity.trial_task_center.native_helper import mark_snapshot_mutation
|
|
path, _ = prepared
|
|
snapshot = tmp_path / 'snapshot-job-a.tsv'
|
|
snapshot.write_text(f'M\t{tmp_path / "other.prj"}\tOLD\tNEW\tsheet:1\nC\tu1\tR1\t0\t0\t0\t0\t0\n')
|
|
(tmp_path / 'command.tsv').write_text('task_id\tjob_id\tproject_path\n'
|
|
f'task-a\tjob-a\t{tmp_path / "board.prj"}\n')
|
|
with pytest.raises(ValueError):
|
|
mark_snapshot_mutation(snapshot)
|
|
assert attempts.read_attempt(path)['state'] == 'prepared'
|
|
|
|
|
|
def test_marker_cli_fails_closed_on_stale_job(prepared):
|
|
from dx_productivity.trial_task_center.application import main
|
|
path, record = prepared
|
|
assert main(['--mark-batch-attempt', '--attempt-job', 'other', '--attempt-task', 'task-a',
|
|
'--attempt-project', record['project_path']]) == 1
|
|
assert attempts.read_attempt(path)['state'] == 'prepared'
|
|
|
|
|
|
def test_native_failure_does_not_reuse_previous_attempt_transaction(prepared, tmp_path, monkeypatch):
|
|
from dx_productivity.trial_task_center import native_helper as native
|
|
path, _ = prepared
|
|
snapshot = tmp_path / 'snapshot-job-a.tsv'
|
|
snapshot.write_text(f'M\t{tmp_path / "board.prj"}\tOLD\tNEW\tsheet:1\nC\tu1\tR1\t0\t0\t0\t0\t0\n')
|
|
(tmp_path / 'command.tsv').write_text('task_id\tjob_id\tproject_path\n'
|
|
f'task-a\tjob-a\t{tmp_path / "board.prj"}\n')
|
|
report_path = tmp_path / 'snapshot-job-a.tsv.native.json'
|
|
report_path.write_text(json.dumps({'stage': 'native_replace_started',
|
|
'transaction': {'old': 'unrelated'}, 'batch_attempt': {'attempt_id': 'old'}}))
|
|
def unavailable_cad(snapshot, report):
|
|
raise RuntimeError('CAD unavailable before mutation')
|
|
monkeypatch.setattr(native, 'run_native', unavailable_cad)
|
|
assert native.run(snapshot) == 1
|
|
report = json.loads(report_path.read_text())
|
|
assert report['stage'] == 'preflight' and 'transaction' not in report
|
|
assert report['batch_attempt']['job_id'] == 'job-a'
|
|
assert attempts.read_attempt(path)['state'] == 'prepared'
|
|
|
|
def test_attempt_write_handles_long_unicode_evidence_and_keeps_canonical_identity(tmp_path, monkeypatch):
|
|
from pathlib import Path
|
|
directory = tmp_path / ('long-' + 'x' * 110) / ('more-' + 'y' * 80)
|
|
path = directory / 'attempt.json'
|
|
real_mkdir = Path.mkdir
|
|
def strict_mkdir(target, *args, **kwargs):
|
|
if len(str(target)) >= 260 and not str(target).startswith(chr(92) * 2 + '?'):
|
|
raise OSError('legacy MAX_PATH')
|
|
return real_mkdir(target, *args, **kwargs)
|
|
monkeypatch.setattr(Path, 'mkdir', strict_mkdir)
|
|
project = tmp_path / 'board.prj'
|
|
record = attempts.prepare_attempt(path, session_id='session', generation=1,
|
|
task_id='task', job_id='job', project_path=project)
|
|
assert record['project_path'] == os.path.normcase(str(project.resolve()))
|
|
assert attempts.can_retry_attempt(path, record)
|
|
assert not str(record['project_path']).startswith(chr(92) * 2 + '?')
|
|
|
|
|
|
def test_publication_retries_sharing_violation_only_and_keeps_original_record(tmp_path, monkeypatch):
|
|
path = tmp_path / 'attempt.json'
|
|
first = attempts.prepare_attempt(path, session_id='session', generation=1,
|
|
task_id='task', job_id='job', project_path=tmp_path / 'board.prj')
|
|
calls = []
|
|
def fail(source, target):
|
|
calls.append((source, target))
|
|
error = PermissionError('sharing violation')
|
|
error.winerror = 32
|
|
raise error
|
|
monkeypatch.setattr(os, 'replace', fail)
|
|
with pytest.raises(PermissionError):
|
|
attempts.prepare_attempt(path, session_id='session', generation=2,
|
|
task_id='task', job_id='job', project_path=tmp_path / 'board.prj')
|
|
assert len(calls) == 3
|
|
assert attempts.read_attempt(path) == first
|
|
assert list(tmp_path.iterdir()) == [path]
|