422 lines
16 KiB
Python
422 lines
16 KiB
Python
"""Real description-to-disk publication, failure injection, competition and junctions."""
|
|
|
|
import os
|
|
import shutil
|
|
import subprocess
|
|
import uuid
|
|
from collections.abc import Callable, Iterator
|
|
from concurrent.futures import ThreadPoolExecutor
|
|
from pathlib import Path
|
|
from threading import Barrier
|
|
from unittest.mock import patch
|
|
|
|
import mido # type: ignore[import-untyped]
|
|
import pytest
|
|
from jsonschema import Draft202012Validator
|
|
from pydantic import ValidationError
|
|
|
|
from riff_groove_builder.articulations import compile_score
|
|
from riff_groove_builder.compose import compose_score
|
|
from riff_groove_builder.description import resolve_description
|
|
from riff_groove_builder.errors import (
|
|
DomainError,
|
|
NativeFormatUnavailableError,
|
|
OutputExistsError,
|
|
OutputIOError,
|
|
SerializationError,
|
|
)
|
|
from riff_groove_builder.midi import validate_midi_file, write_midi
|
|
from riff_groove_builder.profiles import load_profile_registry
|
|
from riff_groove_builder.schemas import (
|
|
EventPlan,
|
|
GenerateMusicRequest,
|
|
GenerationResult,
|
|
Part,
|
|
ProfileSelection,
|
|
tool_output_schema,
|
|
)
|
|
from riff_groove_builder.service import GenerationService, _Stage
|
|
|
|
ROOT = Path(__file__).resolve().parents[2]
|
|
pytestmark = pytest.mark.integration
|
|
|
|
|
|
@pytest.fixture
|
|
def workspace() -> Iterator[Path]:
|
|
path = ROOT / ".test-artifacts" / f"generation-{uuid.uuid4().hex}"
|
|
path.mkdir(parents=True)
|
|
try:
|
|
yield path
|
|
finally:
|
|
shutil.rmtree(path)
|
|
|
|
|
|
def request(**updates: object) -> GenerateMusicRequest:
|
|
job = GenerateMusicRequest.model_validate(
|
|
{
|
|
"description": "lead bass drums 137.5 BPM 2 bars 7/8 Bb minor quarter rests",
|
|
"basename": "song",
|
|
"seed": 42,
|
|
**updates,
|
|
}
|
|
)
|
|
if job.profiles is None:
|
|
job.profiles = ProfileSelection(
|
|
**{
|
|
part: "standard.gm-drums.v1" if part == "drums" else f"standard.{part}.v1"
|
|
for part in resolve_description(job).intent.parts
|
|
}
|
|
)
|
|
return job
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"parts", [["lead"], ["bass"], ["drums"], ["lead", "bass", "drums"], ["drums", "bass"]]
|
|
)
|
|
def test_actual_saved_midi_and_resolved_schema(workspace: Path, parts: list[Part]) -> None:
|
|
job = request(parts=parts)
|
|
result = GenerationService(workspace).generate_music(job)
|
|
Draft202012Validator(tool_output_schema("generate_music")).validate(
|
|
result.model_dump(mode="json")
|
|
)
|
|
assert GenerationResult.model_validate_json(result.model_dump_json()) == result
|
|
resolved = result.resolved
|
|
assert resolved.parts == parts
|
|
assert resolved.tempo_bpm == 137.5
|
|
assert resolved.bars == 2
|
|
assert resolved.time_signature.model_dump() == {"numerator": 7, "denominator": 8}
|
|
assert resolved.key == "A# minor"
|
|
assert resolved.seed == 42
|
|
assert resolved.overrides and resolved.assumptions
|
|
assert resolved.musical_start_tick == 0 and resolved.musical_end_tick == 6720
|
|
artifact = result.artifacts[0]
|
|
assert artifact.parts == artifact.fallback_for == parts
|
|
path = Path(artifact.path)
|
|
assert path.is_absolute() and path == workspace / "song" / "song.mid"
|
|
assert artifact.size_bytes == path.stat().st_size == len(path.read_bytes())
|
|
assert path.read_bytes()[:4] == b"MThd"
|
|
midi = mido.MidiFile(path)
|
|
assert midi.type == 1 and midi.ticks_per_beat == 960
|
|
assert [track.name for track in midi.tracks] == [
|
|
"Conductor",
|
|
*(part.capitalize() for part in parts),
|
|
]
|
|
assert [sum(message.time for message in track) for track in midi.tracks] == [6720] * (
|
|
len(parts) + 1
|
|
)
|
|
conductor = midi.tracks[0]
|
|
assert next(msg.tempo for msg in conductor if msg.type == "set_tempo") == round(
|
|
60_000_000 / 137.5
|
|
)
|
|
meter = next(msg for msg in conductor if msg.type == "time_signature")
|
|
assert (meter.numerator, meter.denominator) == (7, 8)
|
|
for part, track in zip(parts, midi.tracks[1:], strict=True):
|
|
channel = {"lead": 0, "bass": 1, "drums": 9}[part]
|
|
notes = [message for message in track if message.type == "note_on"]
|
|
assert notes and all(
|
|
note.channel == channel and 1 <= note.velocity <= 127 for note in notes
|
|
)
|
|
assert all(message.is_meta or message.type in ("note_on", "note_off") for message in track)
|
|
if part == "drums":
|
|
assert {note.note for note in notes} == {36, 38, 42}
|
|
resolution = resolve_description(job)
|
|
assert job.profiles is not None
|
|
selected = load_profile_registry().select(parts, job.profiles)
|
|
validate_midi_file(path, compile_score(compose_score(resolution.intent, selected), selected))
|
|
assert list(workspace.iterdir()) == [path.parent]
|
|
assert list(path.parent.iterdir()) == [path]
|
|
assert "description" not in result.model_dump_json()
|
|
|
|
|
|
def test_midi_only_is_complete_and_native_only_substitutes_all_parts(workspace: Path) -> None:
|
|
service = GenerationService(workspace)
|
|
direct = service.generate_music(request(basename="direct", formats=["mid"]))
|
|
native = service.generate_music(request(basename="native", formats=["agp", "sdp"]))
|
|
assert direct.status == "complete" and direct.artifacts[0].fallback_for == []
|
|
assert native.status == "midi_fallback"
|
|
assert native.artifacts[0].fallback_for == ["lead", "bass", "drums"]
|
|
assert len(direct.warnings) == 3 and len(native.warnings) == 6
|
|
assert (
|
|
Path(direct.artifacts[0].path).read_bytes() == Path(native.artifacts[0].path).read_bytes()
|
|
)
|
|
assert not list(workspace.rglob("*.agp")) and not list(workspace.rglob("*.sdp"))
|
|
with pytest.raises(NativeFormatUnavailableError):
|
|
service.generate_music(request(basename="disabled", allow_midi_fallback=False))
|
|
assert not (workspace / "disabled").exists()
|
|
assert not list(workspace.glob(".riff-stage-*"))
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("operation", "failure", "code"),
|
|
[
|
|
(
|
|
"write_midi",
|
|
SerializationError(details={"reason": "serializer_failed"}),
|
|
"SERIALIZATION_ERROR",
|
|
),
|
|
("write_midi", OutputIOError(details={"reason": "midi_write_failed"}), "OUTPUT_IO_ERROR"),
|
|
(
|
|
"validate_midi_file",
|
|
SerializationError(details={"reason": "smf_content_mismatch"}),
|
|
"SERIALIZATION_ERROR",
|
|
),
|
|
(
|
|
"validate_midi_file",
|
|
OutputIOError(details={"reason": "midi_read_failed"}),
|
|
"OUTPUT_IO_ERROR",
|
|
),
|
|
("validate_midi_file", PermissionError("private-path"), "OUTPUT_IO_ERROR"),
|
|
],
|
|
)
|
|
def test_write_read_failures_leave_no_partial_final_or_stage(
|
|
workspace: Path, operation: str, failure: Exception, code: str
|
|
) -> None:
|
|
sentinel = workspace / "sentinel"
|
|
sentinel.write_bytes(b"unrelated operator data")
|
|
before = sentinel.stat()
|
|
with patch(f"riff_groove_builder.service.{operation}", side_effect=failure):
|
|
with pytest.raises(DomainError) as captured:
|
|
GenerationService(workspace).generate_music(request())
|
|
assert captured.value.code == code
|
|
assert list(workspace.iterdir()) == [sentinel]
|
|
assert sentinel.read_bytes() == b"unrelated operator data"
|
|
assert (sentinel.stat().st_ino, sentinel.stat().st_mtime_ns) == (
|
|
before.st_ino,
|
|
before.st_mtime_ns,
|
|
)
|
|
|
|
|
|
def test_partial_write_is_cleaned_and_not_reported_as_fallback(workspace: Path) -> None:
|
|
def failed_write(
|
|
path: Path, _plan: EventPlan, *, on_created: Callable[[os.stat_result], None]
|
|
) -> Path:
|
|
with path.open("xb") as stream:
|
|
on_created(os.fstat(stream.fileno()))
|
|
stream.write(b"partial bytes")
|
|
raise OutputIOError(details={"reason": "midi_write_failed"})
|
|
|
|
with (
|
|
patch("riff_groove_builder.service.write_midi", side_effect=failed_write),
|
|
pytest.raises(OutputIOError) as captured,
|
|
):
|
|
GenerationService(workspace).generate_music(request())
|
|
assert captured.value.details["reason"] == "midi_write_failed"
|
|
assert not list(workspace.iterdir())
|
|
|
|
|
|
def test_actual_corruption_fails_readback_and_cleans(workspace: Path) -> None:
|
|
def corrupt(
|
|
path: Path, plan: EventPlan, *, on_created: Callable[[os.stat_result], None]
|
|
) -> Path:
|
|
write_midi(path, plan, on_created=on_created)
|
|
path.write_bytes(b"not MIDI")
|
|
return path
|
|
|
|
with (
|
|
patch("riff_groove_builder.service.write_midi", side_effect=corrupt),
|
|
pytest.raises(SerializationError),
|
|
):
|
|
GenerationService(workspace).generate_music(request())
|
|
assert not list(workspace.iterdir())
|
|
|
|
|
|
def test_result_model_failure_precedes_publication(workspace: Path) -> None:
|
|
with pytest.raises(ValidationError) as captured:
|
|
GenerationResult.model_validate({})
|
|
with (
|
|
patch(
|
|
"riff_groove_builder.service.GenerationResult.model_validate",
|
|
side_effect=captured.value,
|
|
),
|
|
pytest.raises(SerializationError) as error,
|
|
):
|
|
GenerationService(workspace).generate_music(request())
|
|
assert error.value.details["reason"] == "invalid_generation_result"
|
|
assert not list(workspace.iterdir())
|
|
|
|
|
|
def test_unexpected_bug_propagates_but_owned_stage_is_cleaned(workspace: Path) -> None:
|
|
with (
|
|
patch("riff_groove_builder.service.validate_midi_file", side_effect=RuntimeError("bug")),
|
|
pytest.raises(RuntimeError, match="bug"),
|
|
):
|
|
GenerationService(workspace).generate_music(request())
|
|
assert not list(workspace.iterdir())
|
|
|
|
|
|
def test_file_change_during_readback_is_not_published(workspace: Path) -> None:
|
|
def change(path: Path, plan: EventPlan) -> None:
|
|
validate_midi_file(path, plan)
|
|
with path.open("ab") as handle:
|
|
handle.write(b"changed after readback")
|
|
|
|
with (
|
|
patch("riff_groove_builder.service.validate_midi_file", side_effect=change),
|
|
pytest.raises(OutputIOError) as captured,
|
|
):
|
|
GenerationService(workspace).generate_music(request())
|
|
assert captured.value.details == {"reason": "staged_content_changed"}
|
|
assert not list(workspace.iterdir())
|
|
|
|
|
|
def test_root_change_mid_generation_refuses_unsafe_cleanup(workspace: Path) -> None:
|
|
root = workspace / "outputs"
|
|
root.mkdir()
|
|
service = GenerationService(root)
|
|
moved = workspace / "original-root"
|
|
|
|
def change_root(
|
|
path: Path, plan: EventPlan, *, on_created: Callable[[os.stat_result], None]
|
|
) -> Path:
|
|
write_midi(path, plan, on_created=on_created)
|
|
root.rename(moved)
|
|
root.mkdir()
|
|
(root / "sentinel").write_bytes(b"replacement data")
|
|
return path
|
|
|
|
with (
|
|
patch("riff_groove_builder.service.write_midi", side_effect=change_root),
|
|
pytest.raises(OutputIOError) as captured,
|
|
):
|
|
service.generate_music(request())
|
|
assert captured.value.details == {
|
|
"reason": "stage_cleanup_failed",
|
|
"original_code": "OUTPUT_IO_ERROR",
|
|
}
|
|
assert list(root.iterdir()) == [root / "sentinel"]
|
|
assert (root / "sentinel").read_bytes() == b"replacement data"
|
|
assert len(list(moved.glob(".riff-stage-*"))) == 1
|
|
assert not (root / "song").exists() and not (moved / "song").exists()
|
|
|
|
|
|
def test_publication_failure_is_io_and_cleans_complete_stage(workspace: Path) -> None:
|
|
with patch.object(Path, "rename", side_effect=PermissionError("private-path")):
|
|
with pytest.raises(OutputIOError) as captured:
|
|
GenerationService(workspace).generate_music(request())
|
|
assert captured.value.details == {"reason": "publication_failed"}
|
|
assert not list(workspace.iterdir())
|
|
|
|
|
|
def test_cleanup_failure_is_explicit_and_does_not_delete_other_files(workspace: Path) -> None:
|
|
sentinel = workspace / "sentinel"
|
|
sentinel.write_bytes(b"preserved")
|
|
with (
|
|
patch.object(Path, "rename", side_effect=PermissionError("private-path")),
|
|
patch.object(Path, "unlink", side_effect=PermissionError("private-cleanup")),
|
|
pytest.raises(OutputIOError) as captured,
|
|
):
|
|
GenerationService(workspace).generate_music(request())
|
|
assert captured.value.details == {
|
|
"reason": "stage_cleanup_failed",
|
|
"original_code": "OUTPUT_IO_ERROR",
|
|
}
|
|
assert not (workspace / "song").exists()
|
|
stages = list(workspace.glob(".riff-stage-*"))
|
|
assert len(stages) == 1 and (stages[0] / "song.mid").read_bytes().startswith(b"MThd")
|
|
assert sentinel.read_bytes() == b"preserved"
|
|
shutil.rmtree(stages[0])
|
|
|
|
|
|
def test_concurrent_same_name_has_exactly_one_winner(workspace: Path) -> None:
|
|
barrier = Barrier(2)
|
|
publish = GenerationService._publish
|
|
|
|
def synchronized(self: GenerationService, stage: _Stage, destination: Path) -> None:
|
|
barrier.wait(timeout=15)
|
|
publish(self, stage, destination)
|
|
|
|
def run(service: GenerationService) -> GenerationResult | DomainError:
|
|
try:
|
|
return service.generate_music(request())
|
|
except DomainError as error:
|
|
return error
|
|
|
|
services = [GenerationService(workspace), GenerationService(workspace)]
|
|
with patch.object(GenerationService, "_publish", synchronized), ThreadPoolExecutor(2) as pool:
|
|
results = list(pool.map(run, services))
|
|
assert len([result for result in results if isinstance(result, GenerationResult)]) == 1
|
|
losers = [result for result in results if isinstance(result, DomainError)]
|
|
assert len(losers) == 1 and isinstance(losers[0], OutputExistsError)
|
|
assert list(workspace.iterdir()) == [workspace / "song"]
|
|
assert list((workspace / "song").iterdir()) == [workspace / "song" / "song.mid"]
|
|
assert mido.MidiFile(workspace / "song" / "song.mid").type == 1
|
|
|
|
|
|
def junction(link: Path, target: Path) -> None:
|
|
result = subprocess.run(
|
|
[os.environ["COMSPEC"], "/d", "/c", "mklink", "/J", str(link), str(target)],
|
|
capture_output=True,
|
|
timeout=15,
|
|
check=False,
|
|
)
|
|
if result.returncode:
|
|
pytest.skip("Windows junction creation unavailable in this environment")
|
|
assert link.lstat().st_file_attributes & 0x400
|
|
|
|
|
|
@pytest.mark.skipif(os.name != "nt", reason="Real Windows junction/reparse checks")
|
|
@pytest.mark.parametrize("location", ["root", "ancestor", "pinned-root", "destination", "stage"])
|
|
def test_real_windows_junctions_cannot_redirect_generation(workspace: Path, location: str) -> None:
|
|
outside = workspace / "outside"
|
|
outside.mkdir()
|
|
sentinel = outside / "song.mid"
|
|
sentinel.write_bytes(b"outside sentinel")
|
|
root = workspace / "outputs"
|
|
link = workspace / "link"
|
|
if location in ("root", "ancestor"):
|
|
(outside / "nested").mkdir()
|
|
junction(link, outside)
|
|
try:
|
|
with pytest.raises(ValueError, match="existing local directory"):
|
|
GenerationService(link if location == "root" else link / "nested")
|
|
finally:
|
|
link.rmdir()
|
|
else:
|
|
root.mkdir()
|
|
service = GenerationService(root)
|
|
if location == "pinned-root":
|
|
root.rename(workspace / "original-root")
|
|
junction(root, outside)
|
|
try:
|
|
with pytest.raises(OutputIOError) as captured:
|
|
service.generate_music(request())
|
|
assert captured.value.details["reason"] == "output_root_changed"
|
|
finally:
|
|
root.rmdir()
|
|
elif location == "destination":
|
|
link = root / "song"
|
|
junction(link, outside)
|
|
try:
|
|
with pytest.raises(OutputExistsError):
|
|
service.generate_music(request())
|
|
finally:
|
|
link.rmdir()
|
|
else:
|
|
links: list[Path] = []
|
|
|
|
def redirect(
|
|
path: Path, plan: EventPlan, *, on_created: Callable[[os.stat_result], None]
|
|
) -> Path:
|
|
write_midi(path, plan, on_created=on_created)
|
|
path.parent.rename(root / "moved-stage")
|
|
junction(path.parent, outside)
|
|
links.append(path.parent)
|
|
return path
|
|
|
|
try:
|
|
with (
|
|
patch("riff_groove_builder.service.write_midi", side_effect=redirect),
|
|
pytest.raises(OutputIOError) as error,
|
|
):
|
|
service.generate_music(request())
|
|
assert error.value.details == {
|
|
"reason": "stage_cleanup_failed",
|
|
"original_code": "OUTPUT_IO_ERROR",
|
|
}
|
|
assert not (root / "song").exists()
|
|
finally:
|
|
for item in links:
|
|
item.rmdir()
|
|
assert sentinel.read_bytes() == b"outside sentinel"
|
|
assert not list(outside.glob("*.agp")) and not list(outside.glob("*.sdp"))
|