using Febe.Core.Domain;
using Febe.Core.Library;
using Febe.Data;
namespace Febe.Tests.Support;
/// A library with its Data folder, database and services, in a temporary folder.
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 CreateAsync(TempFolder temp)
{
var db = await FebeDatabase.OpenAsync(temp.Combine("dati"));
return new TestLibrary(temp, db, new ManualClock(Make.T0));
}
/// Records an entry and stores its files as the collection pipeline would, then writes the journal line.
public async Task SaveAsync(Account account, Entry entry, IReadOnlyList 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))!;
}
/// Simulates the loss of the database: closes it, deletes the file and opens an empty one.
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);
}
///
/// 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.
///
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();
}
/// A file to store: its record and its bytes.
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);
}
}