Owner review 2, R10: nothing may run out of sight, so every timer the server ran becomes a system schedule the admin panel shows and manages, and administrators create their own. - SchedulerHost runs the shared Scheduler on the job engine (started after JobEngineHost, stopped before it); ServerScheduleHost gives it the container's time zone (UTC with a warning when TZ is unknown), the archive refreshed from archive.json at every run (what ArchivePolling did), the clean-up steps and the system schedules: archive-scan every 10 minutes (no catch-up, also run once at start like the polling), upload-cleanup every 30 minutes, index-backup at 03:00 (SQLite only), housekeeping (job history) at 04:00 and audit-cleanup at 04:30. - ArchivePolling and DatabaseBackupService are gone; UploadMaintenance only recovers commits at start, its sweep is the "uploads" clean-up step. - /api/v1/schedules (ManageArchive, audited): list with actions and time zone, create, PUT/PATCH, delete (409 schedule_system), run now (409 schedule_pending), reset (409 schedule_no_defaults), runs paged by cursor; invalid fields are 400 invalid_schedule naming the field. - CHRONOS_AUDIT_RETENTION_DAYS (AuditRetentionDays, default 365) seeds the audit clean-up; set by the environment it is applied at every start and locked. Job history leaves Settings: it is the housekeeping schedule's age limit, and the setting is what a reset restores. - Admin panel: Jobs has Queue and Scheduled tabs; schedules with when (in the panel's language and the server's zone), next run, last result, a switch, Run now, Edit, Delete or Reset, their runs linking to the jobs, and a side panel for the action, recurrence and parameters; job rows a schedule queued carry a Scheduled pill. Strings in en and it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit 808ce94ae29e3bf4522cb4d40dfd76d4f8529c64)
350 lines
21 KiB
C#
350 lines
21 KiB
C#
using System.Net;
|
|
using System.Net.Http.Json;
|
|
using Microsoft.Extensions.DependencyInjection;
|
|
using Chronos.Core.Model;
|
|
using Chronos.Protocol;
|
|
using Chronos.Protocol.Client;
|
|
using Chronos.Server.Storage;
|
|
using Chronos.Testing;
|
|
|
|
namespace Chronos.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 ACopyFlaggedOrGoneIsNoShortcut()
|
|
{
|
|
await using var server = await TestServer.StartAsync(context, o => o.ChunkSizeBytes = Chunk);
|
|
var (uploader, _, _) = await server.UserAsync("roof-cam", "uploader");
|
|
// A client may delete its file on "already exists": a damaged copy must ask for the bytes again.
|
|
var flagged = Uploads.Photo(5000, 11);
|
|
var first = await Uploads.UploadAsync(uploader, flagged);
|
|
await server.Database.Frames.UpdateFlagsAsync([first.FrameId], FrameFlags.Corrupt, FrameFlags.None);
|
|
Assert.False((await Uploads.StartAsync(uploader, flagged)).AlreadyExists);
|
|
|
|
var gone = Uploads.Photo(5000, 12);
|
|
var second = await Uploads.UploadAsync(uploader, gone);
|
|
File.Delete(Path.Combine(server.Options.ArchivePath, Assert.NotNull(await server.Database.Frames.GetAsync(second.FrameId)).RelativePath));
|
|
Assert.False((await Uploads.StartAsync(uploader, gone)).AlreadyExists);
|
|
}
|
|
|
|
[Test]
|
|
public async Task ACommitLeftByACrashIsSettledOnlyByAnIntactFrame()
|
|
{
|
|
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 + 100, 13);
|
|
var missing = await Uploads.UploadAsync(uploader, data);
|
|
await server.Database.Frames.UpdateFlagsAsync([missing.FrameId], FrameFlags.Missing, FrameFlags.None);
|
|
var start = await Uploads.StartAsync(uploader, data);
|
|
var id = Assert.NotNull(start.UploadId);
|
|
for (var i = 0; i < 2; i++)
|
|
{
|
|
using var put = await Uploads.PutChunkAsync(uploader, id, i, Uploads.Chunk(data, Chunk, i));
|
|
await put.ExpectAsync(HttpStatusCode.OK);
|
|
}
|
|
// The server stopped while committing it.
|
|
Assert.True(await server.Database.Uploads.TryTransitionAsync(id, Chronos.Data.Repositories.UploadState.Receiving,
|
|
Chronos.Data.Repositories.UploadState.Committing, cancellationToken: context.Cancellation));
|
|
|
|
await server.Services.GetRequiredService<UploadMaintenance>().RecoverAsync(context.Cancellation);
|
|
|
|
// The flagged frame does not stand for it: the client completes again with its part file intact.
|
|
using (var state = await uploader.GetAsync($"/api/v1/uploads/{id}")) Assert.Equal("receiving", (await state.ReadAsync(ProtocolJson.Default.UploadState)).State);
|
|
Assert.True(server.Services.GetRequiredService<UploadStore>().Exists(id));
|
|
}
|
|
|
|
[Test]
|
|
public async Task AnUploadKeepsItsChunkSizeWhenTheSettingShrinks()
|
|
{
|
|
await using var server = await TestServer.StartAsync(context, o => o.ChunkSizeBytes = Chunk * 2);
|
|
var (uploader, _, _) = await server.UserAsync("roof-cam", "uploader");
|
|
var data = Uploads.Photo(Chunk * 3, 14);
|
|
var start = await Uploads.StartAsync(uploader, data);
|
|
var id = Assert.NotNull(start.UploadId);
|
|
Assert.Equal(Chunk * 2, start.ChunkSize);
|
|
|
|
// An administrator lowers the chunk size; the upload resumes with the size it started with.
|
|
server.Options.ChunkSizeBytes = Chunk;
|
|
var resumed = await Uploads.StartAsync(uploader, data);
|
|
Assert.Equal((id, Chunk * 2), (resumed.UploadId!.Value, resumed.ChunkSize));
|
|
for (var i = 0; i < 2; i++)
|
|
{
|
|
using var put = await Uploads.PutChunkAsync(uploader, id, i, Uploads.Chunk(data, Chunk * 2, i));
|
|
await put.ExpectAsync(HttpStatusCode.OK);
|
|
}
|
|
using var complete = await uploader.PostAsync($"/api/v1/uploads/{id}/complete", null);
|
|
await complete.ExpectAsync(HttpStatusCode.OK);
|
|
|
|
// A new upload takes the new size, and a body above it is refused.
|
|
var next = Uploads.Photo(Chunk * 2, 15);
|
|
var small = await Uploads.StartAsync(uploader, next);
|
|
Assert.Equal(Chunk, small.ChunkSize);
|
|
using var oversized = await Uploads.PutChunkAsync(uploader, small.UploadId!.Value, 0, next);
|
|
await oversized.ExpectErrorAsync(HttpStatusCode.BadRequest, "chunk_size");
|
|
}
|
|
|
|
[Test]
|
|
public async Task AnswersThatLeaveALargeChunkUnreadReachTheClient()
|
|
{
|
|
// Chunks far above the 1 MiB other requests may send: more than the connection buffers while the server reads nothing.
|
|
const int large = 32 * 1024 * 1024;
|
|
await using var server = await TestServer.StartAsync(context, o => o.ChunkSizeBytes = large);
|
|
var (uploader, _, _) = await server.UserAsync("roof-cam", "uploader");
|
|
var data = Uploads.Photo(24 * 1024 * 1024, 16);
|
|
var id = (await Uploads.StartAsync(uploader, data)).UploadId!.Value;
|
|
using (var first = await Uploads.PutChunkAsync(uploader, id, 0, data)) await first.ExpectAsync(HttpStatusCode.OK);
|
|
|
|
// The client lost the answer and sends the chunk again: the same answer, not a closed connection.
|
|
using (var again = await Uploads.PutChunkAsync(uploader, id, 0, data))
|
|
{
|
|
await again.ExpectAsync(HttpStatusCode.OK);
|
|
Assert.SequenceEqual([0], (await again.ReadAsync(ProtocolJson.Default.ChunkReceived)).Received);
|
|
}
|
|
using (var unknown = await Uploads.PutChunkAsync(uploader, Guid.CreateVersion7(), 0, data)) await unknown.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found");
|
|
using (var complete = await uploader.PostAsync($"/api/v1/uploads/{id}/complete", null)) await complete.ExpectAsync(HttpStatusCode.OK);
|
|
using (var late = await Uploads.PutChunkAsync(uploader, id, 0, data)) await late.ExpectErrorAsync(HttpStatusCode.Conflict, "upload_state");
|
|
|
|
// Authentication answers before the endpoint runs: a user who may not upload, and a session signed out meanwhile.
|
|
var (viewer, _, _) = await server.UserAsync("marco", "viewer");
|
|
using (var forbidden = await Uploads.PutChunkAsync(viewer, id, 0, data)) await forbidden.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden");
|
|
using (var logout = await uploader.PostAsync("/api/v1/auth/logout", null)) await logout.ExpectAsync(HttpStatusCode.NoContent);
|
|
using var revoked = await Uploads.PutChunkAsync(uploader, id, 0, data);
|
|
await revoked.ExpectErrorAsync(HttpStatusCode.Unauthorized, "unauthorized");
|
|
}
|
|
|
|
[Test]
|
|
public async Task RenderUploadsNeedTheEditPermission()
|
|
{
|
|
await using var server = await TestServer.StartAsync(context, o => o.ChunkSizeBytes = Chunk);
|
|
var (uploader, _, _) = await server.UserAsync("roof-cam", "uploader");
|
|
var (editor, _, _) = await server.UserAsync("alberto", "editor");
|
|
var frame = await Uploads.UploadAsync(uploader, Uploads.Photo(5000, 16), sessionKey: "roof");
|
|
var output = Uploads.Photo(3000, 17);
|
|
var request = new RenderUploadRequest(Guid.CreateVersion7(), "Roof.mp4", output.Length, Uploads.Sha(output), "4K HEVC", "hevc", 3840, 2160, 30, 10, null);
|
|
|
|
// Render outputs count against no quota: an upload-only account cannot add them to any sequence.
|
|
using (var refused = await uploader.PostAsJsonAsync($"/api/v1/sequences/{frame.SequenceId}/renders", request, ProtocolJson.Default.RenderUploadRequest))
|
|
await refused.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden");
|
|
using (var complete = await uploader.PostAsync($"/api/v1/sequences/{frame.SequenceId}/renders/{Guid.CreateVersion7()}/complete", null))
|
|
await complete.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden");
|
|
using var accepted = await editor.PostAsJsonAsync($"/api/v1/sequences/{frame.SequenceId}/renders", request, ProtocolJson.Default.RenderUploadRequest);
|
|
await accepted.ExpectAsync(HttpStatusCode.Created);
|
|
}
|
|
|
|
[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 ChronosClient(server.HttpBase, new CertificatePinning([]), "Chronos 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(cancellationToken: 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<T> 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);
|
|
}
|
|
}
|