Files
Anubis/tests/Anubis.Tests/TradingSupport.cs
T
Alby96andClaude Opus 5.5 e3caa26207 Test the order manager and reconciliation end to end (refs #27 #28 #30)
Order manager tests drive the internal simulator turn by turn: the chasing
limit with its post-only steps and aggressive cross, a buy given up, a sale
never given up with its alert, the pace of six sends a minute, Alpaca's
GTC + day stops, the stop-already-passed rule and splits, lost answers,
duplicate fills, refusals and residues. Reconciliation tests cover clean,
healed, prudent mode and its return, align/exclude, unknown orders, stop
coverage, withdraw-capable keys and an unreachable broker.

Two defects found by the tests are fixed: stops were not cleared before an
execution that starts aggressive (Alpaca refuses a buy with a sell stop open,
and a sale must free the quantity), and an order's creation is now recorded
as its first event.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 20:40:21 +01:00

231 lines
10 KiB
C#

using System.Collections.Concurrent;
using Anubis.Core;
using Anubis.Data;
using Anubis.Db;
using Anubis.Trading;
namespace Anubis.Tests;
/// <summary>
/// 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.
/// </summary>
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<string, Quote> _quotes = new(StringComparer.Ordinal);
private readonly ConcurrentDictionary<string, InstrumentSpec> _specs = new(StringComparer.Ordinal);
private readonly ConcurrentDictionary<Guid, Instrument> _instruments = new();
private readonly List<IDisposable> _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; }
/// <summary>Quotes are refused while this is true: the price feed is "down".</summary>
public bool QuotesDown { get; set; }
public static async Task<TradingRig> CreateAsync() => new(await DatabaseTests.MigratedAsync().ConfigureAwait(false));
public async Task<AccountContext> AccountAsync(string broker, string environment, string? name = null)
{
var account = new AccountContext(Ids.NewId(Clock), name ?? AccountSetup.NameOf(broker, environment), broker, environment, Strategies.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<Instrument> 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 };
/// <summary>The same prices, read again now: the feed is alive and the market has not moved.</summary>
public void Refresh()
{
foreach (var (symbol, quote) in _quotes)
{
_quotes[symbol] = quote with { At = Clock.UtcNow };
}
}
public Task<Quote?> QuoteAsync(string symbol, CancellationToken cancellationToken) =>
Task.FromResult(QuotesDown ? null : _quotes.TryGetValue(symbol, out var quote) ? quote : null);
public Task<Instrument?> 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<Instrument, CancellationToken, Task<bool>>? marketOpen = null,
Func<Instrument, CancellationToken, Task<CorporateAction?>>? 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;
}
/// <summary>Several turns of the order manager, the clock moving between them (the simulator's latency, the steps).</summary>
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<IReadOnlyList<T>> QueryAsync<T>(string sql, Func<DbRow, T> read, params (string, object?)[] args) =>
Db.ReadAsync<IReadOnlyList<T>>(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);
}
}
/// <summary>A broker in front of another one that can lose answers, refuse orders, repeat fills or go silent (fault tests, SPEC 7.4).</summary>
internal sealed class FaultyBroker(IBrokerAccount inner, string? environment = null) : IBrokerAccount
{
/// <summary>Quantities the account no longer shows, by symbol: a difference the ledger cannot explain.</summary>
public Dictionary<string, decimal> Missing { get; } = new(StringComparer.Ordinal);
/// <summary>The key reports that it may withdraw.</summary>
public bool KeyCanWithdraw { get; set; }
/// <summary>The next order reaches the broker but its answer is lost.</summary>
public bool LoseNextAnswer { get; set; }
/// <summary>The next order is refused with this code.</summary>
public string? RejectNext { get; set; }
/// <summary>Every fill is reported twice.</summary>
public bool DuplicateFills { get; set; }
/// <summary>Every call fails as if the network were down.</summary>
public bool Down { get; set; }
public List<OrderRequest> Sent { get; } = [];
public string Venue => inner.Venue;
public string Environment => environment ?? inner.Environment;
public BrokerCapabilities Capabilities => inner.Capabilities;
public Task<DateTimeOffset> ServerTimeAsync(CancellationToken cancellationToken) => Guard(() => inner.ServerTimeAsync(cancellationToken));
public Task<AccountSnapshot> GetAccountAsync(CancellationToken cancellationToken) => Guard(() => inner.GetAccountAsync(cancellationToken));
public async Task<IReadOnlyList<BrokerPosition>> 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<IReadOnlyList<BrokerOrder>> GetOpenOrdersAsync(CancellationToken cancellationToken) => Guard(() => inner.GetOpenOrdersAsync(cancellationToken));
public async Task<BrokerOrder> 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<BrokerOrder?> GetOrderAsync(string clientOrderId, string symbol, CancellationToken cancellationToken) => Guard(() => inner.GetOrderAsync(clientOrderId, symbol, cancellationToken));
public async Task<IReadOnlyList<BrokerFill>> GetFillsAsync(DateTimeOffset since, CancellationToken cancellationToken)
{
var fills = await Guard(() => inner.GetFillsAsync(since, cancellationToken)).ConfigureAwait(false);
return DuplicateFills ? [.. fills, .. fills] : fills;
}
public Task<IReadOnlyList<CashActivity>> GetCashActivitiesAsync(DateTimeOffset since, CancellationToken cancellationToken) => Guard(() => inner.GetCashActivitiesAsync(since, cancellationToken));
public Task<KeyPermissions> GetKeyPermissionsAsync(CancellationToken cancellationToken) =>
KeyCanWithdraw ? Task.FromResult(new KeyPermissions(true, true, true, "lettura, ordini, prelievi")) : Guard(() => inner.GetKeyPermissionsAsync(cancellationToken));
public IAsyncEnumerable<OrderUpdate> StreamOrderUpdatesAsync(CancellationToken cancellationToken) => inner.StreamOrderUpdatesAsync(cancellationToken);
private Task<T> Guard<T>(Func<Task<T>> call) => Down ? throw new BrokerException("rete giù", retryable: true) : call();
}