CI / Build and test (push) Failing after 3m1s
CI / PostgreSQL 16 integration (push) Skipped
CI / PostgreSQL 17 integration (push) Skipped
CI / Docker image (push) Skipped
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 10s
Release / Build, test and publish (push) Successful in 15m31s
Release / Server image (push) Successful in 1m13s
Convert photos already in the archive to JPEG, TIFF-16 or Linear DNG, from the panel's Library and the desktop's Archive and Library. Each run asks Replace (same frames, originals to the trash, recoverable) or New sequence. A dry run lists what converts, what is skipped and why, size before and after, and free space; the job converts exactly the confirmed photos, resumes, and commits all or nothing per sequence. A conversion never changes what Chronos reads from a photo. Replaced originals are erased only on the archive's own word that their conversion is gone. Desktop TIFFs that WIC showed black or as noise now go to the managed reader; the Edit picker no longer spins a core. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: Alberto Balbo <alberto.balbo.96@gmail.com>
221 lines
9.1 KiB
C#
221 lines
9.1 KiB
C#
using Chronos.App.Library;
|
|
using Chronos.Core.Model;
|
|
using Chronos.Data.Repositories;
|
|
using Chronos.Testing;
|
|
|
|
namespace Chronos.App.Tests.Library;
|
|
|
|
public sealed class LibraryPagerTests
|
|
{
|
|
[Test]
|
|
public async Task PagesFollowTheCursorUntilTheEnd()
|
|
{
|
|
var source = new FakeSource(450);
|
|
var pager = new LibraryPager(source.FetchAsync, pageSize: 200);
|
|
|
|
var first = Assert.NotNull(await pager.ResetAsync(new LibraryFilter()));
|
|
Assert.True(first.IsFirst);
|
|
Assert.Equal(200, first.Items.Count);
|
|
Assert.True(pager.HasMore);
|
|
Assert.Null(source.Queries[0].Cursor);
|
|
|
|
var second = Assert.NotNull(await pager.LoadMoreAsync());
|
|
Assert.False(second.IsFirst);
|
|
Assert.Equal(200, second.Items.Count);
|
|
Assert.Equal("200", source.Queries[1].Cursor);
|
|
|
|
var third = Assert.NotNull(await pager.LoadMoreAsync());
|
|
Assert.Equal(50, third.Items.Count);
|
|
Assert.False(third.HasMore);
|
|
Assert.False(pager.HasMore);
|
|
Assert.Equal(450, pager.Loaded);
|
|
|
|
Assert.Null(await pager.LoadMoreAsync());
|
|
Assert.Equal(3, source.Queries.Count);
|
|
var ids = first.Items.Concat(second.Items).Concat(third.Items).Select(s => s.Id).ToList();
|
|
Assert.Equal(450, ids.Distinct().Count());
|
|
}
|
|
|
|
[Test]
|
|
public async Task FilterAndSortReachTheQuery()
|
|
{
|
|
var source = new FakeSource(10);
|
|
var pager = new LibraryPager(source.FetchAsync, pageSize: 50);
|
|
await pager.ResetAsync(new LibraryFilter
|
|
{
|
|
Text = " harbour ",
|
|
Year = 2026,
|
|
Camera = "Canon EOS R5",
|
|
Status = StatusFilter.NotAnalysed,
|
|
Tag = "sunset",
|
|
Sort = SequenceSort.Title,
|
|
});
|
|
var q = source.Queries.Single();
|
|
Assert.Equal("harbour", q.Text);
|
|
Assert.Equal(2026, q.Year);
|
|
Assert.Equal("Canon EOS R5", q.Camera);
|
|
Assert.Equal("sunset", q.Tag);
|
|
Assert.Equal(SequenceStatus.None, q.WithStatus);
|
|
Assert.Equal(SequenceStatus.AnalyzedLight, q.WithoutStatus);
|
|
Assert.Equal(SequenceSort.Title, q.Sort);
|
|
Assert.Equal(50, q.Limit);
|
|
}
|
|
|
|
[Test]
|
|
public async Task AResetDropsThePageOfTheOldFilter()
|
|
{
|
|
var source = new FakeSource(1000) { Gate = new TaskCompletionSource() };
|
|
var pager = new LibraryPager(source.FetchAsync, pageSize: 100);
|
|
var stale = pager.ResetAsync(new LibraryFilter { Text = "old" });
|
|
|
|
source.Gate = null;
|
|
var fresh = await pager.ResetAsync(new LibraryFilter { Text = "new" });
|
|
Assert.NotNull(fresh);
|
|
Assert.Equal(2, fresh!.Generation);
|
|
|
|
// The first request was cancelled; even if its data had arrived it must not be applied.
|
|
Assert.Null(await stale);
|
|
Assert.True(source.Cancelled > 0);
|
|
Assert.Equal("new", pager.Filter.Text);
|
|
}
|
|
|
|
[Test]
|
|
public async Task ASupersededResultIsDroppedEvenWithoutCancellation()
|
|
{
|
|
var gate = new TaskCompletionSource();
|
|
var source = new FakeSource(1000) { Gate = gate, IgnoreCancellation = true };
|
|
var pager = new LibraryPager(source.FetchAsync, pageSize: 100);
|
|
var stale = pager.ResetAsync(new LibraryFilter { Text = "old" });
|
|
source.Gate = null;
|
|
var fresh = await pager.ResetAsync(new LibraryFilter { Text = "new" });
|
|
gate.SetResult();
|
|
Assert.Null(await stale);
|
|
Assert.Equal(100, fresh!.Items.Count);
|
|
Assert.Equal(100, pager.Loaded);
|
|
}
|
|
|
|
[Test]
|
|
public async Task OnlyOnePageLoadsAtATime()
|
|
{
|
|
var source = new FakeSource(1000);
|
|
var pager = new LibraryPager(source.FetchAsync, pageSize: 100);
|
|
await pager.ResetAsync(new LibraryFilter());
|
|
source.Gate = new TaskCompletionSource();
|
|
var a = pager.LoadMoreAsync();
|
|
var b = pager.LoadMoreAsync();
|
|
Assert.True(pager.IsLoading);
|
|
Assert.Null(await b);
|
|
source.Gate.SetResult();
|
|
Assert.Equal(100, (await a)!.Items.Count);
|
|
Assert.Equal(2, source.Queries.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task AFailedPageStopsScrollLoadingUntilTheNextReset()
|
|
{
|
|
var source = new FakeSource(1000);
|
|
var pager = new LibraryPager(source.FetchAsync, pageSize: 100);
|
|
await pager.ResetAsync(new LibraryFilter());
|
|
source.Fail = true;
|
|
await Assert.ThrowsAsync<InvalidOperationException>(() => pager.LoadMoreAsync());
|
|
Assert.False(pager.HasMore);
|
|
Assert.Null(await pager.LoadMoreAsync());
|
|
source.Fail = false;
|
|
Assert.NotNull(await pager.ResetAsync(new LibraryFilter()));
|
|
Assert.True(pager.HasMore);
|
|
}
|
|
|
|
[Test]
|
|
public void StatusChoicesMapToFlags()
|
|
{
|
|
Assert.Equal((SequenceStatus.AnalyzedLight, SequenceStatus.None), LibraryFilter.Flags(StatusFilter.Analysed));
|
|
Assert.Equal((SequenceStatus.None, SequenceStatus.ProxiesBuilt), LibraryFilter.Flags(StatusFilter.NoProxies));
|
|
Assert.Equal((SequenceStatus.Verified, SequenceStatus.None), LibraryFilter.Flags(StatusFilter.Verified));
|
|
Assert.Equal((SequenceStatus.HasWarnings, SequenceStatus.None), LibraryFilter.Flags(StatusFilter.Warnings));
|
|
Assert.Equal((SequenceStatus.None, SequenceStatus.None), LibraryFilter.Flags(StatusFilter.Any));
|
|
Assert.True(new LibraryFilter { Sort = SequenceSort.Size }.IsUnfiltered);
|
|
Assert.False(new LibraryFilter { Text = "x" }.IsUnfiltered);
|
|
Assert.False(new LibraryFilter { Status = StatusFilter.Proxies }.IsUnfiltered);
|
|
var cleared = new LibraryFilter { Text = "x", Year = 2020, Sort = SequenceSort.Oldest }.Cleared();
|
|
Assert.True(cleared.IsUnfiltered);
|
|
Assert.Equal(SequenceSort.Oldest, cleared.Sort);
|
|
Assert.Null(new LibraryFilter { Text = " " }.ToQuery(10, null).Text);
|
|
}
|
|
|
|
/// <summary>An in-memory library: cursors are offsets, optionally held back by a gate.</summary>
|
|
[Test]
|
|
public async Task APageInFlightIsWaitedForNotAskedForAgain()
|
|
{
|
|
// The Edit picker reads on until a sequence is listed; the list may ask for a page as it scrolls meanwhile.
|
|
var source = new FakeSource(30);
|
|
var pager = new LibraryPager(source.FetchAsync, pageSize: 10);
|
|
await pager.ResetAsync(new LibraryFilter());
|
|
Assert.True(pager.WhenLoadedAsync().IsCompleted, "nothing is loading");
|
|
|
|
source.Gate = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
var scrolled = pager.LoadMoreAsync();
|
|
var again = pager.LoadMoreAsync();
|
|
Assert.True(again.IsCompletedSuccessfully && again.Result is null, "asking again gets nothing at once");
|
|
var loaded = pager.WhenLoadedAsync();
|
|
Assert.False(loaded.IsCompleted, "the page in flight is waited for");
|
|
|
|
source.Gate.SetResult();
|
|
await loaded;
|
|
Assert.True(scrolled.IsCompleted, "the wait ends with that page");
|
|
Assert.Equal(10, Assert.NotNull(await scrolled).Items.Count);
|
|
Assert.Equal(2, source.Queries.Count);
|
|
}
|
|
|
|
[Test]
|
|
public async Task WaitingForAPageThatFailsDoesNotFail()
|
|
{
|
|
var source = new FakeSource(30);
|
|
var pager = new LibraryPager(source.FetchAsync, pageSize: 10);
|
|
await pager.ResetAsync(new LibraryFilter());
|
|
source.Gate = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
source.Fail = true;
|
|
var page = pager.LoadMoreAsync();
|
|
var loaded = pager.WhenLoadedAsync();
|
|
|
|
source.Gate.SetResult();
|
|
await loaded;
|
|
await Assert.ThrowsAsync<InvalidOperationException>(() => page);
|
|
Assert.False(pager.HasMore, "a failing page stops the reading");
|
|
}
|
|
|
|
private sealed class FakeSource(int count)
|
|
{
|
|
private readonly Guid _archive = Guid.CreateVersion7();
|
|
|
|
public List<SequenceQuery> Queries { get; } = [];
|
|
public TaskCompletionSource? Gate { get; set; }
|
|
public bool IgnoreCancellation { get; init; }
|
|
public bool Fail { get; set; }
|
|
public int Cancelled { get; private set; }
|
|
|
|
public async Task<Page<Sequence>> FetchAsync(SequenceQuery query, CancellationToken ct)
|
|
{
|
|
Queries.Add(query);
|
|
if (Gate is { } gate)
|
|
{
|
|
try
|
|
{
|
|
await gate.Task.WaitAsync(IgnoreCancellation ? CancellationToken.None : ct);
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
Cancelled++;
|
|
throw;
|
|
}
|
|
}
|
|
if (Fail) throw new InvalidOperationException("database gone");
|
|
var start = query.Cursor is null ? 0 : int.Parse(query.Cursor, System.Globalization.CultureInfo.InvariantCulture);
|
|
var items = Enumerable.Range(start, Math.Max(0, Math.Min(query.Limit, count - start)))
|
|
.Select(i => new Sequence { Id = Guid.CreateVersion7(), ArchiveId = _archive, Folder = "s" + i, Title = "S" + i })
|
|
.ToList();
|
|
var next = start + items.Count < count ? (start + items.Count).ToString(System.Globalization.CultureInfo.InvariantCulture) : null;
|
|
return new Page<Sequence>(items, next);
|
|
}
|
|
}
|
|
}
|