The local render, the send home, the clean-up, the settings page and the folder move were built apart; together they left gaps: - A local render to an image sequence writes a folder, which the send took for a missing file. The archive home now files the folder whole (checked by its listing hash, as the render recorded it) and the clean-up removes a sent folder; a server, which takes one file per render, refuses it with Errors.Workspace.SendSequence. - Rename, delete and Remove local copy are refused while the folder is being moved, so no project folder changes under the move. - Settings > Workspace shows the folder, usage, Move... and Change... again when a move ends (WorkspaceHost.MoveEnded). - Empty... uses the Settings typed confirmation; the separate trash dialog, never shown, is removed. The move plan counts unsent renders with the clean-up's helper. - Tests: the follow-up send now runs in the render tests; an end-to-end archive-home test (originals, version on render, local render, send with project and version, clean-up) and an image-sequence send test. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
258 lines
14 KiB
C#
258 lines
14 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)
|
|
{
|
|
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, null, 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 failed = await SendAsync(fx, engine, store, project.ProjectId, JobState.Failed);
|
|
|
|
Assert.Equal(Loc.L("Errors.Workspace.SendVersion"), failed.Error);
|
|
Assert.Null(await fx.Db.Renders.GetAsync(entry.RenderId, fx.Ct));
|
|
// Not the render's fault: it waits, unsent, for the next send.
|
|
Assert.Equal(WorkspaceRenderEntry.Pending, project.ReadRenders().Find(entry.RenderId)!.State);
|
|
}
|
|
|
|
[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;
|
|
}
|