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; /// Runs at every request, before the answer (a test changes the page while the permit is asked). public Action? OnRequest { get; set; } public Task RequestAsync(ActionKind kind, long? accountId, CancellationToken ct) { _requests.Enqueue((kind, accountId)); OnRequest?.Invoke(kind); 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; }