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; /// Projects of a sequence with this PC's archive as their home (owner review 2, R8): sidecars, index, Main mirror, push. [Category("projects")] public abstract class ProjectServiceTests(TestContext context) : DatabaseTest(context) { internal async Task FixtureAsync() => Own(await CreateAsync(Context, database: await NewOptionsAsync(multiConnection: true))); /// A sequence of uploaded photos (hashed), ten seconds apart. internal static async Task<(Sequence Sequence, List 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 frames) => new(frames.Select(f => (f.Index, new FramePhoto(f.Sha256, f.Size, f.CapturedAt)))); /// The sequence's settings written as an older code path writes them (the editor, an analysis): index first, with its version check. internal static async Task 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!; } /// A version made from with (positions on ), as a workspace sends it. internal static ProjectVersion Draft(ProjectVersion parent, ProjectSettings settings, IEnumerable 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); Assert.Equal(after.SettingsJson, File.ReadAllText(fx.Paths.Sequence(sequence.Folder).ProjectPath)); 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(() => projects.CreateAsync(sequence.Id, "VERTICAL SOCIAL", cancellationToken: fx.Ct))).Reason); Assert.Equal(ProjectError.InvalidName, (await Assert.ThrowsAsync(() => 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(() => 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(() => 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().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 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(() => 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 moved = "2026/Moved " + Guid.NewGuid().ToString("N")[..6]; Directory.CreateDirectory(Path.GetDirectoryName(fx.Paths.Sequence(moved).Folder)!); Directory.Move(fx.Paths.Sequence(sequence.Folder).Folder, fx.Paths.Sequence(moved).Folder); await fx.Db.Sequences.RelocateAsync(sequence.Id, moved, sequence.Title, fx.Ct); 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(moved).VersionPath(main.Id, 2, pushed.Version!.Id)); } } 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; }