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);
}
}