Pagine aperte da Alberto non sono segnali (regole-1); cookie perso fuori sessione = disconnessione (regole-2); pagina a riposo quando Alberto lascia il browser (regole-6); la lease di «Accedi»/«Usa il browser» finisce da sola dopo 2 minuti senza vista remota né finestra (websec-1); ping con scadenza sulla vista remota (websec-5); aperture della vista remota serializzate (websec-6); orologio virtuale senza fine anticipata (engine-1); la sincronizzazione della coda non duplica il compito in corso (engine-2); raccolte in evidenza programmate (sched-1). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Mzbb6zeFTjT6Rp8b92AVkA
159 lines
5.8 KiB
C#
159 lines
5.8 KiB
C#
using Febe.Core.Simulation;
|
|
|
|
namespace Febe.Tests.Engine;
|
|
|
|
[TestClass]
|
|
public sealed class VirtualClockTests
|
|
{
|
|
private static readonly DateTimeOffset Start = new(2026, 10, 14, 10, 0, 0, TimeSpan.Zero);
|
|
|
|
[TestMethod]
|
|
public async Task DelaysCompleteOnlyWhenTimeReachesThem()
|
|
{
|
|
var clock = new VirtualClock(Start);
|
|
var late = clock.Delay(TimeSpan.FromMinutes(10), CancellationToken.None);
|
|
var early = clock.Delay(TimeSpan.FromMinutes(5), CancellationToken.None);
|
|
Assert.AreEqual(2, clock.PendingTimers);
|
|
Assert.IsFalse(early.IsCompleted);
|
|
|
|
clock.Advance(TimeSpan.FromMinutes(6));
|
|
await early;
|
|
Assert.IsFalse(late.IsCompleted);
|
|
Assert.AreEqual(Start.AddMinutes(6), clock.Now);
|
|
|
|
clock.Advance(TimeSpan.FromMinutes(10));
|
|
await late;
|
|
Assert.AreEqual(0, clock.PendingTimers);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task ACancelledDelayLeavesTheQueue()
|
|
{
|
|
var clock = new VirtualClock(Start);
|
|
using var cts = new CancellationTokenSource();
|
|
var delay = clock.Delay(TimeSpan.FromHours(1), cts.Token);
|
|
Assert.AreEqual(1, clock.PendingTimers);
|
|
await cts.CancelAsync();
|
|
Assert.AreEqual(0, clock.PendingTimers);
|
|
await Assert.ThrowsAsync<TaskCanceledException>(() => delay);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task RunUntilJumpsFromTimerToTimerWhileTheActorWaits()
|
|
{
|
|
var clock = new VirtualClock(Start);
|
|
var seen = new List<DateTimeOffset>();
|
|
using var cts = new CancellationTokenSource();
|
|
async Task Actor()
|
|
{
|
|
for (var i = 0; i < 5; i++)
|
|
{
|
|
await Task.Yield();
|
|
await clock.Delay(TimeSpan.FromMinutes(30), cts.Token);
|
|
seen.Add(clock.Now);
|
|
}
|
|
|
|
await clock.Delay(TimeSpan.FromDays(10), cts.Token);
|
|
}
|
|
|
|
var actor = Actor();
|
|
await clock.RunUntilAsync(Start.AddHours(2), CancellationToken.None, actor);
|
|
Assert.AreEqual(Start.AddHours(2), clock.Now);
|
|
CollectionAssert.AreEqual(new[] { Start.AddMinutes(30), Start.AddMinutes(60), Start.AddMinutes(90), Start.AddMinutes(120) }, seen);
|
|
|
|
await clock.RunUntilAsync(Start.AddHours(3), CancellationToken.None, actor);
|
|
Assert.HasCount(5, seen);
|
|
await cts.CancelAsync();
|
|
await Assert.ThrowsAsync<TaskCanceledException>(() => actor);
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task AFailingActorStopsTheRun()
|
|
{
|
|
var clock = new VirtualClock(Start);
|
|
async Task Actor()
|
|
{
|
|
await clock.Delay(TimeSpan.FromMinutes(1), CancellationToken.None);
|
|
throw new InvalidOperationException("guasto");
|
|
}
|
|
|
|
var actor = Actor();
|
|
await Assert.ThrowsAsync<InvalidOperationException>(() => clock.RunUntilAsync(Start.AddHours(1), CancellationToken.None, actor));
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task ATimerCancelledFromThePoolNeverEndsTheRunEarly()
|
|
{
|
|
// As EngineHost.OnBreakerChanged does: a pool thread cancels the actor's pending timer (here as soon as it is
|
|
// registered, so that it often lands between the driver's look at the actors and its decision).
|
|
for (var i = 0; i < 20_000; i++)
|
|
{
|
|
var clock = new VirtualClock(Start);
|
|
using var session = new CancellationTokenSource();
|
|
using var end = new CancellationTokenSource();
|
|
var oneMinuteLater = false;
|
|
var stop = 0;
|
|
Task? canceller = null;
|
|
async Task Actor()
|
|
{
|
|
canceller = Task.Run(() =>
|
|
{
|
|
while (clock.PendingTimers == 0 && Volatile.Read(ref stop) == 0)
|
|
{
|
|
Thread.SpinWait(20);
|
|
}
|
|
|
|
session.Cancel();
|
|
});
|
|
try
|
|
{
|
|
await clock.Delay(TimeSpan.FromSeconds(5), session.Token);
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
}
|
|
|
|
await clock.Delay(TimeSpan.FromMinutes(1), CancellationToken.None);
|
|
oneMinuteLater = true;
|
|
await clock.Delay(TimeSpan.FromDays(10), end.Token);
|
|
}
|
|
|
|
var actor = Actor();
|
|
bool reached;
|
|
DateTimeOffset at;
|
|
try
|
|
{
|
|
await clock.RunUntilAsync(Start.AddHours(1), CancellationToken.None, actor);
|
|
reached = Volatile.Read(ref oneMinuteLater);
|
|
at = clock.Now;
|
|
}
|
|
finally
|
|
{
|
|
// Lets the actor end in every case (also when the driver left it behind), so nothing keeps running.
|
|
Volatile.Write(ref stop, 1);
|
|
await canceller!;
|
|
await end.CancelAsync();
|
|
for (var spin = 0; !actor.IsCompleted && spin < 1000; spin++)
|
|
{
|
|
clock.AdvanceTo(clock.Now.AddDays(1));
|
|
await Task.WhenAny(actor, Task.Delay(1));
|
|
}
|
|
}
|
|
|
|
Assert.IsTrue(reached, $"Run {i}: the driver returned while the actor was running, and skipped its timer.");
|
|
Assert.AreEqual(Start.AddHours(1), at);
|
|
Assert.IsTrue(actor.IsCanceled, $"Run {i}: the actor ends on its last timer, cancelled here.");
|
|
}
|
|
}
|
|
|
|
[TestMethod]
|
|
public async Task AutoAdvanceMovesTimeAtOnceAndRoundsToMilliseconds()
|
|
{
|
|
var clock = new VirtualClock(Start) { AutoAdvance = true };
|
|
await clock.Delay(TimeSpan.FromTicks(1), CancellationToken.None);
|
|
Assert.AreEqual(Start.AddMilliseconds(1), clock.Now);
|
|
await clock.Delay(TimeSpan.FromSeconds(4), CancellationToken.None);
|
|
Assert.AreEqual(Start.AddMilliseconds(4001), clock.Now);
|
|
}
|
|
}
|