using System.Collections.Concurrent;
using Anubis.Core;
using Anubis.Data;
using Anubis.Db;
using Anubis.Trading;
namespace Anubis.Tests;
///
/// A migrated database on the engine of this run with what trading tests need: a manual clock, quotes set by the
/// test, accounts and instruments, the internal simulator and order managers. Tuesday 10 November 2026, 10:00 in New York.
///
internal sealed class TradingRig : IAsyncDisposable
{
public const string Installation = "TST1";
public static readonly DateTimeOffset Start = new(2026, 11, 10, 15, 0, 0, TimeSpan.Zero);
private readonly ConcurrentDictionary _quotes = new(StringComparer.Ordinal);
private readonly ConcurrentDictionary _specs = new(StringComparer.Ordinal);
private readonly ConcurrentDictionary _instruments = new();
private readonly List _owned = [];
private TradingRig(TestDb test)
{
Test = test;
Clock = new ManualClock(Start);
Ledger = new Ledger(test.Db, Clock);
Catalog = new InstrumentCatalog(test.Db, Clock);
}
public TestDb Test { get; }
public Database Db => Test.Db;
public ManualClock Clock { get; }
public Ledger Ledger { get; }
public InstrumentCatalog Catalog { get; }
/// Quotes are refused while this is true: the price feed is "down".
public bool QuotesDown { get; set; }
public static async Task CreateAsync() => new(await DatabaseTests.MigratedAsync().ConfigureAwait(false));
public async Task AccountAsync(string broker, string environment, string? name = null)
{
var account = new AccountContext(Ids.NewId(Clock), name ?? AccountSetup.NameOf(broker, environment), broker, environment, StrategyNames.CurrencyOf(broker));
await Db.WriteAsync(s => s.ExecuteAsync("INSERT INTO accounts (id, name, broker, environment, base_currency, created_at) VALUES (@id, @n, @b, @e, @c, @now)", CancellationToken.None,
("id", account.AccountId), ("n", account.Name), ("b", broker), ("e", environment), ("c", account.Currency), ("now", Clock.UtcNow)), CancellationToken.None).ConfigureAwait(false);
return account;
}
public async Task InstrumentAsync(InstrumentSpec spec)
{
var instrument = await Catalog.EnsureAsync(spec, CancellationToken.None).ConfigureAwait(false);
_specs[spec.Symbol] = instrument.Spec;
_instruments[instrument.Id] = instrument;
return instrument;
}
public static InstrumentSpec Btc => MarketDataStoreTests.Okx("BTC-EUR") with { TickSize = 0.1m, LotSize = 0.00000001m, MinSize = 0.00001m };
public static InstrumentSpec Pepe => MarketDataStoreTests.Okx("PEPE-EUR") with { TickSize = 0.00000001m, LotSize = 1m, MinSize = 100000m };
public static InstrumentSpec Stock(string symbol, bool fractionable = true) => TradingRulesTests.Stock(symbol, fractionable);
public void Quote(string symbol, decimal bid, decimal ask, decimal? size = null) =>
_quotes[symbol] = new Quote(symbol, bid, ask, Clock.UtcNow) { BidSize = size, AskSize = size };
/// The same prices, read again now: the feed is alive and the market has not moved.
public void Refresh()
{
foreach (var (symbol, quote) in _quotes)
{
_quotes[symbol] = quote with { At = Clock.UtcNow };
}
}
public Task QuoteAsync(string symbol, CancellationToken cancellationToken) =>
Task.FromResult(QuotesDown ? null : _quotes.TryGetValue(symbol, out var quote) ? quote : null);
public Task FindAsync(Guid id, CancellationToken cancellationToken) => Task.FromResult(_instruments.GetValueOrDefault(id));
public InstrumentSpec? Spec(string symbol) => _specs.GetValueOrDefault(symbol);
public PaperBroker Paper(PaperOptions options, Guid accountId, bool persist = true)
{
var broker = new PaperBroker(options with { MinLatency = TimeSpan.Zero, MaxLatency = TimeSpan.Zero }, Clock, QuoteAsync, Spec,
persist ? new PaperBookStore(Db, Clock, accountId) : null);
_owned.Add(broker);
return broker;
}
public OrderManager Manager(IBrokerAccount broker, AccountContext account, Func>? marketOpen = null,
Func>? pendingSplit = null)
{
var manager = new OrderManager(Db, Clock, Ledger, broker, account, Installation, FindAsync, QuoteAsync)
{
StepTime = TimeSpan.FromSeconds(60),
ConfirmPrice = QuoteAsync,
MarketOpen = marketOpen ?? ((_, _) => Task.FromResult(true)),
PendingSplit = pendingSplit,
};
_owned.Add(manager);
return manager;
}
/// Several turns of the order manager, the clock moving between them (the simulator's latency, the steps).
public async Task TurnsAsync(OrderManager manager, int turns, TimeSpan every)
{
for (var i = 0; i < turns; i++)
{
Refresh();
if (manager.Broker is PaperBroker paper)
{
await paper.PumpAsync(CancellationToken.None).ConfigureAwait(false);
}
await manager.TickAsync(CancellationToken.None).ConfigureAwait(false);
Clock.Advance(every);
}
}
public Task> QueryAsync(string sql, Func read, params (string, object?)[] args) =>
Db.ReadAsync>(async s => await s.QueryAsync(sql, read, args).ConfigureAwait(false), CancellationToken.None);
public LedgerFill Fill(AccountContext account, Instrument instrument, string strategy, OrderSide side, decimal quantity, decimal price, decimal fee = 0m, string? feeCurrency = null) =>
new(account.AccountId, instrument.Id, strategy, "X" + Ids.NewId(Clock).ToString("N"), side, quantity, price, fee, feeCurrency ?? instrument.Spec.QuoteCurrency, Clock.UtcNow);
public async ValueTask DisposeAsync()
{
foreach (var owned in _owned)
{
owned.Dispose();
}
await Test.DisposeAsync().ConfigureAwait(false);
}
}
/// A broker in front of another one that can lose answers, refuse orders, repeat fills or go silent (fault tests, SPEC 7.4).
internal sealed class FaultyBroker(IBrokerAccount inner, string? environment = null) : IBrokerAccount
{
/// Quantities the account no longer shows, by symbol: a difference the ledger cannot explain.
public Dictionary Missing { get; } = new(StringComparer.Ordinal);
/// The key reports that it may withdraw.
public bool KeyCanWithdraw { get; set; }
/// The next order reaches the broker but its answer is lost.
public bool LoseNextAnswer { get; set; }
/// The next order is refused with this code.
public string? RejectNext { get; set; }
/// Every fill is reported twice.
public bool DuplicateFills { get; set; }
/// Every call fails as if the network were down.
public bool Down { get; set; }
public List Sent { get; } = [];
public string Venue => inner.Venue;
public string Environment => environment ?? inner.Environment;
public BrokerCapabilities Capabilities => inner.Capabilities;
public Task ServerTimeAsync(CancellationToken cancellationToken) => Guard(() => inner.ServerTimeAsync(cancellationToken));
public Task GetAccountAsync(CancellationToken cancellationToken) => Guard(() => inner.GetAccountAsync(cancellationToken));
public async Task> GetPositionsAsync(CancellationToken cancellationToken)
{
var positions = await Guard(() => inner.GetPositionsAsync(cancellationToken)).ConfigureAwait(false);
return [.. positions.Select(p => p with { Quantity = p.Quantity - Missing.GetValueOrDefault(p.Symbol) })];
}
public Task> GetOpenOrdersAsync(CancellationToken cancellationToken) => Guard(() => inner.GetOpenOrdersAsync(cancellationToken));
public async Task SubmitOrderAsync(OrderRequest request, CancellationToken cancellationToken)
{
if (Down)
{
throw new BrokerException("rete giù", retryable: true);
}
if (RejectNext is { } code)
{
RejectNext = null;
throw new OrderRejectedException("rifiutato", code);
}
Sent.Add(request);
var answer = await inner.SubmitOrderAsync(request, cancellationToken).ConfigureAwait(false);
if (LoseNextAnswer)
{
LoseNextAnswer = false;
throw new BrokerException("risposta persa", retryable: true);
}
return answer;
}
public Task CancelOrderAsync(string clientOrderId, string symbol, CancellationToken cancellationToken) => Guard(async () =>
{
await inner.CancelOrderAsync(clientOrderId, symbol, cancellationToken).ConfigureAwait(false);
return true;
});
public Task GetOrderAsync(string clientOrderId, string symbol, CancellationToken cancellationToken) => Guard(() => inner.GetOrderAsync(clientOrderId, symbol, cancellationToken));
public async Task> GetFillsAsync(DateTimeOffset since, CancellationToken cancellationToken)
{
var fills = await Guard(() => inner.GetFillsAsync(since, cancellationToken)).ConfigureAwait(false);
return DuplicateFills ? [.. fills, .. fills] : fills;
}
public Task> GetCashActivitiesAsync(DateTimeOffset since, CancellationToken cancellationToken) => Guard(() => inner.GetCashActivitiesAsync(since, cancellationToken));
public Task GetKeyPermissionsAsync(CancellationToken cancellationToken) =>
KeyCanWithdraw ? Task.FromResult(new KeyPermissions(true, true, true, "lettura, ordini, prelievi")) : Guard(() => inner.GetKeyPermissionsAsync(cancellationToken));
public IAsyncEnumerable StreamOrderUpdatesAsync(CancellationToken cancellationToken) => inner.StreamOrderUpdatesAsync(cancellationToken);
private Task Guard(Func> call) => Down ? throw new BrokerException("rete giù", retryable: true) : call();
}