Originals are now judged by their bytes, never by the media index: a removal or clean-up hashes every file under media/originals and deletes it only when the home holds that SHA-256; every other file, named or not, goes to the workspace trash. Trash entries are filled under a staging name that Empty never lists. A ledger can only name files inside exports/. Jobs follow the workspace: a copy, render or send resolves the folder that holds its project now (a moved workspace, a retry after a move) and waits while a move has not switched yet. A clean-up failure after the switch is a warning that keeps the journal for a later resume; entries that changed since they were copied are kept, and a same-volume rename refused across volumes falls back to copy and verify. Sends map a replayed version by content hash, or go with the project only, and note an old server that drops provenance. The media index (format 2) and project file (format 3) refuse older readers while they hold originals. Metered connections also hold sync downloads and server copies. The editor gains Send again, the Settings page can resume a stopped move, the disabled tooltips say why, and unused strings are pruned. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
299 lines
17 KiB
C#
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;
|
|
}
|