using System.Collections.Concurrent;
using Febe.Core.Abstractions;
using Febe.Core.Collection.Recipes;
using Febe.Core.Engine;
namespace Febe.Tests.Collection.Support;
///
/// A clock that compresses time: waits for real only a fraction of the requested time, and
/// moves on by the whole of it. Recipes against a real browser keep their order of events, but a
/// 2.2-second «wait after load» lasts a few hundred milliseconds.
///
public sealed class CompressedClock : IClock
{
private readonly Lock _gate = new();
private TimeSpan _offset;
public CompressedClock(double factor = 10, TimeZoneInfo? zone = null)
{
Factor = factor;
LocalZone = zone ?? TimeZoneInfo.Utc;
}
public double Factor { get; }
public TimeZoneInfo LocalZone { get; }
public DateTimeOffset Now
{
get
{
lock (_gate)
{
return DateTimeOffset.UtcNow + _offset;
}
}
}
public async Task Delay(TimeSpan time, CancellationToken ct)
{
if (time <= TimeSpan.Zero)
{
ct.ThrowIfCancellationRequested();
return;
}
var real = TimeSpan.FromTicks((long)(time.Ticks / Factor));
if (real >= TimeSpan.FromMilliseconds(1))
{
await Task.Delay(real, ct).ConfigureAwait(false);
}
else
{
ct.ThrowIfCancellationRequested();
await Task.Yield();
}
lock (_gate)
{
_offset += time - real;
}
}
}
///
/// A Governor that grants everything, records each request and can refuse a category after a number of grants
/// (to test the orderly stop of the recipes). Never used outside tests.
///
public sealed class PermissiveGovernor : IGovernor, IBudgetView
{
private readonly ConcurrentQueue<(ActionKind Kind, long? AccountId)> _requests = new();
private readonly ConcurrentDictionary _limits = new();
private readonly ConcurrentDictionary _granted = new();
public IReadOnlyList<(ActionKind Kind, long? AccountId)> Requests => [.. _requests];
/// Remaining budget reported to when no limit is set.
public int ReportedRemaining { get; set; } = 1000;
public int Granted(ActionKind kind) => _granted.TryGetValue(kind, out var n) ? n : 0;
/// After granted requests of , the next ones are refused.
public void Limit(ActionKind kind, int grants) => _limits[kind] = grants;
public Task RequestAsync(ActionKind kind, long? accountId, CancellationToken ct)
{
_requests.Enqueue((kind, accountId));
if (_limits.TryGetValue(kind, out var limit) && Granted(kind) >= limit)
{
return Task.FromResult(Permit.Deny(kind, accountId, DenialReason.HourlyBudgetReached, "Tetto orario raggiunto (prova)."));
}
_granted.AddOrUpdate(kind, 1, (_, n) => n + 1);
return Task.FromResult(Permit.Grant(kind, accountId));
}
public Task RemainingAsync(ActionKind kind, long? accountId, CancellationToken ct) =>
Task.FromResult(_limits.TryGetValue(kind, out var limit) ? Math.Max(0, limit - Granted(kind)) : ReportedRemaining);
}
/// A daily data budget kept in memory.
public sealed class FakeDataBudget(long bytesPerDay = long.MaxValue / 4) : IDataBudget
{
private long _used;
public long Used => Interlocked.Read(ref _used);
public Task RemainingTodayAsync(CancellationToken ct) => Task.FromResult(Math.Max(0, bytesPerDay - Used));
public Task RecordAsync(long bytes, long? accountId, CancellationToken ct)
{
Interlocked.Add(ref _used, bytes);
return Task.CompletedTask;
}
}
/// A session context for one test.
public sealed record TestSession(long SessionId = 1, double Mood = 1.0) : ISessionContext
{
public DateTimeOffset PlannedEnd { get; init; } = DateTimeOffset.MaxValue;
}