Files
Chronos/tests/Chronos.Server.Tests/Storage/ProxyUploadTests.cs
T
Alby96andClaude Opus 5.5 5f27a86406
CI / Build and test (pull_request) Failing after 2m3s
CI / PostgreSQL 16 integration (pull_request) Skipped
CI / PostgreSQL 17 integration (pull_request) Skipped
CI / Docker image (pull_request) Skipped
CI / Windows tests and installer (pull_request) Skipped
CI / YAML check (pull_request) Successful in 4s
refactor!: rename Titano to Chronos and move CI and releases to Gitea
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. 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) and
  pe-check.

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>
2026-10-23 11:34:48 +02:00

224 lines
13 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
using System.Net;
using System.Net.Http.Headers;
using Chronos.Core.Codecs.Jpeg;
using Chronos.Core.Imaging;
using Chronos.Core.Metadata;
using Chronos.Core.Model;
using Chronos.Protocol;
using Chronos.Server.Storage;
using Chronos.Testing;
namespace Chronos.Server.Tests.Storage;
/// <summary>
/// Proxies of originals the server cannot decode (BRIEF §2.3: HEIF) arrive from clients and render nodes through
/// <c>PUT /api/v1/frames/{id}/proxy</c> and become the frame's proxy and thumbnail.
/// </summary>
[Category("server")]
public sealed class ProxyUploadTests(TestContext context)
{
[Test]
public async Task AProxySentForAFrameTheServerCannotDecodeIsCheckedKeptAndThumbnailed()
{
await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register);
var (editor, _, _) = await server.UserAsync("alberto", "editor");
var (viewer, _, _) = await server.UserAsync("vera", "viewer");
var upload = await Uploads.UploadAsync(editor, Heif(1), "IMG_0001.HEIC", sessionKey: "roof");
var frame = Assert.NotNull(await server.Database.Frames.GetAsync(upload.FrameId));
Assert.Equal(ImageFileFormat.Heif, frame.Format);
var manifest = await ManifestAsync(editor, upload.SequenceId);
Assert.Equal((true, false), (manifest.Frames.Single().WantsProxy, manifest.Frames.Single().HasProxy));
Assert.Equal(new ProxySpec(1920, 92), manifest.Proxies);
using (var garbage = await PutAsync(editor, frame.Id, "not a photo"u8.ToArray()))
await garbage.ExpectErrorAsync(HttpStatusCode.UnprocessableEntity, "invalid_proxy");
using (var other = await PutAsync(editor, frame.Id, Proxy(frame.CapturedAt!.Value.AddSeconds(1))))
await other.ExpectErrorAsync(HttpStatusCode.UnprocessableEntity, "proxy_mismatch");
var proxy = Proxy(frame.CapturedAt!.Value);
using (var refused = await PutAsync(viewer, frame.Id, proxy))
await refused.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden");
using (var missing = await PutAsync(editor, Guid.CreateVersion7(), proxy))
await missing.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found");
using (var stored = await PutAsync(editor, frame.Id, proxy))
await stored.ExpectAsync(HttpStatusCode.NoContent);
await Http.BytesEqualAsync(proxy, editor.GetByteArrayAsync($"/api/v1/frames/{frame.Id}/proxy"));
var after = (await ManifestAsync(editor, upload.SequenceId)).Frames.Single();
Assert.Equal((false, true), (after.WantsProxy, after.HasProxy));
// The thumbnail job the proxy queued draws the frame from it.
var until = DateTime.UtcNow + TimeSpan.FromSeconds(30);
while (true)
{
using var thumb = await editor.GetAsync($"/api/v1/frames/{frame.Id}/thumb");
if (thumb.StatusCode == HttpStatusCode.OK)
{
var jpeg = await thumb.Content.ReadAsByteArrayAsync();
Assert.Equal((320, 240), (JpegDecoder.ReadInfo(jpeg).Width, JpegDecoder.ReadInfo(jpeg).Height));
break;
}
Assert.True(DateTime.UtcNow < until, $"thumbnail not built: {(int)thumb.StatusCode}");
await Task.Delay(100);
}
}
[Test]
public async Task AnotherPhotosProxyInTheFramesPlaceIsAskedForAgainAndNeverServed()
{
await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register);
var (editor, _, _) = await server.UserAsync("alberto", "editor");
var upload = await Uploads.UploadAsync(editor, Heif(1), "IMG_0001.HEIC", sessionKey: "roof");
var frame = Assert.NotNull(await server.Database.Frames.GetAsync(upload.FrameId));
var sequence = Assert.NotNull(await server.Database.Sequences.GetAsync(upload.SequenceId));
// Proxies are named by frame index: after a frame was inserted before this one, its place holds another photo's.
var path = new Core.Archiving.ArchivePaths(server.Options.ArchivePath).Sequence(sequence.Folder).Proxy(frame.Index);
Directory.CreateDirectory(Path.GetDirectoryName(path)!);
await File.WriteAllBytesAsync(path, Proxy(frame.CapturedAt!.Value.AddSeconds(-10)));
Assert.Equal((true, false), Wanted((await ManifestAsync(editor, upload.SequenceId)).Frames.Single()));
using (var served = await editor.GetAsync($"/api/v1/frames/{frame.Id}/proxy"))
Assert.Equal("asset_missing", (await served.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found")).Details);
// The frame's own proxy takes its place.
var proxy = Proxy(frame.CapturedAt!.Value);
using (var stored = await PutAsync(editor, frame.Id, proxy))
await stored.ExpectAsync(HttpStatusCode.NoContent);
Assert.Equal((false, true), Wanted((await ManifestAsync(editor, upload.SequenceId)).Frames.Single()));
await Http.BytesEqualAsync(proxy, editor.GetByteArrayAsync($"/api/v1/frames/{frame.Id}/proxy"));
}
[Test]
public async Task FramesAddedAfterEveryProxyArrivedAreAskedForTheirs()
{
await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register);
var (editor, _, _) = await server.UserAsync("alberto", "editor");
var first = await Uploads.UploadAsync(editor, Heif(1), "IMG_0001.HEIC", sessionKey: "roof");
var frame = Assert.NotNull(await server.Database.Frames.GetAsync(first.FrameId));
using (var stored = await PutAsync(editor, frame.Id, Proxy(frame.CapturedAt!.Value)))
await stored.ExpectAsync(HttpStatusCode.NoContent);
// A frame comes after the proxy pass found every proxy there: until the next pass the status still says so, yet
// the new frame is asked for its proxy and the first keeps its own.
var second = await Uploads.UploadAsync(editor, Heif(2), "IMG_0002.HEIC", sessionKey: "roof");
Assert.Equal(first.SequenceId, second.SequenceId);
await server.Database.Sequences.UpdateStatusAsync(first.SequenceId, SequenceStatus.ProxiesBuilt, SequenceStatus.None, context.Cancellation);
var frames = (await ManifestAsync(editor, first.SequenceId)).Frames;
Assert.Equal((false, true), Wanted(frames.Single(f => f.Id == first.FrameId)));
Assert.Equal((true, false), Wanted(frames.Single(f => f.Id == second.FrameId)));
}
[Test]
public async Task AProxyTheServerMadeIsServedForAFrameTimedToTheTick()
{
await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register);
var (editor, _, _) = await server.UserAsync("alberto", "editor");
// Seven sub-second digits: the sidecar, and the proxy made from it, keep them all; the index keeps six.
var upload = await Uploads.UploadAsync(editor, Proxy(new DateTime(2026, 9, 28, 18, 2, 11).AddTicks(1_234_567)), "IMG_0001.JPG", sessionKey: "roof");
// The proxy pass the upload queued makes the frame's proxy, and the server serves it.
var until = DateTime.UtcNow + TimeSpan.FromSeconds(30);
while (true)
{
using var proxy = await editor.GetAsync($"/api/v1/frames/{upload.FrameId}/proxy");
if (proxy.StatusCode == HttpStatusCode.OK) break;
Assert.True(DateTime.UtcNow < until, $"proxy not served: {(int)proxy.StatusCode}");
await Task.Delay(100);
}
}
[Test]
public async Task AReportThatFoundAFrameUnreadableBeforeItsProxyCameIsNotServed()
{
await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register);
var (editor, _, _) = await server.UserAsync("alberto", "editor");
var upload = await Uploads.UploadAsync(editor, Heif(1), "IMG_0001.HEIC", sessionKey: "roof");
var frame = Assert.NotNull(await server.Database.Frames.GetAsync(upload.FrameId));
var sequence = Assert.NotNull(await server.Database.Sequences.GetAsync(upload.SequenceId));
// A deep analysis ran before the proxy came and found no pixels in the HEIF original.
var path = new Core.Archiving.ArchivePaths(server.Options.ArchivePath).Sequence(sequence.Folder).AnalysisPath;
Directory.CreateDirectory(Path.GetDirectoryName(path)!);
Reports.Minimal(1, undecodable: 0).Save(path);
var url = $"/api/v1/sequences/{sequence.Id}/analysis/report";
using (var before = await editor.GetAsync(url))
await before.ExpectAsync(HttpStatusCode.OK);
// Once the frame is read from its proxy, that verdict and its advice to exclude the frame no longer hold, even
// before a light analysis has dropped the deep status.
using (var stored = await PutAsync(editor, frame.Id, Proxy(frame.CapturedAt!.Value)))
await stored.ExpectAsync(HttpStatusCode.NoContent);
using var after = await editor.GetAsync(url);
Assert.Equal("analysis", (await after.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found")).Details);
}
[Test]
public async Task FramesTheServerDecodesAskForNoProxy()
{
await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register);
var (editor, _, _) = await server.UserAsync("alberto", "editor");
var upload = await Uploads.UploadAsync(editor, Proxy(new DateTime(2026, 9, 28, 18, 2, 11)), "IMG_0001.JPG", sessionKey: "roof");
Assert.False((await ManifestAsync(editor, upload.SequenceId)).Frames.Single().WantsProxy);
// Nor takes one: renders and remote views keep the proxy the server makes itself.
using var refused = await PutAsync(editor, upload.FrameId, Proxy(new DateTime(2026, 9, 28, 18, 2, 11)));
await refused.ExpectErrorAsync(HttpStatusCode.UnprocessableEntity, "proxy_not_wanted");
}
[Test]
public async Task AnswersThatLeaveALargeProxyUnreadReachTheClient()
{
// A full-size proxy is far above the 1 MiB other requests may send: more than the connection buffers while the
// server reads nothing.
await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register);
var (editor, _, _) = await server.UserAsync("alberto", "editor");
var heif = await Uploads.UploadAsync(editor, Heif(1), "IMG_0001.HEIC", sessionKey: "roof");
var jpeg = await Uploads.UploadAsync(editor, Proxy(new DateTime(2026, 9, 28, 18, 2, 12)), "IMG_0002.JPG", sessionKey: "roof");
var large = Uploads.Photo(24 * 1024 * 1024, 7);
// The handler answers before reading the body: a frame deleted since the manifest, and one the server decodes itself.
using (var missing = await PutAsync(editor, Guid.CreateVersion7(), large))
Assert.Equal("frame", (await missing.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found")).Details);
using (var unwanted = await PutAsync(editor, jpeg.FrameId, large))
await unwanted.ExpectErrorAsync(HttpStatusCode.UnprocessableEntity, "proxy_not_wanted");
// A body that may be the proxy is read whole, past the 1 MiB, before it is judged.
using (var invalid = await PutAsync(editor, heif.FrameId, large))
await invalid.ExpectErrorAsync(HttpStatusCode.UnprocessableEntity, "invalid_proxy");
// Authentication answers before the endpoint runs: an account that lost the Edit role, and a session signed out meanwhile.
var (viewer, _, _) = await server.UserAsync("vera", "viewer");
using (var forbidden = await PutAsync(viewer, heif.FrameId, large))
await forbidden.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden");
using (var logout = await editor.PostAsync("/api/v1/auth/logout", null))
await logout.ExpectAsync(HttpStatusCode.NoContent);
using var revoked = await PutAsync(editor, heif.FrameId, large);
await revoked.ExpectErrorAsync(HttpStatusCode.Unauthorized, "unauthorized");
}
/// <summary>A HEIF file as far as signature sniffing goes (an <c>ftyp</c> box naming heic), with no pixels the server can read.</summary>
private static byte[] Heif(int seed) => [0, 0, 0, 24, .. "ftypheic"u8, 0, 0, 0, 0, .. "mif1heic"u8, .. Uploads.Photo(2000, seed)];
/// <summary>A 320 × 240 JPEG with <paramref name="captured"/> in its Exif, as a client makes a proxy.</summary>
private static byte[] Proxy(DateTime captured)
{
using var image = new ImageBuffer(320, 240);
for (var c = 0; c < 3; c++) image.Plane(c).Fill(0.3f + c * 0.1f);
var exif = ExifWriter.BuildJpegApp1(new FrameMetadata { CapturedAt = captured, Software = "Chronos" });
return JpegEncoder.Encode(image, new JpegEncodeOptions { Quality = 85, App1Segments = [exif[4..]] });
}
private static (bool WantsProxy, bool HasProxy) Wanted(ManifestFrame frame) => (frame.WantsProxy, frame.HasProxy);
private static Task<HttpResponseMessage> PutAsync(HttpClient client, Guid frameId, byte[] body)
{
var content = new ByteArrayContent(body);
content.Headers.ContentType = new MediaTypeHeaderValue("image/jpeg");
return client.PutAsync($"/api/v1/frames/{frameId}/proxy", content);
}
private static async Task<SequenceManifest> ManifestAsync(HttpClient client, Guid sequenceId)
{
using var response = await client.GetAsync($"/api/v1/sequences/{sequenceId}/manifest");
return await response.ReadAsync(ProtocolJson.Default.SequenceManifest);
}
}