An archive open lists the pending rename plans; one journal that was not valid JSON threw out of ArchiveService.OpenAsync, so the archive (and the server, at boot) did not open until the file was removed by hand. It is now logged and left in place; its own job fails with the reason instead of planning again over a half-applied plan. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
775 lines
48 KiB
C#
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()));
|
|
}
|
|
}
|