Second fix round of owner review 2, phase 3 (engine, server, desktop). - A photo never hashed whose original is missing can be deleted again: it goes into its trash record without a file and without a tombstone (nothing is left to name), stays listed until Empty erases it, and a restore keeps it with the reason "no file". FrameDeleteBlock.Unhashable now blocks only a present original that cannot be read; the API answers it as 409 photo_unreadable naming the photo, and every block has its own code and message. - Deleting a whole sequence first settles an interrupted photo deletion, restore or ingest of it (ReadLocked under its lease), so no journal or half entry travels into the sequence's trash entry; it refuses while a restore into it waits for its busy entry. - FrameTrash.Settle takes the photo entry's lease and leaves the journal for later while the entry is busy (an emptying), so it never races EraseAsync; meanwhile no other restore writes its journal over it and scans do not adopt its files. - The hashes computed for frames that stay (to find a twin of a deleted photo) go into the sidecar and index, and only a frame whose first and last 64 KiB match a deleted photo's is read whole. - A restore into a new sequence rewrites its record after each photo filed, so a crash or a database failure never leaves filed photos listed. - An upload completion no longer has a window before the commit: the ingest checks the sidecar's tombstones under the sequence lease a deletion takes (IngestRequest.RefuseRemoved), unless the upload asked to bring it back. - A restore reports each kept photo with its reason (no longer matches its record, could not be moved back, already in the sequence, had no file); the desktop line and the API message say so in en and it, and the tooltip holds the whole sentence. The desktop tells TrashMismatchException by its type. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 1858f1f450a35fb8383ede8d80ce5f8de9b7ceac)
663 lines
43 KiB
C#
663 lines
43 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);
|
|
}
|
|
|
|
/// <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 });
|
|
}
|
|
}
|