using Chronos.Core.IO;
using Chronos.Core.Project;
using Chronos.Data.Homes;
using Chronos.Data.Sync;
using Chronos.Data.Workspaces;
using Chronos.Testing;
namespace Chronos.Data.Tests.Homes;
/// The one-time sorting of a 1.0 workspace and cache into homes (owner review 5, #66).
[Category("homes")]
public sealed class HomeLayoutMigrationTests(TestContext context)
{
private static readonly Guid Id = Guid.Parse("0192a4c1-7b3e-7cc0-8a51-2f9d0e6b1a01");
/// A 1.0 data folder: a workspace with local, server and damaged projects and a trash, and a cache with proxies, render-node files and a staged import.
private sealed class Legacy
{
public required string Data { get; init; }
public required string Workspace { get; init; }
public required string Cache { get; init; }
public required Guid Local { get; init; }
public required Guid OnNas { get; init; }
public required Guid OnOther { get; init; }
public required Guid Damaged { get; init; }
public required Guid NasRemote { get; init; }
public HomeLayoutMigration Migration(ServerIdentity? identity = null, Action? cut = null) =>
new(new HomeLayoutOptions
{
DataDirectory = Data,
WorkspaceRoot = Workspace,
CacheRoot = Cache,
Identity = identity ?? ServerIdentity.None,
CurrentServer = HomeFixtures.Nas,
})
{ Cut = cut };
}
private Legacy Make()
{
var data = context.CreateTempDirectory("data");
var workspace = HomeFixtures.LegacyWorkspace(data);
var local = HomeFixtures.Project(workspace, HomeFixtures.Local());
var onNas = HomeFixtures.Project(workspace, HomeFixtures.Server(HomeFixtures.Nas));
var onOther = HomeFixtures.Project(workspace, HomeFixtures.Server(HomeFixtures.Other));
var damaged = Guid.CreateVersion7();
Directory.CreateDirectory(Path.Combine(workspace, damaged.ToString("N")));
File.WriteAllText(Path.Combine(workspace, damaged.ToString("N"), WorkspaceProject.BundleFile), "{ not json");
HomeFixtures.TrashEntry(workspace, onNas, HomeFixtures.Server(HomeFixtures.Nas));
File.WriteAllText(Path.Combine(workspace, WorkspaceTrash.FolderName, "loose.txt"), "kept");
var cache = Path.Combine(data, "cache");
var nasRemote = Guid.CreateVersion7();
HomeFixtures.LegacyProxies(cache, HomeFixtures.Nas, nasRemote);
HomeFixtures.LegacyProxies(cache, HomeFixtures.Other, Guid.CreateVersion7());
Directory.CreateDirectory(Path.Combine(cache, "render-node", "job1"));
File.WriteAllText(Path.Combine(cache, "render-node", "job1", "frame.jpg"), "rn");
Directory.CreateDirectory(Path.Combine(cache, "server-import"));
File.WriteAllText(Path.Combine(cache, "server-import", "card.part"), "import");
return new Legacy
{
Data = data,
Workspace = workspace,
Cache = cache,
Local = local,
OnNas = onNas,
OnOther = onOther,
Damaged = damaged,
NasRemote = nasRemote,
};
}
/// Every file and folder under with its size and time: what a dry run must leave as it was.
private static List Snapshot(string root) =>
[.. new DirectoryInfo(root).EnumerateFileSystemInfos("*", SearchOption.AllDirectories)
.Select(e => Path.GetRelativePath(root, e.FullName) + "|" + (e is FileInfo f ? f.Length + "|" + f.LastWriteTimeUtc.Ticks : "dir"))
.Order(StringComparer.Ordinal)];
private static string Home(string workspace, string key) => Path.Combine(workspace, "servers", HomeFolders.ServerFolder(key));
private static void AssertSorted(Legacy legacy, string nasFolder)
{
var ws = legacy.Workspace;
Assert.True(WorkspaceHomes.IsSplitRoot(ws));
Assert.FileExists(Path.Combine(ws, "local", legacy.Local.ToString("N"), WorkspaceProject.BundleFile));
Assert.FileExists(Path.Combine(ws, "local", legacy.Damaged.ToString("N"), WorkspaceProject.BundleFile));
Assert.FileExists(Path.Combine(ws, "servers", nasFolder, legacy.OnNas.ToString("N"), WorkspaceProject.BundleFile));
Assert.FileExists(Path.Combine(Home(ws, HomeFixtures.Other), legacy.OnOther.ToString("N"), WorkspaceProject.BundleFile));
Assert.FileExists(Path.Combine(ws, "local", WorkspaceTrash.FolderName, "loose.txt"));
Assert.Count(1, Directory.EnumerateDirectories(Path.Combine(ws, "servers", nasFolder, WorkspaceTrash.FolderName)));
Assert.False(Directory.EnumerateDirectories(ws).Any(d => Guid.TryParseExact(Path.GetFileName(d), "N", out _)), "no project is left in the parent");
Assert.False(Directory.Exists(Path.Combine(ws, WorkspaceTrash.FolderName)), "the parent's emptied trash went");
Assert.Equal("Studio NAS", Assert.NotNull(ServerHomeRecord.Read(Path.Combine(ws, "servers", nasFolder))).Name);
Assert.FileExists(Path.Combine(legacy.Cache, "servers", nasFolder, "proxies", legacy.NasRemote.ToString("N"), "remote.json"));
Assert.True(Directory.Exists(Path.Combine(legacy.Cache, "servers", HomeFolders.ServerFolder(HomeFixtures.Other), "proxies")));
Assert.FileExists(Path.Combine(legacy.Cache, "servers", nasFolder, "render-node", "job1", "frame.jpg"));
Assert.FileExists(Path.Combine(legacy.Cache, "servers", nasFolder, "import", "card.part"));
Assert.False(Directory.Exists(Path.Combine(legacy.Cache, "render-node")));
Assert.FileMissing(Path.Combine(legacy.Data, HomeLayoutMigration.JournalFile));
var homes = new WorkspaceHomes(ws);
Assert.True(homes.IsSplit);
Assert.Equal(4, homes.List().Count);
}
[Test]
public async Task ThePlanWritesNothing()
{
var legacy = Make();
var before = Snapshot(legacy.Data);
var plan = await legacy.Migration().PlanAsync(context.Cancellation);
Assert.SequenceEqual(before, Snapshot(legacy.Data));
Assert.True(plan.SplitsWorkspace);
Assert.Null(plan.Deferred);
Assert.Equal(4, plan.Projects);
Assert.Equal(2, plan.Entries.Count(e => e.Kind == HomeEntryKind.Trash));
Assert.Equal(2, plan.Entries.Count(e => e.Kind == HomeEntryKind.Proxies));
Assert.Equal(1, plan.Entries.Count(e => e.Kind == HomeEntryKind.RenderNode));
Assert.Equal(1, plan.Entries.Count(e => e.Kind == HomeEntryKind.Import));
var damaged = plan.Entries.Single(e => e.Source.EndsWith(legacy.Damaged.ToString("N"), StringComparison.Ordinal));
Assert.Equal(Path.Combine(legacy.Workspace, "local", legacy.Damaged.ToString("N")), damaged.Target);
Assert.Equal(plan.Fingerprint, (await legacy.Migration().PlanAsync(context.Cancellation)).Fingerprint);
}
[Test]
public async Task SortingMovesEveryHomeAndRenamesOnly()
{
var legacy = Make();
var before = HomeFixtures.Manifest(legacy.Workspace);
var cacheBefore = HomeFixtures.Manifest(legacy.Cache);
var result = await legacy.Migration().ApplyAsync(context.Cancellation);
Assert.Equal((4, 0, false, true), (result.ProjectsMoved, result.InUse, result.Resumed, result.Split));
AssertSorted(legacy, HomeFolders.ServerFolder(HomeFixtures.Nas));
// Every file is there with the same name relative to its project and the same bytes: the sorting only renamed.
Assert.SequenceEqual(before, HomeFixtures.Manifest(legacy.Workspace));
Assert.SequenceEqual(cacheBefore.Values.Order(), HomeFixtures.Manifest(legacy.Cache).Values.Order());
// A second run does nothing.
var again = await legacy.Migration().ApplyAsync(context.Cancellation);
Assert.Equal(HomeLayoutResult.Nothing, again);
Assert.True((await legacy.Migration().PlanAsync(context.Cancellation)).IsEmpty);
}
[Test]
public async Task AServerKnownByIdGetsItsIdHome()
{
var legacy = Make();
await legacy.Migration(new ServerIdentity([new KnownServerKey(Id, [HomeFixtures.Nas])])).ApplyAsync(context.Cancellation);
AssertSorted(legacy, Id.ToString("N"));
Assert.Equal(ServerIdentity.IdKey(Id), Assert.NotNull(ServerHomeRecord.Read(Path.Combine(legacy.Workspace, "servers", Id.ToString("N")))).Key);
}
[Test]
public async Task ACrashAtAnyStepIsTakenUpToTheSameEnd()
{
var entries = (await Make().Migration().PlanAsync(context.Cancellation)).Entries.Count;
var cuts = new List<(string Step, int Occurrence)> { ("journal", 1), ("commit", 1) };
for (var i = 1; i <= entries; i++) cuts.AddRange([("rename", i), ("renamed", i)]);
foreach (var (step, occurrence) in cuts)
{
var legacy = Make();
var before = HomeFixtures.Manifest(legacy.Workspace);
var seen = 0;
var crashing = legacy.Migration(cut: (name, _) =>
{
if (name == step && ++seen == occurrence) throw new IOException("cut at " + step);
});
await Assert.ThrowsAsync(() => crashing.ApplyAsync(context.Cancellation));
Assert.FileExists(Path.Combine(legacy.Data, HomeLayoutMigration.JournalFile));
var resumed = await legacy.Migration().ApplyAsync(context.Cancellation);
Assert.True(resumed.Resumed, $"{step} #{occurrence}");
AssertSorted(legacy, HomeFolders.ServerFolder(HomeFixtures.Nas));
Assert.SequenceEqual(before, HomeFixtures.Manifest(legacy.Workspace), $"{step} #{occurrence}");
Assert.Equal(HomeLayoutResult.Nothing, await legacy.Migration().ApplyAsync(context.Cancellation));
}
}
[Test]
public async Task AProjectInUseIsLeftAndMovedAtALaterStart()
{
var legacy = Make();
var held = HomeFixtures.Hold(Path.Combine(legacy.Workspace, legacy.Local.ToString("N")));
HomeLayoutResult result;
using (held)
{
var plan = await legacy.Migration().PlanAsync(context.Cancellation);
Assert.SequenceEqual(new[] { legacy.Local }, plan.InUse);
result = await legacy.Migration().ApplyAsync(context.Cancellation);
Assert.Equal((3, 1, true), (result.ProjectsMoved, result.InUse, result.Split));
Assert.True(WorkspaceHomes.IsSplitRoot(legacy.Workspace));
var homes = new WorkspaceHomes(legacy.Workspace);
Assert.Equal(homes.Root, Path.GetDirectoryName(Assert.NotNull(homes.Find(legacy.Local)).Folder));
Assert.Equal(4, homes.List().Count);
// A copy, render or send job of the project left in place still finds it: the parent opens as the view of what it holds.
var root = WorkspaceJobRoots.Resolve(legacy.Workspace, legacy.Local, null, "Errors.Workspace.NotCheckedOut");
Assert.Equal(WorkspaceStore.FullRoot(legacy.Workspace), root);
Assert.Throws(() => new WorkspaceStore(root));
Assert.NotNull(WorkspaceStore.ForJob(root).Find(legacy.Local));
}
result = await legacy.Migration().ApplyAsync(context.Cancellation);
Assert.Equal((1, 0), (result.ProjectsMoved, result.InUse));
Assert.FileExists(Path.Combine(legacy.Workspace, "local", legacy.Local.ToString("N"), WorkspaceProject.BundleFile));
Assert.Null(new WorkspaceHomes(legacy.Workspace).Homes().FirstOrDefault(h => h.IsLegacy));
}
[Test]
public async Task AnUnfinishedMoveDefersTheWorkspaceWhileTheCacheIsSorted()
{
var legacy = Make();
File.WriteAllText(Path.Combine(legacy.Workspace, WorkspaceMover.JournalFile), "{}");
var before = Snapshot(legacy.Workspace);
var result = await legacy.Migration().ApplyAsync(context.Cancellation);
Assert.Equal((HomeLayoutDeferral?)HomeLayoutDeferral.Moving, result.Deferred);
Assert.False(result.Split);
Assert.SequenceEqual(before, Snapshot(legacy.Workspace));
Assert.FileExists(Path.Combine(legacy.Cache, "servers", HomeFolders.ServerFolder(HomeFixtures.Nas), "proxies", legacy.NasRemote.ToString("N"), "remote.json"));
File.Delete(Path.Combine(legacy.Workspace, WorkspaceMover.JournalFile));
await legacy.Migration().ApplyAsync(context.Cancellation);
AssertSorted(legacy, HomeFolders.ServerFolder(HomeFixtures.Nas));
}
[Test]
public async Task AWorkspaceThatWentOfflineWaitsWithItsJournal()
{
var legacy = Make();
var before = HomeFixtures.Manifest(legacy.Workspace);
await Assert.ThrowsAsync(() => legacy.Migration(cut: (name, _) =>
{
if (name == "journal") throw new IOException("cut");
}).ApplyAsync(context.Cancellation));
// The drive goes before the next start.
var away = legacy.Workspace + "-unplugged";
Directory.Move(legacy.Workspace, away);
var waiting = await legacy.Migration().ApplyAsync(context.Cancellation);
Assert.Equal((HomeLayoutDeferral?)HomeLayoutDeferral.Offline, waiting.Deferred);
Assert.FileExists(Path.Combine(legacy.Data, HomeLayoutMigration.JournalFile));
Assert.FileExists(Path.Combine(legacy.Cache, "servers", HomeFolders.ServerFolder(HomeFixtures.Nas), "import", "card.part"));
// Back: the workspace is sorted, the cache left as it is now.
Directory.Move(away, legacy.Workspace);
await legacy.Migration().ApplyAsync(context.Cancellation);
AssertSorted(legacy, HomeFolders.ServerFolder(HomeFixtures.Nas));
Assert.SequenceEqual(before, HomeFixtures.Manifest(legacy.Workspace));
}
[Test]
public async Task AProjectInBothPlacesKeepsTheCopySavedLastAndTrashesTheOther()
{
var data = context.CreateTempDirectory("data");
var workspace = HomeFixtures.LegacyWorkspace(data);
var id = Guid.CreateVersion7();
var home = HomeFixtures.Local();
HomeFixtures.Project(workspace, home, "newer", DateTimeOffset.UtcNow, id);
HomeFixtures.Project(Path.Combine(workspace, "local"), home, "older", DateTimeOffset.UtcNow.AddDays(-1), id);
var files = Directory.EnumerateFiles(workspace, "*", SearchOption.AllDirectories).Count(f => Path.GetFileName(f) != WorkspaceStore.ManifestFile);
var result = await new HomeLayoutMigration(new HomeLayoutOptions { DataDirectory = data, WorkspaceRoot = workspace }).ApplyAsync(context.Cancellation);
Assert.Equal(1, result.Clashes);
var kept = ProjectBundle.Load(Path.Combine(workspace, "local", id.ToString("N"), WorkspaceProject.BundleFile));
Assert.Equal("newer", kept.Workspace!.Name);
var trashed = Assert.NotNull(Directory.EnumerateDirectories(Path.Combine(workspace, "local", WorkspaceTrash.FolderName)).SingleOrDefault());
Assert.Equal("older", ProjectBundle.Load(Path.Combine(trashed, WorkspaceProject.BundleFile)).Workspace!.Name);
Assert.Equal(files, Directory.EnumerateFiles(workspace, "*", SearchOption.AllDirectories)
.Count(f => Path.GetFileName(f) is not (WorkspaceStore.ManifestFile or "server.json")), "nothing was deleted");
}
[Test]
public async Task ARenameThatDoesNotCheckStopsWithItsJournal()
{
var legacy = Make();
var tampered = false;
var migration = legacy.Migration(cut: (name, path) =>
{
if (name != "renamed" || tampered || !Directory.Exists(path)) return;
tampered = true;
File.WriteAllText(Path.Combine(path, "stray.txt"), "written meanwhile");
});
await Assert.ThrowsAsync(() => migration.ApplyAsync(context.Cancellation));
Assert.FileExists(Path.Combine(legacy.Data, HomeLayoutMigration.JournalFile));
// The next start takes it up; the entry found renamed is taken as moved.
await legacy.Migration().ApplyAsync(context.Cancellation);
AssertSorted(legacy, HomeFolders.ServerFolder(HomeFixtures.Nas));
}
[Test]
public async Task AWorkspaceNeverMadeOrAlreadySortedHasNothingToDo()
{
var data = context.CreateTempDirectory("data");
var options = new HomeLayoutOptions { DataDirectory = data, WorkspaceRoot = Path.Combine(data, "workspace"), CacheRoot = Path.Combine(data, "cache") };
Assert.True((await new HomeLayoutMigration(options).PlanAsync(context.Cancellation)).IsEmpty);
Assert.Equal(HomeLayoutResult.Nothing, await new HomeLayoutMigration(options).ApplyAsync(context.Cancellation));
Assert.False(Directory.Exists(options.WorkspaceRoot));
_ = new WorkspaceHomes(options.WorkspaceRoot);
Assert.True((await new HomeLayoutMigration(options).PlanAsync(context.Cancellation)).IsEmpty);
// An empty 1.0 workspace is split by its manifest alone.
var empty = HomeFixtures.LegacyWorkspace(context.CreateTempDirectory("empty"));
var split = await new HomeLayoutMigration(options with { WorkspaceRoot = empty }).ApplyAsync(context.Cancellation);
Assert.True(split.Split);
Assert.True(WorkspaceHomes.IsSplitRoot(empty));
Assert.Equal(WorkspaceStore.FormatVersion, new WorkspaceStore(Path.Combine(empty, "local")).Manifest.FormatVersion);
}
}