Cubase-MCP-GAJ3T.MusicGen.R.../tests/integration/test_contracts.py

364 lines
14 KiB
Python

"""Model/JSON Schema integration with synthetic in-memory data, never real outputs."""
import json
import subprocess
import sys
from fractions import Fraction
import pytest
from jsonschema import Draft202012Validator
from pydantic import ValidationError
from riff_groove_builder.schemas import (
GENERATION_OUTPUT,
PROFILE_LIST_OUTPUT,
EventPlan,
GenerateMusicRequest,
GenerationError,
GenerationResult,
ListInstrumentProfilesRequest,
ProfileListResult,
ToolName,
tool_input_schema,
tool_output_schema,
)
@pytest.mark.parametrize(
("parts", "formats"),
[
(["lead"], ["mid", "agp"]),
(["bass"], ["agp"]),
(["drums"], ["sdp"]),
(["lead", "bass"], ["mid", "agp"]),
(["lead", "bass", "drums"], ["mid", "agp", "sdp"]),
],
)
def test_representative_requests(parts: list[str], formats: list[str]) -> None:
data = {
"description": "Synthetic contract example, not interpreted here.",
"basename": "contract-1",
"parts": parts,
"formats": formats,
"tempo_bpm": 120.5,
"profiles": {part: f"synthetic-{part}" for part in parts},
}
schema = tool_input_schema("generate_music")
Draft202012Validator(schema).validate(data)
model = GenerateMusicRequest.model_validate(data)
serialized = model.model_dump_json(exclude_unset=True)
Draft202012Validator(schema).validate(json.loads(serialized))
restored = GenerateMusicRequest.model_validate_json(serialized)
assert restored == model
assert restored.model_fields_set == model.model_fields_set
assert restored.bars is None and restored.key is None and restored.time_signature is None
assert "bars" not in json.loads(serialized)
@pytest.mark.parametrize("tool", ["list_instrument_profiles", "generate_music"])
def test_schemas_are_valid_independent_and_explicit(tool: ToolName) -> None:
input_schema = tool_input_schema(tool)
output_schema = tool_output_schema(tool)
Draft202012Validator.check_schema(input_schema)
Draft202012Validator.check_schema(output_schema)
assert input_schema["additionalProperties"] is False
assert output_schema["type"] == "object"
assert len(output_schema["oneOf"]) == 2
input_schema["additionalProperties"] = True
output_schema.clear()
assert tool_input_schema(tool)["additionalProperties"] is False
assert "oneOf" in tool_output_schema(tool)
@pytest.mark.parametrize(
"updates",
[
{"description": " "},
{"basename": "con"},
{"basename": "../bad"},
{"basename": "valid\n"},
{"parts": []},
{"parts": ["bass", "bass"]},
{"parts": ["guitar"]},
{"formats": []},
{"formats": ["mid", "mid"]},
{"formats": ["wav"]},
{"tempo_bpm": True},
{"tempo_bpm": 301},
{"bars": True},
{"bars": 0},
{"seed": -1},
{"seed": True},
{"allow_midi_fallback": 1},
{"time_signature": {"numerator": 4, "denominator": 3}},
{"key": "C major minor"},
{"key": "C major\n"},
{"profiles": {"guitar": "synthetic"}},
{"parts": ["drums"], "formats": ["agp"]},
{"parts": ["lead"], "formats": ["sdp"]},
{"parts": ["lead"], "profiles": {"bass": "synthetic"}},
{"extra": 1},
],
)
def test_request_schema_and_model_reject_representative_bad_payloads(
updates: dict[str, object],
) -> None:
data = {"description": "riff", "basename": "contract", **updates}
assert not Draft202012Validator(tool_input_schema("generate_music")).is_valid(data)
with pytest.raises(ValidationError):
GenerateMusicRequest.model_validate(data)
def test_empty_profile_contract_and_error_branch() -> None:
input_validator = Draft202012Validator(tool_input_schema("list_instrument_profiles"))
assert input_validator.is_valid({})
assert not input_validator.is_valid({"extra": 1})
assert not input_validator.is_valid([])
assert ListInstrumentProfilesRequest.model_validate_json("{}").model_dump() == {}
validator = Draft202012Validator(tool_output_schema("list_instrument_profiles"))
for model in (
ProfileListResult(profiles=[]),
GenerationError(code="PROFILE_REQUIRED", message="Select a verified profile.", details={}),
):
payload = model.model_dump_json()
validator.validate(json.loads(payload))
assert PROFILE_LIST_OUTPUT.validate_json(payload) == model
for data in ({}, {"profiles": [], "code": "INVALID_REQUEST", "message": "Bad", "details": {}}):
assert not validator.is_valid(data)
def complete_data() -> dict[str, object]:
return {
"status": "complete",
"resolved": {
"parts": ["lead", "bass", "drums"],
"tempo_bpm": 120.25,
"bars": 1,
"time_signature": {"numerator": 7, "denominator": 8},
"key": "Bb minor",
"seed": 42,
"profile_ids": {
"lead": "synthetic-lead",
"bass": "synthetic-bass",
"drums": "synthetic-drums",
},
"assumptions": [],
"overrides": ["Explicit key"],
"musical_start_tick": 30,
"musical_end_tick": 3390,
"ticks_per_quarter": 960,
},
"artifacts": [
{
"format": "mid",
"parts": ["lead", "bass", "drums"],
"path": r"C:\synthetic\contract.mid",
"size_bytes": 100,
"profile_ids": ["synthetic-lead", "synthetic-bass", "synthetic-drums"],
"fallback_for": [],
},
{
"format": "griff",
"parts": ["lead"],
"path": r"C:\synthetic\contract_lead.griff",
"size_bytes": 100,
"profile_ids": ["synthetic-lead"],
"fallback_for": [],
},
{
"format": "briff",
"parts": ["bass"],
"path": r"C:\synthetic\contract_bass.briff",
"size_bytes": 100,
"profile_ids": ["synthetic-bass"],
"fallback_for": [],
},
{
"format": "sd3p",
"parts": ["drums"],
"path": r"C:\synthetic\contract_drums.sd3p",
"size_bytes": 100,
"profile_ids": ["synthetic-drums"],
"fallback_for": [],
},
],
"warnings": [],
}
def test_success_fallback_and_error_output_schema_round_trip() -> None:
complete = GenerationResult.model_validate(complete_data())
data = complete.model_dump()
data["status"] = "midi_fallback"
data["artifacts"] = [data["artifacts"][0]]
data["artifacts"][0]["fallback_for"] = ["lead", "bass", "drums"]
data["warnings"] = [
{"code": "NATIVE_FORMAT_UNAVAILABLE", "part": part, "message": "Synthetic test limit"}
for part in ("lead", "bass", "drums")
]
validator = Draft202012Validator(tool_output_schema("generate_music"))
for model in (
complete,
GenerationResult.model_validate(data),
GenerationError(
code="UNSUPPORTED_DESCRIPTION",
message="Use supported instructions.",
details={"unsupported": ["synthetic-term"]},
),
):
serialized = model.model_dump_json()
validator.validate(json.loads(serialized))
assert GENERATION_OUTPUT.validate_json(serialized) == model
updates: list[dict[str, object]] = [
{"status": "unknown"},
{"artifacts": []},
{"warnings": [{"code": "NATIVE_FORMAT_UNAVAILABLE", "part": "lead", "message": "Test"}]},
{"status": "midi_fallback"},
{"code": "INVALID_REQUEST", "message": "Mixed branch", "details": {}},
]
for update in updates:
payload = {**complete.model_dump(), **update}
assert not validator.is_valid(payload)
with pytest.raises(ValidationError):
GenerationResult.model_validate(payload)
def test_profile_summary_model_schema_associations() -> None:
validator = Draft202012Validator(tool_output_schema("list_instrument_profiles"))
for part, instrument, native in (
("lead", "eclips", "griff"),
("bass", "ray", "briff"),
("drums", "sd3", "sd3p"),
):
summary = {
"id": f"synthetic-{part}",
"part": part,
"instrument": instrument,
"product_name": "Synthetic metadata only",
"product_version": "test",
"mapping_version": "test",
"midi_available": False,
"native_format": native,
"native_available": False,
"supported_articulations": [],
"limitations": ["Not a verified production profile"],
}
model = ProfileListResult.model_validate({"profiles": [summary]})
assert model.profiles[0].mapping_kind == "instrument"
assert validator.is_valid({"profiles": [summary]})
validator.validate(json.loads(model.model_dump_json()))
assert PROFILE_LIST_OUTPUT.validate_json(model.model_dump_json()) == model
updates: list[dict[str, object]] = [
{"instrument": "unknown"},
{"native_format": "mid"},
{"limitations": []},
]
for update in updates:
bad = {"profiles": [{**summary, **update}]}
assert not validator.is_valid(bad)
with pytest.raises(ValidationError):
ProfileListResult.model_validate(bad)
def test_standard_profile_summaries_model_and_schema() -> None:
from riff_groove_builder.profiles import load_profile_registry
validator = Draft202012Validator(tool_output_schema("list_instrument_profiles"))
model = ProfileListResult(profiles=load_profile_registry().summaries())
validator.validate(json.loads(model.model_dump_json()))
assert PROFILE_LIST_OUTPUT.validate_json(model.model_dump_json()) == model
for summary in model.profiles:
if summary.mapping_kind == "instrument":
assert summary.native_available and summary.limitations
continue
assert summary.mapping_kind == "standard_midi"
updates: list[dict[str, object]] = [
{"mapping_kind": "GM"},
{"native_available": True},
{"supported_articulations": ["palm_mute"]},
{"limitations": []},
]
for update in updates:
data = {"profiles": [{**summary.model_dump(), **update}]}
assert not validator.is_valid(data)
with pytest.raises(ValidationError):
ProfileListResult.model_validate(data)
def test_exact_rational_score_event_serialization_without_profile_map() -> None:
plan = EventPlan.model_validate(
{
"score": {
"intent": {
"description": "Synthetic timing test",
"parts": ["lead", "bass", "drums"],
"tempo_bpm": 120,
"bars": 1,
"time_signature": {"numerator": 1, "denominator": 4},
"key": "C major",
"seed": 0,
},
"start": {"numerator": 0},
"end": {"numerator": 1},
"tracks": [
{
"part": part,
"notes": [
{
"kind": "drum" if part == "drums" else "pitched",
"part": part,
**(
{"voice": "synthetic_voice"}
if part == "drums"
else {"pitch": 60}
),
"start": {"numerator": 2, "denominator": 6},
"duration": {"numerator": 1, "denominator": 7},
"intensity": 0.5,
"articulation": "synthetic",
}
],
}
for part in ("lead", "bass", "drums")
],
},
"musical_start_tick": 24,
"musical_end_tick": 984,
"end_tick": 1000,
"tracks": [{"part": part, "events": []} for part in ("lead", "bass", "drums")],
}
)
serialized = plan.model_dump_json()
Draft202012Validator.check_schema(EventPlan.model_json_schema())
Draft202012Validator(EventPlan.model_json_schema()).validate(json.loads(serialized))
restored = EventPlan.model_validate_json(serialized)
assert restored == plan
for track in restored.score.tracks:
assert track.notes[0].start.value == Fraction(1, 3)
assert track.notes[0].duration.value == Fraction(1, 7)
assert track.notes[0].start.value + track.notes[0].duration.value == Fraction(10, 21)
assert track.notes[0].start.model_dump() == {"numerator": 1, "denominator": 3}
# A sub-tick logical duration is retained, not silently rounded by these models.
assert restored.score.tracks[0].notes[0].duration.value * 960 == Fraction(960, 7)
def test_contract_imports_do_not_start_server_or_write_protocol_output() -> None:
result = subprocess.run(
[
sys.executable,
"-I",
"-B",
"-c",
"import sys; import riff_groove_builder.schemas; "
"import riff_groove_builder.errors; "
"assert 'mcp' not in sys.modules; "
"assert 'riff_groove_builder.server' not in sys.modules",
],
capture_output=True,
text=True,
timeout=15,
check=False,
)
assert result.returncode == 0, result.stderr
assert result.stdout == result.stderr == ""