using System.Net;
using System.Net.Http.Json;
using Microsoft.Extensions.DependencyInjection;
using Chronos.Core.Model;
using Chronos.Data;
using Chronos.Data.Archiving;
using Chronos.Protocol;
using Chronos.Server.Events;
using Chronos.Server.Tests.Api;
using Chronos.Testing;
namespace Chronos.Server.Tests.Storage;
///
/// (owner review 6, #73): a photo another sequence of the served archive holds is
/// copied into the target by the server itself, authorised and scoped on the server.
///
[Category("server")]
public sealed class UploadIntoTests(TestContext context)
{
private static readonly DateTime Shot = new(2026, 9, 28, 18, 2, 11, 250, DateTimeKind.Unspecified);
[Test]
public async Task APhotoHeldElsewhereIsCopiedIntoTheTargetAndChargedOnce()
{
await using var server = await TestServer.StartAsync(context);
await CopiedAsync(server, context);
}
[Test]
[RequiresEnvironment("CHRONOS_TEST_PG")]
public async Task APhotoHeldElsewhereIsCopiedIntoTheTargetAndChargedOnceOnPostgres()
{
await using var schema = await PgSchema.CreateAsync(context);
await using var server = await schema.StartAsync(context);
Assert.Equal(Dialect.Postgres, server.Database.Dialect);
await CopiedAsync(server, context);
}
[Test]
public async Task ACommitThatFindsThePhotoFiledMeanwhileChargesNothing()
{
await using var server = await TestServer.StartAsync(context, services: s =>
{
s.AddSingleton();
s.AddSingleton(sp => sp.GetRequiredService());
});
var scene = await SceneAsync(server);
var racing = server.Services.GetRequiredService();
Guid? raced = null;
// Another writer files the same photo into the target just before this commit: the ingest answers a duplicate.
racing.Before = async request =>
{
var copy = request.StagedPath + ".race";
File.Copy(request.StagedPath, copy);
raced = (await racing.Inner.CommitAsync(request with { StagedPath = copy }, context.Cancellation)).FrameId;
};
var used = await UsedAsync(scene.Editor);
using var response = await StartIntoAsync(scene.Editor, scene.Photo, scene.Target);
var answer = await response.ReadAsync(ProtocolJson.Default.StartUploadResponse);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.True(answer.AlreadyExists && answer.Copied);
Assert.Equal(Assert.NotNull(raced), answer.FrameId);
Assert.Equal(used, await UsedAsync(scene.Editor));
Assert.Empty(Directory.EnumerateFiles(server.Options.StagingPath));
}
[Test]
public async Task TheCopyIsRefusedBeyondTheQuota()
{
await using var server = await TestServer.StartAsync(context);
// The two uploads of the scene take 9,000 bytes; copying the 5,000-byte photo would take the account beyond 10,000.
var scene = await SceneAsync(server, quota: 10_000);
using var response = await StartIntoAsync(scene.Editor, scene.Photo, scene.Target);
await response.ExpectErrorAsync(HttpStatusCode.Forbidden, "quota_exceeded");
Assert.Empty(await FramesOfAsync(server, scene.Target, scene.Photo));
}
[Test]
public async Task OnlyTheOwnerAnAdminOrAnEditorMayUploadIntoATarget()
{
await using var server = await TestServer.StartAsync(context);
var scene = await SceneAsync(server);
var (uploader, _, _) = await server.UserAsync("roof-cam", "uploader");
// An upload-only account may not file into another account's sequence.
using (var refused = await StartIntoAsync(uploader, scene.Photo, scene.Target))
await refused.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden");
Assert.Empty(await FramesOfAsync(server, scene.Target, scene.Photo));
// Into its own sequence it may: the server copies the photo the editor's sequence holds.
var own = (await Uploads.UploadAsync(uploader, Uploads.Photo(3000, 903), "IMG_0200.CR3", sessionKey: "roof")).SequenceId;
using (var allowed = await StartIntoAsync(uploader, scene.Photo, own))
Assert.True((await allowed.ReadAsync(ProtocolJson.Default.StartUploadResponse)).Copied);
Assert.Count(1, await FramesOfAsync(server, own, scene.Photo));
// An administrator may.
var admin = await server.AdminAsync();
using (var byAdmin = await StartIntoAsync(admin, scene.Photo, scene.Target))
Assert.True((await byAdmin.ReadAsync(ProtocolJson.Default.StartUploadResponse)).Copied);
}
[Test]
public async Task ATargetOfAnotherArchiveIsUnknown()
{
await using var server = await TestServer.StartAsync(context);
var scene = await SceneAsync(server);
var foreign = await PhotoLookupTests.ForeignFrameAsync(server, context, Uploads.Photo(2000, 904));
using (var other = await StartIntoAsync(scene.Editor, scene.Photo, foreign.SequenceId))
Assert.Equal("sequence", (await other.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found")).Details);
using (var unknown = await StartIntoAsync(scene.Editor, scene.Photo, Guid.CreateVersion7()))
await unknown.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found");
Assert.Empty(await FramesOfAsync(server, foreign.SequenceId, scene.Photo));
}
[Test]
public async Task AnUploadIntoATargetNamesItAndNeverRestores()
{
await using var server = await TestServer.StartAsync(context);
var scene = await SceneAsync(server);
using (var restore = await StartIntoAsync(scene.Editor, scene.Photo, scene.Target, restore: true))
Assert.Equal("restore", (await restore.ExpectErrorAsync(HttpStatusCode.BadRequest, "bad_request")).Details);
using (var none = await StartIntoAsync(scene.Editor, scene.Photo, null))
Assert.Equal("sequenceId", (await none.ExpectErrorAsync(HttpStatusCode.BadRequest, "bad_request")).Details);
}
[Test]
public async Task ATargetThatHoldsThePhotoAnswersItsFrame()
{
await using var server = await TestServer.StartAsync(context);
var scene = await SceneAsync(server);
using var response = await StartIntoAsync(scene.Editor, scene.Photo, scene.Held.SequenceId);
var answer = await response.ReadAsync(ProtocolJson.Default.StartUploadResponse);
Assert.True(answer.AlreadyExists);
Assert.False(answer.Copied);
Assert.Equal(scene.Held.FrameId, answer.FrameId);
}
[Test]
public async Task APhotoTheTargetDeletedStaysDeleted()
{
await using var server = await TestServer.StartAsync(context);
var scene = await SceneAsync(server);
await server.Database.FrameRemovals.SyncSequenceAsync(scene.Target,
[new FrameRemoval(scene.Target, Uploads.Sha(scene.Photo), null, RemovalReason.Deleted, DateTimeOffset.UtcNow)], context.Cancellation);
var requests = server.Services.GetRequiredService().Requests.Count;
using var response = await StartIntoAsync(scene.Editor, scene.Photo, scene.Target);
var answer = await response.ReadAsync(ProtocolJson.Default.StartUploadResponse);
Assert.True(answer.AlreadyExists);
Assert.Null(answer.FrameId);
Assert.False(answer.Copied);
Assert.Empty(await FramesOfAsync(server, scene.Target, scene.Photo));
Assert.Equal(requests, server.Services.GetRequiredService().Requests.Count);
}
[Test]
public async Task APhotoOnlyAnotherArchiveHoldsIsUploaded()
{
await using var server = await TestServer.StartAsync(context);
var scene = await SceneAsync(server);
var elsewhere = Uploads.Photo(2500, 905);
await PhotoLookupTests.ForeignFrameAsync(server, context, elsewhere);
using var response = await StartIntoAsync(scene.Editor, elsewhere, scene.Target);
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
var answer = await response.ReadAsync(ProtocolJson.Default.StartUploadResponse);
Assert.NotNull(answer.UploadId);
Assert.False(answer.AlreadyExists || answer.Copied);
}
[Test]
public async Task ADamagedSourceLeavesTheClientToSendThePhoto()
{
await using var server = await TestServer.StartAsync(context);
var scene = await SceneAsync(server);
// The file keeps its size, so the frame reads as intact; its bytes are no longer the photo.
var source = Assert.NotNull(await server.Database.Frames.GetAsync(scene.Held.FrameId));
await File.WriteAllBytesAsync(Path.Combine(server.Options.ArchivePath, source.RelativePath), Uploads.Photo(scene.Photo.Length, 906), context.Cancellation);
using (var response = await StartIntoAsync(scene.Editor, scene.Photo, scene.Target))
{
Assert.Equal(HttpStatusCode.Created, response.StatusCode);
var answer = await response.ReadAsync(ProtocolJson.Default.StartUploadResponse);
Assert.NotNull(answer.UploadId);
Assert.False(answer.Copied);
}
Assert.Empty(Directory.EnumerateFiles(server.Options.StagingPath));
Assert.Empty(await FramesOfAsync(server, scene.Target, scene.Photo));
}
[Test]
public async Task WithoutIntoTargetACopyElsewhereStillStandsIn()
{
await using var server = await TestServer.StartAsync(context);
var scene = await SceneAsync(server);
var used = await UsedAsync(scene.Editor);
var answer = await Uploads.StartAsync(scene.Editor, scene.Photo, sequenceId: scene.Target, expected: HttpStatusCode.OK);
Assert.True(answer.AlreadyExists);
Assert.False(answer.Copied);
Assert.Equal(scene.Held.FrameId, answer.FrameId);
Assert.Empty(await FramesOfAsync(server, scene.Target, scene.Photo));
Assert.Equal(used, await UsedAsync(scene.Editor));
}
/// The copy lands in the target with the photo's bytes, charged once, announced, and answered from the target after.
internal static async Task CopiedAsync(TestServer server, TestContext context)
{
var scene = await SceneAsync(server);
var used = await UsedAsync(scene.Editor);
using var events = server.Services.GetRequiredService().Subscribe();
StartUploadResponse answer;
using (var response = await StartIntoAsync(scene.Editor, scene.Photo, scene.Target))
{
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
answer = await response.ReadAsync(ProtocolJson.Default.StartUploadResponse);
}
Assert.True(answer.AlreadyExists && answer.Copied);
Assert.Null(answer.UploadId);
var frame = Assert.NotNull(await server.Database.Frames.GetAsync(Assert.NotNull(answer.FrameId), context.Cancellation));
Assert.Equal(scene.Target, frame.SequenceId);
Assert.Equal(Uploads.Sha(scene.Photo), frame.Sha256);
await Http.BytesEqualAsync(scene.Photo, File.ReadAllBytesAsync(Path.Combine(server.Options.ArchivePath, frame.RelativePath)));
Assert.NotNull(await server.Database.Frames.GetAsync(scene.Held.FrameId, context.Cancellation));
var request = Assert.NotNull(server.Services.GetRequiredService().Requests.LastOrDefault());
Assert.Equal(scene.Target, request.SequenceId);
Assert.True(request.RefuseRemoved, "the copy refuses a photo the target deleted");
Assert.Equal(scene.Photo.Length, request.Size);
Assert.True(request.StagedPath.StartsWith(server.Options.StagingPath, StringComparison.Ordinal), request.StagedPath);
Assert.Empty(Directory.EnumerateFiles(server.Options.StagingPath));
Assert.Equal(used + scene.Photo.Length, await UsedAsync(scene.Editor));
using (var wait = CancellationTokenSource.CreateLinkedTokenSource(context.Cancellation))
{
wait.CancelAfter(TimeSpan.FromSeconds(10));
while (await events.Reader.ReadAsync(wait.Token) is var e)
{
if (e is SequenceChangedEvent { Change: "frames" } changed && changed.SequenceId == scene.Target) break;
}
}
// Asked again, the target answers with its own copy, charged nothing more.
using (var again = await StartIntoAsync(scene.Editor, scene.Photo, scene.Target))
{
var repeated = await again.ReadAsync(ProtocolJson.Default.StartUploadResponse);
Assert.True(repeated.AlreadyExists);
Assert.False(repeated.Copied);
Assert.Equal(frame.Id, repeated.FrameId);
}
Assert.Equal(used + scene.Photo.Length, await UsedAsync(scene.Editor));
Assert.Count(1, await FramesOfAsync(server, scene.Target, scene.Photo));
}
/// An editor's sequence A holding a 5,000-byte photo, and the editor's sequence B (the target) holding another photo.
private static async Task SceneAsync(TestServer server, long quota = 0)
{
var (editor, _, _) = await server.UserAsync("alberto", "editor", quotaBytes: quota);
var photo = Uploads.Photo(5000, 901);
var held = await Uploads.UploadAsync(editor, photo, "IMG_0001.CR3", sessionKey: "a", capturedAt: Shot);
var target = (await Uploads.UploadAsync(editor, Uploads.Photo(4000, 902), "IMG_0100.CR3", sessionKey: "b")).SequenceId;
return new Scene(editor, photo, held, target);
}
private static Task StartIntoAsync(HttpClient client, byte[] data, Guid? target, bool restore = false) =>
client.PostAsJsonAsync("/api/v1/uploads", new StartUploadRequest(target, "IMG_0001.CR3", data.Length, Uploads.Sha(data), Shot, null, restore, IntoTarget: true),
ProtocolJson.Default.StartUploadRequest);
private static async Task UsedAsync(HttpClient client)
{
using var me = await client.GetAsync("/api/v1/auth/me");
return (await me.ReadAsync(ProtocolJson.Default.UserDto)).UsedBytes;
}
private static async Task> FramesOfAsync(TestServer server, Guid sequenceId, byte[] photo) =>
[.. (await server.Database.Frames.FindBySha256Async(Uploads.Sha(photo))).Where(f => f.SequenceId == sequenceId)];
private sealed record Scene(HttpClient Editor, byte[] Photo, CompleteUploadResponse Held, Guid Target);
/// The fake ingest, with a step that runs once just before the next commit (another writer filing the same photo).
private sealed class RacingIngest(FakeArchiveIngest inner) : IArchiveIngest
{
public FakeArchiveIngest Inner => inner;
public Func? Before { get; set; }
public async Task CommitAsync(IngestRequest request, CancellationToken cancellationToken = default)
{
if (Before is { } before)
{
Before = null;
await before(request);
}
return await inner.CommitAsync(request, cancellationToken);
}
}
}