using System.Globalization;
using System.IO;
using Chronos.App.Jobs;
using Chronos.Core.Archiving;
using Chronos.Core.Localization;
using Chronos.Core.Model;
using Chronos.Data.Housekeeping;
using Chronos.Data.Scheduling;
using Chronos.Protocol;
using Chronos.Testing;
using Chronos.Ui.Controls;
namespace Chronos.App.Tests.Jobs;
/// Jobs › Scheduled (owner review 2, R10): the list, the switch, the row commands and the editor, on a real scheduler.
public sealed class SchedulesViewModelTests
{
private readonly TestContext _context;
public SchedulesViewModelTests(TestContext context)
{
_context = context;
Loc.SetCulture(CultureInfo.GetCultureInfo("en"));
}
[Test]
public async Task SystemSchedulesComeFirstInTheUsersLanguage()
{
await using var fx = await ScheduleFixture.CreateAsync(_context);
using var vm = await fx.ViewModelAsync();
Assert.True(vm.IsRunning && vm.IsLoaded && vm.HasRows, "the schedules are listed");
Assert.SequenceEqual(["Archive scan", "Index backup", "Housekeeping"], vm.Rows.Select(r => r.Name));
Assert.SequenceEqual(["Every 10 minutes", "Every day", "Daily at " + ScheduleText.Time(new TimeOnly(4, 0))], vm.Rows.Select(r => r.WhenText));
Assert.SequenceEqual(["Archive scan", "Index backup", "Clean-up"], vm.Rows.Select(r => r.ActionText));
Assert.True(vm.Rows.All(r => r.IsSystem && r.IsEnabled && r.LastText == "never run" && r.LastKind == StatusKind.Offline), "nothing ran yet");
// The scan's next run is ten minutes away, today.
Assert.Equal(ScheduleText.Moment(fx.Clock.Now.AddMinutes(10)), vm.Rows[0].NextText);
Assert.Equal(CleanupSteps.DefaultHistoryDays, vm.HistoryDays);
// A schedule the user creates joins the list after the system ones.
var created = await fx.Scheduler!.CreateAsync(new CreateScheduleRequest("Weekly check", ScheduleActions.Verify, new RecurrenceDto("weekly", Time: "02:30", Days: ["mon", "thu"])), null);
Assert.Null(created.Problem);
Assert.Equal("Weekly check", vm.Rows[3].Name);
Assert.Equal(ScheduleText.DayShort(DayOfWeek.Monday) + ", " + ScheduleText.DayShort(DayOfWeek.Thursday) + " at " + ScheduleText.Time(new TimeOnly(2, 30)),
vm.Rows[3].WhenText);
}
[Test]
public void RecurrencesReadAsTheTableShowsThem()
{
var at3 = ScheduleText.Time(new TimeOnly(3, 0));
Assert.Equal("Every 5 minutes", ScheduleText.When(ScheduleRecurrence.Interval(5, RecurrenceUnit.Minutes)));
Assert.Equal("Every hour", ScheduleText.When(ScheduleRecurrence.Interval(1, RecurrenceUnit.Hours)));
Assert.Equal("Every 6 hours", ScheduleText.When(ScheduleRecurrence.Interval(6, RecurrenceUnit.Hours)));
Assert.Equal("Every 2 days", ScheduleText.When(ScheduleRecurrence.Interval(2, RecurrenceUnit.Days)));
Assert.Equal("Daily at " + at3, ScheduleText.When(ScheduleRecurrence.DailyAt(new TimeOnly(3, 0))));
Assert.Equal("Daily at " + at3, ScheduleText.When(ScheduleRecurrence.WeeklyAt(Enum.GetValues(), new TimeOnly(3, 0))));
Assert.Equal("Sun at " + at3, ScheduleText.When(ScheduleRecurrence.WeeklyAt([DayOfWeek.Sunday], new TimeOnly(3, 0))));
Assert.Equal("Monthly, day 1 at " + at3, ScheduleText.When(ScheduleRecurrence.MonthlyAt(1, new TimeOnly(3, 0))));
Assert.Equal("Invalid recurrence", ScheduleText.When(new RecurrenceDto("hourly")));
// Outcomes: the job's state while it is known, else the run's own word.
Assert.Equal("skipped: busy", ScheduleText.Outcome(ScheduleOutcome.SkippedPending, null));
Assert.Equal("failed", ScheduleText.Outcome(ScheduleOutcome.Failed("disk full"), null));
Assert.Equal("queued", ScheduleText.Outcome(ScheduleOutcome.Queued, null));
var job = new Job { Id = Guid.CreateVersion7(), Kind = JobKind.Backup, State = JobState.Done };
Assert.Equal("done", ScheduleText.Outcome(ScheduleOutcome.Queued, job));
Assert.Equal(StatusKind.Done, ScheduleText.OutcomeKind(ScheduleOutcome.Queued, job));
Assert.Equal(StatusKind.Failed, ScheduleText.OutcomeKind(ScheduleOutcome.Failed("x"), null));
Assert.Contains("disk full", ScheduleText.OutcomeToolTip(ScheduleOutcome.Failed("disk full"), DateTimeOffset.UtcNow, null));
Assert.Equal("Off", ScheduleText.Next(DateTimeOffset.UtcNow, enabled: false));
Assert.Equal("Cache trim", ScheduleText.Step(CacheTrimStep.StepName));
Assert.Equal("someone-else", ScheduleText.Step("someone-else"));
}
[Test]
public async Task TheSwitchTurnsAScheduleOffAndOn()
{
await using var fx = await ScheduleFixture.CreateAsync(_context);
using var vm = await fx.ViewModelAsync();
var backup = vm.Rows.Single(r => r.Schedule.SystemKey == DesktopScheduleHost.IndexBackup);
await vm.SetEnabledAsync(backup, false);
Assert.False(backup.IsEnabled);
Assert.Equal("Off", backup.NextText);
var stored = (await fx.Db.Schedules.GetAsync(backup.Id))!;
Assert.Equal((false, (DateTimeOffset?)null), (stored.Enabled, stored.NextRun));
await vm.SetEnabledAsync(backup, true);
Assert.True(backup.IsEnabled);
Assert.Equal(fx.Clock.Now.AddDays(1), (await fx.Db.Schedules.GetAsync(backup.Id))!.NextRun);
// The housekeeping turned off keeps every job: the history line says so.
var housekeeping = vm.Rows.Single(r => r.Schedule.SystemKey == DesktopScheduleHost.Housekeeping);
await vm.SetEnabledAsync(housekeeping, false);
Assert.Null(vm.HistoryDays);
}
[Test]
public async Task RunNowShowsTheJobsStateAsTheLastResult()
{
await using var fx = await ScheduleFixture.CreateAsync(_context);
var toasts = new List();
using var vm = await fx.ViewModelAsync(toasts: toasts);
var backup = vm.Rows.Single(r => r.Schedule.SystemKey == DesktopScheduleHost.IndexBackup);
var next = backup.Schedule.NextRun;
await vm.RunNowAsync(backup);
Assert.Equal(ScheduleOutcome.Queued, backup.Schedule.LastOutcome);
Assert.Equal(next, backup.Schedule.NextRun);
Assert.Empty(toasts);
var job = (await fx.Db.Jobs.ListByScheduleAsync(backup.Id)).Single();
Assert.Equal(job.Id, backup.Schedule.LastJobId);
// The Jobs screen forwards the job's changes: the last result follows it, and so do the selected schedule's runs.
vm.Selected = backup;
await vm.RunsLoading;
Assert.SequenceEqual([job.Id], vm.Runs.Select(r => r.Id));
vm.OnJob(job with { State = JobState.Done });
Assert.Equal(("done", StatusKind.Done), (backup.LastText, backup.LastKind));
Assert.Equal("done", vm.Runs[0].StateText);
// Run again while that job is still pending (the engine runs nothing here): nothing new is queued, and a toast says why.
await vm.RunNowAsync(backup);
Assert.Equal(ScheduleOutcome.SkippedPending, backup.Schedule.LastOutcome);
Assert.Count(1, toasts);
Assert.Count(1, await fx.Db.Jobs.ListByScheduleAsync(backup.Id));
}
[Test]
public async Task UsersSchedulesAreDeletedSystemOnesReset()
{
await using var fx = await ScheduleFixture.CreateAsync(_context);
var answer = false;
using var vm = await fx.ViewModelAsync(confirm: _ => answer);
await fx.Scheduler!.CreateAsync(new CreateScheduleRequest("Orphans", ScheduleActions.Orphans, new RecurrenceDto("monthly", Time: "05:00", DayOfMonth: 1)), null);
var mine = vm.Rows.Single(r => !r.IsSystem);
var scan = vm.Rows.Single(r => r.Schedule.SystemKey == DesktopScheduleHost.ArchiveScan);
Assert.False(scan.DeleteCommand.CanExecute(null));
Assert.False(mine.ResetCommand.CanExecute(null));
await vm.DeleteAsync(mine);
Assert.Count(4, vm.Rows);
answer = true;
vm.Selected = mine;
await vm.DeleteAsync(mine);
Assert.Count(3, vm.Rows);
Assert.Null(vm.Selected);
Assert.Null(await fx.Db.Schedules.GetAsync(mine.Id));
await fx.Scheduler.UpdateAsync(scan.Id, new UpdateScheduleRequest(Recurrence: new RecurrenceDto("every", Every: 1, Unit: "hours"), CatchUp: true));
Assert.Equal("Every hour", scan.WhenText);
await vm.ResetAsync(scan);
Assert.Equal(("Every 10 minutes", false), (scan.WhenText, scan.Schedule.CatchUp));
}
/// A delete the index refuses (busy, locked) keeps the row: the schedule still runs, so it stays in sight.
[Test]
public async Task ADeleteThatFailsKeepsTheRow()
{
await using var fx = await ScheduleFixture.CreateAsync(_context);
var toasts = new List();
using var vm = await fx.ViewModelAsync(toasts: toasts);
await fx.Scheduler!.CreateAsync(new CreateScheduleRequest("Orphans", ScheduleActions.Orphans, new RecurrenceDto("monthly", Time: "05:00", DayOfMonth: 1)), null);
var mine = vm.Rows.Single(r => !r.IsSystem);
await using (var session = await fx.Db.Database.OpenAsync(_context.Cancellation))
{
await session.ExecuteScriptAsync("CREATE TRIGGER refuse_delete BEFORE DELETE ON schedules BEGIN SELECT RAISE(ABORT, 'the index is busy'); END;",
_context.Cancellation);
}
await vm.DeleteAsync(mine);
Assert.SequenceEqual([Loc.L("Jobs.Schedule.Failed")], toasts);
Assert.Count(4, vm.Rows);
Assert.Contains(mine, vm.Rows);
Assert.NotNull(await fx.Db.Schedules.GetAsync(mine.Id));
}
///
/// Whether this PC runs an action is read again when Jobs › Scheduled is shown: proxies turned on in Settings › Archive
/// make the Proxies schedule runnable and the action selectable, without a restart.
///
[Test]
public async Task ShowingTheTabReadsTheActionsAgain()
{
await using var fx = await ScheduleFixture.CreateAsync(_context);
var archive = await fx.Archives.CreateAsync(Path.Combine(fx.Folder, "archive"), "archive", proxies: new ProxyPolicy { LongEdge = ProxyPolicy.Disabled });
fx.Settings.LastArchivePath = archive.RootPath;
using var vm = await fx.ViewModelAsync();
Assert.Null((await fx.Scheduler!.CreateAsync(new CreateScheduleRequest("Proxies", ScheduleActions.Proxies, new RecurrenceDto("daily", Time: "01:00")), null)).Problem);
var proxies = vm.Rows.Single(r => !r.IsSystem);
Assert.False(vm.IsAvailable(ScheduleActions.Proxies));
Assert.False(proxies.RunNowCommand.CanExecute(null));
Assert.Equal(Loc.L("Tooltips.Jobs.Schedule.Unavailable.ProxiesDisabled"), proxies.RunNowToolTip);
vm.NewCommand.Execute(null);
var editor = Assert.NotNull(vm.Editor);
Assert.False(editor.ActionOptions.Single(a => a.Name == ScheduleActions.Proxies).IsAvailable);
await fx.Archives.UpdateSettingsAsync(archive.Id, a => a with { Proxies = a.Proxies with { LongEdge = 1920 } }, _context.Cancellation);
await vm.RefreshActionsAsync();
Assert.True(vm.IsAvailable(ScheduleActions.Proxies));
Assert.True(proxies.RunNowCommand.CanExecute(null));
Assert.Equal(Loc.L("Tooltips.Jobs.Schedule.RunNow"), proxies.RunNowToolTip);
Assert.Equal(ScheduleText.ActionToolTip(ScheduleActions.Proxies), proxies.ActionToolTip);
// The open editor follows too; what it had chosen stays chosen.
var chosen = editor.SelectedAction.Name;
Assert.True(editor.ActionOptions.Single(a => a.Name == ScheduleActions.Proxies).IsAvailable);
Assert.Equal(chosen, editor.SelectedAction.Name);
Assert.True(editor.ActionOptions.Any(o => ReferenceEquals(o, editor.SelectedAction)), "the choice is one of the new options");
editor.SelectedAction = editor.ActionOptions.Single(a => a.Name == ScheduleActions.Proxies);
Assert.Equal(ScheduleActions.Proxies, editor.SelectedAction.Name);
}
///
/// The last result follows the newest news of the last job: a read of it that started before a live change (or before
/// a later read) does not put back an older state.
///
[Test]
public async Task AReadOfTheLastJobNeverUndoesANewerChange()
{
await using var fx = await ScheduleFixture.CreateAsync(_context);
using var vm = await fx.ViewModelAsync();
var job = new Job { Id = Guid.CreateVersion7(), Kind = JobKind.Backup, State = JobState.Running };
// A row of its own: the view model reads nothing into it meanwhile.
var row = new ScheduleRowViewModel(vm.Rows[1].Schedule with { LastOutcome = ScheduleOutcome.Queued, LastJobId = job.Id }, vm);
// The job ends while it is read: the engine's Done comes first, the read's Running after it.
var read = row.BeginLastJobRead();
row.SetLastJob(job with { State = JobState.Done });
row.SetLoadedLastJob(job, read);
Assert.Equal(("done", StatusKind.Done), (row.LastText, row.LastKind));
// Two reads: the later one wins, whichever ends first.
var first = row.BeginLastJobRead();
var second = row.BeginLastJobRead();
row.SetLoadedLastJob(job with { State = JobState.Failed }, second);
row.SetLoadedLastJob(job, first);
Assert.Equal(StatusKind.Failed, row.LastKind);
// A read of the job of the previous run does not apply once the schedule has run again.
var stale = row.BeginLastJobRead();
row.Update(row.Schedule with { LastJobId = Guid.CreateVersion7() });
row.SetLoadedLastJob(job with { State = JobState.Done }, stale);
Assert.Null(row.LastJob);
Assert.Equal(("queued", StatusKind.Queued), (row.LastText, row.LastKind));
}
[Test]
public async Task TheEditorChecksEachFieldAndBuildsTheRecurrence()
{
await using var fx = await ScheduleFixture.CreateAsync(_context);
using var vm = await fx.ViewModelAsync();
vm.NewCommand.Execute(null);
var editor = Assert.NotNull(vm.Editor);
Assert.True(editor.IsNew && !editor.IsSystem && editor.CanChangeAction, "a new schedule of the user");
Assert.Equal(Loc.L("Tooltips.Jobs.Editor.NameMissing"), editor.Problem());
Assert.False(editor.SaveCommand.CanExecute(null));
editor.Name.Text = "Nightly thumbnails";
Assert.Null(editor.Problem());
Assert.Equal(new RecurrenceDto("daily", Time: "03:00"), editor.Recurrence());
// Every: the unit decides the range.
editor.KindIndex = 0;
editor.SelectedUnit = editor.Units.Single(u => u.Value == RecurrenceUnit.Minutes);
editor.Every.Text = "3";
Assert.Equal(Loc.L("Tooltips.Jobs.Editor.Number", "5", "1440"), editor.Problem());
Assert.Equal("—", editor.WhenText);
editor.SelectedUnit = editor.Units.Single(u => u.Value == RecurrenceUnit.Hours);
Assert.Null(editor.Problem());
Assert.Equal("Every 3 hours", editor.WhenText);
// Weekly: a time and at least one day.
editor.KindIndex = 2;
foreach (var day in editor.Days) day.IsChecked = false;
Assert.Equal(Loc.L("Tooltips.Jobs.Editor.NoDays"), editor.Problem());
editor.Days.Single(d => d.Value == DayOfWeek.Thursday).IsChecked = true;
editor.Days.Single(d => d.Value == DayOfWeek.Monday).IsChecked = true;
editor.Time.Text = "25:00";
Assert.Equal(Loc.L("Tooltips.Jobs.Editor.TimeInvalid"), editor.Problem());
editor.Time.Text = "2:30";
Assert.Equal("weekly:mon,thu@02:30", ScheduleMapping.FromDto(editor.Recurrence())!.Format());
// Monthly: days 1 to 28.
editor.KindIndex = 3;
editor.DayOfMonth.Text = "31";
Assert.NotNull(editor.Problem());
editor.DayOfMonth.Text = "28";
Assert.Equal("monthly:28@02:30", ScheduleMapping.FromDto(editor.Recurrence())!.Format());
// The action's own parameters, from its defaults.
editor.SelectedAction = editor.ActionOptions.Single(a => a.Name == ScheduleActions.Verify);
Assert.True(editor.ShowsOlderThan && editor.ShowsPercent && !editor.ShowsSteps, "verify's parameters");
Assert.Equal(("30", "100"), (editor.OlderThan.Text, editor.Percent.Text));
editor.Percent.Text = "0";
Assert.Equal(Loc.L("Tooltips.Jobs.Editor.Number", "1", "100"), editor.Problem());
editor.Percent.Text = "25";
Assert.Equal(new ScheduleParametersDto(OlderThanDays: 30, Percent: 25), editor.Parameters());
editor.SelectedPriority = editor.Priorities.Single(p => p.Value == JobPriority.Normal);
editor.CatchUp = false;
Assert.True(editor.SaveCommand.CanExecute(null), "the schedule can be saved");
await editor.SaveAsync();
Assert.Null(vm.Editor);
var saved = vm.Rows.Single(r => !r.IsSystem);
Assert.Equal((ScheduleActions.Verify, "monthly:28@02:30", "normal", false), (saved.Schedule.Action, ScheduleMapping.FromDto(saved.Schedule.Recurrence)!.Format(),
saved.Schedule.Priority, saved.Schedule.CatchUp));
Assert.Equal(new ScheduleParametersDto(OlderThanDays: 30, Percent: 25), saved.Schedule.Parameters);
Assert.Same(saved, vm.Selected);
}
[Test]
public async Task ASystemScheduleKeepsItsNameAndActionInTheEditor()
{
await using var fx = await ScheduleFixture.CreateAsync(_context);
using var vm = await fx.ViewModelAsync();
var housekeeping = vm.Rows.Single(r => r.Schedule.SystemKey == DesktopScheduleHost.Housekeeping);
housekeeping.EditCommand.Execute(null);
var editor = Assert.NotNull(vm.Editor);
Assert.True(editor.IsSystem && !editor.CanChangeAction, "a system schedule");
Assert.Equal("Housekeeping", editor.SystemName);
// The steps this PC runs, the schedule's own checked.
Assert.SequenceEqual([CleanupSteps.JobHistory, CleanupSteps.Audit, CleanupSteps.TrashReport, CacheTrimStep.StepName], editor.Steps.Select(s => s.Value));
Assert.SequenceEqual([CleanupSteps.JobHistory, CacheTrimStep.StepName], editor.Steps.Where(s => s.IsChecked).Select(s => s.Value));
foreach (var step in editor.Steps) step.IsChecked = false;
Assert.Equal(Loc.L("Tooltips.Jobs.Editor.NoSteps"), editor.Problem());
editor.Steps[0].IsChecked = true;
editor.OlderThan.Text = "30";
var update = editor.BuildUpdate();
Assert.Equal(((string?)null, (string?)null), (update.Name, update.Action));
await editor.SaveAsync();
Assert.Null(vm.Editor);
Assert.Equal(30, vm.HistoryDays);
Assert.SequenceEqual([CleanupSteps.JobHistory], housekeeping.Schedule.Parameters.Steps!);
Assert.Equal("Housekeeping", housekeeping.Name);
}
}