using System.Globalization;
using System.IO;
using Chronos.App.Infrastructure;
using Chronos.App.Workspace;
using Chronos.Core.Localization;
using Chronos.Core.Model;
using Chronos.Data;
using Chronos.Data.Archiving;
using Chronos.Data.Jobs;
using Chronos.Data.Workspaces;
using Chronos.Testing;
namespace Chronos.App.Tests.Workspace;
///
/// Settings › Workspace › Move… (phase 5c, P6) as the desktop runs it: the plan and its confirmation, the open project
/// closed first, the workspace held while the move waits or runs, the setting switched only once the move verified
/// everything, a failed move that leaves both as they were, and a move stopped before it ended taken up again.
///
[Category("workspace")]
public sealed class WorkspaceMoveTests(TestContext context)
{
static WorkspaceMoveTests() => Loc.SetCulture(CultureInfo.GetCultureInfo("en"));
[Test]
public async Task TheWorkspaceWaitsForTheMoveAndFollowsTheFolderOnlyOnceItEnded()
{
await using var bed = await WorkspaceTestBed.CreateAsync(context, frames: 4);
var settings = new AppSettings();
var mainId = await bed.CheckoutAsync(bed.Host(settings));
await using var moves = await MovesAsync(bed, settings);
var host = moves.Host;
var from = host.Root;
var target = Path.Combine(bed.Directory, "moved workspace");
var plan = await host.PlanMoveAsync(target);
Assert.True(plan.CanMove, plan.Refusal);
Assert.Equal((from, Path.GetFullPath(target), true), (plan.From, plan.To, plan.SameVolume));
var project = Assert.NotNull(plan.Projects.SingleOrDefault());
Assert.Equal(mainId, project.ProjectId);
Assert.True(plan.Files >= project.Files && project.Files > 0 && plan.Bytes > 0);
var failures = new List();
var closes = 0;
var close = true;
Task CloseProject()
{
closes++;
return Task.FromResult(close);
}
// Declined, or the open project kept open: nothing is queued.
var dialogs = new MoveDialogs { Folder = target, Answer = false };
Assert.False(await WorkspaceFolderChange.MoveAsync(host, dialogs, CloseProject, failures.Add));
var asked = Assert.NotNull(dialogs.Asked.SingleOrDefault());
Assert.Equal(Loc.L("Settings.Workspace.MovePlan.Message", plan.From, plan.To), asked.Message);
Assert.Contains(Loc.L("Settings.Workspace.MovePlan.Projects", Formatting.Count(1)), asked.Detail);
Assert.Contains(Loc.L("Settings.Workspace.MovePlan.SameVolume"), asked.Detail);
Assert.True(asked is { IsDestructive: false, ActionText.Length: > 0, ActionToolTip.Length: > 0, SafeToolTip.Length: > 0 });
Assert.Equal(0, closes, "nothing closed before the plan is confirmed");
dialogs.Answer = true;
close = false;
Assert.False(await WorkspaceFolderChange.MoveAsync(host, dialogs, CloseProject, failures.Add));
Assert.False(host.IsMoving);
// Queued: until it ends the workspace opens, copies, syncs and changes folder no more, and is not moved twice.
close = true;
Assert.True(await WorkspaceFolderChange.MoveAsync(host, dialogs, CloseProject, failures.Add));
Assert.Empty(failures);
Assert.True(host.IsMoving);
var moving = Loc.L("Errors.Workspace.Moving");
Assert.Equal(moving, (await Assert.ThrowsAsync(() => host.FindAsync(mainId))).Message);
Assert.Equal(moving, (await Assert.ThrowsAsync(() => host.ProjectsOfAsync(bed.SequenceId))).Message);
Assert.Equal(moving, (await Assert.ThrowsAsync(() => host.SyncAsync(mainId))).Message);
Assert.Equal(moving, (await Assert.ThrowsAsync(() => host.QueueCopyAsync(mainId))).Message);
Assert.Equal(moving, (await Assert.ThrowsAsync(() => host.CheckoutAsync(bed.SequenceId, mainId, null))).Message);
Assert.Equal(moving, (await Assert.ThrowsAsync(() => host.UseFolderAsync(Path.Combine(bed.Directory, "elsewhere")))).Message);
Assert.False(await WorkspaceFolderChange.MoveAsync(host, dialogs, CloseProject, failures.Add));
Assert.SequenceEqual([moving], failures);
Assert.Equal(((string?)null, 0), (settings.WorkspaceFolder, moves.Saves), "the setting waits for the move");
await moves.Engine.StartAsync(context.Cancellation);
var job = Assert.NotNull((await moves.Db.Jobs.ListAsync(null, JobKind.WorkspaceMove, 5, cancellationToken: context.Cancellation)).Items.SingleOrDefault());
await moves.WaitAsync(job.Id, JobState.Done);
await WorkspaceTestBed.UntilAsync(() => !host.IsMoving, "the workspace is let go");
Assert.Equal((Path.GetFullPath(target), 1), (settings.WorkspaceFolder, moves.Saves));
Assert.Equal(Path.GetFullPath(target), host.Root);
Assert.Equal(mainId, Assert.NotNull(await host.FindAsync(mainId)).ProjectId);
Assert.Equal(mainId, (await host.ListAsync()).Single().ProjectId);
Assert.False(Directory.Exists(Path.Combine(from, mainId.ToString("N"))), "the project left the folder");
}
[Test]
public async Task AMoveThatFailsLeavesTheSettingAndTheWorkspaceWhereTheyWere()
{
await using var bed = await WorkspaceTestBed.CreateAsync(context, frames: 4);
var settings = new AppSettings();
var mainId = await bed.CheckoutAsync(bed.Host(settings));
await using var moves = await MovesAsync(bed, settings);
var host = moves.Host;
var from = host.Root;
var target = Path.Combine(bed.Directory, "target");
// A workspace job waiting refuses the plan.
var copy = await moves.Engine.EnqueueAsync(JobKind.WorkspaceCopy, [bed.SequenceId], "copy", null, cancellationToken: context.Cancellation);
Assert.Equal(Loc.L("Errors.Workspace.JobsRunning"), (await host.PlanMoveAsync(target)).Refusal);
await moves.Engine.CancelAsync(copy.Id, context.Cancellation);
var plan = await host.PlanMoveAsync(target);
await host.QueueMoveAsync(plan);
// Meanwhile the target became a workspace of its own: the job refuses it.
_ = new WorkspaceStore(target);
await moves.Engine.StartAsync(context.Cancellation);
var job = Assert.NotNull((await moves.Db.Jobs.ListAsync(null, JobKind.WorkspaceMove, 5, cancellationToken: context.Cancellation)).Items.SingleOrDefault());
var failed = await moves.WaitAsync(job.Id, JobState.Failed);
Assert.Equal(Loc.L("Errors.Workspace.MoveTargetNotEmpty", Path.GetFullPath(target)), failed.Error);
await WorkspaceTestBed.UntilAsync(() => !host.IsMoving, "the workspace is let go");
Assert.Equal(((string?)null, 0, from), (settings.WorkspaceFolder, moves.Saves, host.Root));
Assert.Equal(mainId, Assert.NotNull(await host.FindAsync(mainId)).ProjectId);
Assert.Empty(new WorkspaceStore(target).List());
}
[Test]
public async Task AMoveStoppedBeforeItEndedIsOfferedAgainAndGoesOn()
{
await using var bed = await WorkspaceTestBed.CreateAsync(context, frames: 4);
var settings = new AppSettings();
var mainId = await bed.CheckoutAsync(bed.Host(settings));
await using var moves = await MovesAsync(bed, settings);
var host = moves.Host;
var from = host.Root;
var target = Path.Combine(bed.Directory, "target");
// The program closed as the move began: its journal is in the folder, and no job waits for it.
var plan = await host.PlanMoveAsync(target);
using (var closed = new CancellationTokenSource())
{
await closed.CancelAsync();
await Assert.ThrowsAsync(() => new WorkspaceMover(from, target).MoveAsync(plan.Fingerprint, cancellationToken: closed.Token));
}
Assert.True(host.IsMoving, "a journal holds the workspace");
Assert.Equal(Loc.L("Errors.Workspace.Moving"), (await Assert.ThrowsAsync(() => host.FindAsync(mainId))).Message);
var journal = Assert.NotNull(await host.UnfinishedMoveAsync());
Assert.Equal((Path.GetFullPath(target), WorkspaceMoveStage.Moving), (journal.To, journal.Stage));
var job = await host.ResumeMoveAsync(journal);
Assert.Null(await host.UnfinishedMoveAsync());
await moves.Engine.StartAsync(context.Cancellation);
var done = await moves.WaitAsync(job.Id, JobState.Done);
Assert.Contains(Loc.L("Archive.Log.WorkspaceMoveResumed", Path.Combine(from, WorkspaceMover.JournalFile)), done.LogTail);
await WorkspaceTestBed.UntilAsync(() => !host.IsMoving, "the workspace is let go");
Assert.Equal(Path.GetFullPath(target), settings.WorkspaceFolder);
Assert.Equal(mainId, Assert.NotNull(await host.FindAsync(mainId)).ProjectId);
Assert.Null(await host.UnfinishedMoveAsync());
}
///
/// A workspace over the bed's folder whose move jobs run on an engine of their own (over an index of their own, so the
/// bed's engine never takes them), which tells the workspace once a move ended; the engine is started by the test.
///
private async Task MovesAsync(WorkspaceTestBed bed, AppSettings settings)
{
var db = await ChronosDatabase.OpenAsync(DatabaseOptions.Sqlite(Path.Combine(context.CreateTempDirectory("moves"), "index.db")), context.Cancellation);
var moves = new Moves(db);
var options = new WorkspaceJobOptions(WorkspaceJobOptions.For(bed.Archives).Processing, () => false, (f, t) => moves.Host.MovedAsync(f, t));
moves.Engine = new JobEngine(db, WorkspaceJobs.CreateHandlers(db, bed.Archives, null, options),
new JobEngineOptions { Workers = 1, WorkerId = "moves", PollInterval = TimeSpan.FromMilliseconds(50), CheckpointInterval = TimeSpan.FromMilliseconds(50) });
moves.Host = new WorkspaceHost(bed.Environment, settings, () => moves.Saves++, () => db, () => bed.Archives, () => moves.Engine)
{
LockWait = TimeSpan.FromSeconds(TestTiming.Budget(10)),
};
return moves;
}
private sealed class Moves(ChronosDatabase db) : IAsyncDisposable
{
public ChronosDatabase Db { get; } = db;
public JobEngine Engine { get; set; } = null!;
public WorkspaceHost Host { get; set; } = null!;
public int Saves { get; set; }
public async Task WaitAsync(Guid jobId, JobState expected)
{
var deadline = DateTime.UtcNow + TimeSpan.FromSeconds(TestTiming.Budget(60));
while (true)
{
var job = await Db.Jobs.GetAsync(jobId);
if (job is { State: JobState.Done or JobState.Failed or JobState.Cancelled })
{
Assert.Equal(expected, job.State, job.Error ?? job.LogTail);
return job;
}
if (DateTime.UtcNow > deadline) Assert.Fail($"Job {jobId} still {job?.State} after its time budget");
await Task.Delay(50);
}
}
public async ValueTask DisposeAsync()
{
await Engine.DisposeAsync();
await Db.DisposeAsync();
}
}
/// Dialogs that pick and answer every confirmation with , recording what they were asked.
private sealed class MoveDialogs : IAppDialogs
{
public string? Folder { get; set; }
public bool Answer { get; set; }
public List Asked { get; } = [];
public string? PickFolder(string title, string? initialFolder = null) => Folder;
public string? PickJsonFile(string title) => null;
public bool Confirm(ConfirmRequest request)
{
Asked.Add(request);
return Answer;
}
public bool SignIn(string server, string? username, Func> signIn) => false;
}
}