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(); }