using System.Collections.Concurrent; using Titano.App.Editor; using Titano.Core.Project; using Titano.Testing; namespace Titano.App.Tests.Editor; /// Debouncing and cancellation of preview work, and the coalescing project writer. public sealed class SchedulingTests { [Test] public async Task OnlyTheLastOfRapidRequestsRuns() { using var runner = new LatestRunner(TimeSpan.FromMilliseconds(80)); var ran = new ConcurrentQueue(); var tasks = Enumerable.Range(0, 10).Select(i => runner.Schedule(_ => { ran.Enqueue(i); return Task.CompletedTask; })).ToList(); await Task.WhenAll(tasks); Assert.SequenceEqual([9], ran); } [Test] public async Task ANewRequestCancelsTheRunningOne() { using var runner = new LatestRunner(TimeSpan.Zero); var started = new TaskCompletionSource(); var cancelled = false; var first = runner.Schedule(async token => { started.SetResult(); try { await Task.Delay(Timeout.Infinite, token); } catch (OperationCanceledException) { cancelled = true; throw; } }); await started.Task; var second = runner.Schedule(_ => Task.CompletedTask); await Task.WhenAll(first, second); Assert.True(cancelled, "the superseded run saw its token cancelled"); Assert.True(first.IsCompletedSuccessfully, "a superseded run ends quietly"); } [Test] public async Task ImmediateRequestsSkipTheDelay() { using var runner = new LatestRunner(TimeSpan.FromSeconds(30)); var ran = false; await runner.Schedule(_ => { ran = true; return Task.CompletedTask; }, immediate: true).WaitAsync(TimeSpan.FromSeconds(10)); Assert.True(ran); } [Test] public async Task FailuresSurfaceFromTheRun() { using var runner = new LatestRunner(TimeSpan.Zero); await Assert.ThrowsAsync(() => runner.Schedule(_ => throw new InvalidOperationException("broken"))); } [Test] public async Task CancelStopsThePendingRequest() { using var runner = new LatestRunner(TimeSpan.FromMilliseconds(200)); var ran = false; var run = runner.Schedule(_ => { ran = true; return Task.CompletedTask; }); runner.Cancel(); await run; Assert.False(ran); } [Test] public async Task TheSaverWritesTheNewestProjectOnce() { var saved = new List(); var saver = new ProjectSaver(p => { saved.Add(p.HeroFrame); return Task.CompletedTask; }, TimeSpan.FromMilliseconds(50)); for (var i = 0; i < 5; i++) saver.Schedule(new ProjectSettings { HeroFrame = i }); await saver.FlushAsync(); Assert.SequenceEqual([(int?)4], saved); Assert.False(saver.HasPendingChanges); } [Test] public async Task FlushSkipsTheDelay() { var saved = 0; var saver = new ProjectSaver(_ => { saved++; return Task.CompletedTask; }, TimeSpan.FromMinutes(5)); saver.Schedule(new ProjectSettings()); await saver.FlushAsync().WaitAsync(TimeSpan.FromSeconds(10)); Assert.Equal(1, saved); } [Test] public async Task AFailedWriteIsRetriedUntilStored() { var attempts = 0; var stored = new List(); var failures = new List(); var saver = new ProjectSaver(p => { if (++attempts <= 2) throw new System.IO.IOException("offline"); stored.Add(p.HeroFrame); return Task.CompletedTask; }, TimeSpan.Zero); saver.Failed += (_, count) => failures.Add(count); // Without a delay the first write happens at once and fails; the flush retries at once and fails again. saver.Schedule(new ProjectSettings { HeroFrame = 7 }); Assert.False(await saver.FlushAsync()); Assert.True(saver.HasPendingChanges, "kept pending after a failure"); Assert.NotNull(saver.LastError); Assert.True(await saver.FlushAsync().WaitAsync(TimeSpan.FromSeconds(10)), "a flush skips the retry delay"); Assert.SequenceEqual([(int?)7], stored); Assert.SequenceEqual([1, 2], failures, "failures in a row are counted"); Assert.False(saver.HasPendingChanges); Assert.Null(saver.LastError); } [Test] public async Task ARetryWritesTheNewestChange() { var fail = true; var stored = new List(); var saver = new ProjectSaver(p => { if (fail) throw new System.IO.IOException("offline"); stored.Add(p.HeroFrame); return Task.CompletedTask; }, TimeSpan.Zero); saver.Schedule(new ProjectSettings { HeroFrame = 1 }); Assert.False(await saver.FlushAsync()); saver.Schedule(new ProjectSettings { HeroFrame = 2 }); fail = false; Assert.True(await saver.FlushAsync()); Assert.SequenceEqual([(int?)2], stored, "the newer project contains the failed one"); } [Test] public async Task StopDropsThePendingChange() { var saved = 0; var saver = new ProjectSaver(_ => { saved++; throw new System.IO.IOException("offline"); }, TimeSpan.Zero); saver.Schedule(new ProjectSettings { HeroFrame = 1 }); Assert.False(await saver.FlushAsync()); var attempts = saved; saver.Stop(); Assert.True(await saver.FlushAsync().WaitAsync(TimeSpan.FromSeconds(10)), "nothing pending after a stop"); saver.Schedule(new ProjectSettings { HeroFrame = 2 }); Assert.False(saver.HasPendingChanges, "a stopped saver takes no new change"); Assert.Equal(attempts, saved); } [Test] public async Task FlushWithNothingPendingIsStored() { var saver = new ProjectSaver(_ => Task.CompletedTask, TimeSpan.FromMinutes(5)); Assert.True(await saver.FlushAsync().WaitAsync(TimeSpan.FromSeconds(10))); } [Test] public async Task AChangeDuringAWriteIsWrittenAfterIt() { var gate = new TaskCompletionSource(); var saved = new List(); var saver = new ProjectSaver(async p => { saved.Add(p.HeroFrame); if (saved.Count == 1) await gate.Task; }, TimeSpan.Zero); saver.Schedule(new ProjectSettings { HeroFrame = 1 }); while (saved.Count == 0) await Task.Delay(5); saver.Schedule(new ProjectSettings { HeroFrame = 2 }); saver.Schedule(new ProjectSettings { HeroFrame = 3 }); gate.SetResult(); await saver.FlushAsync(); Assert.SequenceEqual([(int?)1, 3], saved); } }