Files
Claude 3aeaa17da7 M1 Dati e libreria: modello, archivi SQLite con scrittore unico, nomi dei file, scrittura sicura, miniature, impronte, _febe.jsonl, copie, eliminazione e ricostruzione
Modello del dominio e interfacce degli archivi in Febe.Core; implementazione SQLite in Febe.Data (WAL, chiavi esterne, migrazioni numerate in transazione, coda di scrittura su un solo thread); logica della libreria in Febe.Core/Library; 164 prove MSTest, compresa la ricostruzione del database da una libreria di prova e la scala a 200.000 elementi.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Claude-Session: https://claude.ai/code/session_01Mzbb6zeFTjT6Rp8b92AVkA
2026-10-13 16:06:15 +00:00

301 lines
19 KiB
C#

using Febe.Core.Domain;
using Febe.Core.Storage;
using Febe.Data;
using Febe.Tests.Support;
namespace Febe.Tests.Data;
[TestClass]
public sealed class EntryStoreTests
{
[TestMethod]
public async Task KnownIdentifiersIncludeDeletedEntries()
{
using var temp = new TempFolder();
await using var db = await TestDatabase.OpenAsync(temp);
var account = await db.Accounts.AddAsync(Make.Account("marta.demo"));
var kept = await db.Entries.AddAsync(Make.Entry(account.Id, "1", Make.T0), [Make.Photo()]);
var deleted = await db.Entries.AddAsync(Make.Entry(account.Id, "2", Make.T0), [Make.Stored(Make.Photo(), Make.Sha(2), "post/x.jpg")]);
var removed = await db.Entries.AddAsync(Make.Entry(account.Id, "3", Make.T0), [Make.Photo()]);
await db.Entries.MarkDeletedAsync(deleted.Stored.Entry.Id, Make.T0.AddDays(1));
await db.Entries.RemoveAsync(removed.Stored.Entry.Id);
Assert.IsTrue(await db.Entries.IsKnownAsync(account.Id, EntryKind.Post, "1"));
Assert.IsTrue(await db.Entries.IsKnownAsync(account.Id, EntryKind.Post, "2"), "Un elemento eliminato resta noto e non si riscarica.");
Assert.IsFalse(await db.Entries.IsKnownAsync(account.Id, EntryKind.Post, "3"), "«Lascia che torni» toglie il record.");
Assert.IsFalse(await db.Entries.IsKnownAsync(account.Id, EntryKind.Story, "1"));
var known = await db.Entries.GetKnownInstagramIdsAsync(account.Id, EntryKind.Post, ["1", "2", "3", "4", " 1 "]);
Assert.IsTrue(known.SetEquals(["1", "2"]));
var deletedRead = (await db.Entries.GetWithMediaAsync(deleted.Stored.Entry.Id))!;
Assert.AreEqual(EntryState.Deleted, deletedRead.Entry.State);
Assert.AreEqual(Make.T0.AddDays(1), deletedRead.Entry.DeletedAt);
Assert.AreEqual(MediaState.Deleted, deletedRead.Media[0].State);
Assert.IsNull(deletedRead.Media[0].RelativePath);
Assert.AreEqual(Make.Sha(2), deletedRead.Media[0].Sha256);
Assert.AreEqual(kept.Stored.Entry.Id, (await db.Entries.FindAsync(account.Id, EntryKind.Post, "1"))!.Id);
}
[TestMethod]
public async Task FindsEntriesByIdentifierAcrossKindsAndByPublicationTime()
{
using var temp = new TempFolder();
await using var db = await TestDatabase.OpenAsync(temp);
var account = await db.Accounts.AddAsync(Make.Account("marta.demo"));
await db.Entries.AddAsync(Make.Entry(account.Id, "77", Make.T0, EntryKind.Story), [Make.Photo()]);
await db.Entries.AddAsync(Make.Entry(account.Id, "77", Make.T0, EntryKind.Highlight), [Make.Photo()]);
var imported = await db.Entries.AddAsync(
Make.Entry(account.Id, "x", Make.T0.AddMinutes(30)) with { InstagramId = null, Provenance = Provenance.Imported },
[Make.Photo(1, MediaState.Imported) with { Sha256 = Make.Sha(9), RelativePath = "importati/a.jpg" }]);
Assert.HasCount(2, await db.Entries.FindByInstagramIdAsync(account.Id, "77"));
Assert.AreEqual(EntryState.Imported, imported.Stored.Entry.State);
var match = await db.Entries.FindByPublicationTimeAsync(account.Id, EntryKind.Post, Make.T0.AddMinutes(30).AddMilliseconds(1500), TimeSpan.FromSeconds(2));
Assert.AreEqual(imported.Stored.Entry.Id, match?.Id);
Assert.IsNull(await db.Entries.FindByPublicationTimeAsync(account.Id, EntryKind.Post, Make.T0.AddMinutes(30).AddSeconds(3), TimeSpan.FromSeconds(2)));
// Recognized later: Instagram data is added to the existing entry (spec §9.5).
await db.Entries.UpdateAsync(imported.Stored.Entry with { InstagramId = "888", Code = "Abc", Caption = "Ritrovata" });
Assert.IsTrue(await db.Entries.IsKnownAsync(account.Id, EntryKind.Post, "888"));
}
[TestMethod]
public async Task StateFollowsTheFiles()
{
using var temp = new TempFolder();
await using var db = await TestDatabase.OpenAsync(temp);
var account = await db.Accounts.AddAsync(Make.Account("marta.demo"));
var added = await db.Entries.AddAsync(Make.Entry(account.Id, "1", Make.T0), [Make.Photo(1), Make.Video(2)]);
var photo = added.Stored.Media[0];
var video = added.Stored.Media[1];
Assert.AreEqual(EntryState.ToDownload, added.Stored.Entry.State);
await db.Media.MarkStoredAsync(photo.Id, new StoredFile("post/2026/a_1.jpg", 1234, Make.Sha(1), 0xABCDEFUL, 1080, 1350, null, true), MediaState.Downloaded, Make.T0.AddMinutes(1));
Assert.AreEqual(EntryState.Partial, (await db.Entries.GetAsync(added.Stored.Entry.Id))!.State);
await db.Media.MarkFailedAsync(video.Id, MediaState.Expired, "Indirizzo scaduto", Make.T0.AddMinutes(2));
var afterExpiry = (await db.Entries.GetWithMediaAsync(added.Stored.Entry.Id))!;
Assert.AreEqual(EntryState.Partial, afterExpiry.Entry.State);
Assert.AreEqual(1, afterExpiry.Media[1].Attempts);
await db.Media.UpdateSourceAsync(video.Id, "https://cdn.example/v.mp4", null, Make.T0.AddMinutes(3));
Assert.AreEqual(MediaState.ToDownload, (await db.Media.GetAsync(video.Id))!.State);
await db.Media.MarkStoredAsync(video.Id, new StoredFile("post/2026/a_2.mp4", 99, Make.Sha(2), Duration: TimeSpan.FromSeconds(12)), MediaState.Downloaded, Make.T0.AddMinutes(4));
var done = (await db.Entries.GetWithMediaAsync(added.Stored.Entry.Id))!;
Assert.AreEqual(EntryState.Downloaded, done.Entry.State);
Assert.AreEqual(Make.T0.AddMinutes(4), done.Entry.DownloadedAt);
Assert.IsNull(done.Media[1].SourceUrl, "L'indirizzo firmato non resta nel database dopo lo scaricamento.");
Assert.AreEqual(0xABCDEFUL, done.Media[0].PerceptualHash);
Assert.AreEqual(TimeSpan.FromSeconds(12), done.Media[1].Duration);
Assert.AreEqual(EntryState.Skipped, EntryStateRules.FromMedia(EntryState.ToDownload, Provenance.Downloaded, [MediaState.Skipped]));
Assert.AreEqual(EntryState.Failed, EntryStateRules.FromMedia(EntryState.ToDownload, Provenance.Downloaded, [MediaState.Failed, MediaState.Skipped]));
Assert.AreEqual(EntryState.Deleted, EntryStateRules.FromMedia(EntryState.Deleted, Provenance.Downloaded, [MediaState.Downloaded]));
}
[TestMethod]
public async Task ExactDuplicatesAreFoundAcrossTheLibrary()
{
using var temp = new TempFolder();
await using var db = await TestDatabase.OpenAsync(temp);
var marta = await db.Accounts.AddAsync(Make.Account("marta.demo"));
var luca = await db.Accounts.AddAsync(Make.Account("luca.demo"));
await db.Entries.AddAsync(Make.Entry(marta.Id, "1", Make.T0), [Make.Stored(Make.Photo(), Make.Sha(7), "post/a.jpg") with { PerceptualHash = 5 }]);
await db.Entries.AddAsync(Make.Entry(luca.Id, "1", Make.T0, EntryKind.Tagged), [Make.Stored(Make.Photo(), Make.Sha(7).ToUpperInvariant(), "taggati/a.jpg")]);
await db.Entries.AddAsync(Make.Entry(luca.Id, "2", Make.T0), [Make.Stored(Make.Photo(), Make.Sha(8), "post/b.jpg") with { PerceptualHash = 6 }]);
var found = await db.Media.FindBySha256Async(Make.Sha(7).ToUpperInvariant());
Assert.HasCount(2, found);
Assert.IsTrue(found.Select(f => f.Username).Order().SequenceEqual(["luca.demo", "marta.demo"]));
var hashes = await db.Media.LoadPerceptualHashesAsync();
Assert.HasCount(2, hashes);
Assert.Contains(new PerceptualHashRecord(found.Single(f => f.Username == "marta.demo").Media.Id, marta.Id, 5), hashes);
}
[TestMethod]
public async Task DownloadQueueGivesStoriesPrecedence()
{
using var temp = new TempFolder();
await using var db = await TestDatabase.OpenAsync(temp);
var a = await db.Accounts.AddAsync(Make.Account("marta.demo"));
var b = await db.Accounts.AddAsync(Make.Account("luca.demo"));
await db.Entries.AddAsync(Make.Entry(a.Id, "post", Make.T0), [Make.Photo(1), Make.Photo(2)]);
await db.Entries.AddAsync(Make.Entry(b.Id, "storia-tardi", Make.T0, EntryKind.Story) with { ExpiresAt = Make.T0.AddHours(20) }, [Make.Video()]);
await db.Entries.AddAsync(Make.Entry(b.Id, "storia-presto", Make.T0, EntryKind.Story) with { ExpiresAt = Make.T0.AddHours(2) }, [Make.Video()]);
var gone = await db.Entries.AddAsync(Make.Entry(a.Id, "eliminato", Make.T0), [Make.Photo()]);
await db.Entries.MarkDeletedAsync(gone.Stored.Entry.Id, Make.T0);
var queue = await db.Media.ListPendingDownloadsAsync(10);
Assert.HasCount(4, queue);
Assert.AreEqual(EntryKind.Story, queue[0].Kind);
Assert.AreEqual(Make.T0.AddHours(2), queue[0].ExpiresAt);
Assert.AreEqual(EntryKind.Story, queue[1].Kind);
Assert.AreEqual(1, queue[2].Media.Position);
Assert.AreEqual(2, queue[3].Media.Position);
Assert.AreEqual(2, await db.Media.CountPendingDownloadsAsync(a.Id));
Assert.AreEqual(4, await db.Media.CountPendingDownloadsAsync());
}
[TestMethod]
public async Task LibraryPagesWithKeysetInBothDirections()
{
using var temp = new TempFolder();
await using var db = await TestDatabase.OpenAsync(temp);
var account = await db.Accounts.AddAsync(Make.Account("marta.demo"));
var items = Enumerable.Range(0, 25)
.Select(i => new NewEntry(Make.Entry(account.Id, $"e{i}", Make.T0.AddMinutes(i % 10 == 0 ? 0 : i)), [Make.Stored(Make.Photo(), Make.Sha(i + 1), $"post/{i}.jpg")]))
.ToList();
await db.Entries.AddManyAsync(items);
var seen = new List<long>();
var page = await db.Entries.QueryLibraryAsync(new LibraryQuery { Limit = 7 });
Assert.IsNull(page.Newer);
while (true)
{
seen.AddRange(page.Tiles.Select(t => t.EntryId));
if (page.Older is not { } older)
{
break;
}
page = await db.Entries.QueryLibraryAsync(new LibraryQuery { Limit = 7, Cursor = older });
Assert.IsNotNull(page.Newer);
}
Assert.HasCount(25, seen);
Assert.AreEqual(25, seen.Distinct().Count());
var all = await db.Entries.ListByAccountAsync(account.Id, new EntryListOptions { Limit = 100 });
Assert.IsTrue(all.Select(e => e.Id).SequenceEqual(seen), "Stesso ordine: data di pubblicazione decrescente, poi chiave.");
// Going back up from the middle returns the newer window, still in display order.
var middle = new LibraryCursor(all[12].PublishedAt, all[12].Id);
var newer = await db.Entries.QueryLibraryAsync(new LibraryQuery { Limit = 5, Cursor = middle, Direction = LibraryDirection.Newer });
Assert.IsTrue(newer.Tiles.Select(t => t.EntryId).SequenceEqual(all.Skip(7).Take(5).Select(e => e.Id)));
Assert.IsNotNull(newer.Newer);
Assert.IsNotNull(newer.Older);
var jump = await db.Entries.QueryLibraryAsync(new LibraryQuery { Limit = 3, Cursor = LibraryCursor.At(Make.T0.AddMinutes(5)) });
Assert.IsTrue(jump.Tiles.All(t => t.PublishedAt <= Make.T0.AddMinutes(5)));
}
[TestMethod]
public async Task LibraryFiltersByKindAccountPeriodProvenanceAndSearch()
{
using var temp = new TempFolder();
await using var db = await TestDatabase.OpenAsync(temp);
var marta = await db.Accounts.AddAsync(Make.Account("marta.demo") with { DisplayName = "Marta Bianchi" });
var luca = await db.Accounts.AddAsync(Make.Account("luca.viaggi.demo"));
var photoPost = await Add(db, marta.Id, "foto", EntryKind.Post, Make.T0, "Perché no? Tramonto a Genova", Make.Photo());
var videoPost = await Add(db, marta.Id, "video", EntryKind.Post, Make.T0.AddHours(1), "Reel della domenica", Make.Video());
var mixed = await Add(db, luca.Id, "misto", EntryKind.Post, Make.T0.AddHours(2), "50% sconto_estate", Make.Photo(), Make.Video(2));
var story = await Add(db, luca.Id, "storia", EntryKind.Story, Make.T0.AddHours(3), null, Make.Video());
var highlightItem = await Add(db, luca.Id, "evid", EntryKind.Highlight, Make.T0.AddHours(4), null, Make.Photo());
var tagged = await Add(db, marta.Id, "tag", EntryKind.Tagged, Make.T0.AddHours(5), "Con @amica", Make.Photo());
var profile = await Add(db, marta.Id, "profilo", EntryKind.ProfilePicture, Make.T0.AddHours(6), null, Make.Photo());
var imported = await db.Entries.AddAsync(
Make.Entry(marta.Id, "imp", Make.T0.AddDays(-30)) with { Provenance = Provenance.Imported },
[Make.Photo(1, MediaState.Imported) with { Sha256 = Make.Sha(99), RelativePath = "importati/x.jpg" }]);
var pending = await db.Entries.AddAsync(Make.Entry(marta.Id, "attesa", Make.T0), [Make.Photo()]);
// The story is also referenced by a highlight collection (H9).
var collection = await db.Highlights.UpsertAsync(new Highlight { AccountId = luca.Id, InstagramId = "h1", Title = "Viaggi", DiscoveredAt = Make.T0 });
await db.Highlights.SetItemsAsync(collection.Id, [highlightItem, story]);
async Task<long[]> Ids(LibraryFilter filter) =>
(await db.Entries.QueryLibraryAsync(new LibraryQuery { Filter = filter, Limit = 100 })).Tiles.Select(t => t.EntryId).Order().ToArray();
static long[] Of(params long[] ids) => ids.Order().ToArray();
CollectionAssert.AreEqual(Of(photoPost, videoPost, mixed, story, highlightItem, tagged, imported.Stored.Entry.Id), await Ids(new LibraryFilter()));
CollectionAssert.AreEqual(Of(photoPost, mixed, imported.Stored.Entry.Id), await Ids(new LibraryFilter { Kind = LibraryKindFilter.Photos }));
CollectionAssert.AreEqual(Of(videoPost, mixed), await Ids(new LibraryFilter { Kind = LibraryKindFilter.Videos }));
CollectionAssert.AreEqual(Of(story), await Ids(new LibraryFilter { Kind = LibraryKindFilter.Stories }));
CollectionAssert.AreEqual(Of(story, highlightItem), await Ids(new LibraryFilter { Kind = LibraryKindFilter.Highlights }));
CollectionAssert.AreEqual(Of(tagged), await Ids(new LibraryFilter { Kind = LibraryKindFilter.Tagged }));
CollectionAssert.AreEqual(Of(profile), await Ids(new LibraryFilter { Kind = LibraryKindFilter.ProfilePictures }));
CollectionAssert.AreEqual(Of(mixed, story, highlightItem), await Ids(new LibraryFilter { AccountIds = [luca.Id] }));
CollectionAssert.AreEqual(Of(videoPost, mixed), await Ids(new LibraryFilter { From = Make.T0.AddHours(1), To = Make.T0.AddHours(3) }));
CollectionAssert.AreEqual(Of(imported.Stored.Entry.Id), await Ids(new LibraryFilter { Provenance = Provenance.Imported }));
CollectionAssert.AreEqual(Of(pending.Stored.Entry.Id), await Ids(new LibraryFilter { States = [EntryState.ToDownload] }));
// Search: caption without accents or case, literal % and _, user name, display name.
CollectionAssert.AreEqual(Of(photoPost), await Ids(new LibraryFilter { Search = "PERCHE" }));
CollectionAssert.AreEqual(Of(mixed), await Ids(new LibraryFilter { Search = "50%" }));
CollectionAssert.AreEqual(Of(mixed), await Ids(new LibraryFilter { Search = "o_e" }));
CollectionAssert.AreEqual(Of(mixed, story, highlightItem), await Ids(new LibraryFilter { Search = "@luca.viaggi" }));
CollectionAssert.AreEqual(Of(photoPost, videoPost, tagged, imported.Stored.Entry.Id), await Ids(new LibraryFilter { Search = "bianchi" }));
CollectionAssert.AreEqual(Of(tagged), await Ids(new LibraryFilter { Search = "amica", Kind = LibraryKindFilter.Tagged }));
Assert.IsEmpty(await Ids(new LibraryFilter { Search = "nessuna corrispondenza" }));
var totals = await db.Entries.GetLibraryTotalsAsync(new LibraryFilter());
Assert.AreEqual(new LibraryTotals(7, 2), totals);
var tiles = (await db.Entries.QueryLibraryAsync(new LibraryQuery { Filter = new LibraryFilter { AccountIds = [luca.Id], Kind = LibraryKindFilter.Posts } })).Tiles;
var tile = tiles.Single();
Assert.AreEqual(2, tile.MediaCount);
Assert.AreEqual(MediaKind.Photo, tile.CoverKind);
Assert.AreEqual("luca.viaggi.demo", tile.Username);
var ordered = await db.Entries.GetTilesAsync([story, photoPost, 999]);
Assert.IsTrue(ordered.Select(t => t.EntryId).SequenceEqual([story, photoPost]));
}
[TestMethod]
public async Task CountsPerLocalDayFollowAlbertosZone()
{
using var temp = new TempFolder();
await using var db = await TestDatabase.OpenAsync(temp);
var account = await db.Accounts.AddAsync(Make.Account("marta.demo"));
// 22:30 UTC on 12 October is 00:30 on 13 October in Rome (CEST, +2).
await Add(db, account.Id, "a", EntryKind.Post, new DateTimeOffset(2026, 10, 12, 22, 30, 0, TimeSpan.Zero), null, Make.Photo());
await Add(db, account.Id, "b", EntryKind.Post, new DateTimeOffset(2026, 10, 12, 21, 59, 0, TimeSpan.Zero), null, Make.Photo());
await Add(db, account.Id, "c", EntryKind.Story, new DateTimeOffset(2026, 10, 13, 21, 45, 0, TimeSpan.Zero), null, Make.Photo());
// 25 October 2026: clocks go back. 23:15 UTC is 00:15 on 26 October in Rome (CET, +1).
await Add(db, account.Id, "d", EntryKind.Post, new DateTimeOffset(2026, 10, 25, 23, 15, 0, TimeSpan.Zero), null, Make.Photo());
await Add(db, account.Id, "e", EntryKind.Post, new DateTimeOffset(2026, 10, 25, 22, 45, 0, TimeSpan.Zero), null, Make.Photo());
var days = await db.Entries.CountLibraryByDayAsync(new LibraryFilter(), TestZones.Rome);
CollectionAssert.AreEqual(
new[]
{
new DayCount(new DateOnly(2026, 10, 26), 1),
new DayCount(new DateOnly(2026, 10, 25), 1),
new DayCount(new DateOnly(2026, 10, 13), 2),
new DayCount(new DateOnly(2026, 10, 12), 1),
},
days.ToArray());
var stories = await db.Entries.CountLibraryByDayAsync(new LibraryFilter { Kind = LibraryKindFilter.Stories }, TestZones.Rome);
CollectionAssert.AreEqual(new[] { new DayCount(new DateOnly(2026, 10, 13), 1) }, stories.ToArray());
}
[TestMethod]
public async Task AccountListPagesAndDailyDiscoveryCount()
{
using var temp = new TempFolder();
await using var db = await TestDatabase.OpenAsync(temp);
var account = await db.Accounts.AddAsync(Make.Account("marta.demo"));
for (var i = 0; i < 10; i++)
{
await db.Entries.AddAsync(Make.Entry(account.Id, $"p{i}", Make.T0.AddDays(-i)) with { DiscoveredAt = Make.T0.AddMinutes(i) }, [Make.Photo()]);
}
var first = await db.Entries.ListByAccountAsync(account.Id, new EntryListOptions { Kind = EntryKind.Post, Limit = 4 });
var next = await db.Entries.ListByAccountAsync(account.Id, new EntryListOptions { Kind = EntryKind.Post, Limit = 4, Before = new LibraryCursor(first[^1].PublishedAt, first[^1].Id) });
Assert.IsTrue(first.Concat(next).Select(e => e.InstagramId).SequenceEqual(Enumerable.Range(0, 8).Select(i => $"p{i}")));
Assert.AreEqual(5, await db.Entries.CountDiscoveredAsync(account.Id, EntryKind.Post, Make.T0, Make.T0.AddMinutes(5)));
}
private static int shaCounter = 1000;
private static async Task<long> Add(FebeDatabase db, long accountId, string id, EntryKind kind, DateTimeOffset at, string? caption, params Media[] media)
{
var stored = media.Select((m, i) => m with { State = MediaState.Downloaded, Sha256 = Make.Sha(Interlocked.Increment(ref shaCounter)), RelativePath = $"x/{id}_{i}" }).ToList();
var result = await db.Entries.AddAsync(Make.Entry(accountId, id, at, kind, caption), stored);
return result.Stored.Entry.Id;
}
}