using System.Net; using System.Net.Http.Headers; using System.Net.Http.Json; using Microsoft.Extensions.DependencyInjection; using Chronos.Core.Codecs.Jpeg; using Chronos.Core.Model; using Chronos.Protocol; using Chronos.Server.Storage; using Chronos.Testing; namespace Chronos.Server.Tests.Api; /// /// The library the admin panel manages (owner review 2, R6): sequence thumbnails, photos deleted into the trash, the trash /// listed, restored and emptied, and bulk operations, against the real archive engine. /// [Category("server")] public sealed class LibraryTests(TestContext context) { private static readonly TimeSpan Wait = TimeSpan.FromSeconds(TestTiming.Budget(30)); [Test] public async Task PhotosAreDeletedIntoTheTrashAndRestoredThroughTheApi() { await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); var (editor, _, _) = await server.UserAsync("alberto", "editor"); var (other, _, _) = await server.UserAsync("giulia", "editor"); var admin = await server.AdminAsync(); var photos = Enumerable.Range(0, 3).Select(Photo).ToList(); Guid? id = null; for (var i = 0; i < photos.Count; i++) id = (await Uploads.UploadAsync(editor, photos[i], $"IMG_{i + 1:0000}.JPG", sessionKey: "roof")).SequenceId; await UntilIdleAsync(server); var sequence = (await server.Database.Sequences.GetAsync(id!.Value))!; var frames = await server.Database.Frames.ListBySequenceAsync(sequence.Id); var url = $"/api/v1/sequences/{sequence.Id}/frames/delete"; using (var forbidden = await other.PostAsJsonAsync(url, new FrameDeleteRequest([frames[1].Id], null, false), ProtocolJson.Default.FrameDeleteRequest)) await forbidden.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden"); using (var none = await editor.PostAsJsonAsync(url, new FrameDeleteRequest([], null, false), ProtocolJson.Default.FrameDeleteRequest)) await none.ExpectErrorAsync(HttpStatusCode.BadRequest, "bad_request"); using (var stale = await editor.PostAsJsonAsync(url, new FrameDeleteRequest([frames[1].Id], sequence.FramesVersion - 1, false), ProtocolJson.Default.FrameDeleteRequest)) Assert.Equal(sequence.FramesVersion.ToString(System.Globalization.CultureInfo.InvariantCulture), (await stale.ExpectErrorAsync(HttpStatusCode.Conflict, "frames_conflict")).Details); using (var all = await editor.PostAsJsonAsync(url, new FrameDeleteRequest([.. frames.Select(f => f.Id)], null, false), ProtocolJson.Default.FrameDeleteRequest)) await all.ExpectErrorAsync(HttpStatusCode.Conflict, "would_empty"); using (var dry = await editor.PostAsJsonAsync(url, new FrameDeleteRequest([frames[1].Id], sequence.FramesVersion, true), ProtocolJson.Default.FrameDeleteRequest)) { var plan = await dry.ReadAsync(ProtocolJson.Default.FrameDeleteResultDto); Assert.True(plan.DryRun); Assert.Equal((1, frames[1].Size, 3), (plan.Photos, plan.Bytes, plan.FrameCount)); Assert.Null(plan.TrashEntry); } Assert.Count(3, await server.Database.Frames.ListBySequenceAsync(sequence.Id)); FrameDeleteResultDto done; using (var deleted = await editor.PostAsJsonAsync(url, new FrameDeleteRequest([frames[1].Id], sequence.FramesVersion, false), ProtocolJson.Default.FrameDeleteRequest)) done = await deleted.ReadAsync(ProtocolJson.Default.FrameDeleteResultDto); Assert.False(done.DryRun); Assert.Equal((2, sequence.FramesVersion + 1), (done.FrameCount, done.FramesVersion)); var name = Assert.NotNull(done.TrashEntry); Assert.FileMissing(Path.Combine(server.Options.ArchivePath, frames[1].RelativePath)); // The manifest names the deleted photo, so clients do not send it back; an upload of it is answered as already there. using (var manifest = await editor.GetAsync($"/api/v1/sequences/{sequence.Id}/manifest")) Assert.SequenceEqual([Uploads.Sha(photos[1])], Assert.NotNull((await manifest.ReadAsync(ProtocolJson.Default.SequenceManifest)).Removed).Select(r => r.Sha256)); var again = await Uploads.StartAsync(editor, photos[1], "IMG_0002.JPG", sequence.Id, expected: HttpStatusCode.OK); Assert.True(again.AlreadyExists); Assert.Null(again.FrameId); Assert.Count(2, await server.Database.Frames.ListBySequenceAsync(sequence.Id)); using (var notAdmin = await editor.GetAsync("/api/v1/archive/trash")) await notAdmin.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden"); using (var list = await admin.GetAsync("/api/v1/archive/trash")) { var trash = await list.ReadAsync(ProtocolJson.Default.TrashListDto); var entry = Assert.Contains(trash.Entries, e => e.Name == name); Assert.Equal(("photos", 1, sequence.Id, "alberto"), (entry.Kind, entry.Photos, entry.SequenceId, entry.DeletedBy)); Assert.Equal(frames[1].Size, trash.Bytes); } await UntilIdleAsync(server); using (var restored = await admin.PostAsync($"/api/v1/archive/trash/{name}/restore", null)) { var result = await restored.ReadAsync(ProtocolJson.Default.TrashRestoreDto); Assert.Equal(("photos", sequence.Id, 1, false), (result.Kind, result.SequenceId, result.Photos, result.NewSequence)); Assert.Empty(result.Kept); } Assert.SequenceEqual(frames.Select(f => f.Id), (await server.Database.Frames.ListBySequenceAsync(sequence.Id)).Select(f => f.Id)); using (var gone = await admin.PostAsync($"/api/v1/archive/trash/{name}/restore", null)) await gone.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found"); using (var bad = await admin.PostAsync("/api/v1/archive/trash/..%2F..%2Fsecret/restore", null)) Assert.Equal(HttpStatusCode.NotFound, bad.StatusCode); } [Test] public async Task TheTrashIsEmptiedByAJobAfterADryRunAndItsFingerprint() { await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); var (editor, _, _) = await server.UserAsync("alberto", "editor"); var admin = await server.AdminAsync(); var a = (await Uploads.UploadAsync(editor, Photo(10), "a.jpg", sessionKey: "a")).SequenceId; Guid b = default; for (var i = 0; i < 2; i++) b = (await Uploads.UploadAsync(editor, Photo(20 + i), $"b{i}.jpg", sessionKey: "b")).SequenceId; await UntilIdleAsync(server); using (var deleted = await editor.DeleteAsync($"/api/v1/sequences/{a}")) await deleted.ExpectAsync(HttpStatusCode.OK); var frames = await server.Database.Frames.ListBySequenceAsync(b); using (var photo = await editor.PostAsJsonAsync($"/api/v1/sequences/{b}/frames/delete", new FrameDeleteRequest([frames[0].Id], null, false), ProtocolJson.Default.FrameDeleteRequest)) await photo.ExpectAsync(HttpStatusCode.OK); await UntilIdleAsync(server); TrashEmptyPlanDto plan; using (var dry = await admin.PostAsJsonAsync("/api/v1/archive/trash/empty", new TrashEmptyRequest(null, true, null), ProtocolJson.Default.TrashEmptyRequest)) plan = await dry.ReadAsync(ProtocolJson.Default.TrashEmptyPlanDto); Assert.Equal(2, plan.Entries.Count); Assert.SequenceEqual(["photos", "sequence"], plan.Entries.Select(e => e.Kind).Order()); Assert.Equal(2, plan.Photos); using (var noPrint = await admin.PostAsJsonAsync("/api/v1/archive/trash/empty", new TrashEmptyRequest(null, false, null), ProtocolJson.Default.TrashEmptyRequest)) await noPrint.ExpectErrorAsync(HttpStatusCode.BadRequest, "bad_request"); using (var wrong = await admin.PostAsJsonAsync("/api/v1/archive/trash/empty", new TrashEmptyRequest(null, false, "0123"), ProtocolJson.Default.TrashEmptyRequest)) Assert.Equal(plan.Fingerprint, (await wrong.ExpectErrorAsync(HttpStatusCode.Conflict, "trash_changed")).Details); using (var names = await admin.PostAsJsonAsync("/api/v1/archive/trash/empty", new TrashEmptyRequest(["../x"], true, null), ProtocolJson.Default.TrashEmptyRequest)) await names.ExpectErrorAsync(HttpStatusCode.BadRequest, "bad_request"); JobDto job; using (var empty = await admin.PostAsJsonAsync("/api/v1/archive/trash/empty", new TrashEmptyRequest(null, false, plan.Fingerprint), ProtocolJson.Default.TrashEmptyRequest)) { await empty.ExpectAsync(HttpStatusCode.Accepted); job = await empty.ReadAsync(ProtocolJson.Default.JobDto); } Assert.Equal("empty-trash", job.Kind); await UntilJobAsync(admin, job.Id, "done"); using (var list = await admin.GetAsync("/api/v1/archive/trash")) Assert.Empty((await list.ReadAsync(ProtocolJson.Default.TrashListDto)).Entries); Assert.Empty(Directory.EnumerateFiles(server.Options.TrashPath, "*", SearchOption.AllDirectories)); Assert.Count(1, await server.Database.Frames.ListBySequenceAsync(b)); } [Test] public async Task BulkOperationsAnswerForEachSequence() { await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); var archive = server.Services.GetRequiredService(); var (editor, _, _) = await server.UserAsync("alberto", "editor"); var (other, _, _) = await server.UserAsync("giulia", "editor"); var a = (await Uploads.UploadAsync(editor, Photo(30), "a.jpg", sessionKey: "a")).SequenceId; var b = (await Uploads.UploadAsync(editor, Photo(31), "b.jpg", sessionKey: "b")).SequenceId; var c = (await Uploads.UploadAsync(other, Photo(32), "c.jpg", sessionKey: "c")).SequenceId; var unknown = Guid.CreateVersion7(); await UntilIdleAsync(server); using (var retag = await editor.PostAsJsonAsync("/api/v1/sequences/bulk/retag", new BulkRetagRequest([a, b, unknown], ["Night", "roof"], null), ProtocolJson.Default.BulkRetagRequest)) { var result = await retag.ReadAsync(ProtocolJson.Default.BulkResultDto); Assert.Equal((2, 1), (result.Ok, result.Skipped)); Assert.Equal("not_found", result.Items.Single(i => i.Id == unknown).Reason); } using (var untag = await editor.PostAsJsonAsync("/api/v1/sequences/bulk/retag", new BulkRetagRequest([a], ["sky"], ["NIGHT"]), ProtocolJson.Default.BulkRetagRequest)) await untag.ExpectAsync(HttpStatusCode.OK); Assert.SequenceEqual(["roof", "sky"], (await server.Database.Sequences.GetAsync(a))!.Tags.Order()); Assert.SequenceEqual(["Night", "roof"], (await server.Database.Sequences.GetAsync(b))!.Tags.Order()); using (var noTags = await editor.PostAsJsonAsync("/api/v1/sequences/bulk/retag", new BulkRetagRequest([a], null, null), ProtocolJson.Default.BulkRetagRequest)) await noTags.ExpectErrorAsync(HttpStatusCode.BadRequest, "bad_request"); // A verify of sequences targets their archive (it once targeted the sequences, which its handler cannot read). using (var verify = await editor.PostAsJsonAsync("/api/v1/sequences/bulk/jobs", new BulkJobsRequest([a, b, unknown], "verify"), ProtocolJson.Default.BulkJobsRequest)) { await verify.ExpectAsync(HttpStatusCode.Accepted); var result = await verify.ReadAsync(ProtocolJson.Default.BulkResultDto); var job = Assert.NotNull(result.Job); Assert.Equal(("verify", 2, 1), (job.Kind, result.Ok, result.Skipped)); Assert.SequenceEqual([archive.Id], job.TargetIds); await UntilJobAsync(editor, job.Id, "done"); } using (var single = await editor.PostAsJsonAsync("/api/v1/jobs", new CreateJobRequest("verify", [a], null), ProtocolJson.Default.CreateJobRequest)) { var job = await single.ReadAsync(ProtocolJson.Default.JobDto); Assert.SequenceEqual([archive.Id], job.TargetIds); await UntilJobAsync(editor, job.Id, "done"); } using (var thumbs = await editor.PostAsJsonAsync("/api/v1/sequences/bulk/jobs", new BulkJobsRequest([a, b], "thumbnails"), ProtocolJson.Default.BulkJobsRequest)) { var job = Assert.NotNull((await thumbs.ReadAsync(ProtocolJson.Default.BulkResultDto)).Job); Assert.Equal("thumbs", job.Kind); Assert.SequenceEqual([a, b], job.TargetIds); } using (var bogus = await editor.PostAsJsonAsync("/api/v1/sequences/bulk/jobs", new BulkJobsRequest([a], "render"), ProtocolJson.Default.BulkJobsRequest)) await bogus.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_job_kind"); await UntilIdleAsync(server); using (var dry = await editor.PostAsJsonAsync("/api/v1/sequences/bulk/delete", new BulkDeleteRequest([a, c, unknown], true), ProtocolJson.Default.BulkDeleteRequest)) { var result = await dry.ReadAsync(ProtocolJson.Default.BulkResultDto); Assert.True(result.DryRun); Assert.Equal(".chronos/trash/" + a.ToString("N"), result.Items[0].TrashFolder); Assert.SequenceEqual(["ok", "skipped", "skipped"], result.Items.Select(i => i.Outcome)); Assert.SequenceEqual([null, "forbidden", "not_found"], result.Items.Select(i => i.Reason)); Assert.Equal(1, result.Photos); } Assert.NotNull(await server.Database.Sequences.GetAsync(a)); using (var deleted = await editor.PostAsJsonAsync("/api/v1/sequences/bulk/delete", new BulkDeleteRequest([a, b], false), ProtocolJson.Default.BulkDeleteRequest)) Assert.Equal(2, (await deleted.ReadAsync(ProtocolJson.Default.BulkResultDto)).Ok); Assert.Null(await server.Database.Sequences.GetAsync(a)); Assert.Null(await server.Database.Sequences.GetAsync(b)); Assert.NotNull(await server.Database.Sequences.GetAsync(c)); } [Test] public async Task ASequenceThumbnailIsItsHeroFramesOrItsFirst() { await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); var (editor, _, _) = await server.UserAsync("alberto", "editor"); var first = await Uploads.UploadAsync(editor, Photo(40), "IMG_0001.JPG", sessionKey: "t"); var second = await Uploads.UploadAsync(editor, Photo(41), "IMG_0002.JPG", sessionKey: "t"); var id = first.SequenceId; var thumbs = new Dictionary(); foreach (var frame in new[] { first.FrameId, second.FrameId }) thumbs[frame] = await ThumbnailAsync(editor, $"/api/v1/frames/{frame}/thumb"); using (var cover = await editor.GetAsync($"/api/v1/sequences/{id}/thumb")) { await cover.ExpectAsync(HttpStatusCode.OK); var bytes = await cover.Content.ReadAsByteArrayAsync(); Assert.BytesEqual(thumbs[first.FrameId], bytes); var etag = Assert.NotNull(cover.Headers.ETag); using var request = new HttpRequestMessage(HttpMethod.Get, $"/api/v1/sequences/{id}/thumb"); request.Headers.IfNoneMatch.Add(etag); using var cached = await editor.SendAsync(request); Assert.Equal(HttpStatusCode.NotModified, cached.StatusCode); } using (var hero = await editor.PatchAsJsonAsync($"/api/v1/sequences/{id}", new UpdateSequenceRequest(null, null, null, null, null, null, second.FrameId), ProtocolJson.Default.UpdateSequenceRequest)) await hero.ExpectAsync(HttpStatusCode.OK); var heroThumb = await ThumbnailAsync(editor, $"/api/v1/sequences/{id}/thumb"); Assert.BytesEqual(thumbs[second.FrameId], heroThumb); using var created = await editor.PostAsJsonAsync("/api/v1/sequences", new CreateSequenceRequest("Empty", null), ProtocolJson.Default.CreateSequenceRequest); var empty = await created.ReadAsync(ProtocolJson.Default.SequenceDto); using (var none = await editor.GetAsync($"/api/v1/sequences/{empty.Id}/thumb")) await none.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found"); using (var unknown = await editor.GetAsync($"/api/v1/sequences/{Guid.CreateVersion7()}/thumb")) await unknown.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found"); } /// A thumbnail once its pass has drawn it (404 until then). private static async Task ThumbnailAsync(HttpClient client, string url) { var until = DateTime.UtcNow + Wait; while (true) { using var response = await client.GetAsync(url); if (response.StatusCode == HttpStatusCode.OK) return await response.Content.ReadAsByteArrayAsync(); Assert.True(DateTime.UtcNow < until, $"{url}: {(int)response.StatusCode}"); await Task.Delay(50); } } private static async Task UntilJobAsync(HttpClient client, Guid id, string state) { var until = DateTime.UtcNow + Wait; while (true) { using var response = await client.GetAsync($"/api/v1/jobs/{id}"); var job = await response.ReadAsync(ProtocolJson.Default.JobDto); if (job.State == state) return; if (job.State is "failed" or "cancelled") Assert.Fail($"job {job.Kind} {job.State}: {job.Error}\n{job.LogTail}"); Assert.True(DateTime.UtcNow < until, $"job {job.Kind} still {job.State}"); await Task.Delay(50); } } /// Waits until no job is queued or running (the thumbnails, proxies and analyses uploads queue). private static async Task UntilIdleAsync(TestServer server) { var until = DateTime.UtcNow + Wait; foreach (var state in new[] { JobState.Queued, JobState.Running, JobState.Queued, JobState.Running }) { while ((await server.Database.Jobs.ListAsync(state)).Items.Count > 0) { Assert.True(DateTime.UtcNow < until, $"jobs still {state}"); await Task.Delay(50); } } } private static byte[] Photo(int seed) { const int width = 96, height = 64; var pixels = new byte[width * height * 3]; for (var i = 0; i < pixels.Length; i++) pixels[i] = (byte)((i * 7 + seed * 31) % 251); return JpegEncoder.Encode(pixels, width, height, 3, new JpegEncodeOptions { Quality = 90 }); } }