Cubase-MCP-GAJ3T.MusicGen.R.../tests/GAJ3T.MusicGen.RiffGrooveBu.../Generation/GenerationServiceTests.cs

410 lines
20 KiB
C#

using GAJ3T.MusicGen.RiffGrooveBuilder.Core.Articulations;
using GAJ3T.MusicGen.RiffGrooveBuilder.Core.Composition;
using GAJ3T.MusicGen.RiffGrooveBuilder.Core.Generation;
using GAJ3T.MusicGen.RiffGrooveBuilder.Generation;
using GAJ3T.MusicGen.RiffGrooveBuilder.Generation.Profiles;
using Melanchall.DryWetMidi.Core;
namespace GAJ3T.MusicGen.RiffGrooveBuilder.UnitTests.Generation;
public sealed class GenerationServiceTests : IDisposable
{
public const string Aglp = "ample-aglp-documented-defaults-2026-10-20";
public const string Ame = "ample-ame-documented-defaults-2026-10-20";
public const string Agm = "ample-agm-documented-defaults-2026-10-20";
public const string Agt = "ample-agt-documented-defaults-2026-10-20";
public const string Abj = "ample-abj-documented-defaults-2026-10-20";
private readonly string directory = Path.Combine(AppContext.BaseDirectory, "generation-" + Guid.NewGuid().ToString("N"));
private readonly GenerationService service = new();
private GenerateProjectRequest Request() => new("palm-muted eighth-note lead", directory, "song",
[OutputFormat.Mid], new(Aglp));
[Theory]
[InlineData(null, 7, 5)]
[InlineData(TrackRole.Lead, 4, 4)]
[InlineData(TrackRole.Bass, 2, 1)]
[InlineData(TrackRole.Drums, 1, 0)]
public void DiscoveryIncludesUnmappedIdentitiesAndHonestCapabilities(TrackRole? role, int instruments, int profiles)
{
var result = service.ListInstrumentProfiles(new(role));
Assert.Equal(instruments, result.Instruments.Count);
Assert.Equal(profiles, result.Profiles.Count);
if (role is null)
{
Assert.Equal(new[] { "ample-abj", "ample-aglp", "ample-agm", "ample-agt", "ample-ame", "ample-amr", "toontrack-sd3" },
result.Instruments.Select(i => i.Id));
Assert.Equal(new[] { Abj, Aglp, Agm, Agt, Ame }, result.Profiles.Select(p => p.Id));
}
Assert.All(result.Instruments, i =>
{
Assert.True(Uri.IsWellFormedUriString(i.DocumentationUrl, UriKind.Absolute));
Assert.Equal(result.Profiles.Any(p => p.InstrumentId == i.Id) ? MappingAvailability.ProfileAvailable : MappingAvailability.MappingUnavailable, i.Availability);
if (role is not null) Assert.Equal(role, i.Role);
});
Assert.All(result.Profiles, p =>
{
Assert.Equal(MappingVerification.Documented, p.Evidence.Status);
Assert.NotEmpty(p.Evidence.Source);
Assert.NotEmpty(p.Evidence.VerificationRecord);
Assert.NotNull(p.CompatibilityNotes);
Assert.Contains("not", p.CompatibilityNotes.VersionScope, StringComparison.OrdinalIgnoreCase);
Assert.Equal(NativeStatus.Unverified, p.NativeStatus);
Assert.Equal(new[] { OutputFormat.Agp }, p.NativeFormats);
Assert.Equal(p.Role == TrackRole.Bass ? 1 : 0, p.Channel);
Assert.Equal(p.Role == TrackRole.Bass ? new[] { Articulation.Sustain } :
[Articulation.Sustain, Articulation.PalmMute], p.Articulations.Select(a => a.Articulation));
Assert.All(p.Articulations, a =>
{
Assert.Equal(new[] { ArticulationMechanism.Keyswitch, ArticulationMechanism.Velocity }, a.Mechanisms);
Assert.NotNull(a.Keyswitch);
Assert.Equal(120, a.Keyswitch.AdvanceTicks);
Assert.Equal(30, a.Keyswitch.DurationTicks);
});
});
Assert.Equal(WriterStatus.Implemented, Assert.Single(result.Formats, f => f.Format == OutputFormat.Mid).WriterStatus);
Assert.All(result.Formats.Where(f => f.Format != OutputFormat.Mid), f => Assert.Equal(WriterStatus.Unavailable, f.WriterStatus));
Assert.All(result.Formats, f => Assert.Equal(NativeStatus.Unverified, f.ApplicationStatus));
}
[Theory]
[InlineData(Aglp, false)]
[InlineData(Aglp, true)]
[InlineData(Ame, false)]
[InlineData(Ame, true)]
[InlineData(Agm, false)]
[InlineData(Agm, true)]
[InlineData(Agt, false)]
[InlineData(Agt, true)]
public async Task ExplicitDocumentedMidiOnlySucceedsRegardlessOfFallbackFlag(string id, bool fallback)
{
var result = await service.GenerateAsync(Request() with { Profiles = new(id), FallbackToMidi = fallback });
Assert.Equal(GenerationStatus.Complete, result.Status);
Assert.Empty(result.Errors);
var artifact = Assert.Single(result.Artifacts);
Assert.Equal(OutputFormat.Mid, artifact.Format);
Assert.Equal(new[] { TrackRole.Lead }, artifact.Roles);
Assert.Equal(new[] { id }, artifact.ProfileIds);
Assert.Equal(Path.Combine(directory, "song.mid"), artifact.AbsolutePath);
Assert.Equal(new FileInfo(artifact.AbsolutePath).Length, artifact.ByteCount);
Assert.True(artifact.ByteCount > 0);
var target = Assert.Single(result.Targets);
Assert.Equal(id[..id.IndexOf("-documented", StringComparison.Ordinal)], target.InstrumentId);
Assert.Equal(id, target.ProfileId);
Assert.Equal(TargetOutcome.Written, target.Outcome);
Assert.Null(target.ReasonCode);
var warning = Assert.Single(result.Warnings);
Assert.Equal("documented_profile", warning.Code);
Assert.Contains("NOT installed/application-verified", warning.Message);
var notes = InstrumentProfileCatalog.LoadEmbedded().Select(TrackRole.Lead, id).Profile!.CompatibilityNotes!;
Assert.Contains(notes.VersionScope, warning.Message);
Assert.Contains(notes.ConfigurationRequirements, warning.Message);
Assert.Contains(notes.RoutingPolicy, warning.Message);
Assert.Contains(notes.TimingPolicy, warning.Message);
Assert.Equal(120, result.Timing!.LeadInTicks);
Assert.Equal(960, result.Timing.TicksPerQuarterNote);
Assert.Equal(4, result.InterpretedComposition!.Bars);
Assert.NotEmpty(result.InterpretedComposition.DefaultsApplied);
Assert.Equal(MidiFileFormat.MultiTrack, MidiFile.Read(artifact.AbsolutePath).OriginalFormat);
Assert.Equal(new[] { artifact.AbsolutePath }, Directory.GetFiles(directory));
}
[Fact]
public async Task ExplicitAbjSustainOnlyProducesBassOnItsDisclosedChannel()
{
var result = await service.GenerateAsync(Request() with { Description = "sustained bass",
Profiles = new(Bass: Abj), FallbackToMidi = false });
Assert.Equal(GenerationStatus.Complete, result.Status);
var artifact = Assert.Single(result.Artifacts);
Assert.Equal(new[] { TrackRole.Bass }, artifact.Roles);
Assert.Equal(new[] { Abj }, artifact.ProfileIds);
var track = MidiFile.Read(artifact.AbsolutePath).Chunks.Cast<TrackChunk>().Last();
Assert.Equal("Bass", Assert.Single(track.Events.OfType<SequenceTrackNameEvent>()).Text);
Assert.All(track.Events.OfType<ChannelEvent>(), e => Assert.Equal(1, (int)e.Channel));
Assert.Equal(new[] { 24, 40, 40, 40, 40 }, track.Events.OfType<NoteOnEvent>().Select(e => (int)e.NoteNumber));
Assert.Contains("PalmMute are rejected", Assert.Single(result.Warnings).Message);
}
[Theory]
[InlineData("palm-muted bass")]
[InlineData("palm-muted lead and palm-muted bass")]
public async Task UnsupportedAbjPalmMuteFailsWholeArrangementWithoutDirectoryOrSubstitution(string text)
{
var result = await service.GenerateAsync(Request() with { Description = text,
Profiles = new(text.Contains("lead", StringComparison.Ordinal) ? Ame : null, Abj) });
AssertFailure(result, "unsupported_articulation");
Assert.All(result.Targets, t => Assert.Equal(TargetOutcome.Failed, t.Outcome));
Assert.False(Directory.Exists(directory));
}
[Theory]
[InlineData(false)]
[InlineData(true)]
[InlineData(null)]
public async Task NativeOnlyNativePlusMidiAndOmittedFormatsReuseOneRealMidi(bool? includeMidi)
{
var formats = includeMidi is null ? null : includeMidi.Value
? new[] { OutputFormat.Agp, OutputFormat.Mid } : new[] { OutputFormat.Agp };
var result = await service.GenerateAsync(Request() with { Formats = formats });
Assert.Equal(GenerationStatus.Fallback, result.Status);
Assert.Empty(result.Errors);
var artifact = Assert.Single(result.Artifacts);
Assert.Equal(OutputFormat.Mid, artifact.Format);
Assert.Single(Directory.GetFiles(directory));
Assert.Equal(includeMidi == false ? 1 : 2, result.Targets.Count);
var native = Assert.Single(result.Targets, t => t.RequestedFormat == OutputFormat.Agp);
Assert.Equal(TargetOutcome.Fallback, native.Outcome);
Assert.Equal("native_writer_unavailable", native.ReasonCode);
Assert.All(result.Targets, t => Assert.Equal(new[] { artifact.AbsolutePath }, t.ArtifactPaths));
Assert.Contains(result.Warnings, w => w.Code == "native_writer_unavailable" && w.RequestedFormat == OutputFormat.Agp);
Assert.Contains(result.Warnings, w => w.Code == "documented_profile");
Assert.DoesNotContain(result.Targets, t => t.RequestedFormat == OutputFormat.Sdp);
}
[Theory]
[InlineData(false)]
[InlineData(true)]
[InlineData(null)]
public async Task DisabledNativeFallbackFailsBeforeDirectoryCreation(bool? explicitMidi)
{
var result = await service.GenerateAsync(Request() with
{
Formats = explicitMidi is null ? null : explicitMidi.Value ? [OutputFormat.Agp, OutputFormat.Mid] : [OutputFormat.Agp],
FallbackToMidi = false
});
AssertFailure(result, "native_fallback_disabled");
Assert.Contains(result.Targets, t => t.RequestedFormat == OutputFormat.Agp && t.ReasonCode == "native_writer_unavailable");
Assert.False(Directory.Exists(directory));
}
[Theory]
[InlineData(null)]
[InlineData("")]
[InlineData("unknown")]
[InlineData("ample-agm")]
[InlineData("ample-aglp")]
public async Task MissingOrUnknownProfileNeverSelectsFirstInstrument(string? id)
{
var result = await service.GenerateAsync(Request() with { Profiles = id is null ? null : new(id) });
Assert.Equal(GenerationStatus.Failed, result.Status);
Assert.Contains(result.Errors, e => e.Message.Contains(Aglp, StringComparison.Ordinal) && e.Message.Contains(Ame, StringComparison.Ordinal));
Assert.Empty(result.Artifacts);
Assert.False(Directory.Exists(directory));
}
[Theory]
[InlineData("bass", false, "no_default_profile")]
[InlineData("drums", false, "mapping_unavailable")]
[InlineData("lead and bass", true, "no_default_profile")]
[InlineData("lead and drums", true, "mapping_unavailable")]
[InlineData("120 bpm", true, "mapping_unavailable")]
public async Task MissingSelectedRoleMappingFailsWholeArrangement(string text, bool leadProfile, string code)
{
var result = await service.GenerateAsync(Request() with { Description = text, Profiles = leadProfile ? new(Aglp) : null });
AssertFailure(result, code);
Assert.NotNull(result.InterpretedComposition);
Assert.Contains(result.Targets, t => t.Role != TrackRole.Lead && t.ProfileId is null && t.InstrumentId is null);
Assert.False(Directory.Exists(directory));
}
[Theory]
[InlineData("bass", false)]
[InlineData("drums", false)]
[InlineData("lead", true)]
public async Task WrongRoleAndUnselectedProfilesFail(string text, bool extra)
{
var request = Request() with { Description = text, Profiles = extra ? new(Aglp, Aglp) : text == "bass" ? new(Bass: Aglp) : new(Drums: Aglp) };
var result = await service.GenerateAsync(request);
AssertFailure(result, extra ? "unselected_role_profile" : "profile_role_mismatch");
Assert.False(Directory.Exists(directory));
}
[Theory]
[InlineData("lead", OutputFormat.Sdp)]
[InlineData("bass", OutputFormat.Sdp)]
[InlineData("drums", OutputFormat.Agp)]
public async Task InapplicableNativeFormatIsAnErrorNotFallback(string text, OutputFormat format)
{
var result = await service.GenerateAsync(Request() with { Description = text, Formats = [format], Profiles = text == "lead" ? new(Aglp) : null });
AssertFailure(result, "inapplicable_format");
Assert.False(Directory.Exists(directory));
}
[Theory]
[InlineData("")]
[InlineData("funky music please")]
[InlineData("0 bars lead")]
[InlineData("999999999999999999 bars lead")]
[InlineData("20000 bars sixteenth-note lead")]
public async Task InvalidDescriptionAndPlannerLimitsProduceNoPartialOutput(string text)
{
var result = await service.GenerateAsync(Request() with { Description = text });
Assert.Equal(GenerationStatus.Failed, result.Status);
Assert.Null(result.InterpretedComposition);
Assert.Null(result.Timing);
Assert.NotEmpty(result.Errors);
Assert.Empty(result.Artifacts);
Assert.False(Directory.Exists(directory));
}
[Theory]
[InlineData("../escape")]
[InlineData("..\\escape")]
[InlineData("CON")]
[InlineData("con.name")]
[InlineData("CON .name")]
[InlineData("COM¹")]
[InlineData("LPT²")]
[InlineData("LPT9")]
[InlineData("NUL")]
[InlineData("a:stream")]
[InlineData("bad?")]
[InlineData("song.")]
[InlineData("song ")]
[InlineData("")]
[InlineData("..")]
public async Task UnsafeNamesAreRejected(string name)
{
AssertFailure(await service.GenerateAsync(Request() with { ProjectName = name }), "invalid_output_path");
Assert.False(Directory.Exists(directory));
}
[Theory]
[InlineData("")]
[InlineData("relative")]
[InlineData("..\\relative")]
[InlineData(@"\\?\C:\device")]
[InlineData(@"\\.\NUL")]
public async Task InvalidDirectoryIsRejected(string path)
{
AssertFailure(await service.GenerateAsync(Request() with { OutputDirectory = path }), "invalid_output_path");
Assert.False(Directory.Exists(directory));
}
[Fact]
public async Task AbsoluteTraversalIsRejected()
{
AssertFailure(await service.GenerateAsync(Request() with { OutputDirectory = Path.Combine(directory, "..", "escape") }), "invalid_output_path");
AssertFailure(await service.GenerateAsync(Request() with { OutputDirectory = directory + "/../escape" }), "invalid_output_path");
AssertFailure(await service.GenerateAsync(Request() with { OutputDirectory = directory + "\\CON\\child" }), "invalid_output_path");
Assert.False(Directory.Exists(directory));
}
[Theory]
[InlineData(0)]
[InlineData(1)]
[InlineData(2)]
public async Task InvalidFormatsFailEarly(int variant)
{
OutputFormat[] formats = variant switch { 0 => [], 1 => [OutputFormat.Mid, OutputFormat.Mid], _ => [(OutputFormat)99] };
AssertFailure(await service.GenerateAsync(Request() with { Formats = formats }), "invalid_formats");
Assert.False(Directory.Exists(directory));
}
[Theory]
[InlineData("sustained lead 1/256")]
[InlineData("1000 bars sustained lead 255/1")]
public async Task MidiLibraryAndStandardLimitsAreFailuresNotFallback(string text)
{
var result = await service.GenerateAsync(Request() with { Description = text, Formats = [OutputFormat.Agp] });
AssertFailure(result, "midi_not_supported");
Assert.False(Directory.Exists(directory));
}
[Fact]
public async Task ExistingFileAndUnrelatedStageArePreserved()
{
Directory.CreateDirectory(directory);
var path = Path.Combine(directory, "song.mid");
var stage = Path.Combine(directory, ".unrelated.stage");
File.WriteAllText(path, "other owner");
File.WriteAllText(stage, "keep");
AssertFailure(await service.GenerateAsync(Request()), "output_exists");
Assert.Equal("other owner", File.ReadAllText(path));
Assert.Equal("keep", File.ReadAllText(stage));
Assert.Equal(2, Directory.GetFiles(directory).Length);
}
[Fact]
public async Task DirectoryCollisionAndRacingFileCannotBeOverwritten()
{
Directory.CreateDirectory(directory);
var path = Path.Combine(directory, "song.mid");
var racing = new GenerationService(InstrumentProfileCatalog.LoadEmbedded(), _ => File.WriteAllText(path, "racer"));
AssertFailure(await racing.GenerateAsync(Request()), "output_io_error");
Assert.Equal("racer", File.ReadAllText(path));
File.Delete(path);
Directory.CreateDirectory(path);
AssertFailure(await service.GenerateAsync(Request()), "output_exists");
Assert.Empty(Directory.GetFiles(directory, "*", SearchOption.AllDirectories));
}
[Fact]
public async Task ConcurrentRequestsPublishAtMostOneWholeMidi()
{
var results = await Task.WhenAll(service.GenerateAsync(Request()), service.GenerateAsync(Request()));
Assert.Single(results, r => r.Status == GenerationStatus.Complete);
Assert.Single(results, r => r.Status == GenerationStatus.Failed);
Assert.Single(Directory.GetFiles(directory));
Assert.Equal(MidiFileFormat.MultiTrack, MidiFile.Read(Path.Combine(directory, "song.mid")).OriginalFormat);
}
[Fact]
public async Task IoFailureNeverBecomesSuccessfulFallback()
{
Directory.CreateDirectory(directory);
var file = Path.Combine(directory, "not-directory");
File.WriteAllText(file, "keep");
AssertFailure(await service.GenerateAsync(Request() with { OutputDirectory = file, Formats = [OutputFormat.Agp] }), "output_io_error");
Assert.Equal("keep", File.ReadAllText(file));
Assert.Single(Directory.GetFiles(directory));
}
[Theory]
[InlineData(false)]
[InlineData(true)]
public async Task ExpectedIoAndAccessErrorsHaveActionableResults(bool accessDenied)
{
var failing = new GenerationService(InstrumentProfileCatalog.LoadEmbedded(), _ =>
{
if (accessDenied) throw new UnauthorizedAccessException("test access denied");
throw new IOException("test I/O failure");
});
var result = await failing.GenerateAsync(Request() with { Formats = [OutputFormat.Agp, OutputFormat.Mid] });
AssertFailure(result, "output_io_error");
Assert.Equal(2, result.Targets.Count);
Assert.False(Directory.Exists(directory));
}
[Fact]
public async Task CancellationBeforeWorkAndBeforeOutputPropagates()
{
await Assert.ThrowsAnyAsync<OperationCanceledException>(() => service.GenerateAsync(Request(), new(true)));
using var cancellation = new CancellationTokenSource();
var cancellable = new GenerationService(InstrumentProfileCatalog.LoadEmbedded(), _ => cancellation.Cancel());
await Assert.ThrowsAnyAsync<OperationCanceledException>(() => cancellable.GenerateAsync(Request(), cancellation.Token));
Assert.False(Directory.Exists(directory));
}
[Fact]
public async Task UnexpectedFailurePropagatesRatherThanMasqueradingAsFallback()
{
var broken = new GenerationService(InstrumentProfileCatalog.LoadEmbedded(), _ => throw new InvalidOperationException("unexpected-test-failure"));
await Assert.ThrowsAsync<InvalidOperationException>(() => broken.GenerateAsync(Request() with { Formats = [OutputFormat.Agp] }));
Assert.False(Directory.Exists(directory));
}
private static void AssertFailure(GenerationResult result, string code)
{
Assert.Equal(GenerationStatus.Failed, result.Status);
Assert.Contains(result.Errors, e => e.Code == code);
Assert.Empty(result.Artifacts);
Assert.All(result.Targets, t => { Assert.Equal(TargetOutcome.Failed, t.Outcome); Assert.Empty(t.ArtifactPaths); Assert.NotNull(t.ReasonCode); });
}
public void Dispose()
{
if (Directory.Exists(directory)) Directory.Delete(directory, recursive: true);
}
}