The Archive screen's orphans fix indexed photos copied in by hand but left AnalyzedLight, ThumbsBuilt and ProxiesBuilt set and recorded the folder's stamps, so no scan came back to it and the light analysis was never redone: Auto values, warnings and preview-only tiers stayed those of the old frames. It now clears the three flags in the sidecar and the row as a scan's reconcile does, and queues the light analysis on the host's engine (on a server, the thumbnails and proxies too). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
184 lines
10 KiB
C#
184 lines
10 KiB
C#
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;
|
|
|
|
/// <summary>New sequences get their light analysis (and so their Auto values) without any user action (BRIEF §1.1).</summary>
|
|
[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, 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);
|
|
|
|
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 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);
|
|
}
|
|
|
|
/// <summary>Queues a job before the engine starts.</summary>
|
|
private static async Task<Job> 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<Job?> SingleLightJobAsync(ProcessingFixture fx) =>
|
|
(await fx.Db.Jobs.ListAsync(null, JobKind.LightAnalyse, cancellationToken: fx.Ct)).Items.SingleOrDefault();
|
|
}
|