using System.Net;
using System.Text;
using System.Threading.Channels;
using Anubis.Brokers;
namespace Anubis.Tests;
/// Recorded responses saved under Fixtures/ (trap 12: no network in tests).
internal static class Fixture
{
public static string Path(string relative) => System.IO.Path.Combine(AppContext.BaseDirectory, "Fixtures", relative);
public static string Text(string relative) => File.ReadAllText(Path(relative));
public static byte[] Bytes(string relative) => File.ReadAllBytes(Path(relative));
}
///
/// An HTTP handler that answers from a list of rules (first match wins) and records every request.
/// A request no rule matches fails the test with its address.
///
internal sealed class FakeHttp : HttpMessageHandler
{
private readonly List<(Func Match, Func Answer)> _rules = [];
public List Requests { get; } = [];
public HttpClient Client() => new(this, disposeHandler: false);
public FakeHttp On(Func match, Func answer)
{
_rules.Add((match, answer));
return this;
}
public FakeHttp On(string contains, string body, HttpStatusCode status = HttpStatusCode.OK) =>
On(u => u.ToString().Contains(contains, StringComparison.Ordinal), _ => Respond(body, status));
public FakeHttp OnBytes(string contains, byte[] body) =>
On(u => u.ToString().Contains(contains, StringComparison.Ordinal), _ => new HttpResponseMessage(HttpStatusCode.OK) { Content = new ByteArrayContent(body) });
public static HttpResponseMessage Respond(string body, HttpStatusCode status = HttpStatusCode.OK) =>
new(status) { Content = new StringContent(body, Encoding.UTF8, "application/json") };
public IEnumerable Urls => Requests.Select(r => r.RequestUri!);
protected override Task SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
lock (Requests)
{
Requests.Add(request);
}
foreach (var (match, answer) in _rules)
{
if (match(request.RequestUri!))
{
return Task.FromResult(answer(request));
}
}
throw new AssertFailedException("Unexpected request: " + request.RequestUri);
}
}
/// A WebSocket that plays messages pushed by the test and records what the client sends.
internal sealed class FakeSocket : IWebSocketTransport
{
private readonly Channel _incoming = Channel.CreateUnbounded();
public Uri? Url { get; private set; }
public IReadOnlyDictionary? Headers { get; private set; }
public List Sent { get; } = [];
public TaskCompletionSource Connected { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously);
public bool Disposed { get; private set; }
public void Push(string message) => _incoming.Writer.TryWrite(message);
/// The server closes the connection.
public void Close() => _incoming.Writer.TryWrite(null);
public Task ConnectAsync(Uri url, IReadOnlyDictionary? headers, CancellationToken cancellationToken)
{
Url = url;
Headers = headers;
Connected.TrySetResult();
return Task.CompletedTask;
}
public Task SendAsync(string text, CancellationToken cancellationToken)
{
lock (Sent)
{
Sent.Add(text);
}
return Task.CompletedTask;
}
public async Task ReceiveAsync(CancellationToken cancellationToken) =>
await _incoming.Reader.ReadAsync(cancellationToken).ConfigureAwait(false);
public ValueTask DisposeAsync()
{
Disposed = true;
return ValueTask.CompletedTask;
}
}
/// A clock whose waits finish at once by moving time forward: back-offs and rate limits cost nothing in tests.
internal sealed class FastClock(DateTimeOffset start) : Anubis.Core.IClock
{
private readonly Lock _gate = new();
private DateTimeOffset _now = start;
public DateTimeOffset UtcNow
{
get
{
lock (_gate)
{
return _now;
}
}
}
public TimeSpan Waited { get; private set; }
public void Advance(TimeSpan by)
{
lock (_gate)
{
_now += by;
}
}
public Task WaitUntilAsync(DateTimeOffset dueUtc, CancellationToken cancellationToken)
{
lock (_gate)
{
if (dueUtc > _now)
{
Waited += dueUtc - _now;
_now = dueUtc;
}
}
return Task.CompletedTask;
}
}