using System.Security.Cryptography; using System.Text.Json; using Chronos.Core.Archiving; using Chronos.Core.Import; using Chronos.Core.Model; using Chronos.Core.Project; using Chronos.Data.Archiving; using Chronos.Data.Archiving.Jobs; using Chronos.Data.Repositories; using Chronos.Data.Tests.Infrastructure; using Chronos.Testing; using static Chronos.Data.Tests.Archiving.ArchiveFixture; namespace Chronos.Data.Tests.Archiving; /// Deleting photos of a sequence into the archive's trash, restoring them and emptying the trash (owner review 2, R6). [Category("archive")] public abstract class FrameTrashTests(TestContext context) : DatabaseTest(context) { private async Task FixtureAsync() => Own(await CreateAsync(Context, database: await NewOptionsAsync(multiConnection: true))); /// A sequence of uploaded photos (hashed, under originals/), ten seconds apart. private static async Task<(Sequence Sequence, List Frames)> UploadedAsync(ArchiveFixture fx, int count, string session = "upload-1", int seed = 100) { Guid? id = null; for (var i = 0; i < count; i++) { var (path, size, sha) = fx.Stage(Start.AddSeconds(10 * i), seed + i); var result = await fx.Service.Ingest.CommitAsync(new IngestRequest(fx.Archive.Id, id, null, id is null ? session : null, path, $"IMG_{i + 1:0000}.JPG", size, sha, null, null), fx.Ct); id = result.SequenceId; } return ((await fx.Db.Sequences.GetAsync(id!.Value))!, [.. await fx.Db.Frames.ListBySequenceAsync(id.Value)]); } private static async Task DeleteAsync(ArchiveFixture fx, Sequence sequence, params Frame[] frames) { var plan = await fx.Service.FrameTrash.PlanDeleteAsync(sequence.Id, [.. frames.Select(f => f.Id)], sequence.FramesVersion, fx.Ct); Assert.True(plan.CanDelete, string.Join(", ", plan.Blocked)); return await fx.Service.FrameTrash.DeleteAsync(plan, "alberto", null, fx.Ct); } private static Job Running(JobKind kind, IReadOnlyList targets) => new() { Id = Guid.CreateVersion7(), Kind = kind, TargetIds = targets, State = JobState.Running, NodeId = "test#0", Created = DateTimeOffset.UtcNow, Started = DateTimeOffset.UtcNow, }; private static string Sha(string path) => Convert.ToHexStringLower(SHA256.HashData(File.ReadAllBytes(path))); [Test] public async Task TheDryRunCountsThePhotosAndChangesNothing() { var fx = await FixtureAsync(); var (sequence, frames) = await UploadedAsync(fx, 5); var before = await Photos.DumpIndexAsync(fx.Db, fx.Archive.Id); var plan = await fx.Service.FrameTrash.PlanDeleteAsync(sequence.Id, [frames[1].Id, frames[3].Id], sequence.FramesVersion, fx.Ct); Assert.True(plan.CanDelete); Assert.SequenceEqual([frames[1].Id, frames[3].Id], plan.Frames.Select(f => f.Id)); Assert.Equal(frames[1].Size + frames[3].Size, plan.Bytes); Assert.Equal(before, await Photos.DumpIndexAsync(fx.Db, fx.Archive.Id)); Assert.False(Directory.Exists(FrameTrash.Directory(fx.Paths)), "a dry run moves nothing"); foreach (var frame in frames) Assert.FileExists(fx.Paths.FromRelative(frame.RelativePath)); } [Test] public async Task APlanSaysWhyPhotosCannotGo() { var fx = await FixtureAsync(); var (sequence, frames) = await UploadedAsync(fx, 3); var trash = fx.Service.FrameTrash; Assert.SequenceEqual([FrameDeleteBlock.WouldEmpty], (await trash.PlanDeleteAsync(sequence.Id, [.. frames.Select(f => f.Id)], null, fx.Ct)).Blocked); Assert.SequenceEqual([FrameDeleteBlock.FramesChanged], (await trash.PlanDeleteAsync(sequence.Id, [frames[0].Id], sequence.FramesVersion - 1, fx.Ct)).Blocked); Assert.SequenceEqual([FrameDeleteBlock.FramesChanged], (await trash.PlanDeleteAsync(sequence.Id, [frames[0].Id, Guid.CreateVersion7()], null, fx.Ct)).Blocked); await Assert.ThrowsAsync(() => trash.PlanDeleteAsync(Guid.CreateVersion7(), [frames[0].Id], null, fx.Ct)); // A job on the sequence, or on its whole archive, holds it. await fx.Db.Jobs.EnqueueAsync(Running(JobKind.Render, [sequence.Id])); var busy = await trash.PlanDeleteAsync(sequence.Id, [frames[0].Id], null, fx.Ct); Assert.SequenceEqual([FrameDeleteBlock.Busy], busy.Blocked); Assert.False(busy.CanDelete); await Assert.ThrowsAsync(() => trash.DeleteAsync(busy, null, null, fx.Ct)); Assert.Count(3, await fx.Db.Frames.ListBySequenceAsync(sequence.Id)); } [Test] public async Task DeletingMovesThePhotosToTheTrashAndTombstonesThem() { var fx = await FixtureAsync(); var (sequence, frames) = await UploadedAsync(fx, 5); var folder = fx.Paths.Sequence(sequence.Folder); // Proxies are named by frame index: they follow their frames. Directory.CreateDirectory(folder.Proxies); for (var i = 0; i < frames.Count; i++) File.WriteAllBytes(folder.Proxy(i), [(byte)i]); await fx.Db.Sequences.UpdateStatusAsync(sequence.Id, SequenceStatus.AnalyzedLight | SequenceStatus.ThumbsBuilt, SequenceStatus.None); var result = await DeleteAsync(fx, sequence, frames[1], frames[3]); foreach (var gone in new[] { frames[1], frames[3] }) Assert.FileMissing(fx.Paths.FromRelative(gone.RelativePath)); var entry = result.Entry; Assert.Equal(TrashKind.Photos, entry.Kind); Assert.True(FrameTrash.IsPhotoEntry(entry.Name)); Assert.Equal(2, entry.Frames); Assert.Equal(frames[1].Size + frames[3].Size, entry.Bytes); var entryFolder = Path.Combine(FrameTrash.Directory(fx.Paths), entry.Name[FrameTrash.EntryPrefix.Length..]); Assert.Equal(frames[1].Sha256, Sha(Path.Combine(entryFolder, "originals", Path.GetFileName(frames[1].RelativePath)))); Assert.FileMissing(folder.RemovalJournalPath); var manifest = ManifestStore.ReadSequence(folder.ManifestPath); Assert.SequenceEqual([frames[0].Id, frames[2].Id, frames[4].Id], manifest.Frames.Select(f => f.Id)); Assert.SequenceEqual([0, 1, 2], manifest.Frames.Select(f => f.I)); Assert.Equal(sequence.FramesVersion + 1, manifest.Versions.Frames); Assert.SequenceEqual([frames[1].Sha256, frames[3].Sha256], Assert.NotNull(manifest.Removed).Select(r => r.Sha256)); Assert.True(manifest.Removed.All(r => r.Reason == RemovalReason.Deleted)); var row = result.Sequence; Assert.Equal(3, row.FrameCount); Assert.Equal(manifest.Versions.Frames, row.FramesVersion); Assert.Equal(SequenceStatus.None, row.Status & (SequenceStatus.AnalyzedLight | SequenceStatus.ThumbsBuilt)); Assert.SequenceEqual([frames[0].Id, frames[2].Id, frames[4].Id], (await fx.Db.Frames.ListBySequenceAsync(sequence.Id)).Select(f => f.Id)); Assert.SequenceEqual([frames[1].Sha256, frames[3].Sha256], (await fx.Db.FrameRemovals.ListBySequenceAsync(sequence.Id)).Select(r => r.Sha256).Order()); Assert.True(await fx.Db.FrameRemovals.IsRemovedAsync(sequence.Id, frames[3].Sha256!.ToUpperInvariant())); Assert.SequenceEqual([0, 2, 4], Enumerable.Range(0, 3).Select(i => File.ReadAllBytes(folder.Proxy(i))[0])); Assert.FileMissing(folder.Proxy(3)); Assert.FileMissing(folder.Proxy(4)); var listed = Assert.Contains(await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct), e => e.Name == entry.Name); Assert.Equal(sequence.DisplayTitle, listed.Title); Assert.Equal("alberto", listed.DeletedBy); } [Test] public async Task PositionsOnDeletedPhotosWaitAndComeBackWithThem() { var fx = await FixtureAsync(); var (sequence, frames) = await UploadedAsync(fx, 5); var folder = fx.Paths.Sequence(sequence.Folder); var project = new ProjectSettings { ExcludedFrames = [1, 4], HeroFrame = 3 }.ToJson(); var version = (await fx.Db.Sequences.EditAsync(sequence.Id, new SequenceEdit { SettingsJson = project, HeroFrameId = frames[3].Id }, null, fx.Ct)) .Sequence!.SettingsVersion; var deleted = await DeleteAsync(fx, (await fx.Db.Sequences.GetAsync(sequence.Id))!, frames[1], frames[3]); var row = deleted.Sequence; var parked = ProjectSettings.FromJson(row.SettingsJson!); Assert.SequenceEqual([2], parked.ExcludedFrames, "the exclusion of the fifth photo follows it"); Assert.Null(parked.HeroFrame); Assert.Count(2, Assert.NotNull(parked.PendingFrames)); Assert.True(parked.HeroPending, "the hero waits for its photo"); Assert.Null(row.HeroFrameId); Assert.Equal(version, row.SettingsVersion); Assert.True(File.Exists(folder.ProjectPath), "project.json mirrors the index"); var restored = await fx.Service.RestoreEntryAsync(fx.Archive.Id, deleted.Entry.Name, null, fx.Ct); Assert.Equal(TrashKind.Photos, restored.Kind); Assert.Equal(2, restored.Photos); Assert.Empty(restored.Kept); var back = (await fx.Db.Sequences.GetAsync(sequence.Id))!; var placed = ProjectSettings.FromJson(back.SettingsJson!); Assert.SequenceEqual([1, 4], placed.ExcludedFrames); Assert.Equal(3, placed.HeroFrame); Assert.Null(placed.PendingFrames); Assert.Equal(frames[3].Id, back.HeroFrameId); Assert.Equal(version, back.SettingsVersion); } [Test] public async Task ARestorePutsThePhotosBackWithTheirIdsAndDropsTheirTombstones() { var fx = await FixtureAsync(); var (sequence, frames) = await UploadedAsync(fx, 4); var folder = fx.Paths.Sequence(sequence.Folder); Directory.CreateDirectory(folder.Proxies); for (var i = 0; i < frames.Count; i++) File.WriteAllBytes(folder.Proxy(i), [(byte)i]); var deleted = await DeleteAsync(fx, sequence, frames[0], frames[2]); var restored = await fx.Service.RestoreEntryAsync(fx.Archive.Id, deleted.Entry.Name, null, fx.Ct); Assert.False(restored.NewSequence); Assert.Equal(sequence.Id, restored.Sequence.Id); var now = await fx.Db.Frames.ListBySequenceAsync(sequence.Id); Assert.SequenceEqual(frames.Select(f => f.Id), now.Select(f => f.Id)); Assert.SequenceEqual(frames.Select(f => f.RelativePath), now.Select(f => f.RelativePath)); Assert.SequenceEqual(frames.Select(f => f.Sha256), now.Select(f => f.Sha256)); foreach (var frame in frames) Assert.Equal(frame.Sha256, Sha(fx.Paths.FromRelative(frame.RelativePath))); Assert.Null(ManifestStore.ReadSequence(folder.ManifestPath).Removed); Assert.Empty(await fx.Db.FrameRemovals.ListBySequenceAsync(sequence.Id)); Assert.Equal(sequence.FramesVersion + 2, restored.Sequence.FramesVersion); Assert.DoesNotContain(deleted.Entry.Name, (await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct)).Select(e => e.Name)); Assert.False(Directory.Exists(Path.Combine(FrameTrash.Directory(fx.Paths), deleted.Entry.Name[FrameTrash.EntryPrefix.Length..]))); // The proxies of the frames that stayed are back at their index; those of the photos that went are made again. Assert.SequenceEqual([1], File.ReadAllBytes(folder.Proxy(1))); Assert.SequenceEqual([3], File.ReadAllBytes(folder.Proxy(3))); Assert.FileMissing(folder.Proxy(0)); } [Test] public async Task ARestoreKeepsAPhotoWhoseFileNoLongerMatchesItsRecord() { var fx = await FixtureAsync(); var (sequence, frames) = await UploadedAsync(fx, 4); var deleted = await DeleteAsync(fx, sequence, frames[1], frames[2]); var entryFolder = Path.Combine(FrameTrash.Directory(fx.Paths), deleted.Entry.Name[FrameTrash.EntryPrefix.Length..]); var damaged = Path.Combine(entryFolder, "originals", Path.GetFileName(frames[2].RelativePath)); var bytes = File.ReadAllBytes(damaged); bytes[^10] ^= 0x01; File.WriteAllBytes(damaged, bytes); var restored = await fx.Service.RestoreEntryAsync(fx.Archive.Id, deleted.Entry.Name, null, fx.Ct); Assert.Equal(1, restored.Photos); Assert.SequenceEqual([frames[2].OriginalFileName!], restored.Kept); Assert.SequenceEqual([frames[0].Id, frames[1].Id, frames[3].Id], (await fx.Db.Frames.ListBySequenceAsync(sequence.Id)).Select(f => f.Id)); Assert.SequenceEqual([frames[2].Sha256], (await fx.Db.FrameRemovals.ListBySequenceAsync(sequence.Id)).Select(r => r.Sha256)); var left = Assert.Contains(await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct), e => e.Name == deleted.Entry.Name); Assert.Equal(1, left.Frames); Assert.FileExists(damaged); // Nothing left that matches: the entry stays as it is. await Assert.ThrowsAsync(() => fx.Service.RestoreEntryAsync(fx.Archive.Id, deleted.Entry.Name, null, fx.Ct)); Assert.FileExists(damaged); } [Test] public async Task PhotosOfASequenceThatIsGoneComeBackAsANewOne() { var fx = await FixtureAsync(); var (sequence, frames) = await UploadedAsync(fx, 3); var deleted = await DeleteAsync(fx, sequence, frames[1]); var whole = await fx.Service.PlanDeleteAsync([sequence.Id], null, fx.Ct); await fx.Service.DeleteAsync(whole, null, null, fx.Ct); var restored = await fx.Service.RestoreEntryAsync(fx.Archive.Id, deleted.Entry.Name, null, fx.Ct); Assert.True(restored.NewSequence); Assert.NotEqual(sequence.Id, restored.Sequence.Id); Assert.Equal(sequence.DisplayTitle, restored.Sequence.DisplayTitle); var frame = (await fx.Db.Frames.ListBySequenceAsync(restored.Sequence.Id)).Single(); Assert.Equal(frames[1].Sha256, frame.Sha256); Assert.Equal(frames[1].Sha256, Sha(fx.Paths.FromRelative(frame.RelativePath))); // The whole sequence is still in the trash, restorable on its own. Assert.Contains(await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct), e => e.Kind == TrashKind.Sequence && e.SequenceId == sequence.Id); } [Test] public async Task TombstonesSurviveARebuildFromTheSidecars() { var fx = await FixtureAsync(); var (sequence, frames) = await UploadedAsync(fx, 3); await DeleteAsync(fx, sequence, frames[0]); await fx.ReopenWithEmptyIndexAsync(); await fx.ScanAsync(ScanMode.Rebuild); var removals = await fx.Db.FrameRemovals.ListBySequenceAsync(sequence.Id); Assert.SequenceEqual([frames[0].Sha256], removals.Select(r => r.Sha256)); Assert.Equal(RemovalReason.Deleted, removals[0].Reason); Assert.Count(2, await fx.Db.Frames.ListBySequenceAsync(sequence.Id)); } [Test] public async Task TombstonesAreReplacedWholeAndGoWithTheirSequence() { var fx = await FixtureAsync(); var (sequence, _) = await UploadedAsync(fx, 1); var at = new DateTimeOffset(2026, 10, 27, 10, 0, 0, TimeSpan.Zero); var many = Enumerable.Range(0, 450).Select(i => new FrameRemoval(sequence.Id, i.ToString("x64", System.Globalization.CultureInfo.InvariantCulture), i % 2 == 0 ? null : new string('A', 64), i % 2 == 0 ? RemovalReason.Deleted : RemovalReason.Replaced, at)).ToList(); Assert.Equal(450, await fx.Db.FrameRemovals.SyncSequenceAsync(sequence.Id, many, fx.Ct)); var stored = await fx.Db.FrameRemovals.ListBySequenceAsync(sequence.Id, fx.Ct); Assert.Count(450, stored); Assert.Equal((new string('a', 64), RemovalReason.Replaced), (stored.Single(r => r.Sha256 == many[1].Sha256).ReplacementSha256, stored[1].Reason)); Assert.Equal(1, await fx.Db.FrameRemovals.SyncSequenceAsync(sequence.Id, [many[3], many[3]], fx.Ct)); Assert.Count(1, await fx.Db.FrameRemovals.ListBySequenceAsync(sequence.Id, fx.Ct)); await fx.Db.Sequences.DeleteAsync(sequence.Id, fx.Ct); Assert.Empty(await fx.Db.FrameRemovals.ListBySequenceAsync(sequence.Id, fx.Ct)); } [Test] public async Task ADeletionACrashInterruptedIsUndoneByTheNextWriter() { var fx = await FixtureAsync(); var (sequence, frames) = await UploadedAsync(fx, 3); var folder = fx.Paths.Sequence(sequence.Folder); // The journal was written and one of two files moved when the process died; the sidecar still lists both frames. var entry = Path.Combine(FrameTrash.Directory(fx.Paths), $"{sequence.Id:N}-20261027120000"); var record = entry + ".json"; Directory.CreateDirectory(Path.Combine(entry, "originals")); File.WriteAllText(record, "{}"); var moves = frames.Take(2).Select(f => new FrameRemovalMove(f.RelativePath[(sequence.Folder.Length + 1)..], fx.Paths.ToRelative(Path.Combine(entry, "originals", Path.GetFileName(f.RelativePath))))).ToList(); FrameRemovalJournal.Write(folder, new FrameRemovalJournal(fx.Paths.ToRelative(record), fx.Paths.ToRelative(entry), [frames[0].Id, frames[1].Id], moves)); File.Move(fx.Paths.FromRelative(frames[0].RelativePath), fx.Paths.FromRelative(moves[0].To)); // Any writer of the sequence reads its sidecar under the lease first. await fx.Service.SetSequenceInfoAsync(sequence.Id, "Harbour", [], 0, null, fx.Ct); foreach (var frame in frames) Assert.Equal(frame.Sha256, Sha(fx.Paths.FromRelative(frame.RelativePath))); Assert.FileMissing(folder.RemovalJournalPath); Assert.FileMissing(record); Assert.False(Directory.Exists(entry)); Assert.Count(3, ManifestStore.ReadSequence(folder.ManifestPath).Frames); } [Test] public async Task ErasingTheCardKeepsTheCardCopyOfADeletedPhoto() { var fx = await FixtureAsync(); var card = Context.CreateTempDirectory("card"); Photos.WriteSeries(Path.Combine(card, "DCIM", "100CANON"), Start, 4); var media = await fx.Service.Imports.RegisterCardAsync(new CardVolume("3F2A9C11-EOS_DIGITAL-127865454592", 0x3F2A9C11, "EOS_DIGITAL", 127_865_454_592), fx.Ct); var plan = await fx.Service.PlanImportAsync(fx.Archive.Id, card, new ImportOptions(), media.Id, null, fx.Ct); await fx.Service.Imports.ExecuteAsync(new ImportJobParameters(fx.Archive.Id, plan, media.Id, true, null), Guid.NewGuid(), 0, _ => ValueTask.CompletedTask, null, fx.Ct); var id = (await fx.Db.Sequences.FindBySessionKeyAsync(fx.Archive.Id, plan.Sessions.Single().SessionKey))!.Value; var frames = await fx.Db.Frames.ListBySequenceAsync(id); await DeleteAsync(fx, (await fx.Db.Sequences.GetAsync(id))!, frames[2]); var erase = await fx.Service.PlanCardEraseAsync(fx.Archive.Id, media.Id, card, null, fx.Ct); CardEraser.Execute(erase); // The deleted photo has no frame any more: nothing in the archive vouches for its card copy, which stays. Assert.Equal(3, erase.ToDelete.Count()); var left = Directory.EnumerateFiles(card, "*.JPG", SearchOption.AllDirectories).Select(f => Path.GetFileName(f)).ToList(); Assert.SequenceEqual([frames[2].OriginalFileName!], left); } [Test] public async Task EmptyingErasesExactlyThePlannedEntries() { var fx = await FixtureAsync(); var (sequence, frames) = await UploadedAsync(fx, 3); var (other, _) = await UploadedAsync(fx, 2, "upload-2", 200); var photos = await DeleteAsync(fx, sequence, frames[1]); await fx.Service.DeleteAsync(await fx.Service.PlanDeleteAsync([other.Id], null, fx.Ct), null, null, fx.Ct); var engine = await fx.StartEngineAsync(); var plan = await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct); Assert.Count(2, plan.Entries); Assert.Equal(3, plan.Photos); Assert.True(plan.Bytes > 0); Assert.Equal(plan.Fingerprint, (await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct)).Fingerprint, "the plan reads only"); Assert.SequenceEqual(["nope"], (await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, [photos.Entry.Name, "nope"], fx.Ct)).Unknown); var job = await engine.EnqueueAsync(ArchiveJobs.EmptyTrash(fx.Archive, plan), cancellationToken: fx.Ct); var done = await fx.WaitForAsync(job.Id, JobState.Done); Assert.Empty(await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct)); Assert.Empty(Directory.EnumerateFileSystemEntries(FrameTrash.Directory(fx.Paths))); Assert.Empty(Directory.EnumerateFiles(SequenceTrash.TrashDirectory(fx.Paths), "*", SearchOption.AllDirectories)); Assert.Contains(Chronos.Core.Localization.Loc.L("Archive.Log.TrashEmptied", 2, Housekeeping.CleanupSteps.Megabytes(plan.Bytes)), done.LogTail); // Tombstones outlive the trash: the deleted photo is still not offered back. Assert.True(await fx.Db.FrameRemovals.IsRemovedAsync(sequence.Id, frames[1].Sha256!)); } [Test] public async Task AnEmptyingPlannedBeforeTheTrashChangedErasesNothing() { var fx = await FixtureAsync(); var (sequence, frames) = await UploadedAsync(fx, 4); var first = await DeleteAsync(fx, sequence, frames[1]); var second = await DeleteAsync(fx, (await fx.Db.Sequences.GetAsync(sequence.Id))!, frames[2]); var plan = await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct); var engine = await fx.StartEngineAsync(); // A planned entry came back (restored) before the job ran. await fx.Service.RestoreEntryAsync(fx.Archive.Id, first.Entry.Name, null, fx.Ct); var job = await engine.EnqueueAsync(ArchiveJobs.EmptyTrash(fx.Archive, plan), cancellationToken: fx.Ct); var failed = await fx.WaitForAsync(job.Id, JobState.Failed); Assert.Equal(Chronos.Core.Localization.Loc.L("Archive.Error.TrashChanged"), failed.Error); Assert.Contains(await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct), e => e.Name == second.Entry.Name); // A planned entry whose folder changed since makes the plan stale too. var again = await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct); var folder = Path.Combine(FrameTrash.Directory(fx.Paths), second.Entry.Name[FrameTrash.EntryPrefix.Length..]); File.WriteAllBytes(Path.Combine(folder, "added.bin"), [1, 2, 3]); Assert.NotEqual(again.Fingerprint, (await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct)).Fingerprint); var stale = await engine.EnqueueAsync(ArchiveJobs.EmptyTrash(fx.Archive, again), cancellationToken: fx.Ct); await fx.WaitForAsync(stale.Id, JobState.Failed); Assert.Contains(await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct), e => e.Name == second.Entry.Name); Assert.FileExists(Path.Combine(folder, "added.bin")); } [Test] public async Task AReplacedEntryIsErasedOnlyWhileItsReplacementMatches() { var fx = await FixtureAsync(); var (sequence, frames) = await UploadedAsync(fx, 2); var replacement = frames[1]; var good = WriteReplaced(fx, sequence, "20261027100000", replacement.Sha256!); var bad = WriteReplaced(fx, sequence, "20261027110000", new string('a', 64)); var engine = await fx.StartEngineAsync(); var listed = await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct); Assert.True(listed.All(e => e.Kind == TrashKind.Replaced)); var plan = await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct); var job = await engine.EnqueueAsync(ArchiveJobs.EmptyTrash(fx.Archive, plan), cancellationToken: fx.Ct); var failed = await fx.WaitForAsync(job.Id, JobState.Failed); Assert.Equal(Chronos.Core.Localization.Loc.Plural("Archive.Error.TrashKept", 1), failed.Error); var left = Assert.Contains(await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct), e => e.Name == FrameTrash.EntryPrefix + bad); Assert.Equal(TrashKind.Replaced, left.Kind); Assert.DoesNotContain(FrameTrash.EntryPrefix + good, (await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct)).Select(e => e.Name)); // A replacement whose file no longer hashes to it keeps its originals too. var other = WriteReplaced(fx, sequence, "20261027120000", replacement.Sha256!); var file = fx.Paths.FromRelative(replacement.RelativePath); var bytes = File.ReadAllBytes(file); bytes[^10] ^= 0x01; File.WriteAllBytes(file, bytes); var again = await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, [FrameTrash.EntryPrefix + other], fx.Ct); var second = await engine.EnqueueAsync(ArchiveJobs.EmptyTrash(fx.Archive, again), cancellationToken: fx.Ct); await fx.WaitForAsync(second.Id, JobState.Failed); Assert.Contains(await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct), e => e.Name == FrameTrash.EntryPrefix + other); } /// An entry of originals a conversion replaced (a later phase), its one photo replaced by . private static string WriteReplaced(ArchiveFixture fx, Sequence sequence, string stamp, string replacement) { var name = $"{sequence.Id:N}-{stamp}"; var folder = Path.Combine(FrameTrash.Directory(fx.Paths), name); Directory.CreateDirectory(Path.Combine(folder, "originals")); var bytes = Photos.Jpeg(Start, 999); File.WriteAllBytes(Path.Combine(folder, "originals", "IMG_0001.CR2"), bytes); var sha = Convert.ToHexStringLower(SHA256.HashData(bytes)); var frame = new SidecarFrame { Id = Guid.CreateVersion7(), File = "originals/IMG_0001.CR2", Size = bytes.Length, Sha256 = sha }; var record = new PhotoTrashRecord(TrashKind.Replaced, sequence.Id, sequence.DisplayTitle, sequence.Folder, [new TrashedPhoto(frame, [new TrashedFile(frame.File, "originals/IMG_0001.CR2", bytes.Length, sha)], replacement)], bytes.Length, DateTimeOffset.UtcNow, "converter"); File.WriteAllText(folder + ".json", JsonSerializer.Serialize(record, TrashJson.Default.PhotoTrashRecord)); return name; } } public sealed class SqliteFrameTrashTests(TestContext context) : FrameTrashTests(context) { protected override Backend Backend => Backend.SqliteFile; } [RequiresEnvironment(PgTestServer.Variable)] public sealed class PostgresFrameTrashTests(TestContext context) : FrameTrashTests(context) { protected override Backend Backend => Backend.Postgres; }