Cubase-MCP-GAJ3T.MusicGen.R.../tests/unit/test_sdp.py

251 lines
9.5 KiB
Python

"""SDP capability contracts; mapping fixtures are not native files or vendor evidence."""
from collections.abc import Callable
from dataclasses import FrozenInstanceError, asdict
from pathlib import Path
from typing import cast
import pytest
from riff_groove_builder.errors import (
DomainError,
InvalidRequestError,
NativeFormatUnavailableError,
)
from riff_groove_builder.formats import NativeCapability
from riff_groove_builder.formats.sdp import check_sdp_capability, require_sdp_capability
from riff_groove_builder.profiles import (
InstrumentProfile,
InvalidProfileError,
ProfilePartMismatchError,
load_profile_registry,
parse_profile,
)
from riff_groove_builder.schemas import Part, ProfileSelection
Boundary = Callable[[Part, InstrumentProfile], NativeCapability]
BOUNDARIES: list[Boundary] = [check_sdp_capability, require_sdp_capability]
FIXTURES = Path(__file__).resolve().parents[1] / "fixtures" / "profiles"
def standard(part: Part = "drums") -> InstrumentProfile:
identifier = "standard.gm-drums.v1" if part == "drums" else f"standard.{part}.v1"
return load_profile_registry().select([part], ProfileSelection(**{part: identifier}))[part]
def test_gm_profile_returns_explicit_typed_immutable_unavailable() -> None:
profile = standard()
before = profile.model_dump()
capability: NativeCapability = check_sdp_capability("drums", profile)
assert type(capability) is NativeCapability
assert asdict(capability) == {
"part": "drums",
"format": "sdp",
"available": False,
"reason": "sdp_profile_not_supported",
}
assert profile.id == "standard.gm-drums.v1"
assert profile.summary.mapping_kind == "standard_midi"
assert profile.summary.native_available is False
assert profile.provenance.status == "standard_midi"
assert profile.model_dump() == before
assert check_sdp_capability("drums", profile) == capability
assert not hasattr(capability, "__dict__")
for field, value in (
("part", "lead"),
("format", "agp"),
("available", True),
("reason", "forged"),
):
with pytest.raises(FrozenInstanceError):
setattr(capability, field, value)
def test_synthetic_instrument_mapping_does_not_establish_a_codec() -> None:
profile = parse_profile((FIXTURES / "synthetic-drums.json").read_bytes())
assert profile.summary.mapping_kind == "instrument"
assert profile.provenance.status == "test_only"
assert check_sdp_capability("drums", profile) == check_sdp_capability("drums", standard())
def test_mapping_attestation_and_product_version_are_not_native_evidence() -> None:
data = parse_profile((FIXTURES / "synthetic-drums.json").read_bytes()).model_dump()
data["id"] = data["summary"]["id"] = "harness.mapping.only"
data["summary"]["product_name"] = "TEST HARNESS mapping attestation, NOT vendor evidence"
data["summary"]["product_version"] = data["provenance"]["product_version"] = "unknown-build"
data["provenance"]["status"] = "verified"
data["provenance"]["sources"] = [
{
"kind": "lawful_local",
"reference": "TEST-HARNESS-NOT-VENDOR-EVIDENCE",
"aspects": [
"identity",
"range_or_voices",
"channels",
"actions",
"state_reset",
"timing",
"velocity",
],
}
]
profile = InstrumentProfile.model_validate(data)
assert check_sdp_capability("drums", profile).available is False
with pytest.raises(NativeFormatUnavailableError) as caught:
require_sdp_capability("drums", profile)
assert caught.value.details["reason"] == "sdp_profile_not_supported"
@pytest.mark.parametrize("boundary", BOUNDARIES)
def test_native_metadata_cannot_enable_instrument_support(boundary: Boundary) -> None:
profile = parse_profile((FIXTURES / "synthetic-drums.json").read_bytes())
profile.summary.native_available = True
with pytest.raises(InvalidProfileError) as caught:
boundary("drums", profile)
assert caught.value.details == {"reason": "invalid_profile_model"}
def test_require_raises_named_error_with_safe_complete_context() -> None:
with pytest.raises(NativeFormatUnavailableError) as caught:
require_sdp_capability("drums", standard())
assert caught.value.code == "NATIVE_FORMAT_UNAVAILABLE"
assert caught.value.details == {
"format": "sdp",
"part": "drums",
"reason": "sdp_profile_not_supported",
}
@pytest.mark.parametrize("boundary", BOUNDARIES)
@pytest.mark.parametrize(
"invalid", ["lead", "bass", "sd3", "drum", "DRUMS", "", None, 1, True, [], {}]
)
def test_invalid_parts_are_bad_requests_not_unavailable(
boundary: Boundary, invalid: object
) -> None:
with pytest.raises(InvalidRequestError) as caught:
boundary(cast(Part, invalid), standard())
assert caught.value.code == "INVALID_REQUEST"
assert caught.value.details == {"format": "sdp", "reason": "unsupported_sdp_part"}
@pytest.mark.parametrize("boundary", BOUNDARIES)
@pytest.mark.parametrize("profile_part", ["lead", "bass"])
def test_valid_wrong_part_profiles_are_selection_errors(
boundary: Boundary, profile_part: Part
) -> None:
with pytest.raises(ProfilePartMismatchError) as caught:
boundary("drums", standard(profile_part))
assert caught.value.code == "PROFILE_REQUIRED"
assert caught.value.details == {"format": "sdp", "part": "drums", "reason": "wrong_part"}
@pytest.mark.parametrize("boundary", BOUNDARIES)
@pytest.mark.parametrize(
"mutation",
[
"instrument",
"part",
"format",
"native_flag",
"channel",
"voice_note",
"duplicate_note",
"voice_alias",
"empty_voices",
"range",
"aliases",
"layer",
"provenance",
"mapping_kind",
"version",
"schema",
"unchecked_copy",
"unchecked_construct",
],
)
def test_mutated_profiles_are_invalid_not_native_unavailable(
boundary: Boundary, mutation: str
) -> None:
profile = standard()
if mutation == "instrument":
profile.summary.instrument = "eclips"
elif mutation == "part":
profile.summary.part = "lead"
elif mutation == "format":
profile.summary.native_format = "griff"
elif mutation == "native_flag":
profile.summary.native_available = True
elif mutation == "channel":
profile.channel = 128
elif mutation == "voice_note":
profile.drum_voices[0].note = 128
elif mutation == "duplicate_note":
profile.drum_voices[1].note = profile.drum_voices[0].note
elif mutation == "voice_alias":
profile.drum_voices[0].aliases.append(profile.drum_voices[1].name)
elif mutation == "empty_voices":
profile.drum_voices.clear()
elif mutation == "range":
profile.playable_range = standard("lead").playable_range
elif mutation == "aliases":
profile.articulations[0].aliases.append("slide")
elif mutation == "layer":
profile.articulations[0].layers[0].velocity_high = 128
elif mutation == "provenance":
profile.provenance.sources[0].aspects.clear()
elif mutation == "mapping_kind":
profile.summary.mapping_kind = "instrument"
elif mutation == "version":
profile.provenance.mapping_version = "private-inconsistent-version"
elif mutation == "schema":
profile = profile.model_copy(update={"schema_version": "private-invalid-version"})
elif mutation == "unchecked_copy":
profile = profile.model_copy(update={"drum_voices": ["private-invalid-voice"]})
else:
profile = InstrumentProfile.model_construct(id="private-incomplete-profile")
with pytest.raises(InvalidProfileError) as caught:
boundary("drums", profile)
assert caught.value.code == "SERIALIZATION_ERROR"
assert caught.value.details == {"reason": "invalid_profile_model"}
assert "private" not in str(caught.value)
@pytest.mark.parametrize("boundary", BOUNDARIES)
@pytest.mark.parametrize("invalid", [None, {}, "not a profile"])
def test_wrong_profile_model_type_is_corrupted_input(boundary: Boundary, invalid: object) -> None:
with pytest.raises(InvalidProfileError) as caught:
boundary("drums", cast(InstrumentProfile, invalid))
assert caught.value.code == "SERIALIZATION_ERROR"
assert caught.value.details == {"reason": "invalid_profile_model"}
def test_mutating_a_profile_after_check_cannot_authorize_require() -> None:
profile = standard()
capability = check_sdp_capability("drums", profile)
profile.drum_voices.clear()
with pytest.raises(InvalidProfileError):
require_sdp_capability("drums", profile)
assert capability.available is False
@pytest.mark.parametrize("boundary", BOUNDARIES)
def test_unexpected_validation_errors_are_not_fallback(
monkeypatch: pytest.MonkeyPatch, boundary: Boundary
) -> None:
profile = standard()
def broken_check(profile: InstrumentProfile) -> InstrumentProfile:
raise RuntimeError("test-only unexpected programming failure")
monkeypatch.setattr("riff_groove_builder.formats.sdp.checked_profile", broken_check)
with pytest.raises(RuntimeError):
boundary("drums", profile)
@pytest.mark.parametrize("boundary", BOUNDARIES)
def test_invalid_request_takes_precedence_over_invalid_profile(boundary: Boundary) -> None:
with pytest.raises(DomainError) as caught:
boundary("lead", cast(InstrumentProfile, None))
assert type(caught.value) is InvalidRequestError