using Chronos.Data.Projects; using System.IO; using Chronos.App.Editor; using Chronos.Core.Archiving; using Chronos.Core.Codecs.Jpeg; using Chronos.Core.Imaging; using Chronos.Core.Imaging.Decoders; using Chronos.Core.Localization; using Chronos.Core.Metadata; using Chronos.Core.Model; using Chronos.Core.Project; using Chronos.Data; using Chronos.Data.Archiving; using Chronos.Data.Jobs; using Chronos.Data.Processing; using Chronos.Data.Repositories; using Chronos.Testing; namespace Chronos.App.Tests.Editor; /// Project merges, and the local source over a real SQLite index and archive folder. public sealed class ProjectStoreTests(TestContext context) { [Test] public void AMemberOnlyTheyChangedIsKept() { var basis = new ProjectSettings(); var ours = basis with { Exposure = basis.Exposure with { ExposureOffsetEv = 0.5 } }; var theirs = basis with { HeroFrame = 12 }; var merged = ProjectMerge.Merge(basis, ours, theirs); Assert.Equal(0.5, merged.Exposure.ExposureOffsetEv); Assert.Equal(12, merged.HeroFrame); } [Test] public void AdviceMergesIntoAManualValueOfTheSameSetting() { var basis = new ProjectSettings(); var ours = basis with { Exposure = basis.Exposure with { Deflicker = basis.Exposure.Deflicker.WithManual(true) } }; var theirs = basis with { Exposure = basis.Exposure with { Deflicker = basis.Exposure.Deflicker.WithAdvice(false, "Advisor.Reason.Deflicker.Off") } }; var merged = ProjectMerge.Merge(basis, ours, theirs).Exposure.Deflicker; Assert.False(merged.IsAuto, "the user's manual choice stays"); Assert.True(merged.Manual); Assert.True(merged.HasAdvice, "the new advice is stored next to it"); Assert.Equal("Advisor.Reason.Deflicker.Off", merged.ReasonKey); } [Test] public void WhenBothChangedAValueTheEditorWins() { var basis = new ProjectSettings(); var merged = ProjectMerge.Merge(basis, basis with { HeroFrame = 3 }, basis with { HeroFrame = 9 }); Assert.Equal(3, merged.HeroFrame); } [Test] public async Task TheLocalSourceReadsDecodesSavesAndQueues() { var (db, sequenceId, root) = await ArchiveAsync(12); await using (db) { var options = new ArchiveServiceOptions { Owner = "test", LeaseWait = TimeSpan.FromSeconds(20) }; await using var source = new LocalSequenceSource(db, sequenceId, DecoderFactory.CreateClient(null), null, options); var content = await source.LoadAsync(context.Cancellation); Assert.Equal(12, content.Count); Assert.Equal(96, content.SourceWidth); Assert.Equal(64, content.SourceHeight); Assert.Null(content.Deep, "not analysed yet"); Assert.NotNull(content.ExportsFolder); Assert.Contains("exports", content.ExportsFolder!); using (var frame = await source.DecodeAsync(3, 32, DecodePurpose.Thumbnail, context.Cancellation)) { Assert.NotNull(frame); Assert.LessOrEqual(Math.Max(frame!.Width, frame.Height), 32); } Assert.Null(await source.DecodeAsync(99, 32, DecodePurpose.Thumbnail, context.Cancellation)); // A save writes project.json and the index row together. var edited = content.Project with { HeroFrame = 4, Exposure = content.Project.Exposure with { ExposureOffsetEv = 0.3 } }; var stored = await source.SaveProjectAsync(edited, content.Project, context.Cancellation); Assert.True(ProjectMerge.SameValues(edited, stored)); var projectPath = Path.Combine(root, "Synthetic", ".chronos", "project.json"); Assert.FileExists(projectPath); Assert.Equal(edited.ToJson(), File.ReadAllText(projectPath)); var row = await db.Sequences.GetAsync(sequenceId); Assert.Equal(edited.ToJson(), row!.SettingsJson); // Someone else changes the settings meanwhile (the server API): both edits survive the next save. var theirs = stored with { Camera = stored.Camera with { OffsetY = 0.25 } }; await db.Sequences.EditAsync(sequenceId, new SequenceEdit { SettingsJson = theirs.ToJson() }, row.SettingsVersion); var mine = stored with { HeroFrame = 7 }; var merged = await source.SaveProjectAsync(mine, stored, context.Cancellation); Assert.Equal(7, merged.HeroFrame); Assert.Equal(0.25, merged.Camera.OffsetY); Assert.Equal(merged.ToJson(), File.ReadAllText(projectPath)); Assert.Equal(merged.ToJson(), (await db.Sequences.GetAsync(sequenceId))!.SettingsJson); var reloaded = await source.LoadAsync(context.Cancellation); Assert.True(ProjectMerge.SameValues(merged, reloaded.Project), "the index copy is read back"); await Assert.ThrowsAsync(() => source.SubmitAsync(ProcessingJobs.DeepAnalysis([sequenceId]), context.Cancellation)); } } [Test] public async Task SetHeroReachesTheLibraryThumbnail() { var (db, sequenceId, root) = await ArchiveAsync(6); await using (db) { await using var source = new LocalSequenceSource(db, sequenceId, DecoderFactory.CreateClient(null), null, new ArchiveServiceOptions { Owner = "test", LeaseWait = TimeSpan.FromSeconds(20) }); var changed = new List(); source.HeroChanged += changed.Add; var content = await source.LoadAsync(context.Cancellation); var session = new EditorSession(source, content, [], TimeSpan.FromMilliseconds(20)); await using (session) { Assert.True(session.SetHero(4)); Assert.True(await session.FlushAsync()); Assert.Equal(content.Frames[4].Id, (await db.Sequences.GetAsync(sequenceId))!.HeroFrameId, "the index names the hero frame"); Assert.Equal(content.Frames[4].Id, Assert.Contains(changed, _ => true).HeroFrameId, "the Library is told"); session.Edit(p => p with { Exposure = p.Exposure with { ExposureOffsetEv = 0.2 } }); Assert.True(await session.FlushAsync()); Assert.Count(1, changed); Assert.True(session.Undo()); Assert.True(session.Undo()); Assert.True(await session.FlushAsync()); Assert.Null((await db.Sequences.GetAsync(sequenceId))!.HeroFrameId, "undoing Set hero brings back the first frame"); Assert.Count(2, changed); } // "Save both" copies kept by a sync conflict are listed with the sequence. File.WriteAllText(Path.Combine(root, "Synthetic", ".chronos", "project.this-pc-20261003-142200.json"), new ProjectSettings().ToJson()); Assert.Equal(new DateTime(2026, 10, 3, 14, 22, 0), Assert.Contains((await source.LoadAsync(context.Cancellation)).SavedCopies, _ => true).SavedAt); } } [Test] public async Task AnEditorOpenWhileEarlierPhotosArriveSavesOnTheFramesTheUserChose() { var (db, sequenceId, root) = await ArchiveAsync(10); await using (db) { var options = new ArchiveServiceOptions { Owner = "test", LeaseWait = TimeSpan.FromSeconds(20) }; await using var source = new LocalSequenceSource(db, sequenceId, DecoderFactory.CreateClient(null), null, options); var content = await source.LoadAsync(context.Cancellation); var session = new EditorSession(source, content, [], TimeSpan.FromMilliseconds(20)); await using (session) { Assert.True(session.SetExcluded([5], true)); Assert.True(session.SetHero(6)); Assert.True(await session.FlushAsync()); // Three photos taken before the others are found in the folder (a sync download, an import or a scan // inserts them the same way): the index moves the stored positions with their frames. await InsertEarlierAsync(db, root, content, options, 3); var moved = ProjectSettings.FromJson((await db.Sequences.GetAsync(sequenceId))!.SettingsJson!); Assert.SequenceEqual([8], moved.ExcludedFrames); Assert.Equal(9, moved.HeroFrame); // The editor still shows the ten frames it read; the user excludes the eighth of them. Assert.Equal(10, session.Content.Count); Assert.True(session.SetExcluded([7], true)); Assert.True(await session.FlushAsync()); Assert.Equal(13, session.Content.Count, "the frames were read again before the save"); Assert.SequenceEqual([8, 10], session.Project.ExcludedFrames); Assert.Equal(9, session.Project.HeroFrame); var row = (await db.Sequences.GetAsync(sequenceId))!; var stored = ProjectSettings.FromJson(row.SettingsJson!); var frames = session.Content.Frames; Assert.SequenceEqual([content.Frames[5].Id, content.Frames[7].Id], stored.ExcludedFrames.Select(i => frames[i].Id), "the photos the user chose"); Assert.Equal(content.Frames[6].Id, frames[stored.HeroFrame!.Value].Id); Assert.Equal(content.Frames[6].Id, row.HeroFrameId); Assert.Equal(row.SettingsJson, File.ReadAllText(Path.Combine(root, "Synthetic", ".chronos", "project.json"))); // Undo takes back the user's last step on the new frames too. Assert.True(session.Undo()); Assert.True(await session.FlushAsync()); Assert.SequenceEqual([8], ProjectSettings.FromJson((await db.Sequences.GetAsync(sequenceId))!.SettingsJson!).ExcludedFrames); } } } [Test] public async Task ARenderAfterEarlierPhotosArriveEmbedsTheFramesTheUserChose() { var (db, sequenceId, root) = await ArchiveAsync(10); await using (db) { var options = new ArchiveServiceOptions { Owner = "test", LeaseWait = TimeSpan.FromSeconds(20) }; await using var source = new LocalSequenceSource(db, sequenceId, DecoderFactory.CreateClient(null), null, options); var content = await source.LoadAsync(context.Cancellation); var session = new EditorSession(source, content, [], TimeSpan.FromMilliseconds(20)); await using (session) { Assert.True(session.SetExcluded([5], true)); Assert.True(await session.FlushAsync()); Assert.True(await source.FramesCurrentAsync(context.Cancellation)); // Earlier photos arrive while the editor is open; the user renders without another edit. await InsertEarlierAsync(db, root, content, options, 3); Assert.False(await source.FramesCurrentAsync(context.Cancellation)); await session.EnsureFramesAsync(context.Cancellation); var request = session.RenderRequests(session.Project.Export)[0]; Assert.True(await source.FramesCurrentAsync(context.Cancellation)); Assert.Equal(13, session.Content.Count); var embedded = ProjectSettings.FromJson(ProcessingJobs.ReadRender(request.ParametersJson).Parameters.SettingsJson!); Assert.SequenceEqual([content.Frames[5].Id], embedded.ExcludedFrames.Select(i => session.Content.Frames[i].Id), "the photo the user excluded"); } } } [Test] public async Task AnEditorOpenWhileAReorganizeMovesItsFolderSavesWhereTheSequenceIsNow() { var (db, sequenceId, root) = await ArchiveAsync(6); await using (db) { var options = new ArchiveServiceOptions { Owner = "test", LeaseWait = TimeSpan.FromSeconds(20) }; await using var source = new LocalSequenceSource(db, sequenceId, DecoderFactory.CreateClient(null), null, options); var content = await source.LoadAsync(context.Cancellation); var session = new EditorSession(source, content, [], TimeSpan.FromMilliseconds(20)); await using (session) { Assert.True(session.SetHero(2)); Assert.True(await session.FlushAsync()); // Only the folder template changed: the Reorganize moves the folder and keeps the frames version. var service = new ArchiveService(db, options); var plan = await service.PlanRenameAsync(content.Sequence.ArchiveId, [sequenceId], "Moved/{title}", null, context.Cancellation); await service.ApplyRenameAsync(plan, null, context.Cancellation); var moved = new ArchivePaths(root).Sequence(plan.Steps.Single().ToFolder); Assert.Equal(content.Sequence.FramesVersion, (await db.Sequences.GetAsync(sequenceId))!.FramesVersion); Assert.False(await source.FramesCurrentAsync(context.Cancellation), "the files are no longer where the editor read them"); session.Edit(p => p with { Exposure = p.Exposure with { ExposureOffsetEv = 0.4 } }); Assert.True(await session.FlushAsync()); var row = (await db.Sequences.GetAsync(sequenceId))!; Assert.Equal(0.4, ProjectSettings.FromJson(row.SettingsJson!).Exposure.ExposureOffsetEv); Assert.Equal(row.SettingsJson, File.ReadAllText(moved.ProjectPath), "the moved folder's project has the edit"); Assert.False(Directory.Exists(Path.Combine(root, "Synthetic")), "the folder it left is not created again"); Assert.True(await source.FramesCurrentAsync(context.Cancellation)); Assert.Equal(moved.Exports, session.Content.ExportsFolder); using var frame = await source.DecodeAsync(1, 32, DecodePurpose.Thumbnail, context.Cancellation); Assert.NotNull(frame, "the frames are read where they are now"); } } } [Test] public async Task ASaveThatDoesNotReachTheIndexThrows() { var (db, sequenceId, _) = await ArchiveAsync(4); await using (db) { await using var source = new LocalSequenceSource(db, sequenceId, DecoderFactory.CreateClient(null), null, new ArchiveServiceOptions { Owner = "test", LeaseWait = TimeSpan.FromSeconds(20) }); var content = await source.LoadAsync(context.Cancellation); Assert.True(await db.Sequences.DeleteAsync(sequenceId)); var gone = await Assert.ThrowsAsync(() => source.SaveProjectAsync(content.Project with { HeroFrame = 1 }, content.Project, context.Cancellation)); Assert.Equal(Loc.L("Editor.Error.Missing"), gone.Message, "the toast shows the editor's own sentence"); } } [Test] public async Task ASaveAfterAnotherIndexMovedTheFolderWritesNothing() { var (db, sequenceId, root) = await ArchiveAsync(4); await using (db) { await using var source = new LocalSequenceSource(db, sequenceId, DecoderFactory.CreateClient(null), null, new ArchiveServiceOptions { Owner = "test", LeaseWait = TimeSpan.FromSeconds(20) }); var content = await source.LoadAsync(context.Cancellation); // A server sharing the archive moved the folder; this index finds it there at its next scan. var left = Path.Combine(root, "Synthetic"); Directory.Move(left, Path.Combine(root, "Moved")); var gone = await Assert.ThrowsAsync(() => source.SaveProjectAsync(content.Project with { HeroFrame = 1 }, content.Project, context.Cancellation)); Assert.Equal(Loc.L("Editor.Error.Missing"), gone.Message); Assert.False(Directory.Exists(left), "the folder it left is not created again"); Assert.Equal(content.Sequence.SettingsVersion, (await db.Sequences.GetAsync(sequenceId))!.SettingsVersion, "nothing recorded"); } } [Test] public async Task ASaveNeverWritesIntoAnotherSequenceMovedIntoTheFolder() { var (db, sequenceId, root) = await ArchiveAsync(4); await using (db) { await using var source = new LocalSequenceSource(db, sequenceId, DecoderFactory.CreateClient(null), null, new ArchiveServiceOptions { Owner = "test", LeaseWait = TimeSpan.FromSeconds(20) }); var content = await source.LoadAsync(context.Cancellation); // A server sharing the archive moved the folder away, then another sequence into the folder it left; this index // finds both at its next scan. var paths = new ArchivePaths(root); Directory.Move(paths.Sequence("Synthetic").Folder, paths.Sequence("Moved").Folder); var stranger = paths.Sequence("Synthetic"); Directory.CreateDirectory(stranger.MetaDirectory); ManifestStore.WriteSequence(stranger.ManifestPath, ManifestStore.ReadSequence(paths.Sequence("Moved").ManifestPath) with { Id = Guid.NewGuid() }); const string theirs = """{"exposure":{"deflickerWindow":{"isAuto":false,"manual":7}}}"""; await File.WriteAllTextAsync(stranger.ProjectPath, theirs, context.Cancellation); var gone = await Assert.ThrowsAsync(() => source.SaveProjectAsync(content.Project with { HeroFrame = 1 }, content.Project, context.Cancellation)); Assert.Equal(Loc.L("Editor.Error.Missing"), gone.Message); Assert.Equal(theirs, await File.ReadAllTextAsync(stranger.ProjectPath, context.Cancellation), "the other sequence's project is untouched"); Assert.Equal(content.Sequence.SettingsVersion, (await db.Sequences.GetAsync(sequenceId))!.SettingsVersion, "nothing recorded"); } } [Test] public async Task JobsGoToTheEngine() { var (db, sequenceId, _) = await ArchiveAsync(4); await using (db) { await using var engine = new JobEngine(db, [], new JobEngineOptions { WorkerId = "test" }); await using var source = new LocalSequenceSource(db, sequenceId, DecoderFactory.CreateClient(null), engine); var content = await source.LoadAsync(context.Cancellation); var session = new EditorSession(source, content, []); var id = await session.SubmitAsync(session.AnalysisRequest(), context.Cancellation); var job = await db.Jobs.GetAsync(id); Assert.Equal(JobKind.DeepAnalyse, job!.Kind); Assert.Equal(JobState.Queued, job.State); Assert.SequenceEqual([sequenceId], job.TargetIds); } } [Test] public async Task AnUnreadableProjectIsReportedNotReplaced() { var (db, sequenceId, root) = await ArchiveAsync(4); await using (db) { var path = Path.Combine(root, "Synthetic", ".chronos", "project.json"); File.WriteAllText(path, "{ not json"); await using var source = new LocalSequenceSource(db, sequenceId, DecoderFactory.CreateClient(null), null); var unreadable = await Assert.ThrowsAsync(() => source.LoadAsync(context.Cancellation)); Assert.Equal(Loc.L("Editor.Error.Project"), unreadable.Message); Assert.Equal("{ not json", File.ReadAllText(path)); // A project written by a newer Chronos reads the same, not as the parser's English sentence. var newer = $"{{\"version\":{ProjectSettings.CurrentVersion + 1}}}"; File.WriteAllText(path, newer); Assert.Equal(Loc.L("Editor.Error.Project"), (await Assert.ThrowsAsync(() => source.LoadAsync(context.Cancellation))).Message); Assert.Equal(newer, File.ReadAllText(path)); } } /// /// Writes photos taken before the sequence's first frame into its folder and scans the /// archive: they are inserted in front, and the index moves the stored positions with their frames. /// private async Task InsertEarlierAsync(ChronosDatabase db, string root, SequenceContent content, ArchiveServiceOptions options, int count) { var sequence = EditorFixture.Sequence(count); var first = content.Frames[0].CapturedAt!.Value; for (var i = 0; i < count; i++) { using var image = sequence.Render(i); var exif = ExifWriter.BuildJpegApp1(sequence.Metadata[i] with { CapturedAt = first.AddMinutes(i - count) }); File.WriteAllBytes(Path.Combine(root, "Synthetic", $"EARLY_{i + 1}.JPG"), JpegEncoder.Encode(image, new JpegEncodeOptions { Quality = 90, App1Segments = [exif[4..]] })); } var archive = (await db.Archives.GetAsync(content.Sequence.ArchiveId, context.Cancellation))!; await new ArchiveService(db, options).Indexer.ScanAsync(archive, ScanMode.Full, null, _ => ValueTask.CompletedTask, context.Cancellation); } /// A temporary archive with one adopted folder of synthetic JPEGs, indexed. /// /// A decode superseded by a newer edit (R4, owner review 1): the caller sees a cancellation, never an unreadable frame, /// and the provider's cancellation stays inside the source's own task. /// [Test] public async Task ACancelledDecodeIsACancellationNotAnUnreadableFrame() { var (db, sequenceId, _) = await ArchiveAsync(4); await using (db) { var entered = new TaskCompletionSource(); var blocking = new ImageDecoder([new BlockingProvider(entered)]); var options = new ArchiveServiceOptions { Owner = "test", LeaseWait = TimeSpan.FromSeconds(20) }; await using var source = new LocalSequenceSource(db, sequenceId, blocking, null, options); await source.LoadAsync(context.Cancellation); using var cts = new CancellationTokenSource(); var decode = source.DecodeAsync(1, 64, DecodePurpose.Proxy, cts.Token).AsTask(); await entered.Task.WaitAsync(TimeSpan.FromSeconds(10)); await cts.CancelAsync(); await Assert.ThrowsAsync(() => decode); } } /// Decodes nothing until its token is cancelled, then throws the cancellation, as WIC does between bands. private sealed class BlockingProvider(TaskCompletionSource entered) : IImageDecoderProvider { public string Name => "blocking"; public DecodeTier? TierFor(ImageFileFormat format) => DecodeTier.Native; public DecodedImage? Decode(DecodeRequest request, CancellationToken cancellationToken = default) { entered.TrySetResult(); cancellationToken.WaitHandle.WaitOne(TimeSpan.FromSeconds(10)); cancellationToken.ThrowIfCancellationRequested(); return null; } } private async Task<(ChronosDatabase Db, Guid SequenceId, string Root)> ArchiveAsync(int frames) { var directory = context.CreateTempDirectory("editor"); var root = Path.Combine(directory, "archive"); var db = await ChronosDatabase.OpenAsync(DatabaseOptions.Sqlite(Path.Combine(directory, "index.db"))); var service = new ArchiveService(db, new ArchiveServiceOptions { Owner = "test", LeaseWait = TimeSpan.FromSeconds(20) }); var archive = await service.CreateAsync(root, "Test"); var sequence = EditorFixture.Sequence(frames); 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 service.Indexer.ScanAsync(archive, ScanMode.Full, null, _ => ValueTask.CompletedTask, context.Cancellation); var location = (await db.Sequences.ListLocationsAsync(archive.Id, context.Cancellation)).Single(); return (db, location.Id, root); } }