Owner review 2, R6: the web panel manages the library without editing it, so the engine and the server must delete single photos safely, keep them out of sync afterwards, and let an administrator restore or finally erase the trash. - Migration 0008: frame_removals (tombstones by sequence and SHA-256, reason, replacement); the sidecar gains "removed" (omitted when empty) and frames a reserved "source"; the indexer writes the tombstones on every sync, so a rebuild keeps them, and drops a hero frame that is gone. - FrameTrash: dry run (busy, frames changed, offline, would empty), delete under the sequence lease with a write-ahead journal that the next writer undoes after a crash, files to trash/photos/<seq>-<time>/originals with a record, sidecar without the frames plus tombstones, index sync clearing analyses, thumbnails and proxies, proxies renamed to follow their frames, follow-up jobs. Restore re-hashes every file, keeps mismatches in the trash, puts the same frame records back and drops their tombstones, or files the photos into a new sequence through the ingest when theirs is gone. - Project positions on vanished photos are translated by photo and wait as pending frames, so they come back with a restore. - Trash entries have a kind (sequence, photos, replaced); emptying is a dry run with a fingerprint and a new EmptyTrash job (18) that erases exactly the planned entries, refuses a stale plan and erases replaced originals only while their replacements still hash right. - Sync honours tombstones: nothing one side deleted is offered back, local files are never deleted, replaced photos count as their replacement; the server answers an upload of a tombstoned SHA-256 as already there. - Server: sequence thumbnail, photo delete, bulk delete/retag/jobs, trash list/restore/empty endpoints with their error messages; a verify of sequences now targets their archive (POST /jobs failed before). - Desktop trash dialog lists photo entries and empties the trash after a typed confirmation through the same job. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 35bb56690a1d69eae57153d036e1409201cd73f7)
294 lines
18 KiB
C#
294 lines
18 KiB
C#
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;
|
|
|
|
/// <summary>
|
|
/// 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.
|
|
/// </summary>
|
|
[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<ServerArchive>();
|
|
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<string?>([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<Guid, byte[]>();
|
|
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");
|
|
}
|
|
|
|
/// <summary>A thumbnail once its pass has drawn it (404 until then).</summary>
|
|
private static async Task<byte[]> 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);
|
|
}
|
|
}
|
|
|
|
/// <summary>Waits until no job is queued or running (the thumbnails, proxies and analyses uploads queue).</summary>
|
|
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 });
|
|
}
|
|
}
|