CI / Build and test (push) Failing after 3m1s
CI / PostgreSQL 16 integration (push) Skipped
CI / PostgreSQL 17 integration (push) Skipped
CI / Docker image (push) Skipped
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 10s
Release / Build, test and publish (push) Successful in 15m31s
Release / Server image (push) Successful in 1m13s
Convert photos already in the archive to JPEG, TIFF-16 or Linear DNG, from the panel's Library and the desktop's Archive and Library. Each run asks Replace (same frames, originals to the trash, recoverable) or New sequence. A dry run lists what converts, what is skipped and why, size before and after, and free space; the job converts exactly the confirmed photos, resumes, and commits all or nothing per sequence. A conversion never changes what Chronos reads from a photo. Replaced originals are erased only on the archive's own word that their conversion is gone. Desktop TIFFs that WIC showed black or as noise now go to the managed reader; the Edit picker no longer spins a core. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: Alberto Balbo <alberto.balbo.96@gmail.com>
811 lines
51 KiB
C#
811 lines
51 KiB
C#
using System.Security.Cryptography;
|
|
using Chronos.Core.Archiving;
|
|
using Chronos.Core.Import;
|
|
using Chronos.Core.Localization;
|
|
using Chronos.Core.Model;
|
|
using Chronos.Core.Project;
|
|
using Chronos.Data.Archiving;
|
|
using Chronos.Data.Archiving.Jobs;
|
|
using Chronos.Data.Repositories;
|
|
using Chronos.Testing;
|
|
using static Chronos.Data.Tests.Archiving.ArchiveFixture;
|
|
|
|
namespace Chronos.Data.Tests.Archiving;
|
|
|
|
/// <summary>
|
|
/// Frames whose files a conversion replaced (owner review 2, R7) and everything that meets them afterwards: a replacement
|
|
/// that could not be undone, a second conversion, the conversion deleted, the trash emptied, the job that made an entry,
|
|
/// project positions, and the original filed again.
|
|
/// </summary>
|
|
[Category("archive")]
|
|
public sealed class ReplacedTrashTests(TestContext context)
|
|
{
|
|
/// <summary>A sequence of <paramref name="count"/> uploaded photos ten seconds apart, and their bytes.</summary>
|
|
private static async Task<(Guid Id, List<byte[]> Photos)> UploadedAsync(ArchiveFixture fx, int count, string session = "upload-1")
|
|
{
|
|
Guid? id = null;
|
|
var photos = new List<byte[]>();
|
|
for (var i = 0; i < count; i++)
|
|
{
|
|
var bytes = Photos.Jpeg(Start.AddSeconds(10 * i), 100 + i);
|
|
photos.Add(bytes);
|
|
id = (await CommitAsync(fx, id, id is null ? session : null, bytes, $"IMG_{i + 1:0000}.JPG")).SequenceId;
|
|
}
|
|
return (id!.Value, photos);
|
|
}
|
|
|
|
private static Task<IngestResult> CommitAsync(ArchiveFixture fx, Guid? sequenceId, string? session, byte[] bytes, string name)
|
|
{
|
|
var staging = Path.Combine(fx.Paths.StagingDirectory, "uploads");
|
|
Directory.CreateDirectory(staging);
|
|
var path = Path.Combine(staging, $"{Guid.NewGuid():N}.part");
|
|
File.WriteAllBytes(path, bytes);
|
|
return fx.Service.Ingest.CommitAsync(new IngestRequest(fx.Archive.Id, sequenceId, null, sequenceId is null ? session : null, path, name, bytes.Length,
|
|
Sha(bytes), null, null), fx.Ct);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Replaces the files of the frames at <paramref name="indices"/> (in the sidecar now) with other photos, as a
|
|
/// conversion's stage B does (<see cref="FrameTrash.ReplaceAsync"/>), on this host or on <paramref name="by"/> (another
|
|
/// host sharing the archive, whose index this one does not read); returns the trash entry of the originals.
|
|
/// </summary>
|
|
private static async Task<TrashEntry> ReplaceAsync(ArchiveFixture fx, Guid sequenceId, IReadOnlyList<int> indices, int seed, Guid? job = null,
|
|
(ArchiveService Service, Archive Archive)? by = null)
|
|
{
|
|
var sequence = (await fx.Db.Sequences.GetAsync(sequenceId))!;
|
|
var manifest = Sidecar(fx, sequence);
|
|
var staging = Path.Combine(fx.Paths.StagingDirectory, "replace-test");
|
|
Directory.CreateDirectory(staging);
|
|
var swaps = new List<FrameSwap>();
|
|
foreach (var i in indices)
|
|
{
|
|
var frame = manifest.Frames[i];
|
|
var bytes = Photos.Jpeg(frame.CapturedAt, seed + i);
|
|
var path = Path.Combine(staging, $"{Guid.NewGuid():N}.jpeg");
|
|
File.WriteAllBytes(path, bytes);
|
|
var sha = Sha(bytes);
|
|
swaps.Add(new FrameSwap(frame.Id, fx.Paths.ToRelative(path), [], (current, _) => Path.ChangeExtension(current.File, ".jpeg"), current => current with
|
|
{
|
|
Sha256 = sha,
|
|
Size = bytes.Length,
|
|
Source = new FrameSource { Sha256 = current.Sha256, Format = current.Format, File = current.File, Size = current.Size },
|
|
}));
|
|
}
|
|
var (service, archive) = by ?? (fx.Service, fx.Archive);
|
|
var result = Assert.NotNull(await service.FrameTrash.ReplaceAsync(archive, sequenceId, null, swaps, null, job, null, null, fx.Ct));
|
|
return Assert.NotNull(result.Entry);
|
|
}
|
|
|
|
/// <summary>Flips a byte near the end of <paramref name="path"/>; returns its bytes before.</summary>
|
|
private static byte[] Damage(string path)
|
|
{
|
|
var bytes = File.ReadAllBytes(path);
|
|
var damaged = (byte[])bytes.Clone();
|
|
damaged[^10] ^= 0x01;
|
|
File.WriteAllBytes(path, damaged);
|
|
return bytes;
|
|
}
|
|
|
|
private static SequenceManifest Sidecar(ArchiveFixture fx, Sequence sequence) => ManifestStore.ReadSequence(fx.Paths.Sequence(sequence.Folder).ManifestPath);
|
|
|
|
private static string Sha(byte[] bytes) => Convert.ToHexStringLower(SHA256.HashData(bytes));
|
|
|
|
private static string Sha(string path) => Sha(File.ReadAllBytes(path));
|
|
|
|
private static async Task<Job> EmptyAsync(ArchiveFixture fx, Chronos.Data.Jobs.JobEngine engine, TrashEmptyPlan plan, JobState state)
|
|
{
|
|
var job = await engine.EnqueueAsync(ArchiveJobs.EmptyTrash(fx.Archive, plan), cancellationToken: fx.Ct);
|
|
return await fx.WaitForAsync(job.Id, state);
|
|
}
|
|
|
|
/// <summary>What the emptying job of <paramref name="plan"/> is given, for a test that runs the emptying itself.</summary>
|
|
private static EmptyTrashParameters Parameters(TrashEmptyPlan plan) =>
|
|
new([.. plan.Entries.Select(e => new EmptyTrashItem(e.Name, SequenceTrash.EntryFingerprint(e)))], plan.Fingerprint);
|
|
|
|
[Test]
|
|
public async Task AReplacementThatCouldNotBeUndoneIsUndoneBeforeAnythingElseIsFiled()
|
|
{
|
|
await using var fx = await CreateAsync(context);
|
|
var (id, _) = await UploadedAsync(fx, 2);
|
|
var sequence = (await fx.Db.Sequences.GetAsync(id))!;
|
|
var folder = fx.Paths.Sequence(sequence.Folder);
|
|
var manifest = Sidecar(fx, sequence);
|
|
var frame = manifest.Frames[0];
|
|
// A replacement that failed and whose undo failed too: the original in its entry, the converted file in the sequence,
|
|
// the record pending, the sidecar as it was, and the folder the converted file must go back to taken by a file.
|
|
var staging = Path.Combine(fx.Paths.StagingDirectory, "convert-test");
|
|
var staged = Path.Combine(staging, "converted.jpeg");
|
|
var converted = Photos.Jpeg(frame.CapturedAt, 900);
|
|
var entryFolder = Path.Combine(FrameTrash.Directory(fx.Paths), $"{id:N}-20261027120000");
|
|
var record = entryFolder + ".json";
|
|
var trashed = Path.Combine(entryFolder, "originals", Path.GetFileName(frame.File));
|
|
var placed = Path.ChangeExtension(frame.File, ".jpeg");
|
|
new FrameReplaceJournal(manifest.Versions.Frames, fx.Paths.ToRelative(record), fx.Paths.ToRelative(entryFolder),
|
|
[new SwapMove(frame.File, fx.Paths.ToRelative(trashed))], [new SwapMove(placed, fx.Paths.ToRelative(staged))], false, null)
|
|
{
|
|
Names = new Dictionary<Guid, string> { [frame.Id] = placed },
|
|
}.Write(folder);
|
|
Directory.CreateDirectory(Path.GetDirectoryName(trashed)!);
|
|
File.WriteAllText(FrameRemovalJournal.PendingRecord(record), "{}");
|
|
File.Move(folder.File(frame.File), trashed);
|
|
File.WriteAllBytes(folder.File(placed), converted);
|
|
Directory.CreateDirectory(fx.Paths.StagingDirectory);
|
|
File.WriteAllText(staging, "in the way");
|
|
|
|
// An upload into the sequence meanwhile: the undo fails again, and nothing is filed.
|
|
await Assert.ThrowsAsync<IOException>(() => CommitAsync(fx, id, null, Photos.Jpeg(Start.AddSeconds(30), 300), "IMG_0003.JPG"));
|
|
Assert.Equal(manifest.Versions.Frames, Sidecar(fx, sequence).Versions.Frames);
|
|
Assert.Equal(ReplacePhase.Undoing, Assert.NotNull(FrameReplaceJournal.Read(folder)).Phase);
|
|
Assert.Empty(await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct));
|
|
|
|
// Another writer of an earlier build moved the frames version meanwhile: the replacement is undone all the same, never
|
|
// taken for one whose sidecar was written.
|
|
ManifestStore.WriteSequence(folder.ManifestPath, manifest with { Versions = manifest.Versions with { Frames = manifest.Versions.Frames + 1 } });
|
|
File.Delete(staging);
|
|
await fx.Service.EditSequenceInfoAsync(id, info => info with { Rating = 2 }, fx.Ct);
|
|
Assert.FileMissing(folder.ReplaceJournalPath);
|
|
Assert.Equal(frame.Sha256, Sha(folder.File(frame.File)));
|
|
Assert.FileMissing(folder.File(placed));
|
|
Assert.Equal(Sha(converted), Sha(staged));
|
|
Assert.False(Directory.Exists(entryFolder));
|
|
Assert.FileMissing(FrameRemovalJournal.PendingRecord(record));
|
|
Assert.Empty(await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct));
|
|
Assert.SequenceEqual(manifest.Frames.Select(f => (f.Id, f.File, f.Sha256)), Sidecar(fx, sequence).Frames.Select(f => (f.Id, f.File, f.Sha256)));
|
|
|
|
// Settled, the upload goes in.
|
|
await CommitAsync(fx, id, null, Photos.Jpeg(Start.AddSeconds(30), 300), "IMG_0003.JPG");
|
|
Assert.Count(3, Sidecar(fx, sequence).Frames);
|
|
}
|
|
|
|
[Test]
|
|
public async Task AnInterruptedReplacementIsSettledByWhatItsSidecarLists()
|
|
{
|
|
await using var fx = await CreateAsync(context);
|
|
var (id, _) = await UploadedAsync(fx, 2);
|
|
var entry = await ReplaceAsync(fx, id, [0], 500);
|
|
var sequence = (await fx.Db.Sequences.GetAsync(id))!;
|
|
var folder = fx.Paths.Sequence(sequence.Folder);
|
|
var manifest = Sidecar(fx, sequence);
|
|
var (entryFolder, record) = FrameTrash.Location(fx.Paths, entry.Name);
|
|
// As a crash right after the sidecar was written leaves it (at the version an ingest would give too): completed.
|
|
File.Move(record, FrameRemovalJournal.PendingRecord(record));
|
|
new FrameReplaceJournal(manifest.Versions.Frames - 1, fx.Paths.ToRelative(record), fx.Paths.ToRelative(entryFolder), [], [], false, null)
|
|
{
|
|
Names = new Dictionary<Guid, string> { [manifest.Frames[0].Id] = manifest.Frames[0].File },
|
|
}.Write(folder);
|
|
Assert.Empty(await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct));
|
|
await fx.Service.EditSequenceInfoAsync(id, info => info with { Rating = 2 }, fx.Ct);
|
|
Assert.FileMissing(folder.ReplaceJournalPath);
|
|
Assert.Equal(entry.Name, (await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct)).Single().Name);
|
|
|
|
// As a crash before the sidecar was written leaves it, with the frames version moved by another writer since: undone.
|
|
manifest = Sidecar(fx, sequence);
|
|
var frame = manifest.Frames[1];
|
|
var staged = Path.Combine(fx.Paths.StagingDirectory, "convert-test", "converted.jpeg");
|
|
var converted = Photos.Jpeg(frame.CapturedAt, 901);
|
|
var second = Path.Combine(FrameTrash.Directory(fx.Paths), $"{id:N}-20261027130000");
|
|
var trashed = Path.Combine(second, "originals", Path.GetFileName(frame.File));
|
|
var placed = Path.ChangeExtension(frame.File, ".jpeg");
|
|
new FrameReplaceJournal(manifest.Versions.Frames, fx.Paths.ToRelative(second + ".json"), fx.Paths.ToRelative(second),
|
|
[new SwapMove(frame.File, fx.Paths.ToRelative(trashed))], [new SwapMove(placed, fx.Paths.ToRelative(staged))], false, null)
|
|
{
|
|
Names = new Dictionary<Guid, string> { [frame.Id] = placed },
|
|
}.Write(folder);
|
|
Directory.CreateDirectory(Path.GetDirectoryName(trashed)!);
|
|
File.WriteAllText(FrameRemovalJournal.PendingRecord(second + ".json"), "{}");
|
|
File.Move(folder.File(frame.File), trashed);
|
|
File.WriteAllBytes(folder.File(placed), converted);
|
|
ManifestStore.WriteSequence(folder.ManifestPath, manifest with { Versions = manifest.Versions with { Frames = manifest.Versions.Frames + 1 } });
|
|
|
|
await fx.Service.EditSequenceInfoAsync(id, info => info with { Rating = 3 }, fx.Ct);
|
|
Assert.FileMissing(folder.ReplaceJournalPath);
|
|
Assert.Equal(frame.Sha256, Sha(folder.File(frame.File)));
|
|
Assert.FileMissing(folder.File(placed));
|
|
Assert.Equal(Sha(converted), Sha(staged));
|
|
Assert.False(Directory.Exists(second));
|
|
Assert.Equal(entry.Name, (await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct)).Single().Name);
|
|
}
|
|
|
|
[Test]
|
|
public async Task OriginalsConvertedTwiceAreErasedWhileTheLastConversionHolds()
|
|
{
|
|
await using var fx = await CreateAsync(context);
|
|
var (id, _) = await UploadedAsync(fx, 2);
|
|
var engine = await fx.StartEngineAsync();
|
|
await ReplaceAsync(fx, id, [0, 1], 500);
|
|
await ReplaceAsync(fx, id, [0, 1], 600);
|
|
var sequence = (await fx.Db.Sequences.GetAsync(id))!;
|
|
var current = fx.Paths.Sequence(sequence.Folder).File(Sidecar(fx, sequence).Frames[0].File);
|
|
var bytes = File.ReadAllBytes(current);
|
|
|
|
// The last conversion damaged: neither the originals nor the first conversion go.
|
|
var damaged = (byte[])bytes.Clone();
|
|
damaged[^10] ^= 0x01;
|
|
File.WriteAllBytes(current, damaged);
|
|
var plan = await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct);
|
|
Assert.Count(2, plan.Entries);
|
|
Assert.True(plan.Entries.All(e => !e.ConversionDeleted), "the conversions are in the sequence");
|
|
await EmptyAsync(fx, engine, plan, JobState.Failed);
|
|
Assert.Count(2, await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct));
|
|
|
|
// Whole again: the first originals are held by the second conversion, through the first one's tombstone.
|
|
File.WriteAllBytes(current, bytes);
|
|
await EmptyAsync(fx, engine, await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct), JobState.Done);
|
|
Assert.Empty(await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct));
|
|
}
|
|
|
|
[Test]
|
|
public async Task OriginalsWhoseConversionWasDeletedAreErasedAsTheDryRunSays()
|
|
{
|
|
await using var fx = await CreateAsync(context);
|
|
var (id, _) = await UploadedAsync(fx, 3);
|
|
var engine = await fx.StartEngineAsync();
|
|
var replaced = await ReplaceAsync(fx, id, [0], 500);
|
|
var before = await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct);
|
|
Assert.False(before.Entries.Single().ConversionDeleted);
|
|
|
|
// The user deletes the converted photo.
|
|
var frames = await fx.Db.Frames.ListBySequenceAsync(id);
|
|
var sequence = (await fx.Db.Sequences.GetAsync(id))!;
|
|
var deletion = await fx.Service.FrameTrash.DeleteAsync(await fx.Service.FrameTrash.PlanDeleteAsync(id, [frames[0].Id], sequence.FramesVersion, fx.Ct),
|
|
null, null, fx.Ct);
|
|
|
|
// The plan made before no longer holds: nothing is erased.
|
|
await EmptyAsync(fx, engine, before, JobState.Failed);
|
|
Assert.Count(2, await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct));
|
|
|
|
var plan = await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct);
|
|
Assert.True(plan.Entries.Single(e => e.Name == replaced.Name).ConversionDeleted, "the dry run says the conversion was deleted");
|
|
Assert.False(plan.Entries.Single(e => e.Name == deletion.Entry.Name).ConversionDeleted);
|
|
Assert.NotEqual(SequenceTrash.EntryFingerprint(plan.Entries.Single(e => e.Name == replaced.Name) with { ConversionDeleted = false }),
|
|
SequenceTrash.EntryFingerprint(plan.Entries.Single(e => e.Name == replaced.Name)));
|
|
|
|
// The deleted conversion is still in the trash, damaged: the originals stay.
|
|
var record = Assert.NotNull(FrameTrash.ReadEntry(fx.Paths, deletion.Entry.Name));
|
|
var copy = Path.Combine(FrameTrash.Location(fx.Paths, deletion.Entry.Name).Folder, record.Photos[0].Files[0].Path);
|
|
var bytes = File.ReadAllBytes(copy);
|
|
var damaged = (byte[])bytes.Clone();
|
|
damaged[^10] ^= 0x01;
|
|
File.WriteAllBytes(copy, damaged);
|
|
await EmptyAsync(fx, engine, await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, [replaced.Name], fx.Ct), JobState.Failed);
|
|
Assert.Contains(replaced.Name, (await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct)).Select(e => e.Name));
|
|
|
|
// Whole again, both go; and once the conversion's entry is erased, the originals go with nothing left to check.
|
|
File.WriteAllBytes(copy, bytes);
|
|
await EmptyAsync(fx, engine, await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct), JobState.Done);
|
|
Assert.Empty(await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct));
|
|
}
|
|
|
|
[Test]
|
|
public async Task OriginalsWhoseConvertedSequenceWasDeletedAreErasedWithIt()
|
|
{
|
|
await using var fx = await CreateAsync(context);
|
|
var (id, _) = await UploadedAsync(fx, 2);
|
|
var engine = await fx.StartEngineAsync();
|
|
var replaced = await ReplaceAsync(fx, id, [0, 1], 500);
|
|
await fx.Service.Trash.DeleteAsync(await fx.Service.Trash.PlanAsync([id], null, fx.Ct), null, null, fx.Ct);
|
|
|
|
var plan = await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct);
|
|
Assert.Count(2, plan.Entries);
|
|
Assert.True(plan.Entries.Single(e => e.Name == replaced.Name).ConversionDeleted);
|
|
Assert.False(plan.Entries.Single(e => e.Kind == TrashKind.Sequence).ConversionDeleted);
|
|
// Only the originals: the sequence's entry still holds the conversions, which hash to their records.
|
|
await EmptyAsync(fx, engine, await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, [replaced.Name], fx.Ct), JobState.Done);
|
|
Assert.Equal(TrashKind.Sequence, (await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct)).Single().Kind);
|
|
|
|
await fx.Service.RestoreAsync(fx.Archive.Id, (await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct)).Single().Name, fx.Ct);
|
|
Assert.Count(2, await fx.Db.Frames.ListBySequenceAsync(id));
|
|
}
|
|
|
|
[Test]
|
|
public async Task AConversionAnotherHostMadeIsHashedWhereTheArchiveHoldsIt()
|
|
{
|
|
await using var fx = await CreateAsync(context);
|
|
var (id, photos) = await UploadedAsync(fx, 2);
|
|
var engine = await fx.StartEngineAsync();
|
|
// A desktop sharing the archive converts the first photo; this index still holds the original there.
|
|
var replaced = await ReplaceAsync(fx, id, [0], 500, by: await fx.OtherWriterAsync());
|
|
Assert.Equal(Sha(photos[0]), (await fx.Db.Frames.ListBySequenceAsync(id))[0].Sha256);
|
|
var sequence = (await fx.Db.Sequences.GetAsync(id))!;
|
|
var converted = fx.Paths.Sequence(sequence.Folder).File(Sidecar(fx, sequence).Frames[0].File);
|
|
|
|
// The conversion is damaged since: the dry run finds it in the sequence, and the emptying keeps the originals.
|
|
var bytes = Damage(converted);
|
|
var plan = await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct);
|
|
Assert.False(plan.Entries.Single().ConversionDeleted, "the archive holds the conversion, whatever this index has");
|
|
var kept = await EmptyAsync(fx, engine, plan, JobState.Failed);
|
|
Assert.Contains(Loc.L("Archive.Log.TrashKeptMismatch", replaced.Title), kept.LogTail);
|
|
Assert.Equal(replaced.Name, (await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct)).Single().Name);
|
|
|
|
// Whole again: the originals go.
|
|
File.WriteAllBytes(converted, bytes);
|
|
await EmptyAsync(fx, engine, await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct), JobState.Done);
|
|
Assert.Empty(await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct));
|
|
}
|
|
|
|
[Test]
|
|
public async Task AConversionAnotherIndexMovedIsHashedWhereItIsNow()
|
|
{
|
|
await using var fx = await CreateAsync(context);
|
|
var (id, _) = await UploadedAsync(fx, 2);
|
|
var engine = await fx.StartEngineAsync();
|
|
var replaced = await ReplaceAsync(fx, id, [0], 500);
|
|
// Another index moves the sequence into another folder; this one has not scanned since.
|
|
var before = (await fx.Db.Sequences.GetAsync(id))!.Folder;
|
|
var (other, archive) = await fx.OtherWriterAsync();
|
|
await other.ApplyRenameAsync(await other.PlanRenameAsync(archive.Id, [id], "moved/{title}", null, fx.Ct), null, fx.Ct);
|
|
Assert.Equal(before, (await fx.Db.Sequences.GetAsync(id))!.Folder);
|
|
var folder = ArchiveScanner.FindSequenceFolders(fx.Paths, fx.Ct).Select(s => fx.Paths.Sequence(s.RelativeFolder)).Single(s => s.RelativeFolder != before);
|
|
Assert.True(folder.RelativeFolder.StartsWith("moved", StringComparison.Ordinal), folder.RelativeFolder);
|
|
var converted = folder.File(ManifestStore.ReadSequence(folder.ManifestPath).Frames[0].File);
|
|
|
|
var bytes = Damage(converted);
|
|
var plan = await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct);
|
|
Assert.False(plan.Entries.Single().ConversionDeleted, "found in the folder the sequence is in now");
|
|
Assert.Contains(Loc.L("Archive.Log.TrashKeptMismatch", replaced.Title), (await EmptyAsync(fx, engine, plan, JobState.Failed)).LogTail);
|
|
|
|
File.WriteAllBytes(converted, bytes);
|
|
await EmptyAsync(fx, engine, await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct), JobState.Done);
|
|
Assert.Empty(await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct));
|
|
}
|
|
|
|
[Test]
|
|
public async Task OriginalsStayWhileTheArchiveCannotTellWhereTheirConversionIs()
|
|
{
|
|
await using var fx = await CreateAsync(context);
|
|
var (id, photos) = await UploadedAsync(fx, 2);
|
|
var engine = await fx.StartEngineAsync();
|
|
var replaced = await ReplaceAsync(fx, id, [0], 500);
|
|
var sequence = (await fx.Db.Sequences.GetAsync(id))!;
|
|
var folder = fx.Paths.Sequence(sequence.Folder);
|
|
var manifest = Sidecar(fx, sequence);
|
|
|
|
// A sidecar that cannot be read: a scan rebuilds it, as the line says.
|
|
File.WriteAllText(folder.ManifestPath, "{ \"damaged");
|
|
var plan = await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct);
|
|
Assert.False(plan.Entries.Single().ConversionDeleted);
|
|
Assert.Contains(Loc.L("Archive.Log.TrashKeptUnreadable", replaced.Title), (await EmptyAsync(fx, engine, plan, JobState.Failed)).LogTail);
|
|
|
|
// A sidecar rebuilt from the photos, as a scan adopts a folder that lost its own: new frame ids, nothing hashed, no
|
|
// tombstones. A verify of the sequence, as the line says, may find the conversion in one of its frames.
|
|
var rebuilt = manifest with { Frames = [.. manifest.Frames.Select(f => f with { Id = Guid.CreateVersion7(), Sha256 = null })], Removed = null };
|
|
ManifestStore.WriteSequence(folder.ManifestPath, rebuilt);
|
|
plan = await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct);
|
|
Assert.False(plan.Entries.Single().ConversionDeleted);
|
|
Assert.Contains(Loc.L("Archive.Log.TrashKeptUnhashed", replaced.Title), (await EmptyAsync(fx, engine, plan, JobState.Failed)).LogTail);
|
|
// Unless their files are missing: there is nothing a verify could hash.
|
|
ManifestStore.WriteSequence(folder.ManifestPath, rebuilt with { Frames = [.. rebuilt.Frames.Select(f => f with { Flags = f.Flags | FrameFlags.Missing })] });
|
|
plan = await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct);
|
|
Assert.Contains(Loc.L("Archive.Log.TrashKeptUnknown", replaced.Title), (await EmptyAsync(fx, engine, plan, JobState.Failed)).LogTail);
|
|
// Nor when they are flagged corrupt: a verify does not hash a file whose size differs from its record, so it would
|
|
// never settle the entry.
|
|
ManifestStore.WriteSequence(folder.ManifestPath, rebuilt with { Frames = [.. rebuilt.Frames.Select(f => f with { Flags = f.Flags | FrameFlags.Corrupt })] });
|
|
plan = await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct);
|
|
Assert.Contains(Loc.L("Archive.Log.TrashKeptUnknown", replaced.Title), (await EmptyAsync(fx, engine, plan, JobState.Failed)).LogTail);
|
|
|
|
// Hashed, the conversion damaged meanwhile: no frame holds it and no tombstone says it was deleted. The originals stay,
|
|
// and the dry run never calls them the last copy: only the archive's own word makes a conversion deleted.
|
|
Damage(folder.File(manifest.Frames[0].File));
|
|
ManifestStore.WriteSequence(folder.ManifestPath, rebuilt with { Frames = [.. rebuilt.Frames.Select(f => f with { Sha256 = Sha(folder.File(f.File)) })] });
|
|
plan = await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct);
|
|
Assert.False(plan.Entries.Single().ConversionDeleted, "nothing in the archive says the conversion was deleted");
|
|
Assert.Contains(Loc.L("Archive.Log.TrashKeptUnknown", replaced.Title), (await EmptyAsync(fx, engine, plan, JobState.Failed)).LogTail);
|
|
|
|
// Restored, as the line says, the original comes back whole, as a sequence of its own.
|
|
var restored = await fx.Service.RestoreEntryAsync(fx.Archive.Id, replaced.Name, null, fx.Ct);
|
|
Assert.True(restored.NewSequence);
|
|
Assert.SequenceEqual([Sha(photos[0])], (await fx.Db.Frames.ListBySequenceAsync(restored.Sequence.Id)).Select(f => f.Sha256!));
|
|
Assert.Empty(await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct));
|
|
}
|
|
|
|
[Test]
|
|
public async Task AConversionAnotherHostMadeIsNotTakenForDeletedOnceItsSidecarIsRebuilt()
|
|
{
|
|
await using var fx = await CreateAsync(context);
|
|
var (id, photos) = await UploadedAsync(fx, 2);
|
|
var engine = await fx.StartEngineAsync();
|
|
// A desktop sharing the archive converts the first photo: this index never sees the converted file.
|
|
var replaced = await ReplaceAsync(fx, id, [0], 500, by: await fx.OtherWriterAsync());
|
|
var sequence = (await fx.Db.Sequences.GetAsync(id))!;
|
|
var folder = fx.Paths.Sequence(sequence.Folder);
|
|
// The conversion is damaged and the sidecar lost since: this index's scan rebuilds the sidecar from the photos with what
|
|
// it knew, which is nothing of the conversion (the converted file gets a new frame id, no tombstone names it).
|
|
Damage(folder.File(Sidecar(fx, sequence).Frames[0].File));
|
|
File.Delete(folder.ManifestPath);
|
|
await fx.ScanAsync();
|
|
Assert.Null(Sidecar(fx, sequence).Removed);
|
|
var before = await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct);
|
|
Assert.False(before.Entries.Single().ConversionDeleted);
|
|
Assert.Contains(Loc.L("Archive.Log.TrashKeptUnhashed", replaced.Title), (await EmptyAsync(fx, engine, before, JobState.Failed)).LogTail);
|
|
|
|
// A routine verify hashes every photo, the damaged conversion too: still nothing says the conversion was deleted, so the
|
|
// originals, the only good copy of that photo, are neither called the last copy nor erased.
|
|
await fx.Service.Verifier.VerifyAsync(fx.Archive, [id], default, (_, _, _) => ValueTask.CompletedTask, cancellationToken: fx.Ct);
|
|
Assert.True(Sidecar(fx, sequence).Frames.All(f => f.Sha256 is not null), "verified");
|
|
var plan = await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct);
|
|
Assert.False(plan.Entries.Single().ConversionDeleted, "the archive does not say the conversion was deleted");
|
|
Assert.Contains(Loc.L("Archive.Log.TrashKeptUnknown", replaced.Title), (await EmptyAsync(fx, engine, plan, JobState.Failed)).LogTail);
|
|
var record = Assert.NotNull(FrameTrash.ReadEntry(fx.Paths, replaced.Name));
|
|
Assert.Equal(Sha(photos[0]), Sha(Path.Combine(FrameTrash.Location(fx.Paths, replaced.Name).Folder, record.Photos[0].Files[0].Path)));
|
|
}
|
|
|
|
[Test]
|
|
public async Task OriginalsOfASequenceAnotherHostDeletedAndErasedGoAsTheDryRunSays()
|
|
{
|
|
await using var fx = await CreateAsync(context);
|
|
var (id, _) = await UploadedAsync(fx, 2);
|
|
var engine = await fx.StartEngineAsync();
|
|
var replaced = await ReplaceAsync(fx, id, [0, 1], 500);
|
|
// A desktop sharing the archive deletes the converted sequence and erases its entry alone; this index still lists it.
|
|
var (other, archive) = await fx.OtherWriterAsync();
|
|
await other.Trash.DeleteAsync(await other.Trash.PlanAsync([id], null, fx.Ct), null, null, fx.Ct);
|
|
var deleted = (await other.ListTrashAsync(archive.Id, fx.Ct)).Single(e => e.Kind == TrashKind.Sequence);
|
|
var erased = await other.Trash.EmptyAsync(archive, Parameters(await other.Trash.PlanEmptyAsync(archive, [deleted.Name], fx.Ct)), 0,
|
|
(_, _) => ValueTask.CompletedTask, fx.Ct);
|
|
Assert.Equal((1, 0), (erased.Erased, erased.Refused.Count));
|
|
Assert.NotNull(await fx.Db.Sequences.GetAsync(id));
|
|
var erasures = Path.Combine(SequenceTrash.TrashDirectory(fx.Paths), ".erased");
|
|
Assert.FileExists(Path.Combine(erasures, $"{id:N}.json"));
|
|
|
|
// The trash's record of that erasing is the archive's word that the conversions went with the sequence, whatever this
|
|
// index still lists: the dry run says so, and the emptying confirmed with it erases.
|
|
var plan = await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct);
|
|
Assert.True(plan.Entries.Single().ConversionDeleted, "the trash erased the sequence that held the conversions");
|
|
await EmptyAsync(fx, engine, plan, JobState.Done);
|
|
Assert.Empty(await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct));
|
|
Assert.False(Directory.Exists(erasures), "no entry needs the record any more");
|
|
}
|
|
|
|
[Test]
|
|
public async Task ASequenceThatAlsoLivesLeavesNoRecordOfItsErasing()
|
|
{
|
|
await using var fx = await CreateAsync(context);
|
|
var (id, _) = await UploadedAsync(fx, 2);
|
|
var engine = await fx.StartEngineAsync();
|
|
var replaced = await ReplaceAsync(fx, id, [0, 1], 500);
|
|
var sequence = (await fx.Db.Sequences.GetAsync(id))!;
|
|
// A copy of the converted sequence's folder made outside Chronos: its sidecar names the same sequence.
|
|
var source = fx.Paths.Sequence(sequence.Folder).Folder;
|
|
var copy = Path.Combine(fx.Paths.Root, "copy", Path.GetFileName(source));
|
|
foreach (var file in Directory.EnumerateFiles(source, "*", SearchOption.AllDirectories))
|
|
{
|
|
var target = Path.Combine(copy, Path.GetRelativePath(source, file));
|
|
Directory.CreateDirectory(Path.GetDirectoryName(target)!);
|
|
File.Copy(file, target);
|
|
}
|
|
await fx.Service.Trash.DeleteAsync(await fx.Service.Trash.PlanAsync([id], null, fx.Ct), null, null, fx.Ct);
|
|
var deleted = (await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct)).Single(e => e.Kind == TrashKind.Sequence);
|
|
|
|
// Erasing the deleted sequence while a folder still names it leaves no record that its conversions went with it.
|
|
var erased = await fx.Service.Trash.EmptyAsync(fx.Archive, Parameters(await fx.Service.Trash.PlanEmptyAsync(fx.Archive, [deleted.Name], fx.Ct)), 0,
|
|
(_, _) => ValueTask.CompletedTask, fx.Ct);
|
|
Assert.Equal((1, 0), (erased.Erased, erased.Refused.Count));
|
|
Assert.FileMissing(Path.Combine(SequenceTrash.TrashDirectory(fx.Paths), ".erased", $"{id:N}.json"));
|
|
|
|
// So once the copy's sidecar is lost, the walk missing it, the originals stay: its conversions are still there.
|
|
File.Delete(Path.Combine(copy, Path.GetRelativePath(source, fx.Paths.Sequence(sequence.Folder).ManifestPath)));
|
|
var plan = await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct);
|
|
Assert.False(plan.Entries.Single().ConversionDeleted);
|
|
Assert.Contains(Loc.L("Archive.Log.TrashKeptUnknown", replaced.Title), (await EmptyAsync(fx, engine, plan, JobState.Failed)).LogTail);
|
|
Assert.Equal(replaced.Name, (await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct)).Single().Name);
|
|
}
|
|
|
|
[Test]
|
|
public async Task OriginalsOfASequenceGoneWithoutTheTrashErasingItStay()
|
|
{
|
|
await using var fx = await CreateAsync(context);
|
|
var (id, photos) = await UploadedAsync(fx, 2);
|
|
var engine = await fx.StartEngineAsync();
|
|
var replaced = await ReplaceAsync(fx, id, [0], 500);
|
|
var sequence = (await fx.Db.Sequences.GetAsync(id))!;
|
|
|
|
// The sequence's folder removed outside Chronos while this index still lists it: kept, and the line says what drops the row.
|
|
Directory.Delete(fx.Paths.Sequence(sequence.Folder).Folder, recursive: true);
|
|
var plan = await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct);
|
|
Assert.False(plan.Entries.Single().ConversionDeleted);
|
|
Assert.Contains(Loc.L("Archive.Log.TrashKeptStaleIndex", replaced.Title), (await EmptyAsync(fx, engine, plan, JobState.Failed)).LogTail);
|
|
|
|
// Rebuilt, the index lists it no more; still nothing in the archive says the conversion was deleted, so the originals,
|
|
// the only copy of that photo there is, stay.
|
|
await fx.ScanAsync(ScanMode.Rebuild);
|
|
Assert.Null(await fx.Db.Sequences.GetAsync(id));
|
|
plan = await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct);
|
|
Assert.False(plan.Entries.Single().ConversionDeleted, "no sequence of that id anywhere, and no record of erasing it");
|
|
Assert.Contains(Loc.L("Archive.Log.TrashKeptUnknown", replaced.Title), (await EmptyAsync(fx, engine, plan, JobState.Failed)).LogTail);
|
|
|
|
// Restored, as the line says, it comes back as a sequence of its own.
|
|
var restored = await fx.Service.RestoreEntryAsync(fx.Archive.Id, replaced.Name, null, fx.Ct);
|
|
Assert.True(restored.NewSequence);
|
|
Assert.SequenceEqual([Sha(photos[0])], (await fx.Db.Frames.ListBySequenceAsync(restored.Sequence.Id)).Select(f => f.Sha256!));
|
|
Assert.Empty(await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct));
|
|
}
|
|
|
|
[Test]
|
|
public async Task OriginalsStayWhileTheirSequenceIsInAFolderWithoutSidecar()
|
|
{
|
|
await using var fx = await CreateAsync(context);
|
|
var (id, _) = await UploadedAsync(fx, 2);
|
|
var engine = await fx.StartEngineAsync();
|
|
var replaced = await ReplaceAsync(fx, id, [0], 500);
|
|
// Another index moves the sequence, its sidecar is lost there, and this index, which never saw the move, lists it no more.
|
|
var (other, archive) = await fx.OtherWriterAsync();
|
|
await other.ApplyRenameAsync(await other.PlanRenameAsync(archive.Id, [id], "moved/{title}", null, fx.Ct), null, fx.Ct);
|
|
var moved = ArchiveScanner.FindSequenceFolders(fx.Paths, fx.Ct).Select(s => fx.Paths.Sequence(s.RelativeFolder)).Single();
|
|
Assert.True(moved.RelativeFolder.StartsWith("moved", StringComparison.Ordinal), moved.RelativeFolder);
|
|
File.Delete(moved.ManifestPath);
|
|
await fx.Db.Sequences.DeleteAsync(id, fx.Ct);
|
|
|
|
// The walk of the archive cannot tell whose photos those are, and the trash never erased the sequence: its conversion,
|
|
// alive there, is not taken for deleted, and the originals stay without it being hashed.
|
|
var plan = await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct);
|
|
Assert.False(plan.Entries.Single().ConversionDeleted);
|
|
Assert.Contains(Loc.L("Archive.Log.TrashKeptUnknown", replaced.Title), (await EmptyAsync(fx, engine, plan, JobState.Failed)).LogTail);
|
|
Assert.Equal(replaced.Name, (await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct)).Single().Name);
|
|
}
|
|
|
|
[Test]
|
|
public async Task OriginalsOfAConvertedSequenceErasedBeforeThemGoAsTheDryRunSays()
|
|
{
|
|
await using var fx = await CreateAsync(context);
|
|
var (id, _) = await UploadedAsync(fx, 2);
|
|
var (second, _) = await UploadedAsync(fx, 2, "upload-2");
|
|
var engine = await fx.StartEngineAsync();
|
|
var replaced = await ReplaceAsync(fx, id, [0, 1], 500);
|
|
var together = await ReplaceAsync(fx, second, [0], 600);
|
|
await fx.Service.Trash.DeleteAsync(await fx.Service.Trash.PlanAsync([id, second], null, fx.Ct), null, null, fx.Ct);
|
|
var erasures = Path.Combine(SequenceTrash.TrashDirectory(fx.Paths), ".erased");
|
|
|
|
// The first sequence's entry erased alone: the trash records erasing it, for the originals it leaves there.
|
|
var deleted = (await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct)).Single(e => e.Kind == TrashKind.Sequence && e.SequenceId == id);
|
|
await EmptyAsync(fx, engine, await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, [deleted.Name], fx.Ct), JobState.Done);
|
|
Assert.Equal($"{id:N}.json", Path.GetFileName(Directory.EnumerateFiles(erasures).Single()));
|
|
|
|
// Then everything in one run: the first one's originals as that record says, the second sequence, then its originals
|
|
// as the record its erasing leaves says. No record is left once no entry needs one.
|
|
var plan = await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct);
|
|
Assert.Count(3, plan.Entries);
|
|
Assert.True(plan.Entries.Single(e => e.Name == replaced.Name).ConversionDeleted, "the trash erased the sequence that held the conversions");
|
|
Assert.True(plan.Entries.Single(e => e.Name == together.Name).ConversionDeleted, "its sequence is in the trash");
|
|
await EmptyAsync(fx, engine, plan, JobState.Done);
|
|
Assert.Empty(await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct));
|
|
Assert.False(Directory.Exists(erasures), "no entry needs a record of erasing any more");
|
|
Assert.Empty(Directory.EnumerateFiles(SequenceTrash.TrashDirectory(fx.Paths), "*", SearchOption.AllDirectories));
|
|
}
|
|
|
|
[Test]
|
|
public async Task AnEmptyingWalksTheArchiveAgainForASequenceThatMovedSinceItsWalk()
|
|
{
|
|
await using var fx = await CreateAsync(context);
|
|
var (id, _) = await UploadedAsync(fx, 2);
|
|
var (second, _) = await UploadedAsync(fx, 3, "upload-2");
|
|
var replaced = await ReplaceAsync(fx, id, [0], 500);
|
|
// Photos deleted from another sequence since: the newer entry, erased first.
|
|
var row = (await fx.Db.Sequences.GetAsync(second))!;
|
|
var deletion = await fx.Service.FrameTrash.DeleteAsync(
|
|
await fx.Service.FrameTrash.PlanDeleteAsync(second, [(await fx.Db.Frames.ListBySequenceAsync(second))[0].Id], row.FramesVersion, fx.Ct), null, null, fx.Ct);
|
|
// Another index moved the converted sequence: this one finds it by walking the archive, once for the whole plan.
|
|
var (other, archive) = await fx.OtherWriterAsync();
|
|
await other.ApplyRenameAsync(await other.PlanRenameAsync(archive.Id, [id], "moved/{title}", null, fx.Ct), null, fx.Ct);
|
|
var plan = await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct);
|
|
Assert.SequenceEqual([deletion.Entry.Name, replaced.Name], plan.Entries.Select(e => e.Name));
|
|
Assert.False(plan.Entries.Single(e => e.Name == replaced.Name).ConversionDeleted, "found where it is now");
|
|
|
|
// It moves again while the emptying erases the other entry: the folder that walk found no longer holds it, so the archive
|
|
// is walked again, and the conversion is hashed where it is now.
|
|
var result = await fx.Service.Trash.EmptyAsync(fx.Archive, Parameters(plan), 0, async (done, _) =>
|
|
{
|
|
if (done == 1) await other.ApplyRenameAsync(await other.PlanRenameAsync(archive.Id, [id], "again/{title}", null, fx.Ct), null, fx.Ct);
|
|
}, fx.Ct);
|
|
Assert.Equal((2, 0), (result.Erased, result.Refused.Count));
|
|
Assert.Empty(await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct));
|
|
}
|
|
|
|
[Test]
|
|
public async Task OriginalsOfABusySequenceStayInTheTrash()
|
|
{
|
|
await using var fx = await CreateAsync(context, configure: o => o with { LeaseWait = TimeSpan.FromMilliseconds(300) });
|
|
var (id, _) = await UploadedAsync(fx, 2);
|
|
var replaced = await ReplaceAsync(fx, id, [0], 500);
|
|
var plan = await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct);
|
|
var parameters = new EmptyTrashParameters([.. plan.Entries.Select(e => new EmptyTrashItem(e.Name, SequenceTrash.EntryFingerprint(e)))], plan.Fingerprint);
|
|
|
|
// Another host writes the sequence meanwhile: the conversion is not weighed under it.
|
|
using (Assert.NotNull(LeaseFile.TryAcquire(fx.Paths.LocksDirectory, $"seq-{id:N}", "another host")))
|
|
{
|
|
var busy = await fx.Service.Trash.EmptyAsync(fx.Archive, parameters, 0, (_, _) => ValueTask.CompletedTask, fx.Ct);
|
|
Assert.Equal((0, TrashKeptReason.Busy), (busy.Erased, busy.Refused.Single().Reason));
|
|
Assert.Equal(Loc.L("Archive.Log.TrashKeptBusy", replaced.Title), busy.Refused.Single().LogLine);
|
|
}
|
|
Assert.Equal(replaced.Name, (await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct)).Single().Name);
|
|
|
|
var free = await fx.Service.Trash.EmptyAsync(fx.Archive, parameters, 0, (_, _) => ValueTask.CompletedTask, fx.Ct);
|
|
Assert.Equal((1, 0), (free.Erased, free.Refused.Count));
|
|
}
|
|
|
|
[Test]
|
|
public async Task AConversionAnotherHostDeletedIsReadFromTheArchiveNotThisIndex()
|
|
{
|
|
await using var fx = await CreateAsync(context);
|
|
var (id, _) = await UploadedAsync(fx, 3);
|
|
var engine = await fx.StartEngineAsync();
|
|
var replaced = await ReplaceAsync(fx, id, [0], 500);
|
|
var frames = await fx.Db.Frames.ListBySequenceAsync(id);
|
|
// A desktop sharing the archive deletes the converted photo; this index still holds it.
|
|
var (other, _) = await fx.OtherWriterAsync();
|
|
var deletion = await other.FrameTrash.DeleteAsync(await other.FrameTrash.PlanDeleteAsync(id, [frames[0].Id], null, fx.Ct), null, null, fx.Ct);
|
|
Assert.Count(3, await fx.Db.Frames.ListBySequenceAsync(id));
|
|
|
|
var plan = await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct);
|
|
Assert.True(plan.Entries.Single(e => e.Name == replaced.Name).ConversionDeleted, "the sidecar's tombstone says so, whatever this index holds");
|
|
Assert.False(plan.Entries.Single(e => e.Name == deletion.Entry.Name).ConversionDeleted);
|
|
|
|
// The deleted conversion is in the trash, damaged: the originals stay.
|
|
var record = Assert.NotNull(FrameTrash.ReadEntry(fx.Paths, deletion.Entry.Name));
|
|
var copy = Path.Combine(FrameTrash.Location(fx.Paths, deletion.Entry.Name).Folder, record.Photos[0].Files[0].Path);
|
|
var bytes = Damage(copy);
|
|
var kept = await EmptyAsync(fx, engine, await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, [replaced.Name], fx.Ct), JobState.Failed);
|
|
Assert.Contains(Loc.L("Archive.Log.TrashKeptMismatch", replaced.Title), kept.LogTail);
|
|
|
|
// Whole again: the originals go, the deleted conversion stays where it is.
|
|
File.WriteAllBytes(copy, bytes);
|
|
await EmptyAsync(fx, engine, await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, [replaced.Name], fx.Ct), JobState.Done);
|
|
Assert.Equal(deletion.Entry.Name, (await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct)).Single().Name);
|
|
}
|
|
|
|
[Test]
|
|
public async Task OriginalsStayWhenTheirConversionChangedSince()
|
|
{
|
|
await using var fx = await CreateAsync(context);
|
|
var (id, _) = await UploadedAsync(fx, 2);
|
|
var engine = await fx.StartEngineAsync();
|
|
var replaced = await ReplaceAsync(fx, id, [0], 500);
|
|
var sequence = (await fx.Db.Sequences.GetAsync(id))!;
|
|
var folder = fx.Paths.Sequence(sequence.Folder);
|
|
var manifest = Sidecar(fx, sequence);
|
|
// The converted file was edited in place and hashed again: its frame holds other content, and nothing says what
|
|
// became of the conversion.
|
|
var edited = Photos.Jpeg(manifest.Frames[0].CapturedAt, 700);
|
|
File.WriteAllBytes(folder.File(manifest.Frames[0].File), edited);
|
|
ManifestStore.WriteSequence(folder.ManifestPath, manifest with
|
|
{
|
|
Frames = [.. manifest.Frames.Select((f, i) => i == 0 ? f with { Sha256 = Sha(edited), Size = edited.Length } : f)],
|
|
});
|
|
|
|
var plan = await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, null, fx.Ct);
|
|
Assert.False(plan.Entries.Single().ConversionDeleted, "the frame is there");
|
|
Assert.Contains(Loc.L("Archive.Log.TrashKeptMismatch", replaced.Title), (await EmptyAsync(fx, engine, plan, JobState.Failed)).LogTail);
|
|
Assert.Equal(replaced.Name, (await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct)).Single().Name);
|
|
}
|
|
|
|
[Test]
|
|
public async Task AnEmptyingReadsAnEntryOnlyOnceAnUndoWaitingForItIsSettled()
|
|
{
|
|
await using var fx = await CreateAsync(context);
|
|
var (id, photos) = await UploadedAsync(fx, 2);
|
|
var engine = await fx.StartEngineAsync();
|
|
var replaced = await ReplaceAsync(fx, id, [0], 500);
|
|
var (entryFolder, recordPath) = FrameTrash.Location(fx.Paths, replaced.Name);
|
|
var record = await File.ReadAllTextAsync(recordPath, fx.Ct);
|
|
// Undone: the original is back in its frame, the conversion in an entry of its own.
|
|
await fx.Service.RestoreEntryAsync(fx.Archive.Id, replaced.Name, null, fx.Ct);
|
|
var undo = (await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct)).Single();
|
|
// As a crash right after the undo's sidecar was written leaves it: the entry its original came from still lists it,
|
|
// and the undo's completion waits for that entry's lease.
|
|
Directory.CreateDirectory(entryFolder);
|
|
await File.WriteAllTextAsync(recordPath, record, fx.Ct);
|
|
var sequence = (await fx.Db.Sequences.GetAsync(id))!;
|
|
var folder = fx.Paths.Sequence(sequence.Folder);
|
|
var manifest = Sidecar(fx, sequence);
|
|
var (undoFolder, undoRecord) = FrameTrash.Location(fx.Paths, undo.Name);
|
|
new FrameReplaceJournal(manifest.Versions.Frames - 1, fx.Paths.ToRelative(undoRecord), fx.Paths.ToRelative(undoFolder), [], [], false,
|
|
new ConsumedEntry(fx.Paths.ToRelative(recordPath), fx.Paths.ToRelative(entryFolder), SequenceTrash.EntryLease(replaced.Name), [manifest.Frames[0].Id],
|
|
null))
|
|
{
|
|
Phase = ReplacePhase.Written,
|
|
}.Write(folder);
|
|
var plan = await fx.Service.PlanEmptyTrashAsync(fx.Archive.Id, [replaced.Name], fx.Ct);
|
|
Assert.Equal(replaced.Name, plan.Entries.Single().Name);
|
|
|
|
// The emptying settles the undo under the entry's lease before it reads the entry again, which takes the photo out of
|
|
// it: the entry is not erased as planned, and the sequence keeps its original.
|
|
var kept = await EmptyAsync(fx, engine, plan, JobState.Failed);
|
|
Assert.Contains(Loc.L("Archive.Log.TrashKept", replaced.Title), kept.LogTail);
|
|
Assert.FileMissing(folder.ReplaceJournalPath);
|
|
Assert.Equal(undo.Name, (await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct)).Single().Name);
|
|
Assert.Equal(Sha(photos[0]), Sha(folder.File(Sidecar(fx, sequence).Frames[0].File)));
|
|
}
|
|
|
|
[Test]
|
|
public async Task AnEntryNamesTheJobThatReplacedItsPhotos()
|
|
{
|
|
await using var fx = await CreateAsync(context);
|
|
var (id, photos) = await UploadedAsync(fx, 2);
|
|
var job = Guid.CreateVersion7();
|
|
var entry = await ReplaceAsync(fx, id, [0, 1], 500, job);
|
|
Assert.Equal(job, entry.JobId);
|
|
Assert.Equal(job, (await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct)).Single().JobId);
|
|
|
|
// Its undo swaps the originals back; the entry of the converted files it makes names no job.
|
|
var undone = await fx.Service.RestoreEntryAsync(fx.Archive.Id, entry.Name, null, fx.Ct);
|
|
Assert.False(undone.NewSequence);
|
|
Assert.SequenceEqual(photos.Select(Sha), (await fx.Db.Frames.ListBySequenceAsync(id)).Select(f => f.Sha256!));
|
|
var swapped = (await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct)).Single();
|
|
Assert.Equal(TrashKind.Replaced, swapped.Kind);
|
|
Assert.Null(swapped.JobId);
|
|
}
|
|
|
|
[Test]
|
|
public async Task PositionsOnAConvertedFrameStayWhenAFrameWentBehindTheIndex()
|
|
{
|
|
await using var fx = await CreateAsync(context);
|
|
var (id, _) = await UploadedAsync(fx, 3);
|
|
var frames = await fx.Db.Frames.ListBySequenceAsync(id);
|
|
var project = new ProjectSettings { ExcludedFrames = [2], HeroFrame = 2 }.ToJson();
|
|
await fx.Db.Sequences.EditAsync(id, new SequenceEdit { SettingsJson = project, HeroFrameId = frames[2].Id }, null, fx.Ct);
|
|
// A desktop sharing the archive deletes the first photo; this index has not read the sidecar since.
|
|
var (other, _) = await fx.OtherWriterAsync();
|
|
await other.FrameTrash.DeleteAsync(await other.FrameTrash.PlanDeleteAsync(id, [frames[0].Id], null, fx.Ct), null, null, fx.Ct);
|
|
|
|
// This host converts the photo the positions are on (second in the sidecar now).
|
|
await ReplaceAsync(fx, id, [1], 500);
|
|
|
|
var row = (await fx.Db.Sequences.GetAsync(id))!;
|
|
var settings = ProjectSettings.FromJson(row.SettingsJson!);
|
|
Assert.SequenceEqual([1], settings.ExcludedFrames);
|
|
Assert.Equal((1, frames[2].Id), (settings.HeroFrame, row.HeroFrameId));
|
|
Assert.True(settings.PendingFrames is not { Count: > 0 }, "nothing waits for the photo the conversion replaced");
|
|
}
|
|
|
|
[Test]
|
|
public async Task TheOriginalOfAConvertedPhotoFiledAgainIsADuplicateOfItsConversion()
|
|
{
|
|
await using var fx = await CreateAsync(context);
|
|
var (id, photos) = await UploadedAsync(fx, 2, "card-1");
|
|
await ReplaceAsync(fx, id, [0], 500);
|
|
var sequence = (await fx.Db.Sequences.GetAsync(id))!;
|
|
var converted = Sidecar(fx, sequence).Frames[0];
|
|
|
|
// The card imported again on a PC without its history (same session, so the same sequence).
|
|
var again = await CommitAsync(fx, null, "card-1", photos[0], "IMG_0001.JPG");
|
|
Assert.Equal((id, converted.Id, true), (again.SequenceId, again.FrameId, again.Duplicate));
|
|
var after = Sidecar(fx, sequence);
|
|
Assert.Count(2, after.Frames);
|
|
Assert.Contains(after.Removed!, r => r.Sha256 == Sha(photos[0]) && r.Replacement == converted.Sha256 && r.Reason == RemovalReason.Replaced);
|
|
Assert.True(await fx.Db.FrameRemovals.IsRemovedAsync(id, Sha(photos[0]), fx.Ct), "the alias stays in the index");
|
|
|
|
// Converted once more: the original is a duplicate of the last conversion.
|
|
await ReplaceAsync(fx, id, [0], 600);
|
|
var last = Sidecar(fx, sequence).Frames[0];
|
|
var third = await CommitAsync(fx, null, "card-1", photos[0], "IMG_0001.JPG");
|
|
Assert.Equal((last.Id, true), (third.FrameId, third.Duplicate));
|
|
Assert.Count(2, Sidecar(fx, sequence).Frames);
|
|
}
|
|
|
|
[Test]
|
|
public async Task AFolderImportedAgainDoesNotFileTheOriginalsOfItsConvertedPhotos()
|
|
{
|
|
await using var fx = await CreateAsync(context);
|
|
var source = Path.Combine(context.CreateTempDirectory("source"), "Etna eruption");
|
|
Photos.WriteSeries(source, Start, 3);
|
|
var whole = new ImportOptions { Grouping = ImportGrouping.WholeFolder };
|
|
var plan = await fx.Service.PlanImportAsync(fx.Archive.Id, source, whole, null, null, fx.Ct);
|
|
await fx.Service.Imports.ExecuteAsync(new ImportJobParameters(fx.Archive.Id, plan, null, 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;
|
|
await ReplaceAsync(fx, id, [0, 1, 2], 500);
|
|
var sequence = (await fx.Db.Sequences.GetAsync(id))!;
|
|
var aliases = Sidecar(fx, sequence).Removed!.Count;
|
|
|
|
// A new shot in the folder, imported with the rest of it.
|
|
Photos.WriteSeries(source, Start.AddMinutes(5), 1, firstSeed: 40, prefix: "LATE_");
|
|
var later = await fx.Service.PlanImportAsync(fx.Archive.Id, source, whole, null, null, fx.Ct);
|
|
await fx.Service.Imports.ExecuteAsync(new ImportJobParameters(fx.Archive.Id, later, null, true, null), Guid.NewGuid(), 0, _ => ValueTask.CompletedTask, null,
|
|
fx.Ct);
|
|
|
|
var after = Sidecar(fx, sequence);
|
|
Assert.Count(4, after.Frames);
|
|
Assert.Equal(aliases, after.Removed!.Count);
|
|
Assert.Equal(3, after.Frames.Count(f => f.Source is not null));
|
|
}
|
|
}
|