feat: owner review 2 phase 5a: workspace and projects with a local home (#14)
CI / Build and test (push) Successful in 9m43s
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 27s
CI / PostgreSQL 16 integration (push) Failing after 8m41s
CI / PostgreSQL 17 integration (push) Successful in 12m37s
CI / Docker image (push) Successful in 56s
Release / Build, test and publish (push) Successful in 14m59s
Release / Server image (push) Successful in 1m51s

Edit opens a sequence as a project of a workspace folder outside the library. Projects have linear version histories kept as sidecars in .chronos/projects/, Main mirrors the sequence's settings, and sync merges setting by setting. Migration 0009, JobKind.WorkspaceCopy = 20, Settings › Workspace, and 241 new strings in 38 languages.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-authored-by: Alberto Balbo <alberto.balbo.96@gmail.com>
This commit was merged in pull request #14.
This commit is contained in:
Alby96andClaude Opus 5.5 authored and Alby96 committed 2026-11-04 09:22:08 +01:00
1 parent efa87f68ce
commit 9b24cf74fc
370 files changed
+29237 -287

No files matched your search

@@ -0,0 +1,469 @@
using Chronos.Core.Archiving;
using Chronos.Core.Model;
using Chronos.Core.Project;
using Chronos.Data.Archiving;
using Chronos.Data.Projects;
using Chronos.Data.Repositories;
using Chronos.Data.Tests.Archiving;
using Chronos.Data.Tests.Infrastructure;
using Chronos.Testing;
using static Chronos.Data.Tests.Archiving.ArchiveFixture;
namespace Chronos.Data.Tests.Projects;
/// <summary>Projects of a sequence with this PC's archive as their home (owner review 2, R8): sidecars, index, Main mirror, push.</summary>
[Category("projects")]
public abstract class ProjectServiceTests(TestContext context) : DatabaseTest(context)
{
internal async Task<ArchiveFixture> FixtureAsync() => Own(await CreateAsync(Context, database: await NewOptionsAsync(multiConnection: true)));
/// <summary>A sequence of <paramref name="count"/> uploaded photos (hashed), ten seconds apart.</summary>
internal static async Task<(Sequence Sequence, List<Frame> Frames)> UploadedAsync(ArchiveFixture fx, int count, int seed = 100)
{
Guid? id = null;
for (var i = 0; i < count; i++)
{
var (path, size, sha) = fx.Stage(Start.AddSeconds(10 * i), seed + i);
var result = await fx.Service.Ingest.CommitAsync(new IngestRequest(fx.Archive.Id, id, null, id is null ? $"upload-{seed}" : null, path,
$"IMG_{i + 1:0000}.JPG", size, sha, null, null), fx.Ct);
id = result.SequenceId;
}
return ((await fx.Db.Sequences.GetAsync(id!.Value))!, [.. await fx.Db.Frames.ListBySequenceAsync(id.Value)]);
}
internal static FramePhotos Photos(IEnumerable<Frame> frames) => new(frames.Select(f => (f.Index, new FramePhoto(f.Sha256, f.Size, f.CapturedAt))));
/// <summary>
/// The files of the frames at <paramref name="indices"/> replaced by other encodings, as a Replace conversion does (owner
/// review 2, R7, <see cref="FrameTrash.ReplaceAsync"/>): the same frames, other files and SHA-256.
/// </summary>
internal static async Task ConvertAsync(ArchiveFixture fx, Guid sequenceId, IReadOnlyList<int> indices, int seed)
{
var sequence = (await fx.Db.Sequences.GetAsync(sequenceId))!;
var manifest = ManifestStore.ReadSequence(fx.Paths.Sequence(sequence.Folder).ManifestPath);
var staging = Path.Combine(fx.Paths.StagingDirectory, "convert-test");
Directory.CreateDirectory(staging);
var swaps = new List<FrameSwap>();
foreach (var i in indices)
{
var frame = manifest.Frames[i];
var bytes = Chronos.Data.Tests.Archiving.Photos.Jpeg(frame.CapturedAt, seed + i);
var path = Path.Combine(staging, $"{Guid.NewGuid():N}.jpeg");
File.WriteAllBytes(path, bytes);
var sha = Convert.ToHexStringLower(System.Security.Cryptography.SHA256.HashData(bytes));
swaps.Add(new FrameSwap(frame.Id, fx.Paths.ToRelative(path), [], (current, _) => Path.ChangeExtension(current.File, ".jpeg"), current => current with
{
Sha256 = sha,
Size = bytes.Length,
Source = new FrameSource { Sha256 = current.Sha256, Format = current.Format, File = current.File, Size = current.Size },
}));
}
Assert.NotNull(await fx.Service.FrameTrash.ReplaceAsync(fx.Archive, sequenceId, null, swaps, null, null, null, null, fx.Ct));
}
/// <summary>The sequence's settings written as an older code path writes them (the editor, an analysis): index first, with its version check.</summary>
internal static async Task<Sequence> WriteSettingsAsync(ArchiveFixture fx, Guid sequenceId, ProjectSettings settings)
{
var row = (await fx.Db.Sequences.GetAsync(sequenceId))!;
var result = await fx.Db.Sequences.EditAsync(sequenceId, new SequenceEdit { SettingsJson = settings.ToJson() }, row.SettingsVersion, fx.Ct);
Assert.Equal(SequenceEditOutcome.Updated, result.Outcome);
return result.Sequence!;
}
/// <summary>A version made from <paramref name="parent"/> with <paramref name="settings"/> (positions on <paramref name="frames"/>), as a workspace sends it.</summary>
internal static ProjectVersion Draft(ProjectVersion parent, ProjectSettings settings, IEnumerable<Frame> frames, string? note = null)
{
var portable = ProjectContent.ToPortable(settings, Photos(frames));
return new ProjectVersion
{
Id = Guid.CreateVersion7(),
ProjectId = parent.ProjectId,
ParentId = parent.Id,
Number = parent.Number + 1,
Kind = ProjectVersionKind.Commit,
Author = "alberto",
ClientName = "test",
Note = note,
SettingsJson = portable,
ContentHash = ProjectContent.Hash(portable),
FramesVersion = parent.FramesVersion,
CreatedAt = DateTimeOffset.UtcNow,
};
}
[Test]
public async Task MainIsMadeFromTheSequenceSettingsWithItsPositionsParkedByPhoto()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 5);
await WriteSettingsAsync(fx, sequence.Id, new ProjectSettings { ExcludedFrames = [1], HeroFrame = 3 });
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
Assert.True(main.IsMain);
Assert.Equal((ProjectService.MainName, 1), (main.Name, main.HeadNumber));
var head = await projects.HeadAsync(main.Id, fx.Ct);
Assert.Equal(ProjectVersionKind.Imported, head.Kind);
Assert.True(ProjectContent.Verifies(head.SettingsJson, head.ContentHash));
var portable = ProjectSettings.FromJson(head.SettingsJson);
Assert.Empty(portable.ExcludedFrames);
Assert.Null(portable.HeroFrame);
Assert.Equal(2, portable.PendingFrames!.Count);
var placed = ProjectSettings.FromJson(ProjectContent.Place(head.SettingsJson, Photos(frames)));
Assert.SequenceEqual([1], placed.ExcludedFrames);
Assert.Equal(3, placed.HeroFrame);
// The sidecars hold it: the record and an immutable version file.
var folder = fx.Paths.Sequence(sequence.Folder);
var record = ProjectSidecars.ReadRecord(folder.ProjectRecordPath(main.Id));
Assert.Equal((main.Id, sequence.Id, true, head.Id, 1), (record.Id, record.SequenceId, record.IsMain, record.Head!.Id, record.Head.Number));
Assert.Equal(head.SettingsJson, ProjectSidecars.ReadVersion(folder.VersionPath(main.Id, 1, head.Id)).SettingsJson);
// Asking again makes nothing new.
Assert.Equal(main.Id, (await projects.MainAsync(sequence.Id, fx.Ct)).Id);
Assert.Count(1, await projects.ListAsync(sequence.Id, fx.Ct));
Assert.Count(1, await projects.HistoryAsync(main.Id, cancellationToken: fx.Ct));
}
[Test]
public async Task APushFastForwardsAndMirrorsMainIntoTheSequence()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 5);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var head = await projects.HeadAsync(main.Id, fx.Ct);
var before = (await fx.Db.Sequences.GetAsync(sequence.Id))!;
var draft = Draft(head, new ProjectSettings { ExcludedFrames = [0, 4], HeroFrame = 2, Exposure = new ExposureSettings { ExposureOffsetEv = 0.7 } }, frames,
"first look");
var result = await projects.PushAsync(main.Id, draft, fx.Ct);
Assert.Equal(PushOutcome.Stored, result.Outcome);
var stored = Assert.NotNull(result.Version);
Assert.Equal((draft.Id, 2, "first look"), (stored.Id, stored.Number, stored.Note));
Assert.NotNull(stored.StoredAt);
Assert.Equal(stored.Id, (await projects.HeadAsync(main.Id, fx.Ct)).Id);
Assert.SequenceEqual([2, 1], (await projects.HistoryAsync(main.Id, cancellationToken: fx.Ct)).Select(v => v.Number));
Assert.FileExists(fx.Paths.Sequence(sequence.Folder).VersionPath(main.Id, 2, draft.Id));
// Main's head is the sequence's settings, positions on its frames, through the settings version check.
var after = (await fx.Db.Sequences.GetAsync(sequence.Id))!;
Assert.Greater(after.SettingsVersion, before.SettingsVersion);
var mirrored = ProjectSettings.FromJson(after.SettingsJson!);
Assert.SequenceEqual([0, 4], mirrored.ExcludedFrames);
Assert.Equal(0.7, mirrored.Exposure.ExposureOffsetEv);
Assert.Equal(frames[2].Id, after.HeroFrameId);
// PostgreSQL stores the settings as jsonb, which reorders keys: compare the JSON, not the text.
Assert.True(System.Text.Json.Nodes.JsonNode.DeepEquals(System.Text.Json.Nodes.JsonNode.Parse(after.SettingsJson!),
System.Text.Json.Nodes.JsonNode.Parse(File.ReadAllText(fx.Paths.Sequence(sequence.Folder).ProjectPath))), "project.json mirrors Main's head");
var row = (await fx.Db.Projects.GetAsync(main.Id))!;
Assert.Equal((stored.Id, after.SettingsVersion), (row.MirroredVersionId, row.MirroredSettingsVersion));
// The mirror is no outside change: no version is added for it.
Assert.Equal(2, (await projects.HeadAsync(main.Id, fx.Ct)).Number);
}
[Test]
public async Task APushIsIdempotentDivergesFromAnOldParentAndChecksItsHash()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var first = await projects.HeadAsync(main.Id, fx.Ct);
var draft = Draft(first, new ProjectSettings { Stack = new StackSettings { Mode = StackSetting.Median } }, frames);
Assert.Equal(PushOutcome.Stored, (await projects.PushAsync(main.Id, draft, fx.Ct)).Outcome);
var again = await projects.PushAsync(main.Id, draft, fx.Ct);
Assert.Equal((PushOutcome.AlreadyStored, 2), (again.Outcome, again.Version!.Number));
Assert.Equal(2, (await projects.HistoryAsync(main.Id, cancellationToken: fx.Ct)).Count);
var late = Draft(first, new ProjectSettings { Stack = new StackSettings { Mode = StackSetting.Mean } }, frames);
var diverged = await projects.PushAsync(main.Id, late, fx.Ct);
Assert.Equal(PushOutcome.Diverged, diverged.Outcome);
Assert.Equal(draft.Id, diverged.Head!.Id);
var head = diverged.Head;
var damaged = Draft(head, new ProjectSettings(), frames) with { ContentHash = new string('f', 64) };
Assert.Equal(PushOutcome.HashMismatch, (await projects.PushAsync(main.Id, damaged, fx.Ct)).Outcome);
var positional = new ProjectSettings { ExcludedFrames = [1] }.ToJson();
var notPortable = Draft(head, new ProjectSettings(), frames) with { SettingsJson = positional, ContentHash = ProjectContent.Hash(positional) };
Assert.Equal(PushOutcome.Invalid, (await projects.PushAsync(main.Id, notPortable, fx.Ct)).Outcome);
var newer = """{ "version": 9 }""";
Assert.Equal(PushOutcome.NewerFormat,
(await projects.PushAsync(main.Id, Draft(head, new ProjectSettings(), frames) with { SettingsJson = newer, ContentHash = ProjectContent.Hash(newer) }, fx.Ct)).Outcome);
Assert.Equal(2, (await projects.HeadAsync(main.Id, fx.Ct)).Number);
}
[Test]
public async Task SettingsAnotherPathWritesBecomeAnExternalVersionOfMain()
{
var fx = await FixtureAsync();
var (sequence, _) = await UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
// The editor's old path (or an analysis, or the server's API) writes the settings.
await WriteSettingsAsync(fx, sequence.Id, new ProjectSettings { ExcludedFrames = [2], Exposure = new ExposureSettings { ExposureOffsetEv = -0.3 } });
var history = await projects.HistoryAsync(main.Id, cancellationToken: fx.Ct);
Assert.Equal((2, ProjectVersionKind.External), (history[0].Number, history[0].Kind));
Assert.Equal(history[1].Id, history[0].ParentId);
Assert.Equal(-0.3, ProjectSettings.FromJson(history[0].SettingsJson).Exposure.ExposureOffsetEv);
// A title or tags edit moves the settings version too, but not the settings: nothing is added.
await fx.Db.Sequences.SetTagsAsync(sequence.Id, ["harbour"], fx.Ct);
Assert.Equal(2, (await projects.HistoryAsync(main.Id, cancellationToken: fx.Ct)).Count);
}
[Test]
public async Task AMirrorACrashCutShortIsCompletedAndOneRacedByAnEditIsMerged()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 4);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var first = await projects.HeadAsync(main.Id, fx.Ct);
var pushed = (await projects.PushAsync(main.Id, Draft(first, new ProjectSettings { Stack = new StackSettings { Mode = StackSetting.Median } }, frames),
fx.Ct)).Version!;
// As if the push had stopped before its mirror: the sequence still holds version 1, mirrored at its settings version.
var reverted = await WriteSettingsAsync(fx, sequence.Id, new ProjectSettings());
await fx.Db.Projects.SetMirroredAsync(main.Id, first.Id, reverted.SettingsVersion, fx.Ct);
Assert.Equal(pushed.Id, (await projects.HeadAsync(main.Id, fx.Ct)).Id);
var completed = (await fx.Db.Sequences.GetAsync(sequence.Id))!;
Assert.Equal(StackSetting.Median, ProjectSettings.FromJson(completed.SettingsJson!).Stack.Mode);
// Again, but someone wrote other settings meanwhile: both changes are kept in a merge version.
await WriteSettingsAsync(fx, sequence.Id, new ProjectSettings());
await fx.Db.Projects.SetMirroredAsync(main.Id, first.Id, completed.SettingsVersion, fx.Ct);
await WriteSettingsAsync(fx, sequence.Id, new ProjectSettings { Exposure = new ExposureSettings { ExposureOffsetEv = 1.25 } });
var merge = await projects.HeadAsync(main.Id, fx.Ct);
Assert.Equal((ProjectVersionKind.Merge, pushed.Id), (merge.Kind, merge.ParentId));
var merged = ProjectSettings.FromJson((await fx.Db.Sequences.GetAsync(sequence.Id))!.SettingsJson!);
Assert.Equal((StackSetting.Median, 1.25), (merged.Stack.Mode, merged.Exposure.ExposureOffsetEv));
}
[Test]
public async Task ProjectsAreNamedOnceDeletedIntoTheirTrashAndMainStays()
{
var fx = await FixtureAsync();
var (sequence, _) = await UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var mainHead = await projects.HeadAsync(main.Id, fx.Ct);
var vertical = await projects.CreateAsync(sequence.Id, " Vertical social ", author: "alberto", cancellationToken: fx.Ct);
Assert.Equal(("Vertical social", false, 1), (vertical.Name, vertical.IsMain, vertical.HeadNumber));
var copy = await projects.HeadAsync(vertical.Id, fx.Ct);
Assert.Equal((ProjectVersionKind.Imported, mainHead.ContentHash), (copy.Kind, copy.ContentHash));
Assert.Equal(ProjectError.NameTaken,
(await Assert.ThrowsAsync<ProjectException>(() => projects.CreateAsync(sequence.Id, "VERTICAL SOCIAL", cancellationToken: fx.Ct))).Reason);
Assert.Equal(ProjectError.InvalidName, (await Assert.ThrowsAsync<ProjectException>(() => projects.CreateAsync(sequence.Id, " ", cancellationToken: fx.Ct))).Reason);
var landscape = await projects.CreateAsync(sequence.Id, "4K landscape", copy.Id, cancellationToken: fx.Ct);
Assert.Equal(ProjectError.NameTaken, (await Assert.ThrowsAsync<ProjectException>(() => projects.RenameAsync(landscape.Id, "Main", fx.Ct))).Reason);
landscape = await projects.RenameAsync(landscape.Id, "4K wide", fx.Ct);
Assert.Equal("4K wide", ProjectSidecars.ReadRecord(fx.Paths.Sequence(sequence.Folder).ProjectRecordPath(landscape.Id)).Name);
Assert.SequenceEqual(["Main", "Vertical social", "4K wide"], (await projects.ListAsync(sequence.Id, fx.Ct)).Select(p => p.Name));
Assert.Equal(ProjectError.MainCannotBeDeleted, (await Assert.ThrowsAsync<ProjectException>(() => projects.DeleteAsync(main.Id, fx.Ct))).Reason);
await projects.DeleteAsync(vertical.Id, fx.Ct);
var folder = fx.Paths.Sequence(sequence.Folder);
Assert.False(Directory.Exists(folder.ProjectDirectory(vertical.Id)));
var trashed = Directory.GetDirectories(folder.ProjectsTrashDirectory).Single();
Assert.True(Path.GetFileName(trashed).StartsWith(vertical.Id.ToString("N"), StringComparison.Ordinal));
Assert.NotNull(ProjectSidecars.ReadRecord(Path.Combine(trashed, "project.json")).Deleted);
Assert.SequenceEqual(["Main", "4K wide"], (await projects.ListAsync(sequence.Id, fx.Ct)).Select(p => p.Name));
// Its name is free again.
await projects.CreateAsync(sequence.Id, "Vertical social", cancellationToken: fx.Ct);
}
[Test]
public async Task AnIndexRebuiltFromTheSidecarsHasEveryProjectAndVersionBack()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 4);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var mainPush = (await projects.PushAsync(main.Id, Draft(await projects.HeadAsync(main.Id, fx.Ct), new ProjectSettings { ExcludedFrames = [3] }, frames),
fx.Ct)).Version!;
var vertical = await projects.CreateAsync(sequence.Id, "Vertical", cancellationToken: fx.Ct);
var verticalPush = (await projects.PushAsync(vertical.Id,
Draft(await projects.HeadAsync(vertical.Id, fx.Ct), new ProjectSettings { Camera = new CameraSettings { Aspect = new Auto<string>().WithManual("9:16") } }, frames),
fx.Ct)).Version!;
var gone = await projects.CreateAsync(sequence.Id, "Old", cancellationToken: fx.Ct);
await projects.DeleteAsync(gone.Id, fx.Ct);
await fx.ReopenWithEmptyIndexAsync();
await fx.ScanAsync(ScanMode.Rebuild);
var rebuilt = fx.Service.Projects;
var listed = await rebuilt.ListAsync(sequence.Id, fx.Ct);
Assert.SequenceEqual([main.Id, vertical.Id], listed.Select(p => p.Id));
Assert.Equal((mainPush.Id, 2), (listed[0].HeadVersionId, listed[0].HeadNumber));
Assert.Equal((verticalPush.Id, 2), (listed[1].HeadVersionId, listed[1].HeadNumber));
Assert.Equal(verticalPush.SettingsJson, (await rebuilt.GetVersionAsync(verticalPush.Id, fx.Ct))!.SettingsJson);
Assert.NotNull((await fx.Db.Projects.GetAsync(gone.Id))!.DeletedAt);
// The sequence's settings are Main's head: the rebuilt index recognises the mirror and adds no version.
Assert.SequenceEqual([2, 1], (await rebuilt.HistoryAsync(main.Id, cancellationToken: fx.Ct)).Select(v => v.Number));
Assert.Equal(mainPush.Id, (await fx.Db.Projects.GetAsync(main.Id))!.MirroredVersionId);
}
[Test]
public async Task AProjectTheIndexDoesNotKnowYetIsFoundInItsSidecarsThroughItsHome()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 3);
var vertical = await fx.Service.Projects.CreateAsync(sequence.Id, "Vertical", cancellationToken: fx.Ct);
var head = (await fx.Service.Projects.PushAsync(vertical.Id,
Draft(await fx.Service.Projects.HeadAsync(vertical.Id, fx.Ct), new ProjectSettings { ExcludedFrames = [1] }, frames), fx.Ct)).Version!;
// An index taken back from an older backup (or a sequence back from the trash) holds the sequence, not its projects yet:
// a workspace that has one checked out still finds it, and its versions.
await fx.ReopenWithEmptyIndexAsync();
await fx.ScanAsync();
Assert.Null(await fx.Db.Projects.GetAsync(vertical.Id));
var version = await new ArchiveProjectHome(fx.Db, fx.Service.Projects, sequence.Id).GetVersionAsync(vertical.Id, head.Id, fx.Ct);
Assert.Equal(head.ContentHash, Assert.NotNull(version).ContentHash);
await fx.ReopenWithEmptyIndexAsync();
await fx.ScanAsync();
var home = new ArchiveProjectHome(fx.Db, fx.Service.Projects, sequence.Id);
Assert.Equal(head.Id, (await home.HeadAsync(vertical.Id, fx.Ct)).Id);
// A project of another sequence is still none of this home's.
var other = (await UploadedAsync(fx, 1, seed: 300)).Sequence;
var square = await fx.Service.Projects.CreateAsync(other.Id, "Square", cancellationToken: fx.Ct);
Assert.Equal(ProjectError.NotFound, (await Assert.ThrowsAsync<ProjectException>(() => home.HeadAsync(square.Id, fx.Ct))).Reason);
Assert.Null(await home.GetVersionAsync(square.Id, head.Id, fx.Ct));
}
[Test]
public async Task AVersionFileAPushLeftBehindItsRecordIsAdoptedAndAStrayOneSetAside()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var vertical = await projects.CreateAsync(sequence.Id, "Vertical", cancellationToken: fx.Ct);
var head = await projects.HeadAsync(vertical.Id, fx.Ct);
var folder = fx.Paths.Sequence(sequence.Folder);
// A push that wrote its version file and stopped before the record: the file follows the head.
var follower = Draft(head, new ProjectSettings { Stack = new StackSettings { Mode = StackSetting.StarTrails } }, frames) with { StoredAt = DateTimeOffset.UtcNow };
ProjectSidecars.WriteVersion(folder.VersionPath(vertical.Id, 2, follower.Id), follower);
// And a file past the head that follows nothing.
var stray = Draft(head, new ProjectSettings(), frames) with { Number = 5, ParentId = Guid.CreateVersion7(), StoredAt = DateTimeOffset.UtcNow };
ProjectSidecars.WriteVersion(folder.VersionPath(vertical.Id, 5, stray.Id), stray);
Assert.Equal(follower.Id, (await projects.HeadAsync(vertical.Id, fx.Ct)).Id);
Assert.Equal(follower.Id, ProjectSidecars.ReadRecord(folder.ProjectRecordPath(vertical.Id)).Head!.Id);
Assert.False(File.Exists(folder.VersionPath(vertical.Id, 5, stray.Id)));
Assert.Count(1, Directory.GetFiles(Path.Combine(folder.ProjectVersionsDirectory(vertical.Id), ".stray")));
// A version file is immutable: another version at its name is refused.
Assert.Throws<IOException>(() => ProjectSidecars.WriteVersion(folder.VersionPath(vertical.Id, 2, follower.Id), follower with { ContentHash = stray.ContentHash }));
}
[Test]
public async Task AReadWhileAnotherWriterHoldsTheSequenceAnswersFromTheIndex()
{
var fx = await FixtureAsync();
var (sequence, _) = await UploadedAsync(fx, 2);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
using (Assert.NotNull(LeaseFile.TryAcquire(fx.Paths.LocksDirectory, $"seq-{sequence.Id:N}", "another process")))
{
var watch = System.Diagnostics.Stopwatch.StartNew();
Assert.Equal(main.Id, (await projects.ListAsync(sequence.Id, fx.Ct)).Single().Id);
Assert.Equal(main.HeadVersionId, (await projects.HeadAsync(main.Id, fx.Ct)).Id);
// Each read waits a moment for the lease, never the writers' whole wait.
Assert.Less(watch.Elapsed.TotalSeconds, TestTiming.Budget(15));
}
}
[Test]
public async Task AReorganizedSequenceKeepsItsProjects()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 3);
var projects = fx.Service.Projects;
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var vertical = await projects.CreateAsync(sequence.Id, "Vertical", cancellationToken: fx.Ct);
// A Reorganize (phase 4a) moves the whole folder under the sequence's lease: the projects' sidecars go with it.
var plan = await fx.Service.Renamer.PlanAsync(fx.Archive, [sequence.Id], "Moved/{title}", null, fx.Ct);
await fx.Service.Renamer.ApplyAsync(fx.Archive, plan, cancellationToken: fx.Ct);
var reorganized = (await fx.Db.Sequences.GetAsync(sequence.Id))!;
Assert.NotEqual(sequence.Folder, reorganized.Folder);
Assert.FileExists(fx.Paths.Sequence(reorganized.Folder).ProjectRecordPath(vertical.Id));
Assert.SequenceEqual([main.Id, vertical.Id], (await projects.ListAsync(sequence.Id, fx.Ct)).Select(p => p.Id));
var pushed = await projects.PushAsync(main.Id, Draft(await projects.HeadAsync(main.Id, fx.Ct), new ProjectSettings { ExcludedFrames = [1] }, frames), fx.Ct);
Assert.Equal(PushOutcome.Stored, pushed.Outcome);
Assert.FileExists(fx.Paths.Sequence(reorganized.Folder).VersionPath(main.Id, 2, pushed.Version!.Id));
// Another index of the archive moved it away: until this index finds it there, its projects are read from the index (none
// taken for gone) and nothing is written where it was, which is never made again. A workspace hears its home is out of
// reach for now, and reads its head from the index meanwhile.
var away = "2026/Away " + Guid.NewGuid().ToString("N")[..6];
Directory.CreateDirectory(Path.GetDirectoryName(fx.Paths.Sequence(away).Folder)!);
Directory.Move(fx.Paths.Sequence(reorganized.Folder).Folder, fx.Paths.Sequence(away).Folder);
Assert.SequenceEqual([main.Id, vertical.Id], (await projects.ListAsync(sequence.Id, fx.Ct)).Select(p => p.Id));
var head = await projects.HeadAsync(main.Id, fx.Ct);
await Assert.ThrowsAsync<SequenceFolderMovedException>(() => projects.PushAsync(main.Id, Draft(head, new ProjectSettings { ExcludedFrames = [2] }, frames), fx.Ct));
var home = new ArchiveProjectHome(fx.Db, projects, sequence.Id);
await Assert.ThrowsAsync<HomeUnavailableException>(() => home.PushAsync(main.Id, Draft(head, new ProjectSettings { ExcludedFrames = [2] }, frames), fx.Ct));
await Assert.ThrowsAsync<HomeUnavailableException>(() => home.CreateAsync("Square", null, null, fx.Ct));
Assert.Equal(head.Id, (await home.HeadAsync(main.Id, fx.Ct)).Id);
Assert.False(Directory.Exists(fx.Paths.Sequence(reorganized.Folder).Folder));
// Another sequence moved into the folder it left is no home of its projects either: none is read from it or written there.
var other = (await UploadedAsync(fx, 1, seed: 300)).Sequence;
Directory.Move(fx.Paths.Sequence(other.Folder).Folder, fx.Paths.Sequence(reorganized.Folder).Folder);
await Assert.ThrowsAsync<SequenceFolderMovedException>(() => projects.RenameAsync(vertical.Id, "Vertical 2", fx.Ct));
Assert.False(Directory.Exists(fx.Paths.Sequence(reorganized.Folder).ProjectsDirectory));
Assert.SequenceEqual([main.Id, vertical.Id], (await projects.ListAsync(sequence.Id, fx.Ct)).Select(p => p.Id));
await fx.Db.Sequences.RelocateAsync(sequence.Id, away, reorganized.Title, fx.Ct);
Assert.Equal(PushOutcome.Stored, (await projects.PushAsync(main.Id, Draft(head, new ProjectSettings { ExcludedFrames = [2] }, frames), fx.Ct)).Outcome);
Assert.Null((await projects.GetAsync(vertical.Id, fx.Ct))!.DeletedAt);
}
[Test]
public async Task AVersionKeepsItsPositionsWhenItsPhotosAreConverted()
{
var fx = await FixtureAsync();
var (sequence, frames) = await UploadedAsync(fx, 4);
var projects = fx.Service.Projects;
await WriteSettingsAsync(fx, sequence.Id, new ProjectSettings { ExcludedFrames = [1], HeroFrame = 2 });
var main = await projects.MainAsync(sequence.Id, fx.Ct);
var head = await projects.HeadAsync(main.Id, fx.Ct);
// A Replace conversion (phase 4b) gives frames 1 and 2 other files: the same frames, other SHA-256.
await ConvertAsync(fx, sequence.Id, [1, 2], 700);
var home = await projects.FramesAsync(sequence.Id, fx.Ct);
Assert.NotEqual(frames[1].Sha256, home.Frames[1].Sha256);
Assert.Equal(frames[1].Id, home.Frames[1].Id);
// The version parked the photos as they were: it still names the converted frames.
var placed = ProjectSettings.FromJson(ProjectContent.Place(head.SettingsJson, home.Photos));
Assert.SequenceEqual([1], placed.ExcludedFrames);
Assert.Equal((int?)2, placed.HeroFrame);
// The sequence's settings written again with the same choices are no outside change: Main keeps its head.
var row = (await fx.Db.Sequences.GetAsync(sequence.Id))!;
await WriteSettingsAsync(fx, sequence.Id, ProjectSettings.FromJson(row.SettingsJson!));
Assert.Equal(head.Id, (await projects.HeadAsync(main.Id, fx.Ct)).Id);
// A version pushed on top of it is mirrored onto the converted frames.
var pushed = await projects.PushAsync(main.Id, Draft(head, new ProjectSettings { ExcludedFrames = [1, 3], HeroFrame = 2 }, home.Frames), fx.Ct);
Assert.Equal(PushOutcome.Stored, pushed.Outcome);
var mirrored = ProjectSettings.FromJson((await fx.Db.Sequences.GetAsync(sequence.Id))!.SettingsJson!);
Assert.SequenceEqual([1, 3], mirrored.ExcludedFrames);
Assert.Equal((int?)2, mirrored.HeroFrame);
}
}
public sealed class SqliteProjectServiceTests(TestContext context) : ProjectServiceTests(context)
{
protected override Backend Backend => Backend.SqliteFile;
}
[RequiresEnvironment(PgTestServer.Variable)]
public sealed class PostgresProjectServiceTests(TestContext context) : ProjectServiceTests(context)
{
protected override Backend Backend => Backend.Postgres;
}