Files
Chronos/tests/Chronos.App.Tests/Settings/SettingsLogicTests.cs
T
Alby96andClaude Opus 5.5 e0644e5304 fix(settings): hold Change and Move while a switched move awaits Resume
A move that switched to the folder in use but left part of its old folder
showed Resume and a "resume it first" tooltip on Change… and Move…, yet both
stayed enabled because no journal lies in the folder in use. Choosing another
folder then would hide the Resume for good and leave the old folder's copy
on disk. Change… and Move… now wait whenever a stopped move is found.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-04 17:43:40 +01:00

817 lines
44 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
using System.ComponentModel;
using System.Globalization;
using System.IO;
using Chronos.App.Infrastructure;
using Chronos.App.Settings;
using Chronos.App.Workspace;
using Chronos.Core.Localization;
using Chronos.Core.Naming;
using Chronos.Core.Video;
using Chronos.Core.Windows.Shell;
using Chronos.Testing;
namespace Chronos.App.Tests.Settings;
public sealed class SettingsLogicTests
{
private readonly TestContext _context;
public SettingsLogicTests(TestContext context)
{
_context = context;
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)]
[Case("{n}{ext}", "Errors.Template.Extension", "", 0)]
[Case("{title}_{ext}", "Errors.Template.Extension", "", 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]);
Assert.Null(NamingPreview.Validate("{name}.{ext}", isFolder: false));
}
[Theory]
[Case("Originals/{year}")]
[Case("{year}/exports")]
[Case(".archive/{date}")]
[Case("{year}/.chronos")]
public void FolderTemplatesScansWouldSkipAreRefused(string template)
{
Assert.Equal(Loc.L("Errors.Template.ReservedFolder"), NamingPreview.Validate(template, isFolder: true), template);
Assert.Empty(NamingPreview.FirstNames(template, TemplateDefaults.File));
}
[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 EachEncoderNamesThePresetsItServes()
{
var hevc = new EncoderRow("HEVC", "NVIDIA HEVC Encoder MFT", "NVIDIA", EncoderSource.MediaFoundation, true, true, 8192, 8192, VideoCodec.Hevc);
var av1 = hevc with { Codec = "AV1", Name = "NVIDIA AV1 Encoder MFT", VideoCodec = VideoCodec.Av1 };
var h264 = new EncoderRow("H.264", "H264 Encoder MFT", "Microsoft", EncoderSource.MediaFoundation, false, false, 4096, 2304, VideoCodec.H264);
var animation = new EncoderRow("GIF · APNG", "Chronos", null, EncoderSource.BuiltInAnimation, false, false, 0, 0, null);
Assert.SequenceEqual(["8K archive", "4K archive", "4K HEVC", "DCI 4K", "Cinema 21:9", "4K 60 fps"], EncoderUse.Presets(hevc));
Assert.Equal("Animated GIF · Animated PNG", EncoderUse.Text(animation));
Assert.Contains("Share 1080p", EncoderUse.Presets(h264));
Assert.Equal("4K AV1", EncoderUse.Text(av1));
}
[Test]
public void ARenderNodeOffersHardwareEncodersOnlyWhenRendersMayUseThem()
{
EncoderRow[] rows =
[
new("HEVC", "NVIDIA HEVC Encoder MFT", "NVIDIA", EncoderSource.MediaFoundation, true, true, 8192, 8192, VideoCodec.Hevc),
new("H.264", "NVIDIA H.264 Encoder MFT", "NVIDIA", EncoderSource.MediaFoundation, true, false, 4096, 4096, VideoCodec.H264),
new("H.264", "H264 Encoder MFT", "Microsoft", EncoderSource.MediaFoundation, false, false, 4096, 2304, VideoCodec.H264),
new("MJPEG · AVI", "Chronos", null, EncoderSource.BuiltInMjpeg, false, false, 0, 0, VideoCodec.Mjpeg),
];
Assert.Equal("HEVC · H.264", EncoderUse.Codecs(EncoderUse.Node(rows, allowsHardware: true)));
Assert.Equal(3, EncoderUse.Node(rows, allowsHardware: true).Count);
Assert.Equal("H.264", EncoderUse.Codecs(EncoderUse.Node(rows, allowsHardware: false)));
Assert.Null(EncoderUse.Codecs([]));
}
[Test]
public void ThePreviewTitleSpeaksTheInterfaceLanguage()
{
// The sample's title is a catalog string read on every preview (so a language switch shows at once), not English text.
Assert.Equal("Harbour sunset", NamingPreview.FirstNames("{title}", "{n:0000}")[0].Split('/')[0]);
Assert.Equal("Harbour sunset", NamingPreview.SampleFrames[0].Title);
Assert.False(ReferenceEquals(NamingPreview.SampleFrames, NamingPreview.SampleFrames), "built on each call");
var italian = Loc.Get("Settings.Naming.SampleTitle", CultureInfo.GetCultureInfo("it"));
Assert.True(italian is { Length: > 0 } && italian != "Harbour sunset", italian);
}
[Test]
public void TheQualityProfileTunesTheJobs()
{
var settings = new Chronos.App.Infrastructure.AppSettings { Quality = Chronos.App.Infrastructure.QualityProfile.Best, Parallelism = 3, MemoryBudgetGb = 6 };
var basis = new Chronos.Data.Processing.ProcessingOptions();
// One job runs at a time (owner review 1): it has the whole 6 GB, and decodes and measures 3 photos at once.
var best = ProcessingTuning.Apply(basis, settings, 64L << 30, 16, @"C:\cache");
Assert.Equal((6L << 30, @"C:\cache", 8, 3), (best.FrameWindow.MemoryBudget, best.FrameWindow.SpillDirectory, best.FrameWindow.Ahead, best.FrameWindow.MaxConcurrentLoads));
Assert.Equal((1024, Chronos.Core.Project.FlowQualitySetting.Best), (best.Render.AnalysisLongEdge, best.Render.DefaultFlowQuality));
Assert.Equal(3, best.DeepAnalysis.MaxDegreeOfParallelism);
settings.Parallelism = 1;
var single = ProcessingTuning.Apply(basis, settings, 64L << 30, 16, @"C:\cache");
Assert.Equal((6L << 30, 1, 1), (single.FrameWindow.MemoryBudget, single.FrameWindow.MaxConcurrentLoads, single.DeepAnalysis.MaxDegreeOfParallelism));
// A parallelism beyond the read-ahead widens the window, so the decodes have frames to work on.
settings.Parallelism = 12;
var wide = ProcessingTuning.Apply(basis, settings, 64L << 30, 16, @"C:\cache");
Assert.Equal((12, 12, 12), (wide.FrameWindow.Ahead, wide.FrameWindow.MaxConcurrentLoads, wide.DeepAnalysis.MaxDegreeOfParallelism));
// Auto: a quarter of 32 GB, and half the 16 cores at once, with no cap of the analysis threads.
settings.Quality = Chronos.App.Infrastructure.QualityProfile.Fast;
settings.MemoryBudgetGb = null;
settings.Parallelism = null;
var fast = ProcessingTuning.Apply(basis, settings, 32L << 30, 16, @"C:\cache");
Assert.Equal((8L << 30, 8), (fast.FrameWindow.MemoryBudget, fast.FrameWindow.Ahead));
Assert.Equal((8, 8), (fast.FrameWindow.MaxConcurrentLoads, fast.DeepAnalysis.MaxDegreeOfParallelism));
Assert.Equal((256, Chronos.Core.Project.FlowQualitySetting.Draft), (fast.Render.AnalysisLongEdge, fast.Render.DefaultFlowQuality));
Assert.Equal(512, ProcessingTuning.PreparationLongEdge(Chronos.App.Infrastructure.QualityProfile.Balanced));
}
[Test]
public void ParallelismAutoIsHalfTheCores()
{
// Photos the running job processes at once (owner review 1): half the cores, the archive engine's own default.
Assert.Equal(8, ProcessingTuning.ParallelismAuto(16));
Assert.Equal(2, ProcessingTuning.ParallelismAuto(4));
Assert.Equal(1, ProcessingTuning.ParallelismAuto(1));
Assert.Equal(Chronos.Data.Archiving.ArchiveServiceOptions.DefaultParallelism, ProcessingTuning.ParallelismAuto(Environment.ProcessorCount));
Assert.Equal(1, new Chronos.Data.Jobs.JobEngineOptions().Workers);
Assert.Equal(8, ProcessingTuning.Parallelism(new Chronos.App.Infrastructure.AppSettings(), 16));
Assert.Equal(5, ProcessingTuning.Parallelism(new Chronos.App.Infrastructure.AppSettings { Parallelism = 5 }, 16));
}
[Test]
public void TheAnalysisSettingsBecomeTheDeepAnalysisParameters()
{
var defaults = new Chronos.App.Infrastructure.AppSettings().DeepAnalysis(Chronos.Core.Analysis.Deep.DeepAnalysisOptions.Default);
// The defaults of Settings › Analysis are the engine's own: nothing changes until the user does.
Assert.Equal(Chronos.Core.Analysis.Deep.DeepAnalysisOptions.Default.Fingerprint(), defaults.Fingerprint());
Assert.Equal(Chronos.Core.Analysis.Deep.DeepAnalysisOptions.Default.StarFieldDensity, defaults.StarFieldDensity);
var tuned = new Chronos.App.Infrastructure.AppSettings { AnalysisLongEdge = 1024, NightBrightnessPercent = 12.5, StarFieldDensity = 60 }
.DeepAnalysis(Chronos.Core.Analysis.Deep.DeepAnalysisOptions.Default);
Assert.Equal((1024, -3.0, 60.0), (tuned.MaxAnalysisLongEdge, tuned.DarkLogLuminance, tuned.StarFieldDensity));
}
[Test]
public void NewCardsStartFromSettingsImport()
{
var settings = new Chronos.App.Infrastructure.AppSettings
{
ImportSessionGapMinutes = 90,
ImportMinimumFrames = 20,
ImportSubfolders = false,
ImportVerify = false,
ImportDuplicates = Chronos.Core.Import.DuplicatePolicy.ImportAgain,
ImportAfter = Chronos.Data.Archiving.AfterImport.DeleteImported,
ImportEject = false,
DeepAnalysisAfterImport = false,
};
var profile = settings.ImportProfile("{year}", "{name}");
Assert.Equal(("{year}", "{name}", 90, 20), (profile.FolderTemplate, profile.FileTemplate, profile.SessionGapMinutes, profile.MinimumSessionFrames));
Assert.Equal((false, false, false, false), (profile.IncludeSubfolders, profile.VerifyCopies, profile.Eject, profile.DeepAnalysis));
Assert.Equal((Chronos.Core.Import.DuplicatePolicy.ImportAgain, Chronos.Data.Archiving.AfterImport.DeleteImported), (profile.Duplicates, profile.AfterImport));
// Untouched settings give the brief's card defaults.
Assert.Equal(new Chronos.Data.Archiving.CardProfile(), new Chronos.App.Infrastructure.AppSettings().ImportProfile(TemplateDefaults.Folder, TemplateDefaults.File));
}
[Test]
public void NewArchivesTakeSettingsArchive()
{
var settings = new Chronos.App.Infrastructure.AppSettings { FolderTemplate = "{year}", FileTemplate = "{name}", ProxyLongEdge = 2560, ThumbnailLongEdge = 480 };
var archive = settings.ArchiveDefaults();
Assert.Equal(("{year}", "{name}", 2560, 480), (archive.Templates.Folder, archive.Templates.File, archive.Proxies.LongEdge, archive.Thumbnails.LongEdge));
Assert.Null((new Chronos.App.Infrastructure.AppSettings().ArchiveDefaults() with { Name = "Archive" }).Problem());
}
[Test]
public void TheArchiveRowsEditOnlyTheArchiveAtTheArchiveFolder()
{
var main = new Chronos.Core.Model.Archive { Id = Guid.CreateVersion7(), Name = "Main", RootPath = "/archive", Created = DateTimeOffset.UtcNow };
var travel = new Chronos.Core.Model.Archive { Id = Guid.CreateVersion7(), Name = "Travel", RootPath = "/media/travel", Created = DateTimeOffset.UtcNow };
Assert.Equal(travel.Id, Chronos.App.Archiving.CurrentArchive.At([main, travel], "/media/travel/")!.Id);
// A folder no archive of the index is at: no archive at all, never the first one (its archive.json is someone else's).
Assert.Null(Chronos.App.Archiving.CurrentArchive.At([main, travel], "/media/new"));
Assert.Equal(main.Id, Chronos.App.Archiving.CurrentArchive.Pick([main, travel], "/media/new")!.Id);
}
[Test]
public void SettingsSurviveARoundTripWithTheNewSections()
{
var settings = new Chronos.App.Infrastructure.AppSettings { ThumbnailLongEdge = 640, ScanIntervalMinutes = 30, NightBrightnessPercent = 3.5, DeepAnalysisAfterScan = true };
var copy = Chronos.App.Infrastructure.AppSettings.Parse(settings.ToJson())!;
Assert.Equal((640, 30, 3.5, true), (copy.ThumbnailLongEdge, copy.ScanIntervalMinutes, copy.NightBrightnessPercent, copy.DeepAnalysisAfterScan));
}
[Test]
public void BackgroundPriorityRaisesTheInterfaceOnlyInFront()
{
Assert.Equal(ThreadPriority.AboveNormal, InterfacePriority.For(enabled: true, active: true));
Assert.Equal(ThreadPriority.Normal, InterfacePriority.For(enabled: true, active: false));
Assert.Equal(ThreadPriority.Normal, InterfacePriority.For(enabled: false, active: true));
}
[Test]
public void FormatsShowTheirTierAndWhatToInstall()
{
Assert.Equal(("JPEG XL", "CR3", "3FR"), (FormatNames.Of(Chronos.Core.Imaging.ImageFileFormat.JpegXl), FormatNames.Of(Chronos.Core.Imaging.ImageFileFormat.Cr3),
FormatNames.Of(Chronos.Core.Imaging.ImageFileFormat.ThreeFr)));
var heif = Chronos.Core.Windows.Codecs.StoreExtension.Get(Chronos.Core.Windows.Codecs.StoreExtensionKind.HeifImage);
var format = Chronos.Core.Imaging.Decoders.DecoderFactory.DescribeFormats(Chronos.Core.Imaging.Decoders.DecoderFactory.CreateClient(null))
.First(f => f.Format.Format == Chronos.Core.Imaging.ImageFileFormat.Heif).Format;
var row = new FormatRowViewModel(new FormatRow(format, Chronos.Core.Imaging.DecodeTier.EmbeddedPreview, "managed", [heif]));
Assert.Equal(("Preview only", "Chronos", heif.ProductName), (row.TierText, row.DecoderText, row.NeedsText));
Assert.Equal(Chronos.Ui.Controls.StatusKind.Warning, row.TierKind);
Assert.Equal("HEIF: Preview only", row.Announcement);
var missing = new MissingExtensionViewModel(heif, new Chronos.Ui.Mvvm.RelayCommand(() => { }));
Assert.Equal(heif.ProductName + " missing", missing.Text);
var none = new FormatRowViewModel(new FormatRow(format, Chronos.Core.Imaging.DecodeTier.Unavailable, null, []));
Assert.Equal(("Not supported", "—", "—", false), (none.TierText, none.DecoderText, none.NeedsText, none.HasNeeds));
}
[Test]
public void ASettingsPageIsFoundOnlyByTheRowsItShows()
{
// About's translation row shows outside English only: its keyword is read at each search, not once (owner review 2).
var shown = false;
var about = new SettingsPageItem(SettingsPage.About, () => shown ? ["About.Translation"] : []);
Assert.False(about.Matches(Loc.L("About.Translation")), "a hidden row does not match");
shown = true;
Assert.True(about.Matches(Loc.L("About.Translation")));
Assert.True(new SettingsPageItem(SettingsPage.About, ["About.Build"]).Matches(Loc.L("About.Build")));
}
[Test]
public void EnumDrivenKeysExistInEveryRequiredLanguage()
{
var keys = new List<string>();
keys.AddRange(Enum.GetNames<Chronos.Core.Model.JobKind>().Select(k => "Jobs.Kind." + k));
keys.AddRange(Enum.GetNames<Chronos.Core.Model.JobState>().Select(k => "Jobs.State." + k));
keys.AddRange(Enum.GetNames<Chronos.Core.Model.JobState>().Select(k => "Tooltips.Jobs.State." + k));
keys.AddRange(Enum.GetNames<Chronos.App.Jobs.JobFilter>().SelectMany(k => new[] { "Jobs.Filter." + k, "Tooltips.Jobs.Filter." + k }));
keys.AddRange(Enum.GetNames<Chronos.App.Library.StatusFilter>().Where(k => k != "Any").Select(k => "Library.Filter.Status." + k));
keys.AddRange(Enum.GetNames<Chronos.Data.Repositories.SequenceSort>().Select(k => "Library.Sort." + k));
keys.AddRange(Enum.GetNames<Chronos.App.Server.ConnectError>().Where(k => k != "None").Select(k => "Server.Error." + k));
keys.AddRange(Enum.GetNames<Chronos.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<Chronos.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 `Chronos.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);
}
// ---------------- Settings › Workspace (phase 5c) ----------------
[Test]
public void TheWorkspaceSizeLimitOffersItsPresetsThenNoLimit()
{
var (settings, rows, saves) = WorkspaceRows();
Assert.SequenceEqual([25, 50, 100, 200, 500, 1000, 0], rows.SizeLimitChoices.Select(c => c.Value));
Assert.Equal(("100 GB", "No limit"), (rows.SizeLimitChoices.Single(c => c.Value == 100).Label, rows.SizeLimitChoices[^1].Label));
Assert.Equal(100, rows.SelectedSizeLimit.Value);
Assert.Equal(Loc.L("Tooltips.Settings.Workspace.SizeLimit"), rows.SizeLimitToolTip);
rows.SelectedSizeLimit = rows.SizeLimitChoices.Single(c => c.Value == 500);
Assert.Equal((500, 1), (settings.WorkspaceSizeLimitGb, saves()));
rows.SelectedSizeLimit = rows.SizeLimitChoices.Single(c => c.Value == 500);
rows.SelectedSizeLimit = null!;
Assert.Equal(1, saves(), "nothing to store");
rows.SelectedSizeLimit = rows.SizeLimitChoices[^1];
Assert.Equal((0, 2), (settings.WorkspaceSizeLimitGb, saves()));
Assert.Equal(Loc.L("Tooltips.Settings.Workspace.NoLimit"), rows.SizeLimitToolTip);
// A value set by hand is listed in order with the presets; one below 1 is no limit, as the clean-up applies it.
settings.WorkspaceSizeLimitGb = 300;
Assert.SequenceEqual([25, 50, 100, 200, 300, 500, 1000, 0], rows.SizeLimitChoices.Select(c => c.Value));
Assert.Equal(300, rows.SelectedSizeLimit.Value);
settings.WorkspaceSizeLimitGb = -5;
Assert.Equal(0, rows.SelectedSizeLimit.Value);
Assert.Count(7, rows.SizeLimitChoices);
}
[Test]
public void TheDefaultMediaAreTheProxiesUnlessTheOriginalsAreChosen()
{
var (settings, rows, saves) = WorkspaceRows();
Assert.Equal((true, false), (rows.IsDefaultProxies, rows.IsDefaultOriginals));
rows.IsDefaultOriginals = true;
Assert.Equal((Chronos.Core.Project.BundleMedia.Originals, 1), (settings.WorkspaceDefaultMedia, saves()));
Assert.Equal((false, true), (rows.IsDefaultProxies, rows.IsDefaultOriginals));
// A radio button unchecked by its sibling stores nothing.
rows.IsDefaultProxies = false;
rows.IsDefaultOriginals = true;
Assert.Equal(1, saves());
rows.IsDefaultProxies = true;
Assert.Equal((Chronos.Core.Project.BundleMedia.Proxies, 2), (settings.WorkspaceDefaultMedia, saves()));
// What the open dialog takes from a hand-edited file: originals in any case, anything else the proxies.
settings.WorkspaceDefaultMedia = "ORIGINALS";
Assert.True(rows.IsDefaultOriginals);
settings.WorkspaceDefaultMedia = "everything";
Assert.Equal((true, false), (rows.IsDefaultProxies, rows.IsDefaultOriginals));
}
[Test]
public void VersionOnRenderIsOnUntilTurnedOff()
{
var (settings, rows, saves) = WorkspaceRows();
Assert.True(rows.VersionOnRender);
rows.VersionOnRender = false;
Assert.Equal((false, 1), (settings.WorkspaceVersionOnRender, saves()));
rows.VersionOnRender = false;
Assert.Equal(1, saves(), "nothing to store");
rows.VersionOnRender = true;
Assert.Equal((true, 2), (settings.WorkspaceVersionOnRender, saves()));
}
[Test]
public void CleanAfterOffersItsDaysThenNever()
{
var (settings, rows, saves) = WorkspaceRows();
Assert.SequenceEqual([7, 14, 30, 60, 90, 0], rows.CleanAfterChoices.Select(c => c.Value));
Assert.Equal(("30 days", "Never"), (rows.CleanAfterChoices.Single(c => c.Value == 30).Label, rows.CleanAfterChoices[^1].Label));
Assert.Equal(30, rows.SelectedCleanAfter.Value);
Assert.Equal(Loc.L("Tooltips.Settings.Workspace.CleanAfter"), rows.CleanAfterToolTip);
rows.SelectedCleanAfter = rows.CleanAfterChoices.Single(c => c.Value == 7);
Assert.Equal((7, 1), (settings.WorkspaceCleanAfterDays, saves()));
rows.SelectedCleanAfter = rows.CleanAfterChoices[^1];
Assert.Equal((0, 2), (settings.WorkspaceCleanAfterDays, saves()));
Assert.Equal(Loc.L("Tooltips.Settings.Workspace.Never"), rows.CleanAfterToolTip);
settings.WorkspaceCleanAfterDays = 1;
Assert.Equal("1 day", rows.SelectedCleanAfter.Label);
Assert.SequenceEqual([1, 7, 14, 30, 60, 90, 0], rows.CleanAfterChoices.Select(c => c.Value));
settings.WorkspaceCleanAfterDays = -1;
Assert.Equal(0, rows.SelectedCleanAfter.Value);
}
[Test]
public void OpenProjectIsTheLastUsedUnlessMainOrAskIsChosen()
{
var (settings, rows, saves) = WorkspaceRows();
Assert.Equal((true, false, false), (rows.IsOpenLastUsed, rows.IsOpenMain, rows.IsOpenAsk));
rows.IsOpenMain = true;
Assert.Equal((WorkspaceOpenPolicy.Main, 1), (settings.WorkspaceOpenProject, saves()));
rows.IsOpenLastUsed = false;
Assert.Equal(1, saves());
rows.IsOpenAsk = true;
Assert.Equal((WorkspaceOpenPolicy.Ask, 2), (settings.WorkspaceOpenProject, saves()));
Assert.Equal((false, false, true), (rows.IsOpenLastUsed, rows.IsOpenMain, rows.IsOpenAsk));
rows.IsOpenLastUsed = true;
Assert.Equal((WorkspaceOpenPolicy.LastUsed, 3), (settings.WorkspaceOpenProject, saves()));
// A value the enum does not know reads as the default.
settings.WorkspaceOpenProject = (WorkspaceOpenPolicy)99;
Assert.Equal((true, false, false), (rows.IsOpenLastUsed, rows.IsOpenMain, rows.IsOpenAsk));
}
[Test]
public void AWorkspaceListThatChangesIsRaisedBeforeItsSelection()
{
var (settings, rows, _) = WorkspaceRows();
settings.WorkspaceSizeLimitGb = 300;
var raised = new List<string?>();
rows.PropertyChanged += (_, e) => raised.Add(e.PropertyName);
rows.SelectedSizeLimit = rows.SizeLimitChoices.Single(c => c.Value == 50);
Assert.SequenceEqual([nameof(rows.SizeLimitChoices), nameof(rows.SelectedSizeLimit), nameof(rows.SizeLimitToolTip)], raised);
raised.Clear();
rows.SelectedCleanAfter = rows.CleanAfterChoices.Single(c => c.Value == 90);
Assert.SequenceEqual([nameof(rows.CleanAfterChoices), nameof(rows.SelectedCleanAfter), nameof(rows.CleanAfterToolTip)], raised);
raised.Clear();
rows.SelectedKept = rows.KeptChoices.Single(c => c.Value == 5);
Assert.SequenceEqual([nameof(rows.KeptChoices), nameof(rows.SelectedKept)], raised);
}
[Test]
public void ResetRestoresEveryWorkspaceRowButKeepsTheFolderAndWhatItRemembers()
{
var (settings, rows, _) = WorkspaceRows();
var project = Guid.NewGuid();
settings.WorkspaceFolder = @"E:\Fast\Chronos workspace";
settings.WorkspaceRecent[Guid.NewGuid()] = project;
settings.WorkspaceOpened[project] = DateTimeOffset.UnixEpoch;
settings.WorkspaceSizeLimitGb = 0;
settings.WorkspaceDefaultMedia = Chronos.Core.Project.BundleMedia.Originals;
settings.WorkspaceAutoSync = false;
settings.WorkspaceVersionOnRender = false;
settings.WorkspaceKeptVersions = 5;
settings.WorkspaceCleanAfterDays = 0;
settings.WorkspaceOpenProject = WorkspaceOpenPolicy.Ask;
var raised = new List<string?>();
rows.PropertyChanged += (_, e) => raised.Add(e.PropertyName);
rows.Reset();
var defaults = new AppSettings();
Assert.Equal((defaults.WorkspaceSizeLimitGb, defaults.WorkspaceDefaultMedia, defaults.WorkspaceAutoSync, defaults.WorkspaceVersionOnRender),
(settings.WorkspaceSizeLimitGb, settings.WorkspaceDefaultMedia, settings.WorkspaceAutoSync, settings.WorkspaceVersionOnRender));
Assert.Equal((defaults.WorkspaceKeptVersions, defaults.WorkspaceCleanAfterDays, defaults.WorkspaceOpenProject),
(settings.WorkspaceKeptVersions, settings.WorkspaceCleanAfterDays, settings.WorkspaceOpenProject));
Assert.Equal((100, BundleMediaProxies, true, true, 20, 30, WorkspaceOpenPolicy.LastUsed),
(rows.SelectedSizeLimit.Value, settings.WorkspaceDefaultMedia, rows.AutoSync, rows.VersionOnRender, rows.SelectedKept.Value, rows.SelectedCleanAfter.Value,
settings.WorkspaceOpenProject));
Assert.Equal(@"E:\Fast\Chronos workspace", settings.WorkspaceFolder);
Assert.Count(1, settings.WorkspaceRecent);
Assert.Equal(DateTimeOffset.UnixEpoch, settings.WorkspaceOpened[project]);
Assert.Contains(raised, p => string.IsNullOrEmpty(p));
}
[Test]
public void MoveTakesTheFolderAlongAndWaitsWhileAMoveRuns()
{
var moving = false;
var moves = 0;
var (_, rows, _) = WorkspaceRows(new FakeWorkspace(), move: () =>
{
moves++;
return Task.CompletedTask;
}, isMoving: () => moving);
Assert.True(rows.CanMove);
Assert.True(rows.MoveCommand.CanExecute(null));
Assert.Equal(Loc.L("Tooltips.Settings.Workspace.Move"), rows.MoveToolTip);
rows.MoveCommand.Execute(null);
Assert.Equal(1, moves);
moving = true;
Assert.False(rows.MoveCommand.CanExecute(null));
Assert.False(rows.ChangeCommand.CanExecute(null), "the folder changes only once the move ends");
Assert.Equal(Loc.L("Errors.Workspace.Moving"), rows.MoveToolTip);
// Without the workspace's services (or a move), no Move… button.
var (_, bare, _) = WorkspaceRows();
Assert.False(bare.CanMove);
Assert.False(bare.MoveCommand.CanExecute(null));
Assert.Null(bare.UsageText);
Assert.Null(bare.TrashText);
}
[Test]
public async Task TheWorkspaceIsMeasuredWithItsTrash()
{
var workspace = new FakeWorkspace();
var pending = new TaskCompletionSource<WorkspaceUsage>();
workspace.Measure = _ => pending.Task;
var (_, rows, _) = WorkspaceRows(workspace);
var measuring = rows.MeasureAsync();
Assert.True(rows.IsMeasuring);
Assert.Equal(("Measuring…", "Measuring…"), (rows.UsageText, rows.TrashText));
Assert.False(rows.EmptyTrashCommand.CanExecute(null), "nothing to erase is known yet");
pending.SetResult(new WorkspaceUsage(MediaBytes: 9_000_000_000, TotalBytes: 12_400_000_000, TrashBytes: 1_200_000_000, TrashItems: 3));
await measuring;
Assert.False(rows.IsMeasuring);
Assert.Equal(("12.4 GB used", "3 items, 1.2 GB"), (rows.UsageText, rows.TrashText));
Assert.True(rows.HasUsageText);
Assert.True(rows.HasTrash);
Assert.True(rows.EmptyTrashCommand.CanExecute(null));
Assert.Equal(Loc.L("Tooltips.Settings.Workspace.EmptyTrash"), rows.EmptyTrashToolTip);
workspace.Measure = _ => Task.FromResult(new WorkspaceUsage(0, 4_000, 0, 0));
await rows.MeasureAsync();
Assert.Equal(("4 KB used", "Nothing in trash"), (rows.UsageText, rows.TrashText));
Assert.False(rows.HasTrash);
Assert.False(rows.EmptyTrashCommand.CanExecute(null));
Assert.Equal(Loc.L("Tooltips.Settings.Workspace.EmptyTrash.Disabled"), rows.EmptyTrashToolTip);
workspace.Measure = _ => Task.FromResult(new WorkspaceUsage(0, 1_000, 2_000, 1));
await rows.MeasureAsync();
Assert.Equal("1 item, 2 KB", rows.TrashText);
}
[Test]
public async Task ALaterMeasureReplacesOneStillRunningAndAFailureShowsNothing()
{
var workspace = new FakeWorkspace();
var first = new TaskCompletionSource<WorkspaceUsage>();
CancellationToken firstToken = default;
workspace.Measure = token =>
{
firstToken = token;
return first.Task;
};
var (_, rows, _) = WorkspaceRows(workspace);
var older = rows.MeasureAsync();
workspace.Measure = _ => Task.FromResult(new WorkspaceUsage(0, 2_000_000, 0, 0));
await rows.MeasureAsync();
Assert.True(firstToken.IsCancellationRequested, "the older measure is told to stop");
first.SetResult(new WorkspaceUsage(0, 9_000_000_000, 0, 5));
await older;
Assert.Equal(("2 MB used", false, false), (rows.UsageText, rows.HasTrash, rows.IsMeasuring));
workspace.Measure = _ => Task.FromException<WorkspaceUsage>(new IOException("the drive went away"));
await rows.MeasureAsync();
Assert.Null(rows.UsageText);
Assert.False(rows.HasUsageText);
Assert.Null(rows.TrashText);
Assert.False(rows.HasTrash);
}
[Test]
public async Task EmptyingTheWorkspaceTrashShowsItsPlanAndAsksForTheCountTyped()
{
var workspace = new FakeWorkspace { Confirmed = false };
var items = Enumerable.Range(1, 8).Select(i => new WorkspaceTrashItem($"{Guid.Empty:N}-{i}", i * 1_000_000, i, DateTimeOffset.UnixEpoch.AddDays(i))).ToList();
var plan = new WorkspaceTrashPlan(@"C:\workspace\.trash", items, items.Sum(i => i.Bytes), "fingerprint");
workspace.Plan = plan;
workspace.Measure = _ => Task.FromResult(new WorkspaceUsage(0, 50_000_000, plan.Bytes, items.Count));
var (_, rows, _) = WorkspaceRows(workspace);
await rows.MeasureAsync();
// Kept: the plan was shown, nothing erased.
await rows.EmptyTrashAsync();
var request = Assert.NotNull(workspace.Asked);
Assert.Equal(0, workspace.Emptied.Count);
Assert.Equal((Loc.L("Settings.Workspace.TrashPlan.Title"), "8", Loc.L("Settings.Workspace.TrashPlan.Type", "8")),
(request.Heading, request.TypedConfirmation, request.TypedPrompt));
Assert.True(request.IsDestructive);
Assert.Equal((Loc.L("Settings.Workspace.TrashPlan.Action"), Loc.L("Tooltips.Settings.Workspace.TrashPlan.Action"), Loc.L("Tooltips.Settings.Workspace.TrashPlan.Keep")),
(request.ActionText, request.ActionToolTip, request.SafeToolTip));
var lines = request.Detail!.Split(Environment.NewLine);
Assert.Equal(("Entries: 8", "Size: 36 MB"), (lines[0], lines[1]));
// The newest entries are named, the rest counted.
Assert.Equal(Loc.L("Settings.Workspace.TrashPlan.Item", items[7].Name, "8 MB", Formatting.Date(items[7].Trashed)), lines[2]);
Assert.Equal(2 + DeletePlansListed + 1, lines.Length);
Assert.Equal(Loc.Plural("Archive.Delete.More", 2), lines[^1]);
// Erased: exactly the plan shown, then told and measured again.
workspace.Confirmed = true;
workspace.Measure = _ => Task.FromResult(new WorkspaceUsage(0, 14_000_000, 0, 0));
await rows.EmptyTrashAsync();
Assert.Same(plan, Assert.Contains(workspace.Emptied, _ => true));
Assert.Equal((Loc.L("Settings.Workspace.TrashEmptied"), "36 MB", false), Assert.Contains(workspace.Notices, _ => true));
Assert.Equal("Nothing in trash", rows.TrashText);
// An empty trash asks nothing.
workspace.Asked = null;
workspace.Plan = new WorkspaceTrashPlan(@"C:\workspace\.trash", [], 0, string.Empty);
await rows.EmptyTrashAsync();
Assert.Null(workspace.Asked);
Assert.Null(SettingsTrashRequest(workspace.Plan));
}
[Test]
public async Task ATrashThatChangedSinceItsPlanIsNotEmptied()
{
var item = new WorkspaceTrashItem("copy", 1_000, 1, DateTimeOffset.UnixEpoch);
var workspace = new FakeWorkspace
{
Plan = new WorkspaceTrashPlan(@"C:\workspace\.trash", [item], 1_000, "before"),
Empty = _ => throw new WorkspaceException(Loc.L("Errors.Workspace.TrashChanged")),
};
workspace.Measure = _ => Task.FromResult(new WorkspaceUsage(0, 1_000, 1_000, 1));
var (_, rows, _) = WorkspaceRows(workspace);
await rows.EmptyTrashAsync();
Assert.Equal((Loc.L("Settings.Workspace.TrashNotEmptied"), Loc.L("Errors.Workspace.TrashChanged"), true), Assert.Contains(workspace.Notices, _ => true));
Assert.Equal("1 item, 1 KB", rows.TrashText);
workspace.Notices.Clear();
workspace.Empty = _ => throw new UnauthorizedAccessException("denied");
await rows.EmptyTrashAsync();
var (title, _, isError) = Assert.Contains(workspace.Notices, _ => true);
Assert.Equal((Loc.L("Settings.Workspace.TrashNotEmptied"), true), (title, isError));
}
[Test]
public async Task TheWorkspaceRowsReachTheWorkspaceHost()
{
var local = _context.CreateTempDirectory("local");
var environment = AppEnvironment.From(AppPaths.Resolve(_context.CreateTempDirectory("app"), local, []));
var settings = new AppSettings { WorkspaceFolder = _context.CreateTempDirectory("fast") };
var host = new WorkspaceHost(environment, settings, () => { }, () => null, () => null, () => null);
var notices = new List<string>();
var services = WorkspaceSettingsServices.For(host, new NoDialogs(), (title, _, _) => notices.Add(title), () => Task.CompletedTask);
Assert.False(services.IsMoving());
var rows = new WorkspaceSettingsRows(settings, () => { }, () => host.Root, () => { }, () => Task.CompletedTask, services);
await rows.MeasureAsync();
Assert.Equal(("Nothing in trash", false), (rows.TrashText, rows.HasTrash));
await rows.EmptyTrashAsync();
Assert.Empty(notices);
Assert.True(rows.CanMove);
}
[Test]
public async Task AMoveStoppedBeforeItEndedIsOfferedAgainAndHoldsChangeAndMove()
{
var stopped = true;
var resumed = 0;
var (_, rows, _) = WorkspaceRows(new FakeWorkspace(), move: () => Task.CompletedTask, isMoving: () => stopped, unfinished: () => stopped, resume: () =>
{
resumed++;
stopped = false;
return Task.CompletedTask;
});
await rows.MeasureAsync();
// Change and Move say why they wait; Resume takes the move up.
Assert.True(rows.CanResumeMove);
Assert.Equal((Loc.L("Tooltips.Settings.Workspace.MoveUnfinished"), Loc.L("Tooltips.Settings.Workspace.MoveUnfinished")), (rows.ChangeToolTip, rows.MoveToolTip));
Assert.False(rows.ChangeCommand.CanExecute(null));
Assert.False(rows.MoveCommand.CanExecute(null));
Assert.True(rows.ResumeMoveCommand.CanExecute(null));
rows.ResumeMoveCommand.Execute(null);
await Chronos.App.Tests.Workspace.WorkspaceTestBed.UntilAsync(() => !rows.ResumeMoveCommand.IsRunning, "the move taken up");
Assert.Equal(1, resumed);
Assert.False(rows.CanResumeMove);
Assert.Equal((Loc.L("Tooltips.Settings.ChangeWorkspace"), Loc.L("Tooltips.Settings.Workspace.Move")), (rows.ChangeToolTip, rows.MoveToolTip));
Assert.True(rows.ChangeCommand.CanExecute(null));
Assert.True(rows.MoveCommand.CanExecute(null));
}
[Test]
public async Task AMoveThatSwitchedHereAndLeftPartOfItsOldFolderStillHoldsChangeAndMove()
{
// The folder in use holds no journal (the move switched to it), but the old folder still does: Resume clears it,
// and another folder chosen first would leave that part with no Resume.
var (_, rows, _) = WorkspaceRows(new FakeWorkspace(), move: () => Task.CompletedTask, isMoving: () => false, unfinished: () => true,
resume: () => Task.CompletedTask);
await rows.MeasureAsync();
Assert.True(rows.CanResumeMove);
Assert.Equal((Loc.L("Tooltips.Settings.Workspace.MoveUnfinished"), Loc.L("Tooltips.Settings.Workspace.MoveUnfinished")), (rows.ChangeToolTip, rows.MoveToolTip));
Assert.False(rows.ChangeCommand.CanExecute(null));
Assert.False(rows.MoveCommand.CanExecute(null));
}
[Test]
public void ADefaultMediaOrOpenPolicySetElsewhereReadsAsEverythingAppliesIt()
{
var (settings, rows, _) = WorkspaceRows();
settings.WorkspaceDefaultMedia = "ORIGINALS";
Assert.Equal(Chronos.Core.Project.BundleMedia.Originals, settings.EffectiveDefaultMedia);
Assert.True(rows.IsDefaultOriginals);
settings.WorkspaceDefaultMedia = "raw files";
Assert.Equal(BundleMediaProxies, settings.EffectiveDefaultMedia);
Assert.True(rows.IsDefaultProxies);
settings.WorkspaceOpenProject = (WorkspaceOpenPolicy)42;
Assert.Equal(WorkspaceOpenPolicy.LastUsed, settings.EffectiveOpenPolicy);
Assert.True(rows.IsOpenLastUsed);
settings.WorkspaceOpenProject = WorkspaceOpenPolicy.Ask;
Assert.Equal(WorkspaceOpenPolicy.Ask, settings.EffectiveOpenPolicy);
Assert.False(rows.IsOpenLastUsed);
}
private const int DeletePlansListed = Chronos.App.Archiving.DeletePlans.ListedLines;
private const string BundleMediaProxies = Chronos.Core.Project.BundleMedia.Proxies;
private static ConfirmRequest? SettingsTrashRequest(WorkspaceTrashPlan plan) => WorkspaceSettingsRows.TrashRequest(plan);
private static (AppSettings Settings, WorkspaceSettingsRows Rows, Func<int> Saves) WorkspaceRows(FakeWorkspace? workspace = null, Func<Task>? move = null,
Func<bool>? isMoving = null, Func<bool>? unfinished = null, Func<Task>? resume = null)
{
var settings = new AppSettings();
var saves = 0;
WorkspaceSettingsServices? services = workspace is null ? null : new WorkspaceSettingsServices
{
Usage = token => workspace.Measure(token),
PlanTrash = _ => Task.FromResult(workspace.Plan),
EmptyTrash = (plan, _) =>
{
var result = workspace.Empty(plan);
workspace.Emptied.Add(plan);
return Task.FromResult(result);
},
Confirm = request =>
{
workspace.Asked = request;
return workspace.Confirmed;
},
Notify = (title, message, isError) => workspace.Notices.Add((title, message, isError)),
Move = move,
IsMoving = isMoving ?? (() => false),
HasUnfinishedMove = unfinished is null ? null : _ => Task.FromResult(unfinished()),
ResumeMove = resume,
};
var rows = new WorkspaceSettingsRows(settings, () => saves++, () => @"C:\Users\me\AppData\Local\Chronos\workspace", () => { }, () => Task.CompletedTask, services);
return (settings, rows, () => saves);
}
/// <summary>The workspace as Settings › Workspace reaches it: its usage, its trash's plan and emptying, the questions and toasts.</summary>
private sealed class FakeWorkspace
{
public Func<CancellationToken, Task<WorkspaceUsage>> Measure { get; set; } = _ => Task.FromResult(WorkspaceUsage.None);
public WorkspaceTrashPlan Plan { get; set; } = new(@"C:\workspace\.trash", [], 0, string.Empty);
public Func<WorkspaceTrashPlan, WorkspaceTrashResult> Empty { get; set; } = plan => new WorkspaceTrashResult(plan.Items.Count, plan.Bytes);
public bool Confirmed { get; set; } = true;
public ConfirmRequest? Asked { get; set; }
public List<WorkspaceTrashPlan> Emptied { get; } = [];
public List<(string Title, string? Message, bool IsError)> Notices { get; } = [];
}
private sealed class NoDialogs : IAppDialogs
{
public string? PickFolder(string title, string? initialFolder = null) => null;
public string? PickJsonFile(string title) => null;
public bool Confirm(ConfirmRequest request) => throw new InvalidOperationException("nothing to confirm");
public bool SignIn(string server, string? username, Func<string, string, Task<string?>> signIn) => false;
}
}