Files
Chronos/tests/Titano.Server.Tests/Api/SequenceTests.cs
T
Claude 80b91d0585 test(server): auth, uploads, ranges, sync, jobs, render nodes, events
Covers bootstrap admin, sign-in failure, lockout and rate limit, token
revocation and expiry, 401 versus 403, CSRF on cookie sessions, the error
shape and API header, chunked upload happy path, resume, hash
short-circuit, damaged chunk, quota, Range on originals, thumbnails and
exports, path traversal, settings_version conflicts, job state
transitions with a fake handler, render node claim, heartbeat timeout and
reassignment, output upload, WebSocket progress events, the discovery
beacon, the Windows service command line and status rules, and a
PostgreSQL run (TITANO_TEST_PG).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
2026-10-02 12:28:47 +00:00

174 lines
9.8 KiB
C#

using System.Net;
using System.Net.Http.Headers;
using System.Net.Http.Json;
using Titano.Protocol;
using Titano.Testing;
namespace Titano.Server.Tests.Api;
[Category("server")]
public sealed class SequenceTests(TestContext context)
{
[Test]
public async Task ConcurrentSettingsEditsConflict()
{
await using var server = await TestServer.StartAsync(context);
var (alberto, _, _) = await server.UserAsync("alberto", "editor");
var (giulia, _, _) = await server.UserAsync("giulia", "editor");
using var created = await alberto.PostAsJsonAsync("/api/v1/sequences", new CreateSequenceRequest("Harbour sunset", null), ProtocolJson.Default.CreateSequenceRequest);
await created.ExpectAsync(HttpStatusCode.Created);
var sequence = await created.ReadAsync(ProtocolJson.Default.SequenceDto);
Assert.Equal(0, sequence.SettingsVersion);
using (var first = await alberto.PatchAsJsonAsync($"/api/v1/sequences/{sequence.Id}",
new UpdateSequenceRequest(null, ["sunset", "harbour"], 4, null, """{"deflicker":{"strength":0.8}}""", 0), ProtocolJson.Default.UpdateSequenceRequest))
{
await first.ExpectAsync(HttpStatusCode.OK);
var updated = await first.ReadAsync(ProtocolJson.Default.SequenceDto);
Assert.Equal(1, updated.SettingsVersion);
Assert.SequenceEqual(["harbour", "sunset"], updated.Tags);
Assert.Equal(4, updated.Rating);
}
using (var stale = await giulia.PatchAsJsonAsync($"/api/v1/sequences/{sequence.Id}",
new UpdateSequenceRequest(null, null, null, null, """{"deflicker":{"strength":0.2}}""", 0), ProtocolJson.Default.UpdateSequenceRequest))
{
var error = await stale.ExpectErrorAsync(HttpStatusCode.Conflict, "settings_conflict");
Assert.Equal("1", error.Details);
}
// The ETag of a fresh read works as If-Match.
using var read = await giulia.GetAsync($"/api/v1/sequences/{sequence.Id}");
var etag = Assert.NotNull(read.Headers.ETag);
using var request = new HttpRequestMessage(HttpMethod.Patch, $"/api/v1/sequences/{sequence.Id}")
{
Content = JsonContent.Create(new UpdateSequenceRequest(null, null, null, null, """{"deflicker":{"strength":0.2}}""", null), ProtocolJson.Default.UpdateSequenceRequest),
};
request.Headers.IfMatch.Add(etag);
using (var retried = await giulia.SendAsync(request))
{
await retried.ExpectAsync(HttpStatusCode.OK);
Assert.Equal(2, (await retried.ReadAsync(ProtocolJson.Default.SequenceDto)).SettingsVersion);
}
using var notModified = new HttpRequestMessage(HttpMethod.Get, $"/api/v1/sequences/{sequence.Id}");
notModified.Headers.IfNoneMatch.Add(etag);
using (var changed = await giulia.SendAsync(notModified)) await changed.ExpectAsync(HttpStatusCode.OK);
using var invalid = await giulia.PatchAsJsonAsync($"/api/v1/sequences/{sequence.Id}",
new UpdateSequenceRequest(null, null, null, null, "{ broken", null), ProtocolJson.Default.UpdateSequenceRequest);
await invalid.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_settings");
}
[Test]
public async Task TheManifestCarriesHashesAndAnEtag()
{
await using var server = await TestServer.StartAsync(context);
var (editor, _, _) = await server.UserAsync("alberto", "editor");
var a = Uploads.Photo(2000, 31);
var b = Uploads.Photo(2000, 32);
var first = await Uploads.UploadAsync(editor, a, "a.CR3", sessionKey: "k");
await Uploads.UploadAsync(editor, b, "b.CR3", sessionKey: "k");
using var response = await editor.GetAsync($"/api/v1/sequences/{first.SequenceId}/manifest");
await response.ExpectAsync(HttpStatusCode.OK);
var manifest = await response.ReadAsync(ProtocolJson.Default.SequenceManifest);
Assert.SequenceEqual([Uploads.Sha(a), Uploads.Sha(b)], manifest.Frames.Select(f => f.Sha256));
Assert.Equal(2, manifest.FramesVersion);
using var cached = new HttpRequestMessage(HttpMethod.Get, $"/api/v1/sequences/{first.SequenceId}/manifest");
cached.Headers.IfNoneMatch.Add(response.Headers.ETag!);
using (var unchanged = await editor.SendAsync(cached)) await unchanged.ExpectAsync(HttpStatusCode.NotModified);
await Uploads.UploadAsync(editor, Uploads.Photo(2000, 33), "c.CR3", sessionKey: "k");
using var again = new HttpRequestMessage(HttpMethod.Get, $"/api/v1/sequences/{first.SequenceId}/manifest");
again.Headers.IfNoneMatch.Add(response.Headers.ETag!);
using var changed = await editor.SendAsync(again);
await changed.ExpectAsync(HttpStatusCode.OK);
Assert.Count(3, (await changed.ReadAsync(ProtocolJson.Default.SequenceManifest)).Frames);
}
[Test]
public async Task ListingFiltersAndPagesWithACursor()
{
await using var server = await TestServer.StartAsync(context);
var (editor, _, _) = await server.UserAsync("alberto", "editor");
for (var i = 0; i < 5; i++)
{
using var created = await editor.PostAsJsonAsync("/api/v1/sequences", new CreateSequenceRequest($"Shoot {i}", null), ProtocolJson.Default.CreateSequenceRequest);
await created.ExpectAsync(HttpStatusCode.Created);
}
var seen = new List<string>();
string? cursor = null;
long? total = null;
do
{
using var page = await editor.GetAsync($"/api/v1/sequences?sort=title&limit=2{(cursor is null ? string.Empty : "&cursor=" + Uri.EscapeDataString(cursor))}");
await page.ExpectAsync(HttpStatusCode.OK);
var items = await page.ReadAsync(ProtocolJson.Default.PageSequenceDto);
total ??= items.Total;
seen.AddRange(items.Items.Select(s => s.DisplayTitle));
cursor = items.NextCursor;
}
while (cursor is not null);
Assert.Equal(5L, total);
Assert.SequenceEqual(["Shoot 0", "Shoot 1", "Shoot 2", "Shoot 3", "Shoot 4"], seen);
using (var search = await editor.GetAsync("/api/v1/sequences?q=shoot%203")) Assert.Count(1, (await search.ReadAsync(ProtocolJson.Default.PageSequenceDto)).Items);
using (var badCursor = await editor.GetAsync("/api/v1/sequences?cursor=bm9wZQ")) await badCursor.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_cursor");
using var badStatus = await editor.GetAsync("/api/v1/sequences?status=shiny");
await badStatus.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_filter");
}
[Test]
public async Task DeletingPlansFirstAndMovesTheFolderToTrash()
{
await using var server = await TestServer.StartAsync(context);
var (editor, _, _) = await server.UserAsync("alberto", "editor");
var (other, _, _) = await server.UserAsync("giulia", "editor");
var frame = await Uploads.UploadAsync(editor, Uploads.Photo(3000, 34));
var sequence = (await server.Database.Sequences.GetAsync(frame.SequenceId))!;
var folder = Path.Combine(server.Options.ArchivePath, sequence.Folder);
using (var notOwner = await other.DeleteAsync($"/api/v1/sequences/{sequence.Id}")) await notOwner.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden");
using (var plan = await editor.DeleteAsync($"/api/v1/sequences/{sequence.Id}?dryRun=true"))
{
var dryRun = await plan.ReadAsync(ProtocolJson.Default.SequenceDeletePlan);
Assert.True(dryRun.DryRun);
Assert.Equal(1, dryRun.FrameCount);
Assert.Equal($".titano/trash/{sequence.Id:N}", dryRun.TrashFolder);
}
Assert.True(Directory.Exists(folder), "a dry run changes nothing");
Assert.NotNull(await server.Database.Sequences.GetAsync(sequence.Id));
using (var deleted = await editor.DeleteAsync($"/api/v1/sequences/{sequence.Id}")) await deleted.ExpectAsync(HttpStatusCode.OK);
Assert.False(Directory.Exists(folder));
Assert.True(Directory.Exists(Path.Combine(server.Options.TrashPath, sequence.Id.ToString("N"))), "the files are kept in the trash");
Assert.Null(await server.Database.Sequences.GetAsync(sequence.Id));
using var gone = await editor.GetAsync($"/api/v1/sequences/{sequence.Id}");
await gone.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found");
}
[Test]
public async Task FramesAndStatsArePaged()
{
await using var server = await TestServer.StartAsync(context);
var (editor, _, _) = await server.UserAsync("alberto", "editor");
var first = await Uploads.UploadAsync(editor, Uploads.Photo(1000, 40), "f0.jpg", sessionKey: "p");
for (var i = 1; i < 4; i++) await Uploads.UploadAsync(editor, Uploads.Photo(1000 + i, 40 + i), $"f{i}.jpg", sessionKey: "p");
var id = first.SequenceId;
using var page1 = await editor.GetAsync($"/api/v1/sequences/{id}/frames?limit=2");
var frames = await page1.ReadAsync(ProtocolJson.Default.PageFrameDto);
Assert.SequenceEqual([0, 1], frames.Items.Select(f => f.Index));
using var page2 = await editor.GetAsync($"/api/v1/sequences/{id}/frames?limit=2&cursor={Uri.EscapeDataString(frames.NextCursor!)}");
Assert.SequenceEqual([2, 3], (await page2.ReadAsync(ProtocolJson.Default.PageFrameDto)).Items.Select(f => f.Index));
using var stats = await editor.GetAsync($"/api/v1/sequences/{id}/stats");
var dto = await stats.ReadAsync(ProtocolJson.Default.SequenceStatsDto);
Assert.Equal(4, dto.FrameCount);
Assert.Equal(4L, dto.ByFormat.Sum(f => f.Count));
using var analysis = await editor.GetAsync($"/api/v1/sequences/{id}/analysis");
Assert.Equal("analysis", (await analysis.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found")).Details);
}
}