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().Last(); Assert.Equal("Bass", Assert.Single(track.Events.OfType()).Text); Assert.All(track.Events.OfType(), e => Assert.Equal(1, (int)e.Channel)); Assert.Equal(new[] { 24, 40, 40, 40, 40 }, track.Events.OfType().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(() => service.GenerateAsync(Request(), new(true))); using var cancellation = new CancellationTokenSource(); var cancellable = new GenerationService(InstrumentProfileCatalog.LoadEmbedded(), _ => cancellation.Cancel()); await Assert.ThrowsAnyAsync(() => 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(() => 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); } }