Owner review 2, phase 4b, fix round 2 (trash and sync). - Emptying a Replaced entry decided "conversion deleted" from this host's index alone, so a conversion another host made, or one this index had not read yet, could be taken for deleted and its originals erased without re-hashing it. The survey now reads the archive: the sequence's sidecar where the index or the entry says it is, in the trash, or found by walking the archive's folders. Its Replaced tombstones are followed and every conversion it holds is re-hashed. A conversion counts as deleted only when the sidecar shows it (a Deleted tombstone, or the frame gone while every frame is hashed and no photo of the folder is unlisted), when the sequence is in the trash, or when no sidecar of it exists and this index has no row either. Whatever the archive cannot tell, or a converted frame whose file changed since, keeps the entry, and the job log says why (changed after the plan, sequence busy, conversion no longer matches, conversion not located). - The erase weighs a Replaced entry under the entry's and the sequence's leases and settles the sequence first (an undo waiting for that entry's lease completes), so the entry it reads again and fingerprints is the one it erases. Read before the settle, a consumed entry's folder vanished under the erase. - Each sidecar is indexed once per survey: one conversion's entry (every frame it swapped) is weighed in one pass, not one pass over the sidecar per photo. - The desktop Empty confirmation names every entry whose conversion was deleted first, with why, wherever the trash lists it; the detail scrolls when long. The panel lists them first as well. - Download originals queues the passes a frame swapped to another encoding cleared (light analysis, the deep analysis it had, thumbnails, proxies), as any replacement does. - The job log lines of uploads and downloads are resources (en, it). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 27d9a512183e64da9a3d7fa69a267470ca3ce744)
702 lines
46 KiB
C#
702 lines
46 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);
|
|
// The panel's confirmation names such entries first, each saying so, wherever the trash lists them.
|
|
var page = await server.Client.GetStringAsync("/admin/pages/library/trash.js");
|
|
Assert.Contains("list: [...plan.entries.filter((e) => e.conversionDeleted), ...plan.entries.filter((e) => !e.conversionDeleted)]", page);
|
|
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 });
|
|
}
|
|
}
|