Files
Chronos/tests/Titano.Server.Tests/Api/SequenceTests.cs
T
Claude 3f443eaacf fix(server): a refused sequence delete names its reason
DELETE /api/v1/sequences/{id} answers 503 archive_offline for an offline
archive, 409 sequence_busy for a busy sequence or a stale plan, and 409
archive_root, contains_sequences, sidecar_mismatch, folder_missing or
folder_in_use otherwise; a sequence deleted meanwhile is a 404.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
2026-10-05 22:06:31 +00:00

232 lines
13 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 ASequenceAJobWorksOnIsNotDeleted()
{
await using var server = await TestServer.StartAsync(context);
var (editor, _, _) = await server.UserAsync("alberto", "editor");
var frame = await Uploads.UploadAsync(editor, Uploads.Photo(3000, 35));
var sequence = (await server.Database.Sequences.GetAsync(frame.SequenceId))!;
await server.Database.Jobs.EnqueueAsync(new Titano.Core.Model.Job
{
Id = Guid.CreateVersion7(),
Kind = Titano.Core.Model.JobKind.Render,
TargetIds = [sequence.Id],
State = Titano.Core.Model.JobState.Running,
NodeId = "node#0",
Created = DateTimeOffset.UtcNow,
Started = DateTimeOffset.UtcNow,
});
using (var plan = await editor.DeleteAsync($"/api/v1/sequences/{sequence.Id}?dryRun=true")) await plan.ExpectErrorAsync(HttpStatusCode.Conflict, "sequence_busy");
using (var deleted = await editor.DeleteAsync($"/api/v1/sequences/{sequence.Id}")) await deleted.ExpectErrorAsync(HttpStatusCode.Conflict, "sequence_busy");
Assert.True(Directory.Exists(Path.Combine(server.Options.ArchivePath, sequence.Folder)));
Assert.NotNull(await server.Database.Sequences.GetAsync(sequence.Id));
}
[Test]
public async Task ADeleteThatCannotMoveSaysWhy()
{
await using var server = await TestServer.StartAsync(context);
var (editor, _, _) = await server.UserAsync("alberto", "editor");
var a = (await server.Database.Sequences.GetAsync((await Uploads.UploadAsync(editor, Uploads.Photo(3000, 36), "a.jpg", sessionKey: "a")).SequenceId))!;
var b = (await server.Database.Sequences.GetAsync((await Uploads.UploadAsync(editor, Uploads.Photo(3000, 37), "b.jpg", sessionKey: "b")).SequenceId))!;
Assert.NotEqual(a.Folder, b.Folder);
var archive = new Titano.Core.Archiving.ArchivePaths(server.Options.ArchivePath);
// The folder of b now holds a sidecar naming another sequence (copied over by hand): the index is out of date.
var sidecar = archive.Sequence(b.Folder).ManifestPath;
Directory.CreateDirectory(Path.GetDirectoryName(sidecar)!);
File.WriteAllText(sidecar, $$"""{"schemaVersion":1,"id":"{{a.Id}}"}""");
await RefusedAsync(editor, b.Id, "sidecar_mismatch");
Directory.Delete(archive.Sequence(a.Folder).Folder, recursive: true);
await RefusedAsync(editor, a.Id, "folder_missing");
Assert.NotNull(await server.Database.Sequences.GetAsync(a.Id));
Assert.NotNull(await server.Database.Sequences.GetAsync(b.Id));
// A sequence still waiting for its first photo has no folder: only its row goes.
using var created = await editor.PostAsJsonAsync("/api/v1/sequences", new CreateSequenceRequest("Waiting", null), ProtocolJson.Default.CreateSequenceRequest);
var empty = await created.ReadAsync(ProtocolJson.Default.SequenceDto);
using (var deleted = await editor.DeleteAsync($"/api/v1/sequences/{empty.Id}")) Assert.Null((await deleted.ReadAsync(ProtocolJson.Default.SequenceDeletePlan)).TrashFolder);
Assert.Null(await server.Database.Sequences.GetAsync(empty.Id));
static async Task RefusedAsync(HttpClient client, Guid id, string code)
{
using var response = await client.DeleteAsync($"/api/v1/sequences/{id}");
var error = await response.ExpectErrorAsync(HttpStatusCode.Conflict, code);
Assert.NotEqual(code, error.Message, "the code has a sentence");
}
}
[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);
}
}