using Chronos.App.Jobs; using Chronos.Core.Model; using Chronos.Testing; namespace Chronos.App.Tests.Jobs; /// UI-08: which job endings raise the shell's toast, whichever screen started the job, and how a batch speaks once. public sealed class JobNoticesTests { [Theory] [Case(JobKind.Render)] [Case(JobKind.DeepAnalyse)] [Case(JobKind.Verify)] [Case(JobKind.Rebuild)] [Case(JobKind.Maintenance)] [Case(JobKind.UploadCommit)] [Case(JobKind.Move)] [Case(JobKind.Adopt)] [Case(JobKind.Convert)] [Case(JobKind.WorkspaceRender)] [Case(JobKind.WorkspaceSend)] [Case(JobKind.WorkspaceMove)] public void ALongOperationThatEndsSaysSo(JobKind kind) { Assert.Equal(JobNotice.Done, JobNotices.For(JobState.Running, Job(kind, JobState.Done))); Assert.Equal(JobNotice.Failed, JobNotices.For(JobState.Running, Job(kind, JobState.Failed))); // Queued and finished between two flushes of the Jobs screen: still one notice. Assert.Equal(JobNotice.Done, JobNotices.For(JobState.Queued, Job(kind, JobState.Done))); Assert.Equal(JobNotice.Done, JobNotices.For(null, Job(kind, JobState.Done))); } [Theory] [Case(JobKind.Scan)] [Case(JobKind.LightAnalyse)] [Case(JobKind.Thumbs)] [Case(JobKind.Proxies)] [Case(JobKind.Cleanup)] public void UpkeepAndScansEndSilently(JobKind kind) { Assert.Equal(JobNotice.None, JobNotices.For(JobState.Running, Job(kind, JobState.Done))); Assert.Equal(JobNotice.None, JobNotices.For(JobState.Running, Job(kind, JobState.Failed))); } [Theory] [Case(JobKind.Import)] [Case(JobKind.Download)] [Case(JobKind.Duplicates)] [Case(JobKind.Orphans)] [Case(JobKind.Backup)] public void EveryOtherFailureIsSaid(JobKind kind) { // An import announces its result on the Import screen, a download on its Library card and Server row. Assert.Equal(JobNotice.None, JobNotices.For(JobState.Running, Job(kind, JobState.Done))); Assert.Equal(JobNotice.Failed, JobNotices.For(JobState.Running, Job(kind, JobState.Failed))); } [Test] public void BackgroundPriorityCancelledAndRepeatedEndingsSayNothing() { // The deep analysis queued after an import, and the proxies sync fetches, run in the background. Assert.Equal(JobNotice.None, JobNotices.For(JobState.Running, Job(JobKind.DeepAnalyse, JobState.Done, JobPriority.Background))); Assert.Equal(JobNotice.None, JobNotices.For(JobState.Running, Job(JobKind.Download, JobState.Failed, JobPriority.Background))); Assert.Equal(JobNotice.None, JobNotices.For(JobState.Running, Job(JobKind.Render, JobState.Cancelled))); Assert.Equal(JobNotice.None, JobNotices.For(JobState.Done, Job(JobKind.Render, JobState.Done))); Assert.Equal(JobNotice.None, JobNotices.For(JobState.Failed, Job(JobKind.Render, JobState.Failed))); Assert.Equal(JobNotice.None, JobNotices.For(JobState.Queued, Job(JobKind.Render, JobState.Running))); // "Add to queue" renders have Normal priority: they are announced too. Assert.Equal(JobNotice.Done, JobNotices.For(JobState.Running, Job(JobKind.Render, JobState.Done, JobPriority.Normal))); } [Test] public void ABatchOfOneKindSpeaksOnceWhenItsLastJobEnds() { // Server › Upload all: 100 uploads queued; each one that ends waits for the rest. var endings = new JobEndings(); var model = new JobListModel(); var uploads = Enumerable.Range(0, 100).Select(_ => Job(JobKind.UploadCommit, JobState.Queued)).ToList(); foreach (var upload in uploads) model.Apply(upload); for (var i = 0; i < 99; i++) { var done = uploads[i] with { State = JobState.Done }; model.Apply(done); endings.Add(JobNotices.For(JobState.Running, done), done); Assert.Empty(endings.Take(model.IsBusy)); } Assert.Equal(99, endings.Waiting); // A render of the same flush is its own kind: it is said at once. var render = Job(JobKind.Render, JobState.Done); model.Apply(render); endings.Add(JobNotice.Done, render); var due = endings.Take(model.IsBusy); Assert.Count(1, due); Assert.Equal(JobNotice.Done, due[0].Notice); Assert.SequenceEqual([render.Id], due[0].Jobs.Select(j => j.Id)); var last = uploads[99] with { State = JobState.Done }; model.Apply(last); endings.Add(JobNotice.Done, last); due = endings.Take(model.IsBusy); Assert.Count(1, due); Assert.SequenceEqual(uploads.Select(u => u.Id), due[0].Jobs.Select(j => j.Id)); Assert.Equal(0, endings.Waiting); Assert.Empty(endings.Take(model.IsBusy)); } [Test] public void PausedAndBackgroundJobsDoNotHoldABatch() { var endings = new JobEndings(); var model = new JobListModel(); // An upload paused on a metered network, and the proxies sync fetches in the background, wait for something else. model.Apply(Job(JobKind.UploadCommit, JobState.Paused)); model.Apply(Job(JobKind.Download, JobState.Running, JobPriority.Background)); var upload = Job(JobKind.UploadCommit, JobState.Done); model.Apply(upload); endings.Add(JobNotice.Done, upload); Assert.Count(1, endings.Take(model.IsBusy)); Assert.False(model.IsBusy(JobKind.UploadCommit)); Assert.False(model.IsBusy(JobKind.Download)); } [Test] public void FailuresAreSaidAtTheEndOfTheirFlushTogether() { var endings = new JobEndings(); var model = new JobListModel(); // More uploads still run: failures do not wait for them. model.Apply(Job(JobKind.UploadCommit, JobState.Running)); var first = Job(JobKind.UploadCommit, JobState.Failed); var second = Job(JobKind.Verify, JobState.Failed); endings.Add(JobNotice.Failed, first); endings.Add(JobNotice.Failed, second); endings.Add(JobNotice.None, Job(JobKind.Scan, JobState.Done)); var due = endings.Take(model.IsBusy); Assert.Count(1, due); Assert.Equal(JobNotice.Failed, due[0].Notice); Assert.SequenceEqual([first.Id, second.Id], due[0].Jobs.Select(j => j.Id)); // The next flush starts again. var third = Job(JobKind.UploadCommit, JobState.Failed); endings.Add(JobNotice.Failed, third); due = endings.Take(model.IsBusy); Assert.Count(1, due); Assert.SequenceEqual([third.Id], due[0].Jobs.Select(j => j.Id)); Assert.Empty(endings.Take(model.IsBusy)); } /// Owner review 2, R10: a schedule's background run is said only when it fails, unless the next run repeats it anyway. [Theory] [Case(JobKind.Backup)] [Case(JobKind.Verify)] [Case(JobKind.Maintenance)] [Case(JobKind.Duplicates)] [Case(JobKind.DeepAnalyse)] public void AScheduledBackgroundRunIsSaidOnlyWhenItFails(JobKind kind) { var schedule = Guid.CreateVersion7(); Assert.Equal(JobNotice.None, JobNotices.For(JobState.Running, Job(kind, JobState.Done, JobPriority.Background) with { ScheduleId = schedule })); Assert.Equal(JobNotice.Failed, JobNotices.For(JobState.Running, Job(kind, JobState.Failed, JobPriority.Background) with { ScheduleId = schedule })); Assert.Equal(JobNotice.None, JobNotices.For(JobState.Failed, Job(kind, JobState.Failed, JobPriority.Background) with { ScheduleId = schedule })); Assert.Equal(JobNotice.None, JobNotices.For(JobState.Running, Job(kind, JobState.Cancelled, JobPriority.Background) with { ScheduleId = schedule })); // The same work queued in the background by something else stays silent. Assert.Equal(JobNotice.None, JobNotices.For(JobState.Running, Job(kind, JobState.Failed, JobPriority.Background))); } [Theory] [Case(JobKind.Scan)] [Case(JobKind.Thumbs)] [Case(JobKind.Proxies)] [Case(JobKind.LightAnalyse)] [Case(JobKind.Cleanup)] public void AScheduledUpkeepRunEndsSilently(JobKind kind) { var schedule = Guid.CreateVersion7(); Assert.Equal(JobNotice.None, JobNotices.For(JobState.Running, Job(kind, JobState.Done, JobPriority.Background) with { ScheduleId = schedule })); Assert.Equal(JobNotice.None, JobNotices.For(JobState.Running, Job(kind, JobState.Failed, JobPriority.Background) with { ScheduleId = schedule })); } [Test] public void AScheduledRunAtAHigherPriorityIsSaidAsAnyOther() { var verify = Job(JobKind.Verify, JobState.Done, JobPriority.Normal) with { ScheduleId = Guid.CreateVersion7() }; Assert.Equal(JobNotice.Done, JobNotices.For(JobState.Running, verify)); } private static Job Job(JobKind kind, JobState state, JobPriority priority = JobPriority.User) => new() { Id = Guid.CreateVersion7(), Kind = kind, State = state, Priority = priority, TargetLabel = "Harbour sunset", Created = DateTimeOffset.UtcNow, }; }