Files
Chronos/tests/Titano.Server.Tests/Storage/UploadTests.cs
T
Claude 80b91d0585 test(server): auth, uploads, ranges, sync, jobs, render nodes, events
Covers bootstrap admin, sign-in failure, lockout and rate limit, token
revocation and expiry, 401 versus 403, CSRF on cookie sessions, the error
shape and API header, chunked upload happy path, resume, hash
short-circuit, damaged chunk, quota, Range on originals, thumbnails and
exports, path traversal, settings_version conflicts, job state
transitions with a fake handler, render node claim, heartbeat timeout and
reassignment, output upload, WebSocket progress events, the discovery
beacon, the Windows service command line and status rules, and a
PostgreSQL run (TITANO_TEST_PG).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
2026-10-02 12:28:47 +00:00

228 lines
13 KiB
C#

using System.Net;
using System.Net.Http.Json;
using Microsoft.Extensions.DependencyInjection;
using Titano.Protocol;
using Titano.Protocol.Client;
using Titano.Server.Storage;
using Titano.Testing;
namespace Titano.Server.Tests.Storage;
[Category("server")]
public sealed class UploadTests(TestContext context)
{
private const int Chunk = 64 * 1024;
[Test]
public async Task ChunksInAnyOrderCommitAVerifiedFrame()
{
await using var server = await TestServer.StartAsync(context, o => o.ChunkSizeBytes = Chunk);
var (uploader, _, _) = await server.UserAsync("roof-cam", "uploader");
var data = Uploads.Photo(Chunk * 3 + 1234, 1);
var start = await Uploads.StartAsync(uploader, data, sessionKey: "roof-2026-09-28");
var id = Assert.NotNull(start.UploadId);
Assert.Equal(Chunk, start.ChunkSize);
Assert.Empty(start.Received);
foreach (var index in new[] { 3, 0, 2, 1, 0 })
{
using var put = await Uploads.PutChunkAsync(uploader, id, index, Uploads.Chunk(data, Chunk, index));
await put.ExpectAsync(HttpStatusCode.OK);
Assert.Equal(index, (await put.ReadAsync(ProtocolJson.Default.ChunkReceived)).Index);
}
using (var state = await uploader.GetAsync($"/api/v1/uploads/{id}"))
{
var resume = await state.ReadAsync(ProtocolJson.Default.UploadState);
Assert.SequenceEqual([0, 1, 2, 3], resume.Received);
Assert.Equal("receiving", resume.State);
}
using var complete = await uploader.PostAsync($"/api/v1/uploads/{id}/complete", null);
await complete.ExpectAsync(HttpStatusCode.OK);
var frame = await complete.ReadAsync(ProtocolJson.Default.CompleteUploadResponse);
var ingest = server.Services.GetRequiredService<FakeArchiveIngest>();
var request = Assert.NotNull(ingest.Requests.LastOrDefault());
Assert.Equal("roof-2026-09-28", request.SessionKey);
Assert.Null(request.SequenceId);
Assert.Equal(Uploads.Sha(data), request.Sha256);
Assert.True(request.StagedPath.StartsWith(server.Options.StagingPath, StringComparison.Ordinal), request.StagedPath);
var stored = Assert.NotNull(await server.Database.Frames.GetAsync(frame.FrameId));
await Http.BytesEqualAsync(data, File.ReadAllBytesAsync(Path.Combine(server.Options.ArchivePath, stored.RelativePath)));
Assert.False(server.Services.GetRequiredService<UploadStore>().Exists(id), "the partial file is gone");
Assert.Empty(Directory.EnumerateFiles(server.Options.StagingPath));
using (var me = await uploader.GetAsync("/api/v1/auth/me")) Assert.Equal(data.Length, (await me.ReadAsync(ProtocolJson.Default.UserDto)).UsedBytes);
// A completion whose response was lost can be repeated.
using var again = await uploader.PostAsync($"/api/v1/uploads/{id}/complete", null);
await again.ExpectAsync(HttpStatusCode.OK);
Assert.Equal(frame.FrameId, (await again.ReadAsync(ProtocolJson.Default.CompleteUploadResponse)).FrameId);
}
[Test]
public async Task AnInterruptedUploadResumesWithItsReceivedChunks()
{
await using var server = await TestServer.StartAsync(context, o => o.ChunkSizeBytes = Chunk);
var (uploader, _, _) = await server.UserAsync("roof-cam", "uploader");
var data = Uploads.Photo(Chunk * 4, 2);
var first = await Uploads.StartAsync(uploader, data);
foreach (var index in new[] { 0, 2 })
{
using var put = await Uploads.PutChunkAsync(uploader, first.UploadId!.Value, index, Uploads.Chunk(data, Chunk, index));
await put.ExpectAsync(HttpStatusCode.OK);
}
var resumed = await Uploads.StartAsync(uploader, data);
Assert.Equal(first.UploadId, resumed.UploadId);
Assert.SequenceEqual([0, 2], resumed.Received);
foreach (var index in new[] { 1, 3 })
{
using var put = await Uploads.PutChunkAsync(uploader, first.UploadId!.Value, index, Uploads.Chunk(data, Chunk, index));
await put.ExpectAsync(HttpStatusCode.OK);
}
using var complete = await uploader.PostAsync($"/api/v1/uploads/{first.UploadId}/complete", null);
await complete.ExpectAsync(HttpStatusCode.OK);
}
[Test]
public async Task AKnownHashShortCircuitsTheUpload()
{
await using var server = await TestServer.StartAsync(context, o => o.ChunkSizeBytes = Chunk);
var (uploader, _, _) = await server.UserAsync("roof-cam", "uploader");
var data = Uploads.Photo(5000, 3);
var frame = await Uploads.UploadAsync(uploader, data);
var again = await Uploads.StartAsync(uploader, data, expected: HttpStatusCode.OK);
Assert.True(again.AlreadyExists);
Assert.Null(again.UploadId);
Assert.Equal(frame.FrameId, again.FrameId);
}
[Test]
public async Task TheProtocolClientUploadsAndDownloadsLikeTheUploader()
{
await using var server = await TestServer.StartAsync(context, o => o.ChunkSizeBytes = Chunk);
var (_, _, token) = await server.UserAsync("alberto", "editor");
var folder = context.CreateTempDirectory("source");
var path = Path.Combine(folder, "2026-09-28_18-02-11_0413.CR3");
var data = Uploads.Photo(Chunk * 2 + 77, 4);
await File.WriteAllBytesAsync(path, data);
using var client = new TitanoClient(server.HttpBase, new CertificatePinning([]), "Titano Uploader (tests)") { Token = token };
var sequence = await client.CreateSequenceAsync(new CreateSequenceRequest("Harbour sunset", null));
var progress = new List<UploadProgress>();
var result = Assert.NotNull(await client.UploadFileAsync(path, sequence.Id, new DateTime(2026, 9, 28), progress: new SyncProgress<UploadProgress>(progress.Add)));
Assert.Equal(sequence.Id, result.SequenceId);
Assert.Equal(0, result.Index);
Assert.Equal(data.Length, progress[^1].BytesSent);
var duplicate = Assert.NotNull(await client.UploadFileAsync(path, sequence.Id, null));
Assert.Equal((result.FrameId, -1), (duplicate.FrameId, duplicate.Index));
using var downloaded = new MemoryStream();
await client.DownloadFrameAsync(result.FrameId, "original", downloaded);
Assert.BytesEqual(data, downloaded.ToArray());
var manifest = await client.GetManifestAsync(sequence.Id);
Assert.Equal(Uploads.Sha(data), manifest.Frames.Single().Sha256);
}
[Test]
public async Task ADamagedChunkFailsTheHashCheck()
{
await using var server = await TestServer.StartAsync(context, o => o.ChunkSizeBytes = Chunk);
var (uploader, _, _) = await server.UserAsync("roof-cam", "uploader");
var data = Uploads.Photo(Chunk * 2, 5);
var start = await Uploads.StartAsync(uploader, data);
var id = start.UploadId!.Value;
var damaged = Uploads.Chunk(data, Chunk, 1).ToArray();
damaged[100] ^= 0xFF;
using (var a = await Uploads.PutChunkAsync(uploader, id, 0, Uploads.Chunk(data, Chunk, 0))) await a.ExpectAsync(HttpStatusCode.OK);
using (var b = await Uploads.PutChunkAsync(uploader, id, 1, damaged)) await b.ExpectAsync(HttpStatusCode.OK);
using var complete = await uploader.PostAsync($"/api/v1/uploads/{id}/complete", null);
await complete.ExpectErrorAsync(HttpStatusCode.UnprocessableEntity, "hash_mismatch");
using (var state = await uploader.GetAsync($"/api/v1/uploads/{id}")) Assert.Equal("failed", (await state.ReadAsync(ProtocolJson.Default.UploadState)).State);
Assert.False(server.Services.GetRequiredService<UploadStore>().Exists(id));
Assert.Empty(await server.Database.Frames.FindBySha256Async(Uploads.Sha(data)));
Assert.Empty(server.Services.GetRequiredService<FakeArchiveIngest>().Requests);
var retry = await Uploads.StartAsync(uploader, data);
Assert.NotEqual(id, retry.UploadId!.Value);
}
[Test]
public async Task ChunksAndCompletionsAreValidated()
{
await using var server = await TestServer.StartAsync(context, o => o.ChunkSizeBytes = Chunk);
var (uploader, _, _) = await server.UserAsync("roof-cam", "uploader");
var data = Uploads.Photo(Chunk + 10, 6);
var id = (await Uploads.StartAsync(uploader, data)).UploadId!.Value;
using (var small = await Uploads.PutChunkAsync(uploader, id, 0, new byte[10])) await small.ExpectErrorAsync(HttpStatusCode.BadRequest, "chunk_size");
using (var range = await Uploads.PutChunkAsync(uploader, id, 2, new byte[10])) await range.ExpectErrorAsync(HttpStatusCode.BadRequest, "chunk_out_of_range");
using (var early = await uploader.PostAsync($"/api/v1/uploads/{id}/complete", null)) await early.ExpectErrorAsync(HttpStatusCode.Conflict, "incomplete");
using (var name = await uploader.PostAsJsonAsync("/api/v1/uploads", new StartUploadRequest(null, "../../etc/passwd", 10, Uploads.Sha(data), null, null),
ProtocolJson.Default.StartUploadRequest))
await name.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_file_name");
using (var hash = await uploader.PostAsJsonAsync("/api/v1/uploads", new StartUploadRequest(null, "a.jpg", 10, "abc", null, null), ProtocolJson.Default.StartUploadRequest))
await hash.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_hash");
var (other, _, _) = await server.UserAsync("intruder", "uploader");
using (var foreign = await Uploads.PutChunkAsync(other, id, 0, Uploads.Chunk(data, Chunk, 0))) await foreign.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found");
using (var cancel = await uploader.DeleteAsync($"/api/v1/uploads/{id}")) await cancel.ExpectAsync(HttpStatusCode.NoContent);
Assert.False(server.Services.GetRequiredService<UploadStore>().Exists(id));
using var late = await Uploads.PutChunkAsync(uploader, id, 0, Uploads.Chunk(data, Chunk, 0));
await late.ExpectErrorAsync(HttpStatusCode.Conflict, "upload_state");
}
[Test]
public async Task QuotaCountsCommittedAndPendingUploads()
{
await using var server = await TestServer.StartAsync(context, o => o.ChunkSizeBytes = Chunk);
var (uploader, _, _) = await server.UserAsync("roof-cam", "uploader", quotaBytes: 100_000);
var first = Uploads.Photo(80_000, 7);
var pending = await Uploads.StartAsync(uploader, first);
using (var over = await uploader.PostAsJsonAsync("/api/v1/uploads", new StartUploadRequest(null, "b.jpg", 40_000, Uploads.Sha(Uploads.Photo(40_000, 8)), null, null),
ProtocolJson.Default.StartUploadRequest))
await over.ExpectErrorAsync(HttpStatusCode.Forbidden, "quota_exceeded");
using (var cancel = await uploader.DeleteAsync($"/api/v1/uploads/{pending.UploadId}")) await cancel.ExpectAsync(HttpStatusCode.NoContent);
await Uploads.UploadAsync(uploader, first);
using var after = await uploader.PostAsJsonAsync("/api/v1/uploads", new StartUploadRequest(null, "c.jpg", 30_000, Uploads.Sha(Uploads.Photo(30_000, 9)), null, null),
ProtocolJson.Default.StartUploadRequest);
await after.ExpectErrorAsync(HttpStatusCode.Forbidden, "quota_exceeded");
}
[Test]
public async Task FilesAboveTheLimitAreRefused()
{
await using var server = await TestServer.StartAsync(context, o => o.MaxUploadBytes = 1000);
var (uploader, _, _) = await server.UserAsync("roof-cam", "uploader");
using var response = await uploader.PostAsJsonAsync("/api/v1/uploads", new StartUploadRequest(null, "big.jpg", 1001, new string('0', 64), null, null),
ProtocolJson.Default.StartUploadRequest);
var error = await response.ExpectErrorAsync(HttpStatusCode.RequestEntityTooLarge, "too_large");
Assert.Equal("1000", error.Details);
}
[Test]
public async Task AbandonedUploadsExpireAndLoseTheirFiles()
{
var clock = new ManualTimeProvider();
await using var server = await TestServer.StartAsync(context, o => o.UploadRetentionHours = 48, s => s.AddSingleton<TimeProvider>(clock));
var (uploader, _, _) = await server.UserAsync("roof-cam", "uploader");
var id = (await Uploads.StartAsync(uploader, Uploads.Photo(1000, 10))).UploadId!.Value;
var store = server.Services.GetRequiredService<UploadStore>();
Assert.True(store.Exists(id));
// Upload rows carry real timestamps; the sweep looks 48 h past the moved clock.
clock.Advance(TimeSpan.FromHours(49));
await server.Services.GetRequiredService<UploadMaintenance>().SweepAsync(context.Cancellation);
Assert.False(store.Exists(id));
using var state = await uploader.GetAsync($"/api/v1/uploads/{id}");
Assert.Equal("cancelled", (await state.ReadAsync(ProtocolJson.Default.UploadState)).State);
}
/// <summary>Reports synchronously (Progress&lt;T&gt; posts to the thread pool and may arrive late).</summary>
private sealed class SyncProgress<T>(Action<T> report) : IProgress<T>
{
public void Report(T value) => report(value);
}
}