using System.Globalization; using Chronos.App.Jobs; 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)); } [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); } }