using System.Globalization; using System.IO; using Chronos.App.Archiving; using Chronos.App.Infrastructure; using Chronos.App.Settings; using Chronos.App.Workspace; using Chronos.Core.Archiving; using Chronos.Core.Localization; using Chronos.Data.Projects; using Chronos.Data.Sync; using Chronos.Data.Workspaces; using Chronos.Testing; using Chronos.Ui.Controls; namespace Chronos.App.Tests.Workspace; /// /// The ways on that review 2's phase 5a fix round 2 gave the workspace (owner review 2, R8): another workspace folder when /// the one in use is refused, a copy whose working state cannot be read listed as damaged and removed only after a plan, /// the half media of a cancelled first copy, the copy's size and the drive's free space before it starts, a conflict of /// format that offers only Save both, a read-only library named as such, and pruning that keeps a version the library /// cannot give back. /// [Category("workspace")] public sealed class WorkspaceFallbackTests(TestContext context) { static WorkspaceFallbackTests() => Loc.SetCulture(CultureInfo.GetCultureInfo("en")); [Test] public async Task AnotherWorkspaceFolderIsUsedAfterItsPlanAndNothingIsMoved() { await using var bed = await WorkspaceTestBed.CreateAsync(context, frames: 4); var settings = new AppSettings(); var saves = 0; var host = new WorkspaceHost(bed.Environment, settings, () => saves++, () => bed.Db, () => bed.Archives, () => bed.Engine) { LockWait = TimeSpan.FromSeconds(TestTiming.Budget(10)), }; var mainId = await bed.CheckoutAsync(host); var first = host.Root; var before = saves; var row = await bed.RowAsync(); var library = (await bed.Db.Archives.GetAsync(row.ArchiveId))!.RootPath; // A folder inside a library is refused, and nothing changes. var inside = Path.Combine(library, "workspace"); Assert.True((await host.PlanFolderAsync(inside)).InsideLibrary); var refused = await Assert.ThrowsAsync(() => host.UseFolderAsync(inside)); Assert.True(refused.FolderRefused); Assert.Equal(Loc.L("Errors.Workspace.InsideLibraryFolder", Path.GetFullPath(inside)), refused.Message); Assert.Equal(((string?)null, before, first), (settings.WorkspaceFolder, saves, host.Root)); Assert.False(Directory.Exists(inside), "nothing was written there"); // The plan counts what stays and what is found; using the folder names it in the settings and lists its projects. var other = Path.Combine(bed.Directory, "other workspace"); var plan = await host.PlanFolderAsync(other); Assert.Equal(new WorkspaceFolderPlan(first, Path.GetFullPath(other), 1, 0, false), plan); Assert.False(plan.IsSame); Assert.True((await host.PlanFolderAsync(first + Path.DirectorySeparatorChar)).IsSame); await host.UseFolderAsync(other); Assert.Equal((Path.GetFullPath(other), before + 1), (settings.WorkspaceFolder, saves)); Assert.Equal(Path.GetFullPath(other), host.Root); Assert.Empty(await host.ListAsync()); Assert.FileExists(Path.Combine(first, mainId.ToString("N"), WorkspaceProject.BundleFile)); // Chosen back, the default is named by no setting and its project is listed again. Assert.Equal(new WorkspaceFolderPlan(Path.GetFullPath(other), first, 0, 1, false), await host.PlanFolderAsync(first)); await host.UseFolderAsync(first); Assert.Equal(((string?)null, before + 2), (settings.WorkspaceFolder, saves)); Assert.Equal(mainId, (await host.ListAsync()).Single().ProjectId); } [Test] public async Task ChoosingAFolderAsksItsPlanAndClosesTheProjectFirst() { await using var bed = await WorkspaceTestBed.CreateAsync(context, frames: 4); var settings = new AppSettings(); var host = bed.Host(settings); await bed.CheckoutAsync(host); var first = host.Root; var library = (await bed.Db.Archives.GetAsync((await bed.RowAsync()).ArchiveId))!.RootPath; var failures = new List(); var closes = 0; var close = true; Task CloseProject() { closes++; return Task.FromResult(close); } // Nothing picked, or the folder in use: nothing asked. var dialogs = new ScriptedDialogs { Folder = null }; Assert.False(await WorkspaceFolderChange.ChooseAsync(host, dialogs, CloseProject, failures.Add)); dialogs.Folder = first; Assert.False(await WorkspaceFolderChange.ChooseAsync(host, dialogs, CloseProject, failures.Add)); Assert.Empty(dialogs.Asked); // Inside a library: refused with why, without asking. dialogs.Folder = Path.Combine(library, "inside"); Assert.False(await WorkspaceFolderChange.ChooseAsync(host, dialogs, CloseProject, failures.Add)); Assert.SequenceEqual([Loc.L("Errors.Workspace.InsideLibraryFolder", Path.GetFullPath(dialogs.Folder!))], failures); Assert.Empty(dialogs.Asked); // Declined, or the open project kept open: the folder stays. var other = Path.Combine(bed.Directory, "elsewhere"); dialogs.Folder = other; dialogs.Answer = false; Assert.False(await WorkspaceFolderChange.ChooseAsync(host, dialogs, CloseProject, failures.Add)); Assert.Count(1, dialogs.Asked); var asked = dialogs.Asked[0]; Assert.Equal(Loc.L("Settings.Workspace.ChangeMessage", Path.GetFullPath(other), first), asked.Message); Assert.Contains(Loc.L("Settings.Workspace.ProjectsLeft", Formatting.Count(1)), asked.Detail); Assert.Contains(Loc.L("Settings.Workspace.ProjectsFound", Formatting.Count(0)), 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.ChooseAsync(host, dialogs, CloseProject, failures.Add)); Assert.Equal((1, first), (closes, host.Root)); close = true; Assert.True(await WorkspaceFolderChange.ChooseAsync(host, dialogs, CloseProject, failures.Add)); Assert.Equal((Path.GetFullPath(other), 2), (host.Root, closes)); Assert.Count(1, failures); } [Test] public void SettingsWorkspaceChangesTheFolderOnlyWhereItCan() { var settings = new AppSettings(); var changes = 0; var rows = new WorkspaceSettingsRows(settings, () => { }, () => @"D:\Workspace", () => { }, () => { changes++; return Task.CompletedTask; }); Assert.True(rows.CanChange && rows.ChangeCommand.CanExecute(null)); rows.ChangeCommand.Execute(null); Assert.Equal(1, changes); var capture = new WorkspaceSettingsRows(settings, () => { }, () => @"D:\Workspace", () => { }); Assert.False(capture.CanChange || capture.ChangeCommand.CanExecute(null)); } [Test] public async Task ACopyWhoseWorkingStateCannotBeReadIsListedAsDamagedAndGoesOnlyByDiscard() { await using var bed = await WorkspaceTestBed.CreateAsync(context, frames: 4); var host = bed.Host(new AppSettings { WorkspaceAutoSync = false }); var mainId = await bed.CheckoutAsync(host); var (_, session) = await bed.OpenAsync(host, mainId); await using (session) { session.Edit(p => p with { HeroFrame = 2 }); Assert.True(await session.FlushAsync()); } var unsent = (await host.SaveVersionAsync(mainId, "Not sent")).Version!; var project = host.Store.Find(mainId)!; await File.WriteAllTextAsync(project.BundlePath, "{ this is not a project", bed.Ct); var all = await host.ListAsync(); Assert.Count(1, all); var listed = all[0]; Assert.True(listed is { Damaged: true, HasMedia: false }); Assert.Equal(mainId, listed.ProjectId); Assert.True((await host.FindAsync(mainId))!.Damaged); Assert.Empty(await host.ProjectsOfAsync(bed.SequenceId), "a copy that cannot say its sequence is not one of it"); var item = new WorkspaceProjectItem(listed, null); Assert.Equal((Loc.L("Editor.Workspace.State.Damaged"), StatusKind.Error, Loc.L("Tooltips.Editor.Workspace.State.Damaged")), (item.StateText, item.StateKind, item.StateToolTip)); var plan = await host.PlanRemovalAsync(mainId); Assert.True(plan is { Damaged: true, IsSafe: false, Unsent: 1 }); Assert.Greater(plan.Files, 0); var dialog = new RemoveCopyDialogViewModel(plan, _ => Task.CompletedTask, () => Task.CompletedTask, () => false, _ => { }); Assert.False(dialog.RemoveCommand.CanExecute(null) || dialog.SendFirstCommand.CanExecute(null)); Assert.True(dialog.DiscardCommand.CanExecute(null)); Assert.Equal((Loc.L("Errors.Workspace.Damaged"), Loc.L("Errors.Workspace.Damaged")), (dialog.RemoveToolTip, dialog.SendFirstToolTip)); var refused = await Assert.ThrowsAsync(() => host.RemoveLocalCopyAsync(mainId, discard: false)); Assert.Equal(Loc.L("Errors.Workspace.Damaged"), refused.Message); Assert.NotNull(host.Store.Find(mainId), "nothing was removed"); await host.RemoveLocalCopyAsync(mainId, discard: true); Assert.Null(host.Store.Find(mainId)); var aside = Assert.Contains(Directory.EnumerateDirectories(Path.Combine(host.Root, WorkspaceHost.TrashFolder)), d => Path.GetFileName(d).StartsWith(mainId.ToString("N"), StringComparison.Ordinal)); Assert.Equal("{ this is not a project", await File.ReadAllTextAsync(Path.Combine(aside, WorkspaceProject.BundleFile), bed.Ct), "kept as it was"); Assert.True(Directory.EnumerateFiles(Path.Combine(aside, WorkspaceProject.VersionsFolder)).Any(f => f.Contains(unsent.Id.ToString(), StringComparison.OrdinalIgnoreCase) || f.Contains(unsent.Id.ToString("N"), StringComparison.OrdinalIgnoreCase)), "the version never sent is kept"); } [Test] public async Task ACancelledFirstCopyLeavesNoHalfMedia() { await using var bed = await WorkspaceTestBed.CreateAsync(context, frames: 4); var host = bed.Host(); var mainId = await bed.CheckoutAsync(host); var project = host.Store.Find(mainId)!; Assert.False(await host.RemovePartialMediaAsync(mainId), "a copy that ended keeps its media"); Assert.FileExists(project.MediaIndexPath); // A first copy stopped before its index was written: what it wrote goes, the working state stays. File.Delete(project.MediaIndexPath); Assert.NotEmpty(Directory.EnumerateFiles(project.MediaDirectory, "*", SearchOption.AllDirectories)); Assert.True(await host.RemovePartialMediaAsync(mainId)); Assert.False(Directory.Exists(project.MediaDirectory)); Assert.FileExists(project.BundlePath); Assert.False(await host.RemovePartialMediaAsync(mainId), "nothing left to remove"); Assert.False(await host.RemovePartialMediaAsync(Guid.NewGuid())); } [Test] public async Task OpenInWorkspaceShowsTheCopysSizeAndTheFreeSpace() { await using var bed = await WorkspaceTestBed.CreateAsync(context, frames: 4); var host = bed.Host(); var facts = await host.CopyFactsAsync(bed.SequenceId); Assert.Greater(facts.Bytes, 0); Assert.NotNull(facts.Free); Assert.False(facts.TooLittleSpace, "the test drive has room for four small proxies"); var dialog = new OpenInWorkspaceDialogViewModel("Synthetic", await host.HomeProjectsAsync(bed.SequenceId), _ => { }, copy: facts); Assert.SequenceEqual([Loc.L("Editor.OpenWorkspace.Size"), Loc.L("Editor.OpenWorkspace.Free")], dialog.CopyFacts.Select(f => f.Label)); Assert.Equal(Formatting.Bytes(facts.Bytes), dialog.CopyFacts[0].Value); Assert.False(dialog.IsShortOfSpace); var short_ = new OpenInWorkspaceDialogViewModel("Synthetic", [], _ => { }, copy: new WorkspaceCopyFacts(1_000_000, 1_000_000)); Assert.True(short_.IsShortOfSpace); Assert.Equal(Loc.L("Errors.Workspace.NoRoom"), short_.CopyFacts[1].Reason); var unknown = new OpenInWorkspaceDialogViewModel("Synthetic", [], _ => { }, copy: new WorkspaceCopyFacts(1_000_000, null)); Assert.Equal((false, Loc.L("Server.Sync.None")), (unknown.IsShortOfSpace, unknown.CopyFacts[1].Value)); Assert.Empty(new OpenInWorkspaceDialogViewModel("Synthetic", [], _ => { }).CopyFacts); Assert.False(new WorkspaceCopyFacts(1_000, 1_000 + WorkspaceJobs.CopySpaceReserve).TooLittleSpace); Assert.True(new WorkspaceCopyFacts(1_000, 999 + WorkspaceJobs.CopySpaceReserve).TooLittleSpace); } [Test] public void AConflictOfFormatOffersOnlySaveBothAndSaysWhy() { var newer = new ConflictDialogViewModel("Main", "Main (STUDIO-PC)", ["Version 1 here, 2 in the library"], _ => Task.CompletedTask, _ => { }, newerFormat: true); Assert.False(newer.CanMerge || newer.KeepMineCommand.CanExecute(null) || newer.TakeHomeCommand.CanExecute(null)); Assert.True(newer.SaveBothCommand.CanExecute(null)); Assert.SequenceEqual([Loc.L("Editor.Workspace.Conflict.NewerFormat")], newer.Differences); Assert.Equal(Loc.L("Editor.Workspace.Conflict.NewerMessage", "Main"), newer.Message); Assert.Equal(Loc.L("Tooltips.Editor.Workspace.NewerFormat"), newer.DifferencesToolTip); Assert.Equal(Loc.L("Tooltips.Editor.Workspace.SaveBothNewer", "Main (STUDIO-PC)"), newer.SaveBothToolTip); var merge = new ConflictDialogViewModel("Main", "Main (STUDIO-PC)", ["Hero frame 2 here, 3 in the library"], _ => Task.CompletedTask, _ => { }); Assert.True(merge.CanMerge && merge.KeepMineCommand.CanExecute(null) && merge.TakeHomeCommand.CanExecute(null)); Assert.Equal(Loc.L("Tooltips.Editor.Workspace.SaveBoth", "Main (STUDIO-PC)"), merge.SaveBothToolTip); // The format's numbers never reach the lines: one line names the cause. var lines = WorkspaceText.ConflictLines([new SettingsDifference(ProjectMerge.FormatPath, "1", "2"), new SettingsDifference("hero", "2", "3")], 10); Assert.SequenceEqual([Loc.L("Editor.Workspace.Conflict.NewerFormat")], lines); } [Test] public void AReadOnlyLibraryIsNamedAsSuchNotAsOffline() { var readOnly = new ArchiveOfflineException(@"E:\Library", ArchiveAvailability.ReadOnly); Assert.Equal(Loc.L("Errors.Workspace.ReadOnlyHome"), WorkspaceText.Failure(new HomeUnavailableException(readOnly.Message, readOnly))); Assert.Equal(Loc.L("Errors.Workspace.ReadOnlyHome"), WorkspaceText.Failure(readOnly)); var offline = new ArchiveOfflineException(@"E:\Library", ArchiveAvailability.Offline); Assert.Equal(Loc.L("Errors.Workspace.Offline"), WorkspaceText.Failure(new HomeUnavailableException(offline.Message, offline))); Assert.Equal(Loc.L("Errors.Workspace.Offline"), WorkspaceText.Failure(new HomeUnavailableException("The project's home cannot be reached from this PC."))); } [Test] public async Task PruningKeepsAVersionTheLibraryCannotGiveBack() { await using var bed = await WorkspaceTestBed.CreateAsync(context, frames: 4); var settings = new AppSettings { WorkspaceKeptVersions = 100 }; var host = bed.Host(settings); var mainId = await bed.CheckoutAsync(host); var (_, session) = await bed.OpenAsync(host, mainId); await using (session) { for (var i = 1; i <= 5; i++) { session.Edit(p => p with { Exposure = p.Exposure with { ExposureOffsetEv = i / 10.0 } }); Assert.True(await session.FlushAsync()); await host.SaveVersionAsync(mainId, $"Step {i}"); } } var project = host.Store.Find(mainId)!; Assert.SequenceEqual([1, 2, 3, 4, 5, 6], project.Versions().Where(v => v.StoredAt is not null).Select(v => v.Number).Order()); // The library's file of version 2 is damaged: the workspace's copy is the only good one left, so it stays. var second = project.Versions().Single(v => v.Number == 2); var row = await bed.RowAsync(); var library = (await bed.Db.Archives.GetAsync(row.ArchiveId))!.RootPath; var damaged = new ArchivePaths(library).Sequence(row.Folder).VersionPath(mainId, 2, second.Id); Assert.FileExists(damaged); await File.WriteAllTextAsync(damaged, "{ damaged", bed.Ct); settings.WorkspaceKeptVersions = 2; Assert.Equal(3, await host.PruneAsync(mainId, host.HomeOfSequence(bed.SequenceId))); Assert.SequenceEqual([2, 5, 6], project.Versions().Where(v => v.StoredAt is not null).Select(v => v.Number).Order()); } /// Dialogs that pick and answer every confirmation with , recording what they were asked. private sealed class ScriptedDialogs : 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; } }