Files
Febe/tests/Febe.Tests/Support/TestLibrary.cs
T
Alby96andClaude Opus 5.5 f7de7f5642 Ricostruzione: la prova aspetta il database tenuto per un attimo su Windows
TestLibrary.LoseDatabaseAsync elimina febe.sqlite appena chiuso. Su Windows un file aperto da un
altro programma non si elimina, e con Defender attivo succedeva circa 3 volte su 40 esecuzioni
delle prove di libreria: il file era libero dopo 6-17 ms e nessun processo risultava tenerlo,
quindi non è un collegamento di Febe rimasto aperto. Su Windows l'eliminazione che trova il file
in uso si ripete ogni 50 ms per al più 5 s; su Linux, dove eliminare un file aperto riesce
sempre, non cambia nulla.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-20 13:09:19 +02:00

120 lines
4.4 KiB
C#

using Febe.Core.Domain;
using Febe.Core.Library;
using Febe.Data;
namespace Febe.Tests.Support;
/// <summary>A library with its Data folder, database and services, in a temporary folder.</summary>
internal sealed class TestLibrary : IAsyncDisposable
{
private TestLibrary(TempFolder temp, FebeDatabase db, ManualClock clock)
{
Temp = temp;
Db = db;
Clock = clock;
Data = new DataFolderLayout(temp.Combine("dati"));
Layout = new LibraryLayout(temp.Combine("libreria"));
Thumbnails = new ThumbnailStore(Data.Thumbnails);
Index = new PerceptualHashIndex();
Journal = new AccountJournal(clock);
Ingest = new LibraryIngest(db, Layout, LibraryNaming.Default, Journal, clock, Thumbnails, Index);
}
public TempFolder Temp { get; }
public FebeDatabase Db { get; private set; }
public ManualClock Clock { get; }
public DataFolderLayout Data { get; }
public LibraryLayout Layout { get; }
public ThumbnailStore Thumbnails { get; }
public PerceptualHashIndex Index { get; }
public AccountJournal Journal { get; }
public LibraryIngest Ingest { get; private set; }
public static async Task<TestLibrary> CreateAsync(TempFolder temp)
{
var db = await FebeDatabase.OpenAsync(temp.Combine("dati"));
return new TestLibrary(temp, db, new ManualClock(Make.T0));
}
/// <summary>Records an entry and stores its files as the collection pipeline would, then writes the journal line.</summary>
public async Task<EntryWithMedia> SaveAsync(Account account, Entry entry, IReadOnlyList<TestFile> files, string? highlightTitle = null)
{
var added = await Db.Entries.AddAsync(entry, files.Select(f => f.Media).ToList());
foreach (var (media, file) in added.Stored.Media.Zip(files.OrderBy(f => f.Media.Position)))
{
await Ingest.SaveMediaAsync(account, added.Stored.Entry, media, new MediaContent { Content = new MemoryStream(file.Bytes), Extension = file.Extension }, highlightTitle);
}
await Ingest.AppendJournalAsync(added.Stored.Entry.Id);
return (await Db.Entries.GetWithMediaAsync(added.Stored.Entry.Id))!;
}
/// <summary>Simulates the loss of the database: closes it, deletes the file and opens an empty one.</summary>
public async Task LoseDatabaseAsync()
{
await Db.DisposeAsync();
foreach (var suffix in new[] { string.Empty, "-wal", "-shm" })
{
await DeleteClosedFileAsync(Data.Database + suffix);
}
Db = await FebeDatabase.OpenAsync(Data.Root);
Ingest = new LibraryIngest(Db, Layout, LibraryNaming.Default, Journal, Clock, Thumbnails, Index);
}
/// <summary>
/// Deletes a file Febe has already closed. On Windows a file that another program holds open cannot be deleted, and a
/// database just written is sometimes held for a few milliseconds by a program that scans new files (the real-time
/// antivirus): that sharing violation is waited out (at most 5 s). On Linux a delete never meets one, so the first
/// attempt is the only one.
/// </summary>
private static async Task DeleteClosedFileAsync(string path)
{
const int SharingViolation = unchecked((int)0x80070020);
for (var attempt = 1; ; attempt++)
{
try
{
File.Delete(path);
return;
}
catch (IOException ex) when (OperatingSystem.IsWindows() && ex.HResult == SharingViolation && attempt < 100)
{
await Task.Delay(50);
}
}
}
public ValueTask DisposeAsync() => Db.DisposeAsync();
}
/// <summary>A file to store: its record and its bytes.</summary>
internal sealed record TestFile(Media Media, byte[] Bytes, string Extension)
{
private static int videoSeed;
public static TestFile Photo(int position, int scene, int width = 1080, int height = 1350) =>
new(Make.Photo(position), PhotoBytes(scene, width, height), ".jpg");
public static TestFile Video(int position, int size = 50_000)
{
var bytes = new byte[size];
new Random(Interlocked.Increment(ref videoSeed)).NextBytes(bytes);
return new TestFile(Make.Video(position), bytes, ".mp4");
}
public static byte[] PhotoBytes(int scene, int width = 1080, int height = 1350)
{
using var bitmap = TestImages.Scene(scene, width, height);
return TestImages.Jpeg(bitmap, 88);
}
}