Files
Alby96andClaude Opus 5.5 efa87f68ce
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
feat: owner review 2 phase 4b: mass conversion after import (#13)
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>
2026-11-03 10:41:50 +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);
}
}
}