Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Mzbb6zeFTjT6Rp8b92AVkA
170 lines
10 KiB
C#
170 lines
10 KiB
C#
using Febe.Core.Domain;
|
|
using Febe.Core.Library;
|
|
using Febe.Tests.Support;
|
|
|
|
namespace Febe.Tests.Library;
|
|
|
|
/// <summary>
|
|
/// «Ricostruisci il database dalla libreria» (spec §8.5) on libraries that changed after their files were saved: files
|
|
/// removed or replaced by Alberto's choices, files that cannot be read. The rebuild respects the choices, never stops
|
|
/// on one file, and a second run adds nothing.
|
|
/// </summary>
|
|
[TestClass]
|
|
public sealed class LibraryRebuildRecoveryTests
|
|
{
|
|
/// <summary>One file of a series removed by «Tieni quello in libreria» stays removed, not «file mancante».</summary>
|
|
[TestMethod]
|
|
public async Task AFileOfASeriesRemovedByADuplicateDecisionStaysRemoved()
|
|
{
|
|
using var temp = new TempFolder("ricostruzione");
|
|
await using var lib = await TestLibrary.CreateAsync(temp);
|
|
var account = await lib.Db.Accounts.AddAsync(Make.Account("doppie.prova", "500"));
|
|
await lib.SaveAsync(account, Make.Entry(account.Id, "100", Make.T0.AddDays(-3)), [TestFile.Photo(1, 41, 1080, 1350)]);
|
|
var series = await lib.SaveAsync(account, Make.Entry(account.Id, "200", Make.T0), [TestFile.Photo(1, 41, 720, 900), TestFile.Photo(2, 77, 1080, 1080)]);
|
|
var review = new DownloadDuplicateReview(lib.Db, lib.Layout, lib.Journal, lib.Clock, lib.Thumbnails, lib.Index);
|
|
var pair = (await review.ListAsync()).Single(c => c.Candidate.EntryId == series.Entry.Id);
|
|
Assert.AreEqual(1, (await review.DecideAsync(pair.Pair.Id, DuplicateDecision.KeepExisting)).FilesRemoved);
|
|
var before = (await lib.Db.Entries.GetWithMediaAsync(series.Entry.Id))!;
|
|
|
|
await lib.LoseDatabaseAsync();
|
|
var rebuilder = new LibraryRebuilder(lib.Db, lib.Layout, lib.Clock, lib.Thumbnails);
|
|
var report = await rebuilder.RebuildAsync();
|
|
|
|
Assert.AreEqual(0, report.FilesMissing, string.Join("; ", report.Notes));
|
|
var accountAgain = (await lib.Db.Accounts.FindByInstagramIdAsync("500"))!;
|
|
var entry = (await lib.Db.Entries.FindAsync(accountAgain.Id, EntryKind.Post, "200"))!;
|
|
var media = await lib.Db.Media.ListByEntryAsync(entry.Id);
|
|
Assert.AreEqual(MediaState.Deleted, media.Single(m => m.Position == 1).State, "Alberto's removal is respected: never looked for or downloaded again.");
|
|
Assert.AreEqual(MediaState.Downloaded, media.Single(m => m.Position == 2).State);
|
|
Assert.AreEqual(before.Media.Single(m => m.Position == 2).RelativePath, media.Single(m => m.Position == 2).RelativePath);
|
|
Assert.AreEqual(before.Entry.State, entry.State);
|
|
|
|
var again = await rebuilder.RebuildAsync();
|
|
Assert.AreEqual(0, again.EntriesCreated);
|
|
}
|
|
|
|
/// <summary>
|
|
/// A journal written before replacements closed the old file: an imported entry without identifier appears twice,
|
|
/// once with the file that was replaced. Only the entry with its file comes back, on every run.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public async Task AnEntryWithoutIdentifierWhoseFileWasReplacedComesBackOnce()
|
|
{
|
|
using var temp = new TempFolder("ricostruzione");
|
|
await using var lib = await TestLibrary.CreateAsync(temp);
|
|
var account = await lib.Db.Accounts.AddAsync(Make.Account("marta.demo", "600"));
|
|
var folder = lib.Layout.AccountFolder(account);
|
|
var bytes = TestFile.PhotoBytes(5, 800, 600);
|
|
Directory.CreateDirectory(Path.Combine(folder, "importati"));
|
|
await File.WriteAllBytesAsync(Path.Combine(folder, "importati", "IMG_1 (2).jpg"), bytes);
|
|
var entry = new Entry
|
|
{
|
|
AccountId = account.Id,
|
|
Kind = EntryKind.Post,
|
|
PublishedAt = Make.T0.AddDays(-400),
|
|
Provenance = Provenance.Imported,
|
|
DiscoveredAt = Make.T0,
|
|
};
|
|
Media Imported(string path, string sha) => Make.Photo() with { State = MediaState.Imported, RelativePath = path, Sha256 = sha, Bytes = 100 };
|
|
await lib.Journal.AppendSavedAsync(folder, account, entry, [Imported("importati/IMG_1.jpg", Make.Sha(1))]);
|
|
await lib.Journal.AppendSavedAsync(folder, account, entry, [Imported("importati/IMG_1 (2).jpg", Make.Sha(2))]);
|
|
|
|
await lib.LoseDatabaseAsync();
|
|
var rebuilder = new LibraryRebuilder(lib.Db, lib.Layout, lib.Clock);
|
|
var report = await rebuilder.RebuildAsync();
|
|
|
|
Assert.AreEqual(1, report.EntriesCreated);
|
|
Assert.AreEqual(1, report.FilesMissing, "The old file is reported...");
|
|
Assert.IsTrue(report.Notes.Any(n => n.Contains("importati/IMG_1.jpg", StringComparison.Ordinal) && n.Contains("non ripristinato", StringComparison.Ordinal)));
|
|
var accountAgain = (await lib.Db.Accounts.FindByInstagramIdAsync("600"))!;
|
|
var entries = await lib.Db.Entries.ListByAccountAsync(accountAgain.Id);
|
|
Assert.HasCount(1, entries, "...but not restored as an entry of its own.");
|
|
Assert.AreEqual("importati/IMG_1 (2).jpg", (await lib.Db.Media.ListByEntryAsync(entries[0].Id)).Single().RelativePath);
|
|
|
|
var again = await rebuilder.RebuildAsync();
|
|
Assert.AreEqual(0, again.EntriesCreated, "A second run adds nothing.");
|
|
Assert.HasCount(1, await lib.Db.Entries.ListByAccountAsync(accountAgain.Id));
|
|
}
|
|
|
|
/// <summary>A remembered deletion of an imported entry without identifier is not added again by every run.</summary>
|
|
[TestMethod]
|
|
public async Task ARememberedDeletionWithoutIdentifierIsRestoredOnce()
|
|
{
|
|
using var temp = new TempFolder("ricostruzione");
|
|
await using var lib = await TestLibrary.CreateAsync(temp);
|
|
var account = await lib.Db.Accounts.AddAsync(Make.Account("marta.demo", "700"));
|
|
var imported = await lib.SaveAsync(account, Make.Entry(account.Id, "x", Make.T0.AddDays(-300)) with { InstagramId = null, Code = null, Provenance = Provenance.Imported }, [TestFile.Photo(1, 9)]);
|
|
await new LibraryDeletion(lib.Db, lib.Layout, lib.Journal, lib.Clock).DeleteAsync(imported.Entry.Id, DeletionMode.Remember);
|
|
|
|
await lib.LoseDatabaseAsync();
|
|
var rebuilder = new LibraryRebuilder(lib.Db, lib.Layout, lib.Clock);
|
|
Assert.AreEqual(1, (await rebuilder.RebuildAsync()).EntriesDeleted);
|
|
var again = await rebuilder.RebuildAsync();
|
|
|
|
Assert.AreEqual(0, again.EntriesCreated);
|
|
var accountAgain = (await lib.Db.Accounts.FindByInstagramIdAsync("700"))!;
|
|
var entries = await lib.Db.Entries.ListByAccountAsync(accountAgain.Id);
|
|
Assert.HasCount(1, entries);
|
|
Assert.AreEqual(EntryState.Deleted, entries[0].State);
|
|
Assert.AreEqual(imported.Media[0].Sha256, (await lib.Db.Media.ListByEntryAsync(entries[0].Id)).Single().Sha256, "The SHA-256 is remembered: an import does not bring it back.");
|
|
}
|
|
|
|
/// <summary>
|
|
/// A file that cannot be read (here: held exclusively by another program) and an unreadable journal do not stop
|
|
/// the rebuild of everything else; the file stays linked as the journal recorded it.
|
|
/// </summary>
|
|
[TestMethod]
|
|
public async Task AnUnreadableFileOrJournalDoesNotStopTheRebuild()
|
|
{
|
|
using var temp = new TempFolder("ricostruzione");
|
|
await using var lib = await TestLibrary.CreateAsync(temp);
|
|
var marta = await lib.Db.Accounts.AddAsync(Make.Account("marta.demo", "800"));
|
|
var luca = await lib.Db.Accounts.AddAsync(Make.Account("luca.demo", "801"));
|
|
var zoe = await lib.Db.Accounts.AddAsync(Make.Account("zoe.demo", "802"));
|
|
var locked = await lib.SaveAsync(marta, Make.Entry(marta.Id, "a1", Make.T0.AddDays(-2)), [TestFile.Photo(1, 11)]);
|
|
var fine = await lib.SaveAsync(marta, Make.Entry(marta.Id, "a2", Make.T0.AddDays(-1)), [TestFile.Photo(1, 12)]);
|
|
await lib.SaveAsync(luca, Make.Entry(luca.Id, "b1", Make.T0), [TestFile.Photo(1, 13)]);
|
|
await lib.SaveAsync(zoe, Make.Entry(zoe.Id, "c1", Make.T0), [TestFile.Photo(1, 14)]);
|
|
await lib.LoseDatabaseAsync();
|
|
|
|
var lockedPath = lib.Layout.FullPath(marta, locked.Media[0].RelativePath!);
|
|
var report = await WhileHeldAsync(
|
|
[lockedPath, AccountJournal.PathFor(lib.Layout.AccountFolder(luca))],
|
|
() => new LibraryRebuilder(lib.Db, lib.Layout, lib.Clock, lib.Thumbnails).RebuildAsync());
|
|
|
|
Assert.AreEqual(1, report.FilesUnreadable, string.Join("; ", report.Notes));
|
|
Assert.AreEqual(2, report.FilesVerified, "The other files of the folder and of the following folders are verified.");
|
|
Assert.IsTrue(report.Notes.Any(n => n.Contains("luca.demo", StringComparison.Ordinal) && n.Contains("_febe.jsonl", StringComparison.Ordinal)));
|
|
var martaAgain = (await lib.Db.Accounts.FindByInstagramIdAsync("800"))!;
|
|
var restored = (await lib.Db.Media.ListByEntryAsync((await lib.Db.Entries.FindAsync(martaAgain.Id, EntryKind.Post, "a1"))!.Id)).Single();
|
|
Assert.AreEqual(MediaState.Downloaded, restored.State, "The file is where the journal says: linked again, not to be downloaded.");
|
|
Assert.AreEqual(locked.Media[0].RelativePath, restored.RelativePath);
|
|
Assert.AreEqual(locked.Media[0].Sha256, restored.Sha256);
|
|
StringAssert.Contains(restored.LastError, "illeggibile");
|
|
Assert.IsNotNull(await lib.Db.Entries.FindAsync(martaAgain.Id, EntryKind.Post, "a2"));
|
|
Assert.IsNotNull(await lib.Db.Accounts.FindByInstagramIdAsync("802"), "The folders after the unreadable one are rebuilt too.");
|
|
Assert.IsNull(await lib.Db.Accounts.FindByInstagramIdAsync("801"), "The folder with the unreadable journal waits for the next run.");
|
|
|
|
var later = await new LibraryRebuilder(lib.Db, lib.Layout, lib.Clock, lib.Thumbnails).RebuildAsync();
|
|
Assert.AreEqual(1, later.EntriesCreated, "Once readable, the skipped folder is rebuilt.");
|
|
_ = fine;
|
|
}
|
|
|
|
/// <summary>Runs <paramref name="action"/> while other handles hold the files with no sharing at all.</summary>
|
|
private static async Task<T> WhileHeldAsync<T>(IReadOnlyList<string> paths, Func<Task<T>> action)
|
|
{
|
|
var handles = paths.Select(p => new FileStream(p, FileMode.Open, FileAccess.ReadWrite, FileShare.None)).ToList();
|
|
try
|
|
{
|
|
return await action();
|
|
}
|
|
finally
|
|
{
|
|
foreach (var handle in handles)
|
|
{
|
|
await handle.DisposeAsync();
|
|
}
|
|
}
|
|
}
|
|
}
|