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
301 lines
19 KiB
C#
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;
|
|
}
|
|
}
|