daniel/deepdrft
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 13 Wiki Activity

feature: Opus format resolution + sidecar lookup contract (Phase 18.2)

Browse Source
This commit is contained in:
daniel-c-harvey
2026-06-23 07:45:06 -04:00
parent e845dc3496
commit 19793ba1c3
5 changed files with 323 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
DeepDrftTests/TrackFormatResolverTests.cs
+180
View File
@@ -0,0 +1,180 @@
using DeepDrftContent;
using DeepDrftContent.Constants;
using DeepDrftContent.FileDatabase.Models;
using DeepDrftContent.Processors;
using DeepDrftContent.Processors.Opus;
using DeepDrftModels.Enums;
using Microsoft.Extensions.Logging.Abstractions;
using FileDb = DeepDrftContent.FileDatabase.Services.FileDatabase;
namespace DeepDrftTests;
/// <summary>
/// Integration tests for the Phase 18.2 format resolution + sidecar lookup seam
/// (<see cref="TrackFormatResolver"/>) over a real <see cref="FileDb"/>. They exercise the four
/// resolution branches the brief specifies — lossless, Opus hit, the C2 Opus→lossless fallback, and
/// the unknown-track miss — plus sidecar hit/miss. Artifacts are seeded into the vaults exactly as
/// 18.1's <see cref="OpusTranscodeService"/> stores them (Opus audio under the bare EntryKey, sidecar
/// under the <c>-sidecar</c>-suffixed key, the source in the <c>tracks</c> vault), so the test is faithful
/// to the real storage convention rather than a stand-in.
/// </summary>
[TestFixture]
public class TrackFormatResolverTests
{
private string _testDir = string.Empty;
[SetUp]
public void SetUp()
{
_testDir = Path.Combine(Path.GetTempPath(), "TrackFormatResolverTests", Guid.NewGuid().ToString());
Directory.CreateDirectory(_testDir);
}
[TearDown]
public void TearDown()
{
try { Directory.Delete(_testDir, recursive: true); }
catch { /* Best-effort cleanup — ignore failures */ }
}
private static TrackFormatResolver CreateResolver(FileDb fileDatabase)
{
// The resolver only calls GetAudioBinaryAsync (a vault read), which never touches the router —
// but TrackContentService requires one, so supply a real router with real processors.
var router = new AudioProcessorRouter(
new AudioProcessor(), new Mp3AudioProcessor(), new FlacAudioProcessor());
var contentService = new TrackContentService(fileDatabase, router);
return new TrackFormatResolver(
fileDatabase, contentService, NullLogger<TrackFormatResolver>.Instance);
}
// Seeds a source artifact in the tracks vault with the given extension, mirroring how the upload path
// stores the original bytes (WAV/MP3/FLAC). Returns the bytes for downstream identity assertions.
private static async Task<byte[]> SeedSourceAsync(FileDb db, string entryKey, string extension)
{
await db.CreateVaultAsync(VaultConstants.Tracks, MediaVaultType.Audio);
var bytes = new byte[] { 1, 2, 3, 4, 5 };
var audio = new AudioBinary(new AudioBinaryParams(bytes, bytes.Length, extension, 12.0, 1411));
var ok = await db.RegisterResourceAsync(VaultConstants.Tracks, entryKey, audio);
Assert.That(ok, Is.True, "source seed must succeed");
return bytes;
}
// Seeds the Opus audio + sidecar in the track-opus vault exactly as OpusTranscodeService does:
// audio under OpusAudioKey (the bare EntryKey) with the .opus extension, sidecar under OpusSidecarKey.
private static async Task<(byte[] opus, byte[] sidecar)> SeedOpusAsync(FileDb db, string entryKey)
{
await db.CreateVaultAsync(VaultConstants.TrackOpus, MediaVaultType.Audio);
var opusBytes = new byte[] { 9, 9, 9 };
var opusAudio = new AudioBinary(new AudioBinaryParams(
opusBytes, opusBytes.Length, OggOpusConstants.OpusExtension, 12.0, 320));
var audioOk = await db.RegisterResourceAsync(
VaultConstants.TrackOpus, OpusTranscodeService.OpusAudioKey(entryKey), opusAudio);
Assert.That(audioOk, Is.True, "opus audio seed must succeed");
var sidecarBytes = new byte[] { 7, 7, 7, 7 };
var sidecar = new MediaBinary(new MediaBinaryParams(
sidecarBytes, sidecarBytes.Length, OggOpusConstants.SidecarExtension));
var sidecarOk = await db.RegisterResourceAsync(
VaultConstants.TrackOpus, OpusTranscodeService.OpusSidecarKey(entryKey), sidecar);
Assert.That(sidecarOk, Is.True, "sidecar seed must succeed");
return (opusBytes, sidecarBytes);
}
[Test]
public async Task ResolveAsync_Lossless_ReturnsSourceArtifactWithItsRealMime()
{
var db = (await FileDb.FromAsync(_testDir))!;
const string entryKey = "lossless-track";
// A FLAC source — proves the lossless branch does NOT assume WAV: the content-type tracks the
// stored extension's MIME, not a hard-coded audio/wav.
var bytes = await SeedSourceAsync(db, entryKey, ".flac");
var resolver = CreateResolver(db);
var resolved = await resolver.ResolveAsync(entryKey, AudioFormat.Lossless);
Assert.That(resolved, Is.Not.Null);
Assert.That(resolved!.ResolvedFormat, Is.EqualTo(AudioFormat.Lossless));
Assert.That(resolved.ContentType, Is.EqualTo("audio/flac"));
Assert.That(resolved.Audio.Buffer, Is.EqualTo(bytes));
Assert.That(resolved.DidFallBack(AudioFormat.Lossless), Is.False);
}
[Test]
public async Task ResolveAsync_OpusWhenArtifactExists_ReturnsOpusWithOggContentType()
{
var db = (await FileDb.FromAsync(_testDir))!;
const string entryKey = "opus-track";
await SeedSourceAsync(db, entryKey, ".wav");
var (opusBytes, _) = await SeedOpusAsync(db, entryKey);
var resolver = CreateResolver(db);
var resolved = await resolver.ResolveAsync(entryKey, AudioFormat.Opus);
Assert.That(resolved, Is.Not.Null);
Assert.That(resolved!.ResolvedFormat, Is.EqualTo(AudioFormat.Opus));
Assert.That(resolved.ContentType, Is.EqualTo("audio/ogg"));
Assert.That(resolved.Audio.Buffer, Is.EqualTo(opusBytes));
Assert.That(resolved.DidFallBack(AudioFormat.Opus), Is.False);
}
[Test]
public async Task ResolveAsync_OpusWhenNoArtifact_FallsBackToLosslessNeverNull()
{
var db = (await FileDb.FromAsync(_testDir))!;
const string entryKey = "no-opus-track";
// Source exists; no Opus artifact has been derived. The C2 rule: degrade to lossless, never 404.
var bytes = await SeedSourceAsync(db, entryKey, ".wav");
var resolver = CreateResolver(db);
var resolved = await resolver.ResolveAsync(entryKey, AudioFormat.Opus);
Assert.That(resolved, Is.Not.Null, "Opus absence must degrade to lossless, not null/404");
Assert.That(resolved!.ResolvedFormat, Is.EqualTo(AudioFormat.Lossless),
"the resolved format must reflect what was actually returned");
Assert.That(resolved.ContentType, Is.EqualTo("audio/wav"),
"a fallback returns the lossless content-type so the decoder picks the right decoder");
Assert.That(resolved.Audio.Buffer, Is.EqualTo(bytes));
Assert.That(resolved.DidFallBack(AudioFormat.Opus), Is.True);
}
[Test]
public async Task ResolveAsync_UnknownTrack_ReturnsNull()
{
var db = (await FileDb.FromAsync(_testDir))!;
var resolver = CreateResolver(db);
// No source at all — the one case the caller maps to 404. Holds for both requested formats:
// Opus falls back to lossless, finds nothing, and returns null too.
Assert.That(await resolver.ResolveAsync("ghost", AudioFormat.Lossless), Is.Null);
Assert.That(await resolver.ResolveAsync("ghost", AudioFormat.Opus), Is.Null);
}
[Test]
public async Task GetOpusSidecarAsync_WhenPresent_ReturnsBytes()
{
var db = (await FileDb.FromAsync(_testDir))!;
const string entryKey = "sidecar-track";
var (_, sidecarBytes) = await SeedOpusAsync(db, entryKey);
var resolver = CreateResolver(db);
var bytes = await resolver.GetOpusSidecarAsync(entryKey);
Assert.That(bytes, Is.Not.Null);
Assert.That(bytes, Is.EqualTo(sidecarBytes));
}
[Test]
public async Task GetOpusSidecarAsync_WhenAbsent_ReturnsNull()
{
var db = (await FileDb.FromAsync(_testDir))!;
var resolver = CreateResolver(db);
// No Opus artifacts derived for this track — the sidecar lookup misses to null, not an exception.
var bytes = await resolver.GetOpusSidecarAsync("no-sidecar-track");
Assert.That(bytes, Is.Null);
}
}