Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Mzbb6zeFTjT6Rp8b92AVkA
521 lines
32 KiB
C#
521 lines
32 KiB
C#
using System.Security.Cryptography;
|
|
using Febe.Core.Domain;
|
|
using Febe.Core.Import;
|
|
using Febe.Core.Library;
|
|
using Febe.Tests.Import.Support;
|
|
using Febe.Tests.Support;
|
|
|
|
namespace Febe.Tests.Import;
|
|
|
|
[TestClass]
|
|
public sealed class ImportCopyTests
|
|
{
|
|
[TestMethod]
|
|
public async Task KnownFilesTakeTheLibraryNameAndTheOthersGoToImportati()
|
|
{
|
|
using var temp = new TempFolder("importa");
|
|
await using var bed = await ImportTestBed.CreateAsync(temp);
|
|
var marta = await bed.Library.Db.Accounts.AddAsync(Make.Account("marta.demo"));
|
|
bed.Write("marta.demo/post/2026/2026-10-10_18-22-05_DBx3kQ2_1.jpg", ImportTestFiles.Photo(1));
|
|
bed.Write("marta.demo/post/2026/2026-10-10_18-22-05_DBx3kQ2_2.jpg", ImportTestFiles.Photo(2));
|
|
bed.Write("marta.demo/storie/2026/2026-10-13_09-41-07_3742118_1.mp4", ImportTestFiles.Mp4(null, payloadSeed: 11));
|
|
bed.Write("marta.demo/IMG_20210506_070809.jpg", ImportTestFiles.Photo(3));
|
|
bed.Write("marta.demo/senza data.jpg", ImportTestFiles.Photo(4), new DateTime(2018, 3, 4, 5, 6, 7, DateTimeKind.Utc));
|
|
var folder = bed.Library.Layout.AccountFolder(marta);
|
|
Directory.CreateDirectory(Path.Combine(folder, "importati"));
|
|
var squatter = Path.Combine(folder, "importati", "IMG_20210506_070809.jpg");
|
|
File.WriteAllBytes(squatter, [9, 9, 9]);
|
|
var before = bed.Fingerprint();
|
|
|
|
var run = await bed.AnalyzeAsync();
|
|
await bed.Copier.CopyAsync(run.Id);
|
|
|
|
CollectionAssert.AreEqual(before.ToList(), bed.Fingerprint().ToList(), "Con «Copia» gli originali restano come sono.");
|
|
var files = await bed.FilesAsync(run.Id);
|
|
Assert.IsTrue(files.All(f => f.State == ImportFileState.Copied), string.Join("; ", files.Select(f => f.RelativePath + ": " + f.State + " " + f.LastError)));
|
|
Assert.AreEqual(ImportRunState.Completed, (await bed.Library.Db.Imports.GetRunAsync(run.Id))!.State);
|
|
|
|
var carousel = await bed.Library.Db.Imports.FindEntryByCodeAsync(marta.Id, EntryKind.Post, "DBx3kQ2");
|
|
var post = (await bed.Library.Db.Entries.GetWithMediaAsync(carousel!.Id))!;
|
|
Assert.AreEqual(Provenance.Imported, post.Entry.Provenance);
|
|
Assert.AreEqual(EntryState.Imported, post.Entry.State);
|
|
Assert.AreEqual(new DateTimeOffset(2026, 10, 10, 16, 22, 5, TimeSpan.Zero), post.Entry.PublishedAt);
|
|
CollectionAssert.AreEqual(
|
|
new[] { "post/2026/2026-10-10_18-22-05_DBx3kQ2_1.jpg", "post/2026/2026-10-10_18-22-05_DBx3kQ2_2.jpg" },
|
|
post.Media.Select(m => m.RelativePath).ToArray(),
|
|
"Un post con più file diventa un elemento solo, con i nomi dello schema.");
|
|
Assert.IsTrue(post.Media.All(m => m.State == MediaState.Imported && m.HasThumbnail && m.PerceptualHash is not null));
|
|
Assert.IsTrue(bed.Library.Index.Count >= 2, "Le impronte delle foto importate entrano nell'indice.");
|
|
Assert.AreEqual(post.Entry.PublishedAt.UtcDateTime, File.GetLastWriteTimeUtc(bed.Library.Layout.FullPath(marta, post.Media[0].RelativePath!)));
|
|
|
|
var story = (await bed.Library.Db.Entries.FindAsync(marta.Id, EntryKind.Story, "3742118"))!;
|
|
Assert.AreEqual("storie/2026/2026-10-13_09-41-07_3742118_1.mp4", (await bed.Library.Db.Media.ListByEntryAsync(story.Id)).Single().RelativePath);
|
|
|
|
var byDate = files.Single(f => f.RelativePath.EndsWith("IMG_20210506_070809.jpg", StringComparison.Ordinal));
|
|
Assert.AreEqual("importati/IMG_20210506_070809 (2).jpg", byDate.DestinationPath, "Senza codice: in importati con il nome originale, e mai sopra un file che c'è già.");
|
|
CollectionAssert.AreEqual(new byte[] { 9, 9, 9 }, File.ReadAllBytes(squatter));
|
|
Assert.AreEqual("importati/senza data.jpg", files.Single(f => f.RelativePath.EndsWith("senza data.jpg", StringComparison.Ordinal)).DestinationPath);
|
|
|
|
var journal = await AccountJournal.ReadAsync(folder);
|
|
Assert.IsTrue(journal.Lines.All(l => l.Entry.Provenance == "imported"));
|
|
Assert.AreEqual(4, journal.Lines.Select(l => l.Entry.Id ?? l.Entry.Code ?? l.Files![0].Path).Distinct().Count(), "Una riga di _febe.jsonl per ogni elemento importato.");
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task AFolderWithoutAccountBlocksOnlyItsOwnFiles()
|
|
{
|
|
using var temp = new TempFolder("importa");
|
|
await using var bed = await ImportTestBed.CreateAsync(temp);
|
|
bed.Write("marta.demo/a.jpg", ImportTestFiles.Photo(10));
|
|
bed.Write("marta.demo/b.jpg", ImportTestFiles.Photo(11));
|
|
bed.Write("Foto sparse/c.jpg", ImportTestFiles.Photo(12));
|
|
bed.Write("Foto sparse/d.jpg", ImportTestFiles.Photo(13));
|
|
bed.Write("Foto sparse/e.jpg", ImportTestFiles.Photo(14));
|
|
var run = await bed.AnalyzeAsync();
|
|
|
|
var plan = await bed.Review.GetPlanAsync(run.Id);
|
|
Assert.AreEqual(2, plan.ToImport);
|
|
Assert.AreEqual(3, plan.LeftOutNoAccount);
|
|
Assert.AreEqual(1, plan.FoldersWithoutAccount);
|
|
Assert.AreEqual("Importa 2 file", plan.ButtonLabel);
|
|
Assert.AreEqual("1 cartella senza account: 3 file restano fuori", plan.LeftOutLabel);
|
|
|
|
await bed.Copier.CopyAsync(run.Id);
|
|
|
|
var created = await bed.Library.Db.Accounts.FindByUsernameAsync("marta.demo");
|
|
Assert.IsNotNull(created, "L'account nuovo nasce quando parte la copia.");
|
|
Assert.AreEqual(AccountState.ArchiveOnly, created.State);
|
|
Assert.IsFalse(created.KeepUpdated);
|
|
var files = await bed.FilesAsync(run.Id);
|
|
Assert.AreEqual(2, files.Count(f => f.State == ImportFileState.Copied));
|
|
var left = files.Where(f => f.Folder == "Foto sparse").ToList();
|
|
Assert.IsTrue(left.All(f => f.State == ImportFileState.Analyzed && f.LastError == ImportText.NoteNoAccount));
|
|
var report = await bed.Reports.GetReportAsync(run.Id);
|
|
Assert.AreEqual(2, report.Copied);
|
|
Assert.AreEqual(3, report.LeftOut);
|
|
|
|
// «Importa i rimasti»: the folder gets an account and the copy runs again on the same import.
|
|
await bed.Review.SetFolderTargetAsync(run.Id, "Foto sparse", FolderTarget.Existing(created.Id));
|
|
Assert.AreEqual(3, (await bed.Review.GetPlanAsync(run.Id)).ToImport);
|
|
await bed.Copier.CopyAsync(run.Id);
|
|
Assert.AreEqual(5, (await bed.FilesAsync(run.Id)).Count(f => f.State == ImportFileState.Copied));
|
|
Assert.AreEqual(0, (await bed.Review.GetPlanAsync(run.Id)).ToImport);
|
|
Assert.IsNull((await bed.Review.GetPlanAsync(run.Id)).LeftOutLabel);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task AnInterruptedCopyResumesWithoutDuplicates()
|
|
{
|
|
using var temp = new TempFolder("importa");
|
|
await using var bed = await ImportTestBed.CreateAsync(temp);
|
|
for (var i = 0; i < 20; i++)
|
|
{
|
|
bed.Write($"luca.demo/foto-{i:00}.png", ImportTestFiles.Png(200 + i, 48, 36));
|
|
}
|
|
|
|
var run = await bed.AnalyzeAsync();
|
|
using var stop = new CancellationTokenSource();
|
|
var progress = new SyncProgress(p =>
|
|
{
|
|
if (p.Phase == ImportPhase.Copying && p.FilesDone >= 7)
|
|
{
|
|
stop.Cancel();
|
|
}
|
|
});
|
|
|
|
await Assert.ThrowsAsync<OperationCanceledException>(() => bed.Copier.CopyAsync(run.Id, progress, stop.Token));
|
|
Assert.AreEqual(ImportRunState.CopyInterrupted, (await bed.Library.Db.Imports.GetRunAsync(run.Id))!.State);
|
|
var halfway = (await bed.FilesAsync(run.Id)).Count(f => f.State == ImportFileState.Copied);
|
|
Assert.IsTrue(halfway is >= 7 and < 20, $"Copiati prima dell'interruzione: {halfway}.");
|
|
|
|
await bed.Copier.CopyAsync(run.Id);
|
|
|
|
var files = await bed.FilesAsync(run.Id);
|
|
Assert.IsTrue(files.All(f => f.State == ImportFileState.Copied));
|
|
var account = (await bed.Library.Db.Accounts.FindByUsernameAsync("luca.demo"))!;
|
|
var onDisk = Directory.GetFiles(bed.Library.Layout.AccountFolder(account), "*.png", SearchOption.AllDirectories);
|
|
Assert.HasCount(20, onDisk, "Nessun file copiato due volte.");
|
|
Assert.IsFalse(onDisk.Any(f => f.Contains(" (2)", StringComparison.Ordinal)));
|
|
Assert.HasCount(20, await bed.Library.Db.Entries.ListByAccountAsync(account.Id));
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task MoveDeletesAnOriginalOnlyAfterItsCopyIsVerified()
|
|
{
|
|
using var temp = new TempFolder("importa");
|
|
await using var bed = await ImportTestBed.CreateAsync(temp);
|
|
var already = ImportTestFiles.Photo(30);
|
|
await bed.AccountWithPhotoAsync("marta.demo", "300", already);
|
|
var moved = bed.Write("marta.demo/nuova.jpg", ImportTestFiles.Photo(31));
|
|
var skipped = bed.Write("marta.demo/gia-presente.jpg", already);
|
|
var run = await bed.AnalyzeAsync();
|
|
await bed.Review.SetModeAsync(run.Id, ImportMode.Move);
|
|
|
|
await bed.Copier.CopyAsync(run.Id);
|
|
|
|
var file = await bed.FileAsync(run.Id, "marta.demo/nuova.jpg");
|
|
Assert.AreEqual(ImportFileState.Moved, file.State);
|
|
Assert.IsFalse(File.Exists(moved), "Copia verificata: l'originale si elimina.");
|
|
var account = (await bed.Library.Db.Accounts.FindByUsernameAsync("marta.demo"))!;
|
|
var copy = bed.Library.Layout.FullPath(account, file.DestinationPath!);
|
|
Assert.AreEqual(file.Sha256, Convert.ToHexStringLower(SHA256.HashData(File.ReadAllBytes(copy))));
|
|
Assert.IsTrue(File.Exists(skipped), "Un file saltato non si tocca, nemmeno con «Sposta».");
|
|
CollectionAssert.AreEqual(new[] { moved }, bed.FileSystem.Deleted);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task MoveNeverDeletesAnUnverifiedOriginal()
|
|
{
|
|
using var temp = new TempFolder("importa");
|
|
await using var bed = await ImportTestBed.CreateAsync(temp);
|
|
var original = bed.Write("marta.demo/preziosa.jpg", ImportTestFiles.Photo(40));
|
|
var originalBytes = File.ReadAllBytes(original);
|
|
var run = await bed.AnalyzeAsync();
|
|
await bed.Review.SetModeAsync(run.Id, ImportMode.Move);
|
|
bed.FileSystem.CorruptCopies = true; // the copy on disk is damaged before it is checked
|
|
|
|
await bed.Copier.CopyAsync(run.Id);
|
|
|
|
var file = await bed.FileAsync(run.Id, "marta.demo/preziosa.jpg");
|
|
Assert.AreEqual(ImportFileState.Failed, file.State);
|
|
Assert.AreEqual(ImportText.NoteNotVerified, file.LastError);
|
|
Assert.IsTrue(File.Exists(original), "Copia non verificata: l'originale resta.");
|
|
CollectionAssert.AreEqual(originalBytes, File.ReadAllBytes(original));
|
|
Assert.IsEmpty(bed.FileSystem.Deleted);
|
|
|
|
// Trying again checks the copy again: still damaged, still kept.
|
|
await bed.Copier.CopyAsync(run.Id);
|
|
Assert.IsTrue(File.Exists(original));
|
|
Assert.IsEmpty(bed.FileSystem.Deleted);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task AMoveLeftHalfwayIsFinishedAndCopiesMadeBeforeAreNeverMoved()
|
|
{
|
|
using var temp = new TempFolder("importa");
|
|
await using var bed = await ImportTestBed.CreateAsync(temp);
|
|
await bed.Library.Db.Accounts.AddAsync(Make.Account("marta.demo"));
|
|
var copiedFirst = bed.Write("marta.demo/copiata-prima.jpg", ImportTestFiles.Photo(45));
|
|
var locked = bed.Write("Foto sparse/in-uso.jpg", ImportTestFiles.Photo(46));
|
|
var run = await bed.AnalyzeAsync();
|
|
|
|
// First «Copia» for marta.demo only (Foto sparse has no account yet).
|
|
await bed.Copier.CopyAsync(run.Id);
|
|
Assert.AreEqual(ImportFileState.Copied, (await bed.FileAsync(run.Id, "marta.demo/copiata-prima.jpg")).State);
|
|
|
|
// Then «Sposta» for the rest, with the original open in another program.
|
|
var marta = (await bed.Library.Db.Accounts.FindByUsernameAsync("marta.demo"))!;
|
|
await bed.Review.SetFolderTargetAsync(run.Id, "Foto sparse", FolderTarget.Existing(marta.Id));
|
|
await bed.Review.SetModeAsync(run.Id, ImportMode.Move);
|
|
bed.FileSystem.FailDeletes = true;
|
|
await bed.Copier.CopyAsync(run.Id);
|
|
var stuck = await bed.FileAsync(run.Id, "Foto sparse/in-uso.jpg");
|
|
Assert.AreEqual(ImportFileState.Copied, stuck.State);
|
|
StringAssert.EndsWith(stuck.LastError, ImportText.NoteOriginalKept);
|
|
Assert.IsTrue(File.Exists(locked));
|
|
|
|
bed.FileSystem.FailDeletes = false;
|
|
await bed.Copier.CopyAsync(run.Id);
|
|
|
|
Assert.AreEqual(ImportFileState.Moved, (await bed.FileAsync(run.Id, "Foto sparse/in-uso.jpg")).State);
|
|
Assert.IsNull((await bed.FileAsync(run.Id, "Foto sparse/in-uso.jpg")).LastError);
|
|
Assert.IsFalse(File.Exists(locked), "La copia è verificata di nuovo, poi l'originale si elimina.");
|
|
Assert.IsTrue(File.Exists(copiedFirst), "Un file copiato con «Copia» non si elimina passando a «Sposta».");
|
|
Assert.AreEqual(ImportFileState.Copied, (await bed.FileAsync(run.Id, "marta.demo/copiata-prima.jpg")).State);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task AFileChangedAfterTheAnalysisIsNotCopied()
|
|
{
|
|
using var temp = new TempFolder("importa");
|
|
await using var bed = await ImportTestBed.CreateAsync(temp);
|
|
await bed.Library.Db.Accounts.AddAsync(Make.Account("marta.demo"));
|
|
var path = bed.Write("marta.demo/cambiata.jpg", ImportTestFiles.Photo(47));
|
|
var run = await bed.AnalyzeAsync();
|
|
File.WriteAllBytes(path, ImportTestFiles.Photo(48));
|
|
|
|
await bed.Copier.CopyAsync(run.Id);
|
|
|
|
var file = (await bed.FilesAsync(run.Id)).Single();
|
|
Assert.AreEqual(ImportFileState.Failed, file.State);
|
|
Assert.AreEqual(ImportText.NoteChanged, file.LastError);
|
|
var account = (await bed.Library.Db.Accounts.FindByUsernameAsync("marta.demo"))!;
|
|
Assert.IsEmpty(await bed.Library.Db.Entries.ListByAccountAsync(account.Id), "Nessun elemento vuoto resta in libreria.");
|
|
Assert.IsFalse(Directory.Exists(bed.Library.Layout.AccountFolder(account)) && Directory.EnumerateFiles(bed.Library.Layout.AccountFolder(account), "*.jpg", SearchOption.AllDirectories).Any());
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task AnImportCompletesASeriesAlreadyInTheLibrary()
|
|
{
|
|
using var temp = new TempFolder("importa");
|
|
await using var bed = await ImportTestBed.CreateAsync(temp);
|
|
var marta = await bed.Library.Db.Accounts.AddAsync(Make.Account("marta.demo"));
|
|
var first = ImportTestFiles.Photo(130);
|
|
var entry = Make.Entry(marta.Id, "555", new DateTimeOffset(2026, 10, 10, 16, 22, 5, TimeSpan.Zero)) with { Code = "SER1234" };
|
|
var added = await bed.Library.Db.Entries.AddAsync(entry, [Make.Photo(1), Make.Photo(2)]);
|
|
await bed.Library.Ingest.SaveMediaAsync(marta, added.Stored.Entry, added.Stored.Media[0], new MediaContent { Content = new MemoryStream(first), Extension = ".jpg" });
|
|
bed.Write("marta.demo/post/2026/2026-10-10_18-22-05_SER1234_1.jpg", first);
|
|
bed.Write("marta.demo/post/2026/2026-10-10_18-22-05_SER1234_2.jpg", ImportTestFiles.Photo(131));
|
|
|
|
var run = await bed.AnalyzeAsync();
|
|
Assert.AreEqual(ImportOutcome.AlreadyInLibrary, (await bed.FileAsync(run.Id, "marta.demo/post/2026/2026-10-10_18-22-05_SER1234_1.jpg")).Outcome);
|
|
Assert.AreEqual(ImportOutcome.New, (await bed.FileAsync(run.Id, "marta.demo/post/2026/2026-10-10_18-22-05_SER1234_2.jpg")).Outcome, "Il secondo file manca: non è un doppione.");
|
|
await bed.Copier.CopyAsync(run.Id);
|
|
|
|
var stored = (await bed.Library.Db.Entries.GetWithMediaAsync(added.Stored.Entry.Id))!;
|
|
Assert.AreEqual(EntryState.Downloaded, stored.Entry.State, "L'elemento ora ha tutti i suoi file.");
|
|
Assert.AreEqual("post/2026/2026-10-10_18-22-05_SER1234_2.jpg", stored.Media[1].RelativePath);
|
|
Assert.IsTrue(EntryStateRules.IsPresent(stored.Media[1].State));
|
|
Assert.HasCount(1, await bed.Library.Db.Entries.ListByAccountAsync(marta.Id), "Nessun elemento nuovo: il file completa quello che c'era.");
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task AReadOnlySourceDoesNotOfferMove()
|
|
{
|
|
using var temp = new TempFolder("importa");
|
|
await using var bed = await ImportTestBed.CreateAsync(temp, readOnlySource: true);
|
|
bed.Write("marta.demo/a.jpg", ImportTestFiles.Photo(50));
|
|
var info = bed.Environment.CreateSources().Inspect(bed.Source);
|
|
Assert.IsTrue(info.ReadOnly);
|
|
Assert.IsFalse(info.CanMove);
|
|
|
|
var run = await bed.AnalyzeAsync();
|
|
Assert.IsTrue(run.SourceReadOnly);
|
|
Assert.IsFalse((await bed.Review.GetSummaryAsync(run.Id)).CanMove, "«Sposta» non compare.");
|
|
await Assert.ThrowsAsync<InvalidOperationException>(() => bed.Review.SetModeAsync(run.Id, ImportMode.Move));
|
|
|
|
await bed.Copier.CopyAsync(run.Id);
|
|
Assert.AreEqual(ImportFileState.Copied, (await bed.FilesAsync(run.Id)).Single().State);
|
|
Assert.IsTrue(File.Exists(Path.Combine(bed.Source, "marta.demo", "a.jpg")));
|
|
|
|
// In Docker the /importa volume is read-only by configuration, whatever the probe says.
|
|
var docker = new ImportSources(ImportSourceOptions.Docker(bed.Temp.Path), probe: new FixedAccessProbe(false));
|
|
Assert.IsTrue(docker.Inspect(bed.Source).ReadOnly);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task DecisionsOnProbableDuplicatesAreAppliedByTheCopyOnly()
|
|
{
|
|
using var temp = new TempFolder("importa");
|
|
await using var bed = await ImportTestBed.CreateAsync(temp);
|
|
var (marta, a) = await bed.AccountWithPhotoAsync("marta.demo", "70", ImportTestFiles.Photo(70, 800, 600, 92));
|
|
var (_, b) = await bed.AccountWithPhotoAsync("marta.demo", "71", ImportTestFiles.Resized(71, 800, 600, 400, 300, 70));
|
|
var (_, c) = await bed.AccountWithPhotoAsync("marta.demo", "72", ImportTestFiles.Photo(72, 800, 600, 92));
|
|
var (_, d) = await bed.AccountWithPhotoAsync("marta.demo", "73", ImportTestFiles.Photo(73, 800, 600, 92));
|
|
bed.Write("marta.demo/a-piccola.jpg", ImportTestFiles.Resized(70, 800, 600, 400, 300, 60));
|
|
var bigger = bed.Write("marta.demo/b-grande.jpg", ImportTestFiles.Photo(71, 800, 600, 92));
|
|
bed.Write("marta.demo/c-piccola.jpg", ImportTestFiles.Resized(72, 800, 600, 400, 300, 60));
|
|
bed.Write("marta.demo/d-piccola.jpg", ImportTestFiles.Resized(73, 800, 600, 400, 300, 60));
|
|
var run = await bed.AnalyzeAsync();
|
|
var oldB = bed.Library.Layout.FullPath(marta, b.Media[0].RelativePath!);
|
|
|
|
var undecided = await bed.Review.GetPlanAsync(run.Id);
|
|
Assert.AreEqual(4, undecided.LeftOutUndecided);
|
|
StringAssert.Contains(undecided.LeftOutLabel, "4 file aspettano la tua decisione");
|
|
await bed.Copier.CopyAsync(run.Id);
|
|
Assert.IsTrue(File.Exists(oldB), "Senza una scelta di Alberto non si sostituisce nulla (regola 12).");
|
|
Assert.IsTrue((await bed.FilesAsync(run.Id)).All(f => f.State == ImportFileState.Analyzed));
|
|
|
|
var cases = await bed.Review.ListDuplicatesAsync(run.Id);
|
|
Assert.HasCount(4, cases);
|
|
Assert.IsTrue(cases.All(x => x.Pair.Decision == DuplicateDecision.Pending), "Nessuna scelta fatta in partenza.");
|
|
DuplicateCase Case(EntryWithMedia library) => cases.Single(x => x.Existing.MediaId == library.Media[0].Id);
|
|
Assert.IsTrue(Case(b).CandidateIsLarger);
|
|
Assert.IsFalse(Case(a).CandidateIsLarger);
|
|
await bed.Review.DecideAsync(run.Id, Case(a).Pair.Id, DuplicateDecision.KeepLarger);
|
|
await bed.Review.DecideAsync(run.Id, Case(b).Pair.Id, DuplicateDecision.KeepLarger);
|
|
await bed.Review.DecideAsync(run.Id, Case(c).Pair.Id, DuplicateDecision.KeepBoth);
|
|
await bed.Review.DecideAsync(run.Id, Case(d).Pair.Id, DuplicateDecision.KeepExisting);
|
|
var plan = await bed.Review.GetPlanAsync(run.Id);
|
|
Assert.AreEqual(2, plan.ToImport);
|
|
Assert.AreEqual(1, plan.ToReplace);
|
|
|
|
await bed.Copier.CopyAsync(run.Id);
|
|
|
|
var files = await bed.FilesAsync(run.Id);
|
|
ImportFile File_(string name) => files.Single(f => f.RelativePath == "marta.demo/" + name);
|
|
Assert.AreEqual(ImportFileState.Skipped, File_("a-piccola.jpg").State);
|
|
Assert.AreEqual(ImportText.NoteLibraryLarger, File_("a-piccola.jpg").LastError);
|
|
Assert.AreEqual(ImportFileState.Skipped, File_("d-piccola.jpg").State);
|
|
Assert.AreEqual(ImportFileState.Copied, File_("c-piccola.jpg").State, "«Tienili entrambi».");
|
|
Assert.AreEqual(1, (await bed.Library.Db.Entries.ListByAccountAsync(marta.Id)).Count(e => e.Provenance == Provenance.Imported), "Solo «Tienili entrambi» crea un elemento nuovo.");
|
|
|
|
// «Tieni il più grande» with the imported file larger: the library file is replaced, safely.
|
|
var replaced = File_("b-grande.jpg");
|
|
Assert.AreEqual(ImportFileState.Copied, replaced.State);
|
|
StringAssert.StartsWith(replaced.LastError, ImportText.NoteReplaced);
|
|
var media = (await bed.Library.Db.Media.GetAsync(b.Media[0].Id))!;
|
|
Assert.AreEqual(replaced.Sha256, media.Sha256, "Il record della libreria punta al file nuovo.");
|
|
Assert.AreEqual((800, 600), (media.Width, media.Height));
|
|
Assert.AreEqual(MediaState.Downloaded, media.State, "Il file resta quello dell'elemento scaricato.");
|
|
var newPath = bed.Library.Layout.FullPath(marta, media.RelativePath!);
|
|
Assert.AreEqual(replaced.Sha256, Convert.ToHexStringLower(SHA256.HashData(File.ReadAllBytes(newPath))));
|
|
Assert.IsFalse(File.Exists(oldB), "Il file più piccolo si elimina solo dopo che il nuovo è stato scritto e verificato.");
|
|
Assert.IsTrue(File.Exists(bigger), "Con «Copia» l'originale resta.");
|
|
Assert.IsTrue(bed.Library.Thumbnails.Exists(media.Sha256!));
|
|
Assert.IsFalse(bed.Library.Thumbnails.Exists(b.Media[0].Sha256!), "La miniatura del file sostituito non serve più.");
|
|
var journal = await AccountJournal.ReadAsync(bed.Library.Layout.AccountFolder(marta));
|
|
Assert.AreEqual(media.RelativePath, journal.Lines.Last(l => l.Entry.Id == "71").Files!.Single().Path, "L'ultima riga di _febe.jsonl porta il file nuovo.");
|
|
Assert.AreEqual(0, await bed.Library.Db.Duplicates.CountPendingAsync(DuplicateOrigin.Import));
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task ADecisionCanBeAppliedToTheOtherCases()
|
|
{
|
|
using var temp = new TempFolder("importa");
|
|
await using var bed = await ImportTestBed.CreateAsync(temp);
|
|
for (var i = 0; i < 3; i++)
|
|
{
|
|
await bed.AccountWithPhotoAsync("marta.demo", (80 + i).ToString(System.Globalization.CultureInfo.InvariantCulture), ImportTestFiles.Photo(80 + i, 800, 600, 92));
|
|
bed.Write($"marta.demo/copia-{i}.jpg", ImportTestFiles.Resized(80 + i, 800, 600, 400, 300, 60));
|
|
}
|
|
|
|
var account = (await bed.Library.Db.Accounts.FindByUsernameAsync("marta.demo"))!;
|
|
var story = Make.Entry(account.Id, "3742119", Make.T0, EntryKind.Story);
|
|
await bed.Library.SaveAsync(account, story, [new TestFile(Make.Photo(1), ImportTestFiles.Photo(90), ".jpg")]);
|
|
bed.Write("marta.demo/storie/2026/2026-10-13_10-00-00_3742119_1.jpg", ImportTestFiles.Photo(91));
|
|
var run = await bed.AnalyzeAsync();
|
|
var cases = await bed.Review.ListDuplicatesAsync(run.Id);
|
|
Assert.HasCount(4, cases);
|
|
|
|
var visual = cases.First(c => c.Pair.Reason == DuplicateReason.VisuallySimilar);
|
|
Assert.AreEqual(3, await bed.Review.DecideAsync(run.Id, visual.Pair.Id, DuplicateDecision.KeepExisting, DecisionScope.SameReason));
|
|
Assert.HasCount(1, await bed.Review.ListDuplicatesAsync(run.Id), "Resta il caso con un'altra ragione.");
|
|
|
|
var last = (await bed.Review.ListDuplicatesAsync(run.Id)).Single();
|
|
Assert.AreEqual(1, await bed.Review.DecideAsync(run.Id, last.Pair.Id, DuplicateDecision.KeepBoth, DecisionScope.AllPending));
|
|
Assert.IsEmpty(await bed.Review.ListDuplicatesAsync(run.Id));
|
|
Assert.AreEqual(ImportDecision.KeepExisting, (await bed.FileAsync(run.Id, "marta.demo/copia-1.jpg")).Decision);
|
|
await Assert.ThrowsAsync<ArgumentException>(() => bed.Review.DecideAsync(run.Id, last.Pair.Id, DuplicateDecision.Pending));
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task InsideTheSourceKeepLargerImportsOnlyTheLargest()
|
|
{
|
|
using var temp = new TempFolder("importa");
|
|
await using var bed = await ImportTestBed.CreateAsync(temp);
|
|
bed.Write("marta.demo/1-media.jpg", ImportTestFiles.Resized(95, 800, 600, 600, 450, 80));
|
|
bed.Write("marta.demo/2-grande.jpg", ImportTestFiles.Photo(95, 800, 600, 92));
|
|
bed.Write("marta.demo/3-piccola.jpg", ImportTestFiles.Resized(95, 800, 600, 400, 300, 60));
|
|
var run = await bed.AnalyzeAsync();
|
|
var cases = await bed.Review.ListDuplicatesAsync(run.Id);
|
|
Assert.HasCount(2, cases);
|
|
Assert.IsTrue(cases.All(c => c.InsideSource));
|
|
|
|
await bed.Review.DecideAsync(run.Id, cases[0].Pair.Id, DuplicateDecision.KeepLarger, DecisionScope.AllPending);
|
|
await bed.Copier.CopyAsync(run.Id);
|
|
|
|
var files = await bed.FilesAsync(run.Id);
|
|
Assert.AreEqual("marta.demo/2-grande.jpg", files.Single(f => f.State == ImportFileState.Copied).RelativePath);
|
|
Assert.AreEqual(2, files.Count(f => f.State == ImportFileState.Skipped));
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task AFebeLibraryIsImportedWithItsIdentifiersAndCaptions()
|
|
{
|
|
using var temp = new TempFolder("importa");
|
|
await using var bed = await ImportTestBed.CreateAsync(temp);
|
|
var folder = Path.Combine(bed.Source, "marta.demo");
|
|
bed.Write("marta.demo/post/2025/2025-03-01_10-30-15_CxYz123_1.jpg", ImportTestFiles.Photo(100));
|
|
bed.Write("marta.demo/evidenza/Estate 2025/2025-08-02_10-11-12_3391207_1.jpg", ImportTestFiles.Photo(101));
|
|
await AccountJournal.AppendAsync(folder, new JournalLine
|
|
{
|
|
Op = JournalOps.Save,
|
|
At = Make.T0,
|
|
Account = new JournalAccount("4242", "marta.demo"),
|
|
Entry = new JournalEntry { Kind = "post", Id = "3100000000000000001", Code = "CxYz123", PublishedAt = new DateTimeOffset(2025, 3, 1, 9, 30, 15, 250, TimeSpan.Zero), Caption = "Al mare" },
|
|
Files = [new JournalFile { N = 1, Type = "photo", Path = "post/2025/2025-03-01_10-30-15_CxYz123_1.jpg", Id = "3100000000000000002" }],
|
|
});
|
|
await AccountJournal.AppendAsync(folder, new JournalLine
|
|
{
|
|
Op = JournalOps.Save,
|
|
At = Make.T0,
|
|
Account = new JournalAccount("4242", "marta.demo"),
|
|
Entry = new JournalEntry { Kind = "evidenza", Id = "3391207", PublishedAt = new DateTimeOffset(2025, 8, 2, 8, 11, 12, TimeSpan.Zero), Highlights = [new JournalHighlight("99", "Estate 2025")] },
|
|
Files = [new JournalFile { N = 1, Type = "photo", Path = "evidenza/Estate 2025/2025-08-02_10-11-12_3391207_1.jpg" }],
|
|
});
|
|
var marta = await bed.Library.Db.Accounts.AddAsync(Make.Account("marta.demo", "4242"));
|
|
var info = bed.Environment.CreateSources().Inspect(bed.Source);
|
|
Assert.IsTrue(info.LooksLikeFebeLibrary);
|
|
|
|
var run = await bed.AnalyzeAsync();
|
|
var summary = await bed.Review.GetSummaryAsync(run.Id);
|
|
Assert.AreEqual(2, summary.Recognized, "Elementi di cui si conosce codice o identificativo: Febe non li riscaricherà.");
|
|
Assert.AreEqual(marta.Id, summary.Folders.Single().Target.AccountId, "Riconosciuto dall'identificativo Instagram dell'account.");
|
|
await bed.Copier.CopyAsync(run.Id);
|
|
|
|
var post = (await bed.Library.Db.Entries.FindAsync(marta.Id, EntryKind.Post, "3100000000000000001"))!;
|
|
Assert.AreEqual("CxYz123", post.Code);
|
|
Assert.AreEqual("Al mare", post.Caption);
|
|
Assert.AreEqual(new DateTimeOffset(2025, 3, 1, 9, 30, 15, 250, TimeSpan.Zero), post.PublishedAt, "Data esatta dal giornale di Febe.");
|
|
Assert.AreEqual("3100000000000000002", (await bed.Library.Db.Media.ListByEntryAsync(post.Id)).Single().InstagramId);
|
|
Assert.IsTrue(await bed.Library.Db.Entries.IsKnownAsync(marta.Id, EntryKind.Post, "3100000000000000001"), "Quando terrà aggiornato l'account non lo riscaricherà.");
|
|
|
|
var highlight = (await bed.Library.Db.Entries.FindAsync(marta.Id, EntryKind.Highlight, "3391207"))!;
|
|
var collections = await bed.Library.Db.Highlights.ListForEntryAsync(highlight.Id);
|
|
Assert.AreEqual("Estate 2025", collections.Single().Title);
|
|
Assert.AreEqual("evidenza/Estate 2025/2025-08-02_10-11-12_3391207_1.jpg", (await bed.Library.Db.Media.ListByEntryAsync(highlight.Id)).Single().RelativePath);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task TheCsvHasOneRowPerFileSemicolonsAndABom()
|
|
{
|
|
using var temp = new TempFolder("importa");
|
|
await using var bed = await ImportTestBed.CreateAsync(temp);
|
|
await bed.Library.Db.Accounts.AddAsync(Make.Account("marta.demo"));
|
|
bed.Write("marta.demo/uno;due.jpg", ImportTestFiles.Photo(110));
|
|
bed.Write("marta.demo/=SOMMA(1).jpg", ImportTestFiles.Photo(111));
|
|
bed.Write("marta.demo/nota.txt", "testo"u8.ToArray());
|
|
var run = await bed.AnalyzeAsync();
|
|
await bed.Copier.CopyAsync(run.Id);
|
|
|
|
using var output = new MemoryStream();
|
|
await bed.Reports.WriteCsvAsync(run.Id, output);
|
|
var bytes = output.ToArray();
|
|
|
|
CollectionAssert.AreEqual(new byte[] { 0xEF, 0xBB, 0xBF }, bytes[..3], "UTF-8 con BOM, per Excel in italiano.");
|
|
var text = System.Text.Encoding.UTF8.GetString(bytes, 3, bytes.Length - 3);
|
|
var lines = text.Split("\r\n", StringSplitOptions.RemoveEmptyEntries);
|
|
Assert.HasCount(4, lines, "Intestazione e una riga per file.");
|
|
Assert.AreEqual("File;Cartella;Esito;Stato;Account di destinazione;Tipo;Data;Origine della data;Formato;Byte;Larghezza;Altezza;Durata (s);SHA-256;Codice;Identificativo Instagram;Già in libreria;Destinazione;Nota", lines[0]);
|
|
Assert.IsTrue(lines.Any(l => l.StartsWith("\"marta.demo/uno;due.jpg\";marta.demo;Nuovo;Copiato;marta.demo;", StringComparison.Ordinal)), "Un campo con «;» va tra virgolette.");
|
|
Assert.IsTrue(lines.Any(l => l.StartsWith("marta.demo/=SOMMA(1).jpg;", StringComparison.Ordinal)), "Il percorso comincia con la cartella: nessuna formula.");
|
|
Assert.IsTrue(lines.Any(l => l.Contains(";Non riconosciuto;Saltato;", StringComparison.Ordinal)));
|
|
Assert.AreEqual("'=SOMMA(1)", ImportReports.Field("=SOMMA(1)"), "Un testo che Excel prenderebbe per una formula.");
|
|
Assert.AreEqual("\"a \"\"b\"\"\"", ImportReports.Field("a \"b\""));
|
|
Assert.AreEqual($"importazione-2026-10-13-{run.Id}.csv", bed.Reports.CsvFileName(run));
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task TheReportCountsEveryOutcome()
|
|
{
|
|
using var temp = new TempFolder("importa");
|
|
await using var bed = await ImportTestBed.CreateAsync(temp);
|
|
var photo = ImportTestFiles.Photo(120);
|
|
await bed.AccountWithPhotoAsync("luca.demo", "120", photo);
|
|
await bed.Library.Db.Accounts.AddAsync(Make.Account("marta.demo"));
|
|
bed.Write("marta.demo/gia.jpg", photo);
|
|
bed.Write("marta.demo/nuova.jpg", ImportTestFiles.Photo(121));
|
|
bed.Write("marta.demo/copia/nuova.jpg", ImportTestFiles.Photo(121));
|
|
bed.Write("marta.demo/documento.pdf", "%PDF-1.7\n"u8.ToArray());
|
|
var run = await bed.AnalyzeAsync();
|
|
await bed.Copier.CopyAsync(run.Id);
|
|
|
|
var report = await bed.Reports.GetReportAsync(run.Id);
|
|
|
|
Assert.AreEqual(4, report.Files);
|
|
Assert.AreEqual(1, report.ByOutcome[ImportOutcome.AlreadyInLibrary]);
|
|
Assert.AreEqual(1, report.ByOutcome[ImportOutcome.IdenticalInSource]);
|
|
Assert.AreEqual(1, report.Copied);
|
|
Assert.AreEqual(3, report.Skipped, "Già in libreria, copia identica e non riconosciuto.");
|
|
Assert.AreEqual("luca.demo", report.AlreadyInLibraryByAccount.Single().Username);
|
|
Assert.AreEqual("marta.demo", report.ImportedByAccount.Single().Username);
|
|
CollectionAssert.AreEqual(new[] { "marta.demo/documento.pdf" }, report.Unrecognized.ToArray());
|
|
}
|
|
|
|
private sealed class SyncProgress(Action<ImportProgress> report) : IProgress<ImportProgress>
|
|
{
|
|
public void Report(ImportProgress value) => report(value);
|
|
}
|
|
}
|