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; /// /// A workspace's local renders sent home (phase 5c, ) 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. /// [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 FixtureAsync() { var archive = Own(await ArchiveFixture.CreateAsync(Context, database: await NewOptionsAsync(multiConnection: true))); return Own(await WorkspaceFixture.CreateAsync(Context, archive, 3)); } /// An engine with the workspace's handlers; stands for a metered connection. private async Task EngineAsync(WorkspaceFixture fx, Func? 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; } /// Main checked out into a workspace of its own (its media are not needed to send). 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)); } /// An output in the project's exports with its ledger entry, as a local render leaves them. 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 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; }