Files
Febe/tests/Febe.Tests/Library/DownloadDuplicateReviewTests.cs

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());
}
}