Files
Chronos/tests/Chronos.Server.Tests/Api/PhotoLookupTests.cs
T
Alby96andClaude Opus 5.5 94a56278e2 feat(server): photo lookup endpoint and uploads into a target (owner review 6, P2)
Clients must recognise the same time-lapse filed under another id on the server, and an
integrated pair must get a photo into the server sequence even when another sequence there
already holds it. The server now answers both, authorised and scoped by itself.

- POST /api/v1/photos/lookup (Read right): per probe, the sequences of the served archive
  that hold its hashes in a frame, tombstoned them (deleted or replaced by a conversion),
  match its unhashed photos by size and capture millisecond, or carry its session key; only
  ids and counts, batched raw SQL, 413 too_many beyond 200 probes or 20,000 items, a 4 MB
  body limit so a full request fits.
- Uploads with IntoTarget: sequenceId required, never with Restore, the target must be the
  served archive's and the caller its owner, an admin or an editor. Only a copy in the target
  stands in; a tombstone keeps the photo deleted. Otherwise the server copies an intact file
  of another sequence of the served archive (never another archive of the index) into the
  target: quota and room checked, verified copy, hash compared (a damaged source falls back
  to a normal upload), committed refusing removed photos, used bytes charged only for a new
  frame, frames event published, answered copied.
- server/info announces photo-lookup and upload-into (the desktop's hosted share too).

Refs #73

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-16 19:56:30 +01:00

240 lines
13 KiB
C#

using System.Net;
using System.Net.Http.Json;
using Chronos.Core.Model;
using Chronos.Data;
using Chronos.Protocol;
using Chronos.Server.Configuration;
using Chronos.Testing;
namespace Chronos.Server.Tests.Api;
/// <summary><c>POST /api/v1/photos/lookup</c> (owner review 6, #73): counts per probe, scoped to the served archive.</summary>
[Category("server")]
public sealed class PhotoLookupTests(TestContext context)
{
private static readonly DateTime Shot = new DateTime(2026, 9, 28, 18, 2, 11, 123, DateTimeKind.Unspecified).AddTicks(4560);
[Test]
public async Task EachProbeCountsTheSequencesThatHoldItsPhotos()
{
await using var server = await TestServer.StartAsync(context);
await CountsAsync(server, context);
}
[Test]
[RequiresEnvironment("CHRONOS_TEST_PG")]
public async Task EachProbeCountsTheSequencesThatHoldItsPhotosOnPostgres()
{
await using var schema = await PgSchema.CreateAsync(context);
await using var server = await schema.StartAsync(context);
Assert.Equal(Dialect.Postgres, server.Database.Dialect);
await CountsAsync(server, context);
}
[Test]
public async Task OnlyTheServedArchiveIsLookedAt()
{
await using var server = await TestServer.StartAsync(context);
await ScopedAsync(server, context);
}
[Test]
[RequiresEnvironment("CHRONOS_TEST_PG")]
public async Task OnlyTheServedArchiveIsLookedAtOnPostgres()
{
await using var schema = await PgSchema.CreateAsync(context);
await using var server = await schema.StartAsync(context);
await ScopedAsync(server, context);
}
[Test]
public async Task TheLookupNeedsTheReadRight()
{
await using var server = await TestServer.StartAsync(context);
var (uploader, _, _) = await server.UserAsync("roof-cam", "uploader");
using (var refused = await LookupAsync(uploader, new PhotoLookupRequest([new PhotoProbe("a", [Hash('a')])])))
await refused.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden");
using (var anonymous = await LookupAsync(server.Client, new PhotoLookupRequest([new PhotoProbe("a", [Hash('a')])])))
Assert.Equal(HttpStatusCode.Unauthorized, anonymous.StatusCode);
var (viewer, _, _) = await server.UserAsync("guest", "viewer");
using var allowed = await LookupAsync(viewer, new PhotoLookupRequest([new PhotoProbe("a", [Hash('a')])]));
Assert.Empty(Assert.NotNull(await allowed.ReadAsync(ProtocolJson.Default.PhotoLookupResponse)).Results.Single().Hits);
}
[Test]
public async Task MoreThan200ProbesOr20000ItemsAreRefused()
{
await using var server = await TestServer.StartAsync(context);
var (editor, _, _) = await server.UserAsync("alberto", "editor");
var most = Enumerable.Range(0, PhotoLookupRequest.MaxProbes).Select(i => new PhotoProbe("p" + i, [Hash('b')])).ToList();
using (var ok = await LookupAsync(editor, new PhotoLookupRequest(most)))
Assert.Equal(PhotoLookupRequest.MaxProbes, (await ok.ReadAsync(ProtocolJson.Default.PhotoLookupResponse)).Results.Count);
using (var probes = await LookupAsync(editor, new PhotoLookupRequest([.. most, new PhotoProbe("one more", [Hash('b')])])))
await probes.ExpectErrorAsync(HttpStatusCode.RequestEntityTooLarge, "too_many");
// 20,000 items fit in one request (a body larger than the other JSON calls take); one more does not.
var hashes = Enumerable.Range(0, PhotoLookupRequest.MaxItems - 100).Select(i => i.ToString("x64", System.Globalization.CultureInfo.InvariantCulture)).ToList();
var unhashed = Enumerable.Range(0, 99).Select(i => new PhotoKeyDto(1000 + i, Shot.AddSeconds(i))).ToList();
var full = new PhotoProbe("full", hashes, unhashed, "chronos-sync:" + Guid.NewGuid().ToString("N"));
Assert.Equal(PhotoLookupRequest.MaxItems, new PhotoLookupRequest([full]).CountItems());
using (var ok = await LookupAsync(editor, new PhotoLookupRequest([full])))
Assert.Empty((await ok.ReadAsync(ProtocolJson.Default.PhotoLookupResponse)).Results.Single().Hits);
var over = full with { Unhashed = [.. unhashed, new PhotoKeyDto(5, Shot)] };
using (var items = await LookupAsync(editor, new PhotoLookupRequest([over])))
await items.ExpectErrorAsync(HttpStatusCode.RequestEntityTooLarge, "too_many");
}
[Test]
public async Task TheServerAnnouncesTheLookupAndUploadsIntoATarget()
{
await using var server = await TestServer.StartAsync(context);
using var response = await server.Client.GetAsync("/api/v1/server/info");
var info = await response.ReadAsync(ProtocolJson.Default.ServerInfo);
Assert.Contains(ServerCapabilities.PhotoLookup, info.Capabilities);
Assert.Contains(ServerCapabilities.UploadInto, info.Capabilities);
}
/// <summary>
/// Sequence A holds p1, p2 and p3 (p3 captured at <see cref="Shot"/>); B holds p4, tombstoned p5, replaced p6 by p7 and
/// is filed under a session key. One probe counts both, another hits nothing.
/// </summary>
internal static async Task CountsAsync(TestServer server, TestContext context)
{
var (editor, _, _) = await server.UserAsync("alberto", "editor");
var photos = Enumerable.Range(1, 7).Select(i => Uploads.Photo(3000 + i, 700 + i)).ToArray();
var a = (await Uploads.UploadAsync(editor, photos[0], "IMG_0001.JPG", sessionKey: "a")).SequenceId;
await Uploads.UploadAsync(editor, photos[1], "IMG_0002.JPG", sessionKey: "a");
await Uploads.UploadAsync(editor, photos[2], "IMG_0003.JPG", sessionKey: "a", capturedAt: Shot);
var b = (await Uploads.UploadAsync(editor, photos[3], "IMG_0004.JPG", sessionKey: "b")).SequenceId;
var now = DateTimeOffset.UtcNow;
await server.Database.FrameRemovals.SyncSequenceAsync(b,
[
new FrameRemoval(b, Uploads.Sha(photos[4]), null, RemovalReason.Deleted, now),
new FrameRemoval(b, Uploads.Sha(photos[5]), Uploads.Sha(photos[6]), RemovalReason.Replaced, now),
// A stale tombstone: B still holds p4, which counts once, as held.
new FrameRemoval(b, Uploads.Sha(photos[3]), null, RemovalReason.Deleted, now),
], context.Cancellation);
var archive = (await server.Database.Sequences.GetAsync(b, context.Cancellation))!.ArchiveId;
var key = "chronos-sync:" + Guid.NewGuid().ToString("N");
await server.Database.Sequences.MapSessionKeyAsync(archive, key, b, context.Cancellation);
var probe = new PhotoProbe("local-1",
[Uploads.Sha(photos[0]).ToUpperInvariant(), Uploads.Sha(photos[1]), Uploads.Sha(photos[1]), Uploads.Sha(photos[3]), Uploads.Sha(photos[4]),
Uploads.Sha(photos[6]), Hash('c')],
[
// The same millisecond as p3 (the index keeps microseconds); the next millisecond, another size: no match.
new PhotoKeyDto(photos[2].Length, new DateTime(2026, 9, 28, 18, 2, 11, 123).AddTicks(9999)),
new PhotoKeyDto(photos[2].Length, new DateTime(2026, 9, 28, 18, 2, 11, 124)),
new PhotoKeyDto(photos[2].Length + 1, Shot),
],
key);
var nothing = new PhotoProbe("local-2", [Hash('d')], [new PhotoKeyDto(photos[2].Length, Shot.AddDays(1))], "chronos-sync:" + Guid.NewGuid().ToString("N"));
using var response = await LookupAsync(editor, new PhotoLookupRequest([probe, nothing]));
var results = (await response.ReadAsync(ProtocolJson.Default.PhotoLookupResponse)).Results;
Assert.SequenceEqual(["local-1", "local-2"], results.Select(r => r.Key));
var hits = results[0].Hits.ToDictionary(h => h.SequenceId);
Assert.Equal(2, hits.Count);
Assert.Equal(new PhotoLookupHit(a, Hashes: 2, Removed: 0, Unhashed: 1, SessionKey: false), hits[a]);
Assert.Equal(new PhotoLookupHit(b, Hashes: 1, Removed: 2, Unhashed: 0, SessionKey: true), hits[b]);
Assert.Empty(results[1].Hits);
}
/// <summary>A sequence of another archive of the index holding the same photo and session key is never answered.</summary>
internal static async Task ScopedAsync(TestServer server, TestContext context)
{
var (editor, _, _) = await server.UserAsync("alberto", "editor");
var photo = Uploads.Photo(4000, 801);
var mine = (await Uploads.UploadAsync(editor, photo, sessionKey: "mine", capturedAt: Shot)).SequenceId;
var key = "chronos-sync:" + Guid.NewGuid().ToString("N");
var foreign = await ForeignFrameAsync(server, context, photo, Shot, key);
using var response = await LookupAsync(editor, new PhotoLookupRequest([new PhotoProbe("x", [Uploads.Sha(photo)], [new PhotoKeyDto(photo.Length, Shot)], key)]));
var hit = (await response.ReadAsync(ProtocolJson.Default.PhotoLookupResponse)).Results.Single().Hits.Single();
Assert.Equal(new PhotoLookupHit(mine, 1, 0, 1, false), hit);
Assert.NotEqual(foreign.SequenceId, hit.SequenceId);
}
/// <summary>
/// A frame of <paramref name="data"/> in a sequence of a second archive of the index (as a desktop sharing its library
/// keeps other archives' sequences), its file under that archive's root; optionally filed under <paramref name="sessionKey"/>.
/// </summary>
internal static async Task<Frame> ForeignFrameAsync(TestServer server, TestContext context, byte[] data, DateTime? capturedAt = null, string? sessionKey = null)
{
var db = server.Database;
var other = new Archive { Id = Guid.CreateVersion7(), Name = "Another archive", RootPath = context.CreateTempDirectory("other-archive"), Created = DateTimeOffset.UtcNow };
await db.Archives.UpsertAsync(other, context.Cancellation);
var sequence = new Sequence { Id = Guid.CreateVersion7(), ArchiveId = other.Id, Folder = "2026/other", UpdatedAt = DateTimeOffset.UtcNow };
await db.Sequences.UpsertAsync(sequence, context.Cancellation);
const string relative = "2026/other/originals/0000_IMG_0001.CR3";
var path = Path.Combine(other.RootPath, relative);
Directory.CreateDirectory(Path.GetDirectoryName(path)!);
await File.WriteAllBytesAsync(path, data, context.Cancellation);
var frame = new Frame
{
Id = Guid.CreateVersion7(),
SequenceId = sequence.Id,
Index = 0,
RelativePath = relative,
FileName = Path.GetFileName(relative),
OriginalFileName = "IMG_0001.CR3",
Size = data.Length,
Sha256 = Uploads.Sha(data),
CapturedAt = capturedAt,
};
await db.Frames.InsertAsync(frame, context.Cancellation);
await db.Sequences.RefreshStatsAsync(sequence.Id, context.Cancellation);
if (sessionKey is not null) await db.Sequences.MapSessionKeyAsync(other.Id, sessionKey, sequence.Id, context.Cancellation);
return frame;
}
internal static Task<HttpResponseMessage> LookupAsync(HttpClient client, PhotoLookupRequest request) =>
client.PostAsJsonAsync("/api/v1/photos/lookup", request, ProtocolJson.Default.PhotoLookupRequest);
private static string Hash(char c) => new(c, 64);
}
/// <summary>A throw-away schema on the PostgreSQL test server (<c>CHRONOS_TEST_PG</c>), selected through <c>Search Path</c>.</summary>
internal sealed class PgSchema : IAsyncDisposable
{
private readonly IDatabase _admin;
private readonly string _name;
private PgSchema(IDatabase admin, string name, string connectionString)
{
_admin = admin;
_name = name;
ConnectionString = connectionString;
}
public string ConnectionString { get; }
public static async Task<PgSchema> CreateAsync(TestContext context)
{
var baseConnection = Environment.GetEnvironmentVariable("CHRONOS_TEST_PG")!;
var admin = DatabaseFactory.Open(DatabaseOptions.Postgres(baseConnection));
var name = "chronos_l_" + Guid.NewGuid().ToString("N")[..16];
await using (var session = await admin.OpenAsync(context.Cancellation))
await session.ExecuteScriptAsync($"CREATE SCHEMA {name}", context.Cancellation);
return new PgSchema(admin, name, baseConnection.TrimEnd(';', ' ') + $";Search Path={name}");
}
/// <summary>A test server on this schema.</summary>
public Task<TestServer> StartAsync(TestContext context, Action<ServerOptions>? configure = null,
Action<Microsoft.Extensions.DependencyInjection.IServiceCollection>? services = null) =>
TestServer.StartAsync(context, o =>
{
o.Database = DatabaseKind.Postgres;
o.DbConnectionString = ConnectionString;
configure?.Invoke(o);
}, services);
public async ValueTask DisposeAsync()
{
await using (var session = await _admin.OpenAsync(CancellationToken.None))
await session.ExecuteScriptAsync($"DROP SCHEMA IF EXISTS {_name} CASCADE", CancellationToken.None);
await _admin.DisposeAsync();
}
}