using Titano.Core.Archiving; using Titano.Core.Diagnostics.Synthetic; using Titano.Core.Import; using Titano.Core.Model; using Titano.Core.Project; using Titano.Data.Archiving; using Titano.Data.Tests.Archiving; using Titano.Testing; namespace Titano.Data.Tests.Processing; /// New sequences get their light analysis (and so their Auto values) without any user action (BRIEF ยง1.1). [Category("processing")] public sealed class AnalysisFollowUpTests(TestContext context) { [Test] public async Task AnAdoptingScanQueuesLightAnalysisOfTheNewSequencesOnly() { await using var fx = await ProcessingFixture.CreateAsync(context); fx.Write(SyntheticSequence.Create(new SyntheticSequenceOptions { FrameCount = 12 }), "Roof"); await fx.StartEngineAsync(withArchive: true); var scan = await fx.EnqueueAsync(ArchiveJobs.Scan(fx.Archive.Archive, full: true)); await fx.WaitForAsync(scan.Id, JobState.Done); var light = Assert.NotNull(await SingleLightJobAsync(fx)); await fx.WaitForAsync(light.Id, JobState.Done); var sequence = (await fx.Db.Sequences.GetAsync(light.TargetIds.Single(), fx.Ct))!; Assert.Equal("Roof", sequence.Folder); Assert.True(sequence.Status.HasFlag(SequenceStatus.AnalyzedLight), "analysed"); Assert.True(ProjectSettings.FromJson(await File.ReadAllTextAsync(fx.Folder(sequence).ProjectPath, fx.Ct)).Timing.Mode.HasAdvice, "advised"); // Scans that find nothing new queue nothing more. foreach (var full in new[] { false, true }) { var again = await fx.EnqueueAsync(ArchiveJobs.Scan(fx.Archive.Archive, full)); await fx.WaitForAsync(again.Id, JobState.Done); } Assert.Equal(light.Id, (await SingleLightJobAsync(fx))?.Id); } [Test] public async Task AnImportQueuesLightAnalysisOfTheSequencesItFilled() { await using var fx = await ProcessingFixture.CreateAsync(context); var card = context.CreateTempDirectory("card"); Photos.WriteSeries(Path.Combine(card, "DCIM", "100CANON"), ArchiveFixture.Start, 10); var plan = await fx.Archive.Service.PlanImportAsync(fx.Archive.Archive.Id, card, new ImportOptions(), null, null, fx.Ct); await fx.StartEngineAsync(withArchive: true); var import = await fx.Engine.EnqueueAsync(ArchiveJobs.Import(fx.Archive.Archive, plan, null), createdBy: Guid.CreateVersion7(), cancellationToken: fx.Ct); await fx.WaitForAsync(import.Id, JobState.Done); var light = Assert.NotNull(await SingleLightJobAsync(fx)); await fx.WaitForAsync(light.Id, JobState.Done); var sequenceId = await fx.Db.Sequences.FindBySessionKeyAsync(fx.Archive.Archive.Id, plan.Sessions.Single().SessionKey, fx.Ct); Assert.SequenceEqual([Assert.NotNull(sequenceId)], light.TargetIds); Assert.Equal(import.CreatedBy, light.CreatedBy); Assert.Equal(JobPriority.Background, light.Priority); Assert.True((await fx.Db.Sequences.GetAsync(sequenceId.Value, fx.Ct))!.Status.HasFlag(SequenceStatus.AnalyzedLight), "analysed"); } [Test] public async Task PhotosAddedToAnAnalysedFolderAreAnalysedAgain() { await using var fx = await ProcessingFixture.CreateAsync(context); var sequence = await fx.AddAsync(SyntheticSequence.Create(new SyntheticSequenceOptions { FrameCount = 12 }), "Roof"); await fx.StartEngineAsync(withArchive: true); var first = await fx.EnqueueAsync(Titano.Data.Processing.ProcessingJobs.LightAnalysis([sequence.Id])); await fx.WaitForAsync(first.Id, JobState.Done); // The camera kept shooting into the folder: the next scan indexes the new photos and analyses the sequence again. fx.Write(SyntheticSequence.Create(new SyntheticSequenceOptions { FrameCount = 18 }), "Roof", first: 12); var scan = await fx.EnqueueAsync(ArchiveJobs.Scan(fx.Archive.Archive)); await fx.WaitForAsync(scan.Id, JobState.Done); var again = (await fx.Db.Jobs.ListAsync(null, JobKind.LightAnalyse, cancellationToken: fx.Ct)).Items.Single(j => j.Id != first.Id); await fx.WaitForAsync(again.Id, JobState.Done); var analysed = (await fx.Db.Sequences.GetAsync(sequence.Id, fx.Ct))!; Assert.Equal(18, analysed.FrameCount); Assert.True(analysed.Status.HasFlag(SequenceStatus.AnalyzedLight), "analysed again"); Assert.True(ManifestStore.ReadSequence(fx.Folder(sequence).ManifestPath).Status.HasFlag(SequenceStatus.AnalyzedLight), "sidecar status"); } [Test] public async Task PhotosTheOrphansFixIndexesAreAnalysedAgain() { await using var fx = await ProcessingFixture.CreateAsync(context); var sequence = await fx.AddAsync(SyntheticSequence.Create(new SyntheticSequenceOptions { FrameCount = 12 }), "Roof"); var folder = fx.Folder(sequence); await fx.StartEngineAsync(withArchive: true); var first = await fx.EnqueueAsync(Titano.Data.Processing.ProcessingJobs.LightAnalysis([sequence.Id])); await fx.WaitForAsync(first.Id, JobState.Done); // A server sharing the archive drew the twelve frames and made their proxies. const SequenceStatus images = SequenceStatus.ThumbsBuilt | SequenceStatus.ProxiesBuilt; var manifest = ManifestStore.ReadSequence(folder.ManifestPath); ManifestStore.WriteSequence(folder.ManifestPath, manifest with { Status = manifest.Status | images }); await fx.Db.Sequences.UpdateStatusAsync(sequence.Id, images, SequenceStatus.None, fx.Ct); // Photos copied into the folder by hand: the Archive screen's orphans check lists them, and its fix indexes them. The // light analysis it queues waits on the first new photo's probe, so what the fix left can be seen. fx.Write(SyntheticSequence.Create(new SyntheticSequenceOptions { FrameCount = 18 }), "Roof", first: 12); fx.Decoder.HoldProbeOf(12); await fx.Archive.Service.ReconcileAsync(sequence.Id, fx.Engine, deepAnalysis: false, fx.Ct); const SequenceStatus covering = SequenceStatus.AnalyzedLight | images; var row = (await fx.Db.Sequences.GetAsync(sequence.Id, fx.Ct))!; Assert.Equal((18, SequenceStatus.None), (row.FrameCount, row.Status & covering)); Assert.Equal(SequenceStatus.None, ManifestStore.ReadSequence(folder.ManifestPath).Status & covering); var again = (await fx.Db.Jobs.ListAsync(null, JobKind.LightAnalyse, cancellationToken: fx.Ct)).Items.Single(j => j.Id != first.Id); Assert.SequenceEqual([sequence.Id], again.TargetIds); Assert.Empty((await fx.Db.Jobs.ListAsync(null, JobKind.DeepAnalyse, cancellationToken: fx.Ct)).Items); await fx.Decoder.Holding.Task.WaitAsync(TimeSpan.FromSeconds(60), fx.Ct); fx.Decoder.Release(); await fx.WaitForAsync(again.Id, JobState.Done); row = (await fx.Db.Sequences.GetAsync(sequence.Id, fx.Ct))!; Assert.True(row.Status.HasFlag(SequenceStatus.AnalyzedLight), "analysed again"); Assert.True(ManifestStore.ReadSequence(folder.ManifestPath).Status.HasFlag(SequenceStatus.AnalyzedLight), "sidecar status"); Assert.Contains("18", ProjectSettings.FromJson(await File.ReadAllTextAsync(folder.ProjectPath, fx.Ct)).Timing.FrameRate.ReasonArgs!); } [Test] public async Task PhotosTheOrphansFixIndexesGetTheDeepAnalysisAScanWouldQueue() { await using var fx = await ProcessingFixture.CreateAsync(context); var sequence = await fx.AddAsync(SyntheticSequence.Create(new SyntheticSequenceOptions { FrameCount = 12 }), "Roof"); var lake = await fx.AddAsync(SyntheticSequence.Create(new SyntheticSequenceOptions { FrameCount = 12 }), "Lake"); var folder = fx.Folder(sequence); await fx.StartEngineAsync(withArchive: true); Task> QueuedDeepAsync() => fx.Db.Jobs.ListQueuedAsync(JobKind.DeepAnalyse, 50, fx.Ct); // The host asks for a deep analysis after scans: the orphans fix queues one in the background too, behind the light // analysis, which waits on the first new photo's probe so the queue can be seen. fx.Write(SyntheticSequence.Create(new SyntheticSequenceOptions { FrameCount = 18 }), "Roof", first: 12); fx.Decoder.HoldProbeOf(12); await fx.Archive.Service.ReconcileAsync(sequence.Id, fx.Engine, deepAnalysis: true, fx.Ct); var light = (await fx.Db.Jobs.ListAsync(null, JobKind.LightAnalyse, cancellationToken: fx.Ct)).Items.Single(); var deep = (await QueuedDeepAsync()).Single(); Assert.SequenceEqual([sequence.Id], deep.TargetIds); Assert.Equal(JobPriority.Background, deep.Priority); await fx.Decoder.Holding.Task.WaitAsync(TimeSpan.FromSeconds(60), fx.Ct); // The user cancels it, and asks for a deep analysis of both sequences instead. More photos and the fix again: the // one waiting covers them, so no other is queued. await fx.Engine.CancelAsync(deep.Id, fx.Ct); var both = await fx.EnqueueAsync(Titano.Data.Processing.ProcessingJobs.DeepAnalysis([lake.Id, sequence.Id])); fx.Write(SyntheticSequence.Create(new SyntheticSequenceOptions { FrameCount = 20 }), "Roof", first: 18); await fx.Archive.Service.ReconcileAsync(sequence.Id, fx.Engine, deepAnalysis: true, fx.Ct); Assert.SequenceEqual([both.Id], (await QueuedDeepAsync()).Select(j => j.Id)); fx.Decoder.Release(); await fx.WaitForAsync(light.Id, JobState.Done); await fx.WaitForAsync(both.Id, JobState.Done); var row = (await fx.Db.Sequences.GetAsync(sequence.Id, fx.Ct))!; Assert.Equal(20, row.FrameCount); Assert.True(row.Status.HasFlag(SequenceStatus.AnalyzedDeep), row.Status.ToString()); Assert.Equal(20, Titano.Data.Processing.SequenceAnalyser.ReadReport(folder, 20)?.FrameCount); } [Test] public async Task AScanAskedForDeepAnalysisQueuesItInTheBackgroundForNewSequencesOnly() { await using var fx = await ProcessingFixture.CreateAsync(context); fx.Write(SyntheticSequence.Create(new SyntheticSequenceOptions { FrameCount = 12 }), "Roof"); await fx.StartEngineAsync(withArchive: true); var scan = await fx.EnqueueAsync(ArchiveJobs.Scan(fx.Archive.Archive, full: true, deepAnalysis: true)); await fx.WaitForAsync(scan.Id, JobState.Done); var deep = (await fx.Db.Jobs.ListAsync(null, JobKind.DeepAnalyse, cancellationToken: fx.Ct)).Items.Single(); Assert.Equal(JobPriority.Background, deep.Priority); Assert.NotNull(await SingleLightJobAsync(fx)); var done = await fx.WaitForAsync(deep.Id, JobState.Done); var sequence = (await fx.Db.Sequences.GetAsync(done.TargetIds.Single(), fx.Ct))!; Assert.Equal("Roof", sequence.Folder); Assert.True(sequence.Status.HasFlag(SequenceStatus.AnalyzedDeep), "analysed in depth"); // A scan that indexes nothing new asks for nothing; a scan without the option never does. var again = await fx.EnqueueAsync(ArchiveJobs.Scan(fx.Archive.Archive, full: true, deepAnalysis: true)); await fx.WaitForAsync(again.Id, JobState.Done); fx.Write(SyntheticSequence.Create(new SyntheticSequenceOptions { FrameCount = 12 }), "Lake"); var plain = await fx.EnqueueAsync(ArchiveJobs.Scan(fx.Archive.Archive)); await fx.WaitForAsync(plain.Id, JobState.Done); Assert.Count(1, (await fx.Db.Jobs.ListAsync(null, JobKind.DeepAnalyse, cancellationToken: fx.Ct)).Items); } [Test] public async Task ASequenceWaitingForLightAnalysisIsNotQueuedAgain() { await using var fx = await ProcessingFixture.CreateAsync(context); var sequence = await fx.AddAsync(SyntheticSequence.Create(new SyntheticSequenceOptions { FrameCount = 12 }), "Roof"); // Queued before the scan, which runs first (user priority) and finds the sequence not analysed yet. var waiting = await QueueAsync(fx, Titano.Data.Processing.ProcessingJobs.LightAnalysis([sequence.Id])); var scan = await QueueAsync(fx, ArchiveJobs.Scan(fx.Archive.Archive, full: true)); await fx.StartEngineAsync(withArchive: true); await fx.WaitForAsync(scan.Id, JobState.Done); await fx.WaitForAsync(waiting.Id, JobState.Done); Assert.Equal(waiting.Id, (await SingleLightJobAsync(fx))?.Id); } /// Queues a job before the engine starts. private static async Task QueueAsync(ProcessingFixture fx, Titano.Data.Archiving.Jobs.ArchiveJobRequest request) { var job = new Job { Id = Guid.CreateVersion7(), Kind = request.Kind, TargetIds = request.Targets, TargetLabel = request.Label, ParametersJson = request.ParametersJson, Priority = request.Priority, State = JobState.Queued, Created = DateTimeOffset.UtcNow, }; await fx.Db.Jobs.EnqueueAsync(job, fx.Ct); return job; } private static async Task SingleLightJobAsync(ProcessingFixture fx) => (await fx.Db.Jobs.ListAsync(null, JobKind.LightAnalyse, cancellationToken: fx.Ct)).Items.SingleOrDefault(); }