- Editor: a failed save showed what the server or the archive layer would say
for the exception's type, so the editor's own sentences were lost: frames
changed on the server or settings changed elsewhere read "The server does not
answer", a read-only account or a gone sequence "Something went wrong". These
failures are now EditorException (an IOException; ProxiesOutdatedException
derives from it) and the toast shows their sentence as it is. A project
written by a newer Titano is reported with the same sentence as a corrupt one
instead of the parser's English text.
- Library: a job posted to a server whose certificate changed since sign-in
threw out of the action unreported; the pin's refusal now reaches the error
toast ("The certificate was not trusted").
- Archive: picking another archive forced it offline until it was read, so the
rebuild dialog called it offline with the previous archive's count, and
disabled commands said the archive must be online. What was read is now kept
apart from availability: until the picked archive is read, Rebuild and the
online commands wait and say so, health fixes and search results of the
previous archive are cleared, and a running search is cancelled.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
217 lines
11 KiB
C#
217 lines
11 KiB
C#
using System.IO;
|
|
using Titano.App.Editor;
|
|
using Titano.Core.Archiving;
|
|
using Titano.Core.Codecs.Jpeg;
|
|
using Titano.Core.Imaging;
|
|
using Titano.Core.Imaging.Decoders;
|
|
using Titano.Core.Localization;
|
|
using Titano.Core.Metadata;
|
|
using Titano.Core.Model;
|
|
using Titano.Core.Project;
|
|
using Titano.Data;
|
|
using Titano.Data.Archiving;
|
|
using Titano.Data.Jobs;
|
|
using Titano.Data.Processing;
|
|
using Titano.Data.Repositories;
|
|
using Titano.Testing;
|
|
|
|
namespace Titano.App.Tests.Editor;
|
|
|
|
/// <summary>Project merges, and the local source over a real SQLite index and archive folder.</summary>
|
|
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", ".titano", "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<InvalidOperationException>(() => 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<Sequence>();
|
|
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", ".titano", "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 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<EditorException>(() => 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 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", ".titano", "project.json");
|
|
File.WriteAllText(path, "{ not json");
|
|
await using var source = new LocalSequenceSource(db, sequenceId, DecoderFactory.CreateClient(null), null);
|
|
var unreadable = await Assert.ThrowsAsync<EditorException>(() => 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 Titano 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<EditorException>(() => source.LoadAsync(context.Cancellation))).Message);
|
|
Assert.Equal(newer, File.ReadAllText(path));
|
|
}
|
|
}
|
|
|
|
/// <summary>A temporary archive with one adopted folder of synthetic JPEGs, indexed.</summary>
|
|
private async Task<(TitanoDatabase Db, Guid SequenceId, string Root)> ArchiveAsync(int frames)
|
|
{
|
|
var directory = context.CreateTempDirectory("editor");
|
|
var root = Path.Combine(directory, "archive");
|
|
var db = await TitanoDatabase.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);
|
|
}
|
|
}
|