Owner review 2, phase 5a, fix round 5. - A cancelled workspace copy clears its partial media only under the project's lease, after checking again that the job is still cancelled, that no other copy of the same root and project is queued, running or paused, and that no copy in this process is writing. The engine now waits for a paused job's run to end before calling the cancel handler, so the clean-up is never skipped. - The clean-up never recreates a project folder that was removed meanwhile (the lease no longer creates the folder). The next list removes a project folder that holds only lease files nobody holds, older than the lease. - A Main this Chronos cannot read (newer or damaged) refuses the open at once only when nothing else can be offered. Otherwise Open in workspace lists it disabled, with the reason as its tooltip. The refusal's action tooltip is now Remove copy. - The removal plan counts a conflict the same way the sync status does: a conflict that a settling replay took past its commit point is not work left. - A healed record is stamped after both the record's time and the index's, so the next rename made elsewhere is taken. - A trash folder holds back the rebuild of a lost record only when it is this sequence's deletion: its record names this sequence or cannot be read, or it has no record, is within a one-day grace and holds no version of another project. What was seen of folders that are gone or have a record again is forgotten. - When a deletion wins, version files pushed into the live folder before the deletion arrived are moved beside the deleted record in the trash, never deleted. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
403 lines
25 KiB
C#
403 lines
25 KiB
C#
using System.IO;
|
|
using Chronos.App.Editor;
|
|
using Chronos.App.Infrastructure;
|
|
using Chronos.App.Shell;
|
|
using Chronos.App.Tests.Editor;
|
|
using Chronos.App.Tests.Windows;
|
|
using Chronos.App.Workspace;
|
|
using Chronos.Core.Archiving;
|
|
using Chronos.Core.Codecs.Jpeg;
|
|
using Chronos.Core.Localization;
|
|
using Chronos.Core.Metadata;
|
|
using Chronos.Core.Project;
|
|
using Chronos.Core.Windows.Shell;
|
|
using Chronos.Data;
|
|
using Chronos.Data.Archiving;
|
|
using Chronos.Data.Workspaces;
|
|
using Chronos.Testing;
|
|
using Chronos.Ui.Controls;
|
|
|
|
namespace Chronos.App.Tests.Workspace;
|
|
|
|
/// <summary>
|
|
/// Edit opens this PC's sequences as workspace projects (owner review 2, R8), on the real services without a window:
|
|
/// "Open in workspace" asks the first time, the media are copied by a job and the project opens; the library is written
|
|
/// only by a version saved; the picker lists the project in its Workspace group with its state; the next open takes the
|
|
/// project opened last without asking; a project file of format 1 gives its settings to Main.
|
|
/// </summary>
|
|
[WindowsOnly]
|
|
[Serial]
|
|
[Timeout(300_000)]
|
|
[Category("workspace")]
|
|
public sealed class WorkspaceSectionTests(TestContext context)
|
|
{
|
|
[Test]
|
|
public Task OpenInWorkspaceAsksCopiesAndOpensAndThePickerListsTheProject() => ScreenHost.RunAsync(async () =>
|
|
{
|
|
var directory = context.CreateTempDirectory("workspace-section");
|
|
var environment = AppEnvironment.From(AppPaths.Resolve(Directory.CreateDirectory(Path.Combine(directory, "app")).FullName,
|
|
Directory.CreateDirectory(Path.Combine(directory, "local")).FullName, []));
|
|
UiLanguage.Apply("en");
|
|
var settings = new AppSettings { Language = "en", FirstRunCompleted = true, CheckForUpdates = false };
|
|
var services = new AppServices(environment, settings, () => { }, new DeclineDialogs());
|
|
await services.AttachAsync(await ChronosDatabase.OpenAsync(DatabaseOptions.Sqlite(environment.DatabasePath)), startEngine: true);
|
|
var shell = new ShellViewModel(services);
|
|
try
|
|
{
|
|
var sequenceId = await SequenceAsync(services, Path.Combine(directory, "archive"));
|
|
var db = services.Database!;
|
|
var libraryBefore = (await db.Sequences.GetAsync(sequenceId))!.SettingsJson;
|
|
var section = shell.Sequence;
|
|
|
|
shell.OpenSequence(sequenceId);
|
|
await WorkspaceTestBed.UntilAsync(() => section.Dialog is OpenInWorkspaceDialogViewModel, "Open in workspace asks the first time");
|
|
var ask = (OpenInWorkspaceDialogViewModel)section.Dialog!;
|
|
Assert.Equal(Loc.L("Editor.Project.Main"), ask.SelectedProject!.Label, "Main, made from the sequence's settings, is offered first");
|
|
Assert.True(ask.IsProxies && !ask.CanCopyOriginals, "proxies; the originals come later");
|
|
Assert.True(section.ShowsPicker && !section.IsLoading, "the picker shows behind the dialog, not the progress bar");
|
|
ask.OpenCommand.Execute(null);
|
|
Assert.Null(section.Dialog);
|
|
await WorkspaceTestBed.UntilAsync(() => section.Editor is not null, "the project opens once its media are copied");
|
|
var editor = section.Editor!;
|
|
Assert.True(editor.Session.Source is WorkspaceSequenceSource);
|
|
var project = Assert.NotNull(editor.Project);
|
|
Assert.Equal(Loc.L("Editor.Project.Main"), project.Name);
|
|
await WorkspaceTestBed.UntilAsync(() => project.Status is not null, "its state is read");
|
|
Assert.Equal(WorkspaceState.InSync, project.Status!.State);
|
|
Assert.Equal(section.OpenProjectId!.Value, settings.WorkspaceRecent[sequenceId]);
|
|
Assert.True(File.Exists(Path.Combine(WorkspaceHost.DefaultRoot(environment), section.OpenProjectId.Value.ToString("N"), WorkspaceProject.BundleFile)),
|
|
"the project lives in the workspace beside the index");
|
|
|
|
// Edited in the workspace; the library takes it with the version saved.
|
|
editor.Session.Edit(p => p with { Exposure = p.Exposure with { ExposureOffsetEv = 0.4 } });
|
|
Assert.True(await editor.Session.FlushAsync());
|
|
Assert.Equal(libraryBefore, (await db.Sequences.GetAsync(sequenceId))!.SettingsJson, "editing never writes the library");
|
|
await project.SaveVersionAsync("Warmer");
|
|
Assert.Equal(0.4, ProjectSettings.FromJson((await db.Sequences.GetAsync(sequenceId))!.SettingsJson!).Exposure.ExposureOffsetEv);
|
|
|
|
// The picker: the Workspace group lists the project with its state, above the library's sequences.
|
|
section.ChangeSequenceCommand.Execute(null);
|
|
await section.Picker.Loading;
|
|
await section.Picker.WorkspaceLoadedAsync();
|
|
var item = Assert.Contains(section.Picker.WorkspaceItems, i => i.ProjectId == section.OpenProjectId);
|
|
Assert.True(section.Picker.HasWorkspaceItems);
|
|
Assert.Same(item, section.Picker.SelectedProject);
|
|
Assert.Equal(Loc.L("Editor.Workspace.State.InSync"), item.StateText);
|
|
Assert.Contains(section.Picker.Items, i => i.Id == sequenceId);
|
|
await section.PickProjectAsync(item);
|
|
Assert.False(section.IsPicking, "the open project shows again");
|
|
Assert.Same(editor, section.Editor);
|
|
|
|
// Closed, then asked for again: the project opened last opens without a question.
|
|
Assert.True(await section.ConfirmCloseAsync());
|
|
await section.CloseAsync();
|
|
shell.KeepSequence(null);
|
|
shell.OpenSequence(sequenceId);
|
|
await WorkspaceTestBed.UntilAsync(() => section.Editor is not null, "it opens again");
|
|
Assert.Null(section.Dialog);
|
|
Assert.Equal(0.4, section.Editor!.Session.Project.Exposure.ExposureOffsetEv);
|
|
|
|
// A project file of format 1 gives its settings to Main, as one undo step.
|
|
var file = Path.Combine(directory, "Harbour.chronos");
|
|
var bundle = new ProjectBundle(new BundleArchive(Guid.CreateVersion7(), "Elsewhere", null), new BundleSequence(sequenceId, "Synthetic", "Harbour", 6),
|
|
section.Editor.Session.Project with { Camera = section.Editor.Session.Project.Camera with { OffsetY = 0.3 } }, DateTimeOffset.UtcNow);
|
|
bundle.Save(file);
|
|
await new ProjectFiles(shell).OpenAsync(file);
|
|
Assert.Equal(0.3, section.Editor.Session.Project.Camera.OffsetY);
|
|
Assert.True(section.Editor.Session.Undo());
|
|
Assert.Equal(0.0, section.Editor.Session.Project.Camera.OffsetY);
|
|
Assert.True(await section.Editor.Session.FlushAsync());
|
|
}
|
|
finally
|
|
{
|
|
await shell.Sequence.CloseAsync();
|
|
shell.Dispose();
|
|
await services.DisposeAsync();
|
|
}
|
|
});
|
|
|
|
[Test]
|
|
public Task ARefusedFolderOffersAnotherFromItsToastAndCopiesThisChronosCannotReadAreNeverOpened() => ScreenHost.RunAsync(async () =>
|
|
{
|
|
var directory = context.CreateTempDirectory("workspace-refused");
|
|
var environment = AppEnvironment.From(AppPaths.Resolve(Directory.CreateDirectory(Path.Combine(directory, "app")).FullName,
|
|
Directory.CreateDirectory(Path.Combine(directory, "local")).FullName, []));
|
|
UiLanguage.Apply("en");
|
|
var settings = new AppSettings { Language = "en", FirstRunCompleted = true, CheckForUpdates = false };
|
|
var outside = Path.Combine(directory, "outside");
|
|
var dialogs = new ScriptedDialogs { Folder = outside };
|
|
var services = new AppServices(environment, settings, () => { }, dialogs);
|
|
await services.AttachAsync(await ChronosDatabase.OpenAsync(DatabaseOptions.Sqlite(environment.DatabasePath)), startEngine: true);
|
|
var shell = new ShellViewModel(services);
|
|
var toasts = new List<Toast>();
|
|
shell.PendingToasts.CollectionChanged += (_, e) => toasts.AddRange(e.NewItems?.OfType<Toast>() ?? []);
|
|
try
|
|
{
|
|
var library = Path.Combine(directory, "archive");
|
|
var sequenceId = await SequenceAsync(services, library);
|
|
var inside = Path.Combine(library, "workspace");
|
|
settings.WorkspaceFolder = inside;
|
|
var section = shell.Sequence;
|
|
|
|
// Open in workspace shows what the copy writes and the room there is, then the folder is refused with a way on.
|
|
shell.OpenSequence(sequenceId);
|
|
await WorkspaceTestBed.UntilAsync(() => section.Dialog is OpenInWorkspaceDialogViewModel, "Open in workspace asks the first time");
|
|
var ask = (OpenInWorkspaceDialogViewModel)section.Dialog!;
|
|
Assert.SequenceEqual([Loc.L("Editor.OpenWorkspace.Size"), Loc.L("Editor.OpenWorkspace.Free")], ask.CopyFacts.Select(f => f.Label), "the copy's facts reach the dialog");
|
|
ask.OpenCommand.Execute(null);
|
|
await WorkspaceTestBed.UntilAsync(() => toasts.Any(t => t.Title == Loc.L("Editor.Workspace.OpenFailed")), "the refusal is said");
|
|
var refused = toasts.Single(t => t.Title == Loc.L("Editor.Workspace.OpenFailed"));
|
|
Assert.True(refused is { IsError: true, ActionCommand: not null }, "an error with its action");
|
|
Assert.Equal((Loc.L("Errors.Workspace.InsideLibraryEdit", Path.GetFullPath(inside)), Loc.L("Editor.Workspace.ChooseFolder"), Loc.L("Tooltips.Editor.Workspace.ChooseFolder")),
|
|
(refused.Message, refused.ActionText, refused.ActionToolTip));
|
|
Assert.False(Directory.Exists(inside), "nothing was written inside the library");
|
|
Assert.Null(section.Editor);
|
|
|
|
// Its action picks another folder, shows the plan and uses it.
|
|
refused.ActionCommand!.Execute(null);
|
|
await WorkspaceTestBed.UntilAsync(() => string.Equals(services.Workspace.Root, Path.GetFullPath(outside), StringComparison.OrdinalIgnoreCase), "the folder chosen is used");
|
|
Assert.Count(1, dialogs.Asked);
|
|
Assert.Equal(Loc.L("Settings.Workspace.ChangeTitle"), dialogs.Asked[0].Heading);
|
|
|
|
// That workspace holds a copy a newer Chronos saved and a damaged one: listed, never opened.
|
|
var newerId = Guid.CreateVersion7();
|
|
var newer = Directory.CreateDirectory(Path.Combine(outside, newerId.ToString("N"))).FullName;
|
|
await File.WriteAllTextAsync(Path.Combine(newer, WorkspaceProject.BundleFile),
|
|
$$"""{ "format": "chronos-project", "formatVersion": 9, "sequence": { "title": "Harbour" }, "workspace": { "projectId": "{{newerId}}", "name": "Vertical" } }""");
|
|
var damagedId = Guid.CreateVersion7();
|
|
var damaged = Directory.CreateDirectory(Path.Combine(outside, damagedId.ToString("N"))).FullName;
|
|
await File.WriteAllTextAsync(Path.Combine(damaged, WorkspaceProject.BundleFile), "{ not a project");
|
|
await File.WriteAllTextAsync(Path.Combine(damaged, "notes.txt"), "kept");
|
|
await section.Picker.ReloadAsync();
|
|
await section.Picker.WorkspaceLoadedAsync();
|
|
var newerItem = Assert.Contains(section.Picker.WorkspaceItems, i => i.ProjectId == newerId);
|
|
Assert.True(newerItem is { IsNewer: true, IsDamaged: false, IsReadable: false, Name: "Vertical", SequenceTitle: "Harbour" });
|
|
Assert.Null(newerItem.Status, "no state is asked of it");
|
|
await section.PickProjectAsync(newerItem);
|
|
Assert.Contains(toasts, t => t.Message == Loc.L("Errors.Workspace.NewerCopy") && t.IsError);
|
|
Assert.Null(section.Dialog, "nothing is offered over it");
|
|
Assert.FileExists(Path.Combine(newer, WorkspaceProject.BundleFile));
|
|
|
|
// The damaged one offers its removal, named as a damaged copy; Discard asks its files' number and keeps every file aside.
|
|
var damagedItem = Assert.Contains(section.Picker.WorkspaceItems, i => i.ProjectId == damagedId);
|
|
await section.PickProjectAsync(damagedItem);
|
|
var remove = Assert.NotNull(section.Dialog as RemoveCopyDialogViewModel);
|
|
Assert.Equal(Loc.L("Editor.RemoveCopy.DamagedTitle"), remove.Heading);
|
|
dialogs.Answer = true;
|
|
remove.DiscardCommand.Execute(null);
|
|
await WorkspaceTestBed.UntilAsync(() => !Directory.Exists(damaged), "the damaged copy goes");
|
|
var discard = dialogs.Asked[^1];
|
|
Assert.Equal((Loc.L("Editor.RemoveCopy.DamagedDiscard"), Formatting.Count(2), Loc.L("Editor.RemoveCopy.TypeFiles", Formatting.Count(2))),
|
|
(discard.Heading, discard.TypedConfirmation, discard.TypedPrompt));
|
|
var aside = Assert.Contains(Directory.EnumerateDirectories(Path.Combine(outside, WorkspaceHost.TrashFolder)),
|
|
d => Path.GetFileName(d).StartsWith(damagedId.ToString("N"), StringComparison.Ordinal));
|
|
Assert.Equal("kept", await File.ReadAllTextAsync(Path.Combine(aside, "notes.txt")));
|
|
// Nothing knows its name: the toast names no folder id.
|
|
await WorkspaceTestBed.UntilAsync(() => toasts.Any(t => t.Title == Loc.L("Editor.Workspace.Removed")), "the removal is said");
|
|
Assert.Null(toasts.Single(t => t.Title == Loc.L("Editor.Workspace.Removed")).Message);
|
|
}
|
|
finally
|
|
{
|
|
await shell.Sequence.CloseAsync();
|
|
shell.Dispose();
|
|
await services.DisposeAsync();
|
|
}
|
|
});
|
|
|
|
[Test]
|
|
public Task AMainThisChronosCannotReadSaysWhyAtOnceAndADamagedOneOffersItsRemoval() => ScreenHost.RunAsync(async () =>
|
|
{
|
|
var directory = context.CreateTempDirectory("workspace-unreadable-main");
|
|
var environment = AppEnvironment.From(AppPaths.Resolve(Directory.CreateDirectory(Path.Combine(directory, "app")).FullName,
|
|
Directory.CreateDirectory(Path.Combine(directory, "local")).FullName, []));
|
|
UiLanguage.Apply("en");
|
|
var settings = new AppSettings { Language = "en", FirstRunCompleted = true, CheckForUpdates = false };
|
|
var dialogs = new ScriptedDialogs();
|
|
var services = new AppServices(environment, settings, () => { }, dialogs);
|
|
await services.AttachAsync(await ChronosDatabase.OpenAsync(DatabaseOptions.Sqlite(environment.DatabasePath)), startEngine: true);
|
|
var shell = new ShellViewModel(services);
|
|
var toasts = new List<Toast>();
|
|
shell.PendingToasts.CollectionChanged += (_, e) => toasts.AddRange(e.NewItems?.OfType<Toast>() ?? []);
|
|
try
|
|
{
|
|
var sequenceId = await SequenceAsync(services, Path.Combine(directory, "archive"));
|
|
var section = shell.Sequence;
|
|
shell.OpenSequence(sequenceId);
|
|
await WorkspaceTestBed.UntilAsync(() => section.Dialog is OpenInWorkspaceDialogViewModel, "Open in workspace asks the first time");
|
|
((OpenInWorkspaceDialogViewModel)section.Dialog!).OpenCommand.Execute(null);
|
|
await WorkspaceTestBed.UntilAsync(() => section.Editor is not null, "Main opens");
|
|
var mainId = section.OpenProjectId!.Value;
|
|
Assert.True(await section.ConfirmCloseAsync());
|
|
await section.CloseAsync();
|
|
shell.KeepSequence(null);
|
|
var folder = Path.Combine(services.Workspace.Root, mainId.ToString("N"));
|
|
var bundle = Path.Combine(folder, WorkspaceProject.BundleFile);
|
|
|
|
// Saved by a newer Chronos: said at once, nothing offered over it, nothing asked.
|
|
await WriteWhenFreeAsync(bundle,
|
|
$$"""{ "format": "chronos-project", "formatVersion": 9, "sequence": { "title": "Synthetic" }, "workspace": { "projectId": "{{mainId}}", "name": "Main", "isMain": true } }""");
|
|
shell.OpenSequence(sequenceId);
|
|
await WorkspaceTestBed.UntilAsync(() => toasts.Any(t => t.Message == Loc.L("Errors.Workspace.NewerCopy")), "a newer Main is refused");
|
|
var newer = toasts.Single(t => t.Message == Loc.L("Errors.Workspace.NewerCopy"));
|
|
Assert.True(newer is { Title: var title, IsError: true, ActionCommand: null } && title == Loc.L("Editor.Workspace.OpenFailed"));
|
|
Assert.True(section.Dialog is null && section.Editor is null, "nothing asked, nothing opened");
|
|
Assert.FileExists(bundle);
|
|
shell.KeepSequence(null);
|
|
|
|
// Damaged: said at once, with Remove local copy; its Discard keeps the files aside, named as the copy is known.
|
|
await WriteWhenFreeAsync(bundle, "{ not a project");
|
|
shell.OpenSequence(sequenceId);
|
|
await WorkspaceTestBed.UntilAsync(() => toasts.Any(t => t.Message == Loc.L("Errors.Workspace.Damaged")), "a damaged Main is refused");
|
|
var damaged = toasts.Single(t => t.Message == Loc.L("Errors.Workspace.Damaged"));
|
|
Assert.Equal((Loc.L("Editor.Workspace.OpenFailed"), true, Loc.L("Editor.Project.RemoveCopy"), Loc.L("Tooltips.Editor.Project.RemoveCopy")),
|
|
(damaged.Title, damaged.IsError, damaged.ActionText, damaged.ActionToolTip));
|
|
Assert.True(section.Dialog is null && section.Editor is null, "nothing asked, nothing opened");
|
|
damaged.ActionCommand!.Execute(null);
|
|
await WorkspaceTestBed.UntilAsync(() => section.Dialog is RemoveCopyDialogViewModel, "its removal is offered");
|
|
var remove = (RemoveCopyDialogViewModel)section.Dialog!;
|
|
Assert.True(remove.Plan.Damaged, "removed as a damaged copy");
|
|
Assert.Equal(Loc.L("Editor.RemoveCopy.Title", Loc.L("Editor.Project.Main")), remove.Heading);
|
|
remove.DiscardCommand.Execute(null);
|
|
await WorkspaceTestBed.UntilAsync(() => toasts.Any(t => t.Title == Loc.L("Editor.Workspace.Removed")), "the copy goes");
|
|
Assert.False(Directory.Exists(folder));
|
|
var removed = toasts.Single(t => t.Title == Loc.L("Editor.Workspace.Removed"));
|
|
Assert.Equal(Loc.L("Editor.Project.Main"), removed.Message, "named as the index knows it, never by its folder");
|
|
}
|
|
finally
|
|
{
|
|
await shell.Sequence.CloseAsync();
|
|
shell.Dispose();
|
|
await services.DisposeAsync();
|
|
}
|
|
});
|
|
|
|
[Test]
|
|
public Task AMainThisChronosCannotReadIsListedDisabledWhileAnotherProjectCanOpen() => ScreenHost.RunAsync(async () =>
|
|
{
|
|
var directory = context.CreateTempDirectory("workspace-unreadable-main-others");
|
|
var environment = AppEnvironment.From(AppPaths.Resolve(Directory.CreateDirectory(Path.Combine(directory, "app")).FullName,
|
|
Directory.CreateDirectory(Path.Combine(directory, "local")).FullName, []));
|
|
UiLanguage.Apply("en");
|
|
var settings = new AppSettings { Language = "en", FirstRunCompleted = true, CheckForUpdates = false };
|
|
var services = new AppServices(environment, settings, () => { }, new ScriptedDialogs());
|
|
await services.AttachAsync(await ChronosDatabase.OpenAsync(DatabaseOptions.Sqlite(environment.DatabasePath)), startEngine: true);
|
|
var shell = new ShellViewModel(services);
|
|
var toasts = new List<Toast>();
|
|
shell.PendingToasts.CollectionChanged += (_, e) => toasts.AddRange(e.NewItems?.OfType<Toast>() ?? []);
|
|
try
|
|
{
|
|
var sequenceId = await SequenceAsync(services, Path.Combine(directory, "archive"));
|
|
var section = shell.Sequence;
|
|
shell.OpenSequence(sequenceId);
|
|
await WorkspaceTestBed.UntilAsync(() => section.Dialog is OpenInWorkspaceDialogViewModel, "Open in workspace asks the first time");
|
|
((OpenInWorkspaceDialogViewModel)section.Dialog!).OpenCommand.Execute(null);
|
|
await WorkspaceTestBed.UntilAsync(() => section.Editor is not null, "Main opens");
|
|
var mainId = section.OpenProjectId!.Value;
|
|
Assert.True(await section.ConfirmCloseAsync());
|
|
await section.CloseAsync();
|
|
shell.KeepSequence(null);
|
|
var vertical = (await services.Archives!.Projects.CreateAsync(sequenceId, "Vertical", cancellationToken: context.Cancellation)).Id;
|
|
var bundle = Path.Combine(services.Workspace.Root, mainId.ToString("N"), WorkspaceProject.BundleFile);
|
|
|
|
// Damaged: the sequence has another project, so it is asked which; Main is listed, disabled, why in its tooltip.
|
|
await WriteWhenFreeAsync(bundle, "{ not a project");
|
|
shell.OpenSequence(sequenceId);
|
|
await WorkspaceTestBed.UntilAsync(() => section.Dialog is OpenInWorkspaceDialogViewModel, "Open in workspace offers the other project");
|
|
var asked = (OpenInWorkspaceDialogViewModel)section.Dialog!;
|
|
var main = asked.Projects.Single(p => p.Project.IsMain);
|
|
Assert.True(main is { IsAvailable: false } && main.ToolTip == Loc.L("Tooltips.Editor.Workspace.State.DamagedCopy"), "a damaged Main is listed as it is");
|
|
Assert.Equal(vertical, asked.SelectedProject?.Project.Id);
|
|
asked.SelectedProject = main;
|
|
Assert.Equal(vertical, asked.SelectedProject?.Project.Id, "never chosen");
|
|
Assert.True(asked.CanOpen && asked.HasProjects);
|
|
asked.CloseCommand.Execute(null);
|
|
await WorkspaceTestBed.UntilAsync(() => section.Dialog is null, "closed without a choice");
|
|
Assert.False(toasts.Any(t => t.Message == Loc.L("Errors.Workspace.Damaged")), "nothing refused");
|
|
shell.KeepSequence(null);
|
|
|
|
// Saved by a newer Chronos: the same, and the other project opens; Main's copy is left as it is.
|
|
var newer = $$"""{ "format": "chronos-project", "formatVersion": 9, "sequence": { "title": "Synthetic" }, "workspace": { "projectId": "{{mainId}}", "name": "Main", "isMain": true } }""";
|
|
await WriteWhenFreeAsync(bundle, newer);
|
|
shell.OpenSequence(sequenceId);
|
|
await WorkspaceTestBed.UntilAsync(() => section.Dialog is OpenInWorkspaceDialogViewModel, "Open in workspace offers the other project");
|
|
asked = (OpenInWorkspaceDialogViewModel)section.Dialog!;
|
|
main = asked.Projects.Single(p => p.Project.IsMain);
|
|
Assert.True(main is { IsAvailable: false } && main.ToolTip == Loc.L("Tooltips.Editor.Workspace.State.NewerCopy"), "a newer Main is listed as it is");
|
|
asked.OpenCommand.Execute(null);
|
|
await WorkspaceTestBed.UntilAsync(() => section.Editor is not null, "the other project opens");
|
|
Assert.Equal(vertical, section.OpenProjectId);
|
|
Assert.False(toasts.Any(t => t.Message == Loc.L("Errors.Workspace.NewerCopy")), "nothing refused");
|
|
Assert.Equal(newer, await File.ReadAllTextAsync(bundle));
|
|
}
|
|
finally
|
|
{
|
|
await shell.Sequence.CloseAsync();
|
|
shell.Dispose();
|
|
await services.DisposeAsync();
|
|
}
|
|
});
|
|
|
|
/// <summary>Writes <paramref name="path"/> once the project's last background read (its state, after the close) lets go of it.</summary>
|
|
private static async Task WriteWhenFreeAsync(string path, string text)
|
|
{
|
|
var until = DateTime.UtcNow + TimeSpan.FromSeconds(TestTiming.Budget(20));
|
|
while (true)
|
|
{
|
|
try
|
|
{
|
|
await File.WriteAllTextAsync(path, text);
|
|
return;
|
|
}
|
|
catch (IOException) when (DateTime.UtcNow < until)
|
|
{
|
|
await Task.Delay(50);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>An archive with one sequence of six synthetic photos, indexed.</summary>
|
|
private async Task<Guid> SequenceAsync(AppServices services, string root)
|
|
{
|
|
var archives = services.Archives!;
|
|
var archive = await archives.CreateAsync(root, "Test");
|
|
var sequence = EditorFixture.Sequence(6);
|
|
var folder = Path.Combine(root, "Synthetic");
|
|
Directory.CreateDirectory(folder);
|
|
for (var i = 0; i < sequence.Count; i++)
|
|
{
|
|
using var image = sequence.Render(i);
|
|
var exif = ExifWriter.BuildJpegApp1(sequence.Metadata[i]);
|
|
File.WriteAllBytes(Path.Combine(folder, $"IMG_{i + 1:0000}.JPG"), JpegEncoder.Encode(image, new JpegEncodeOptions { Quality = 90, App1Segments = [exif[4..]] }));
|
|
}
|
|
await archives.Indexer.ScanAsync(archive, ScanMode.Full, null, _ => ValueTask.CompletedTask, context.Cancellation);
|
|
return (await services.Database!.Sequences.ListLocationsAsync(archive.Id, context.Cancellation)).Single().Id;
|
|
}
|
|
|
|
/// <summary>Dialogs that pick <see cref="Folder"/> and answer every confirmation with <see cref="Answer"/> (yes first), recording what they were asked.</summary>
|
|
private sealed class ScriptedDialogs : IAppDialogs
|
|
{
|
|
public string? Folder { get; set; }
|
|
public bool Answer { get; set; } = true;
|
|
public List<ConfirmRequest> 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<string, string, Task<string?>> signIn) => false;
|
|
}
|
|
|
|
/// <summary>Dialogs that pick nothing and decline every confirmation.</summary>
|
|
private sealed class DeclineDialogs : IAppDialogs
|
|
{
|
|
public string? PickFolder(string title, string? initialFolder = null) => null;
|
|
public string? PickJsonFile(string title) => null;
|
|
public bool Confirm(ConfirmRequest request) => false;
|
|
public bool SignIn(string server, string? username, Func<string, string, Task<string?>> signIn) => false;
|
|
}
|
|
}
|