Files
Chronos/tests/Titano.App.Tests/Settings/SettingsLogicTests.cs
T
Claude ffbea7cb74 feat(app): library, jobs, settings, server, welcome and about screens
Local-mode composition root (SQLite index, one JobEngine fed by a single
handler registration list), keyset-paged library with thumbnail cache and
hover scrub, live job list with throttled updates and the shell job bar,
settings with live template validation and encoder self-test, server
connection with trust-on-first-use and DPAPI token, first-run welcome,
About with update check, and --capture screenshots with synthetic data.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012iLMBNwBE2GnphAsu4cjaC
2026-10-02 12:26:58 +00:00

157 lines
7.6 KiB
C#

using System.ComponentModel;
using System.Globalization;
using System.IO;
using Titano.App.Settings;
using Titano.Core.Localization;
using Titano.Core.Naming;
using Titano.Testing;
namespace Titano.App.Tests.Settings;
public sealed class SettingsLogicTests
{
public SettingsLogicTests() => Loc.SetCulture(CultureInfo.GetCultureInfo("en"));
[Test]
public void DefaultTemplatesPreviewThreeNames()
{
var names = NamingPreview.FirstNames(TemplateDefaults.Folder, TemplateDefaults.File);
Assert.SequenceEqual(
[
"2026/2026-09-28 Canon EOS R5/2026-09-28_18-02-11_0001.CR2",
"2026/2026-09-28 Canon EOS R5/2026-09-28_18-02-13_0002.CR2",
"2026/2026-09-28 Canon EOS R5/2026-09-28_18-02-15_0003.CR2",
],
names);
Assert.Null(NamingPreview.Validate(TemplateDefaults.Folder, isFolder: true));
Assert.Null(NamingPreview.Validate(TemplateDefaults.File, isFolder: false));
}
[Theory]
[Case("{date}_{time}_{n:0000", "Errors.Template.UnclosedBrace", "", 15)]
[Case("{date}_{nope}", "Errors.Template.UnknownToken", "nope", 8)]
[Case("{}_{n}", "Errors.Template.EmptyToken", "", 1)]
[Case("{n}}x", "Errors.Template.UnopenedBrace", "", 4)]
[Case(" ", "Errors.Template.Empty", "", 1)]
[Case("{date}", "Errors.Template.NotUnique", "", 0)]
[Case("{year}/{n}", "Errors.Template.FileSeparator", "", 0)]
[Case("{date:%}_{n}", "Errors.Template.Format", "", 0)]
public void InvalidFileTemplatesExplainTheProblem(string template, string key, string token, int position)
{
var expected = position > 0 ? Loc.L(key, token, position) : Loc.L(key);
Assert.Equal(expected, NamingPreview.Validate(template, isFolder: false), template);
Assert.Empty(NamingPreview.FirstNames(TemplateDefaults.Folder, template));
}
[Test]
public void TemplateErrorsNameThePosition()
{
Assert.Equal("The brace opened at position 8 is never closed.", NamingPreview.Validate("{date}_{time", isFolder: false));
Assert.Equal("Unknown token “nope” at position 8.", NamingPreview.Validate("{date}_{nope}", isFolder: false));
}
[Test]
public void FolderTemplatesMayNestAndRepeat()
{
Assert.Null(NamingPreview.Validate("{year}/{month}/{camera}", isFolder: true));
Assert.Equal("2026/09/Canon EOS R5/IMG_4211.CR2", NamingPreview.FirstNames("{year}/{month}/{camera}", "{name}")[0]);
}
[Test]
public void EnterCommitsAndEscReverts()
{
string? stored = null;
var field = new EditableField("8", v => int.TryParse(v, out var n) && n is >= 1 and <= 32 ? null : "1 to 32", v => stored = v, () => "Worker threads");
var changes = new List<string?>();
field.PropertyChanged += (_, e) => changes.Add(e.PropertyName);
var errors = 0;
field.ErrorsChanged += (_, _) => errors++;
field.Text = "12";
Assert.True(field.IsDirty);
Assert.False(field.HasErrors);
Assert.Equal("Worker threads", field.ToolTip);
Assert.True(field.Commit());
Assert.Equal("12", stored);
Assert.Equal("12", field.Value);
Assert.False(field.IsDirty);
field.Text = "99";
Assert.True(field.HasErrors);
Assert.Equal("1 to 32", field.ToolTip);
Assert.Equal("1 to 32", ((IEnumerable<string>)field.GetErrors(nameof(EditableField.Text))).Single());
Assert.False(field.Commit());
Assert.Equal("12", stored);
field.Revert();
Assert.Equal("12", field.Text);
Assert.False(field.HasErrors);
Assert.False(field.IsDirty);
Assert.Equal(2, errors);
Assert.Contains(nameof(EditableField.ToolTip), changes);
}
[Test]
public void LoadReplacesTheValueWithoutCommitting()
{
var commits = 0;
var field = new EditableField("a", v => v.Length == 0 ? "empty" : null, _ => commits++, () => "tip");
field.Load("b");
Assert.Equal("b", field.Value);
Assert.Equal("b", field.Text);
Assert.False(field.IsDirty);
Assert.Equal(0, commits);
Assert.True(field.Commit());
Assert.Equal(0, commits); // nothing changed, nothing stored
field.Load(string.Empty);
Assert.True(field.HasErrors);
}
[Test]
public void TheLanguageListHasEveryShippedCatalog()
{
var available = LanguageCatalog.Available;
Assert.Equal("en", available[0].Code);
Assert.Equal(available.Count, available.Select(l => l.Code).Distinct(StringComparer.OrdinalIgnoreCase).Count());
foreach (var option in available)
{
Assert.Contains(option.Code, Languages.Shipped);
Assert.True(LanguageCatalog.HasResources(option.Code), option.Code);
Assert.False(string.IsNullOrWhiteSpace(option.Name));
}
// Every culture folder of the catalog is offered, and nothing else.
var folders = Directory.EnumerateDirectories(Path.Combine(TestContext.RepositoryRoot, "i18n"))
.Select(Path.GetFileName)
.Where(n => n is not null && Directory.EnumerateFiles(Path.Combine(TestContext.RepositoryRoot, "i18n", n), "*.resx").Any())
.ToHashSet(StringComparer.OrdinalIgnoreCase);
Assert.Contains("it", folders);
Assert.SequenceEqual(folders.Order(StringComparer.OrdinalIgnoreCase), available.Select(o => o.Code).Order(StringComparer.OrdinalIgnoreCase));
Assert.Equal("Italiano", available.Single(o => o.Code == "it").Name);
Assert.Equal("it", LanguageCatalog.Match(CultureInfo.GetCultureInfo("it-CH")).Code);
Assert.Equal("en", LanguageCatalog.Match(CultureInfo.GetCultureInfo("sw")).Code);
}
[Test]
public void EnumDrivenKeysExistInEveryRequiredLanguage()
{
var keys = new List<string>();
keys.AddRange(Enum.GetNames<Titano.Core.Model.JobKind>().Select(k => "Jobs.Kind." + k));
keys.AddRange(Enum.GetNames<Titano.Core.Model.JobState>().Select(k => "Jobs.State." + k));
keys.AddRange(Enum.GetNames<Titano.Core.Model.JobState>().Select(k => "Tooltips.Jobs.State." + k));
keys.AddRange(Enum.GetNames<Titano.App.Jobs.JobFilter>().SelectMany(k => new[] { "Jobs.Filter." + k, "Tooltips.Jobs.Filter." + k }));
keys.AddRange(Enum.GetNames<Titano.App.Library.StatusFilter>().Where(k => k != "Any").Select(k => "Library.Filter.Status." + k));
keys.AddRange(Enum.GetNames<Titano.Data.Repositories.SequenceSort>().Select(k => "Library.Sort." + k));
keys.AddRange(Enum.GetNames<Titano.App.Server.ConnectError>().Where(k => k != "None").Select(k => "Server.Error." + k));
keys.AddRange(Enum.GetNames<Titano.Core.Model.UserRole>().SelectMany(k => new[] { "Server.Role." + k, "Tooltips.Server.Role." + k }));
keys.AddRange(Enum.GetNames<SettingsPage>().SelectMany(k => new[] { "Settings.Page." + k, "Tooltips.Settings.Page." + k }));
keys.AddRange(Enum.GetNames<Titano.App.Infrastructure.QualityProfile>().Select(k => "Settings.Rendering.Quality." + k));
keys.AddRange(new[] { "UnclosedBrace", "EmptyToken", "UnknownToken", "UnopenedBrace", "Empty" }.Select(k => "Errors.Template." + k));
// Italian completeness is checked by `Titano.Tools i18n check`; here every enum value must have its key.
var english = Loc.GetArea("Jobs", CultureInfo.InvariantCulture).Keys
.Concat(new[] { "Library", "Server", "Settings", "Tooltips", "Errors" }.SelectMany(a => Loc.GetArea(a, CultureInfo.InvariantCulture).Keys))
.ToHashSet(StringComparer.Ordinal);
foreach (var key in keys) Assert.True(english.Contains(key), key);
}
}