"""Synthetic contracts only: no instrument map, file publication, or music generation.""" import math from fractions import Fraction import pytest from jsonschema import Draft202012Validator from pydantic import BaseModel, TypeAdapter, ValidationError from riff_groove_builder.schemas import ( MAX_SCHEDULED_EVENTS, Artifact, ControlChangeEvent, DrumNote, EventPlan, EventTrack, GenerateMusicRequest, GenerationResult, ListInstrumentProfilesRequest, MusicalIntent, NoteOffEvent, NoteOnEvent, PitchedNote, PositiveBeat, ProfileListResult, ProfileSelection, ProfileSummary, RationalBeat, ResolvedGeneration, ScheduledEvent, Score, ScoreTrack, TimeSignature, tool_input_schema, ) def request(**updates: object) -> GenerateMusicRequest: return GenerateMusicRequest.model_validate( {"description": "A supported riff", "basename": "test_riff-1", **updates} ) @pytest.mark.parametrize( ("field", "value"), [ ("description", "x"), ("description", "x" * 4000), ("basename", "a"), ("basename", "A" * 64), ("parts", ["lead"]), ("parts", ["bass"]), ("parts", ["drums"]), ("parts", ["lead", "bass", "drums"]), ("formats", ["mid"]), ("formats", ["agp"]), ("formats", ["sdp"]), ("formats", ["mid", "agp", "sdp"]), ("tempo_bpm", 20), ("tempo_bpm", 300), ("tempo_bpm", 120.125), ("bars", 1), ("bars", 256), ("time_signature", {"numerator": 1, "denominator": 1}), ("time_signature", {"numerator": 16, "denominator": 16}), ("key", "E minor"), ("profiles", {}), ( "profiles", {"lead": "synthetic-lead", "bass": "synthetic-bass", "drums": "synthetic-drums"}, ), ("seed", 0), ("seed", 2_147_483_647), ("allow_midi_fallback", False), ("allow_midi_fallback", True), ], ) def test_request_valid_boundaries(field: str, value: object) -> None: model = request(**{field: value}) assert GenerateMusicRequest.model_validate_json(model.model_dump_json()) == model @pytest.mark.parametrize( ("field", "value"), [ ("description", ""), ("description", " \t\n"), ("description", "x" * 4001), ("description", 10), ("description", None), ("basename", ""), ("basename", "a" * 65), ("basename", 1), ("basename", None), ("parts", []), ("parts", ["lead", "lead"]), ("parts", ["guitar"]), ("parts", "lead"), ("formats", []), ("formats", ["mid", "mid"]), ("formats", ["wav"]), ("formats", "mid"), ("tempo_bpm", 19.999), ("tempo_bpm", 300.001), ("tempo_bpm", True), ("tempo_bpm", False), ("tempo_bpm", "120"), ("tempo_bpm", math.nan), ("tempo_bpm", math.inf), ("tempo_bpm", -math.inf), ("bars", 0), ("bars", 257), ("bars", True), ("bars", 4.0), ("bars", "4"), ("bars", math.nan), ("bars", math.inf), ("time_signature", {"numerator": 0, "denominator": 4}), ("time_signature", {"numerator": 17, "denominator": 4}), ("time_signature", {"numerator": True, "denominator": 4}), ("time_signature", {"numerator": 4.0, "denominator": 4}), ("time_signature", {"numerator": 4, "denominator": 3}), ("time_signature", {"numerator": 4, "denominator": True}), ("time_signature", {"numerator": 4, "denominator": 4.0}), ("time_signature", {"numerator": 4, "denominator": "4"}), ("time_signature", {"numerator": 4}), ("time_signature", {"numerator": 4, "denominator": 4, "extra": 1}), ("profiles", {"lead": ""}), ("profiles", {"bass": " "}), ("profiles", {"drums": 1}), ("profiles", {"guitar": "unknown"}), ("profiles", []), ("seed", -1), ("seed", 2_147_483_648), ("seed", True), ("seed", 0.0), ("seed", "0"), ("seed", None), ("allow_midi_fallback", 0), ("allow_midi_fallback", "true"), ("allow_midi_fallback", None), ("output_root", r"C:\private"), ], ) def test_request_invalid_boundaries(field: str, value: object) -> None: with pytest.raises(ValidationError): request(**{field: value}) @pytest.mark.parametrize( "basename", [ "CON", "con", "CoN", "PRN", "aux", "NUL", "COM1", "com9", "LPT1", "lPt9", "../escape", r"..\escape", "/absolute", r"C:\absolute", r"\\host\share", "a/b", "a\\b", ".", "..", "a.", "a ", " a", "a..b", "a:b", "a\n", "_riff", "-riff", "é", "CON.txt", "CONIN$", "COM¹", "a\x00", ], ) def test_unsafe_basenames(basename: str) -> None: with pytest.raises(ValidationError): request(basename=basename) @pytest.mark.parametrize("basename", ["CON_1", "con-riff", "COM0", "COM10", "LPT0", "NULx", "9"]) def test_safe_reserved_name_neighbors(basename: str) -> None: assert request(basename=basename).basename == basename @pytest.mark.parametrize( ("raw", "normalized"), [ ("C major", "C major"), (" db MINOR ", "C# minor"), ("Bb major", "A# major"), ("f# mAjOr", "F# major"), ("Cb minor", "B minor"), ("B# major", "C major"), ("E# minor", "F minor"), ("Fb major", "E major"), ("gb major", "F# major"), ("Ab minor", "G# minor"), ("E minor", "E minor"), ("E Minor", "E minor"), ("Em", "E minor"), ("em", "E minor"), (" F#m ", "F# minor"), ("Bbm", "A# minor"), ("Am", "A minor"), ("Cbm", "B minor"), ], ) def test_key_normalization(raw: str, normalized: str) -> None: Draft202012Validator(tool_input_schema("generate_music")).validate( {"description": "riff", "basename": "x", "key": raw} ) assert request(key=raw).key == normalized @pytest.mark.parametrize( "key", [ "C", "EM", "E m", "Emin", "Em major", "F##m", "BBm", "H major", "C dorian", "C major minor", "C major D minor", "C## major", "Dbb minor", "C#b major", "DB major", "D♭ major", "C\tmajor", "C\nmajor", "Cmajor", "C major\n", ], ) def test_invalid_keys(key: str) -> None: assert not Draft202012Validator(tool_input_schema("generate_music")).is_valid( {"description": "riff", "basename": "x", "key": key} ) with pytest.raises(ValidationError): request(key=key) def test_advertised_key_examples_match_schema_and_runtime() -> None: from riff_groove_builder.schemas import KEY_PATTERN schema = tool_input_schema("generate_music") key_schema = schema["properties"]["key"]["anyOf"][0] assert key_schema["pattern"] == KEY_PATTERN for example in key_schema["examples"]: assert request(key=example).key is not None Draft202012Validator(schema).validate( {"description": "riff", "basename": "x", "key": example} ) def test_omissions_do_not_resolve_intent_or_choose_profiles() -> None: minimal = request() assert minimal.model_fields_set == {"description", "basename"} assert minimal.model_dump(exclude_unset=True) == { "description": "A supported riff", "basename": "test_riff-1", } for field in ("parts", "formats", "tempo_bpm", "bars", "time_signature", "key", "profiles"): assert getattr(minimal, field) is None assert getattr(request(**{field: None}), field) is None assert minimal.seed == 0 assert minimal.allow_midi_fallback is True assert ProfileSelection().selected() == {} assert request(formats=["sdp"]).parts is None assert request(profiles={"drums": "synthetic"}).parts is None @pytest.mark.parametrize( "updates", [ {"parts": ["drums"], "formats": ["agp"]}, {"parts": ["bass"], "formats": ["sdp"]}, {"parts": ["lead"], "profiles": {"bass": "synthetic"}}, {"parts": ["bass", "drums"], "profiles": {"lead": "synthetic"}}, ], ) def test_explicit_incompatible_requests(updates: dict[str, object]) -> None: with pytest.raises(ValidationError, match="requires|selected parts"): request(**updates) @pytest.mark.parametrize("denominator", [1, 2, 4, 8, 16]) def test_exact_meter(denominator: int) -> None: assert TimeSignature.model_validate( {"numerator": 7, "denominator": denominator} ).beats_per_bar == Fraction(28, denominator) def summary(**updates: object) -> ProfileSummary: return ProfileSummary.model_validate( { "id": "synthetic-only", "part": "lead", "instrument": "eclips", "product_name": "Synthetic test metadata", "product_version": "test", "mapping_version": "test", "midi_available": False, "native_format": "griff", "native_available": False, "supported_articulations": [], "limitations": ["No verified map or native capability."], **updates, } ) def test_profile_list_empty_and_unavailable_summaries() -> None: assert ListInstrumentProfilesRequest.model_validate({}).model_dump() == {} assert ProfileListResult(profiles=[]).model_dump() == {"profiles": []} unavailable = summary() assert unavailable.mapping_kind == "instrument" assert unavailable.model_dump()["mapping_kind"] == "instrument" assert ProfileSummary.model_json_schema()["properties"]["mapping_kind"]["default"] == ( "instrument" ) available = summary( id="other-synthetic", midi_available=True, native_available=True, supported_articulations=["sustain"], limitations=[], ) assert len(ProfileListResult(profiles=[unavailable, available]).profiles) == 2 with pytest.raises(ValidationError, match="unique"): ProfileListResult(profiles=[unavailable, unavailable]) with pytest.raises(ValidationError): ListInstrumentProfilesRequest.model_validate({"extra": 1}) @pytest.mark.parametrize( "updates", [ {"part": "bass"}, {"instrument": "sd3"}, {"native_format": "sdp"}, {"limitations": []}, {"midi_available": 1}, {"native_available": "false"}, {"id": " "}, {"supported_articulations": ["sustain", "sustain"]}, {"limitations": ["same", "same"]}, {"private_path": "must not be exposed"}, {"mapping_kind": "gm"}, {"mapping_kind": True}, {"mapping_kind": "standard_midi", "supported_articulations": ["slide"]}, { "mapping_kind": "standard_midi", "supported_articulations": ["normal"], "native_available": True, }, ], ) def test_invalid_profile_summaries(updates: dict[str, object]) -> None: with pytest.raises(ValidationError): summary(**updates) def intent() -> MusicalIntent: return MusicalIntent.model_validate( { "description": "Synthetic score only", "parts": ["lead"], "tempo_bpm": 120, "bars": 1, "time_signature": {"numerator": 7, "denominator": 8}, "key": "E minor", "seed": 0, } ) def note(**updates: object) -> PitchedNote: return PitchedNote.model_validate( { "part": "lead", "pitch": 60, "start": {"numerator": 1, "denominator": 3}, "duration": {"numerator": 1, "denominator": 3}, "intensity": 0.5, "articulation": "synthetic", **updates, } ) def score() -> Score: return Score( intent=intent(), start=RationalBeat(numerator=0), end=RationalBeat(numerator=7, denominator=2), tracks=[ScoreTrack(part="lead", notes=[note()])], ) def test_rational_beats_and_score_round_trip() -> None: assert RationalBeat(numerator=2, denominator=6).model_dump() == { "numerator": 1, "denominator": 3, } assert RationalBeat(numerator=0, denominator=17).value == 0 model = score() assert model.intent.duration_beats == Fraction(7, 2) restored = Score.model_validate_json(model.model_dump_json()) assert restored == model logical = restored.tracks[0].notes[0] assert logical.start.value + logical.duration.value == Fraction(2, 3) assert sum((logical.duration.value for _ in range(300)), Fraction()) == 100 assert ( DrumNote.model_validate( { "voice": "synthetic_voice", "start": {"numerator": 0}, "duration": {"numerator": 1}, "intensity": 1, "articulation": "synthetic", } ).part == "drums" ) @pytest.mark.parametrize( ("model", "payload"), [ (RationalBeat, {"numerator": -1}), (RationalBeat, {"numerator": True}), (RationalBeat, {"numerator": 1.0}), (RationalBeat, {"numerator": 1, "denominator": 0}), (RationalBeat, {"numerator": 1, "denominator": -3}), (RationalBeat, {"numerator": 1, "denominator": False}), (RationalBeat, {"numerator": 1, "denominator": 3.0}), (RationalBeat, {"value": "1/3"}), (PositiveBeat, {"numerator": 0}), ], ) def test_invalid_rational_timing(model: type[BaseModel], payload: dict[str, object]) -> None: with pytest.raises(ValidationError): model.model_validate(payload) @pytest.mark.parametrize( "updates", [ {"pitch": -1}, {"pitch": 128}, {"pitch": True}, {"pitch": 60.0}, {"part": "drums"}, {"voice": "kick"}, {"articulation": " "}, {"start": 0.5}, {"duration": {"numerator": 0}}, {"intensity": -0.01}, {"intensity": 1.01}, {"intensity": True}, {"intensity": math.nan}, {"intensity": math.inf}, {"intensity": -math.inf}, ], ) def test_invalid_logical_notes(updates: dict[str, object]) -> None: with pytest.raises(ValidationError): note(**updates) @pytest.mark.parametrize("pitch", [0, 127]) @pytest.mark.parametrize("intensity", [0, 1]) def test_logical_midi_range_not_instrument_certification(pitch: int, intensity: int) -> None: assert note(pitch=pitch, intensity=intensity).pitch == pitch def test_invalid_score_invariants() -> None: data = score().model_dump() updates: list[dict[str, object]] = [ {"tracks": []}, {"tracks": [score().tracks[0].model_dump()] * 2}, {"end": {"numerator": 0}}, {"end": {"numerator": 4}}, {"start": {"numerator": 1}}, {"tracks": [{"part": "bass", "notes": [note().model_dump()]}]}, {"tracks": [{"part": "lead", "notes": [note(start={"numerator": 4}).model_dump()]}]}, ] for update in updates: with pytest.raises(ValidationError): Score.model_validate({**data, **update}) with pytest.raises(ValidationError): MusicalIntent.model_validate({**intent().model_dump(), "parts": []}) def event(**updates: object) -> NoteOnEvent: return NoteOnEvent.model_validate( { "tick": 0, "part": "lead", "channel": 0, "priority": 2, "sequence": 0, "role": "musical_note", "note": 60, "velocity": 100, **updates, } ) @pytest.mark.parametrize( "updates", [ {"tick": -1}, {"tick": True}, {"tick": 0.0}, {"channel": -1}, {"channel": 16}, {"channel": True}, {"channel": 1.0}, {"priority": -1}, {"priority": False}, {"sequence": -1}, {"note": -1}, {"note": 128}, {"note": True}, {"velocity": 0}, {"velocity": 128}, {"velocity": True}, {"velocity": 1.0}, {"role": "articulation_control"}, {"kind": "control_change"}, {"controller": 1}, {"value": 2}, {"part": "guitar"}, ], ) def test_invalid_note_on_events(updates: dict[str, object]) -> None: with pytest.raises(ValidationError): event(**updates) def test_discriminated_events_and_ranges() -> None: adapter = TypeAdapter(ScheduledEvent) for channel in (0, 15): for number in (0, 127): on = event(channel=channel, note=number, velocity=127, role="keyswitch") assert adapter.validate_json(on.model_dump_json()) == on base = {"tick": 0, "part": "lead", "channel": 0, "priority": 0, "sequence": 1} off = NoteOffEvent.model_validate({**base, "role": "keyswitch", "note": 0}) assert off.velocity == 0 for number in (0, 127): cc = ControlChangeEvent.model_validate({**base, "controller": number, "value": number}) assert adapter.validate_json(cc.model_dump_json()) == cc for update in ( {"controller": -1}, {"controller": 128}, {"controller": True}, {"value": -1}, {"value": 128}, {"value": True}, {"note": 2}, {"velocity": 1}, {"role": "keyswitch"}, ): with pytest.raises(ValidationError): ControlChangeEvent.model_validate({**cc.model_dump(), **update}) for velocity in (-1, 128, True, 0.0): with pytest.raises(ValidationError): NoteOffEvent.model_validate({**off.model_dump(), "velocity": velocity}) with pytest.raises(ValidationError): adapter.validate_python({**event().model_dump(), "kind": "unknown"}) with pytest.raises(ValidationError): EventTrack(part="bass", events=[event()]) with pytest.raises(ValidationError, match="ordering keys"): EventTrack(part="lead", events=[event(), event()]) def plan(**updates: object) -> EventPlan: return EventPlan.model_validate( { "score": score(), "musical_start_tick": 24, "musical_end_tick": 3384, "end_tick": 3400, "tracks": [ { "part": "lead", "events": [ event(tick=0, role="keyswitch").model_dump(), event(tick=24, sequence=1).model_dump(), ], } ], **updates, } ) def test_event_plan_metadata_not_a_scheduler() -> None: model = plan() assert model.tracks[0].events[0].ordering_key == (0, 2, 0) assert model.musical_end_tick - model.musical_start_tick == 3360 assert EventPlan.model_validate_json(model.model_dump_json()) == model @pytest.mark.parametrize( "updates", [ {"musical_start_tick": -1}, {"musical_end_tick": 20}, {"musical_end_tick": 3385}, {"end_tick": 3383}, {"end_tick": True}, {"ticks_per_quarter": 0}, {"ticks_per_quarter": True}, {"tracks": []}, {"tracks": [{"part": "bass", "events": []}]}, {"tracks": [{"part": "lead", "events": [event(tick=3401).model_dump()]}]}, {"tracks": [{"part": "lead", "events": [event(tick=0).model_dump()]}]}, {"tracks": [{"part": "lead", "events": [event(tick=3384).model_dump()]}]}, ], ) def test_invalid_event_plans(updates: dict[str, object]) -> None: with pytest.raises(ValidationError): plan(**updates) def test_event_budget_boundary() -> None: payload = plan().model_dump() events = [event(tick=24, sequence=index).model_dump() for index in range(MAX_SCHEDULED_EVENTS)] tracks = [{"part": "lead", "events": events}] assert len(EventPlan.model_validate({**payload, "tracks": tracks}).tracks[0].events) == 100_000 events.append(event(tick=24, sequence=MAX_SCHEDULED_EVENTS).model_dump()) with pytest.raises(ValidationError, match="100,000"): EventPlan.model_validate({**payload, "tracks": tracks}) def result_data() -> dict[str, object]: return { "status": "complete", "resolved": { "parts": ["lead"], "tempo_bpm": 120, "bars": 1, "time_signature": {"numerator": 4, "denominator": 4}, "key": "E minor", "seed": 0, "profile_ids": {"lead": "synthetic-only"}, "assumptions": [], "overrides": [], "musical_start_tick": 0, "musical_end_tick": 3840, "ticks_per_quarter": 960, }, "artifacts": [ { "format": "mid", "parts": ["lead"], "path": r"C:\synthetic\test.mid", "size_bytes": 64, "profile_ids": ["synthetic-only"], "fallback_for": [], } ], "warnings": [], } def test_success_and_fallback_result_invariants() -> None: complete = GenerationResult.model_validate(result_data()) assert GenerationResult.model_validate_json(complete.model_dump_json()) == complete data = complete.model_dump() data["status"] = "midi_fallback" data["artifacts"][0]["fallback_for"] = ["lead"] data["warnings"] = [ {"code": "NATIVE_FORMAT_UNAVAILABLE", "part": "lead", "message": "Synthetic limitation."} ] fallback = GenerationResult.model_validate(data) assert GenerationResult.model_validate_json(fallback.model_dump_json()) == fallback assert ( GenerationResult.model_validate( { **complete.model_dump(), "warnings": [{"code": "ASSUMPTION", "part": None, "message": "Test"}], } ).status == "complete" ) assert Artifact.model_validate( { **complete.artifacts[0].model_dump(), "format": "griff", "path": r"C:\synthetic\test.griff", } ).parts == ["lead"] assert Artifact.model_validate( { **complete.artifacts[0].model_dump(), "format": "sd3p", "path": r"C:\synthetic\test.sd3p", "parts": ["drums"], "profile_ids": ["synthetic-drums"], } ).parts == ["drums"] @pytest.mark.parametrize( "updates", [ {"format": "wav"}, {"size_bytes": 0}, {"size_bytes": -1}, {"size_bytes": True}, {"size_bytes": 64.0}, {"parts": []}, {"parts": ["lead", "lead"]}, {"format": "agp", "parts": ["lead", "bass"]}, {"format": "agp", "parts": ["drums"]}, {"format": "sdp", "parts": ["lead"]}, {"format": "agp", "fallback_for": ["lead"]}, {"fallback_for": ["drums"]}, {"fallback_for": ["lead", "lead"]}, {"path": "relative.mid"}, {"path": r"C:relative.mid"}, {"path": r"\relative.mid"}, {"path": "C:\\file\n.mid"}, {"profile_ids": []}, {"profile_ids": ["synthetic-only", "synthetic-only"]}, ], ) def test_invalid_artifacts(updates: dict[str, object]) -> None: artifact = GenerationResult.model_validate(result_data()).artifacts[0] with pytest.raises(ValidationError): Artifact.model_validate({**artifact.model_dump(), **updates}) def test_invalid_claimed_results() -> None: good = GenerationResult.model_validate(result_data()) artifact = good.artifacts[0].model_dump() resolved = good.resolved.model_dump() warning = {"code": "NATIVE_FORMAT_UNAVAILABLE", "part": "lead", "message": "Synthetic"} updates: list[dict[str, object]] = [ {"status": "success"}, {"artifacts": []}, {"artifacts": [artifact, artifact]}, {"artifacts": [{**artifact, "profile_ids": ["wrong"]}]}, {"artifacts": [{**artifact, "parts": ["bass"]}]}, {"artifacts": [{**artifact, "fallback_for": ["lead"]}]}, {"warnings": [warning]}, {"warnings": [{**warning, "part": "bass", "code": "OTHER"}]}, {"status": "midi_fallback"}, {"status": "midi_fallback", "warnings": [warning]}, {"status": "midi_fallback", "artifacts": [{**artifact, "fallback_for": ["lead"]}]}, {"resolved": {**resolved, "musical_end_tick": -1}}, {"resolved": {**resolved, "musical_start_tick": 5000}}, {"resolved": {**resolved, "profile_ids": {}}}, {"resolved": {**resolved, "profile_ids": {"lead": "synthetic-only", "bass": "other"}}}, { "resolved": { **resolved, "parts": ["lead", "bass"], "profile_ids": {"lead": "synthetic-only", "bass": "other"}, } }, { "status": "midi_fallback", "warnings": [warning], "artifacts": [{**artifact, "fallback_for": ["lead"]}, {**artifact, "format": "agp"}], }, { "status": "midi_fallback", "warnings": [{**warning, "part": None}], "artifacts": [{**artifact, "fallback_for": ["lead"]}], }, ] for update in updates: with pytest.raises(ValidationError): GenerationResult.model_validate({**good.model_dump(), **update}) assert ( ResolvedGeneration.model_validate({**resolved, "musical_start_tick": 3840}).musical_end_tick == 3840 ) @pytest.mark.parametrize( "model", [ request(), summary(), score(), note(), plan(), event(), TimeSignature(numerator=4, denominator=4), ProfileSelection(), ProfileListResult(profiles=[]), GenerationResult.model_validate(result_data()), ], ) def test_unknown_fields_forbidden_on_all_contract_layers(model: BaseModel) -> None: with pytest.raises(ValidationError, match="Extra inputs"): type(model).model_validate({**model.model_dump(), "unsupported": True})