CI / Build and test (push) Successful in 9m26s
CI / Windows tests and installer (push) Skipped
CI / YAML check (push) Successful in 8s
Release / Build, test and publish (push) Successful in 14m31s
CI / PostgreSQL 16 integration (push) Successful in 9m53s
CI / PostgreSQL 17 integration (push) Successful in 9m22s
CI / Docker image (push) Successful in 44s
Release / Server image (push) Successful in 1m36s
Originals in the workspace, local render and send home with provenance, the workspace clean-up, size limit and trash, moving the workspace folder, and the complete Settings › Workspace page (owner review 2, R8, phase 5c). One adversarial review round (35 findings, 32 fixed), a copy-cancel race fixed, 184 strings in all 38 languages. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Co-authored-by: Alberto Balbo <alberto.balbo.96@gmail.com>
817 lines
44 KiB
C#
817 lines
44 KiB
C#
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;
|
||
}
|
||
}
|