Files
Alby96andClaude Opus 5.5 db389a54f2
CI / Build and test (push) Successful in 9m26s
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 8s
Release / Build, test and publish (push) Successful in 14m31s
CI / PostgreSQL 16 integration (push) Successful in 9m53s
CI / PostgreSQL 17 integration (push) Successful in 9m22s
CI / Docker image (push) Successful in 44s
Release / Server image (push) Successful in 1m36s
feat: owner review 2 phase 5c: originals, local render, clean-up and the workspace settings (#18)
Originals in the workspace, local render and send home with provenance, the workspace clean-up, size limit and trash, moving the workspace folder, and the complete Settings › Workspace page (owner review 2, R8, phase 5c). One adversarial review round (35 findings, 32 fixed), a copy-cancel race fixed, 184 strings in all 38 languages.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: Alberto Balbo <alberto.balbo.96@gmail.com>
2026-11-04 20:03:52 +01:00

299 lines
17 KiB
C#

using System.Security.Cryptography;
using Chronos.Core.Localization;
using Chronos.Core.Model;
using Chronos.Core.Project;
using Chronos.Data.Archiving;
using Chronos.Data.Jobs;
using Chronos.Data.Tests.Archiving;
using Chronos.Data.Tests.Infrastructure;
using Chronos.Data.Workspaces;
using Chronos.Testing;
namespace Chronos.Data.Tests.Workspaces;
/// <summary>
/// A workspace's local renders sent home (phase 5c, <see cref="JobKind.WorkspaceSend"/>) to this PC's archive: filed with
/// their project and version, the version pushed first when the home lacks it, a changed or missing file refused and left in
/// the workspace, a send repeated after a cut harmless, and never held on a metered connection.
/// </summary>
[Category("workspace")]
public abstract class WorkspaceSendTests(TestContext context) : DatabaseTest(context)
{
private static readonly DateTimeOffset Rendered = new(2026, 11, 4, 9, 0, 0, TimeSpan.Zero);
private async Task<WorkspaceFixture> FixtureAsync()
{
var archive = Own(await ArchiveFixture.CreateAsync(Context, database: await NewOptionsAsync(multiConnection: true)));
return Own(await WorkspaceFixture.CreateAsync(Context, archive, 3));
}
/// <summary>An engine with the workspace's handlers; <paramref name="hold"/> stands for a metered connection.</summary>
private async Task<JobEngine> EngineAsync(WorkspaceFixture fx, Func<bool>? hold = null)
{
var options = WorkspaceJobOptions.For(fx.Archive.Service) with { HoldTransfers = hold ?? (() => false) };
var engine = new JobEngine(fx.Db, WorkspaceJobs.CreateHandlers(fx.Db, fx.Archive.Service, null, options),
new JobEngineOptions { Workers = 1, WorkerId = "test", PollInterval = TimeSpan.FromMilliseconds(50), CheckpointInterval = TimeSpan.FromMilliseconds(50) });
await engine.StartAsync(Ct);
Own(engine);
return engine;
}
/// <summary>Main checked out into a workspace of its own (its media are not needed to send).</summary>
private static async Task<(WorkspaceStore Store, WorkspaceSync Sync, WorkspaceProject Project)> CheckoutAsync(WorkspaceFixture fx)
{
var (store, sync) = fx.Workspace();
var main = await fx.Archive.Service.Projects.MainAsync(fx.Sequence.Id, fx.Ct);
return (store, sync, await sync.CheckoutAsync(fx.Home, main.Id, cancellationToken: fx.Ct));
}
/// <summary>An output in the project's exports with its ledger entry, as a local render leaves them.</summary>
private static WorkspaceRenderEntry Render(WorkspaceProject project, Guid? versionId, string name, int seed, string? settingsHash = null)
{
Directory.CreateDirectory(project.ExportsDirectory);
var bytes = new byte[150_000 + seed];
new Random(seed).NextBytes(bytes);
File.WriteAllBytes(Path.Combine(project.ExportsDirectory, name), bytes);
var entry = new WorkspaceRenderEntry(Guid.CreateVersion7(), Guid.CreateVersion7(), name, Convert.ToHexStringLower(SHA256.HashData(bytes)), bytes.Length,
"1080p H.264", "h264", 1920, 1080, 24, 2.5, project.ProjectId, versionId, settingsHash, Rendered);
project.WriteRenders(project.ReadRenders().With(entry));
return entry;
}
private static string Sha(string path) => Convert.ToHexStringLower(SHA256.HashData(File.ReadAllBytes(path)));
private static async Task<Job> SendAsync(WorkspaceFixture fx, JobEngine engine, WorkspaceStore store, Guid projectId, JobState expected,
params Guid[] renderIds)
{
var job = await engine.EnqueueAsync(WorkspaceJobs.Send(fx.Sequence.Id, fx.Sequence.DisplayTitle, store.Root, projectId, renderIds), cancellationToken: fx.Ct);
return await fx.Archive.WaitForAsync(job.Id, expected, (int)TestTiming.Budget(60));
}
[Test]
public async Task TheSendFilesTheRenderInTheLibraryWithItsProjectAndVersion()
{
var fx = await FixtureAsync();
var engine = await EngineAsync(fx);
var (store, _, project) = await CheckoutAsync(fx);
var head = project.ReadBundle().Workspace!.Base!.VersionId;
var entry = Render(project, head, "Main 1080p.mp4", 1);
await SendAsync(fx, engine, store, project.ProjectId, JobState.Done);
var row = Assert.NotNull(await fx.Db.Renders.GetAsync(entry.RenderId, fx.Ct));
Assert.Equal((fx.Sequence.Id, (Guid?)project.ProjectId, (Guid?)head, "1080p H.264", entry.Size, 1920),
(row.SequenceId, row.ProjectId, row.ProjectVersionId, row.PresetName, row.Bytes, row.Width));
var filed = Path.Combine(fx.Archive.Archive.RootPath, row.OutputPath);
Assert.Equal(entry.Sha256, Sha(filed));
Assert.Equal("Main 1080p.mp4", Path.GetFileName(filed));
// The workspace keeps its file until a clean-up; the ledger says it went home.
Assert.Equal(entry.Sha256, Sha(project.ExportFile(entry.File)));
var sent = Assert.NotNull(project.ReadRenders().Find(entry.RenderId));
Assert.True(sent.IsSent);
Assert.NotNull(sent.Sent);
Assert.Empty(Directory.GetFiles(fx.Archive.Paths.StagingDirectory, "workspace-render-*"));
}
[Test]
public async Task ASendRepeatedAfterACutFilesNothingTwice()
{
var fx = await FixtureAsync();
var engine = await EngineAsync(fx);
var (store, _, project) = await CheckoutAsync(fx);
var entry = Render(project, project.ReadBundle().Workspace!.Base!.VersionId, "Main.mp4", 2);
await SendAsync(fx, engine, store, project.ProjectId, JobState.Done, entry.RenderId);
// Cut after the home filed it, before the ledger said so: the next send finds it there and only marks it sent.
project.WriteRenders(project.ReadRenders().With(entry));
Assert.True(project.ReadRenders().Find(entry.RenderId)!.IsUnsent);
var again = await SendAsync(fx, engine, store, project.ProjectId, JobState.Done);
Assert.Contains(Loc.L("Archive.Log.WorkspaceSent", project.ReadBundle().Workspace!.Name, 0, 1), again.LogTail);
Assert.True(project.ReadRenders().Find(entry.RenderId)!.IsSent);
Assert.Equal(1, (await fx.Db.Renders.ListBySequenceAsync(fx.Sequence.Id, fx.Ct)).Count);
var exports = Path.GetDirectoryName(Path.Combine(fx.Archive.Archive.RootPath, (await fx.Db.Renders.GetAsync(entry.RenderId, fx.Ct))!.OutputPath))!;
Assert.Equal(1, Directory.GetFiles(exports).Length);
// A send with nothing unsent is done at once.
var nothing = await SendAsync(fx, engine, store, project.ProjectId, JobState.Done);
Assert.Contains(Loc.L("Archive.Log.WorkspaceSent", project.ReadBundle().Workspace!.Name, 0, 0), nothing.LogTail);
}
[Test]
public async Task AnImageSequenceIsFiledWholeAndCheckedByItsListing()
{
var fx = await FixtureAsync();
var engine = await EngineAsync(fx);
var (store, _, project) = await CheckoutAsync(fx);
var folder = Path.Combine(project.ExportsDirectory, "Main frames");
Directory.CreateDirectory(folder);
for (var i = 0; i < 3; i++) File.WriteAllText(Path.Combine(folder, $"frame-{i:D4}.png"), "frame " + i);
var size = Directory.GetFiles(folder).Sum(f => new FileInfo(f).Length);
var entry = new WorkspaceRenderEntry(Guid.CreateVersion7(), Guid.CreateVersion7(), "Main frames", await WorkspaceRenderJobHandler.HashAsync(folder), size,
"PNG frames", "png", 96, 64, 24, 0.125, project.ProjectId, null, null, Rendered);
project.WriteRenders(project.ReadRenders().With(entry));
await SendAsync(fx, engine, store, project.ProjectId, JobState.Done);
var row = Assert.NotNull(await fx.Db.Renders.GetAsync(entry.RenderId, fx.Ct));
Assert.Equal((size, (Guid?)project.ProjectId), (row.Bytes, row.ProjectId));
var filed = Path.Combine(fx.Archive.Archive.RootPath, row.OutputPath);
Assert.True(Directory.Exists(filed), filed);
Assert.Equal(entry.Sha256, await WorkspaceRenderJobHandler.HashAsync(filed));
Assert.True(project.ReadRenders().Find(entry.RenderId)!.IsSent);
Assert.Empty(Directory.GetFileSystemEntries(fx.Archive.Paths.StagingDirectory, "workspace-render-*"));
// A frame changed after the render: refused, the folder left where it is.
var changed = entry with { RenderId = Guid.CreateVersion7(), File = "Changed frames" };
Directory.CreateDirectory(project.ExportFile(changed.File));
foreach (var file in Directory.GetFiles(folder)) File.Copy(file, Path.Combine(project.ExportFile(changed.File), Path.GetFileName(file)));
File.WriteAllText(Path.Combine(project.ExportFile(changed.File), "frame-0001.png"), "frame X");
project.WriteRenders(project.ReadRenders().With(changed with { State = WorkspaceRenderEntry.Pending, Sent = null }));
var failed = await SendAsync(fx, engine, store, project.ProjectId, JobState.Failed);
Assert.Contains(Loc.L("Errors.Workspace.SendHashMismatch", "Changed frames"), failed.LogTail);
Assert.Null(await fx.Db.Renders.GetAsync(changed.RenderId, fx.Ct));
Assert.True(Directory.Exists(project.ExportFile(changed.File)), "the folder stays in the workspace");
}
[Test]
public async Task AVersionTheHomeLacksIsSentFirst()
{
var fx = await FixtureAsync();
var engine = await EngineAsync(fx);
// With its media: a version is saved only of frames the workspace holds.
var (store, sync) = fx.Workspace();
var project = await fx.CheckoutAsync(sync);
var session = await sync.OpenAsync(project.ProjectId, fx.Ct);
await sync.SaveAsync(project.ProjectId, session.Working with { HeroFrame = 2 }, fx.Ct);
var local = Assert.NotNull(await sync.CommitAsync(project.ProjectId, "Render", cancellationToken: fx.Ct));
Assert.Null(await fx.Home.GetVersionAsync(project.ProjectId, local.Id, fx.Ct));
var entry = Render(project, local.Id, "Hero.mp4", 3);
var job = await SendAsync(fx, engine, store, project.ProjectId, JobState.Done);
var pushed = Assert.NotNull(await fx.Home.GetVersionAsync(project.ProjectId, local.Id, fx.Ct));
Assert.Contains(Loc.L("Archive.Log.WorkspaceVersionPushed", project.ReadBundle().Workspace!.Name, pushed.Number), job.LogTail);
Assert.Equal((Guid?)local.Id, (await fx.Db.Renders.GetAsync(entry.RenderId, fx.Ct))!.ProjectVersionId);
Assert.Equal(WorkspaceState.InSync, (await sync.StatusAsync(project.ProjectId, fx.Home, fx.Ct)).State);
}
[Test]
public async Task AChangedOrMissingRenderIsRefusedAndTheOthersGoOn()
{
var fx = await FixtureAsync();
var engine = await EngineAsync(fx);
var (store, _, project) = await CheckoutAsync(fx);
var head = project.ReadBundle().Workspace!.Base!.VersionId;
var changed = Render(project, head, "Changed.mp4", 4);
var gone = Render(project, head, "Gone.mp4", 5);
var good = Render(project, head, "Good.mp4", 6);
var original = File.ReadAllBytes(project.ExportFile(changed.File));
File.AppendAllText(project.ExportFile(changed.File), "edited");
File.Delete(project.ExportFile(gone.File));
var failed = await SendAsync(fx, engine, store, project.ProjectId, JobState.Failed);
Assert.Equal(Loc.L("Errors.Workspace.SendFailed", 2, 3), failed.Error);
var ledger = project.ReadRenders();
Assert.True(ledger.Find(good.RenderId)!.IsSent);
Assert.Equal((WorkspaceRenderEntry.Failed, Loc.L("Errors.Workspace.SendHashMismatch", "Changed.mp4")),
(ledger.Find(changed.RenderId)!.State, ledger.Find(changed.RenderId)!.Error));
Assert.Equal((WorkspaceRenderEntry.Failed, Loc.L("Errors.Workspace.SendMissing", "Gone.mp4")),
(ledger.Find(gone.RenderId)!.State, ledger.Find(gone.RenderId)!.Error));
Assert.Null(await fx.Db.Renders.GetAsync(changed.RenderId, fx.Ct));
Assert.Null(await fx.Db.Renders.GetAsync(gone.RenderId, fx.Ct));
// The changed file stays in the workspace as it is.
Assert.FileExists(project.ExportFile(changed.File));
// Put back as rendered (and the missing one discarded), the next send takes it.
File.WriteAllBytes(project.ExportFile(changed.File), original);
project.WriteRenders(project.ReadRenders().Without(gone.RenderId));
await SendAsync(fx, engine, store, project.ProjectId, JobState.Done);
Assert.True(project.ReadRenders().Find(changed.RenderId)!.IsSent);
Assert.Equal(2, (await fx.Db.Renders.ListBySequenceAsync(fx.Sequence.Id, fx.Ct)).Count);
}
[Test]
public async Task AVersionOfAnotherProjectIsNeverFiledWithTheRender()
{
var fx = await FixtureAsync();
var engine = await EngineAsync(fx);
var (store, _, project) = await CheckoutAsync(fx);
var other = await fx.Home.CreateAsync("Vertical", null, null, fx.Ct);
var foreign = (await fx.Home.HeadAsync(other.Id, fx.Ct)).Id;
var entry = Render(project, foreign, "Foreign.mp4", 7);
var job = await SendAsync(fx, engine, store, project.ProjectId, JobState.Done);
// The project's home holds no such version of this project: the render goes with its project alone.
Assert.Contains(Loc.L("Archive.Log.WorkspaceVersionNotHome", project.ReadBundle().Workspace!.Name), job.LogTail!);
var row = Assert.NotNull(await fx.Db.Renders.GetAsync(entry.RenderId, fx.Ct));
Assert.Equal(((Guid?)project.ProjectId, (Guid?)null), (row.ProjectId, row.ProjectVersionId));
Assert.True(project.ReadRenders().Find(entry.RenderId)!.IsSent);
Assert.Null(project.ReadRenders().Find(entry.RenderId)!.ProjectVersionId);
}
[Test]
public async Task AVersionTheHomeHoldsByAnotherIdIsFiledByThatId()
{
var fx = await FixtureAsync();
var engine = await EngineAsync(fx);
var (store, _, project) = await CheckoutAsync(fx);
// A version a push replayed on a home that moved on: the home holds its content under another id.
var head = await fx.Home.HeadAsync(project.ProjectId, fx.Ct);
var entry = Render(project, Guid.CreateVersion7(), "Replayed.mp4", 11, head.ContentHash);
var job = await SendAsync(fx, engine, store, project.ProjectId, JobState.Done);
Assert.Contains(Loc.L("Archive.Log.WorkspaceVersionReplayed", project.ReadBundle().Workspace!.Name, head.Number), job.LogTail!);
var row = Assert.NotNull(await fx.Db.Renders.GetAsync(entry.RenderId, fx.Ct));
Assert.Equal(((Guid?)project.ProjectId, (Guid?)head.Id), (row.ProjectId, row.ProjectVersionId));
// The ledger names the home's id from now on.
var sent = Assert.NotNull(project.ReadRenders().Find(entry.RenderId));
Assert.Equal(((Guid?)head.Id, true), (sent.ProjectVersionId, sent.IsSent));
}
[Test]
public async Task ALedgerNamingAFileOutsideTheExportsIsRefused()
{
var fx = await FixtureAsync();
var engine = await EngineAsync(fx);
var (store, _, project) = await CheckoutAsync(fx);
// A ledger edited by hand (or a newer Chronos's) naming the working state: never read, never sent.
var entry = Render(project, null, "Outside.mp4", 12) with { File = Path.Combine("..", WorkspaceProject.BundleFile) };
project.WriteRenders(project.ReadRenders().Without(entry.RenderId).With(entry));
var failed = await SendAsync(fx, engine, store, project.ProjectId, JobState.Failed);
Assert.Equal(Loc.L("Errors.Workspace.SendFailed", 1, 1), failed.Error);
Assert.Null(await fx.Db.Renders.GetAsync(entry.RenderId, fx.Ct));
Assert.Equal((WorkspaceRenderEntry.Failed, Loc.L("Errors.Workspace.SendMissing", WorkspaceProject.BundleFile)),
(project.ReadRenders().Find(entry.RenderId)!.State, project.ReadRenders().Find(entry.RenderId)!.Error));
Assert.FileExists(project.BundlePath);
}
[Test]
public async Task ASendToThisPcsLibraryIsNeverHeldOnAMeteredConnection()
{
var fx = await FixtureAsync();
var engine = await EngineAsync(fx, hold: () => true);
var (store, _, project) = await CheckoutAsync(fx);
var entry = Render(project, null, "Working.mp4", 8);
var job = await SendAsync(fx, engine, store, project.ProjectId, JobState.Done);
Assert.False(job.LogTail?.Contains(Loc.L("Archive.Log.WorkspaceSendHeld"), StringComparison.Ordinal) ?? false);
var row = Assert.NotNull(await fx.Db.Renders.GetAsync(entry.RenderId, fx.Ct));
Assert.Equal(((Guid?)project.ProjectId, (Guid?)null), (row.ProjectId, row.ProjectVersionId));
}
}
public sealed class SqliteWorkspaceSendTests(TestContext context) : WorkspaceSendTests(context)
{
protected override Backend Backend => Backend.SqliteFile;
}
[RequiresEnvironment(PgTestServer.Variable)]
public sealed class PostgresWorkspaceSendTests(TestContext context) : WorkspaceSendTests(context)
{
protected override Backend Backend => Backend.Postgres;
}