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(() => 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(() => 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(() => 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 report) : IProgress { public void Report(ImportProgress value) => report(value); } }