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.Data.Archiving; 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); // The audit log records the request: the job checks the plan again when it runs and may erase nothing. var requests = (await server.Database.Audit.ListAsync(null, "trash_empty_requested", 50, null, context.Cancellation)).Items; Assert.Count(1, requests); Assert.Equal(("job", job.Id.ToString()), (requests[0].TargetKind, requests[0].TargetId)); Assert.True(requests[0].Details?.StartsWith($"2 · {plan.Bytes} · ", StringComparison.Ordinal) == true, requests[0].Details); Assert.Empty((await server.Database.Audit.ListAsync(null, "trash_emptied", 50, null, context.Cancellation)).Items); 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 EmptyingNamedEntriesErasesOnlyThose() { 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(50), "a.jpg", sessionKey: "a")).SequenceId; Guid b = default; for (var i = 0; i < 2; i++) b = (await Uploads.UploadAsync(editor, Photo(51 + 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 photo = await DeletePhotoAsync(editor, b, (await server.Database.Frames.ListBySequenceAsync(b))[0].Id); await UntilIdleAsync(server); TrashEmptyPlanDto plan; using (var dry = await admin.PostAsJsonAsync("/api/v1/archive/trash/empty", new TrashEmptyRequest([photo], true, null), ProtocolJson.Default.TrashEmptyRequest)) plan = await dry.ReadAsync(ProtocolJson.Default.TrashEmptyPlanDto); Assert.SequenceEqual([photo], plan.Entries.Select(e => e.Name)); using (var empty = await admin.PostAsJsonAsync("/api/v1/archive/trash/empty", new TrashEmptyRequest([photo], false, plan.Fingerprint), ProtocolJson.Default.TrashEmptyRequest)) await UntilJobAsync(admin, (await empty.ReadAsync(ProtocolJson.Default.JobDto)).Id, "done"); // Only the named entry went: the deleted sequence is still listed, its folder still there. using (var list = await admin.GetAsync("/api/v1/archive/trash")) Assert.SequenceEqual([a.ToString("N")], (await list.ReadAsync(ProtocolJson.Default.TrashListDto)).Entries.Select(e => e.Name)); Assert.True(Directory.Exists(Path.Combine(server.Options.TrashPath, a.ToString("N")))); Assert.False(Directory.Exists(PhotoEntryFolder(server, photo))); } [Test] public async Task TheDeletedSequenceComesBackAndASecondCopyIsRefused() { await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); var (editor, _, _) = await server.UserAsync("alberto", "editor"); var admin = await server.AdminAsync(); Guid id = default; for (var i = 0; i < 2; i++) id = (await Uploads.UploadAsync(editor, Photo(60 + i), $"IMG_{i + 1:0000}.JPG", sessionKey: "s")).SequenceId; await UntilIdleAsync(server); var row = (await server.Database.Sequences.GetAsync(id))!; using (var deleted = await editor.DeleteAsync($"/api/v1/sequences/{id}")) await deleted.ExpectAsync(HttpStatusCode.OK); var name = id.ToString("N"); // The index holds that sequence again (scanned back, or restored elsewhere): this copy cannot come back over it. await server.Database.Sequences.UpsertAsync(row); using (var twice = await admin.PostAsync($"/api/v1/archive/trash/{name}/restore", null)) await twice.ExpectErrorAsync(HttpStatusCode.Conflict, "sequence_in_library"); Assert.True(Directory.Exists(Path.Combine(server.Options.TrashPath, name))); await server.Database.Sequences.DeleteAsync(id); using (var restored = await admin.PostAsync($"/api/v1/archive/trash/{name}/restore", null)) { var result = await restored.ReadAsync(ProtocolJson.Default.TrashRestoreDto); Assert.Equal(("sequence", id, 2, false), (result.Kind, result.SequenceId, result.Photos, result.NewSequence)); } Assert.Count(2, await server.Database.Frames.ListBySequenceAsync(id)); Assert.False(Directory.Exists(Path.Combine(server.Options.TrashPath, name))); } [Test] public async Task PhotosOfADeletedSequenceComeBackAsANewOne() { await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); var (editor, _, _) = await server.UserAsync("alberto", "editor"); var admin = await server.AdminAsync(); Guid id = default; for (var i = 0; i < 3; i++) id = (await Uploads.UploadAsync(editor, Photo(70 + i), $"IMG_{i + 1:0000}.JPG", sessionKey: "gone")).SequenceId; await UntilIdleAsync(server); var frames = await server.Database.Frames.ListBySequenceAsync(id); var name = await DeletePhotoAsync(editor, id, frames[1].Id); await UntilIdleAsync(server); using (var deleted = await editor.DeleteAsync($"/api/v1/sequences/{id}")) await deleted.ExpectAsync(HttpStatusCode.OK); TrashRestoreDto result; using (var restored = await admin.PostAsync($"/api/v1/archive/trash/{name}/restore", null)) result = await restored.ReadAsync(ProtocolJson.Default.TrashRestoreDto); Assert.Equal(("photos", 1, true), (result.Kind, result.Photos, result.NewSequence)); Assert.NotEqual(id, result.SequenceId); Assert.SequenceEqual([frames[1].Sha256], (await server.Database.Frames.ListBySequenceAsync(result.SequenceId)).Select(f => f.Sha256)); } [Test] public async Task ADamagedSidecarOrEntryIsAnsweredWithItsOwnCode() { await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); var (editor, _, _) = await server.UserAsync("alberto", "editor"); var admin = await server.AdminAsync(); var photos = Enumerable.Range(0, 3).Select(i => Photo(80 + i)).ToList(); Guid s = default; for (var i = 0; i < photos.Count; i++) s = (await Uploads.UploadAsync(editor, photos[i], $"IMG_{i + 1:0000}.JPG", sessionKey: "s")).SequenceId; var t = (await Uploads.UploadAsync(editor, Photo(90), "other.jpg", sessionKey: "t")).SequenceId; await UntilIdleAsync(server); var frames = await server.Database.Frames.ListBySequenceAsync(s); var name = await DeletePhotoAsync(editor, s, frames[1].Id); await UntilIdleAsync(server); var archive = new Chronos.Core.Archiving.ArchivePaths(server.Options.ArchivePath); var sidecar = archive.Sequence((await server.Database.Sequences.GetAsync(s))!.Folder).ManifestPath; var other = archive.Sequence((await server.Database.Sequences.GetAsync(t))!.Folder).ManifestPath; var own = await File.ReadAllBytesAsync(sidecar, context.Cancellation); // The sequence's folder holds another sequence's sidecar: said as such, not as a damaged trash entry or a server error. File.Copy(other, sidecar, overwrite: true); try { using (var restore = await admin.PostAsync($"/api/v1/archive/trash/{name}/restore", null)) await restore.ExpectErrorAsync(HttpStatusCode.Conflict, "sidecar_mismatch"); using (var delete = await editor.PostAsJsonAsync($"/api/v1/sequences/{s}/frames/delete", new FrameDeleteRequest([frames[0].Id], null, false), ProtocolJson.Default.FrameDeleteRequest)) await delete.ExpectErrorAsync(HttpStatusCode.Conflict, "sidecar_mismatch"); } finally { await File.WriteAllBytesAsync(sidecar, own, context.Cancellation); } Assert.Count(2, await server.Database.Frames.ListBySequenceAsync(s)); Assert.FileExists(Path.Combine(server.Options.ArchivePath, frames[0].RelativePath)); // The entry's own file no longer matches its record: that is the trash mismatch, and the entry stays. var trashed = Path.Combine(PhotoEntryFolder(server, name), "originals", Path.GetFileName(frames[1].RelativePath)); var bytes = await File.ReadAllBytesAsync(trashed, context.Cancellation); bytes[^10] ^= 0x01; await File.WriteAllBytesAsync(trashed, bytes, context.Cancellation); using (var mismatch = await admin.PostAsync($"/api/v1/archive/trash/{name}/restore", null)) await mismatch.ExpectErrorAsync(HttpStatusCode.UnprocessableEntity, "trash_mismatch"); Assert.FileExists(trashed); // A deleted sequence whose own sidecar names another sequence does not match its record either; its folder stays in the trash. using (var deleted = await editor.DeleteAsync($"/api/v1/sequences/{t}")) await deleted.ExpectAsync(HttpStatusCode.OK); var entry = t.ToString("N"); File.Copy(sidecar, archive.Sequence(".chronos/trash/" + entry).ManifestPath, overwrite: true); using (var foreign = await admin.PostAsync($"/api/v1/archive/trash/{entry}/restore", null)) await foreign.ExpectErrorAsync(HttpStatusCode.UnprocessableEntity, "trash_mismatch"); Assert.True(Directory.Exists(Path.Combine(server.Options.TrashPath, entry))); Assert.Null(await server.Database.Sequences.GetAsync(t)); } [Test] public async Task ARestoreSaysWhichPhotosStayedAndWhy() { await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); var (editor, _, _) = await server.UserAsync("alberto", "editor"); var admin = await server.AdminAsync(); Guid id = default; for (var i = 0; i < 4; i++) id = (await Uploads.UploadAsync(editor, Photo(120 + i), $"IMG_{i + 1:0000}.JPG", sessionKey: "kept")).SequenceId; await UntilIdleAsync(server); var frames = await server.Database.Frames.ListBySequenceAsync(id); string name; using (var deleted = await editor.PostAsJsonAsync($"/api/v1/sequences/{id}/frames/delete", new FrameDeleteRequest([frames[1].Id, frames[2].Id], null, false), ProtocolJson.Default.FrameDeleteRequest)) name = Assert.NotNull((await deleted.ReadAsync(ProtocolJson.Default.FrameDeleteResultDto)).TrashEntry); await UntilIdleAsync(server); var trashed = Path.Combine(PhotoEntryFolder(server, name), "originals", Path.GetFileName(frames[2].RelativePath)); var bytes = await File.ReadAllBytesAsync(trashed, context.Cancellation); bytes[^10] ^= 0x01; await File.WriteAllBytesAsync(trashed, bytes, context.Cancellation); using var restored = await admin.PostAsync($"/api/v1/archive/trash/{name}/restore", null); var result = await restored.ReadAsync(ProtocolJson.Default.TrashRestoreDto); Assert.Equal(1, result.Photos); Assert.SequenceEqual([frames[2].OriginalFileName!], result.Kept); Assert.SequenceEqual(["mismatch"], Assert.NotNull(result.KeptReasons)); Assert.Equal(KeptPhoto.Sentence(KeptReason.Mismatch, 1, System.Globalization.CultureInfo.GetCultureInfo("en")), result.Message); } [Test] [WindowsOnly] public async Task APhotoNeverHashedIsDeletedUnlessItCannotBeRead() { await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); var admin = await server.AdminAsync(); // Photos copied into the archive by hand and scanned: adopted, never hashed. var shoot = Path.Combine(server.Options.ArchivePath, "Shoot"); Directory.CreateDirectory(shoot); for (var i = 0; i < 3; i++) await File.WriteAllBytesAsync(Path.Combine(shoot, $"IMG_{i + 1:0000}.JPG"), Photo(130 + i), context.Cancellation); var archives = server.Services.GetRequiredService(); await archives.Indexer.ScanAsync(server.Services.GetRequiredService().Current, ScanMode.Incremental, null, _ => ValueTask.CompletedTask, context.Cancellation); await UntilIdleAsync(server); var id = (await server.Database.Sequences.ListLocationsAsync(server.Services.GetRequiredService().Id)).Single(l => l.Folder == "Shoot").Id; var frames = await server.Database.Frames.ListBySequenceAsync(id); Assert.True(frames.All(f => f.Sha256 is null), "adopted, not verified"); var url = $"/api/v1/sequences/{id}/frames/delete"; // Another program holds one: it cannot be hashed for its tombstone, and the answer names it (no frames_conflict loop). var held = Path.Combine(server.Options.ArchivePath, frames[1].RelativePath); using (new FileStream(held, FileMode.Open, FileAccess.Read, FileShare.None)) { using var refused = await admin.PostAsJsonAsync(url, new FrameDeleteRequest([frames[1].Id], null, false), ProtocolJson.Default.FrameDeleteRequest); var error = await refused.ExpectErrorAsync(HttpStatusCode.Conflict, "photo_unreadable"); Assert.Equal("1", error.Details); Assert.Contains("IMG_0002.JPG", error.Message); } Assert.FileExists(held); // One whose original is gone has nothing left to hash: it goes, without a tombstone. File.Delete(Path.Combine(server.Options.ArchivePath, frames[2].RelativePath)); using (var gone = await admin.PostAsJsonAsync(url, new FrameDeleteRequest([frames[2].Id], null, false), ProtocolJson.Default.FrameDeleteRequest)) Assert.NotNull((await gone.ReadAsync(ProtocolJson.Default.FrameDeleteResultDto)).TrashEntry); Assert.Empty(await server.Database.FrameRemovals.ListBySequenceAsync(id)); Assert.SequenceEqual([frames[0].Id, frames[1].Id], (await server.Database.Frames.ListBySequenceAsync(id)).Select(f => f.Id)); } [Test] public async Task APhotoDeleteTakesAsManyIdsAsItsLimit() { // 100,000 ids are about 3.9 MB of JSON, above the server's 1 MiB for other bodies: the route has its own limit. await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); var (editor, _, _) = await server.UserAsync("alberto", "editor"); var id = (await Uploads.UploadAsync(editor, Photo(100), "IMG_0001.JPG", sessionKey: "many")).SequenceId; await Uploads.UploadAsync(editor, Photo(101), "IMG_0002.JPG", sessionKey: "many"); await UntilIdleAsync(server); var url = $"/api/v1/sequences/{id}/frames/delete"; var ids = Enumerable.Range(0, Chronos.Server.Api.LibraryEndpoints.MaxFrameIds).Select(_ => Guid.CreateVersion7()).ToList(); // Read whole and planned: those ids are not the sequence's photos. using (var most = await editor.PostAsJsonAsync(url, new FrameDeleteRequest(ids, null, true), ProtocolJson.Default.FrameDeleteRequest)) await most.ExpectErrorAsync(HttpStatusCode.Conflict, "frames_conflict"); ids.Add(Guid.CreateVersion7()); using (var tooMany = await editor.PostAsJsonAsync(url, new FrameDeleteRequest(ids, null, true), ProtocolJson.Default.FrameDeleteRequest)) Assert.Equal("frameIds", (await tooMany.ExpectErrorAsync(HttpStatusCode.BadRequest, "bad_request")).Details); Assert.Count(2, await server.Database.Frames.ListBySequenceAsync(id)); } [Test] public async Task WithTheArchiveOfflineTheTrashAndDeletesAnswerArchiveOffline() { await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); var (editor, _, _) = await server.UserAsync("alberto", "editor"); var admin = await server.AdminAsync(); Guid id = default; for (var i = 0; i < 2; i++) id = (await Uploads.UploadAsync(editor, Photo(110 + i), $"IMG_{i + 1:0000}.JPG", sessionKey: "off")).SequenceId; await UntilIdleAsync(server); var frames = await server.Database.Frames.ListBySequenceAsync(id); var name = await DeletePhotoAsync(editor, id, frames[0].Id); await UntilIdleAsync(server); // The archive drive is gone: the trash is not empty, it cannot be read. var manifest = new Chronos.Core.Archiving.ArchivePaths(server.Options.ArchivePath).ManifestPath; File.Move(manifest, manifest + ".away"); try { using (var list = await admin.GetAsync("/api/v1/archive/trash")) await list.ExpectErrorAsync(HttpStatusCode.ServiceUnavailable, "archive_offline"); using (var dry = await admin.PostAsJsonAsync("/api/v1/archive/trash/empty", new TrashEmptyRequest(null, true, null), ProtocolJson.Default.TrashEmptyRequest)) await dry.ExpectErrorAsync(HttpStatusCode.ServiceUnavailable, "archive_offline"); using (var empty = await admin.PostAsJsonAsync("/api/v1/archive/trash/empty", new TrashEmptyRequest(null, false, "0123"), ProtocolJson.Default.TrashEmptyRequest)) await empty.ExpectErrorAsync(HttpStatusCode.ServiceUnavailable, "archive_offline"); using (var restore = await admin.PostAsync($"/api/v1/archive/trash/{name}/restore", null)) await restore.ExpectErrorAsync(HttpStatusCode.ServiceUnavailable, "archive_offline"); using (var delete = await editor.PostAsJsonAsync($"/api/v1/sequences/{id}/frames/delete", new FrameDeleteRequest([frames[1].Id], null, true), ProtocolJson.Default.FrameDeleteRequest)) await delete.ExpectErrorAsync(HttpStatusCode.ServiceUnavailable, "archive_offline"); using (var bulk = await editor.PostAsJsonAsync("/api/v1/sequences/bulk/delete", new BulkDeleteRequest([id], false), ProtocolJson.Default.BulkDeleteRequest)) { var items = (await bulk.ReadAsync(ProtocolJson.Default.BulkResultDto)).Items; Assert.Count(1, items); Assert.Equal(("skipped", "archive_offline"), (items[0].Outcome, items[0].Reason)); } } finally { File.Move(manifest + ".away", manifest); } Assert.Empty((await server.Database.Jobs.ListAsync(JobState.Queued)).Items.Where(j => j.Kind == JobKind.EmptyTrash)); using (var back = await admin.GetAsync("/api/v1/archive/trash")) Assert.SequenceEqual([name], (await back.ReadAsync(ProtocolJson.Default.TrashListDto)).Entries.Select(e => e.Name)); Assert.NotNull(await server.Database.Sequences.GetAsync(id)); } [Test] public async Task OnlyTheirOwnersAndAdminsChangeSequencesInBulk() { 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 admin = await server.AdminAsync(); Guid a = default; for (var i = 0; i < 2; i++) a = (await Uploads.UploadAsync(editor, Photo(120 + i), $"IMG_{i + 1:0000}.JPG", sessionKey: "a")).SequenceId; var b = (await Uploads.UploadAsync(editor, Photo(130), "b.jpg", sessionKey: "b")).SequenceId; await UntilIdleAsync(server); using (var delete = await viewer.PostAsJsonAsync("/api/v1/sequences/bulk/delete", new BulkDeleteRequest([b], true), ProtocolJson.Default.BulkDeleteRequest)) await delete.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden"); using (var retag = await viewer.PostAsJsonAsync("/api/v1/sequences/bulk/retag", new BulkRetagRequest([b], ["x"], null), ProtocolJson.Default.BulkRetagRequest)) await retag.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden"); using (var jobs = await viewer.PostAsJsonAsync("/api/v1/sequences/bulk/jobs", new BulkJobsRequest([b], "thumbnails"), ProtocolJson.Default.BulkJobsRequest)) await jobs.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden"); using (var photos = await viewer.PostAsJsonAsync($"/api/v1/sequences/{a}/frames/delete", new FrameDeleteRequest([(await server.Database.Frames.ListBySequenceAsync(a))[0].Id], null, true), ProtocolJson.Default.FrameDeleteRequest)) await photos.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden"); // An admin deletes photos and sequences of any user. var frame = (await server.Database.Frames.ListBySequenceAsync(a))[0].Id; using (var photo = await admin.PostAsJsonAsync($"/api/v1/sequences/{a}/frames/delete", new FrameDeleteRequest([frame], null, false), ProtocolJson.Default.FrameDeleteRequest)) Assert.NotNull((await photo.ReadAsync(ProtocolJson.Default.FrameDeleteResultDto)).TrashEntry); await UntilIdleAsync(server); using (var bulk = await admin.PostAsJsonAsync("/api/v1/sequences/bulk/delete", new BulkDeleteRequest([b], false), ProtocolJson.Default.BulkDeleteRequest)) Assert.SequenceEqual(["ok"], (await bulk.ReadAsync(ProtocolJson.Default.BulkResultDto)).Items.Select(i => i.Outcome)); Assert.Null(await server.Database.Sequences.GetAsync(b)); Assert.Count(1, await server.Database.Frames.ListBySequenceAsync(a)); } [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"); } [Test] public async Task TheLibraryFiltersOfferTheArchivesYearsCamerasAndTags() { // The panel's Year, Camera and Tag menus list what the archive has, each with its count, in the values the listing takes. await using var server = await TestServer.StartAsync(context); var archive = server.Services.GetRequiredService(); var (viewer, _, _) = await server.UserAsync("vera", "viewer"); Sequence Seq(DateTime? first, string? make, string? model, params string[] tags) => new() { Id = Guid.CreateVersion7(), ArchiveId = archive.Id, Folder = $"2026/{Guid.NewGuid():N}", CameraMake = make, CameraModel = model, FirstCapture = first, LastCapture = first?.AddHours(1), Tags = tags, UpdatedAt = DateTimeOffset.UtcNow, }; var sony = Seq(new DateTime(2025, 3, 4), "SONY", "ILCE-7M4") with { RenderedCount = 2 }; foreach (var s in new[] { Seq(new DateTime(2024, 5, 1), "Canon", "Canon EOS R5", "Night", "roof"), Seq(new DateTime(2025, 1, 2), "Canon", "Canon EOS R5", "night"), sony, Seq(new DateTime(2023, 8, 9), "NIKON CORPORATION", "NIKON Z 8"), Seq(null, null, null), }) await server.Database.Sequences.UpsertAsync(s); LibraryFacetsDto facets; using (var response = await viewer.GetAsync("/api/v1/sequences/facets")) facets = await response.ReadAsync(ProtocolJson.Default.LibraryFacetsDto); Assert.SequenceEqual([new FacetDto("2025", 2), new FacetDto("2024", 1), new FacetDto("2023", 1)], facets.Years); // Labelled as the desktop names cameras: the brand once. Assert.SequenceEqual([new FacetDto("Canon EOS R5", 2, "Canon EOS R5"), new FacetDto("ILCE-7M4", 1, "SONY ILCE-7M4"), new FacetDto("NIKON Z 8", 1, "Nikon Z 8")], facets.Cameras); Assert.SequenceEqual([new FacetDto("Night", 2), new FacetDto("roof", 1)], facets.Tags); async Task CountAsync(string query) { using var page = await viewer.GetAsync($"/api/v1/sequences?{query}"); return (await page.ReadAsync(ProtocolJson.Default.PageSequenceDto)).Items.Count; } Assert.Equal(2, await CountAsync("year=2025")); Assert.Equal(1, await CountAsync("camera=ILCE-7M4")); Assert.Equal(2, await CountAsync("tag=night")); // The Status menu's Rendered and Not rendered. Assert.Equal(1, await CountAsync("rendered=true")); Assert.Equal(4, await CountAsync("rendered=false")); using var unknown = await viewer.GetAsync("/api/v1/sequences/facets/x"); Assert.Equal(HttpStatusCode.NotFound, unknown.StatusCode); } /// Deletes one photo of a sequence into the trash; returns the entry's name. private static async Task DeletePhotoAsync(HttpClient client, Guid sequenceId, Guid frameId) { using var response = await client.PostAsJsonAsync($"/api/v1/sequences/{sequenceId}/frames/delete", new FrameDeleteRequest([frameId], null, false), ProtocolJson.Default.FrameDeleteRequest); return Assert.NotNull((await response.ReadAsync(ProtocolJson.Default.FrameDeleteResultDto)).TrashEntry); } /// The folder of a photo entry in the archive's trash. private static string PhotoEntryFolder(TestServer server, string name) => Path.Combine(server.Options.TrashPath, Chronos.Data.Archiving.FrameTrash.FolderName, name[Chronos.Data.Archiving.FrameTrash.EntryPrefix.Length..]); /// 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 }); } }