Production hardening: kill switch, circuit breaker, trailing stops, log level, holiday calendar

tests/NT8.Core.Tests/Adapters/NT8DataConverterTests.cs

@@ -0,0 +1,354 @@
+using System;
+using System.Collections.Generic;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NT8.Adapters.NinjaTrader;
+using NT8.Core.Common.Models;
+
+namespace NT8.Core.Tests.Adapters
+{
+    /// <summary>
+    /// Unit tests for NT8DataConverter.
+    /// </summary>
+    [TestClass]
+    public class NT8DataConverterTests
+    {
+        [TestMethod]
+        public void ConvertBar_WithValidESBar_ShouldCreateBarData()
+        {
+            var time = new DateTime(2026, 2, 17, 9, 30, 0, DateTimeKind.Utc);
+
+            var result = NT8DataConverter.ConvertBar("ES", time, 4200.0, 4210.0, 4195.0, 4208.0, 10000, 5);
+
+            Assert.AreEqual("ES", result.Symbol);
+            Assert.AreEqual(time, result.Time);
+            Assert.AreEqual(4200.0, result.Open);
+            Assert.AreEqual(4210.0, result.High);
+            Assert.AreEqual(4195.0, result.Low);
+            Assert.AreEqual(4208.0, result.Close);
+            Assert.AreEqual(10000L, result.Volume);
+            Assert.AreEqual(TimeSpan.FromMinutes(5), result.BarSize);
+        }
+
+        [DataTestMethod]
+        [DataRow(null)]
+        [DataRow("")]
+        [DataRow("   ")]
+        public void ConvertBar_WithInvalidSymbol_ShouldThrowArgumentException(string symbol)
+        {
+            var ex = Assert.ThrowsException<ArgumentException>(
+                delegate
+                {
+                    NT8DataConverter.ConvertBar(symbol, DateTime.UtcNow, 1, 2, 0.5, 1.5, 10, 5);
+                });
+
+            Assert.AreEqual("symbol", ex.Message);
+        }
+
+        [DataTestMethod]
+        [DataRow(0)]
+        [DataRow(-1)]
+        [DataRow(-60)]
+        public void ConvertBar_WithInvalidBarSize_ShouldThrowArgumentException(int barSize)
+        {
+            var ex = Assert.ThrowsException<ArgumentException>(
+                delegate
+                {
+                    NT8DataConverter.ConvertBar("ES", DateTime.UtcNow, 1, 2, 0.5, 1.5, 10, barSize);
+                });
+
+            Assert.AreEqual("barSizeMinutes", ex.Message);
+        }
+
+        [TestMethod]
+        public void ConvertBar_WithDifferentTimeframes_ShouldSetCorrectBarSize()
+        {
+            var sizes = new[] { 1, 5, 15, 30, 60, 240, 1440 };
+
+            for (var i = 0; i < sizes.Length; i++)
+            {
+                var value = sizes[i];
+                var result = NT8DataConverter.ConvertBar("ES", DateTime.UtcNow, 1, 2, 0.5, 1.5, 10, value);
+                Assert.AreEqual(TimeSpan.FromMinutes(value), result.BarSize);
+            }
+        }
+
+        [TestMethod]
+        public void ConvertBar_WithHighLessThanLow_ShouldStillCreate()
+        {
+            var result = NT8DataConverter.ConvertBar("ES", DateTime.UtcNow, 100, 95, 105, 99, 1000, 5);
+
+            Assert.AreEqual(95.0, result.High);
+            Assert.AreEqual(105.0, result.Low);
+        }
+
+        [TestMethod]
+        public void ConvertBar_WithZeroVolume_ShouldCreateBar()
+        {
+            var result = NT8DataConverter.ConvertBar("MES", DateTime.UtcNow, 5000, 5005, 4995, 5001, 0, 1);
+
+            Assert.AreEqual(0L, result.Volume);
+        }
+
+        [TestMethod]
+        public void ConvertBar_WithNegativePrices_ShouldHandleCorrectly()
+        {
+            var result = NT8DataConverter.ConvertBar("ZN", DateTime.UtcNow, -1.2, -0.9, -1.4, -1.0, 2500, 5);
+
+            Assert.AreEqual(-1.2, result.Open);
+            Assert.AreEqual(-0.9, result.High);
+            Assert.AreEqual(-1.4, result.Low);
+            Assert.AreEqual(-1.0, result.Close);
+        }
+
+        [TestMethod]
+        public void ConvertBar_WithLargeVolume_ShouldHandleCorrectly()
+        {
+            var result = NT8DataConverter.ConvertBar("NQ", DateTime.UtcNow, 100, 110, 95, 108, 10000000, 5);
+
+            Assert.AreEqual(10000000L, result.Volume);
+        }
+
+        [TestMethod]
+        public void ConvertAccount_WithPositiveValues_ShouldCreateAccountInfo()
+        {
+            var now = DateTime.UtcNow;
+            var result = NT8DataConverter.ConvertAccount(100000, 250000, 1250.50, 0.05, now);
+
+            Assert.AreEqual(100000.0, result.Equity);
+            Assert.AreEqual(250000.0, result.BuyingPower);
+            Assert.AreEqual(1250.50, result.DailyPnL);
+            Assert.AreEqual(0.05, result.MaxDrawdown);
+            Assert.AreEqual(now, result.LastUpdate);
+        }
+
+        [TestMethod]
+        public void ConvertAccount_WithNegativePnL_ShouldHandleCorrectly()
+        {
+            var result = NT8DataConverter.ConvertAccount(100000, 250000, -2500.75, 0.05, DateTime.UtcNow);
+
+            Assert.AreEqual(-2500.75, result.DailyPnL);
+        }
+
+        [TestMethod]
+        public void ConvertAccount_WithZeroValues_ShouldCreateAccount()
+        {
+            var result = NT8DataConverter.ConvertAccount(0, 0, 0, 0, DateTime.UtcNow);
+
+            Assert.AreEqual(0.0, result.Equity);
+            Assert.AreEqual(0.0, result.BuyingPower);
+            Assert.AreEqual(0.0, result.DailyPnL);
+            Assert.AreEqual(0.0, result.MaxDrawdown);
+        }
+
+        [TestMethod]
+        public void ConvertAccount_WithLargeEquity_ShouldHandleCorrectly()
+        {
+            var result = NT8DataConverter.ConvertAccount(10000000, 25000000, 5000, 100000, DateTime.UtcNow);
+
+            Assert.AreEqual(10000000.0, result.Equity);
+            Assert.AreEqual(25000000.0, result.BuyingPower);
+        }
+
+        [TestMethod]
+        public void ConvertPosition_WithLongPosition_ShouldCreatePosition()
+        {
+            var result = NT8DataConverter.ConvertPosition("ES", 2, 4200.50, 250, 500, DateTime.UtcNow);
+
+            Assert.AreEqual("ES", result.Symbol);
+            Assert.IsTrue(result.Quantity > 0);
+            Assert.AreEqual(2, result.Quantity);
+        }
+
+        [TestMethod]
+        public void ConvertPosition_WithShortPosition_ShouldHandleNegativeQuantity()
+        {
+            var result = NT8DataConverter.ConvertPosition("ES", -1, 4200.50, -150, 200, DateTime.UtcNow);
+
+            Assert.IsTrue(result.Quantity < 0);
+            Assert.AreEqual(-1, result.Quantity);
+        }
+
+        [TestMethod]
+        public void ConvertPosition_WithFlatPosition_ShouldHandleZeroQuantity()
+        {
+            var result = NT8DataConverter.ConvertPosition("ES", 0, 0, 0, 0, DateTime.UtcNow);
+
+            Assert.AreEqual(0, result.Quantity);
+            Assert.AreEqual(0.0, result.AveragePrice);
+        }
+
+        [DataTestMethod]
+        [DataRow(null)]
+        [DataRow("")]
+        [DataRow("   ")]
+        public void ConvertPosition_WithInvalidSymbol_ShouldThrowArgumentException(string symbol)
+        {
+            var ex = Assert.ThrowsException<ArgumentException>(
+                delegate
+                {
+                    NT8DataConverter.ConvertPosition(symbol, 1, 1, 1, 1, DateTime.UtcNow);
+                });
+
+            Assert.AreEqual("symbol", ex.Message);
+        }
+
+        [TestMethod]
+        public void ConvertPosition_WithNegativeUnrealizedPnL_ShouldHandleCorrectly()
+        {
+            var result = NT8DataConverter.ConvertPosition("ES", 1, 4200.50, -350.25, 20, DateTime.UtcNow);
+
+            Assert.AreEqual(-350.25, result.UnrealizedPnL);
+        }
+
+        [TestMethod]
+        public void ConvertSession_WithRTHSession_ShouldCreateMarketSession()
+        {
+            var start = new DateTime(2026, 2, 17, 9, 30, 0, DateTimeKind.Utc);
+            var end = new DateTime(2026, 2, 17, 16, 0, 0, DateTimeKind.Utc);
+
+            var result = NT8DataConverter.ConvertSession(start, end, true, "RTH");
+
+            Assert.IsTrue(result.IsRth);
+            Assert.AreEqual("RTH", result.SessionName);
+        }
+
+        [TestMethod]
+        public void ConvertSession_WithETHSession_ShouldCreateMarketSession()
+        {
+            var start = new DateTime(2026, 2, 17, 18, 0, 0, DateTimeKind.Utc);
+            var end = new DateTime(2026, 2, 18, 9, 30, 0, DateTimeKind.Utc);
+
+            var result = NT8DataConverter.ConvertSession(start, end, false, "ETH");
+
+            Assert.IsFalse(result.IsRth);
+            Assert.AreEqual(start, result.SessionStart);
+            Assert.AreEqual(end, result.SessionEnd);
+        }
+
+        [DataTestMethod]
+        [DataRow(null)]
+        [DataRow("")]
+        [DataRow("   ")]
+        public void ConvertSession_WithInvalidName_ShouldThrowArgumentException(string name)
+        {
+            var ex = Assert.ThrowsException<ArgumentException>(
+                delegate
+                {
+                    NT8DataConverter.ConvertSession(DateTime.UtcNow, DateTime.UtcNow.AddHours(1), true, name);
+                });
+
+            Assert.AreEqual("sessionName", ex.Message);
+        }
+
+        [TestMethod]
+        public void ConvertSession_WithEndBeforeStart_ShouldThrowArgumentException()
+        {
+            var start = new DateTime(2026, 2, 17, 16, 0, 0, DateTimeKind.Utc);
+            var end = new DateTime(2026, 2, 17, 9, 30, 0, DateTimeKind.Utc);
+
+            var ex = Assert.ThrowsException<ArgumentException>(
+                delegate
+                {
+                    NT8DataConverter.ConvertSession(start, end, true, "RTH");
+                });
+
+            Assert.AreEqual("sessionEnd", ex.Message);
+        }
+
+        [TestMethod]
+        public void ConvertContext_WithValidInputs_ShouldCreateStrategyContext()
+        {
+            var position = CreatePosition();
+            var account = CreateAccount();
+            var session = CreateSession();
+            var customData = new Dictionary<string, object>();
+            customData.Add("a", 1);
+            customData.Add("b", "value");
+
+            var result = NT8DataConverter.ConvertContext("ES", DateTime.UtcNow, position, account, session, customData);
+
+            Assert.AreEqual("ES", result.Symbol);
+            Assert.AreEqual(position, result.CurrentPosition);
+            Assert.AreEqual(account, result.Account);
+            Assert.AreEqual(session, result.Session);
+            Assert.AreEqual(2, result.CustomData.Count);
+            Assert.AreEqual(1, (int)result.CustomData["a"]);
+            Assert.AreEqual("value", (string)result.CustomData["b"]);
+        }
+
+        [TestMethod]
+        public void ConvertContext_WithNullCustomData_ShouldCreateEmptyDictionary()
+        {
+            var result = NT8DataConverter.ConvertContext("ES", DateTime.UtcNow, CreatePosition(), CreateAccount(), CreateSession(), null);
+
+            Assert.IsNotNull(result.CustomData);
+            Assert.AreEqual(0, result.CustomData.Count);
+        }
+
+        [DataTestMethod]
+        [DataRow(null)]
+        [DataRow("")]
+        [DataRow("   ")]
+        public void ConvertContext_WithInvalidSymbol_ShouldThrowArgumentException(string symbol)
+        {
+            var ex = Assert.ThrowsException<ArgumentException>(
+                delegate
+                {
+                    NT8DataConverter.ConvertContext(symbol, DateTime.UtcNow, CreatePosition(), CreateAccount(), CreateSession(), null);
+                });
+
+            Assert.AreEqual("symbol", ex.Message);
+        }
+
+        [TestMethod]
+        public void ConvertContext_WithNullPosition_ShouldThrowArgumentNullException()
+        {
+            var ex = Assert.ThrowsException<ArgumentNullException>(
+                delegate
+                {
+                    NT8DataConverter.ConvertContext("ES", DateTime.UtcNow, null, CreateAccount(), CreateSession(), null);
+                });
+
+            Assert.AreEqual("currentPosition", ex.ParamName);
+        }
+
+        [TestMethod]
+        public void ConvertContext_WithNullAccount_ShouldThrowArgumentNullException()
+        {
+            var ex = Assert.ThrowsException<ArgumentNullException>(
+                delegate
+                {
+                    NT8DataConverter.ConvertContext("ES", DateTime.UtcNow, CreatePosition(), null, CreateSession(), null);
+                });
+
+            Assert.AreEqual("account", ex.ParamName);
+        }
+
+        [TestMethod]
+        public void ConvertContext_WithNullSession_ShouldThrowArgumentNullException()
+        {
+            var ex = Assert.ThrowsException<ArgumentNullException>(
+                delegate
+                {
+                    NT8DataConverter.ConvertContext("ES", DateTime.UtcNow, CreatePosition(), CreateAccount(), null, null);
+                });
+
+            Assert.AreEqual("session", ex.ParamName);
+        }
+
+        private static Position CreatePosition()
+        {
+            return new Position("ES", 1, 4200.0, 10.0, 5.0, DateTime.UtcNow);
+        }
+
+        private static AccountInfo CreateAccount()
+        {
+            return new AccountInfo(100000.0, 250000.0, 500.0, 2500.0, DateTime.UtcNow);
+        }
+
+        private static MarketSession CreateSession()
+        {
+            return new MarketSession(DateTime.UtcNow.Date.AddHours(9.5), DateTime.UtcNow.Date.AddHours(16), true, "RTH");
+        }
+    }
+}