using Anubis.Backtest; using Anubis.Data; using Anubis.Strategies; using Anubis.Trading; namespace Anubis.Tests; internal static class StrategyData { public static readonly DateOnly Start = new(2024, 1, 1); public static InstrumentSpec Coin(string coin) => new(Venues.Okx, coin + "-EUR", coin, AssetClasses.Crypto, "EUR") { BaseCurrency = coin, TickSize = 0.0001m, LotSize = 0.00000001m, MinSize = 0.00000001m, MinNotional = 1m, Status = "live", }; public static InstrumentSpec Share(string symbol) => new(Venues.Alpaca, symbol, symbol, AssetClasses.Equity, "USD") { Fractionable = true, Status = "active", Exchange = "NASDAQ", TickSize = 0.01m, LotSize = 0.000000001m, MinNotional = 1m, }; /// Bars with the given closes on consecutive days; high and low a fixed distance around the close. public static List FromCloses(IReadOnlyList closes, DateOnly? from = null, double range = 0, double volume = 10_000) { var day = from ?? Start; return [.. closes.Select((c, i) => new DailyBar(day.AddDays(i), c, c + range, c - range, c, volume))]; } /// Bars on business days (no weekends) from a Monday. public static List OnBusinessDays(IReadOnlyList bars, DateOnly from) { var days = BusinessDays(from, bars.Count); return [.. bars.Select((b, i) => b with { Day = days[i] })]; } public static List BusinessDays(DateOnly from, int count) { var result = new List(count); for (var d = from; result.Count < count; d = d.AddDays(1)) { if (d.DayOfWeek is not (DayOfWeek.Saturday or DayOfWeek.Sunday)) { result.Add(d); } } return result; } /// A steady rise with a tiny alternating wobble: every period of crypto_trend is on, volatility near 1%. public static List SteadyRise(int days, double start = 100, double volume = 10_000) => FromCloses([.. Enumerable.Range(0, days).Select(i => start * Math.Pow(1.001, i) * (1 + (0.0005 * (i % 2))))], volume: volume); public static BarSeries Series(IReadOnlyList bars, InstrumentSpec? spec = null) => new BacktestInstrument(spec ?? Coin("BTC"), bars).SeriesThrough(bars[^1].Day); public static BacktestDataset Crypto(params (string Coin, IReadOnlyList Bars)[] coins) => new(coins.Select(c => new BacktestInstrument(Coin(c.Coin), c.Bars)), "EUR"); } /// Indicators and the three base strategies (issues #38, #39, #40; SPEC 8.1–8.3). [TestClass] public sealed class StrategyTests { // ---- Indicators, against values computed by hand ---- [TestMethod] [TestCategory(Category.Unit)] public void IndicatorsGiveTheValuesComputedByHand() { var closes = StrategyData.Series(StrategyData.FromCloses([1, 2, 3, 4, 5])); Assert.AreEqual(4d, Indicators.Sma(closes, 3)); Assert.IsNull(Indicators.Sma(closes, 6)); // True ranges: max(11−9, |11−9|, |9−9|) = 2; max(3, |12−10|, |9−10|) = 3; max(4, |11−11|, |7−11|) = 4. var bars = StrategyData.Series( [ new DailyBar(StrategyData.Start, 9, 10, 8, 9, 1), new DailyBar(StrategyData.Start.AddDays(1), 10, 11, 9, 10, 1), new DailyBar(StrategyData.Start.AddDays(2), 11, 12, 9, 11, 1), new DailyBar(StrategyData.Start.AddDays(3), 9, 11, 7, 8, 1), ]); Assert.AreEqual(3d, Indicators.Atr(bars, 3)); Assert.AreEqual(3.5d, Indicators.Atr(bars, 2)); // RSI(2) on 10, 11, 10,5, 12: average gain 0,5 and loss 0,25 on the first two changes; then +1,5 gives // gain (0,5 + 1,5) / 2 = 1 and loss 0,25 / 2 = 0,125: RS 8, RSI 100 − 100 / 9. Assert.AreEqual(100 - (100 / 9d), Indicators.Rsi(StrategyData.Series(StrategyData.FromCloses([10, 11, 10.5, 12])), 2)!.Value, 1e-12); // 121 / 100 − 1, skipping the last close. Assert.AreEqual(0.21, Indicators.Momentum(StrategyData.Series(StrategyData.FromCloses([100, 110, 121, 133.1])), 2, 1)!.Value, 1e-12); // Returns +10% and −10%: sample standard deviation √0,02, times √365. Assert.AreEqual(Math.Sqrt(0.02) * Math.Sqrt(365), Indicators.Volatility(StrategyData.Series(StrategyData.FromCloses([100, 110, 99])), 2, 365)!.Value, 1e-12); } // ---- crypto_trend ---- [TestMethod] [TestCategory(Category.Unit)] public void ThePeriodsTurnOnAtANewHighAndOffBelowYesterdaysStop() { // Periods 2 and 3, flat bars (high = low = close) so only the closes count. var settings = new CryptoTrendSettings { Periods = [2, 3], MaxStop = 0.15 }; var bars = StrategyData.FromCloses([10, 10, 10, 12, 13, 12.4, 12.6]); bars[6] = bars[6] with { Low = 12.0 }; var tracker = new TrendTracker(); // Day 3, close 12: both periods beat their previous highs (10); stops at the middle of the last N closes, 11. tracker.Advance(StrategyData.Series(bars[..4]), settings); CollectionAssert.AreEqual(new[] { true, true }, tracker.Active.ToArray()); Assert.AreEqual(1d, tracker.Ensemble); Assert.AreEqual(11d, tracker.ServerStop); // Day 4, close 13: stops rise to 12,5 and 11,5; the server stop is the lowest, 11,5. tracker.Advance(StrategyData.Series(bars[..5]), settings); Assert.AreEqual(11.5d, tracker.ServerStop); // Day 5, close 12,4: below the 2-day stop of yesterday (12,5), so that period turns off; the 3-day one stays, // its stop rising to the middle of 12, 13, 12,4 = 12,5. e = 0,5. tracker.Advance(StrategyData.Series(bars[..6]), settings); CollectionAssert.AreEqual(new[] { false, true }, tracker.Active.ToArray()); Assert.AreEqual(0.5d, tracker.Ensemble); Assert.AreEqual(12.5d, tracker.ServerStop); // Day 6: the low (12) touches the server stop during the day. Every period goes back to 0, and the close of // 12,6 is not a new high for either: no stop, no position. tracker.Advance(StrategyData.Series(bars), settings); CollectionAssert.AreEqual(new[] { false, false }, tracker.Active.ToArray()); Assert.AreEqual(0d, tracker.Ensemble); Assert.IsNull(tracker.ServerStop); } [TestMethod] [TestCategory(Category.Unit)] public void TheServerStopRisesStaysWithin15PercentAndFallsOnlyWhenAPeriodTurnsOn() { var tracker = new TrendTracker(); // Never more than 15% below the close: the middle of 10 and 20 is 15, the cap 17. tracker.Advance(StrategyData.Series(StrategyData.FromCloses([10, 10, 20])), new CryptoTrendSettings { Periods = [2] }); Assert.AreEqual(17d, tracker.ServerStop); // With a loose cap: the 2-day period alone lifts the stop to 11, 13, 15; on day 5 the 5-day period turns on // with its stop at the middle of 10…17 = 13,5, and the server stop comes down to it. var loose = new CryptoTrendSettings { Periods = [2, 5], MaxStop = 0.5 }; var bars = StrategyData.FromCloses([10, 10, 12, 14, 16, 17]); var stops = new List(); for (var n = 3; n <= bars.Count; n++) { stops.Add(new TrendTracker().Advance(StrategyData.Series(bars[..n]), loose).ServerStop); } CollectionAssert.AreEqual(new double?[] { 11, 13, 15, 13.5 }, stops); } [TestMethod] [TestCategory(Category.Unit)] public void WalkingTheBarsOnceOrDayByDayGivesTheSameState() { var bars = BacktestData.Walk(700, 11, start: 30_000, volatility: 0.04); var settings = new CryptoTrendSettings(); var once = new TrendTracker().Advance(StrategyData.Series(bars), settings); var stepwise = new TrendTracker(); for (var n = 1; n <= bars.Count; n++) { stepwise.Advance(StrategyData.Series([.. bars.Take(n)]), settings); } Assert.AreEqual(once.Ensemble, stepwise.Ensemble); Assert.AreEqual(once.ServerStop, stepwise.ServerStop); CollectionAssert.AreEqual(once.Active.ToArray(), stepwise.Active.ToArray()); } [TestMethod] [TestCategory(Category.Unit)] public void WeightsFollowTheCapsThenShrinkTogether() { // Six coins in a steady rise: e = 1 and a volatility near 1%, so every raw weight hits its cap. 35% for BTC // and ETH, 20% for the others: 150% in all, so everything shrinks by 1,5. var coins = new[] { "BTC", "ETH", "SOL", "ADA", "XRP", "DOT" }; var data = StrategyData.Crypto([.. coins.Select(c => (c, (IReadOnlyList)StrategyData.SteadyRise(450)))]); var last = data.Sessions[^1]; var decision = BacktestEngine.DecideOnce(new CryptoTrend(), data, PortfolioState.OnlyCash(10_000m), last); var weights = decision.Proposed.ToDictionary(i => i.Symbol, i => i.TargetWeight); Assert.AreEqual(0.233333m, weights["BTC-EUR"]); Assert.AreEqual(0.233333m, weights["ETH-EUR"]); foreach (var other in new[] { "SOL-EUR", "ADA-EUR", "XRP-EUR", "DOT-EUR" }) { Assert.AreEqual(0.133333m, weights[other]); } Assert.IsTrue(decision.Proposed.All(i => i.Reason == CryptoTrend.Reasons.Entry && i.Stop > 0m)); // Alone, bitcoin stops at its cap. var alone = BacktestEngine.DecideOnce(new CryptoTrend(), StrategyData.Crypto(("BTC", StrategyData.SteadyRise(450))), PortfolioState.OnlyCash(10_000m), last); Assert.AreEqual(0.35m, alone.Proposed.Single().TargetWeight); } [TestMethod] [TestCategory(Category.Unit)] public void APositionIsResizedOnlyBeyondTheThresholds() { var bars = StrategyData.SteadyRise(450); var data = StrategyData.Crypto(("BTC", bars)); var last = data.Sessions[^1]; var close = Math.Round((decimal)bars[^1].Close, 8); IReadOnlyList At(decimal weight) { var quantity = weight * 10_000m / close; var state = new PortfolioState(10_000m - (quantity * close), new Dictionary { ["BTC-EUR"] = new(quantity, close, null, StrategyData.Start) }); return BacktestEngine.DecideOnce(new CryptoTrend(), data, state, last).Proposed; } // Target 35%. At 30% the gap (5 points) is within 20% of the target (7 points): only the stop moves. var near = At(0.30m).Single(); Assert.IsNull(near.TargetWeight); Assert.AreEqual(CryptoTrend.Reasons.StopMoved, near.Reason); // At 25% the gap (10 points) is beyond both thresholds: back to 35%. var far = At(0.25m).Single(); Assert.AreEqual(0.35m, far.TargetWeight); Assert.AreEqual(CryptoTrend.Reasons.Increase, far.Reason); } [TestMethod] [TestCategory(Category.Unit)] public void TheUniverseIsTheTopTenOnTheFirstOfTheMonthWithoutStablecoinsOrYoungCoins() { // Twelve coins with growing traded value, a stablecoin with the largest of all, a coin listed 200 days ago. var instruments = new List(); for (var k = 1; k <= 12; k++) { instruments.Add(new BacktestInstrument(StrategyData.Coin("C" + k.ToString("00", System.Globalization.CultureInfo.InvariantCulture)), StrategyData.SteadyRise(450, volume: 10_000 * k))); } instruments.Add(new BacktestInstrument(StrategyData.Coin("USDC"), StrategyData.FromCloses([.. Enumerable.Repeat(1d, 450)], volume: 1e12))); instruments.Add(new BacktestInstrument(StrategyData.Coin("NEW"), StrategyData.FromCloses([.. Enumerable.Repeat(100d, 200)], from: StrategyData.Start.AddDays(250), volume: 1e9))); var data = new BacktestDataset(instruments, "EUR"); var strategy = new CryptoTrend(); var day = new DateOnly(2025, 3, 20); UniverseContext Context(DateOnly d) => new(d, [.. data.Instruments.Select(i => i.Symbol)]) { Bars = s => data[s]!.SeriesThrough(d), Spec = s => data[s]?.Spec, }; var universe = strategy.Universe(Context(day)); CollectionAssert.AreEqual(Enumerable.Range(3, 10).Reverse().Select(k => "C" + k.ToString("00", System.Globalization.CultureInfo.InvariantCulture) + "-EUR").ToList(), universe.ToList()); // Live, the spread is known: one too wide is out, and the 11th by value comes in. var live = new CryptoTrend().Universe(Context(day) with { SpreadBp = s => s == "C12-EUR" ? 25 : 5 }); CollectionAssert.DoesNotContain(live.ToList(), "C12-EUR"); CollectionAssert.Contains(live.ToList(), "C02-EUR"); } [TestMethod] [TestCategory(Category.Unit)] public void ACoinThatLeftTheUniverseIsManagedButNeverBought() { // A young coin (not in the universe) held at 10% in a steady rise: its target would be its cap, 20%. var data = StrategyData.Crypto(("BTC", StrategyData.SteadyRise(450)), ("NEW", StrategyData.SteadyRise(450).GetRange(150, 300))); var last = data.Sessions[^1]; var close = Math.Round((decimal)data["NEW-EUR"]!.Bars[^1].Close, 8); var quantity = 1_000m / close; var state = new PortfolioState(9_000m, new Dictionary { ["NEW-EUR"] = new(quantity, close, null, last.AddDays(-10)) }); var intents = BacktestEngine.DecideOnce(new CryptoTrend(), data, state, last).Proposed; var coin = intents.Single(i => i.Symbol == "NEW-EUR"); Assert.IsNull(coin.TargetWeight, "No purchase for a coin out of the universe."); Assert.IsNotNull(coin.Stop); } [TestMethod] [TestCategory(Category.Unit)] public void CryptoTrendDecidesOnTheMidnightUtcClose() { // The day's bar opens and closes at 00:00 UTC (trap 23): the decision comes at the close, at midnight. var times = new List(); var data = StrategyData.Crypto(("BTC", BacktestData.Walk(30, 3, from: StrategyData.Start))); BacktestEngine.Run(new Recording(new CryptoTrend(), times), data); Assert.HasCount(30, times); for (var i = 0; i < times.Count; i++) { Assert.AreEqual(new DateTimeOffset(StrategyData.Start.AddDays(i + 1).ToDateTime(TimeOnly.MinValue), TimeSpan.Zero), times[i]); } } [TestMethod] [TestCategory(Category.Unit)] public void CryptoTrendDoesNotLookAhead() { var data = StrategyData.Crypto( ("BTC", BacktestData.Walk(900, 21, start: 30_000, drift: 0.001, volatility: 0.035, from: StrategyData.Start)), ("ETH", BacktestData.Walk(900, 22, start: 2_000, drift: 0.0008, volatility: 0.045, from: StrategyData.Start)), ("SOL", BacktestData.Walk(900, 23, start: 50, drift: 0.0005, volatility: 0.06, from: StrategyData.Start))); var result = LookAheadCheck.Run(_ => new CryptoTrend(new CryptoTrendSettings { MinAgeDays = 100, MinValue = 0 }), data); Assert.IsTrue(result.Passed, string.Join("\n", result.Mismatches.Take(3))); var run = BacktestEngine.Run(new CryptoTrend(new CryptoTrendSettings { MinAgeDays = 100, MinValue = 0 }), data); Assert.IsGreaterThan(5, run.Fills.Count, "The check must look at a strategy that trades."); } // ---- equity_momentum ---- private static readonly DateOnly Monday = new(2022, 1, 3); /// Thirty stocks with different drifts, SPY as data only, on business days. private static BacktestDataset Stocks(int sessions, double spyDrift, int count = 30, ulong seed = 100) { var instruments = new List(); for (var k = 0; k < count; k++) { var bars = BacktestData.Walk(sessions, seed + (ulong)k, start: 50 + k, drift: 0.0002 * (k - 10), volatility: 0.015 + (0.0005 * k)); instruments.Add(new BacktestInstrument(StrategyData.Share("S" + k.ToString("00", System.Globalization.CultureInfo.InvariantCulture)), StrategyData.OnBusinessDays([.. bars.Select(b => b with { Volume = 100_000 })], Monday))); } var spy = BacktestData.Walk(sessions, seed + 999, start: 400, drift: spyDrift, volatility: 0.008); instruments.Add(new BacktestInstrument(StrategyData.Share("SPY") with { IsFund = true }, StrategyData.OnBusinessDays([.. spy], Monday))); return new BacktestDataset(instruments, "USD", dataOnly: ["SPY"]); } [TestMethod] [TestCategory(Category.Unit)] public void TheWeeklyReviewIsTheLastCloseBeforeANewWeek() { StrategyContext At(DateOnly day, DateOnly? next) => new(day, default, [], new PortfolioView(0m, 0m, new Dictionary()), _ => BarSeries.Empty, _ => null) { NextSession = next, }; var friday = new DateOnly(2026, 4, 3); Assert.IsTrue(EquityMomentum.IsReview(At(friday, friday.AddDays(3)))); Assert.IsFalse(EquityMomentum.IsReview(At(friday.AddDays(-1), friday))); // Good Friday closed: Thursday is the last session of the week. Assert.IsTrue(EquityMomentum.IsReview(At(friday.AddDays(-1), friday.AddDays(3)))); // A Monday holiday: the review on Friday, orders on Tuesday. Assert.IsTrue(EquityMomentum.IsReview(At(friday, friday.AddDays(4)))); Assert.IsFalse(EquityMomentum.IsReview(At(friday, null))); } [TestMethod] [TestCategory(Category.Unit)] public void MomentumBuysOnTheFirstSessionOfTheWeekOnlyWhileTheMarketRises() { var rising = BacktestEngine.Run(new EquityMomentum(), Stocks(520, 0.001)); var buys = rising.Fills.Where(f => f.Side == OrderSide.Buy && f.Reason == EquityMomentum.Reasons.Entry).ToList(); Assert.IsNotEmpty(buys); // Every purchase at the open of the first session of its week (here always a Monday). Assert.IsTrue(buys.All(f => f.Day.DayOfWeek == DayOfWeek.Monday), string.Join(", ", buys.Select(f => f.Day))); Assert.IsFalse(rising.Fills.Any(f => f.Symbol == "SPY"), "SPY is data, never an instrument."); // At most 12 positions, no target above the 15% cap. var entries = rising.Decisions.SelectMany(d => d.Proposed).Where(i => i.TargetWeight > 0m).ToList(); Assert.IsTrue(entries.All(i => i.TargetWeight <= 0.15m)); Assert.IsTrue(rising.Decisions.All(d => d.Proposed.Count(i => i.Reason == EquityMomentum.Reasons.Entry) <= 12)); // SPY below its 200-day average: no purchase at all. var falling = BacktestEngine.Run(new EquityMomentum(), Stocks(520, -0.002)); Assert.IsFalse(falling.Fills.Any(f => f.Side == OrderSide.Buy)); } [TestMethod] [TestCategory(Category.Unit)] public void MomentumStopsOnlyRise() { var run = BacktestEngine.Run(new EquityMomentum(), Stocks(520, 0.001)); var stops = run.Decisions.SelectMany(d => d.Proposed.Where(i => i.Reason == EquityMomentum.Reasons.StopMoved).Select(i => (d.Day, i.Symbol, Stop: i.Stop!.Value))).ToList(); Assert.IsNotEmpty(stops); foreach (var group in stops.GroupBy(s => s.Symbol)) { var list = group.OrderBy(s => s.Day).ToList(); for (var i = 1; i < list.Count; i++) { // A new holding period may start lower; within one, every move is up. var exited = run.Fills.Any(f => f.Symbol == group.Key && f.Side == OrderSide.Sell && f.Day > list[i - 1].Day && f.Day <= list[i].Day); Assert.IsTrue(exited || list[i].Stop > list[i - 1].Stop, $"{group.Key} {list[i - 1]} → {list[i]}"); } } } [TestMethod] [TestCategory(Category.Unit)] public void MomentumSellsAStockBelowItsAverageAtTheReview() { var data = Stocks(520, 0.001); var friday = data.Sessions.Last(d => d.DayOfWeek == DayOfWeek.Friday && d < data.Sessions[^1]); // S00 drifts down: it is below its 100-session average. var bars = data["S00"]!.SeriesThrough(friday); Assert.IsLessThan(Indicators.Sma(bars, 100)!.Value, bars.Close(bars.Count - 1)); var close = Math.Round((decimal)bars.Close(bars.Count - 1), 2); var state = new PortfolioState(9_000m, new Dictionary { ["S00"] = new(1_000m / close, close, null, friday.AddDays(-30)) }); var intent = BacktestEngine.DecideOnce(new EquityMomentum(), data, state, friday).Proposed.Single(i => i.Symbol == "S00"); Assert.AreEqual(0m, intent.TargetWeight); Assert.IsTrue(intent.Reason is EquityMomentum.Reasons.ExitTrend or EquityMomentum.Reasons.ExitRank); } [TestMethod] [TestCategory(Category.Unit)] public void EquityMomentumDoesNotLookAhead() { var data = Stocks(520, 0.001); var result = LookAheadCheck.Run(_ => new EquityMomentum(), data); Assert.IsTrue(result.Passed, string.Join("\n", result.Mismatches.Take(3))); } // ---- equity_meanrev ---- /// /// 320 sessions rising by 0,1 a day from 72,3, then three falls of 1: every true range is 2 (high and low one away /// from the close), so ATR(14) = 2 and the stop distance 2,5 × 2 = 5. RSI(2) ends near 1, the close (101) is below /// its 5-session average and above its 200-session one. /// private static List Dip(double shift = 0) { var closes = Enumerable.Range(0, 317).Select(i => Math.Round(72.3 + (0.1 * i), 1) + shift).Concat([103 + shift, 102 + shift, 101 + shift]).ToList(); return StrategyData.OnBusinessDays(StrategyData.FromCloses(closes, range: 1, volume: 100_000), Monday); } private static BacktestDataset Shares(params (string Symbol, List Bars)[] stocks) => new(stocks.Select(s => new BacktestInstrument(StrategyData.Share(s.Symbol), s.Bars)), "USD"); [TestMethod] [TestCategory(Category.Unit)] public void MeanrevSizesForARiskOfFourThousandthsCappedAtThirtyPercent() { var data = Shares(("AAA", Dip())); var last = data.Sessions[^1]; // Reference equity = the strategy's 10.000 $: risk 40 $ over a 5 $ distance = 8 shares at 101 = 808 $, 8,08%. var entry = BacktestEngine.DecideOnce(new EquityMeanrev(), data, PortfolioState.OnlyCash(10_000m), last).Proposed.Single(); Assert.AreEqual(EquityMeanrev.Reasons.Entry, entry.Reason); Assert.AreEqual(0.0808m, entry.TargetWeight); Assert.AreEqual(5m, entry.StopOffset); // With the default share (15% of the bot) the reference is 66.666 $: 53,3 shares, more than the 30% cap. var capped = BacktestEngine.DecideOnce(new EquityMeanrev(), data, PortfolioState.OnlyCash(10_000m), last, new BacktestOptions { ReferenceShare = 0.15m }).Proposed.Single(); Assert.AreEqual(0.3m, capped.TargetWeight); // A position bought today holds 9.500 $, 500 $ stay free: not enough for the candidate (808 $), dropped. var both = Shares(("AAA", Dip()), ("BBB", Dip())); var poor = new PortfolioState(500m, new Dictionary { ["BBB"] = new(9_500m / 101m, 101m, 96m, last) }); Assert.IsFalse(BacktestEngine.DecideOnce(new EquityMeanrev(), both, poor, last).Proposed.Any(i => i.Symbol == "AAA")); } [TestMethod] [TestCategory(Category.Unit)] public void MeanrevTakesAtMostThreeWithTheLowestRsi() { // Five dips; a deeper last fall gives a lower RSI. The three deepest are chosen. var stocks = Enumerable.Range(0, 5).Select(k => { var bars = Dip(k); bars[^1] = bars[^1] with { Close = bars[^1].Close - (0.1 * k), Low = bars[^1].Low - (0.1 * k) }; return ("D" + k.ToString(System.Globalization.CultureInfo.InvariantCulture), bars); }).ToArray(); var data = Shares(stocks); var intents = BacktestEngine.DecideOnce(new EquityMeanrev(), data, PortfolioState.OnlyCash(100_000m), data.Sessions[^1]).Proposed; CollectionAssert.AreEqual(new[] { "D4", "D3", "D2" }, intents.Select(i => i.Symbol).ToArray()); } [TestMethod] [TestCategory(Category.Unit)] public void MeanrevExitsAtTheCloseOnTheRules() { var bars = Dip(); var data = Shares(("AAA", bars)); var last = data.Sessions[^1]; Intent Exit(DateOnly entered, DateOnly day) { var state = new PortfolioState(9_000m, new Dictionary { ["AAA"] = new(10m, 100m, 95m, entered) }); return BacktestEngine.DecideOnce(new EquityMeanrev(), data, state, day).Proposed.Single(i => i.Symbol == "AAA"); } // In the rise the close is above its 5-session average: out at the close. var rising = Exit(data.Sessions[^10], data.Sessions[^5]); Assert.AreEqual(EquityMeanrev.Reasons.ExitAverage, rising.Reason); Assert.IsTrue(rising.AtClose); // In the dip none of the price rules says exit; held since the fifth session from the end: time is up. var timed = Exit(data.Sessions[^5], last); Assert.AreEqual(EquityMeanrev.Reasons.ExitTime, timed.Reason); var state = new PortfolioState(9_000m, new Dictionary { ["AAA"] = new(10m, 100m, 95m, data.Sessions[^4]) }); Assert.IsFalse(BacktestEngine.DecideOnce(new EquityMeanrev(), data, state, last).Proposed.Any(i => i.Symbol == "AAA"), "Four sessions: still held."); } [TestMethod] [TestCategory(Category.Unit)] public void EquityMeanrevDoesNotLookAhead() { var instruments = Enumerable.Range(0, 12).Select(k => new BacktestInstrument(StrategyData.Share("M" + k.ToString("00", System.Globalization.CultureInfo.InvariantCulture)), StrategyData.OnBusinessDays([.. BacktestData.Walk(520, 300 + (ulong)k, start: 60 + k, drift: 0.0006, volatility: 0.02).Select(b => b with { Volume = 100_000 })], Monday))); var data = new BacktestDataset(instruments, "USD"); var result = LookAheadCheck.Run(_ => new EquityMeanrev(), data); Assert.IsTrue(result.Passed, string.Join("\n", result.Mismatches.Take(3))); var run = BacktestEngine.Run(new EquityMeanrev(), data); Assert.IsGreaterThan(5, run.Fills.Count, "The check must look at a strategy that trades."); } // ---- Engine features the strategies need ---- [TestMethod] [TestCategory(Category.Unit)] public void AnExitAtTheCloseIsFilledAtThatCloseAndAStopOffsetFollowsThePriceObtained() { var d1 = BacktestData.D1; var bars = new List { new(d1, 100, 101, 99, 100, 1000), new(d1.AddDays(1), 100, 102, 99, 101, 1000), new(d1.AddDays(2), 101, 103, 100, 102, 1000), new(d1.AddDays(3), 102, 103, 90, 95, 1000), }; var script = new ScriptedStrategy(new Dictionary> { [d1] = [new Intent("BTC-EUR", 0.5m, "enter") { StopOffset = 5m }], [d1.AddDays(2)] = [new Intent("BTC-EUR", 0m, "exit") { AtClose = true }], }); var run = BacktestEngine.Run(script, BacktestData.One(BacktestData.Btc(), bars)); // Bought at the open of day 2 (100 + 5 bp → 100,1); sold at the close of day 3 itself, 102 − 5 bp → 101,9. Assert.AreEqual(d1.AddDays(1), run.Fills[0].Day); Assert.AreEqual(d1.AddDays(2), run.Fills[1].Day); Assert.AreEqual(101.9m, run.Fills[1].Price); Assert.AreEqual("exit", run.Fills[1].Reason); // Without the exit, the stop sits 5 below the price obtained (95,1) and the low of day 4 (90) takes it. var held = BacktestEngine.Run(new ScriptedStrategy(new Dictionary> { [d1] = [new Intent("BTC-EUR", 0.5m, "enter") { StopOffset = 5m }] }), BacktestData.One(BacktestData.Btc(), bars)); var stop = held.Fills.Single(f => f.Side == OrderSide.Sell); Assert.AreEqual(BacktestReasons.Stop, stop.Reason); Assert.AreEqual(d1.AddDays(3), stop.Day); Assert.AreEqual(95.0m, stop.Price); } /// Records the moment each decision is taken. private sealed class Recording(IStrategy inner, List times) : 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) { times.Add(context.Now); return inner.Decide(context); } } }