Files
Chronos/tests/Chronos.App.Tests/Library/LibraryPagerTests.cs
T
Alby96andClaude Opus 5.5 4dd3050334 fix(app): the Edit picker waits for a page the list is loading instead of spinning
To select the sequence edited last, the picker reads pages until it is listed. When the
list had asked for a page as it scrolled, LibraryPager.LoadMoreAsync answered nothing at
once while that page was in flight, and the loop asked again without ever yielding the UI
thread that page needed to finish: a core spun at 100% and the picker never settled
(EditSectionTests timed out under load and kept the test process alive). The loop now
waits for the page in flight (LibraryPager.WhenLoadedAsync) and stops when a page brings
nothing.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-02 11:37:27 +01:00

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);
}
}
}