Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Mzbb6zeFTjT6Rp8b92AVkA
280 lines
16 KiB
C#
280 lines
16 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 ImportAnalysisTests
|
|
{
|
|
[TestMethod]
|
|
public async Task AGeneratedSourceTreeIsAnalysedWithoutTouchingIt()
|
|
{
|
|
using var temp = new TempFolder("importa");
|
|
await using var bed = await ImportTestBed.CreateAsync(temp);
|
|
var named = bed.Write("marta.demo/IMG_20210506_070809.jpg", ImportTestFiles.Photo(1));
|
|
bed.Write("marta.demo/storie/foto-exif.jpg", ImportTestFiles.PhotoWithExifDate(2, new DateTime(2020, 2, 3, 10, 0, 0)));
|
|
bed.Write("marta.demo/storie/video.mp4", ImportTestFiles.Mp4(new DateTimeOffset(2022, 7, 1, 18, 30, 0, TimeSpan.Zero), 1080, 1920, 15_000, payloadSeed: 7));
|
|
bed.Write("marta.demo/vecchia.jpg", ImportTestFiles.Photo(3), new DateTime(2019, 1, 2, 3, 4, 5, DateTimeKind.Utc));
|
|
bed.Write("marta.demo/note.txt", "Appunti, non una foto."u8.ToArray());
|
|
bed.Write("marta.demo/travestita.png", ImportTestFiles.Photo(4, 320, 240));
|
|
bed.Write("Foto sparse/a.jpg", ImportTestFiles.Photo(5));
|
|
bed.Write("marta.demo/Thumbs.db", [1, 2, 3]);
|
|
var realVideo = Path.Combine(bed.Source, "marta.demo", "storie", "ffmpeg.mp4");
|
|
var withFfmpeg = ImportTestFiles.TryMakeMp4WithFfmpeg(realVideo, new DateTimeOffset(2021, 3, 4, 5, 6, 7, TimeSpan.Zero));
|
|
var before = bed.Fingerprint();
|
|
|
|
var run = await bed.AnalyzeAsync();
|
|
|
|
Assert.AreEqual(ImportRunState.Reviewing, run.State);
|
|
Assert.IsNotNull(run.AnalyzedAt);
|
|
CollectionAssert.AreEqual(before.ToList(), bed.Fingerprint().ToList(), "L'analisi è in sola lettura: nessun file della sorgente cambia.");
|
|
var files = (await bed.FilesAsync(run.Id)).Where(f => !f.RelativePath.EndsWith("ffmpeg.mp4", StringComparison.Ordinal)).ToList();
|
|
Assert.HasCount(7, files, "Thumbs.db non è un contenuto e non si elenca.");
|
|
if (withFfmpeg)
|
|
{
|
|
var real = await bed.FileAsync(run.Id, "marta.demo/storie/ffmpeg.mp4");
|
|
Assert.AreEqual("video/mp4", real.ContentType);
|
|
Assert.AreEqual(new DateTimeOffset(2021, 3, 4, 5, 6, 7, TimeSpan.Zero), real.TakenAt, "Data di creazione del video, dal suo mvhd.");
|
|
Assert.AreEqual(ImportDateSource.Metadata, real.DateSource);
|
|
Assert.AreEqual((64, 48), (real.Width, real.Height));
|
|
}
|
|
|
|
Assert.IsTrue(files.All(f => f.State == ImportFileState.Analyzed));
|
|
|
|
var byName = await bed.FileAsync(run.Id, "marta.demo/IMG_20210506_070809.jpg");
|
|
Assert.AreEqual(ImportOutcome.New, byName.Outcome);
|
|
Assert.AreEqual(MediaKind.Photo, byName.MediaKind);
|
|
Assert.AreEqual("image/jpeg", byName.ContentType);
|
|
Assert.AreEqual((800, 600), (byName.Width, byName.Height));
|
|
Assert.AreEqual(Convert.ToHexStringLower(SHA256.HashData(File.ReadAllBytes(named))), byName.Sha256);
|
|
Assert.AreEqual(new FileInfo(named).Length, byName.Bytes);
|
|
Assert.IsNotNull(byName.PerceptualHash);
|
|
Assert.AreEqual(ImportDateSource.FileName, byName.DateSource);
|
|
Assert.AreEqual(new DateTimeOffset(2021, 5, 6, 5, 8, 9, TimeSpan.Zero), byName.TakenAt);
|
|
Assert.AreEqual("marta.demo", byName.Folder);
|
|
Assert.AreEqual("marta.demo", byName.ProbableAccount);
|
|
Assert.IsNull(byName.ProbableKind);
|
|
|
|
var exif = await bed.FileAsync(run.Id, "marta.demo/storie/foto-exif.jpg");
|
|
Assert.AreEqual(ImportDateSource.Metadata, exif.DateSource);
|
|
Assert.AreEqual(new DateTimeOffset(2020, 2, 3, 9, 0, 0, TimeSpan.Zero), exif.TakenAt);
|
|
Assert.AreEqual(EntryKind.Story, exif.ProbableKind);
|
|
|
|
var video = await bed.FileAsync(run.Id, "marta.demo/storie/video.mp4");
|
|
Assert.AreEqual(MediaKind.Video, video.MediaKind);
|
|
Assert.AreEqual(ImportDateSource.Metadata, video.DateSource);
|
|
Assert.AreEqual(new DateTimeOffset(2022, 7, 1, 18, 30, 0, TimeSpan.Zero), video.TakenAt);
|
|
Assert.AreEqual(TimeSpan.FromSeconds(15), video.Duration);
|
|
Assert.AreEqual((1080, 1920), (video.Width, video.Height));
|
|
Assert.IsNull(video.PerceptualHash, "I video non hanno impronta visiva.");
|
|
|
|
var old = await bed.FileAsync(run.Id, "marta.demo/vecchia.jpg");
|
|
Assert.AreEqual(ImportDateSource.ModifiedTime, old.DateSource);
|
|
Assert.AreEqual(new DateTimeOffset(2019, 1, 2, 3, 4, 5, TimeSpan.Zero), old.TakenAt);
|
|
|
|
Assert.AreEqual(ImportOutcome.Unrecognized, (await bed.FileAsync(run.Id, "marta.demo/note.txt")).Outcome);
|
|
Assert.AreEqual("image/jpeg", (await bed.FileAsync(run.Id, "marta.demo/travestita.png")).ContentType, "Il tipo viene dal contenuto.");
|
|
|
|
var loose = await bed.FileAsync(run.Id, "Foto sparse/a.jpg");
|
|
Assert.AreEqual("Foto sparse", loose.Folder);
|
|
Assert.IsNull(loose.ProbableAccount, "«Foto sparse» non può essere un nome utente.");
|
|
|
|
var summary = await bed.Review.GetSummaryAsync(run.Id);
|
|
Assert.AreEqual(withFfmpeg ? 8 : 7, summary.Files);
|
|
Assert.AreEqual(withFfmpeg ? 7 : 6, summary.ByOutcome[ImportOutcome.New]);
|
|
Assert.AreEqual(1, summary.ByOutcome[ImportOutcome.Unrecognized]);
|
|
var marta = summary.Folders.Single(f => f.Folder == "marta.demo");
|
|
Assert.AreEqual(FolderTargetKind.NewArchiveAccount, marta.Target.Kind, "Un nome valido senza account: nuovo account, solo archivio.");
|
|
Assert.AreEqual("marta.demo", marta.Target.Username);
|
|
Assert.AreEqual(FolderTargetKind.None, summary.Folders.Single(f => f.Folder == "Foto sparse").Target.Kind, "Nessun nome riconosciuto: nessuna scelta fatta.");
|
|
Assert.IsTrue(summary.CanMove);
|
|
StringAssert.StartsWith(summary.Headline, withFfmpeg ? "8 file, " : "7 file, ");
|
|
StringAssert.EndsWith(summary.Headline, "Nessun file è stato ancora copiato.");
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task AnInterruptedAnalysisResumesWhereItStopped()
|
|
{
|
|
using var temp = new TempFolder("importa");
|
|
await using var bed = await ImportTestBed.CreateAsync(temp);
|
|
var twin = ImportTestFiles.Png(1000, 48, 36);
|
|
for (var i = 0; i < 100; i++)
|
|
{
|
|
bed.Write($"luca.demo/f{i:000}.png", i == 90 ? twin : ImportTestFiles.Png(1000 + i, 48, 36));
|
|
}
|
|
|
|
var info = bed.Environment.CreateSources().Inspect(bed.Source);
|
|
var run = await bed.Analyzer.CreateRunAsync(info);
|
|
using var stop = new CancellationTokenSource();
|
|
var progress = new SyncProgress(p =>
|
|
{
|
|
if (p.Phase == ImportPhase.Analyzing && p.FilesDone >= 64)
|
|
{
|
|
stop.Cancel();
|
|
}
|
|
});
|
|
|
|
await Assert.ThrowsAsync<OperationCanceledException>(() => bed.Analyzer.AnalyzeAsync(run.Id, progress, stop.Token));
|
|
var interrupted = await bed.Library.Db.Imports.GetRunAsync(run.Id);
|
|
Assert.AreEqual(ImportRunState.AnalysisInterrupted, interrupted!.State);
|
|
Assert.IsNull(interrupted.LastError, "Un'interruzione non è un errore.");
|
|
var halfway = await bed.FilesAsync(run.Id);
|
|
var analysed = halfway.Count(f => f.State == ImportFileState.Analyzed);
|
|
Assert.AreEqual(64, analysed, "Il primo gruppo di file è salvato con il suo esito.");
|
|
Assert.AreEqual(36, halfway.Count(f => f.State == ImportFileState.Pending));
|
|
|
|
var resumed = await bed.Analyzer.AnalyzeAsync(run.Id);
|
|
|
|
Assert.AreEqual(ImportRunState.Reviewing, resumed.State);
|
|
var files = await bed.FilesAsync(run.Id);
|
|
Assert.HasCount(100, files, "Nessun file elencato due volte.");
|
|
Assert.IsTrue(files.All(f => f.State == ImportFileState.Analyzed && f.Outcome != ImportOutcome.Pending), "Un esito per ogni file.");
|
|
Assert.AreEqual(ImportOutcome.IdenticalInSource, files.Single(f => f.RelativePath == "luca.demo/f090.png").Outcome, "La copia identica è riconosciuta anche dopo la ripresa.");
|
|
Assert.AreEqual(99, files.Count(f => f.Outcome == ImportOutcome.New));
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task SameBytesAreAlreadyInTheLibraryAndTheReportSaysWhere()
|
|
{
|
|
using var temp = new TempFolder("importa");
|
|
await using var bed = await ImportTestBed.CreateAsync(temp);
|
|
var photo = ImportTestFiles.Photo(20);
|
|
var (luca, saved) = await bed.AccountWithPhotoAsync("luca.demo", "500", photo);
|
|
var (marta, savedMarta) = await bed.AccountWithPhotoAsync("marta.demo", "600", ImportTestFiles.Photo(21));
|
|
bed.Write("marta.demo/copia.jpg", photo);
|
|
bed.Write("marta.demo/anche-questa.jpg", ImportTestFiles.Photo(21));
|
|
|
|
var run = await bed.AnalyzeAsync();
|
|
|
|
var copy = await bed.FileAsync(run.Id, "marta.demo/copia.jpg");
|
|
Assert.AreEqual(ImportOutcome.AlreadyInLibrary, copy.Outcome);
|
|
Assert.AreEqual(saved.Media[0].Id, copy.MatchedMediaId);
|
|
var rows = await bed.Library.Db.Imports.ListReportRowsAsync(run.Id);
|
|
Assert.AreEqual("luca.demo", rows.Single(r => r.File.Id == copy.Id).MatchedUsername, "Il resoconto dice in quale account si trova.");
|
|
Assert.AreEqual(savedMarta.Media[0].Id, (await bed.FileAsync(run.Id, "marta.demo/anche-questa.jpg")).MatchedMediaId);
|
|
Assert.AreEqual(marta.Id, (await bed.Review.ListFoldersAsync(run.Id)).Single().Target.AccountId, "La cartella va all'account con lo stesso nome.");
|
|
Assert.AreEqual(0, await bed.Library.Db.Duplicates.CountPendingAsync(DuplicateOrigin.Import));
|
|
_ = luca;
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task TheDestinationAccountIsSearchedFirst()
|
|
{
|
|
using var temp = new TempFolder("importa");
|
|
await using var bed = await ImportTestBed.CreateAsync(temp);
|
|
var photo = ImportTestFiles.Photo(22);
|
|
await bed.AccountWithPhotoAsync("luca.demo", "700", photo);
|
|
var (_, inMarta) = await bed.AccountWithPhotoAsync("marta.demo", "701", photo);
|
|
bed.Write("marta.demo/x.jpg", photo);
|
|
|
|
var run = await bed.AnalyzeAsync();
|
|
|
|
Assert.AreEqual(inMarta.Media[0].Id, (await bed.FileAsync(run.Id, "marta.demo/x.jpg")).MatchedMediaId);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task SameIdentifierWithADifferentFileIsAProbableDuplicate()
|
|
{
|
|
using var temp = new TempFolder("importa");
|
|
await using var bed = await ImportTestBed.CreateAsync(temp);
|
|
var account = await bed.Library.Db.Accounts.AddAsync(Make.Account("marta.demo"));
|
|
var story = Make.Entry(account.Id, "3742118", new DateTimeOffset(2026, 10, 13, 7, 41, 7, TimeSpan.Zero), EntryKind.Story);
|
|
var saved = await bed.Library.SaveAsync(account, story, [new TestFile(Make.Photo(1), ImportTestFiles.Photo(30), ".jpg")]);
|
|
bed.Write("marta.demo/storie/2026/2026-10-13_09-41-07_3742118_1.jpg", ImportTestFiles.Photo(31));
|
|
|
|
var run = await bed.AnalyzeAsync();
|
|
|
|
var file = (await bed.FilesAsync(run.Id)).Single();
|
|
Assert.AreEqual(ImportOutcome.ProbableDuplicate, file.Outcome);
|
|
Assert.AreEqual("3742118", file.InstagramId);
|
|
var pair = (await bed.Library.Db.Duplicates.ListPendingAsync(DuplicateOrigin.Import)).Single();
|
|
Assert.AreEqual(DuplicateReason.SameInstagramId, pair.Reason);
|
|
Assert.AreEqual(saved.Media[0].Id, pair.ExistingMediaId);
|
|
Assert.AreEqual(file.Id, pair.CandidateImportFileId);
|
|
Assert.AreEqual(DuplicateDecision.Pending, pair.Decision, "Nessuna scelta è fatta in partenza.");
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task AResizedCopyIsAProbableDuplicateAndACropIsNot()
|
|
{
|
|
using var temp = new TempFolder("importa");
|
|
await using var bed = await ImportTestBed.CreateAsync(temp);
|
|
var (_, saved) = await bed.AccountWithPhotoAsync("marta.demo", "800", ImportTestFiles.Photo(40, 800, 600, 92));
|
|
bed.Write("marta.demo/piccola.jpg", ImportTestFiles.Resized(40, 800, 600, 400, 300, 55));
|
|
bed.Write("marta.demo/ritaglio.jpg", ImportTestFiles.Cropped(40, 800, 600));
|
|
bed.Write("marta.demo/altra.jpg", ImportTestFiles.Photo(41));
|
|
|
|
var run = await bed.AnalyzeAsync();
|
|
|
|
var resized = await bed.FileAsync(run.Id, "marta.demo/piccola.jpg");
|
|
Assert.AreEqual(ImportOutcome.ProbableDuplicate, resized.Outcome);
|
|
var pair = (await bed.Review.ListDuplicatesAsync(run.Id)).Single();
|
|
Assert.AreEqual(DuplicateReason.VisuallySimilar, pair.Pair.Reason);
|
|
Assert.AreEqual(saved.Media[0].Id, pair.Existing.MediaId);
|
|
Assert.IsTrue(pair.Existing.InLibrary);
|
|
Assert.AreEqual("marta.demo", pair.Existing.Username);
|
|
Assert.AreEqual(resized.Id, pair.Candidate.ImportFileId);
|
|
Assert.IsFalse(pair.CandidateIsLarger, "Quella in libreria ha più pixel.");
|
|
Assert.IsTrue(pair.Pair.Distance <= PerceptualHash.DuplicateThreshold);
|
|
|
|
Assert.AreEqual(ImportOutcome.New, (await bed.FileAsync(run.Id, "marta.demo/ritaglio.jpg")).Outcome, "Un ritaglio non è un doppione.");
|
|
Assert.AreEqual(ImportOutcome.New, (await bed.FileAsync(run.Id, "marta.demo/altra.jpg")).Outcome);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task DuplicatesAreLookedForInsideTheSourceToo()
|
|
{
|
|
using var temp = new TempFolder("importa");
|
|
await using var bed = await ImportTestBed.CreateAsync(temp);
|
|
var photo = ImportTestFiles.Photo(50, 800, 600, 92);
|
|
bed.Write("marta.demo/a.jpg", photo);
|
|
bed.Write("marta.demo/backup/a.jpg", photo);
|
|
bed.Write("marta.demo/b-grande.jpg", ImportTestFiles.Photo(51, 800, 600, 92));
|
|
bed.Write("marta.demo/c-piccola.jpg", ImportTestFiles.Resized(51, 800, 600, 400, 300, 55));
|
|
bed.Write("marta.demo/d-video.mp4", ImportTestFiles.Mp4(null, payloadSeed: 3));
|
|
bed.Write("marta.demo/e-video.mp4", ImportTestFiles.Mp4(null, payloadSeed: 4));
|
|
|
|
var run = await bed.AnalyzeAsync();
|
|
|
|
Assert.AreEqual(ImportOutcome.New, (await bed.FileAsync(run.Id, "marta.demo/a.jpg")).Outcome);
|
|
var copy = await bed.FileAsync(run.Id, "marta.demo/backup/a.jpg");
|
|
Assert.AreEqual(ImportOutcome.IdenticalInSource, copy.Outcome);
|
|
StringAssert.Contains(copy.LastError, "marta.demo/a.jpg");
|
|
var large = await bed.FileAsync(run.Id, "marta.demo/b-grande.jpg");
|
|
var small = await bed.FileAsync(run.Id, "marta.demo/c-piccola.jpg");
|
|
Assert.AreEqual(ImportOutcome.New, large.Outcome);
|
|
Assert.AreEqual(ImportOutcome.ProbableDuplicate, small.Outcome);
|
|
var pair = (await bed.Review.ListDuplicatesAsync(run.Id)).Single();
|
|
Assert.IsTrue(pair.InsideSource);
|
|
Assert.AreEqual(large.Id, pair.Existing.ImportFileId);
|
|
Assert.AreEqual(small.Id, pair.Candidate.ImportFileId);
|
|
Assert.AreEqual(ImportOutcome.New, (await bed.FileAsync(run.Id, "marta.demo/e-video.mp4")).Outcome, "Per i video vale solo lo SHA-256.");
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task AFileAlbertoDeletedIsNotBroughtBack()
|
|
{
|
|
using var temp = new TempFolder("importa");
|
|
await using var bed = await ImportTestBed.CreateAsync(temp);
|
|
var photo = ImportTestFiles.Photo(60);
|
|
var (_, saved) = await bed.AccountWithPhotoAsync("marta.demo", "900", photo);
|
|
await new LibraryDeletion(bed.Library.Db, bed.Library.Layout, bed.Library.Journal, bed.Library.Clock).DeleteAsync(saved.Entry.Id);
|
|
bed.Write("marta.demo/eliminata.jpg", photo);
|
|
|
|
var run = await bed.AnalyzeAsync();
|
|
|
|
var file = (await bed.FilesAsync(run.Id)).Single();
|
|
Assert.AreEqual(ImportOutcome.AlreadyInLibrary, file.Outcome);
|
|
StringAssert.Contains(file.LastError, "eliminato");
|
|
}
|
|
|
|
private sealed class SyncProgress(Action<ImportProgress> report) : IProgress<ImportProgress>
|
|
{
|
|
public void Report(ImportProgress value) => report(value);
|
|
}
|
|
}
|