Files
Febe/tests/Febe.Tests/Support/TestLibrary.cs
T
Alby96andClaude Opus 5.5 198e48d4f8 Prove: il commento dell'attesa sul database dice ciò che si è visto, non una causa
Il commento di TestLibrary.DeleteClosedFileAsync dava per certo che il file appena chiuso fosse
tenuto dall'antivirus. È solo una deduzione: su un PC il file restava in uso per pochi
millisecondi, il Restart Manager non elencava alcun processo e Defender era attivo, ma la causa
non è stata dimostrata (la revisione non ha riprodotto il caso). Il commento ora lo dice, così
nessuno smette di cercare né copia l'attesa nel prodotto per una causa mai vista. Il codice non
cambia.

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

120 lines
4.5 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 still held open elsewhere cannot be deleted, and on one PC a
/// database just closed was now and then held for a few milliseconds by something outside Febe (Restart Manager listed
/// no process; probably the real-time antivirus, which was active, but the cause was never shown): 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);
}
}