using Anubis.Backtest;
using Anubis.Data;
using Anubis.Strategies;
using Anubis.Trading;
namespace Anubis.Tests;
/// A strategy that says what it is told on given days: its result can be computed by hand.
internal sealed class ScriptedStrategy(IReadOnlyDictionary> script) : IStrategy
{
public string Id => "scripted";
public string Version => "1";
public IReadOnlyList Schedule() => [DecisionTime.AfterClose];
public IReadOnlyList Universe(UniverseContext context) => context.Available;
public IReadOnlyList Decide(StrategyContext context) => script.GetValueOrDefault(context.Day) ?? [];
}
internal static class BacktestData
{
public static readonly DateOnly D1 = new(2026, 1, 5);
public static InstrumentSpec Btc() => new(Venues.Okx, "BTC-EUR", "Bitcoin", AssetClasses.Crypto, "EUR")
{
BaseCurrency = "BTC",
TickSize = 0.1m,
LotSize = 0.00000001m,
MinSize = 0.00001m,
Status = "live",
};
public static InstrumentSpec Stock(string symbol = "AAPL") => new(Venues.Alpaca, symbol, symbol, AssetClasses.Equity, "USD")
{
Fractionable = true,
Status = "active",
Exchange = "NASDAQ",
};
/// Five sessions (open, high, low, close) on consecutive days from .
public static IReadOnlyList FiveDays() =>
[
new(D1, 100, 101, 99, 100, 1000),
new(D1.AddDays(1), 100, 102, 99, 101, 1000),
new(D1.AddDays(2), 102, 104, 101, 103, 1000),
new(D1.AddDays(3), 103, 106, 102, 105, 1000),
new(D1.AddDays(4), 106, 107, 104, 106, 1000),
];
public static BacktestDataset One(InstrumentSpec spec, IReadOnlyList bars, IReadOnlyList? actions = null) =>
new([new BacktestInstrument(spec, bars, actions)], spec.QuoteCurrency);
/// A random walk with a fixed seed: the same series at every run.
public static IReadOnlyList Walk(int days, ulong seed, double start = 100, double drift = 0.0003, double volatility = 0.02, DateOnly? from = null)
{
var gen = new Gen((int)(seed % int.MaxValue));
var bars = new List(days);
var close = start;
var day = from ?? new DateOnly(2018, 1, 1);
for (var i = 0; i < days; i++)
{
var open = close;
var change = drift + (volatility * gen.Normal());
close = Math.Round(open * Math.Exp(change), 2);
var high = Math.Round(Math.Max(open, close) * (1 + (0.005 * gen.Double())), 2);
var low = Math.Round(Math.Min(open, close) * (1 - (0.005 * gen.Double())), 2);
bars.Add(new DailyBar(day.AddDays(i), open, high, low, close, 1000));
}
return bars;
}
}
/// The event engine, its costs and its records (issue #34, SPEC 12.1).
[TestClass]
public sealed class BacktestTests
{
private static readonly DateOnly D1 = BacktestData.D1;
private static ScriptedStrategy Script(params (DateOnly Day, Intent[] Intents)[] steps) =>
new(steps.ToDictionary(s => s.Day, s => (IReadOnlyList)s.Intents));
[TestMethod]
[TestCategory(Category.Unit)]
public void AToyStrategyGivesExactlyTheResultComputedByHand()
{
// Half the capital in bitcoin at the first close, everything out at the third. By hand, with OKX's
// price list (0,20% taker kept in the coin bought, 5 bp of slippage, 0,1 € tick):
// buy at the open of day 2: 100 × 1,0005 = 100,05 → tick up → 100,1; 50 BTC = 5.005,00 €; fee 0,1 BTC
// received 49,9 BTC; cash 10.000 − 5.005 = 4.995,00 €
// sell at the open of day 4: 103 × 0,9995 = 102,9485 → tick down → 102,9; 49,9 × 102,9 = 5.134,71 €;
// fee 0,2% = 10,26942 €; cash 4.995 + 5.124,44058 = 10.119,44058 €
var strategy = Script((D1, [new Intent("BTC-EUR", 0.5m, "enter")]), (D1.AddDays(2), [new Intent("BTC-EUR", 0m, "exit")]));
var run = BacktestEngine.Run(strategy, BacktestData.One(BacktestData.Btc(), BacktestData.FiveDays()), new BacktestOptions { InitialCapital = 10_000m });
Assert.AreEqual(10_119.44058m, run.FinalEquity);
Assert.AreEqual(119.44058m, run.NetResult);
Assert.HasCount(2, run.Fills);
Assert.AreEqual(new BacktestFill(D1.AddDays(1), "BTC-EUR", OrderSide.Buy, 50m, 100.1m, 5_005m, 10.01m, "enter"), run.Fills[0]);
Assert.AreEqual(new BacktestFill(D1.AddDays(3), "BTC-EUR", OrderSide.Sell, 49.9m, 102.9m, 5_134.71m, 10.26942m, "exit"), run.Fills[1]);
Assert.AreEqual(20.27942m, run.Fees);
var trade = run.Trades.Single();
Assert.AreEqual(new BacktestTrade("BTC-EUR", D1.AddDays(1), D1.AddDays(3), 5_005m, 119.44058m, 20.27942m), trade);
// Valued at every close: cash plus 49,9 BTC at 101 and 103 while held.
CollectionAssert.AreEqual(
new[] { 10_000m, 10_034.9m, 10_134.7m, 10_119.44058m, 10_119.44058m },
run.Equity.Select(e => e.Equity).ToArray());
Assert.IsEmpty(run.Notes);
}
[TestMethod]
[TestCategory(Category.Unit)]
public void TheSameToyOnAStockPaysTheRegulatoryFeesRoundedUp()
{
// Alpaca: no commission, CAT 0,000003 $ a share on both sides and SEC 0,0000206 on sales, each rounded
// up to the cent; price step 0,01 $ above 1 $. By hand:
// buy 50 at 100 × 1,0005 = 100,05: 5.002,50 $ + CAT 0,01 → cash 4.997,49 $
// sell 50 at 103 × 0,9995 = 102,9485 → 102,94: 5.147,00 $ − SEC 0,11 − CAT 0,01 → cash 10.144,37 $
var strategy = Script((D1, [new Intent("AAPL", 0.5m, "enter")]), (D1.AddDays(2), [new Intent("AAPL", 0m, "exit")]));
var run = BacktestEngine.Run(strategy, BacktestData.One(BacktestData.Stock(), BacktestData.FiveDays()));
Assert.AreEqual(10_144.37m, run.FinalEquity);
Assert.AreEqual(0.13m, run.Fees);
Assert.AreEqual(new BacktestTrade("AAPL", D1.AddDays(1), D1.AddDays(3), 5_002.5m, 144.37m, 0.13m), run.Trades.Single());
}
[TestMethod]
[TestCategory(Category.Unit)]
public void StopsFillAtTheirLevelOrAtTheOpenWhenThePriceGapsBelow()
{
// Touched during the session: the low of day 2 (99) reaches the stop at 99,5, sold at 99,5 less slippage.
var touched = Script((D1, [new Intent("BTC-EUR", 0.5m, "enter") { Stop = 99.5m }]));
var run = BacktestEngine.Run(touched, BacktestData.One(BacktestData.Btc(), BacktestData.FiveDays()));
var sale = run.Fills.Single(f => f.Side == OrderSide.Sell);
Assert.AreEqual((D1.AddDays(1), 99.4m, BacktestReasons.Stop), (sale.Day, sale.Price, sale.Reason));
Assert.AreEqual(4_995m + 4_960.06m - 9.92012m, run.FinalEquity);
// Opened below: the stop raised to 102,5 at the close of day 2 meets an open of 102 and sells there (trap 24).
var gapped = Script((D1, [new Intent("BTC-EUR", 0.5m, "enter")]), (D1.AddDays(1), [new Intent("BTC-EUR", null, "raise_stop") { Stop = 102.5m }]));
run = BacktestEngine.Run(gapped, BacktestData.One(BacktestData.Btc(), BacktestData.FiveDays()));
sale = run.Fills.Single(f => f.Side == OrderSide.Sell);
Assert.AreEqual((D1.AddDays(2), 101.9m, BacktestReasons.StopGap), (sale.Day, sale.Price, sale.Reason));
}
[TestMethod]
[TestCategory(Category.Unit)]
public void ASplitChangesSharesAndStopsButNotTheValueAndSignalsSeeOneSeries()
{
// A 2-for-1 split with ex-date on day 4: real prices halve, the adjusted series does not jump.
var bars = BacktestData.FiveDays().Select((b, i) => i >= 3 ? b with { Open = b.Open / 2, High = b.High / 2, Low = b.Low / 2, Close = b.Close / 2 } : b).ToList();
var split = new CorporateAction("AAPL", CorporateActionKinds.Split, D1.AddDays(3), "test", "s1") { Ratio = 2m };
var seen = new List();
var strategy = new Recording(seen, Script((D1, [new Intent("AAPL", 0.5m, "enter") { Stop = 90m }])));
var run = BacktestEngine.Run(strategy, BacktestData.One(BacktestData.Stock(), bars, [split]));
// 50 shares became 100, the stop 90 became 45: nothing was sold and the value went on with the price.
Assert.HasCount(1, run.Fills);
Assert.AreEqual(4_997.49m + (100m * 53m), run.FinalEquity);
// What the strategy saw on the last day: one continuous series in today's prices, no halving.
CollectionAssert.AreEqual(new[] { 50d, 50.5, 51.5, 52.5, 53 }, seen.ToArray());
}
[TestMethod]
[TestCategory(Category.Unit)]
public void PurchasesNeverBorrowAndOrdersBelowTheMinimumAreNotSent()
{
// Two instruments at weight 0,8 each: the second purchase is cut to the cash left, never past it.
var data = new BacktestDataset(
[new BacktestInstrument(BacktestData.Btc(), BacktestData.FiveDays()), new BacktestInstrument(BacktestData.Btc() with { Symbol = "ETH-EUR", BaseCurrency = "ETH" }, BacktestData.FiveDays())],
"EUR");
var run = BacktestEngine.Run(Script((D1, [new Intent("BTC-EUR", 0.8m, "a"), new Intent("ETH-EUR", 0.8m, "b")])), data);
Assert.IsTrue(run.Equity.All(e => e.Cash >= 0m), "Cash never goes below zero.");
Assert.IsTrue(run.Notes.Any(n => n.Symbol == "ETH-EUR" && n.Reason == BacktestReasons.NoCash));
// A purchase worth less than the minimum size is not sent and the note says why.
run = BacktestEngine.Run(Script((D1, [new Intent("BTC-EUR", 0.00000001m, "tiny")])), BacktestData.One(BacktestData.Btc(), BacktestData.FiveDays()));
Assert.IsEmpty(run.Fills);
Assert.AreEqual(OrderReasons.BelowMinimumSize, run.Notes.Single().Reason);
// Short selling is refused (SPEC 9.1).
run = BacktestEngine.Run(Script((D1, [new Intent("BTC-EUR", -0.5m, "short")])), BacktestData.One(BacktestData.Btc(), BacktestData.FiveDays()));
Assert.IsEmpty(run.Fills);
Assert.AreEqual(BacktestReasons.NoShortSelling, run.Notes.Single().Reason);
}
[TestMethod]
[TestCategory(Category.Unit)]
public void DoubleCostsCostMoreAndTheSameInputsGiveTheSameRun()
{
var data = BacktestData.One(BacktestData.Btc(), BacktestData.Walk(400, 7));
var strategy = new MovingAverageCross(10, 40);
var once = BacktestEngine.Run(strategy, data);
var again = BacktestEngine.Run(new MovingAverageCross(10, 40), data);
CollectionAssert.AreEqual(once.Equity.ToArray(), again.Equity.ToArray());
CollectionAssert.AreEqual(once.Fills.ToArray(), again.Fills.ToArray());
Assert.IsGreaterThan(4, once.Trades.Count);
var doubled = BacktestEngine.Run(strategy, data, new BacktestOptions { Costs = new CostModel(2m) });
Assert.IsGreaterThan(once.Fees, doubled.Fees);
Assert.IsLessThan(once.FinalEquity, doubled.FinalEquity);
}
[TestMethod]
[TestCategory(Category.Unit)]
public void TheCorrectivesAndRiskHooksSeeEveryIntentAndCanChangeIt()
{
var seen = new List();
var block = new Hook("risk", (ctx, intents) =>
{
seen.AddRange(intents.Select(i => i.Symbol));
return [];
});
var run = BacktestEngine.Run(Script((D1, [new Intent("BTC-EUR", 0.5m, "enter")])), BacktestData.One(BacktestData.Btc(), BacktestData.FiveDays()), new BacktestOptions { Risk = block });
CollectionAssert.AreEqual(new[] { "BTC-EUR" }, seen);
Assert.IsEmpty(run.Fills);
Assert.HasCount(1, run.Decisions[0].Proposed);
Assert.IsEmpty(run.Decisions[0].Final);
}
[TestMethod]
[TestCategory(Category.Unit)]
public void BuyAndHoldKeepsTheShareOfAnInstrumentWhoseHistoryStartsLater()
{
// ETH has bars only from day 30: buy and hold buys it then, with half the equity, not never.
var data = new BacktestDataset(
[
new BacktestInstrument(BacktestData.Btc(), BacktestData.Walk(60, 3, start: 40_000, from: D1)),
new BacktestInstrument(BacktestData.Btc() with { Symbol = "ETH-EUR", BaseCurrency = "ETH" }, BacktestData.Walk(30, 5, start: 2_000, from: D1.AddDays(30))),
], "EUR");
var run = BacktestEngine.Run(new BuyAndHold(2), data);
Assert.HasCount(2, run.Fills);
var btc = run.Fills.Single(f => f.Symbol == "BTC-EUR");
var eth = run.Fills.Single(f => f.Symbol == "ETH-EUR");
Assert.AreEqual(D1.AddDays(1), btc.Day);
Assert.AreEqual(D1.AddDays(31), eth.Day);
Assert.AreEqual(0.4975, (double)(btc.Gross / run.InitialCapital), 0.005);
var before = run.Equity.Single(p => p.Day == D1.AddDays(30)).Equity;
Assert.AreEqual(0.4975, (double)(eth.Gross / before), 0.01);
Assert.IsTrue(run.Equity.All(e => e.Cash >= 0m));
}
[TestMethod]
[TestCategory(Category.Unit)]
public void OneCycleRestartsFromARecordedBook()
{
// The live book holds 49,9 BTC since day 2: the strategy decides on day 3 as if the backtest had run till then.
var book = new PortfolioState(4_995m, new Dictionary { ["BTC-EUR"] = new(49.9m, 100.3m, null, D1.AddDays(1)) });
var exitWhenHeld = new ExitIfHeld();
var record = BacktestEngine.DecideOnce(exitWhenHeld, BacktestData.One(BacktestData.Btc(), BacktestData.FiveDays()), book, D1.AddDays(2));
Assert.AreEqual(D1.AddDays(2), record.Day);
Assert.AreEqual(new Intent("BTC-EUR", 0m, "held"), record.Proposed.Single());
Assert.AreEqual(4_995m + (49.9m * 103m), exitWhenHeld.Equity, "The book is valued at that day's close.");
}
private sealed class Recording(List seen, IStrategy inner) : IStrategy
{
public string Id => inner.Id;
public string Version => inner.Version;
public IReadOnlyList Schedule() => inner.Schedule();
public IReadOnlyList Universe(UniverseContext context) => inner.Universe(context);
public IReadOnlyList Decide(StrategyContext context)
{
var bars = context.Bars("AAPL");
if (bars.Count == 5)
{
seen.AddRange(bars.Closes(5));
}
return inner.Decide(context);
}
}
private sealed class Hook(string name, Func, IReadOnlyList> apply) : IIntentStage
{
public string Name => name;
public IReadOnlyList Apply(StrategyContext context, IReadOnlyList intents) => apply(context, intents);
}
private sealed class ExitIfHeld : IStrategy
{
public decimal Equity { get; private set; }
public string Id => "exit_if_held";
public string Version => "1";
public IReadOnlyList Schedule() => [DecisionTime.AfterClose];
public IReadOnlyList Universe(UniverseContext context) => context.Available;
public IReadOnlyList Decide(StrategyContext context)
{
Equity = context.Portfolio.Equity;
return [.. context.Universe.Where(context.Portfolio.Holds).Select(s => new Intent(s, 0m, "held"))];
}
}
}