Owner review 2, phase 2 (R10) review findings on the desktop: - Showing the Scheduled tab (and coming back to Jobs on it) reads the actions' availability again, as does a Run now answered unavailable; rows and an open editor follow, so turning proxies on no longer needs a restart. - A delete the index refuses keeps the row: the failed call no longer reads as Deleted (the enum's default), so a live schedule never leaves the page. - SchedulerReady completes false when the index (or the engine) does not open, so the tab shows that the schedules do not run instead of an empty panel. - A read of a schedule's last job that started before a live change or a later read is ignored, so a finished job no longer shows as running. - The editor's Action, Unit and Priority dropdowns follow a language change, keeping what was chosen. - Weekly days in the table read from the UI language's first day, as the editor's toggles do. - Backup tooltips no longer promise daily copies with three kept (their translations are dropped for retranslation); two tooltips now name the real Settings rows (Proxy size; Spazio su disco › Limite della cache). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> (cherry picked from commit c137e2c74cddef299b2e4179ef0417fa4977953c)
208 lines
10 KiB
C#
208 lines
10 KiB
C#
using System.IO;
|
||
using Chronos.App.Infrastructure;
|
||
using Chronos.App.Jobs;
|
||
using Chronos.App.Tests.Uploader;
|
||
using Chronos.Core.Model;
|
||
using Chronos.Data;
|
||
using Chronos.Data.Archiving;
|
||
using Chronos.Data.Scheduling;
|
||
using Chronos.Testing;
|
||
|
||
namespace Chronos.App.Tests.Infrastructure;
|
||
|
||
public sealed class AppServicesTests
|
||
{
|
||
/// <summary>Dialogs that answer like a user who cancels everything.</summary>
|
||
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) => false;
|
||
public bool SignIn(string server, string? username, Func<string, string, Task<string?>> signIn) => false;
|
||
}
|
||
|
||
[Test]
|
||
[WindowsOnly]
|
||
public void ExitStopsTheSchedulesAndTheEngineWhileTheUiThreadWaits()
|
||
{
|
||
var environment = AppEnvironment.ForCapture();
|
||
try
|
||
{
|
||
SingleThreadedContext.Run(async () =>
|
||
{
|
||
var root = Path.Combine(environment.DataDirectory, "archive");
|
||
await using (var setup = await ChronosDatabase.OpenAsync(DatabaseOptions.Sqlite(Path.Combine(environment.DataDirectory, "setup.db"))))
|
||
await new ArchiveService(setup).CreateAsync(root, "Exit");
|
||
var services = new AppServices(environment, new AppSettings { Language = "en", LastArchivePath = root }, () => { }, new NoDialogs());
|
||
await services.OpenAsync(environment.DatabasePath);
|
||
// The archive was reopened, then the schedules started (owner review 2, R10) and its scan schedule ran at once,
|
||
// as the rescans did at start: a scan of it is queued without waiting for the interval.
|
||
Assert.True(await services.SchedulerReady, "the schedules started");
|
||
var scan = Assert.NotNull(await services.Database!.Schedules.GetBySystemKeyAsync(DesktopScheduleHost.ArchiveScan));
|
||
var until = DateTime.UtcNow + TimeSpan.FromSeconds(30);
|
||
while (!(await services.Database!.Jobs.ListAsync(null, JobKind.Scan)).Items.Any(j => j.ScheduleId == scan.Id))
|
||
{
|
||
Assert.True(DateTime.UtcNow < until, "no scan at start");
|
||
await Task.Delay(50);
|
||
}
|
||
|
||
// App.OnExit blocks the UI thread until the services stop: nothing they await may continue on it.
|
||
Assert.True(services.DisposeAsync().AsTask().Wait(TimeSpan.FromSeconds(10)), "services stopped");
|
||
});
|
||
}
|
||
finally
|
||
{
|
||
environment.DeleteCaptureData();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// BRIEF §7, owner review 2 R10: the scheduled scans follow the archive folder, also one chosen after the start (first
|
||
/// run, Settings, relink).
|
||
/// </summary>
|
||
[Test]
|
||
[WindowsOnly]
|
||
public void ScheduledScansFollowTheArchiveFolderChosenAfterTheStart()
|
||
{
|
||
var environment = AppEnvironment.ForCapture();
|
||
try
|
||
{
|
||
SingleThreadedContext.Run(async () =>
|
||
{
|
||
// The first run: the index opens before any archive folder is set.
|
||
var settings = new AppSettings { Language = "en" };
|
||
var services = new AppServices(environment, settings, () => { }, new NoDialogs());
|
||
try
|
||
{
|
||
await services.OpenAsync(environment.DatabasePath);
|
||
Assert.True(await services.SchedulerReady, "the schedules started");
|
||
Assert.Null(await services.ScheduleHost.GetArchiveAsync(default));
|
||
// The scans run all the same, on the schedule seeded from the former Settings › Archive › Rescan every.
|
||
var scan = Assert.NotNull(await services.Database!.Schedules.GetBySystemKeyAsync(DesktopScheduleHost.ArchiveScan));
|
||
Assert.Equal("every:10m", scan.Recurrence);
|
||
Assert.Equal(ScheduleOutcome.SkippedOffline, (await services.Scheduler!.RunNowAsync(scan.Id, null))?.Outcome);
|
||
|
||
// The first-run dialog creates an archive: the schedules work on it.
|
||
var firstRoot = Path.Combine(environment.DataDirectory, "first");
|
||
await services.ArchiveSetup.CreateAsync(firstRoot);
|
||
var first = Assert.NotNull(await services.ScheduleHost.GetArchiveAsync(default));
|
||
Assert.Equal("first", first.Name);
|
||
|
||
// Settings › Archive moves to another archive, which the index lists after the first one: the next scheduled
|
||
// scan is of the archive at the folder, no longer of the first one.
|
||
var other = Path.Combine(environment.DataDirectory, "zeta");
|
||
await new ArchiveService(services.Database!).CreateAsync(other, "zeta");
|
||
Assert.Equal("first", (await services.Database!.Archives.ListAsync())[0].Name);
|
||
async Task<int> ScansOfAsync(Guid archiveId) =>
|
||
(await services.Database!.Jobs.ListAsync(null, JobKind.Scan)).Items.Count(j => j.TargetIds.Contains(archiveId));
|
||
var scansOfFirst = await ScansOfAsync(first.Id);
|
||
settings.LastArchivePath = other;
|
||
services.SaveSettings();
|
||
var rescanned = Assert.NotNull(await services.ScheduleHost.GetArchiveAsync(default));
|
||
Assert.Equal("zeta", rescanned.Name);
|
||
Assert.Equal(ScheduleOutcome.Queued, (await services.Scheduler.RunNowAsync(scan.Id, null))?.Outcome);
|
||
Assert.True(await ScansOfAsync(rescanned.Id) > 0, "the archive at the folder is rescanned");
|
||
Assert.Equal(scansOfFirst, await ScansOfAsync(first.Id));
|
||
|
||
// And back: the folder decides, whatever the order of the index.
|
||
settings.LastArchivePath = firstRoot;
|
||
services.SaveSettings();
|
||
Assert.Equal(first.Id, (await services.ScheduleHost.GetArchiveAsync(default))?.Id);
|
||
}
|
||
finally
|
||
{
|
||
Assert.True(services.DisposeAsync().AsTask().Wait(TimeSpan.FromSeconds(10)), "services stopped");
|
||
}
|
||
});
|
||
}
|
||
finally
|
||
{
|
||
environment.DeleteCaptureData();
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Owner review 2, R10: when the index does not open, the schedules are known not to run at once, so Jobs › Scheduled
|
||
/// says so instead of waiting for them with an empty tab.
|
||
/// </summary>
|
||
[Test]
|
||
[WindowsOnly]
|
||
public void AnIndexThatDoesNotOpenTellsTheScheduledTabTheSchedulesDoNotRun()
|
||
{
|
||
var environment = AppEnvironment.ForCapture();
|
||
try
|
||
{
|
||
SingleThreadedContext.Run(async () =>
|
||
{
|
||
// "File is not a database", and no staged restore to recover it.
|
||
Directory.CreateDirectory(Path.GetDirectoryName(environment.DatabasePath)!);
|
||
await File.WriteAllBytesAsync(environment.DatabasePath, [.. Enumerable.Repeat((byte)0x5A, 8192)]);
|
||
var services = new AppServices(environment, new AppSettings { Language = "en" }, () => { }, new NoDialogs());
|
||
try
|
||
{
|
||
await services.OpenAsync(environment.DatabasePath);
|
||
Assert.NotNull(services.OpenError);
|
||
var ready = services.SchedulerReady;
|
||
Assert.Same(ready, await Task.WhenAny(ready, Task.Delay(TimeSpan.FromSeconds(TestTiming.Budget(10)))));
|
||
Assert.False(await ready, "no schedules without an index");
|
||
|
||
using var schedules = new SchedulesViewModel(() => services.Scheduler, () => services.Database, _ => false, (_, _, _) => { }, _ => Task.CompletedTask);
|
||
await schedules.AttachAsync(services.SchedulerReady);
|
||
Assert.True(schedules.IsLoaded && schedules.IsUnavailable && !schedules.IsRunning, "the tab shows that the schedules do not run");
|
||
}
|
||
finally
|
||
{
|
||
Assert.True(services.DisposeAsync().AsTask().Wait(TimeSpan.FromSeconds(10)), "services stopped");
|
||
}
|
||
});
|
||
}
|
||
finally
|
||
{
|
||
environment.DeleteCaptureData();
|
||
}
|
||
}
|
||
|
||
/// <summary>BRIEF §6.2: a restore staged in Settings › Advanced recovers an index that no longer opens.</summary>
|
||
[Test]
|
||
[WindowsOnly]
|
||
public void AStagedRestoreRecoversAnIndexThatNoLongerOpens()
|
||
{
|
||
var environment = AppEnvironment.ForCapture();
|
||
try
|
||
{
|
||
SingleThreadedContext.Run(async () =>
|
||
{
|
||
await using (var db = await ChronosDatabase.OpenAsync(DatabaseOptions.Sqlite(environment.DatabasePath)))
|
||
{
|
||
await db.Archives.UpsertAsync(new Archive { Id = Guid.CreateVersion7(), Name = "Kept", RootPath = @"C:\Kept", Created = DateTimeOffset.UtcNow });
|
||
var backup = await db.BackupAsync(environment.BackupDirectory, DatabaseBackups.Keep);
|
||
await DatabaseBackups.StageRestoreAsync(backup, environment.DatabasePath);
|
||
}
|
||
// The index is damaged beyond opening ("file is not a database").
|
||
File.Delete(environment.DatabasePath + "-wal");
|
||
File.Delete(environment.DatabasePath + "-shm");
|
||
await File.WriteAllBytesAsync(environment.DatabasePath, [.. Enumerable.Repeat((byte)0x5A, 8192)]);
|
||
|
||
var services = new AppServices(environment, new AppSettings { Language = "en" }, () => { }, new NoDialogs());
|
||
try
|
||
{
|
||
await services.OpenAsync(environment.DatabasePath);
|
||
|
||
Assert.Null(services.OpenError);
|
||
Assert.Equal(StagedRestoreResult.Restored, services.StagedRestore);
|
||
Assert.SequenceEqual(["Kept"], (await services.Database!.Archives.ListAsync()).Select(a => a.Name));
|
||
Assert.False(DatabaseBackups.HasStagedRestore(environment.DatabasePath));
|
||
}
|
||
finally
|
||
{
|
||
Assert.True(services.DisposeAsync().AsTask().Wait(TimeSpan.FromSeconds(10)), "services stopped");
|
||
}
|
||
});
|
||
}
|
||
finally
|
||
{
|
||
environment.DeleteCaptureData();
|
||
}
|
||
}
|
||
}
|