Files
Chronos/tests/Chronos.App.Tests/Library/ThumbnailCacheTests.cs
T
Alby96andClaude Opus 5.5 f2b58522b9
CI / Build and test (push) Successful in 8m14s
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 7s
Release / Build, test and publish (push) Successful in 13m19s
CI / PostgreSQL 16 integration (push) Successful in 4m49s
CI / PostgreSQL 17 integration (push) Successful in 5m28s
CI / Docker image (push) Successful in 53s
Release / Server image (push) Failing after 10s
refactor!: rename Titano to Chronos and move CI and releases to Gitea (#6)
The owner renamed the product and moved the repository to the self-hosted
Gitea (https://gitea.encke-hake.ts.net/BalboSoft/Chronos) for more control,
and asked for Actions and a first automatic release with the server package
and the Windows exe (docs/requests/2026-10-23-chronos-gitea.md).

- Chronos everywhere: a byte-exact rename of contents and paths, then a
  per-language review of the forms the old name's ending had dictated.
- Gitea instead of GitHub: the update check, licence, issue and support
  links read ChronosReleasesUrl; the update check takes the highest stable
  version, offers a pre-release build its final release and reports a
  repository it cannot see as a failed check. EULA, security policy and
  Gitea issue forms live at the repository root.
- Gitea Actions for the Linux act_runner (.gitea/workflows): CI, release,
  nightly image and performance gates in the .NET SDK container with git
  checkout and the system SQLite. The release cross-compiles the Windows
  programs, checks their icon, version and DPI manifest, packs installers
  and zips, publishes the Gitea release and pushes the server image
  (REGISTRY_TOKEN). Windows-only tests run in an opt-in job on a Windows
  runner (WINDOWS_RUNNER).
- New Chronos.Tools commands: zip, gitea-release, postgres-ci (replaces the
  docker-exec script, which Gitea's service containers do not allow; the
  throw-away server runs without durability) and pe-check.
- Timed tests take their budget from TestTiming (CHRONOS_TEST_TIME_FACTOR,
  3 on the shared runner; the weekly performance gates keep theirs).

BREAKING CHANGE: programs, settings, data folders, file types, environment
variables and the Docker image use the new name; nothing is migrated from
Titano, which never had a release.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: Alberto Balbo <alberto.balbo.96@gmail.com>
2026-10-23 12:45:18 +02:00

170 lines
6.2 KiB
C#

using System.Collections.Concurrent;
using System.IO;
using Chronos.App.Library;
using Chronos.Testing;
namespace Chronos.App.Tests.Library;
public sealed class ThumbnailCacheTests
{
private static readonly TimeSpan Wait = TimeSpan.FromSeconds(10);
[Test]
public async Task LeastRecentlyUsedEntriesAreEvicted()
{
var loads = new ConcurrentBag<int>();
using var cache = new ThumbnailCache<int, string>(3, (k, _) =>
{
loads.Add(k);
return Task.FromResult<string?>("img" + k);
});
Assert.Equal("img1", await cache.GetAsync(1, CancellationToken.None));
await cache.GetAsync(2, CancellationToken.None);
await cache.GetAsync(3, CancellationToken.None);
Assert.True(cache.TryGet(1, out _)); // 1 becomes the most recent
await cache.GetAsync(4, CancellationToken.None); // evicts 2
Assert.Equal(3, cache.Count);
Assert.False(cache.TryGet(2, out _));
Assert.True(cache.TryGet(1, out var one));
Assert.Equal("img1", one);
Assert.True(cache.TryGet(3, out _));
Assert.True(cache.TryGet(4, out _));
await cache.GetAsync(1, CancellationToken.None);
Assert.Equal(4, loads.Count); // the cached key was not decoded again
cache.Capacity = 1;
Assert.Equal(1, cache.Count);
Assert.True(cache.TryGet(1, out _));
}
[Test]
public async Task MissingThumbnailsAreCachedButFailuresAreNot()
{
var calls = 0;
using var cache = new ThumbnailCache<int, string>(8, (k, _) =>
{
Interlocked.Increment(ref calls);
return k == 13 ? throw new IOException("unreadable") : Task.FromResult<string?>(null);
});
Assert.Null(await cache.GetAsync(1, CancellationToken.None));
Assert.Null(await cache.GetAsync(1, CancellationToken.None));
Assert.True(cache.TryGet(1, out var none));
Assert.Null(none);
await Assert.ThrowsAsync<IOException>(() => cache.GetAsync(13, CancellationToken.None));
await Assert.ThrowsAsync<IOException>(() => cache.GetAsync(13, CancellationToken.None));
Assert.Equal(3, calls);
Assert.Equal(0, cache.PendingLoads);
}
[Test]
public async Task ConcurrentRequestsShareOneLoad()
{
var release = new TaskCompletionSource();
var calls = 0;
using var cache = new ThumbnailCache<int, string>(8, async (k, ct) =>
{
Interlocked.Increment(ref calls);
await release.Task.WaitAsync(ct);
return "img" + k;
});
var a = cache.GetAsync(7, CancellationToken.None);
var b = cache.GetAsync(7, CancellationToken.None);
release.SetResult();
Assert.Equal("img7", await a.WaitAsync(Wait));
Assert.Equal("img7", await b.WaitAsync(Wait));
Assert.Equal(1, calls);
}
[Test]
public async Task ALoadStopsWhenEveryRequestIsCancelled()
{
var started = new TaskCompletionSource();
var observed = new TaskCompletionSource();
using var cache = new ThumbnailCache<int, string>(8, async (_, ct) =>
{
started.TrySetResult();
try
{
await Task.Delay(Timeout.Infinite, ct);
}
catch (OperationCanceledException)
{
observed.TrySetResult();
throw;
}
return "never";
});
using var first = new CancellationTokenSource();
using var second = new CancellationTokenSource();
var a = cache.GetAsync(5, first.Token);
var b = cache.GetAsync(5, second.Token);
await started.Task.WaitAsync(Wait);
first.Cancel();
await Assert.ThrowsAsync<OperationCanceledException>(() => a);
Assert.False(observed.Task.IsCompleted, "the load must continue while another card still waits");
Assert.Equal(1, cache.PendingLoads);
second.Cancel();
await Assert.ThrowsAsync<OperationCanceledException>(() => b);
await observed.Task.WaitAsync(Wait);
Assert.Equal(0, cache.PendingLoads);
Assert.False(cache.TryGet(5, out _));
}
[Test]
public async Task ALoadAfterACancelledOneStartsFresh()
{
var attempts = 0;
var blocked = true;
using var cache = new ThumbnailCache<int, string>(8, async (k, ct) =>
{
Interlocked.Increment(ref attempts);
if (Volatile.Read(ref blocked)) await Task.Delay(Timeout.Infinite, ct);
return "img" + k;
});
using var scrolledAway = new CancellationTokenSource();
var first = cache.GetAsync(9, scrolledAway.Token);
scrolledAway.Cancel();
await Assert.ThrowsAsync<OperationCanceledException>(() => first);
Volatile.Write(ref blocked, false);
Assert.Equal("img9", await cache.GetAsync(9, CancellationToken.None).WaitAsync(Wait));
// The cancelled load may have stopped before it reached the decoder.
Assert.InRange(Volatile.Read(ref attempts), 1, 2);
Assert.Equal(0, cache.PendingLoads);
}
[Test]
public async Task LoadsRunConcurrentlyUpToTheLimit()
{
var running = 0;
var peak = 0;
var gate = new TaskCompletionSource();
using var cache = new ThumbnailCache<int, string>(64, async (k, ct) =>
{
var now = Interlocked.Increment(ref running);
InterlockedMax(ref peak, now);
await gate.Task.WaitAsync(ct);
Interlocked.Decrement(ref running);
return "img" + k;
}, maxConcurrentLoads: 2);
var tasks = Enumerable.Range(0, 10).Select(i => cache.GetAsync(i, CancellationToken.None)).ToList();
await Task.Delay(100);
Assert.LessOrEqual(Volatile.Read(ref running), 2);
gate.SetResult();
await Task.WhenAll(tasks).WaitAsync(Wait);
Assert.LessOrEqual(peak, 2);
Assert.Equal(10, cache.Count);
}
private static void InterlockedMax(ref int target, int value)
{
int current;
while ((current = Volatile.Read(ref target)) < value && Interlocked.CompareExchange(ref target, value, current) != current)
{
}
}
}