using System.Globalization;
using System.IO;
using Chronos.App.Infrastructure;
using Chronos.App.Settings;
using Chronos.App.Workspace;
using Chronos.Core.Localization;
using Chronos.Core.Model;
using Chronos.Core.Project;
using Chronos.Core.Windows.Shell;
using Chronos.Data.Workspaces;
using Chronos.Testing;
using Chronos.Ui.Controls;
namespace Chronos.App.Tests.Workspace;
///
/// The desktop's workspace (owner review 2, R8): where it lives, what it remembers, its projects' states as the picker
/// shows them, new, renamed and deleted projects, the removal of a local copy that never loses unsent work, the pruning
/// of old versions, and Settings › Workspace.
///
[Category("workspace")]
public sealed class WorkspaceHostTests(TestContext context)
{
static WorkspaceHostTests() => Loc.SetCulture(CultureInfo.GetCultureInfo("en"));
[Test]
public void TheWorkspaceLivesBesideTheIndexUnlessSettingsSayOtherwise()
{
var local = context.CreateTempDirectory("local");
var installed = AppEnvironment.From(AppPaths.Resolve(context.CreateTempDirectory("app"), local, []));
Assert.Equal(Path.Combine(local, "Chronos", "workspace"), WorkspaceHost.DefaultRoot(installed));
var stick = context.CreateTempDirectory("stick");
File.WriteAllText(Path.Combine(stick, PortableMode.MarkerFileName), "");
var portable = AppEnvironment.From(AppPaths.Resolve(stick, local, []));
Assert.Equal(Path.Combine(stick, "data", "workspace"), WorkspaceHost.DefaultRoot(portable));
var settings = new AppSettings();
var host = new WorkspaceHost(installed, settings, () => { }, () => null, () => null, () => null);
Assert.Equal(WorkspaceHost.DefaultRoot(installed), host.Root);
Assert.True(host.IsEnabled);
Assert.False(host.IsAvailable, "no index yet");
var elsewhere = Path.Combine(context.CreateTempDirectory("fast-disk"), "Chronos workspace");
settings.WorkspaceFolder = elsewhere;
Assert.Equal(elsewhere, host.Root);
Assert.Equal(elsewhere, host.Homes.Root, "the homes follow the folder");
Assert.FileExists(Path.Combine(elsewhere, WorkspaceStore.ManifestFile));
// A capture (sample data without an engine) edits its library as before.
var capture = AppEnvironment.ForCapture();
try
{
Assert.False(new WorkspaceHost(capture, new AppSettings(), () => { }, () => null, () => null, () => null).IsEnabled);
}
finally
{
capture.DeleteCaptureData();
}
}
[Test]
public void AProjectOpenInTheEditorIsHeldUntilItsSourceCloses()
{
var installed = AppEnvironment.From(AppPaths.Resolve(context.CreateTempDirectory("app"), context.CreateTempDirectory("local"), []));
var host = new WorkspaceHost(installed, new AppSettings(), () => { }, () => null, () => null, () => null);
var project = Guid.CreateVersion7();
Assert.False(host.HasProjectsInEditor);
// The same project in two editors, then each closing (one twice): held until the last one closes.
var first = host.HoldInEditor(project);
var second = host.HoldInEditor(project);
Assert.True(host.HasProjectsInEditor, "a server's home does not move under an open editor");
first.Dispose();
first.Dispose();
Assert.True(host.HasProjectsInEditor, "the second editor still has it");
second.Dispose();
Assert.False(host.HasProjectsInEditor);
}
[Test]
public void TheWorkspaceSettingsSurviveTheSettingsFile()
{
var sequence = Guid.CreateVersion7();
var project = Guid.CreateVersion7();
var settings = new AppSettings { WorkspaceFolder = @"D:\Fast\Workspace", WorkspaceAutoSync = false, WorkspaceKeptVersions = 50 };
settings.WorkspaceRecent[sequence] = project;
var copy = AppSettings.Parse(settings.ToJson())!;
Assert.Equal((@"D:\Fast\Workspace", false, 50), (copy.WorkspaceFolder, copy.WorkspaceAutoSync, copy.WorkspaceKeptVersions));
Assert.Equal(project, copy.WorkspaceRecent[sequence]);
// A settings file written before the workspace existed gets its defaults: sync on, 20 versions.
var older = AppSettings.Parse("""{ "Theme": "Light" }""")!;
Assert.Equal((null, true, 20), (older.WorkspaceFolder, older.WorkspaceAutoSync, older.WorkspaceKeptVersions));
Assert.Empty(older.WorkspaceRecent);
}
[Test]
public void ThePhase5cWorkspaceSettingsHaveTheirDefaultsAndSurviveTheSettingsFile()
{
var fresh = new AppSettings();
Assert.Equal((100, BundleMedia.Proxies, true, 30, WorkspaceOpenPolicy.LastUsed),
(fresh.WorkspaceSizeLimitGb, fresh.WorkspaceDefaultMedia, fresh.WorkspaceVersionOnRender, fresh.WorkspaceCleanAfterDays, fresh.WorkspaceOpenProject));
Assert.Empty(fresh.WorkspaceOpened);
// A settings file of phase 5b gets them too.
var older = AppSettings.Parse("""{ "Theme": "Light", "WorkspaceKeptVersions": 50 }""")!;
Assert.Equal((100, BundleMedia.Proxies, true, 30, WorkspaceOpenPolicy.LastUsed, 50),
(older.WorkspaceSizeLimitGb, older.WorkspaceDefaultMedia, older.WorkspaceVersionOnRender, older.WorkspaceCleanAfterDays, older.WorkspaceOpenProject,
older.WorkspaceKeptVersions));
Assert.Empty(older.WorkspaceOpened);
var project = Guid.CreateVersion7();
var at = new DateTimeOffset(2026, 11, 4, 9, 30, 0, TimeSpan.FromHours(1));
var settings = new AppSettings
{
WorkspaceSizeLimitGb = 0,
WorkspaceDefaultMedia = BundleMedia.Originals,
WorkspaceVersionOnRender = false,
WorkspaceCleanAfterDays = 0,
WorkspaceOpenProject = WorkspaceOpenPolicy.Ask,
};
settings.WorkspaceOpened[project] = at;
var copy = AppSettings.Parse(settings.ToJson())!;
Assert.Equal((0, BundleMedia.Originals, false, 0, WorkspaceOpenPolicy.Ask),
(copy.WorkspaceSizeLimitGb, copy.WorkspaceDefaultMedia, copy.WorkspaceVersionOnRender, copy.WorkspaceCleanAfterDays, copy.WorkspaceOpenProject));
Assert.Equal(at, copy.WorkspaceOpened[project]);
Assert.Contains("\"Ask\"", settings.ToJson());
}
[Test]
public void WhenEachProjectWasOpenedStaysOnThisPc()
{
var project = Guid.CreateVersion7();
var sequence = Guid.CreateVersion7();
var at = new DateTimeOffset(2026, 11, 4, 9, 30, 0, TimeSpan.Zero);
var mine = new AppSettings { WorkspaceFolder = @"D:\Fast\Workspace", WorkspaceSizeLimitGb = 250, WorkspaceOpenProject = WorkspaceOpenPolicy.Main };
mine.WorkspaceRecent[sequence] = project;
mine.WorkspaceOpened[project] = at;
// Reset puts the preferences back and keeps what this PC knows of its projects.
var reset = mine.ResetKeepingState();
Assert.Equal((AppSettings.DefaultWorkspaceSizeLimitGb, WorkspaceOpenPolicy.LastUsed), (reset.WorkspaceSizeLimitGb, reset.WorkspaceOpenProject));
Assert.Equal((@"D:\Fast\Workspace", project, at), (reset.WorkspaceFolder, reset.WorkspaceRecent[sequence], reset.WorkspaceOpened[project]));
// Export carries the preferences, not this PC's projects.
var exported = AppSettings.Parse(mine.ForExport().ToJson())!;
Assert.Equal((250, WorkspaceOpenPolicy.Main, (string?)null), (exported.WorkspaceSizeLimitGb, exported.WorkspaceOpenProject, exported.WorkspaceFolder));
Assert.Empty(exported.WorkspaceOpened);
Assert.Empty(exported.WorkspaceRecent);
Assert.Equal(at, mine.WorkspaceOpened[project]);
// Import takes another PC's preferences and keeps this PC's projects.
var theirs = new AppSettings { WorkspaceSizeLimitGb = 40, WorkspaceFolder = @"E:\Elsewhere", LastArchivePath = @"D:\Photos" };
theirs.WorkspaceOpened[Guid.CreateVersion7()] = at.AddDays(-3);
mine.LastArchivePath = @"F:\Chronos";
var imported = mine.KeepLocalIn(AppSettings.Parse(theirs.ToJson())!);
Assert.Equal((40, @"D:\Fast\Workspace"), (imported.WorkspaceSizeLimitGb, imported.WorkspaceFolder));
// Another PC's archive folder can name one of this PC's own folders: this PC's stays.
Assert.Equal(@"F:\Chronos", imported.LastArchivePath);
Assert.Equal(at, imported.WorkspaceOpened.Values.Single());
Assert.Count(1, imported.WorkspaceOpened);
}
[Test]
public void TheKnownServersStayOnThisPc()
{
var id = Guid.CreateVersion7();
var originals = Guid.CreateVersion7();
var mine = new AppSettings
{
KnownServers = [new KnownServer { Id = id, Name = "Studio NAS", LastAddress = "https://nas.local:8443", Aliases = ["https://nas.local:8443"], OriginalsArchiveId = originals }],
};
var copy = AppSettings.Parse(mine.ToJson())!;
Assert.Equal(("Studio NAS", originals, "https://nas.local:8443"), (copy.KnownServers.Single().Name, copy.KnownServers.Single().OriginalsArchiveId, copy.KnownServers.Single().Aliases.Single()));
Assert.Equal(id, copy.FindKnownServer(id)?.Id);
Assert.True(copy.KnownIdentity().Same("https://nas.local:8443", Chronos.Core.IO.HomeFolders.IdKey(id)), "an alias names the server by its id");
// Reset and Import keep what this PC knows of its servers; Export leaves it out.
Assert.Equal(id, mine.ResetKeepingState().KnownServers.Single().Id);
Assert.Empty(AppSettings.Parse(mine.ForExport().ToJson())!.KnownServers);
Assert.Equal(id, mine.KeepLocalIn(AppSettings.Parse(new AppSettings().ToJson())!).KnownServers.Single().Id);
}
[Test]
public async Task TheTrashOfEveryHomeIsPlannedAndEmptiedTogether()
{
await using var bed = await WorkspaceTestBed.CreateAsync(context, frames: 2);
var host = bed.Host(name: "homes");
var homes = host.Homes;
Assert.True(homes.IsSplit, "a new workspace is split into homes");
var server = homes.StoreFor(new BundleHome(BundleHome.ServerKind, Guid.CreateVersion7(), null, "https://nas.test:8443")).Root;
foreach (var (root, name) in new[] { (homes.Local.Root, "a"), (server, "b") })
{
var entry = Directory.CreateDirectory(Path.Combine(WorkspaceTrash.FolderOf(root), $"{Guid.CreateVersion7():N}-{name}"));
File.WriteAllBytes(Path.Combine(entry.FullName, "file.bin"), new byte[100]);
}
// Settings › Workspace › Home folders: this PC first, then the server by what its folder records.
var rows = HomeFolderRow.Of(homes, [], _ => { });
Assert.SequenceEqual([Loc.L("Settings.Workspace.ThisPc"), "https://nas.test:8443"], rows.Select(r => r.Name).ToArray());
Assert.Equal(server, rows[1].Path);
var usage = await host.UsageAsync(bed.Ct);
Assert.Equal((2, 200L), (usage.TrashItems, usage.TrashBytes));
var plan = await host.PlanTrashAsync(bed.Ct);
Assert.Equal((2, 200L, 2), (plan.Items.Count, plan.Bytes, plan.Listings.Count));
// One home's trash changed since the plan: nothing is erased, in either.
File.WriteAllBytes(Path.Combine(WorkspaceTrash.FolderOf(server), "late.bin"), new byte[5]);
await Assert.ThrowsAsync(() => host.EmptyTrashAsync(plan, bed.Ct));
Assert.Equal(3, (await host.UsageAsync(bed.Ct)).TrashItems, "nothing was erased");
var again = await host.PlanTrashAsync(bed.Ct);
Assert.Equal(new WorkspaceTrashResult(3, 205), await host.EmptyTrashAsync(again, bed.Ct));
Assert.Equal(0, (await host.UsageAsync(bed.Ct)).TrashItems);
}
[Test]
public void OpeningAProjectRecordsWhenAndSavesIt()
{
var local = context.CreateTempDirectory("local");
var installed = AppEnvironment.From(AppPaths.Resolve(context.CreateTempDirectory("app"), local, []));
var settings = new AppSettings();
var saves = 0;
var host = new WorkspaceHost(installed, settings, () => saves++, () => null, () => null, () => null);
var project = Guid.CreateVersion7();
var at = new DateTimeOffset(2026, 11, 4, 10, 0, 0, TimeSpan.Zero);
host.RecordOpened(project, at);
Assert.Equal((at, 1), (settings.WorkspaceOpened[project], saves));
host.RecordOpened(project);
Assert.True(settings.WorkspaceOpened[project] > at, "opened again later");
Assert.Equal(2, saves);
Assert.False(host.IsMoving);
}
[Test]
public void AProjectWithRendersNotSentIsNotSafeToRemoveAndOriginalsNeedTheirRoom()
{
var plan = new WorkspaceRemovalPlan(Guid.CreateVersion7(), "Main", 12, 1_000, 0, false, false, false);
Assert.True(plan.IsSafe);
Assert.False((plan with { UnsentRenders = 1 }).IsSafe);
Assert.True((plan with { LastOriginals = 3 }).IsSafe, "the last originals go to the trash, never deleted");
var facts = new WorkspaceCopyFacts(1_000, 1_000 + WorkspaceJobs.CopySpaceReserve + 500, 2_000);
Assert.False(facts.TooLittleSpaceFor(BundleMedia.Proxies));
Assert.True(facts.TooLittleSpaceFor(BundleMedia.Originals));
Assert.False((facts with { Free = null }).TooLittleSpaceFor(BundleMedia.Originals), "a drive whose room is unknown is tried");
}
[Test]
public void SettingsWorkspaceRowsStoreEachChoiceAtOnce()
{
var settings = new AppSettings();
var saves = 0;
var opened = 0;
var rows = new WorkspaceSettingsRows(settings, () => saves++, () => @"C:\Users\me\AppData\Local\Chronos\workspace", () => opened++);
Assert.Equal(@"C:\Users\me\AppData\Local\Chronos\workspace", rows.Folder);
rows.OpenCommand.Execute(null);
Assert.Equal(1, opened);
Assert.True(rows.AutoSync);
rows.AutoSync = false;
Assert.Equal((false, 1), (settings.WorkspaceAutoSync, saves));
rows.AutoSync = false;
Assert.Equal(1, saves, "nothing to store");
Assert.SequenceEqual(WorkspaceSettingsRows.KeptPresets, rows.KeptChoices.Select(c => c.Value));
Assert.Equal(20, rows.SelectedKept.Value);
Assert.Equal(Loc.Plural("Settings.Workspace.Versions", 50), rows.KeptChoices.Single(c => c.Value == 50).Label);
rows.SelectedKept = rows.KeptChoices.Single(c => c.Value == 50);
Assert.Equal((50, 2), (settings.WorkspaceKeptVersions, saves));
// A value set by hand is listed with the presets; one below 1 is shown as the 1 the workspace applies.
settings.WorkspaceKeptVersions = 0;
Assert.Equal(1, rows.SelectedKept.Value);
Assert.Contains(1, rows.KeptChoices.Select(c => c.Value));
rows.Reset();
Assert.Equal((true, 20), (settings.WorkspaceAutoSync, settings.WorkspaceKeptVersions));
// The page comes right after Storage.
var pages = Enum.GetValues().ToList();
Assert.Equal(pages.IndexOf(SettingsPage.Storage) + 1, pages.IndexOf(SettingsPage.Workspace));
Assert.Equal(Loc.L("Settings.Page.Workspace"), new SettingsPageItem(SettingsPage.Workspace, ["Settings.Workspace.Kept"]).Label);
}
[Test]
public void ProjectNamesAndTheirStatesReadAsThePickerShowsThem()
{
Assert.Equal(Loc.L("Editor.Project.Main"), WorkspaceText.ProjectName("Main", isMain: true));
Assert.Equal("Main", WorkspaceText.ProjectName("Main", isMain: false), "only the sequence's Main is translated");
Assert.Null(ProjectNames.Validate("Vertical social", ["Main"]));
Assert.Equal(Loc.L("Errors.Workspace.NameTaken"), ProjectNames.Validate(" main ", ["Main"]));
Assert.Equal(Loc.L("Errors.Workspace.InvalidName"), ProjectNames.Validate(" ", []));
Assert.Equal(Loc.L("Errors.Workspace.InvalidName"), ProjectNames.Validate(new string('x', 61), []));
var sibling = WorkspaceHost.SiblingName(new string('y', 60));
Assert.True(sibling.Length <= 60 && sibling.EndsWith(")", StringComparison.Ordinal), sibling);
var status = new WorkspaceStatus(WorkspaceState.Ahead, false, 2, 0, false, false, false, null, null, null);
Assert.Equal((Loc.L("Editor.Workspace.State.Ahead"), StatusKind.Queued), (WorkspaceText.State(status), WorkspaceText.Kind(status)));
Assert.Equal(Loc.L("Tooltips.Editor.Workspace.State.Ahead", "2"), WorkspaceText.StateToolTip(status));
Assert.Equal((Loc.L("Editor.Workspace.State.Syncing"), StatusKind.Running), (WorkspaceText.State(status, syncing: true), WorkspaceText.Kind(status, syncing: true)));
var offline = status with { State = WorkspaceState.Offline, Offline = true };
Assert.Equal((StatusKind.Offline, Loc.L("Tooltips.Editor.Workspace.State.OfflineAhead", "2")), (WorkspaceText.Kind(offline), WorkspaceText.StateToolTip(offline)));
foreach (var state in Enum.GetValues())
{
var each = status with { State = state };
Assert.NotEqual("Editor.Workspace.State." + state, WorkspaceText.State(each), "every state has its text");
}
var entry = new WorkspaceEntry(Guid.CreateVersion7(), Guid.CreateVersion7(), "Main", true, new BundleHome(BundleHome.ArchiveKind, Guid.CreateVersion7()),
"Harbour sunset", HasMedia: true, DateTimeOffset.UtcNow);
var item = new WorkspaceProjectItem(entry, null);
Assert.Equal(Loc.L("Editor.Workspace.State.Reading"), item.StateText);
item.Status = status with { State = WorkspaceState.InSync };
Assert.Equal((Loc.L("Editor.Workspace.State.InSync"), StatusKind.Synced), (item.StateText, item.StateKind));
Assert.Equal(string.Join(Loc.Separator, Loc.L("Editor.Project.Main"), "Harbour sunset", Loc.L("Editor.Workspace.State.InSync")), item.Description);
Assert.Equal(Loc.L("Editor.Workspace.State.MediaRemoved"), new WorkspaceProjectItem(entry with { HasMedia = false }, null).StateText);
}
[Test]
public async Task TheWorkspaceRemembersTheProjectOpenedLast()
{
await using var bed = await WorkspaceTestBed.CreateAsync(context, frames: 4);
var saved = 0;
var settings = new AppSettings();
var host = new WorkspaceHost(bed.Environment, settings, () => saved++, () => bed.Db, () => bed.Archives, () => bed.Engine);
Assert.Null(await host.LastUsedAsync(bed.SequenceId));
var main = await bed.CheckoutAsync(host);
Assert.Equal(main, settings.WorkspaceRecent[bed.SequenceId]);
var vertical = await bed.CheckoutAsync(host, newName: "Vertical social");
Assert.Equal(vertical, (await host.LastUsedAsync(bed.SequenceId))!.ProjectId, "the project checked out last");
host.Remember(bed.SequenceId, main);
Assert.Equal(main, (await host.LastUsedAsync(bed.SequenceId))!.ProjectId);
Assert.True(saved >= 3);
var listed = await host.ProjectsOfAsync(bed.SequenceId);
Assert.Equal(2, listed.Count);
Assert.True(listed.All(p => p.HasMedia));
Assert.SequenceEqual(["Main", "Vertical social"], listed.OrderBy(p => p.Name, StringComparer.Ordinal).Select(p => p.Name), "names as the library has them");
// The home's projects are those of the library: Main, made from the sequence's settings, and the new one.
var home = await host.HomeProjectsAsync(bed.SequenceId);
Assert.Equal((2, "Main"), (home.Count, home[0].Name));
// A project gone from the workspace is forgotten.
settings.WorkspaceRecent[bed.SequenceId] = Guid.CreateVersion7();
Assert.Contains((await host.LastUsedAsync(bed.SequenceId))!.ProjectId, new[] { main, vertical });
}
[Test]
public async Task NewRenamedAndDeletedProjectsReachTheLibrary()
{
await using var bed = await WorkspaceTestBed.CreateAsync(context, frames: 4);
var host = bed.Host();
var mainId = await bed.CheckoutAsync(host);
var (source, session) = await bed.OpenAsync(host, mainId);
var ui = new RecordingUi();
await using (session)
using (var menu = new ProjectMenuViewModel(host, source, session, ui))
{
await menu.RefreshAsync();
session.Edit(p => p with { Exposure = p.Exposure with { ExposureOffsetEv = 0.3 } });
await menu.SaveVersionAsync(null);
// New project…: the name is checked as it is typed; the project starts from this one's last version in the library.
menu.NewProjectCommand.Execute(null);
await WorkspaceTestBed.UntilAsync(() => ui.Open is ProjectNameDialogViewModel, "the name dialog");
var naming = (ProjectNameDialogViewModel)ui.Open!;
naming.Name.Text = "main";
Assert.False(naming.SaveCommand.CanExecute(null), "Main is taken");
Assert.Equal(Loc.L("Errors.Workspace.NameTaken"), naming.SaveToolTip);
naming.Name.Text = "Vertical social";
naming.SaveCommand.Execute(null);
await WorkspaceTestBed.UntilAsync(() => ui.Opened.Count == 1, "the new project opens");
var (sequenceId, verticalId) = ui.Opened[0];
Assert.Equal(bed.SequenceId, sequenceId);
var head = await host.HomeOfSequence(bed.SequenceId).HeadAsync(verticalId, bed.Ct);
Assert.Equal(0.3, ProjectSettings.FromJson(head.SettingsJson).Exposure.ExposureOffsetEv);
}
// Rename: in the library and in the workspace's working state.
var verticalId2 = (await host.HomeProjectsAsync(bed.SequenceId)).Single(p => !p.IsMain).Id;
await bed.CheckoutAsync(host, verticalId2);
Assert.Equal("Vertical", await host.RenameAsync(verticalId2, " Vertical "));
Assert.Equal("Vertical", host.Find(verticalId2)!.ReadBundle().Workspace!.Name);
Assert.Contains((await host.HomeProjectsAsync(bed.SequenceId)), p => p.Name == "Vertical");
// Delete project…: confirmed, sent first, then gone from the library's list and from the workspace (kept in the library's trash).
var (verticalSource, verticalSession) = await bed.OpenAsync(host, verticalId2);
var deleting = new RecordingUi { ConfirmAnswer = false };
await using (verticalSession)
using (var menu = new ProjectMenuViewModel(host, verticalSource, verticalSession, deleting))
{
verticalSession.Edit(p => p with { HeroFrame = 1 });
Assert.True(menu.DeleteCommand.CanExecute(null));
menu.DeleteCommand.Execute(null);
Assert.Count(1, deleting.Confirmations);
Assert.Equal(0, deleting.Closed, "kept: nothing happens");
deleting.ConfirmAnswer = true;
menu.DeleteCommand.Execute(null);
await WorkspaceTestBed.UntilAsync(() => deleting.Toasts.Any(t => t.Title == Loc.L("Editor.Workspace.Deleted", "Vertical")), "the project is deleted");
Assert.Equal(1, deleting.Closed);
}
Assert.DoesNotContain(verticalId2, (await host.HomeProjectsAsync(bed.SequenceId)).Select(p => p.Id));
Assert.Null(host.Find(verticalId2));
var row = await bed.RowAsync();
var trash = Path.Combine(new Chronos.Core.Archiving.ArchivePaths((await bed.Db.Archives.GetAsync(row.ArchiveId))!.RootPath).Sequence(row.Folder).ProjectsTrashDirectory);
Assert.True(Directory.EnumerateDirectories(trash).Any(d => Path.GetFileName(d).StartsWith(verticalId2.ToString("N"), StringComparison.Ordinal)),
"the deleted project's versions wait in the library's project trash");
}
[Test]
public async Task ALocalCopyGoesOnlyOnceTheLibraryHoldsItsWorkOrTheUserDiscardsIt()
{
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 (source, session) = await bed.OpenAsync(host, mainId);
await using (session)
{
Assert.True(source.Workspace!.IsMain);
session.Edit(p => p with { Exposure = p.Exposure with { ExposureOffsetEv = 0.3 } });
Assert.True(await session.FlushAsync());
}
var plan = await host.PlanRemovalAsync(mainId);
Assert.True(plan is { Modified: true, Unsent: 0, Conflict: false, Offline: false, IsSafe: false });
Assert.True(plan.Files >= 4 + 2, "the proxies, the media index and the working state");
Assert.Greater(plan.Bytes, 0);
var discards = new List();
var asked = 0;
var dialog = new RemoveCopyDialogViewModel(plan, d =>
{
discards.Add(d);
return Task.CompletedTask;
}, () => Task.CompletedTask, () => ++asked > 1, _ => { });
Assert.False(dialog.RemoveCommand.CanExecute(null), "not while work is not in the library");
Assert.Equal(Loc.L("Errors.Workspace.Unsent"), dialog.RemoveToolTip);
Assert.True(dialog.SendFirstCommand.CanExecute(null) && dialog.DiscardCommand.CanExecute(null));
// Discard changes asks for the typed confirmation first: refused, nothing is removed; confirmed, it is.
dialog.DiscardCommand.Execute(null);
await WorkspaceTestBed.UntilAsync(() => asked == 1 && dialog.DiscardCommand.CanExecute(null), "the confirmation is asked");
Assert.Empty(discards, "refused: nothing discarded");
dialog.DiscardCommand.Execute(null);
await WorkspaceTestBed.UntilAsync(() => discards.Count == 1, "confirmed: discarded");
Assert.True(discards[0]);
var request = RemoveCopyDialogViewModel.DiscardRequest("Main");
Assert.True(request is { IsDestructive: true, TypedConfirmation: "Main" } && request.TypedPrompt is { Length: > 0 });
var refused = await Assert.ThrowsAsync(() => host.RemoveLocalCopyAsync(mainId, discard: false));
Assert.Equal(Loc.L("Errors.Workspace.Unsent"), refused.Message);
Assert.NotNull(host.Find(mainId), "nothing was removed");
// Send first: saved and sent, then the library's copy is read back and checked before the local one goes.
await host.SaveVersionAsync(mainId, "Before removal");
await host.SyncAsync(mainId);
Assert.True((await host.PlanRemovalAsync(mainId)).IsSafe);
var folder = host.Find(mainId)!.Folder;
await host.RemoveLocalCopyAsync(mainId, discard: false);
Assert.Null(host.Find(mainId));
Assert.False(Directory.Exists(Path.Combine(folder, WorkspaceProject.MediaFolder)), "the copied photos are gone");
Assert.Equal(0.3, ProjectSettings.FromJson((await bed.RowAsync()).SettingsJson!).Exposure.ExposureOffsetEv, "the work is in the library");
// Discard changes: the unsent versions and the working state are kept aside in the workspace's trash, never erased.
var vertical = await bed.CheckoutAsync(host, newName: "Vertical");
var (_, verticalSession) = await bed.OpenAsync(host, vertical);
await using (verticalSession)
{
verticalSession.Edit(p => p with { HeroFrame = 2 });
Assert.True(await verticalSession.FlushAsync());
}
var unsent = (await host.SaveVersionAsync(vertical, "Not sent")).Version!;
await host.RemoveLocalCopyAsync(vertical, discard: true);
Assert.Null(host.Find(vertical));
var aside = Assert.Contains(Directory.EnumerateDirectories(Path.Combine(host.Homes.LocalRoot, WorkspaceHost.TrashFolder)),
d => Path.GetFileName(d).StartsWith(vertical.ToString("N"), StringComparison.Ordinal));
Assert.FileExists(Path.Combine(aside, WorkspaceProject.BundleFile));
Assert.True(Directory.EnumerateFiles(Path.Combine(aside, WorkspaceProject.VersionsFolder)).Any(f => f.Contains(unsent.Id.ToString("N"), StringComparison.OrdinalIgnoreCase)
|| f.Contains(unsent.Id.ToString(), StringComparison.OrdinalIgnoreCase)), "the version never sent is kept");
Assert.False(Directory.Exists(Path.Combine(aside, WorkspaceProject.MediaFolder)), "the photos, copies the library can make again, are not");
Assert.Empty(host.Homes.List());
}
[Test]
public async Task AConflictASettlingReplayTookPastItsCommitPointIsNoWorkLeftForTheRemoval()
{
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 project = host.Find(mainId)!;
var basis = project.ReadBundle().Workspace!.Base!;
var conflict = $$"""
"conflict": { "theirsVersionId": "{{basis.VersionId}}", "theirsNumber": {{basis.Number}}, "baseVersionId": "{{Guid.CreateVersion7()}}",
"mine": [], "differences": [], "found": "2026-11-01T10:00:00+00:00" }
""";
// A take of the library's values cut after its base moved (before sync.json said so): the choice is applied.
await File.WriteAllTextAsync(project.SyncPath,
$$"""{ {{conflict}}, "replay": { "ontoBase": "{{basis.VersionId}}", "replaced": [], "replayed": [], "adopted": [], "settles": true } }""");
Assert.NotNull(project.ReadSync().Conflict, "still in sync.json");
Assert.Null(project.OpenConflict());
Assert.Null((await host.StatusAsync(mainId)).Conflict);
var plan = await host.PlanRemovalAsync(mainId);
Assert.True(plan is { Conflict: false, IsSafe: true }, "counted as the status reads it");
// A conflict still waiting for a choice counts.
await File.WriteAllTextAsync(project.SyncPath, $$"""{ {{conflict}} }""");
Assert.NotNull(project.OpenConflict());
Assert.True((await host.PlanRemovalAsync(mainId)) is { Conflict: true, IsSafe: false });
}
[Test]
public async Task ACopyOfAProjectDeletedInTheLibraryReadsGoneAndGoesOnlyWhenDiscarded()
{
await using var bed = await WorkspaceTestBed.CreateAsync(context, frames: 4);
var host = bed.Host(new AppSettings { WorkspaceAutoSync = false });
var vertical = await bed.CheckoutAsync(host, newName: "Vertical");
Assert.Equal(WorkspaceState.InSync, (await host.StatusAsync(vertical)).State);
// Another PC deletes it in the library: never in step, and the copy goes only when its user discards it.
await bed.Archives.Projects.DeleteAsync(vertical, bed.Ct);
Assert.Equal(WorkspaceState.Gone, (await host.StatusAsync(vertical)).State);
Assert.True((await host.PlanRemovalAsync(vertical)).Gone);
var refused = await Assert.ThrowsAsync(() => host.RemoveLocalCopyAsync(vertical, discard: false));
Assert.Equal(Loc.L("Errors.Workspace.DeletedAtHome"), refused.Message);
Assert.NotNull(host.Find(vertical), "nothing was removed");
await host.RemoveLocalCopyAsync(vertical, discard: true);
Assert.Null(host.Find(vertical));
}
[Test]
public async Task ARemovalThatCannotMoveAFilePutsTheCopyBackWholeAndSaysSo()
{
await using var bed = await WorkspaceTestBed.CreateAsync(context, frames: 4);
var host = bed.Host(new AppSettings { WorkspaceAutoSync = false });
var vertical = await bed.CheckoutAsync(host, newName: "Vertical");
var project = host.Find(vertical)!;
var bundle = File.ReadAllBytes(project.BundlePath);
var held = Path.Combine(project.Folder, "notes.txt");
File.WriteAllText(held, "mine");
// Another program holds a file of the copy: what was moved aside goes back, the working state with it.
using (new FileStream(held, FileMode.Open, FileAccess.Read, FileShare.None))
await Assert.ThrowsAsync(() => host.RemoveLocalCopyAsync(vertical, discard: true));
Assert.SequenceEqual(bundle, File.ReadAllBytes(project.BundlePath), "the working state is back");
Assert.Contains(await host.ListAsync(), e => e.ProjectId == vertical && e.IsReadable);
Assert.True(Directory.Exists(project.MediaDirectory) && Directory.Exists(project.VersionsDirectory), "the copy is whole");
var trash = Path.Combine(host.Homes.LocalRoot, WorkspaceHost.TrashFolder);
Assert.False(Directory.Exists(trash) && Directory.EnumerateDirectories(trash).Any(d => Path.GetFileName(d).StartsWith(vertical.ToString("N"), StringComparison.Ordinal)),
"nothing is left aside");
// The file let go: removed.
await host.RemoveLocalCopyAsync(vertical, discard: true);
Assert.Null(host.Find(vertical));
}
[Test]
public async Task OlderVersionsArePrunedPastKeptVersionsOnlyOnceTheLibraryHoldsThem()
{
await using var bed = await WorkspaceTestBed.CreateAsync(context, frames: 4);
var host = bed.Host(new AppSettings { WorkspaceKeptVersions = 2 });
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.Find(mainId)!;
var kept = project.Versions().Where(v => v.StoredAt is not null).Select(v => v.Number).Order().ToList();
Assert.SequenceEqual([5, 6], kept, "the base and the one before it");
var history = await host.HistoryAsync(mainId);
Assert.Equal(6, history.Versions.Count, "the library keeps every version");
// An old version restores from the library.
var first = history.Versions.Single(v => v.Number == 2);
var restored = await host.RestoreAsync(mainId, first.Id);
Assert.Approximately(0.1, restored.Exposure.ExposureOffsetEv, 1e-9);
}
}