Files
Chronos/tests/Chronos.Core.Tests/Archiving/ReorganizeTests.cs
T
Alby96andClaude Opus 5.5 7e4a3b481d
CI / Build and test (push) Successful in 9m15s
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 6s
Release / Build, test and publish (push) Successful in 15m35s
CI / PostgreSQL 16 integration (push) Successful in 7m26s
CI / PostgreSQL 17 integration (push) Successful in 6m47s
CI / Docker image (push) Successful in 59s
Release / Server image (push) Successful in 1m24s
feat: owner review 2 phase 4a: Reorganize sequences after import (#12)
- Reorganize… on the web panel and the desktop: folder, file and title templates applied to existing sequences, with a dry run and an explicit Apply that runs as a job.
- One naming rule (FrameNaming) for import, upload and Reorganize.
- Crash-safe plan and file journals, held plans, stale-plan refusal; exports move with their folder.
- Writers refuse a folder another program moved or gave to another sequence.
- Server: POST /api/v1/archive/reorganize with a bounded plan cache; template rules.
- Phase 3 docs and translations merged; strings in all 38 languages.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: Alberto Balbo <alberto.balbo.96@gmail.com>
2026-10-27 21:58:39 +01:00

775 lines
48 KiB
C#

using System.Text;
using Chronos.Core.Archiving;
using Chronos.Core.Naming;
using Chronos.Testing;
namespace Chronos.Core.Tests.Archiving;
/// <summary>Reorganize (owner review 2, R7): file names planned from a template, and the two-phase renames of a sequence's files.</summary>
[Category("archive")]
public sealed class ReorganizeTests(TestContext context)
{
private static readonly DateTime Start = new(2026, 9, 28, 18, 0, 0);
/// <summary>Frames in index order, every one hashed, ten seconds apart.</summary>
private static SequenceManifest Sequence(params string[] files) => new()
{
Id = Guid.NewGuid(),
Camera = new SidecarCamera { Make = "Canon", Model = "Canon EOS R5" },
Versions = new ManifestVersions { Frames = 4 },
Frames = [.. files.Select((f, i) => new SidecarFrame
{
Id = Guid.NewGuid(),
I = i,
File = f,
Original = $"IMG_{i + 1:0000}{Path.GetExtension(f)}",
Sha256 = new string((char)('a' + i % 6), 64),
CapturedAt = Start.AddSeconds(10 * i),
})],
};
private static FileRenamePlan Plan(SequenceManifest manifest, string template, string? title = null, IEnumerable<string>? extra = null) =>
FileRenames.Plan(manifest, title, PathTemplate.Parse(template), [.. manifest.Frames.Select(f => f.File), .. extra ?? []]);
[Test]
public void FramesAreNamedInIndexOrderAndNamesTakenGetNumbersAsFilingDoes()
{
var manifest = Sequence("originals/c.JPG", "originals/a.JPG", "originals/b.JPG", "originals/d.JPG");
var plan = Plan(manifest, "{date}");
Assert.SequenceEqual(["originals/2026-09-28.JPG", "originals/2026-09-28_2.JPG", "originals/2026-09-28_3.JPG", "originals/2026-09-28_4.JPG"],
plan.Moves.Select(m => m.To));
Assert.SequenceEqual(manifest.Frames.Select(f => f.Id), plan.Moves.Select(m => m.FrameId));
Assert.Equal(4, plan.Frames);
Assert.SequenceEqual(plan.Moves.Take(FileRenames.SampleCount), plan.Samples);
Assert.Empty(plan.Blocked);
}
[Test]
public void AChainOfNamesIsPlannedAndAFileNoFrameListsKeepsItsName()
{
// Frame 1 now holds the name frame 0 gets, frame 2 the one frame 1 gets: 2→1, 3→2, 4→3. A file no frame lists holds "4".
var manifest = Sequence("originals/2.JPG", "originals/3.JPG", "originals/4.JPG");
var plan = Plan(manifest, "{n:0}");
Assert.SequenceEqual(["originals/2.JPG>originals/1.JPG", "originals/3.JPG>originals/2.JPG", "originals/4.JPG>originals/3.JPG"],
plan.Moves.Select(m => $"{m.From}>{m.To}"));
var stray = Plan(manifest, "{n:0}", extra: ["originals/1.jpg", "originals/notes.txt"]);
Assert.Equal("originals/1_2.JPG", stray.Moves[0].To);
}
[Test]
public void PhotosInPlaceUnhashedOrMissingKeepTheirNamesAndHoldThem()
{
var manifest = Sequence("IMG_0001.JPG", "originals/IMG_0002.JPG", "originals/IMG_0003.JPG", "originals/IMG_0004.JPG");
manifest = manifest with { Frames = [manifest.Frames[0], manifest.Frames[1] with { Sha256 = null }, manifest.Frames[2], manifest.Frames[3]] };
// The third photo is not on disk; the fourth would take its name.
var plan = FileRenames.Plan(manifest, "IMG_0003", PathTemplate.Parse("{title}"), ["IMG_0001.JPG", "originals/IMG_0002.JPG", "originals/IMG_0004.JPG"]);
Assert.SequenceEqual([(RenameBlock.InPlace, 1), (RenameBlock.Unhashed, 1), (RenameBlock.Missing, 1)], plan.Blocked.Select(b => (b.Reason, b.Frames)));
Assert.Equal("originals/IMG_0004.JPG>originals/IMG_0003_2.JPG", plan.Moves.Select(m => $"{m.From}>{m.To}").Single());
Assert.Equal(1, plan.Frames);
}
[Test]
public void CompanionsFollowTheirPhotoAndTheirNamesAreKeptFree()
{
var manifest = Sequence("originals/A.CR2", "originals/B.CR2");
var plan = Plan(manifest, "{n:0000}", extra: ["originals/A.xmp", "originals/B.CR2.xmp", "originals/0001.xmp"]);
// "0001.xmp" belongs to no frame: the first photo, whose companion would take it, gets the next free name.
Assert.SequenceEqual(["originals/A.CR2>originals/0001_2.CR2", "originals/A.xmp>originals/0001_2.xmp",
"originals/B.CR2>originals/0002.CR2", "originals/B.CR2.xmp>originals/0002.CR2.xmp"], plan.Moves.Select(m => $"{m.From}>{m.To}"));
Assert.SequenceEqual([false, true, false, true], plan.Moves.Select(m => m.Companion));
Assert.Equal(2, plan.Frames);
Assert.Count(2, plan.Samples);
}
[Test]
public void TheTrashAndReorganizeFindTheSameCompanionsWhateverTheirCase()
{
var sequence = Folder(out _);
var manifest = Sequence("originals/A.CR2", "originals/B.CR2");
foreach (var file in new[] { "originals/A.CR2", "originals/B.CR2", "originals/a.XMP", "originals/b.cr2.Xmp", "originals/c.xmp" }) Write(sequence, file, file);
var present = FileRenames.ListPresent(sequence, manifest);
var plan = FileRenames.Plan(manifest, null, PathTemplate.Parse("{n:0000}"), present);
Assert.SequenceEqual(["originals/A.CR2>originals/0001.CR2", "originals/a.XMP>originals/0001.XMP", "originals/B.CR2>originals/0002.CR2",
"originals/b.cr2.Xmp>originals/0002.cr2.Xmp"], plan.Moves.Select(m => $"{m.From}>{m.To}"));
var index = new FrameCompanions.Index(sequence);
Assert.SequenceEqual(["originals/a.XMP"], index.Of("originals/A.CR2"));
Assert.SequenceEqual(["originals/b.cr2.Xmp"], index.Of("originals/B.CR2"));
Assert.SequenceEqual(plan.Moves.Where(m => m.Companion).Select(m => m.From), manifest.Frames.SelectMany(f => FrameCompanions.Of(sequence, f.File)));
}
[Test]
public void NamesGivenOnceStayAsTheyAre()
{
var manifest = Sequence("originals/x.JPG", "originals/y.JPG");
var plan = Plan(manifest, "{date}_{n:000}");
var renamed = FileRenameJournal.Applied(manifest, FileRenameJournal.Create(manifest.Versions.Frames, plan.Moves, "t"))!;
Assert.Equal(manifest.Versions.Frames + 1, renamed.Versions.Frames);
Assert.SequenceEqual(manifest.Frames.Select(f => f.Id), renamed.Frames.Select(f => f.Id));
Assert.Empty(Plan(renamed, "{date}_{n:000}").Moves);
Assert.Null(FileRenameJournal.Applied(renamed, FileRenameJournal.Create(manifest.Versions.Frames, plan.Moves, "t")));
}
[Test]
public void APlanWithAFileTemplateCountsSamplesAndListsWhatKeepsItsName()
{
var renamed = Sequence("originals/a.JPG", "originals/b.JPG");
var adopted = Sequence("a.JPG");
var subjects = new[]
{
new RenameSubject(renamed.Id, "s/one", "Trip", Start, "Canon", "Canon EOS R5", null) { Files = new SequenceFiles(renamed, [.. renamed.Frames.Select(f => f.File)]) },
new RenameSubject(adopted.Id, "s/two", "Adopted", Start, "Canon", "Canon EOS R5", null) { Files = new SequenceFiles(adopted, ["a.JPG"]) },
new RenameSubject(Guid.NewGuid(), "s/three", null, Start, "Canon", "Canon EOS R5", null),
};
var plan = RenamePlanner.Plan(Guid.NewGuid(), subjects, null, "{title} 2026", ["s/one", "s/two", "s/three"], _ => false, fileTemplate: "{title}_{n:00}");
Assert.Equal("{title}_{n:00}", plan.FileTemplate);
Assert.SequenceEqual(subjects.Select(s => s.SequenceId), plan.Subjects);
var one = plan.Steps.Single(s => s.SequenceId == renamed.Id);
Assert.Equal((2, 4), (one.FileChanges, one.FramesVersion));
// The new title names the files.
Assert.SequenceEqual(["originals/Trip 2026_01.JPG", "originals/Trip 2026_02.JPG"], one.FileSamples.Select(f => f.To));
var two = plan.Steps.Single(s => s.SequenceId == adopted.Id);
Assert.Equal((0, 0), (two.FileChanges, two.FramesVersion));
Assert.Equal((RenameBlock.InPlace, 1), (two.Blocked.Single().Reason, two.Blocked.Single().Frames));
Assert.True(two.Changes, "its title changes");
var three = plan.Steps.Single(s => s.SequenceId == subjects[2].SequenceId);
Assert.Equal(RenameBlock.Unreadable, three.Blocked.Single().Reason);
// Nothing but kept names: listed, changes nothing.
var keptOnly = RenamePlanner.Plan(Guid.NewGuid(), [subjects[1]], null, null, ["s/two"], _ => false, fileTemplate: "{n}");
Assert.False(keptOnly.Steps.Single().Changes);
}
[Test]
public void FoldersTheTemplateGaveAlreadyStayAndASecondRunPlansNothing()
{
// Two sequences of one day filed by the template, the second beside the first; a third elsewhere, a fourth whose
// folder differs only in case, a fifth with a number filing never gives.
const string Template = "{year}/{date} {title}";
RenameSubject At(string folder) => new(Guid.NewGuid(), folder, "Sunset", Start, null, null, null);
RenameSubject[] subjects = [At("2026/2026-09-28 Sunset"), At("2026/2026-09-28 Sunset (2)"), At("inbox/c"), At("2026/2026-09-28 sunset (4)"),
At("2026/2026-09-28 Sunset (03)")];
var plan = RenamePlanner.Plan(Guid.NewGuid(), subjects, Template, null, subjects.Select(s => s.Folder), _ => false);
Assert.SequenceEqual([(subjects[2].SequenceId, "2026/2026-09-28 Sunset (3)"), (subjects[3].SequenceId, "2026/2026-09-28 Sunset (4)"),
(subjects[4].SequenceId, "2026/2026-09-28 Sunset (5)")], plan.Steps.Select(s => (s.SequenceId, s.ToFolder)));
// Where the plan put them, the same template changes nothing.
var moved = plan.Steps.ToDictionary(s => s.SequenceId, s => s.ToFolder);
RenameSubject[] after = [.. subjects.Select(s => moved.TryGetValue(s.SequenceId, out var to) ? s with { Folder = to } : s)];
var onDisk = after.Select(s => s.Folder).ToHashSet(StringComparer.OrdinalIgnoreCase);
Assert.Empty(RenamePlanner.Plan(Guid.NewGuid(), after, Template, null, onDisk, onDisk.Contains).Steps);
// Nor in another order.
Assert.Empty(RenamePlanner.Plan(Guid.NewGuid(), [.. after.Reverse()], Template, null, onDisk, onDisk.Contains).Steps);
}
[Test]
public void TheFingerprintFollowsWhatThePlanChanges()
{
var manifest = Sequence("originals/a.JPG");
RenamePlan Make(SequenceManifest m) => RenamePlanner.Plan(Guid.NewGuid(), [new RenameSubject(m.Id, "s", "T", Start, null, null, null)
{ Files = new SequenceFiles(m, [.. m.Frames.Select(f => f.File)]) }], null, null, ["s"], _ => false, fileTemplate: "{n:000}");
var plan = Make(manifest);
Assert.Equal(64, plan.Fingerprint().Length);
Assert.Equal(plan.Fingerprint(), Make(manifest).Fingerprint());
// A photo received since under the name the plan gives it raises the frames version only: the plan is the one shown.
var received = manifest with
{
Versions = new ManifestVersions { Frames = 5 },
Frames = [.. manifest.Frames, manifest.Frames[0] with { Id = Guid.NewGuid(), I = 1, File = "originals/002.JPG", CapturedAt = Start.AddSeconds(10) }],
};
Assert.Equal(plan.Fingerprint(), Make(received).Fingerprint());
// One the plan would rename too, or a file renamed otherwise, is another plan.
Assert.NotEqual(plan.Fingerprint(), Make(received with { Frames = [.. received.Frames.SkipLast(1), received.Frames[1] with { File = "originals/b.JPG" }] }).Fingerprint());
Assert.NotEqual(plan.Fingerprint(), Make(manifest with { Frames = [manifest.Frames[0] with { File = "originals/c.JPG" }] }).Fingerprint());
}
[Test]
public void AStepNamedAfterTheTitleSaysSo()
{
var manifest = Sequence("originals/a.JPG");
RenameStep Step(string? folder, string? file) => RenamePlanner.Plan(Guid.NewGuid(), [new RenameSubject(manifest.Id, "s", "Roof", Start, null, null, null)
{ Files = new SequenceFiles(manifest, [.. manifest.Frames.Select(f => f.File)]) }], folder, null, ["s"], _ => false, fileTemplate: file).Steps.Single();
Assert.True(Step("moved/{TITLE}", null) is { MovesFolder: true, NamedByTitle: true, UsesTitle: true, Retitles: false });
Assert.True(Step(null, "{title}_{n:000}") is { FileChanges: 1, NamedByTitle: true, UsesTitle: true });
Assert.True(Step("moved/{date}", "{n:000}") is { MovesFolder: true, FileChanges: 1, NamedByTitle: false, UsesTitle: false });
}
[Test]
public void APlanKeepsItsTemplatesSoTheNamesOfAFirstPhotoNoLongerFirstAreTold()
{
const string Folder = "moved/{date} {title}", Title = "{title} {time}";
var manifest = Sequence("originals/a.JPG", "originals/b.JPG");
// Another sequence holds the folder the template gives: this one takes its " (2)".
var plan = RenamePlanner.Plan(Guid.NewGuid(), [new RenameSubject(manifest.Id, "s", "Roof", Start, null, null, null)
{ Files = new SequenceFiles(manifest, [.. manifest.Frames.Select(f => f.File)]) }], Folder, Title, ["s", "moved/2026-09-28 Roof 18-00-00"], _ => false);
Assert.Equal((Folder, Title, (string?)null), (plan.FolderTemplate, plan.TitleTemplate, plan.FileTemplate));
var step = plan.Steps.Single();
Assert.Equal(("moved/2026-09-28 Roof 18-00-00 (2)", "Roof 18-00-00"), (step.ToFolder, step.ToTitle));
// From the sidecar as it was, the templates give what the plan gives; with its first photo gone, they name it otherwise.
var (title, folder) = RenamePlanner.Names(manifest, "Roof", Folder, Title);
Assert.Equal(("Roof 18-00-00", "moved/2026-09-28 Roof 18-00-00"), (title, folder));
Assert.True(RenamePlanner.Gives(folder!, step.ToFolder));
var (laterTitle, laterFolder) = RenamePlanner.Names(manifest with { Frames = [manifest.Frames[1]] }, "Roof", Folder, Title);
Assert.Equal(("Roof 18-00-10", "moved/2026-09-28 Roof 18-00-10"), (laterTitle, laterFolder));
Assert.False(RenamePlanner.Gives(laterFolder!, step.ToFolder));
// Without templates, the title stays and no folder is given.
Assert.Equal(("Roof", (string?)null), RenamePlanner.Names(manifest, "Roof", null, null));
// Only the folder itself or a number filing gives.
Assert.True(RenamePlanner.Gives("a/b", "a/b"));
Assert.True(RenamePlanner.Gives("a/b", "a/b (12)"));
Assert.False(RenamePlanner.Gives("a/b", "a/b (1)"));
Assert.False(RenamePlanner.Gives("a/b", "a/b (02)"));
Assert.False(RenamePlanner.Gives("a/b", "A/b"));
Assert.False(RenamePlanner.Gives("a/b", "a/b (2) x"));
}
[Test]
public void TemplatesAreCheckedAsTheArchiveSettingsAre()
{
Assert.Null(new RenameTemplates("{year}/{title}", "{date}_{n}", "{title} 2026").Problem());
Assert.Null(new RenameTemplates(File: "{name}.{ext}", Title: "Paris: {title}?").Problem());
Assert.Equal("folderTemplate", new RenameTemplates(Folder: " ").Problem());
Assert.Equal("fileTemplate", new RenameTemplates(File: "{nope}").Problem());
Assert.Equal("fileTemplate", new RenameTemplates(File: "{date:%}").Problem());
Assert.Equal("titleTemplate", new RenameTemplates(Title: "{title").Problem());
// Not valid, blank or written with an unusable format: no rule to name.
Assert.Equal(new TemplateProblem("fileTemplate", null), new RenameTemplates(File: "{date:%}").Check());
Assert.True(new RenameTemplates().IsEmpty);
}
[Theory]
[Case("{n}{ext}", "fileTemplate", "Extension")]
[Case("{date}_{n}_{ext}", "fileTemplate", "Extension")]
[Case("{title}", "fileTemplate", "NotUnique")]
[Case("{date}_{hm}", "fileTemplate", "NotUnique")]
[Case("{year}/{n}", "fileTemplate", "FileSeparator")]
[Case("Originals/{date:yyyy}/{title}", "folderTemplate", "ReservedFolder")]
[Case("{year}/exports", "folderTemplate", "ReservedFolder")]
[Case(".archive/{date}", "folderTemplate", "ReservedFolder")]
[Case("{date:.yyyy}", "folderTemplate", "ReservedFolder")]
public void TemplatesThatWouldLoseOrHidePhotosAreRefused(string template, string field, string rule)
{
var folder = field == "folderTemplate";
var templates = folder ? new RenameTemplates(Folder: template) : new RenameTemplates(File: template);
Assert.Equal(field, templates.Problem());
Assert.Equal(new TemplateProblem(field, rule), templates.Check());
Assert.Equal(rule, folder ? TemplateRules.FolderRule(PathTemplate.Parse(template)) : TemplateRules.FileRule(PathTemplate.Parse(template)));
}
/// <summary>A sidecar of <paramref name="files"/>, each photo's first capture time <paramref name="first"/> (none when null), titled <paramref name="title"/>.</summary>
private static RenameSubject Filed(string folder, string? title, DateTime? first, params string[] files)
{
var manifest = Sequence(files) with { Title = title, Created = new DateTimeOffset(2026, 10, 1, 9, 30, 0, TimeSpan.Zero) };
manifest = manifest with { Frames = [.. manifest.Frames.Select(f => f with { CapturedAt = first?.AddSeconds(10 * f.I) })] };
return new RenameSubject(manifest.Id, folder, title, first, "Canon", "Canon EOS R5", null)
{
Files = new SequenceFiles(manifest, [.. manifest.Frames.Select(f => f.File)]),
};
}
[Theory]
[Case("{year}/{date} {ext}", "2026/2026-09-28 CR2", "2026/2026-09-28 JPG")]
[Case("{date} {name}", "2026-09-28 IMG_0001", "2026-09-28 IMG_0001 (2)")]
[Case("{year}/{date} {camera} {iso}", "2026/2026-09-28 Canon EOS R5", "2026/2026-09-28 Canon EOS R5 (2)")]
public void FoldersFiledFromTheFirstPhotoStayWhereFilingPutThem(string template, string raw, string jpeg)
{
// RAW and JPEG of one day, filed by the template from their first photo ({ext}, {name}… are that photo's).
RenameSubject[] subjects =
[
Filed(raw, null, Start, "originals/2026-09-28_0001.CR2", "originals/2026-09-28_0002.CR2"),
Filed(jpeg, null, Start, "originals/2026-09-28_0001.JPG", "originals/2026-09-28_0002.JPG"),
];
var folders = subjects.Select(s => s.Folder).ToHashSet(StringComparer.OrdinalIgnoreCase);
Assert.Empty(RenamePlanner.Plan(Guid.NewGuid(), subjects, template, null, folders, folders.Contains).Steps);
// The context filing saw: the folder each first frame gives.
var context = FrameNaming.Context(subjects[0].Files!.Manifest.Frames[0], subjects[0].Files!.Manifest, null);
Assert.Equal(raw.Replace(" (2)", string.Empty, StringComparison.Ordinal), PathTemplate.Parse(template).ExpandFolder(context));
}
[Test]
public void ASequenceWithoutACaptureTimeNeverTakesTodaysDate()
{
// No time in the sidecar: the day the sequence was made, as its files are named; no sidecar and no time: no move.
var timeless = Filed("inbox/a", null, null, "originals/a.JPG");
var plan = RenamePlanner.Plan(Guid.NewGuid(), [timeless], "{date}", null, ["inbox/a"], _ => false);
Assert.Equal("2026-10-01", plan.Steps.Single().ToFolder);
var row = new RenameSubject(Guid.NewGuid(), "inbox/b", "B", null, null, null, null);
Assert.Empty(RenamePlanner.Plan(Guid.NewGuid(), [row], "{date}", "{title} {date}", ["inbox/b"], _ => false).Steps);
}
[Test]
public void ASequenceWhoseSidecarCannotBeReadStaysAsItIsAndSoDoesTheFolderAroundIt()
{
var a = Filed("a", "A", Start, "originals/a.JPG");
// Unreadable, titled as D: had it been planned, D would get " (2)".
var unreadable = new RenameSubject(Guid.NewGuid(), "u", "D", Start, null, null, null) { Unreadable = true };
var carrier = Filed("c", "C", Start, "originals/c.JPG");
var inner = new RenameSubject(Guid.NewGuid(), "c/n", "N", Start, null, null, null) { Unreadable = true };
var d = Filed("d", "D", Start, "originals/d.JPG");
var plan = RenamePlanner.Plan(Guid.NewGuid(), [a, unreadable, carrier, d], "moved/{title}", "{title} 2026", ["a", "u", "c", "c/n", "d"], _ => false,
[inner]);
var steps = plan.Steps.ToDictionary(s => s.SequenceId);
Assert.Equal(("moved/A 2026", "A 2026"), (steps[a.SequenceId].ToFolder, steps[a.SequenceId].ToTitle));
Assert.Equal(("moved/D 2026", "D 2026"), (steps[d.SequenceId].ToFolder, steps[d.SequenceId].ToTitle));
foreach (var kept in new[] { unreadable, inner })
{
var step = steps[kept.SequenceId];
Assert.Equal((kept.Folder, kept.Title), (step.ToFolder, step.ToTitle));
Assert.False(step.Changes);
Assert.Equal(RenameBlock.Unreadable, step.Blocked.Single().Reason);
}
// Its own sidecar reads: the title changes, the folder cannot take the sequence inside along.
Assert.Equal(("c", "C 2026"), (steps[carrier.SequenceId].ToFolder, steps[carrier.SequenceId].ToTitle));
Assert.False(steps[inner.SequenceId].Carried);
// With a file template, a sequence without its sidecar's files stays too.
var noFiles = new RenameSubject(Guid.NewGuid(), "x", "X", Start, null, null, null);
var files = RenamePlanner.Plan(Guid.NewGuid(), [noFiles], "moved/{title}", null, ["x"], _ => false, fileTemplate: "{n}");
Assert.Equal(("x", false), (files.Steps.Single().ToFolder, files.Steps.Single().Changes));
}
[Test]
public void AFolderATitleWouldHideFromScansIsEscapedAndFound()
{
var archive = new ArchivePaths(context.CreateTempDirectory("archive"));
var originals = archive.FromRelative("inbox/a/originals");
Directory.CreateDirectory(originals);
File.WriteAllBytes(Path.Combine(originals, "IMG_0001.JPG"), TestPhotos.Jpeg(Start, 1));
var subject = new RenameSubject(Guid.NewGuid(), "inbox/a", "Exports", Start, null, null, null);
var step = RenamePlanner.Plan(Guid.NewGuid(), [subject], "{year}/{title}", null, ["inbox/a"], _ => false).Steps.Single();
Assert.Equal("2026/_Exports", step.ToFolder);
RenamePlanner.MoveFolder(archive, step);
Assert.SequenceEqual(["2026/_Exports"], ArchiveScanner.FindSequenceFolders(archive).Select(f => f.RelativeFolder));
}
[Test]
public void TitlesKeepWhatAFileNameCannotHold()
{
var paris = new RenameSubject(Guid.NewGuid(), "s/paris", "Paris: night", Start, null, null, null);
var plan = RenamePlanner.Plan(Guid.NewGuid(), [paris], "{title}", "{title} 2026", ["s/paris"], _ => false);
// The title is text; the folder it names is a file name.
Assert.Equal(("Paris: night 2026", "Paris_ night 2026"), (plan.Steps.Single().ToTitle, plan.Steps.Single().ToFolder));
Assert.Empty(RenamePlanner.Plan(Guid.NewGuid(), [paris with { Folder = "Paris_ night" }], "{title}", "{title}", ["Paris_ night"], _ => false).Steps);
}
[Test]
public void TwoFoldersThatDifferOnlyInCaseAreNeverGivenOneFolder()
{
// A case-sensitive server: "trip (2)" and "TRIP (2)" are two folders, both of which "Trip (2)" would keep.
RenameSubject At(string folder) => new(Guid.NewGuid(), folder, "Trip", Start, null, null, null);
RenameSubject[] subjects = [At("trip (2)"), At("TRIP (2)")];
var onDisk = new HashSet<string>(["trip (2)", "TRIP (2)"], StringComparer.Ordinal);
var plan = RenamePlanner.Plan(Guid.NewGuid(), subjects, "{title}", null, onDisk, onDisk.Contains);
var targets = plan.Steps.Select(s => s.ToFolder).ToList();
Assert.SequenceEqual(["Trip (2)", "Trip"], targets);
// Where they went, the same template changes nothing.
RenameSubject[] after = [.. subjects.Zip(targets, (s, t) => s with { Folder = t })];
var moved = new HashSet<string>(targets, StringComparer.Ordinal);
Assert.Empty(RenamePlanner.Plan(Guid.NewGuid(), after, "{title}", null, moved, moved.Contains).Steps);
}
[Test]
public void ACaseOnlyMoveOntoAnotherFolderIsRefused()
{
var archive = new ArchivePaths(context.CreateTempDirectory("archive"));
Directory.CreateDirectory(archive.FromRelative("trip (2)"));
File.WriteAllText(Path.Combine(archive.FromRelative("trip (2)"), "a.txt"), "a");
var step = new RenameStep(Guid.NewGuid(), "trip (2)", "Trip (2)", "Trip", "Trip");
if (Directory.Exists(archive.FromRelative("TRIP (2)")))
{
// Case-insensitive: the folder takes the new case, and the step repeated finds it done.
RenamePlanner.MoveFolder(archive, step);
RenamePlanner.MoveFolder(archive, step);
Assert.SequenceEqual(["Trip (2)"], Directory.EnumerateDirectories(archive.Root).Select(Path.GetFileName));
Assert.Equal("a", File.ReadAllText(Path.Combine(archive.FromRelative("Trip (2)"), "a.txt")));
}
else
{
// Case-sensitive: another folder holds the new name exactly; neither moves.
Directory.CreateDirectory(archive.FromRelative("Trip (2)"));
Assert.Throws<IOException>(() => RenamePlanner.MoveFolder(archive, step));
Assert.Equal("a", File.ReadAllText(Path.Combine(archive.FromRelative("trip (2)"), "a.txt")));
Assert.Empty(Directory.EnumerateFileSystemEntries(archive.FromRelative("Trip (2)")));
}
}
[Test]
public void AChangeOfCaseIsNeverPlannedOntoAnotherFolderOfThatExactName()
{
// A case-sensitive server: "Trip (2)" is a folder of its own beside the sequence at "trip (2)", and no sequence's.
var subject = new RenameSubject(Guid.NewGuid(), "trip (2)", "Trip", Start, null, null, null);
var onDisk = new HashSet<string>(["trip (2)", "Trip (2)"], StringComparer.Ordinal);
var plan = RenamePlanner.Plan(Guid.NewGuid(), [subject], "{title}", null, ["trip (2)"], onDisk.Contains, existsExactly: onDisk.Contains);
Assert.Equal("Trip", plan.Steps.Single().ToFolder);
// Case-insensitive, the only folder of that name is its own: it keeps its number, in the template's case.
var own = RenamePlanner.Plan(Guid.NewGuid(), [subject], "{title}", null, ["trip (2)"], f => f.Equals("trip (2)", StringComparison.OrdinalIgnoreCase),
existsExactly: f => f == "trip (2)");
Assert.Equal("Trip (2)", own.Steps.Single().ToFolder);
}
[Test]
public void AFolderExistsExactlyOnlyInTheCaseOfEveryLevel()
{
var archive = new ArchivePaths(context.CreateTempDirectory("archive"));
Directory.CreateDirectory(archive.FromRelative("trip/day"));
File.WriteAllText(Path.Combine(archive.FromRelative("trip/day"), "a.txt"), "a");
Assert.True(RenamePlanner.ExistsExactly(archive, "trip/day"));
Assert.False(RenamePlanner.ExistsExactly(archive, "Trip/day"));
Assert.False(RenamePlanner.ExistsExactly(archive, "trip/Day"));
Assert.False(RenamePlanner.ExistsExactly(archive, "trip/night"));
// An outer level's case alone: the folder moves on any file system (a case-insensitive one keeps the outer name as it was).
var step = new RenameStep(Guid.NewGuid(), "trip/day", "Trip/day", "T", "T");
RenamePlanner.MoveFolder(archive, step);
RenamePlanner.MoveFolder(archive, step);
Assert.Equal("a", File.ReadAllText(Path.Combine(archive.FromRelative("Trip/day"), "a.txt")));
}
[Test]
public void AFolderTheDiskSpellsAsTheTemplateDoesIsTheSequencesOwn()
{
// A case-insensitive file system: the index has "trip (2)" and "Trip/day", the disk spells them "Trip (2)" (renamed in
// Explorer since the last scan) and "trip/day" (an outer level a change of case left as it was). The folders found
// under the template's exact names are the sequences' own: a change of case is all the plan makes, never " (n)".
var disk = new HashSet<string>(["Trip", "Trip (2)", "trip", "trip/day"], StringComparer.Ordinal);
bool OnDisk(string f) => disk.Contains(f, StringComparer.OrdinalIgnoreCase);
var renamed = new RenameSubject(Guid.NewGuid(), "trip (2)", "Trip", Start, null, null, null);
var plan = RenamePlanner.Plan(Guid.NewGuid(), [renamed], "{title}", null, ["trip (2)", "Trip"], OnDisk, existsExactly: disk.Contains);
Assert.Equal("Trip (2)", plan.Steps.Single().ToFolder);
var outer = new RenameSubject(Guid.NewGuid(), "Trip/day", "day", Start, null, null, null);
plan = RenamePlanner.Plan(Guid.NewGuid(), [outer], "trip/day", null, ["Trip/day"], OnDisk, existsExactly: disk.Contains);
Assert.Equal("trip/day", plan.Steps.Single().ToFolder);
}
[Test]
public void ACaseOnlyTargetOnDiskIsRefusedOnlyBesideTheSequencesOwnFolder()
{
var archive = new ArchivePaths(context.CreateTempDirectory("archive"));
foreach (var folder in (string[])["Trip", "Trip (2)", "walk/day"])
{
Directory.CreateDirectory(archive.FromRelative(folder));
File.WriteAllText(Path.Combine(archive.FromRelative(folder), "a.txt"), folder);
}
// The index has "trip (2)" and "Walk/day": on a case-sensitive file system those are folders of their own beside the
// ones the template names.
var caseSensitive = !Directory.Exists(archive.FromRelative("trip (2)"));
if (caseSensitive)
{
Directory.CreateDirectory(archive.FromRelative("trip (2)"));
Directory.CreateDirectory(archive.FromRelative("Walk/day"));
}
bool OnDisk(string f) => Directory.Exists(archive.FromRelative(f));
bool Exactly(string f) => RenamePlanner.ExistsExactly(archive, f);
var renamed = new RenameSubject(Guid.NewGuid(), "trip (2)", "Trip", Start, null, null, null);
var outer = new RenameSubject(Guid.NewGuid(), "Walk/day", "day", Start, null, null, null);
var first = RenamePlanner.Plan(Guid.NewGuid(), [renamed], "{title}", null, ["trip (2)", "Trip", "Walk/day"], OnDisk, existsExactly: Exactly).Steps.Single();
var second = RenamePlanner.Plan(Guid.NewGuid(), [outer], "walk/day", null, ["trip (2)", "Trip", "Walk/day"], OnDisk, existsExactly: Exactly).Steps.Single();
if (caseSensitive)
{
Assert.Equal(("Trip (3)", "walk/day (2)"), (first.ToFolder, second.ToFolder));
return;
}
// Case-insensitive: each sequence keeps its own folder, which is already as the template spells it, so applying the
// steps (twice, as a resumed plan does) moves nothing and loses nothing.
Assert.Equal(("Trip (2)", "walk/day"), (first.ToFolder, second.ToFolder));
foreach (var step in (RenameStep[])[first, second, first, second]) RenamePlanner.MoveFolder(archive, step);
Assert.SequenceEqual(["Trip", "Trip (2)", "walk"], Directory.EnumerateDirectories(archive.Root).Select(Path.GetFileName).Order(StringComparer.Ordinal));
Assert.Equal("Trip (2)", File.ReadAllText(Path.Combine(archive.FromRelative("Trip (2)"), "a.txt")));
Assert.Equal("walk/day", File.ReadAllText(Path.Combine(archive.FromRelative("walk/day"), "a.txt")));
}
[Test]
public void PhotosOfALongTitleKeepTheirExtension()
{
// As long as a title goes, less the room the number and the extension take: the name gives way before ".{ext}".
var manifest = Sequence("originals/a.JPG", "originals/b.JPG", "originals/c.JPG");
var title = new string('t', 186) + " harbour";
const string Template = "{title}_{n:0000}.{ext}";
var plan = Plan(manifest, Template, title);
Assert.Equal(3, plan.Frames);
foreach (var move in plan.Moves)
{
Assert.True(move.To.EndsWith(".JPG", StringComparison.Ordinal), move.To);
Assert.True(Path.GetFileName(move.To).Length <= PathTemplate.MaxSegmentLength + 2, move.To);
}
Assert.Equal(3, plan.Moves.Select(m => m.To).Distinct(StringComparer.OrdinalIgnoreCase).Count());
// Renamed so, the template names them again as they are.
var renamed = FileRenameJournal.Applied(manifest, FileRenameJournal.Create(manifest.Versions.Frames, plan.Moves, "t"))!;
Assert.Empty(Plan(renamed, Template, title).Moves);
}
[Test]
public void ExtensionsAPhotoLostComeBackFromItsName()
{
var manifest = Sequence("originals/0001CR3", "originals/0002.CR3");
manifest = manifest with { Frames = [.. manifest.Frames.Select(f => f with { Original = $"IMG_{f.I + 1:0000}.CR3" })] };
Assert.Equal("CR3", FrameNaming.Context(manifest.Frames[0], manifest, null).Extension);
Assert.SequenceEqual(["originals/0001CR3>originals/0001.CR3"], Plan(manifest, "{n:0000}").Moves.Select(m => $"{m.From}>{m.To}"));
// A file that has an extension of a photo keeps that one, whatever the card's name said.
Assert.Equal("CR3", FrameNaming.Context(manifest.Frames[1] with { Original = "IMG_0002.JPG" }, manifest, null).Extension);
}
[Test]
public void ManyPhotosOfOneNameAreNamedInLinearTimeAsTheSearchFromTwoNamesThem()
{
// Against the search from _2 it replaces, with names taken by stray files and companions in the way.
var taken = new HashSet<string>(["a/x.JPG", "a/x_3.JPG", "a/x_4.xmp"], StringComparer.OrdinalIgnoreCase);
var reference = new HashSet<string>(taken, StringComparer.OrdinalIgnoreCase);
var names = new UniqueNames(taken);
for (var i = 0; i < 12; i++)
{
// Every third photo has an XMP companion: "x_4" is free for the others, not for it.
Func<string, bool> companion = i % 3 == 1 ? c => !reference.Contains(Path.ChangeExtension(c, ".xmp")) : _ => true;
var expected = "a/x.JPG";
for (var n = 2; reference.Contains(expected) || !companion(expected); n++) expected = FrameNaming.Numbered("a/x.JPG", n);
reference.Add(expected);
Assert.Equal(expected, names.Claim("a/x.JPG", companion), $"photo {i}");
}
var frames = Enumerable.Range(0, 20_000).Select(i => $"originals/{i:00000}.JPG").ToArray();
var manifest = Sequence(frames);
var clock = System.Diagnostics.Stopwatch.StartNew();
var plan = Plan(manifest, "{title}", title: "Sunset");
Assert.True(clock.Elapsed.TotalSeconds < TestTiming.Budget(5), $"{clock.Elapsed.TotalSeconds:0.0} s");
Assert.SequenceEqual(["originals/Sunset.JPG", "originals/Sunset_2.JPG", "originals/Sunset_3.JPG"], plan.Samples.Select(s => s.To));
Assert.Equal("originals/Sunset_20000.JPG", plan.Moves[^1].To);
}
private SequencePaths Folder(out ArchivePaths archive)
{
archive = new ArchivePaths(context.CreateTempDirectory("archive"));
var sequence = archive.Sequence("s");
Directory.CreateDirectory(sequence.Originals);
Directory.CreateDirectory(sequence.MetaDirectory);
return sequence;
}
private static void Write(SequencePaths sequence, string file, string text) => File.WriteAllText(sequence.File(file), text, Encoding.UTF8);
private static string Read(SequencePaths sequence, string file) => File.ReadAllText(sequence.File(file), Encoding.UTF8);
[Test]
public void FilesMoveInTwoPhasesSoChainsAndSwapsNeverMeet()
{
var sequence = Folder(out _);
Write(sequence, "originals/a.jpg", "A");
Write(sequence, "originals/b.jpg", "B");
Write(sequence, "originals/c.jpg", "C");
Guid x = Guid.NewGuid(), y = Guid.NewGuid(), z = Guid.NewGuid();
// A swap (a↔b) and a chain into a name that frees up (c→a's place is taken by b, so c→d).
var journal = FileRenameJournal.Create(7, [new FileRename(x, "originals/a.jpg", "originals/b.jpg"), new FileRename(y, "originals/b.jpg", "originals/a.jpg"),
new FileRename(z, "originals/c.jpg", "originals/d.jpg")], "t1");
FileRenameJournal.Write(sequence, journal);
var done = FileRenameJournal.Run(sequence, journal);
Assert.Equal(2, done.Phase);
Assert.Equal(("A", "B", "C"), (Read(sequence, "originals/b.jpg"), Read(sequence, "originals/a.jpg"), Read(sequence, "originals/d.jpg")));
Assert.FileMissing(sequence.File("originals/c.jpg"));
Assert.True(journal.Files.All(f => !File.Exists(sequence.File(f.Temp))));
Assert.True(journal.Files.All(f => Path.GetFileName(f.Temp).StartsWith(".chronos-rename-t1-", StringComparison.Ordinal)), "hidden, never a photo");
}
[Test]
public void AFailedMovePutsEveryFileBackAndChangesNothing()
{
var sequence = Folder(out _);
Write(sequence, "originals/a.jpg", "A");
Write(sequence, "originals/b.jpg", "B");
var journal = FileRenameJournal.Create(1, [new FileRename(Guid.NewGuid(), "originals/a.jpg", "originals/x.jpg"),
new FileRename(Guid.NewGuid(), "originals/b.jpg", "originals/y.jpg")], "t2");
FileRenameJournal.Write(sequence, journal);
// Another file took the second name after the plan: nothing is written over it, and the first file goes back.
Write(sequence, "originals/y.jpg", "other");
Assert.Throws<IOException>(() => FileRenameJournal.Run(sequence, journal));
Assert.Equal(("A", "B", "other"), (Read(sequence, "originals/a.jpg"), Read(sequence, "originals/b.jpg"), Read(sequence, "originals/y.jpg")));
Assert.FileMissing(sequence.File("originals/x.jpg"));
Assert.Null(FileRenameJournal.Read(sequence));
}
[Theory]
[Case(1)]
[Case(2)]
public void ARenameACrashInterruptedIsCompleted(int phase)
{
var sequence = Folder(out _);
var manifest = Sequence("originals/2.jpg", "originals/3.jpg", "originals/4.jpg");
foreach (var f in manifest.Frames) Write(sequence, f.File, f.Id.ToString());
var plan = Plan(manifest, "{n:0}");
var journal = FileRenameJournal.Create(manifest.Versions.Frames, plan.Moves, "t3") with { Phase = phase };
FileRenameJournal.Write(sequence, journal);
// Phase 1: the first file reached its temporary name. Phase 2: every file did, and the first its new name.
File.Move(sequence.File(journal.Files[0].From), sequence.File(journal.Files[0].Temp));
if (phase == 2)
{
foreach (var f in journal.Files.Skip(1)) File.Move(sequence.File(f.From), sequence.File(f.Temp));
File.Move(sequence.File(journal.Files[0].Temp), sequence.File(journal.Files[0].To));
}
var recovered = Assert.NotNull(FileRenameJournal.Recover(sequence, manifest));
Assert.SequenceEqual(["originals/1.jpg", "originals/2.jpg", "originals/3.jpg"], recovered.Frames.Select(f => f.File));
Assert.Equal(manifest.Versions.Frames + 1, recovered.Versions.Frames);
foreach (var f in recovered.Frames) Assert.Equal(f.Id.ToString(), Read(sequence, f.File));
Assert.FileMissing(sequence.File("originals/4.jpg"));
Assert.True(journal.Files.All(f => !File.Exists(sequence.File(f.Temp))));
}
/// <summary>
/// A rename of <paramref name="shape"/> (a chain of names that free up, a swap, a cycle of three) a crash interrupted
/// in its first phase, once its first file reached its temporary name; each file holds its frame's id.
/// </summary>
private static (SequenceManifest Manifest, FileRenameJournal Journal) Interrupted(SequencePaths sequence, string shape)
{
string[][] names = shape switch
{
"chain" => [["originals/2.jpg", "originals/3.jpg", "originals/4.jpg"], ["originals/1.jpg", "originals/2.jpg", "originals/3.jpg"]],
"swap" => [["originals/a.jpg", "originals/b.jpg"], ["originals/b.jpg", "originals/a.jpg"]],
_ => [["originals/a.jpg", "originals/b.jpg", "originals/c.jpg"], ["originals/b.jpg", "originals/c.jpg", "originals/a.jpg"]],
};
var (from, to) = (names[0], names[1]);
var manifest = Sequence(from);
foreach (var f in manifest.Frames) Write(sequence, f.File, f.Id.ToString());
var journal = FileRenameJournal.Create(manifest.Versions.Frames, [.. manifest.Frames.Select((f, i) => new FileRename(f.Id, f.File, to[i]))], "t4");
FileRenameJournal.Write(sequence, journal);
File.Move(sequence.File(journal.Files[0].From), sequence.File(journal.Files[0].Temp));
return (manifest, journal);
}
private static void AssertEveryFrameHoldsItsPhoto(SequencePaths sequence, SequenceManifest recovered)
{
foreach (var f in recovered.Frames) Assert.Equal(f.Id.ToString(), Read(sequence, f.File));
Assert.Empty(Directory.EnumerateFiles(sequence.Originals, ".chronos-rename-*"));
}
[Theory]
[Case("chain")]
[Case("swap")]
[Case("cycle")]
public void ARecoveryRunAgainLeavesEveryFileWithItsFrame(string shape)
{
var sequence = Folder(out _);
var (manifest, _) = Interrupted(sequence, shape);
// Completed, but the sidecar that follows was never written (a full disk, a crash before it): the journal is found again.
var first = Assert.NotNull(FileRenameJournal.Recover(sequence, manifest));
Assert.Equal(2, Assert.NotNull(FileRenameJournal.Read(sequence)).Phase);
var again = Assert.NotNull(FileRenameJournal.Recover(sequence, manifest));
Assert.SequenceEqual(first.Frames.Select(f => f.File), again.Frames.Select(f => f.File));
Assert.False(manifest.Frames.Select(f => f.File).SequenceEqual(again.Frames.Select(f => f.File)), "every frame has its new name");
AssertEveryFrameHoldsItsPhoto(sequence, again);
}
[Test]
[WindowsOnly]
public void ARecoveryCutShortWhileFilesTakeTheirNewNamesGoesOnFromThere()
{
var sequence = Folder(out _);
var (manifest, journal) = Interrupted(sequence, "chain");
// The last file reached its temporary name too, and another program holds it: the recovery stops at it.
File.Move(sequence.File(journal.Files[2].From), sequence.File(journal.Files[2].Temp));
using (new FileStream(sequence.File(journal.Files[2].Temp), FileMode.Open, FileAccess.Read, FileShare.None))
Assert.Throws<IOException>(() => FileRenameJournal.Recover(sequence, manifest));
Assert.Equal("originals/1.jpg", journal.Files[0].To);
Assert.Equal(manifest.Frames[0].Id.ToString(), Read(sequence, "originals/1.jpg"));
// Run again, it goes on from there: no file that took its new name moves again.
var recovered = Assert.NotNull(FileRenameJournal.Recover(sequence, manifest));
Assert.SequenceEqual(["originals/1.jpg", "originals/2.jpg", "originals/3.jpg"], recovered.Frames.Select(f => f.File));
AssertEveryFrameHoldsItsPhoto(sequence, recovered);
}
[Test]
public void ANewNameTakenMeanwhileNeverStrandsAPhoto()
{
var sequence = Folder(out _);
var (manifest, journal) = Interrupted(sequence, "chain");
// Copied in under the name the second file gets after the crash: never written over. Its own old name is the third
// file's new one, so it takes the first free number of that name.
Write(sequence, "originals/2.jpg", "other");
FileRenameJournal.Delete(sequence);
Assert.NotNull(FileRenameJournal.Read(sequence));
var recovered = Assert.NotNull(FileRenameJournal.Recover(sequence, manifest));
Assert.SequenceEqual(["originals/1.jpg", "originals/3_2.jpg", "originals/3.jpg"], recovered.Frames.Select(f => f.File));
Assert.Equal("other", Read(sequence, "originals/2.jpg"));
AssertEveryFrameHoldsItsPhoto(sequence, recovered);
// The new name is in the journal, so a recovery run again finds every file where it is.
Assert.Equal("originals/3_2.jpg", Assert.NotNull(FileRenameJournal.Read(sequence)).Files[1].To);
Assert.SequenceEqual(recovered.Frames.Select(f => f.File), Assert.NotNull(FileRenameJournal.Recover(sequence, manifest)).Frames.Select(f => f.File));
AssertEveryFrameHoldsItsPhoto(sequence, recovered);
Assert.Equal(journal.Files.Count, Directory.EnumerateFiles(sequence.Originals).Count() - 1);
}
[Test]
public void APhotoWhoseCompanionsNewNameIsTakenStaysWithItsCompanion()
{
var sequence = Folder(out _);
var manifest = Sequence("originals/A.CR2");
Write(sequence, "originals/A.CR2", "photo");
Write(sequence, "originals/A.xmp", "sidecar");
var id = manifest.Frames[0].Id;
FileRename[] moves = [new(id, "originals/A.CR2", "originals/0001.CR2"), new(id, "originals/A.xmp", "originals/0001.xmp", Companion: true)];
var journal = FileRenameJournal.Create(manifest.Versions.Frames, moves, "t5") with { Phase = 2 };
FileRenameJournal.Write(sequence, journal);
foreach (var f in journal.Files) File.Move(sequence.File(f.From), sequence.File(f.Temp));
Write(sequence, "originals/0001.xmp", "other");
// Both go back to their names, together; the frame keeps its file.
Assert.Null(FileRenameJournal.Recover(sequence, manifest));
Assert.Equal(("photo", "sidecar", "other"), (Read(sequence, "originals/A.CR2"), Read(sequence, "originals/A.xmp"), Read(sequence, "originals/0001.xmp")));
Assert.FileMissing(sequence.File("originals/0001.CR2"));
Assert.Empty(Directory.EnumerateFiles(sequence.Originals, ".chronos-rename-*"));
}
[Test]
public void APhotoThatTookItsNewNameGoesBackWithACompanionWhoseNewNameIsTaken()
{
var sequence = Folder(out _);
var manifest = Sequence("originals/A.CR2");
Write(sequence, "originals/A.CR2", "photo");
Write(sequence, "originals/A.xmp", "sidecar");
var id = manifest.Frames[0].Id;
FileRename[] moves = [new(id, "originals/A.CR2", "originals/0001.CR2"), new(id, "originals/A.xmp", "originals/0001.xmp", Companion: true)];
var journal = FileRenameJournal.Create(manifest.Versions.Frames, moves, "t6") with { Phase = 2 };
FileRenameJournal.Write(sequence, journal);
foreach (var f in journal.Files) File.Move(sequence.File(f.From), sequence.File(f.Temp));
// Stopped once the photo took its new name, before its companion did; then something took the companion's, and the
// photo's old name too.
File.Move(sequence.File(journal.Files[0].Temp), sequence.File(journal.Files[0].To));
Write(sequence, "originals/0001.xmp", "other");
Write(sequence, "originals/A.CR2", "another");
// The photo goes back with its companion, both to the first free number of its old name; the frame names the photo.
var recovered = Assert.NotNull(FileRenameJournal.Recover(sequence, manifest));
Assert.Equal("originals/A_2.CR2", recovered.Frames.Single().File);
Assert.Equal(("photo", "sidecar"), (Read(sequence, "originals/A_2.CR2"), Read(sequence, "originals/A_2.xmp")));
Assert.Equal(("other", "another"), (Read(sequence, "originals/0001.xmp"), Read(sequence, "originals/A.CR2")));
Assert.FileMissing(sequence.File("originals/0001.CR2"));
Assert.Empty(Directory.EnumerateFiles(sequence.Originals, ".chronos-rename-*"));
// Run again, every file stays where it is.
Assert.Equal("originals/A_2.CR2", Assert.NotNull(FileRenameJournal.Recover(sequence, manifest)).Frames.Single().File);
Assert.Equal(("photo", "sidecar"), (Read(sequence, "originals/A_2.CR2"), Read(sequence, "originals/A_2.xmp")));
}
[Test]
public void ADamagedPlanJournalIsSkippedAtOpenAndFailsItsOwnJob()
{
var archive = new ArchivePaths(context.CreateTempDirectory("archive"));
var good = new RenameJournal(new RenamePlan(Guid.NewGuid(), Guid.NewGuid(), []), []);
RenameJournal.Write(archive, good);
var damaged = Guid.NewGuid();
File.WriteAllText(RenameJournal.PathFor(archive, damaged), "{ \"plan\": ");
var empty = Guid.NewGuid();
File.WriteAllText(RenameJournal.PathFor(archive, empty), "{}");
// The archive still opens: the readable journal resumes, the others stay where they are.
Assert.Equal(good.Plan.Id, RenameJournal.ListPending(archive).Single().Plan.Id);
Assert.True(File.Exists(RenameJournal.PathFor(archive, damaged)));
// The job of a damaged plan fails with the reason instead of planning again.
Assert.Throws<InvalidDataException>(() => RenameJournal.Read(archive, damaged));
Assert.Throws<InvalidDataException>(() => RenameJournal.Read(archive, empty));
Assert.Null(RenameJournal.Read(archive, Guid.NewGuid()));
}
}