The web panel now manages the library without editing it: the owner can browse and view sequences and photos, delete sequences and photos into the archive's trash, restore or empty the trash and run mass operations, as R6 asks, on top of the engine endpoints of the previous commit. - Library page right after the Dashboard: search, Year/Camera/Status/Tag filters fed by a new GET /api/v1/sequences/facets, sort, cards or list (remembered per browser), lazy cover thumbnails, Load more by cursor, multi-select with Shift ranges and "Select all N" of the filter, and a sticky bar for the selection: Analyse, Proxies, Thumbnails, Verify, Tags (add/remove), Export CSV (client-side) and Delete (dry run, list of what moves to the trash, then the move). Filters live in the address, so Back from a sequence finds them again. - Sequence view (#/library?id=): inline title, tags, rating and notes, facts, photos in pages of 500 with content-visibility, a photo viewer (proxy, arrows, Esc, Exif facts), Set cover, Download original, Delete photos (typing the count above 20 photos), Delete sequence, renders to download. No video editing controls. - Trash view (#/library?view=trash, also linked from Archive): entries, Restore, and Empty (dry run, list, the localised word typed, the plan's fingerprint sent back, the job followed to its end). - Live updates from sequenceChanged and jobState; keyboard grid (one tab stop, arrows, Space, Shift+Space, Enter, Ctrl+A, Esc); RTL, dark theme. - GET /sequences takes rendered=true|false for the Status filter. - ui.js: confirmDialog's typed confirmation by name, word or count, with a list of what the action concerns; formDialog. api.js: putBytes for the web upload, which the Library imports on demand (upload.js, optional). - New web icons from icons.py (Image for the Library, trash, grid/list, arrows, stars, cover); directional glyphs mirror in right-to-left pages. - Strings in en and it; tests for the facets (both dialects), the rendered filter, the menu, the modules and the on-demand upload import. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 029cf334f66cb6fa1265b96a6f8faff2964c11ea)
345 lines
21 KiB
C#
345 lines
21 KiB
C#
using System.Net;
|
|
using System.Net.Http.Headers;
|
|
using System.Net.Http.Json;
|
|
using Microsoft.Extensions.DependencyInjection;
|
|
using Chronos.Core.Codecs.Jpeg;
|
|
using Chronos.Core.Model;
|
|
using Chronos.Protocol;
|
|
using Chronos.Server.Storage;
|
|
using Chronos.Testing;
|
|
|
|
namespace Chronos.Server.Tests.Api;
|
|
|
|
/// <summary>
|
|
/// The library the admin panel manages (owner review 2, R6): sequence thumbnails, photos deleted into the trash, the trash
|
|
/// listed, restored and emptied, and bulk operations, against the real archive engine.
|
|
/// </summary>
|
|
[Category("server")]
|
|
public sealed class LibraryTests(TestContext context)
|
|
{
|
|
private static readonly TimeSpan Wait = TimeSpan.FromSeconds(TestTiming.Budget(30));
|
|
|
|
[Test]
|
|
public async Task PhotosAreDeletedIntoTheTrashAndRestoredThroughTheApi()
|
|
{
|
|
await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register);
|
|
var (editor, _, _) = await server.UserAsync("alberto", "editor");
|
|
var (other, _, _) = await server.UserAsync("giulia", "editor");
|
|
var admin = await server.AdminAsync();
|
|
var photos = Enumerable.Range(0, 3).Select(Photo).ToList();
|
|
Guid? id = null;
|
|
for (var i = 0; i < photos.Count; i++) id = (await Uploads.UploadAsync(editor, photos[i], $"IMG_{i + 1:0000}.JPG", sessionKey: "roof")).SequenceId;
|
|
await UntilIdleAsync(server);
|
|
var sequence = (await server.Database.Sequences.GetAsync(id!.Value))!;
|
|
var frames = await server.Database.Frames.ListBySequenceAsync(sequence.Id);
|
|
var url = $"/api/v1/sequences/{sequence.Id}/frames/delete";
|
|
|
|
using (var forbidden = await other.PostAsJsonAsync(url, new FrameDeleteRequest([frames[1].Id], null, false), ProtocolJson.Default.FrameDeleteRequest))
|
|
await forbidden.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden");
|
|
using (var none = await editor.PostAsJsonAsync(url, new FrameDeleteRequest([], null, false), ProtocolJson.Default.FrameDeleteRequest))
|
|
await none.ExpectErrorAsync(HttpStatusCode.BadRequest, "bad_request");
|
|
using (var stale = await editor.PostAsJsonAsync(url, new FrameDeleteRequest([frames[1].Id], sequence.FramesVersion - 1, false),
|
|
ProtocolJson.Default.FrameDeleteRequest))
|
|
Assert.Equal(sequence.FramesVersion.ToString(System.Globalization.CultureInfo.InvariantCulture),
|
|
(await stale.ExpectErrorAsync(HttpStatusCode.Conflict, "frames_conflict")).Details);
|
|
using (var all = await editor.PostAsJsonAsync(url, new FrameDeleteRequest([.. frames.Select(f => f.Id)], null, false), ProtocolJson.Default.FrameDeleteRequest))
|
|
await all.ExpectErrorAsync(HttpStatusCode.Conflict, "would_empty");
|
|
using (var dry = await editor.PostAsJsonAsync(url, new FrameDeleteRequest([frames[1].Id], sequence.FramesVersion, true), ProtocolJson.Default.FrameDeleteRequest))
|
|
{
|
|
var plan = await dry.ReadAsync(ProtocolJson.Default.FrameDeleteResultDto);
|
|
Assert.True(plan.DryRun);
|
|
Assert.Equal((1, frames[1].Size, 3), (plan.Photos, plan.Bytes, plan.FrameCount));
|
|
Assert.Null(plan.TrashEntry);
|
|
}
|
|
Assert.Count(3, await server.Database.Frames.ListBySequenceAsync(sequence.Id));
|
|
|
|
FrameDeleteResultDto done;
|
|
using (var deleted = await editor.PostAsJsonAsync(url, new FrameDeleteRequest([frames[1].Id], sequence.FramesVersion, false),
|
|
ProtocolJson.Default.FrameDeleteRequest))
|
|
done = await deleted.ReadAsync(ProtocolJson.Default.FrameDeleteResultDto);
|
|
Assert.False(done.DryRun);
|
|
Assert.Equal((2, sequence.FramesVersion + 1), (done.FrameCount, done.FramesVersion));
|
|
var name = Assert.NotNull(done.TrashEntry);
|
|
Assert.FileMissing(Path.Combine(server.Options.ArchivePath, frames[1].RelativePath));
|
|
|
|
// The manifest names the deleted photo, so clients do not send it back; an upload of it is answered as already there.
|
|
using (var manifest = await editor.GetAsync($"/api/v1/sequences/{sequence.Id}/manifest"))
|
|
Assert.SequenceEqual([Uploads.Sha(photos[1])], Assert.NotNull((await manifest.ReadAsync(ProtocolJson.Default.SequenceManifest)).Removed).Select(r => r.Sha256));
|
|
var again = await Uploads.StartAsync(editor, photos[1], "IMG_0002.JPG", sequence.Id, expected: HttpStatusCode.OK);
|
|
Assert.True(again.AlreadyExists);
|
|
Assert.Null(again.FrameId);
|
|
Assert.Count(2, await server.Database.Frames.ListBySequenceAsync(sequence.Id));
|
|
|
|
using (var notAdmin = await editor.GetAsync("/api/v1/archive/trash")) await notAdmin.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden");
|
|
using (var list = await admin.GetAsync("/api/v1/archive/trash"))
|
|
{
|
|
var trash = await list.ReadAsync(ProtocolJson.Default.TrashListDto);
|
|
var entry = Assert.Contains(trash.Entries, e => e.Name == name);
|
|
Assert.Equal(("photos", 1, sequence.Id, "alberto"), (entry.Kind, entry.Photos, entry.SequenceId, entry.DeletedBy));
|
|
Assert.Equal(frames[1].Size, trash.Bytes);
|
|
}
|
|
|
|
await UntilIdleAsync(server);
|
|
using (var restored = await admin.PostAsync($"/api/v1/archive/trash/{name}/restore", null))
|
|
{
|
|
var result = await restored.ReadAsync(ProtocolJson.Default.TrashRestoreDto);
|
|
Assert.Equal(("photos", sequence.Id, 1, false), (result.Kind, result.SequenceId, result.Photos, result.NewSequence));
|
|
Assert.Empty(result.Kept);
|
|
}
|
|
Assert.SequenceEqual(frames.Select(f => f.Id), (await server.Database.Frames.ListBySequenceAsync(sequence.Id)).Select(f => f.Id));
|
|
using (var gone = await admin.PostAsync($"/api/v1/archive/trash/{name}/restore", null)) await gone.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found");
|
|
using (var bad = await admin.PostAsync("/api/v1/archive/trash/..%2F..%2Fsecret/restore", null)) Assert.Equal(HttpStatusCode.NotFound, bad.StatusCode);
|
|
}
|
|
|
|
[Test]
|
|
public async Task TheTrashIsEmptiedByAJobAfterADryRunAndItsFingerprint()
|
|
{
|
|
await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register);
|
|
var (editor, _, _) = await server.UserAsync("alberto", "editor");
|
|
var admin = await server.AdminAsync();
|
|
var a = (await Uploads.UploadAsync(editor, Photo(10), "a.jpg", sessionKey: "a")).SequenceId;
|
|
Guid b = default;
|
|
for (var i = 0; i < 2; i++) b = (await Uploads.UploadAsync(editor, Photo(20 + i), $"b{i}.jpg", sessionKey: "b")).SequenceId;
|
|
await UntilIdleAsync(server);
|
|
using (var deleted = await editor.DeleteAsync($"/api/v1/sequences/{a}")) await deleted.ExpectAsync(HttpStatusCode.OK);
|
|
var frames = await server.Database.Frames.ListBySequenceAsync(b);
|
|
using (var photo = await editor.PostAsJsonAsync($"/api/v1/sequences/{b}/frames/delete", new FrameDeleteRequest([frames[0].Id], null, false),
|
|
ProtocolJson.Default.FrameDeleteRequest))
|
|
await photo.ExpectAsync(HttpStatusCode.OK);
|
|
await UntilIdleAsync(server);
|
|
|
|
TrashEmptyPlanDto plan;
|
|
using (var dry = await admin.PostAsJsonAsync("/api/v1/archive/trash/empty", new TrashEmptyRequest(null, true, null), ProtocolJson.Default.TrashEmptyRequest))
|
|
plan = await dry.ReadAsync(ProtocolJson.Default.TrashEmptyPlanDto);
|
|
Assert.Equal(2, plan.Entries.Count);
|
|
Assert.SequenceEqual(["photos", "sequence"], plan.Entries.Select(e => e.Kind).Order());
|
|
Assert.Equal(2, plan.Photos);
|
|
|
|
using (var noPrint = await admin.PostAsJsonAsync("/api/v1/archive/trash/empty", new TrashEmptyRequest(null, false, null), ProtocolJson.Default.TrashEmptyRequest))
|
|
await noPrint.ExpectErrorAsync(HttpStatusCode.BadRequest, "bad_request");
|
|
using (var wrong = await admin.PostAsJsonAsync("/api/v1/archive/trash/empty", new TrashEmptyRequest(null, false, "0123"), ProtocolJson.Default.TrashEmptyRequest))
|
|
Assert.Equal(plan.Fingerprint, (await wrong.ExpectErrorAsync(HttpStatusCode.Conflict, "trash_changed")).Details);
|
|
using (var names = await admin.PostAsJsonAsync("/api/v1/archive/trash/empty", new TrashEmptyRequest(["../x"], true, null), ProtocolJson.Default.TrashEmptyRequest))
|
|
await names.ExpectErrorAsync(HttpStatusCode.BadRequest, "bad_request");
|
|
|
|
JobDto job;
|
|
using (var empty = await admin.PostAsJsonAsync("/api/v1/archive/trash/empty", new TrashEmptyRequest(null, false, plan.Fingerprint),
|
|
ProtocolJson.Default.TrashEmptyRequest))
|
|
{
|
|
await empty.ExpectAsync(HttpStatusCode.Accepted);
|
|
job = await empty.ReadAsync(ProtocolJson.Default.JobDto);
|
|
}
|
|
Assert.Equal("empty-trash", job.Kind);
|
|
await UntilJobAsync(admin, job.Id, "done");
|
|
using (var list = await admin.GetAsync("/api/v1/archive/trash")) Assert.Empty((await list.ReadAsync(ProtocolJson.Default.TrashListDto)).Entries);
|
|
Assert.Empty(Directory.EnumerateFiles(server.Options.TrashPath, "*", SearchOption.AllDirectories));
|
|
Assert.Count(1, await server.Database.Frames.ListBySequenceAsync(b));
|
|
}
|
|
|
|
[Test]
|
|
public async Task BulkOperationsAnswerForEachSequence()
|
|
{
|
|
await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register);
|
|
var archive = server.Services.GetRequiredService<ServerArchive>();
|
|
var (editor, _, _) = await server.UserAsync("alberto", "editor");
|
|
var (other, _, _) = await server.UserAsync("giulia", "editor");
|
|
var a = (await Uploads.UploadAsync(editor, Photo(30), "a.jpg", sessionKey: "a")).SequenceId;
|
|
var b = (await Uploads.UploadAsync(editor, Photo(31), "b.jpg", sessionKey: "b")).SequenceId;
|
|
var c = (await Uploads.UploadAsync(other, Photo(32), "c.jpg", sessionKey: "c")).SequenceId;
|
|
var unknown = Guid.CreateVersion7();
|
|
await UntilIdleAsync(server);
|
|
|
|
using (var retag = await editor.PostAsJsonAsync("/api/v1/sequences/bulk/retag", new BulkRetagRequest([a, b, unknown], ["Night", "roof"], null),
|
|
ProtocolJson.Default.BulkRetagRequest))
|
|
{
|
|
var result = await retag.ReadAsync(ProtocolJson.Default.BulkResultDto);
|
|
Assert.Equal((2, 1), (result.Ok, result.Skipped));
|
|
Assert.Equal("not_found", result.Items.Single(i => i.Id == unknown).Reason);
|
|
}
|
|
using (var untag = await editor.PostAsJsonAsync("/api/v1/sequences/bulk/retag", new BulkRetagRequest([a], ["sky"], ["NIGHT"]),
|
|
ProtocolJson.Default.BulkRetagRequest))
|
|
await untag.ExpectAsync(HttpStatusCode.OK);
|
|
Assert.SequenceEqual(["roof", "sky"], (await server.Database.Sequences.GetAsync(a))!.Tags.Order());
|
|
Assert.SequenceEqual(["Night", "roof"], (await server.Database.Sequences.GetAsync(b))!.Tags.Order());
|
|
using (var noTags = await editor.PostAsJsonAsync("/api/v1/sequences/bulk/retag", new BulkRetagRequest([a], null, null), ProtocolJson.Default.BulkRetagRequest))
|
|
await noTags.ExpectErrorAsync(HttpStatusCode.BadRequest, "bad_request");
|
|
|
|
// A verify of sequences targets their archive (it once targeted the sequences, which its handler cannot read).
|
|
using (var verify = await editor.PostAsJsonAsync("/api/v1/sequences/bulk/jobs", new BulkJobsRequest([a, b, unknown], "verify"),
|
|
ProtocolJson.Default.BulkJobsRequest))
|
|
{
|
|
await verify.ExpectAsync(HttpStatusCode.Accepted);
|
|
var result = await verify.ReadAsync(ProtocolJson.Default.BulkResultDto);
|
|
var job = Assert.NotNull(result.Job);
|
|
Assert.Equal(("verify", 2, 1), (job.Kind, result.Ok, result.Skipped));
|
|
Assert.SequenceEqual([archive.Id], job.TargetIds);
|
|
await UntilJobAsync(editor, job.Id, "done");
|
|
}
|
|
using (var single = await editor.PostAsJsonAsync("/api/v1/jobs", new CreateJobRequest("verify", [a], null), ProtocolJson.Default.CreateJobRequest))
|
|
{
|
|
var job = await single.ReadAsync(ProtocolJson.Default.JobDto);
|
|
Assert.SequenceEqual([archive.Id], job.TargetIds);
|
|
await UntilJobAsync(editor, job.Id, "done");
|
|
}
|
|
using (var thumbs = await editor.PostAsJsonAsync("/api/v1/sequences/bulk/jobs", new BulkJobsRequest([a, b], "thumbnails"), ProtocolJson.Default.BulkJobsRequest))
|
|
{
|
|
var job = Assert.NotNull((await thumbs.ReadAsync(ProtocolJson.Default.BulkResultDto)).Job);
|
|
Assert.Equal("thumbs", job.Kind);
|
|
Assert.SequenceEqual([a, b], job.TargetIds);
|
|
}
|
|
using (var bogus = await editor.PostAsJsonAsync("/api/v1/sequences/bulk/jobs", new BulkJobsRequest([a], "render"), ProtocolJson.Default.BulkJobsRequest))
|
|
await bogus.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_job_kind");
|
|
await UntilIdleAsync(server);
|
|
|
|
using (var dry = await editor.PostAsJsonAsync("/api/v1/sequences/bulk/delete", new BulkDeleteRequest([a, c, unknown], true), ProtocolJson.Default.BulkDeleteRequest))
|
|
{
|
|
var result = await dry.ReadAsync(ProtocolJson.Default.BulkResultDto);
|
|
Assert.True(result.DryRun);
|
|
Assert.Equal(".chronos/trash/" + a.ToString("N"), result.Items[0].TrashFolder);
|
|
Assert.SequenceEqual(["ok", "skipped", "skipped"], result.Items.Select(i => i.Outcome));
|
|
Assert.SequenceEqual<string?>([null, "forbidden", "not_found"], result.Items.Select(i => i.Reason));
|
|
Assert.Equal(1, result.Photos);
|
|
}
|
|
Assert.NotNull(await server.Database.Sequences.GetAsync(a));
|
|
using (var deleted = await editor.PostAsJsonAsync("/api/v1/sequences/bulk/delete", new BulkDeleteRequest([a, b], false), ProtocolJson.Default.BulkDeleteRequest))
|
|
Assert.Equal(2, (await deleted.ReadAsync(ProtocolJson.Default.BulkResultDto)).Ok);
|
|
Assert.Null(await server.Database.Sequences.GetAsync(a));
|
|
Assert.Null(await server.Database.Sequences.GetAsync(b));
|
|
Assert.NotNull(await server.Database.Sequences.GetAsync(c));
|
|
}
|
|
|
|
[Test]
|
|
public async Task ASequenceThumbnailIsItsHeroFramesOrItsFirst()
|
|
{
|
|
await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register);
|
|
var (editor, _, _) = await server.UserAsync("alberto", "editor");
|
|
var first = await Uploads.UploadAsync(editor, Photo(40), "IMG_0001.JPG", sessionKey: "t");
|
|
var second = await Uploads.UploadAsync(editor, Photo(41), "IMG_0002.JPG", sessionKey: "t");
|
|
var id = first.SequenceId;
|
|
var thumbs = new Dictionary<Guid, byte[]>();
|
|
foreach (var frame in new[] { first.FrameId, second.FrameId }) thumbs[frame] = await ThumbnailAsync(editor, $"/api/v1/frames/{frame}/thumb");
|
|
|
|
using (var cover = await editor.GetAsync($"/api/v1/sequences/{id}/thumb"))
|
|
{
|
|
await cover.ExpectAsync(HttpStatusCode.OK);
|
|
var bytes = await cover.Content.ReadAsByteArrayAsync();
|
|
Assert.BytesEqual(thumbs[first.FrameId], bytes);
|
|
var etag = Assert.NotNull(cover.Headers.ETag);
|
|
using var request = new HttpRequestMessage(HttpMethod.Get, $"/api/v1/sequences/{id}/thumb");
|
|
request.Headers.IfNoneMatch.Add(etag);
|
|
using var cached = await editor.SendAsync(request);
|
|
Assert.Equal(HttpStatusCode.NotModified, cached.StatusCode);
|
|
}
|
|
using (var hero = await editor.PatchAsJsonAsync($"/api/v1/sequences/{id}", new UpdateSequenceRequest(null, null, null, null, null, null, second.FrameId),
|
|
ProtocolJson.Default.UpdateSequenceRequest))
|
|
await hero.ExpectAsync(HttpStatusCode.OK);
|
|
var heroThumb = await ThumbnailAsync(editor, $"/api/v1/sequences/{id}/thumb");
|
|
Assert.BytesEqual(thumbs[second.FrameId], heroThumb);
|
|
|
|
using var created = await editor.PostAsJsonAsync("/api/v1/sequences", new CreateSequenceRequest("Empty", null), ProtocolJson.Default.CreateSequenceRequest);
|
|
var empty = await created.ReadAsync(ProtocolJson.Default.SequenceDto);
|
|
using (var none = await editor.GetAsync($"/api/v1/sequences/{empty.Id}/thumb")) await none.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found");
|
|
using (var unknown = await editor.GetAsync($"/api/v1/sequences/{Guid.CreateVersion7()}/thumb")) await unknown.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found");
|
|
}
|
|
|
|
[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>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 });
|
|
}
|
|
}
|