410 lines
20 KiB
C#
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);
|
|
}
|
|
}
|