Files
Chronos/tests/Chronos.Server.Tests/Api/LibraryTests.cs
T
Alby96 d0bbd77c92 fix(archive): settle conversions by content and keep their aliases through trash, undo, sync and ingest
Owner review 2, phase 4b, fix round 1 (trash, undo, recovery, sync and ingest).

- Replace journal: records a phase (moving, written, undoing) and the name each swapped
  frame is filed under. Recovery decides "sidecar written" by what the sidecar lists, not
  by the frames version any writer moves; a failed rollback stays undoing and its failure
  now stops the writer (as a photo deletion's recovery does). The ingest settles restores
  and replacements first, so an upload can no longer complete a swap that never happened.
- Emptying a Replaced entry re-verifies each replacement where it is now: in the sequence
  through later conversions (a second conversion no longer strands the first originals),
  or, when the conversion was deleted, its copy in the trash. The dry run marks such
  entries "conversion deleted" (fingerprinted, shown on the desktop and the panel), and
  the confirmed emptying may then erase them instead of keeping them forever.
- Undo of a conversion takes exactly the entries its job made (the job id is recorded on
  the entry), never entries found by time window.
- Project positions translated by photo use the sidecar's photo of every frame still
  there, so positions on a converted frame stay put when another frame went meanwhile.
- Sync aliases are equivalence classes: an original converted on both sides is one photo;
  link-by-content, proxy counting and proxy upload follow aliases; a download into a
  frame missing here swaps the other encoding into that frame instead of adding a frame.
- The ingest answers a converted photo's original (a card or folder imported again, a
  download) as a duplicate of its conversion and keeps the alias tombstone.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
(cherry picked from commit 3341a2f845753fc4c5bcba51a3b645f126c95eaf)
2026-10-27 22:13:36 +01:00

699 lines
45 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.Data.Archiving;
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);
// 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<ArchiveService>();
await archives.Indexer.ScanAsync(server.Services.GetRequiredService<ServerArchive>().Current, ScanMode.Incremental, null, _ => ValueTask.CompletedTask,
context.Cancellation);
await UntilIdleAsync(server);
var id = (await server.Database.Sequences.ListLocationsAsync(server.Services.GetRequiredService<ServerArchive>().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<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");
}
[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<ServerArchive>();
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<int> 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);
}
[Test]
public async Task TheDryRunSaysWhichReplacedOriginalsLostTheirConversion()
{
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(70 + i), $"IMG_{i + 1:0000}.JPG", sessionKey: "roof")).SequenceId;
await UntilIdleAsync(server);
var request = new ConvertRequest([id], false, "tiff16", null, "replace", DryRun: true);
ConvertPlanDto convert;
using (var dry = await admin.PostAsJsonAsync("/api/v1/archive/convert", request, ProtocolJson.Default.ConvertRequest))
convert = await dry.ReadAsync(ProtocolJson.Default.ConvertPlanDto);
using (var applied = await admin.PostAsJsonAsync("/api/v1/archive/convert", request with { DryRun = false, Fingerprint = convert.Fingerprint },
ProtocolJson.Default.ConvertRequest))
await UntilJobAsync(admin, (await applied.ReadAsync(ProtocolJson.Default.JobDto)).Id, "done");
await UntilIdleAsync(server);
// The converted sequence still holds the conversions: nothing to say.
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(("replaced", false), (plan.Entries.Single().Kind, plan.Entries.Single().ConversionDeleted));
// The user deletes a converted photo: its originals are the last copy of it, and the dry run says so.
var photo = await DeletePhotoAsync(editor, id, (await server.Database.Frames.ListBySequenceAsync(id))[0].Id);
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.True(plan.Entries.Single(e => e.Kind == "replaced").ConversionDeleted);
Assert.False(plan.Entries.Single(e => e.Name == photo).ConversionDeleted);
using (var empty = await admin.PostAsJsonAsync("/api/v1/archive/trash/empty", new TrashEmptyRequest(null, false, plan.Fingerprint),
ProtocolJson.Default.TrashEmptyRequest))
await UntilJobAsync(admin, (await empty.ReadAsync(ProtocolJson.Default.JobDto)).Id, "done");
using (var list = await admin.GetAsync("/api/v1/archive/trash")) Assert.Empty((await list.ReadAsync(ProtocolJson.Default.TrashListDto)).Entries);
}
/// <summary>Deletes one photo of a sequence into the trash; returns the entry's name.</summary>
private static async Task<string> 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);
}
/// <summary>The folder of a photo entry in the archive's trash.</summary>
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..]);
/// <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 });
}
}