Files
Chronos/tests/Chronos.App.Tests/Workspace/WorkspaceNewerFormatTests.cs
T
Alby96andClaude Opus 5.5 9ad8c6f7a9 feat: wire separate homes into the desktop (owner review 5 P3.2)
The desktop now uses the per-home layout from P3.1: each home keeps its
own projects, proxies and originals, and a server is known by its id
whichever address reaches it.

- Settings keep the known servers (id, name, last address, certificate,
  aliases, originals archive). Reset and Import keep them; Export leaves
  them out.
- SyncHost records each server the first time it signs in with an id. It
  names the cache and workspace folders by that id, and re-keys the
  folders a server had under its addresses at sign-in. The re-key waits
  while transfer or workspace jobs are pending.
- Download originals goes to the server's own archive. It is created
  beside this PC's archive at the first download, and a toast says
  where. A sequence that already has a local copy keeps receiving into
  that copy's archive. A server without an id keeps the 1.0 behaviour.
- At start, after the index opens and before any job runs, the folders
  are sorted into their homes. A toast reports the result: sorted,
  pending or failed.
- The workspace host gives each home's store its own sync. Find, List,
  usage, clean-up and the trash plan and empty cover every home. Server
  comparisons go through the identity, so a project stays Online when
  its server is reached by another address.
- The render-node downloads and the server import staging move into the
  server's folder of the cache. The cache trim keeps `servers`, and the
  scheduled scan also scans the originals archives.
- Settings shows the Home folders rows (Workspace) and the Known servers
  table (Server). The diagnostics bundle lists the homes.
- The dead `AppPaths.CreateDirectories` and `ThumbnailsDirectory` are
  removed.

Refs #66

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 14:00:46 +01:00

99 lines
5.0 KiB
C#

using System.IO;
using Chronos.Core.Project;
using Chronos.Data.Projects;
using Chronos.Data.Workspaces;
using Chronos.Testing;
namespace Chronos.App.Tests.Workspace;
/// <summary>
/// The editor of a workspace project whose home moved to settings of a newer Chronos (owner review 2, R8): shown read-only,
/// never merged with this Chronos's, the editor usable whatever its undo steps hold.
/// </summary>
[Category("workspace")]
public sealed class WorkspaceNewerFormatTests(TestContext context)
{
private static ProjectSettings Exposure(ProjectSettings p, double ev) => p with { Exposure = p.Exposure with { ExposureOffsetEv = ev } };
[Test]
public async Task AnEditorWithUndoStepsTakesANewerChronossSettingsReadOnly()
{
await using var bed = await WorkspaceTestBed.CreateAsync(context);
var host = bed.Host();
var projectId = await bed.CheckoutAsync(host);
var (_, session) = await bed.OpenAsync(host, projectId);
await using (session)
{
// Edited, saved and kept as a version: every edit is stored, the undo steps stay.
Assert.True(session.Edit(p => Exposure(p, 0.4)));
Assert.True(session.Edit(p => p with { ExcludedFrames = [2] }));
Assert.True(await session.FlushAsync());
Assert.NotNull(await host.CommitAsync(projectId, bed.Ct));
Assert.True(session.History.CanUndo);
// A pull with nothing of this PC's waiting moved the working state onto a newer Chronos's settings.
var folder = host.Find(projectId)!;
var stored = folder.ReadBundle();
folder.WriteBundle(stored with { Project = Exposure(stored.Project, 1.5) with { Version = ProjectSettings.CurrentVersion + 1 } });
await session.ReloadAsync();
Assert.True(session.IsReadOnly);
Assert.True(session.Project.IsNewerFormat);
Assert.Equal(1.5, session.Project.Exposure.ExposureOffsetEv);
Assert.False(session.History.CanUndo, "no step brings this Chronos's values back over the newer ones");
Assert.False(session.Undo());
Assert.False(session.Edit(p => Exposure(p, 0.2)));
Assert.False(session.HasPendingSave);
// Read again (another analysis, another pull): the editor stays as it is.
await session.ReloadAsync();
Assert.Equal(1.5, session.Project.Exposure.ExposureOffsetEv);
}
}
[Test]
public async Task AnEditNotStoredYetIsKeptAsideWhenANewerChronossSettingsArrive()
{
await using var bed = await WorkspaceTestBed.CreateAsync(context);
var host = bed.Host();
var projectId = await bed.CheckoutAsync(host);
var (source, session) = await bed.OpenAsync(host, projectId);
await using (session)
{
var kept = new List<string>();
session.EditSetAside += kept.Add;
Assert.True(session.Edit(p => Exposure(p, 0.4)));
Assert.True(await session.FlushAsync());
Assert.NotNull(await host.CommitAsync(projectId, bed.Ct));
var folder = host.Find(projectId)!;
var stored = folder.ReadBundle();
// A sync took a newer Chronos's settings while one more edit waited for its save (made during the sync).
folder.WriteBundle(stored with { Project = Exposure(stored.Project, 1.5) with { Version = ProjectSettings.CurrentVersion + 1 } });
Assert.True(session.Edit(p => p with { ExcludedFrames = [2] }));
Assert.False(await session.FlushAsync(), "the working state no longer takes it");
await session.ReloadAsync();
Assert.True(session.IsReadOnly);
Assert.True(session.Project.IsNewerFormat, "the newer settings are taken");
Assert.Equal(1.5, session.Project.Exposure.ExposureOffsetEv);
Assert.True(await session.FlushAsync(), "nothing retried that could never be stored");
Assert.False(session.HasPendingSave);
Assert.Null(session.LastSaveError);
var path = Assert.NotNull(kept.SingleOrDefault(), "the edit is kept aside, and said");
Assert.Equal(Path.Combine(folder.VersionsDirectory, WorkspaceProject.ReplacedFolder), Path.GetDirectoryName(path));
var aside = ProjectSidecars.ReadVersion(path);
var placed = ProjectSettings.FromJson(ProjectContent.Place(aside.SettingsJson, source.Photos));
Assert.Equal(0.4, placed.Exposure.ExposureOffsetEv);
Assert.SequenceEqual([2], placed.ExcludedFrames, "the edit as it was, by photo");
Assert.False(folder.Versions().Any(v => v.Id == aside.Id), "outside the chain: never sent");
Assert.Empty(host.SyncOf(projectId).Unpushed(projectId).Where(v => v.Id == aside.Id));
// Read again: no throw, nothing more kept aside, the editor as it is.
await session.ReloadAsync();
Assert.Count(1, kept);
Assert.Equal(1.5, session.Project.Exposure.ExposureOffsetEv);
Assert.True(await session.FlushAsync());
}
}
}