Files

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