Settle what the R10 scheduler and R11 log packages left open when they were integrated (owner review 2, phase 2). - Audit retention has one source of truth, the audit-cleanup schedule's age limit. AuditRetentionDays defaults to 0 (the audit log is kept forever, so an upgrade deletes nothing; the schedule is seeded off) and accepts 0-3650, what a schedule's age limit takes. Saving Settings › Logs › Keep audit sets the schedule's limit (on with a limit, off at 0) without a restart; CHRONOS_AUDIT_RETENTION_DAYS locks it and Reset goes back to it. - Both hosts scan right after start again, as their polling did: the server after the scheduler starts, the desktop once the archive was reopened and again when an unplugged one is back. Scheduler.RunSystemNowAsync runs the archive-scan schedule when it is enabled and has not run since the start, and skips while its scan is pending. - Desktop scans follow Settings › Analysis › After a scan at every run: a scan schedule without its own deep parameter asks the host (IScheduleHost.DeepAnalysisAfterScan), the archive-scan schedule no longer freezes the setting, and the editor offers deep only for analyses, so the setting's tooltip stays true. - The server's upload clean-up runs every 6 hours instead of every 30 minutes, to keep the job history readable; idle uploads still expire after UploadRetentionHours. - The Unraid template and docker-compose leave CHRONOS_LOG_LEVEL empty or commented out, and say that setting it locks both log levels, so the admin panel can change them. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
167 lines
8.4 KiB
C#
167 lines
8.4 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>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();
|
||
}
|
||
}
|
||
}
|