using Chronos.Core.Model; using Chronos.Data.Archiving; using Chronos.Data.Jobs; using Chronos.Data.Projects; using Chronos.Data.Tests.Archiving; using Chronos.Data.Tests.Projects; using Chronos.Data.Workspaces; using Chronos.Testing; namespace Chronos.Data.Tests.Workspaces; /// An archive with an uploaded sequence as the projects' home, and workspaces that edit it (owner review 2, R8). internal sealed class WorkspaceFixture : IAsyncDisposable { private readonly TestContext _context; private JobEngine? _engine; private WorkspaceFixture(TestContext context, ArchiveFixture archive, Sequence sequence, List frames) { _context = context; Archive = archive; Sequence = sequence; Frames = frames; Home = new ArchiveProjectHome(archive.Db, archive.Service.Projects, sequence.Id); } public ArchiveFixture Archive { get; } public Sequence Sequence { get; set; } public List Frames { get; } public ArchiveProjectHome Home { get; } public ChronosDatabase Db => Archive.Db; public CancellationToken Ct => Archive.Ct; public static async Task CreateAsync(TestContext context, ArchiveFixture archive, int frames = 5) { var (sequence, list) = await ProjectServiceTests.UploadedAsync(archive, frames); return new WorkspaceFixture(context, archive, sequence, list); } /// A workspace of its own (another PC, or another folder of this one) and its sync. public (WorkspaceStore Store, WorkspaceSync Sync) Workspace(string name = "workspace") { var store = new WorkspaceStore(Path.Combine(_context.CreateTempDirectory(name), "workspace")); return (store, new WorkspaceSync(store, "Chronos on " + name) { LockWait = TimeSpan.FromSeconds(TestTiming.Budget(10)) }); } /// /// Another sync of that stops, as a crash would, at the -th time it /// reaches step (), throwing . /// public static WorkspaceSync Cutting(WorkspaceStore store, string step, int occurrence = 1) { var seen = 0; return new WorkspaceSync(store, "Chronos cut") { LockWait = TimeSpan.FromSeconds(TestTiming.Budget(10)), Cut = name => { if (name == step && ++seen == occurrence) throw new CutException(step); }, }; } /// Main of the sequence checked out into 's workspace, its media copied. public async Task CheckoutAsync(WorkspaceSync sync, Guid? projectId = null) { var id = projectId ?? (await Archive.Service.Projects.MainAsync(Sequence.Id, Ct)).Id; var project = await sync.CheckoutAsync(Home, id, cancellationToken: Ct); await CopyAsync(sync.Store, id); return project; } /// Runs a workspace copy job to its end. public Task CopyAsync(WorkspaceStore store, Guid projectId, JobState expected = JobState.Done, string? checkpoint = null, string media = "proxies") => CopyAsync(store.Root, projectId, expected, checkpoint, media); /// Runs a workspace copy job into the workspace at to its end. public async Task CopyAsync(string root, Guid projectId, JobState expected = JobState.Done, string? checkpoint = null, string media = "proxies") { var engine = await EngineAsync(); var request = WorkspaceJobs.Copy(Sequence, root, projectId, media); var job = checkpoint is null ? await engine.EnqueueAsync(request, cancellationToken: Ct) : await Archive.EnqueueWithCheckpointAsync(engine, request, checkpoint); return await Archive.WaitForAsync(job.Id, expected, (int)TestTiming.Budget(60)); } /// Queues a workspace copy job and returns at once, while it runs. public async Task StartCopyAsync(WorkspaceStore store, Guid projectId) { var engine = await EngineAsync(); return await engine.EnqueueAsync(WorkspaceJobs.Copy(Sequence, store.Root, projectId), cancellationToken: Ct); } /// Cancels a job, as the user does from the jobs list. public async Task CancelAsync(Guid jobId) => await (await EngineAsync()).CancelAsync(jobId, Ct); /// Pauses a job, as the user does from the jobs list. public async Task PauseAsync(Guid jobId) => await (await EngineAsync()).PauseAsync(jobId, Ct); private async Task EngineAsync() { if (_engine is not null) return _engine; _engine = new JobEngine(Db, [.. Archive.Service.CreateJobHandlers(), .. WorkspaceJobs.CreateHandlers(Db, Archive.Service)], new JobEngineOptions { Workers = 1, WorkerId = "test", PollInterval = TimeSpan.FromMilliseconds(50), CheckpointInterval = TimeSpan.FromMilliseconds(50) }); await _engine.StartAsync(Ct); return _engine; } public async ValueTask DisposeAsync() { if (_engine is not null) await _engine.DisposeAsync(); } } /// A crash between two writes of a sync (). internal sealed class CutException(string step) : Exception($"Cut at {step}."); /// /// A home whose pushes can be cut: one refused as out of reach before the home sees it, or one stored whose answer is lost /// on the way back (the program killed, the network dropped). /// internal sealed class CuttingHome(IProjectHome home) : IProjectHome { public int Pushes { get; private set; } /// The push (counted from 1) refused as out of reach. public int? Refuse { get; set; } /// The push (counted from 1) the home stores and whose answer is lost. public int? LoseAnswer { get; set; } /// What the home answers every push with, storing nothing (a home with a smaller limit, say); null to store. public PushOutcome? Answer { get; set; } /// The home answers it holds no versions after any number (an index taken back from an older backup). public bool Forgets { get; set; } public async Task PushAsync(Guid projectId, ProjectVersion version, CancellationToken cancellationToken) { var push = ++Pushes; if (push == Refuse) throw new HomeUnavailableException("The home cannot be reached."); if (Answer is { } answer) return new PushResult(answer, null, await home.HeadAsync(projectId, cancellationToken)); var result = await home.PushAsync(projectId, version, cancellationToken); if (push == LoseAnswer) throw new HomeUnavailableException("The answer was lost."); return result; } public Task SequenceAsync(CancellationToken cancellationToken) => home.SequenceAsync(cancellationToken); public Task> ListAsync(CancellationToken cancellationToken) => home.ListAsync(cancellationToken); public Task CreateAsync(string name, Guid? fromVersionId, string? author, CancellationToken cancellationToken) => home.CreateAsync(name, fromVersionId, author, cancellationToken); public Task HeadAsync(Guid projectId, CancellationToken cancellationToken) => home.HeadAsync(projectId, cancellationToken); public Task GetVersionAsync(Guid projectId, Guid versionId, CancellationToken cancellationToken) => home.GetVersionAsync(projectId, versionId, cancellationToken); public Task> VersionsAfterAsync(Guid projectId, int afterNumber, int limit, CancellationToken cancellationToken) => Forgets ? Task.FromResult>([]) : home.VersionsAfterAsync(projectId, afterNumber, limit, cancellationToken); public Task> HistoryAsync(Guid projectId, int? beforeNumber, int limit, CancellationToken cancellationToken) => home.HistoryAsync(projectId, beforeNumber, limit, cancellationToken); public Task FramesAsync(CancellationToken cancellationToken) => home.FramesAsync(cancellationToken); } /// A home that counts its reads of the frames, its stamp of them passed through. internal sealed class CountingHome(IProjectHome home) : IProjectHome { public int FramesReads { get; private set; } public Task FramesAsync(CancellationToken cancellationToken) { FramesReads++; return home.FramesAsync(cancellationToken); } public Task FramesStampAsync(CancellationToken cancellationToken) => home.FramesStampAsync(cancellationToken); public Task SequenceAsync(CancellationToken cancellationToken) => home.SequenceAsync(cancellationToken); public Task> ListAsync(CancellationToken cancellationToken) => home.ListAsync(cancellationToken); public Task CreateAsync(string name, Guid? fromVersionId, string? author, CancellationToken cancellationToken) => home.CreateAsync(name, fromVersionId, author, cancellationToken); public Task HeadAsync(Guid projectId, CancellationToken cancellationToken) => home.HeadAsync(projectId, cancellationToken); public Task GetVersionAsync(Guid projectId, Guid versionId, CancellationToken cancellationToken) => home.GetVersionAsync(projectId, versionId, cancellationToken); public Task> VersionsAfterAsync(Guid projectId, int afterNumber, int limit, CancellationToken cancellationToken) => home.VersionsAfterAsync(projectId, afterNumber, limit, cancellationToken); public Task> HistoryAsync(Guid projectId, int? beforeNumber, int limit, CancellationToken cancellationToken) => home.HistoryAsync(projectId, beforeNumber, limit, cancellationToken); public Task PushAsync(Guid projectId, ProjectVersion version, CancellationToken cancellationToken) => home.PushAsync(projectId, version, cancellationToken); } /// A home that cannot be reached, standing for a server out of reach or an archive offline. internal sealed class UnreachableHome(IProjectHome home) : IProjectHome { public bool Reachable { get; set; } private T Reach(Func call) => Reachable ? call() : throw new HomeUnavailableException("The home cannot be reached."); public Task SequenceAsync(CancellationToken cancellationToken) => Reach(() => home.SequenceAsync(cancellationToken)); public Task> ListAsync(CancellationToken cancellationToken) => Reach(() => home.ListAsync(cancellationToken)); public Task CreateAsync(string name, Guid? fromVersionId, string? author, CancellationToken cancellationToken) => Reach(() => home.CreateAsync(name, fromVersionId, author, cancellationToken)); public Task HeadAsync(Guid projectId, CancellationToken cancellationToken) => Reach(() => home.HeadAsync(projectId, cancellationToken)); public Task GetVersionAsync(Guid projectId, Guid versionId, CancellationToken cancellationToken) => Reach(() => home.GetVersionAsync(projectId, versionId, cancellationToken)); public Task> VersionsAfterAsync(Guid projectId, int afterNumber, int limit, CancellationToken cancellationToken) => Reach(() => home.VersionsAfterAsync(projectId, afterNumber, limit, cancellationToken)); public Task> HistoryAsync(Guid projectId, int? beforeNumber, int limit, CancellationToken cancellationToken) => Reach(() => home.HistoryAsync(projectId, beforeNumber, limit, cancellationToken)); public Task PushAsync(Guid projectId, ProjectVersion version, CancellationToken cancellationToken) => Reach(() => home.PushAsync(projectId, version, cancellationToken)); public Task FramesAsync(CancellationToken cancellationToken) => Reach(() => home.FramesAsync(cancellationToken)); }