Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Mzbb6zeFTjT6Rp8b92AVkA
124 lines
6.8 KiB
C#
124 lines
6.8 KiB
C#
using Febe.Core.Domain;
|
|
using Febe.Core.Library;
|
|
using Febe.Tests.Support;
|
|
|
|
namespace Febe.Tests.Library;
|
|
|
|
/// <summary>
|
|
/// The review of probable duplicates found after a download (spec §9.5): nothing is decided in advance, both files stay
|
|
/// until Alberto chooses, and only his choice removes a file (rule 12) — the whole entry when it had one file (remembered,
|
|
/// so it is not downloaded again), only that position for a series.
|
|
/// </summary>
|
|
[TestClass]
|
|
public sealed class DownloadDuplicateReviewTests
|
|
{
|
|
private static readonly int[] Scenes = [100, 237, 391];
|
|
|
|
private static async Task<(TestLibrary Lib, Account Account, EntryWithMedia Older, EntryWithMedia Newer)> TwoSimilarAsync(TempFolder temp, bool newerIsSeries = false)
|
|
{
|
|
var lib = await TestLibrary.CreateAsync(temp);
|
|
var account = await lib.Db.Accounts.AddAsync(Make.Account("doppie.prova"));
|
|
var older = await lib.SaveAsync(account, Make.Entry(account.Id, "100", Make.T0 - TimeSpan.FromDays(3)), [TestFile.Photo(1, 41, 1080, 1350)]);
|
|
IReadOnlyList<TestFile> files = newerIsSeries
|
|
? [TestFile.Photo(1, 41, 720, 900), TestFile.Photo(2, 77, 1080, 1080)]
|
|
: [TestFile.Photo(1, 41, 720, 900)];
|
|
var newer = await lib.SaveAsync(account, Make.Entry(account.Id, "200", Make.T0), files);
|
|
return (lib, account, older, newer);
|
|
}
|
|
|
|
private static DownloadDuplicateReview Review(TestLibrary lib) => new(lib.Db, lib.Layout, lib.Journal, lib.Clock, lib.Thumbnails, lib.Index);
|
|
|
|
[TestMethod]
|
|
public async Task ThePairWaitsWithNothingDecidedAndBothFilesStay()
|
|
{
|
|
using var temp = new TempFolder("doppioni");
|
|
var (lib, account, older, newer) = await TwoSimilarAsync(temp);
|
|
await using var _ = lib;
|
|
var review = Review(lib);
|
|
Assert.AreEqual(1, await review.CountPendingAsync());
|
|
var cases = await review.ListAsync();
|
|
Assert.HasCount(1, cases);
|
|
var c = cases[0];
|
|
Assert.AreEqual(DuplicateDecision.Pending, c.Pair.Decision);
|
|
Assert.AreEqual(older.Media[0].Id, c.Existing.MediaId);
|
|
Assert.AreEqual(newer.Media[0].Id, c.Candidate.MediaId);
|
|
Assert.IsFalse(c.CandidateIsLarger, "the file already there has more pixels");
|
|
Assert.AreEqual("doppie.prova", c.Existing.Username);
|
|
Assert.IsTrue(File.Exists(lib.Layout.FullPath(account, older.Media[0].RelativePath!)));
|
|
Assert.IsTrue(File.Exists(lib.Layout.FullPath(account, newer.Media[0].RelativePath!)));
|
|
|
|
var result = await review.DecideAsync(c.Pair.Id, DuplicateDecision.KeepBoth);
|
|
Assert.AreEqual(1, result.Decided);
|
|
Assert.AreEqual(0, result.FilesRemoved);
|
|
Assert.AreEqual(0, await review.CountPendingAsync());
|
|
Assert.IsTrue(File.Exists(lib.Layout.FullPath(account, newer.Media[0].RelativePath!)), "«Tienili entrambi» removes nothing");
|
|
await Assert.ThrowsExactlyAsync<KeyNotFoundException>(() => review.DecideAsync(9999, DuplicateDecision.KeepBoth));
|
|
await Assert.ThrowsExactlyAsync<ArgumentException>(() => review.DecideAsync(c.Pair.Id, DuplicateDecision.Pending));
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task KeepTheLargerRemovesTheSmallerEntryAndRemembersIt()
|
|
{
|
|
using var temp = new TempFolder("doppioni");
|
|
var (lib, account, older, newer) = await TwoSimilarAsync(temp);
|
|
await using var _ = lib;
|
|
var review = Review(lib);
|
|
var c = (await review.ListAsync())[0];
|
|
var result = await review.DecideAsync(c.Pair.Id, DuplicateDecision.KeepLarger);
|
|
Assert.AreEqual(1, result.FilesRemoved);
|
|
Assert.IsEmpty(result.Problems);
|
|
Assert.IsTrue(File.Exists(lib.Layout.FullPath(account, older.Media[0].RelativePath!)), "the larger stays");
|
|
Assert.IsFalse(File.Exists(lib.Layout.FullPath(account, newer.Media[0].RelativePath!)), "the smaller goes, by Alberto's choice");
|
|
var entry = await lib.Db.Entries.GetAsync(newer.Entry.Id);
|
|
Assert.AreEqual(EntryState.Deleted, entry!.State, "remembered: it is not downloaded again");
|
|
Assert.AreEqual(DuplicateDecision.KeepLarger, (await lib.Db.Duplicates.GetAsync(c.Pair.Id))!.Decision);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task AFileOfASeriesLeavesOnlyItsPosition()
|
|
{
|
|
using var temp = new TempFolder("doppioni");
|
|
var (lib, account, older, newer) = await TwoSimilarAsync(temp, newerIsSeries: true);
|
|
await using var _ = lib;
|
|
var review = Review(lib);
|
|
var c = (await review.ListAsync()).Single(x => x.Candidate.EntryId == newer.Entry.Id);
|
|
Assert.AreEqual(2, c.Candidate.FilesInEntry);
|
|
var result = await review.DecideAsync(c.Pair.Id, DuplicateDecision.KeepExisting);
|
|
Assert.AreEqual(1, result.FilesRemoved);
|
|
var stored = (await lib.Db.Entries.GetWithMediaAsync(newer.Entry.Id))!;
|
|
Assert.AreNotEqual(EntryState.Deleted, stored.Entry.State, "the entry stays with its other file");
|
|
Assert.AreEqual(MediaState.Deleted, stored.Media.Single(m => m.Position == 1).State);
|
|
Assert.IsFalse(File.Exists(lib.Layout.FullPath(account, newer.Media.Single(m => m.Position == 1).RelativePath!)));
|
|
Assert.IsTrue(File.Exists(lib.Layout.FullPath(account, newer.Media.Single(m => m.Position == 2).RelativePath!)));
|
|
Assert.IsTrue(File.Exists(lib.Layout.FullPath(account, older.Media[0].RelativePath!)));
|
|
|
|
// The journal received the entry again with only the file that remains: a rebuild keeps the choice.
|
|
var journal = await File.ReadAllLinesAsync(AccountJournal.PathFor(lib.Layout.AccountFolder(account)));
|
|
var last = journal.Last(l => l.Contains("\"200\"", StringComparison.Ordinal));
|
|
StringAssert.Contains(last, newer.Media.Single(m => m.Position == 2).RelativePath!);
|
|
Assert.DoesNotContain(newer.Media.Single(m => m.Position == 1).RelativePath!, last);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task OneChoiceCanGoToEveryPendingPair()
|
|
{
|
|
using var temp = new TempFolder("doppioni");
|
|
var lib = await TestLibrary.CreateAsync(temp);
|
|
await using var _ = lib;
|
|
var account = await lib.Db.Accounts.AddAsync(Make.Account("molte.prova"));
|
|
for (var i = 0; i < 3; i++)
|
|
{
|
|
await lib.SaveAsync(account, Make.Entry(account.Id, $"a{i}", Make.T0 - TimeSpan.FromDays(10 + i)), [TestFile.Photo(1, Scenes[i], 1080, 1350)]);
|
|
await lib.SaveAsync(account, Make.Entry(account.Id, $"b{i}", Make.T0 - TimeSpan.FromDays(i)), [TestFile.Photo(1, Scenes[i], 640, 800)]);
|
|
}
|
|
|
|
var review = Review(lib);
|
|
Assert.AreEqual(3, await review.CountPendingAsync());
|
|
var first = (await review.ListAsync())[0];
|
|
var result = await review.DecideAsync(first.Pair.Id, DuplicateDecision.KeepExisting, applyToAllPending: true);
|
|
Assert.AreEqual(3, result.Decided);
|
|
Assert.AreEqual(3, result.FilesRemoved);
|
|
Assert.AreEqual(0, await review.CountPendingAsync());
|
|
}
|
|
}
|