Refactor: Level One Service (#16)

Romazes · web-flow · commit 9641b73d4d13 · 2025-06-24T18:39:21.000+03:00
* refactor: usual order book to Best Bid And Offer (which we get from server)

* refactor: Best Bid and Offer service

* refactor: use LevelOneService from Lean

* feat: use new LevelOneServiceManager for DQH

* refactor: using path of LevelOneOrderBook
diff --git a/QuantConnect.ThetaData.Tests/ThetaDataAdditionalTests.cs b/QuantConnect.ThetaData.Tests/ThetaDataAdditionalTests.cs
@@ -14,8 +14,11 @@
 */
 
 using System;
+using Newtonsoft.Json;
 using NUnit.Framework;
 using System.Collections.Generic;
+using QuantConnect.Lean.DataSource.ThetaData.Models.Enums;
+using QuantConnect.Lean.DataSource.ThetaData.Models.WebSocket;
 
 namespace QuantConnect.Lean.DataSource.ThetaData.Tests;
 
@@ -84,4 +87,56 @@ public void GenerateDateRangesWithInterval_ShouldHandleSameStartEndDate()
 
         Assert.AreEqual(1, ranges.Count, "There should be no date ranges generated.");
     }
+
+    [Test]
+    public void DeserializeWebSocketQuoteResponse()
+    {
+        var webSocketQuoteResponse = @"{
+    ""header"": {
+        ""type"": ""QUOTE"",
+        ""status"": ""CONNECTED""
+    },
+    ""contract"": {
+        ""security_type"": ""STOCK"",
+        ""root"": ""NVDA""
+    },
+    ""quote"": {
+        ""ms_of_day"": 43032783,
+        ""bid_size"": 516,
+        ""bid_exchange"": 29,
+        ""bid"": 145.58,
+        ""bid_condition"": 0,
+        ""ask_size"": 1527,
+        ""ask_exchange"": 29,
+        ""ask"": 145.59,
+        ""ask_condition"": 0,
+        ""date"": 20250616
+    }
+}";
+
+        var webSocketResponse = JsonConvert.DeserializeObject<WebSocketResponse>(webSocketQuoteResponse);
+
+        Assert.IsNotNull(webSocketResponse);
+        Assert.IsNotNull(webSocketResponse.Header.Type);
+        Assert.AreEqual(WebSocketHeaderType.Quote, webSocketResponse.Header.Type);
+
+        Assert.IsNotNull(webSocketResponse.Contract);
+        Assert.AreEqual(ContractSecurityType.Equity, webSocketResponse.Contract?.SecurityType);
+        Assert.AreEqual("NVDA", webSocketResponse.Contract?.Root);
+
+        Assert.IsNotNull(webSocketResponse.Quote);
+        var quote = webSocketResponse.Quote.Value;
+        Assert.AreEqual(43032783, quote.TimeMilliseconds);
+        Assert.AreEqual(516m, quote.BidSize);
+        Assert.AreEqual(29m, quote.BidExchange);
+        Assert.AreEqual(145.58m, quote.BidPrice);
+        Assert.AreEqual(0, quote.BidCondition);
+        Assert.AreEqual(1527m, quote.AskSize);
+        Assert.AreEqual(29m, quote.AskExchange);
+        Assert.AreEqual(145.59m, quote.AskPrice);
+        Assert.AreEqual(0, quote.AskCondition);
+        Assert.AreEqual(new DateTime(2025, 06, 16), quote.Date);
+
+        Assert.IsNull(webSocketResponse.Trade);
+    }
 }
diff --git a/QuantConnect.ThetaData.Tests/ThetaDataProviderTests.cs b/QuantConnect.ThetaData.Tests/ThetaDataProviderTests.cs
@@ -14,6 +14,7 @@
 */
 
 using System;
+using System.Text;
 using System.Linq;
 using NUnit.Framework;
 using System.Threading;
@@ -54,16 +55,61 @@ public void TearDown()
             }
         }
 
-        [TestCase("AAPL", SecurityType.Equity, Resolution.Second, 0, "2024/08/16")]
-        [TestCase("AAPL", SecurityType.Option, Resolution.Second, 215, "2024/08/16")]
-        [TestCase("VIX", SecurityType.Index, Resolution.Second, 0, "2024/08/16")]
-        public void CanSubscribeAndUnsubscribeOnSecondResolution(string ticker, SecurityType securityType, Resolution resolution, decimal strikePrice, DateTime expiryDate = default)
+        private static IEnumerable<TestCaseData> TestParameters
         {
-            var configs = GetSubscriptionDataConfigs(ticker, securityType, resolution, strikePrice, expiryDate);
+            get
+            {
+                var AAPL = Symbols.AAPL;
+                yield return new TestCaseData(new Symbol[] { AAPL }, Resolution.Second);
 
-            Assert.That(configs, Is.Not.Empty);
+                var DJI_Index = Symbol.Create("DJI", SecurityType.Index, Market.USA);
+                yield return new TestCaseData(new Symbol[] { DJI_Index }, Resolution.Second);
+
+                var NVDA = Symbol.Create("NVDA", SecurityType.Equity, Market.USA);
+                var DJT = Symbol.Create("DJT", SecurityType.Equity, Market.USA);
+                var TSLA = Symbol.Create("TSLA", SecurityType.Equity, Market.USA);
+                yield return new TestCaseData(new Symbol[] { AAPL, DJI_Index, NVDA, DJT, TSLA }, Resolution.Second);
+
+                var AAPL_Option = Symbol.CreateOption(AAPL, AAPL.ID.Market, SecurityType.Option.DefaultOptionStyle(), OptionRight.Call, 220m, new DateTime(2025, 06, 20));
+                var AAPL_Option2 = Symbol.CreateOption(AAPL, AAPL.ID.Market, SecurityType.Option.DefaultOptionStyle(), OptionRight.Call, 217.5m, new DateTime(2026, 06, 20));
+                var AAPL_Option3 = Symbol.CreateOption(AAPL, AAPL.ID.Market, SecurityType.Option.DefaultOptionStyle(), OptionRight.Put, 220m, new DateTime(2026, 06, 20));
+                var AAPL_Option4 = Symbol.CreateOption(AAPL, AAPL.ID.Market, SecurityType.Option.DefaultOptionStyle(), OptionRight.Put, 217.5m, new DateTime(2026, 06, 20));
+                yield return new TestCaseData(new[] { AAPL_Option, AAPL_Option2, AAPL_Option3, AAPL_Option4 }, Resolution.Second);
+
+                var nok = Symbol.Create("NOK", SecurityType.Equity, Market.USA);
+                var nok_option = Symbol.CreateOption(nok, nok.ID.Market, SecurityType.Option.DefaultOptionStyle(), OptionRight.Call, 7.5m, new DateTime(2026, 06, 20));
+
+                yield return new TestCaseData(new[] { nok_option }, Resolution.Second);
+            }
+        }
+
+        [Test, TestCaseSource(nameof(TestParameters))]
+        public void CanSubscribeAndUnsubscribeOnSecondResolution(Symbol[] symbols, Resolution resolution)
+        {
+
+            var configs = new List<SubscriptionDataConfig>();
+
+            var dataFromEnumerator = new Dictionary<Symbol, Dictionary<Type, int>>();
 
-            var dataFromEnumerator = new Dictionary<Type, int>() { { typeof(TradeBar), 0 }, { typeof(QuoteBar), 0 } };
+            foreach (var symbol in symbols)
+            {
+                dataFromEnumerator[symbol] = new Dictionary<Type, int>();
+                foreach (var config in GetSubscriptionDataConfigs(symbol, resolution))
+                {
+                    configs.Add(config);
+
+                    var tickType = config.TickType switch
+                    {
+                        TickType.Quote => typeof(QuoteBar),
+                        TickType.Trade => typeof(TradeBar),
+                        _ => throw new NotImplementedException()
+                    };
+
+                    dataFromEnumerator[symbol][tickType] = 0;
+                }
+            }
+
+            Assert.That(configs, Is.Not.Empty);
 
             Action<BaseData> callback = (dataPoint) =>
             {
@@ -74,13 +120,18 @@ public void CanSubscribeAndUnsubscribeOnSecondResolution(string ticker, Security
 
                 switch (dataPoint)
                 {
-                    case TradeBar _:
-                        dataFromEnumerator[typeof(TradeBar)] += 1;
+                    case TradeBar tb:
+                        dataFromEnumerator[tb.Symbol][typeof(TradeBar)] += 1;
                         break;
-                    case QuoteBar _:
-                        dataFromEnumerator[typeof(QuoteBar)] += 1;
+                    case QuoteBar qb:
+                        Assert.GreaterOrEqual(qb.Ask.Open, qb.Bid.Open, $"QuoteBar validation failed for {qb.Symbol}: Ask.Open ({qb.Ask.Open}) <= Bid.Open ({qb.Bid.Open}). Full data: {DisplayBaseData(qb)}");
+                        Assert.GreaterOrEqual(qb.Ask.High, qb.Bid.High, $"QuoteBar validation failed for {qb.Symbol}: Ask.High ({qb.Ask.High}) <= Bid.High ({qb.Bid.High}). Full data: {DisplayBaseData(qb)}");
+                        Assert.GreaterOrEqual(qb.Ask.Low, qb.Bid.Low, $"QuoteBar validation failed for {qb.Symbol}: Ask.Low ({qb.Ask.Low}) <= Bid.Low ({qb.Bid.Low}). Full data: {DisplayBaseData(qb)}");
+                        Assert.GreaterOrEqual(qb.Ask.Close, qb.Bid.Close, $"QuoteBar validation failed for {qb.Symbol}: Ask.Close ({qb.Ask.Close}) <= Bid.Close ({qb.Bid.Close}). Full data: {DisplayBaseData(qb)}");
+                        dataFromEnumerator[qb.Symbol][typeof(QuoteBar)] += 1;
                         break;
-                };
+                }
+                ;
             };
 
             foreach (var config in configs)
@@ -92,7 +143,7 @@ public void CanSubscribeAndUnsubscribeOnSecondResolution(string ticker, Security
                 }), _cancellationTokenSource.Token, callback: callback);
             }
 
-            Thread.Sleep(TimeSpan.FromSeconds(25));
+            Thread.Sleep(TimeSpan.FromSeconds(60));
 
             Log.Trace("Unsubscribing symbols");
             foreach (var config in configs)
@@ -104,20 +155,40 @@ public void CanSubscribeAndUnsubscribeOnSecondResolution(string ticker, Security
 
             _cancellationTokenSource.Cancel();
 
-            Log.Trace($"{nameof(ThetaDataProviderTests)}.{nameof(CanSubscribeAndUnsubscribeOnSecondResolution)}: ***** Summary *****");
-            Log.Trace($"Input parameters: ticker:{ticker} | securityType:{securityType} | resolution:{resolution}");
+            var str = new StringBuilder();
 
-            foreach (var data in dataFromEnumerator)
+            str.AppendLine($"{nameof(ThetaDataProviderTests)}.{nameof(CanSubscribeAndUnsubscribeOnSecondResolution)}: ***** Summary *****");
+
+            foreach (var symbol in symbols)
             {
-                Log.Trace($"[{data.Key}] = {data.Value}");
+                str.AppendLine($"Input parameters: ticker:{symbol} | securityType:{symbol.SecurityType} | resolution:{resolution}");
+
+                foreach (var tickType in dataFromEnumerator[symbol])
+                {
+                    str.AppendLine($"[{tickType.Key}] = {tickType.Value}");
+
+                    if (symbol.SecurityType != SecurityType.Index)
+                    {
+                        Assert.Greater(tickType.Value, 0);
+                    }
+                    // The ThetaData returns TradeBar seldom. Perhaps should find more relevant ticker.
+                    Assert.GreaterOrEqual(tickType.Value, 0);
+                }
+                str.AppendLine(new string('-', 30));
             }
 
-            if (securityType != SecurityType.Index)
+            Log.Trace(str.ToString());
+        }
+
+        private static string DisplayBaseData(BaseData item)
+        {
+            switch (item)
             {
-                Assert.Greater(dataFromEnumerator[typeof(QuoteBar)], 0);
+                case TradeBar tradeBar:
+                    return $"Data Type: {item.DataType} | " + tradeBar.ToString() + $" Time: {tradeBar.Time}, EndTime: {tradeBar.EndTime}";
+                default:
+                    return $"DEFAULT: Data Type: {item.DataType} | Time: {item.Time} | End Time: {item.EndTime} | Symbol: {item.Symbol} | Price: {item.Price} | IsFillForward: {item.IsFillForward}";
             }
-            // The ThetaData returns TradeBar seldom. Perhaps should find more relevant ticker.
-            Assert.GreaterOrEqual(dataFromEnumerator[typeof(TradeBar)], 0);
         }
 
         [TestCase("AAPL", SecurityType.Equity)]
@@ -152,7 +223,7 @@ public void MultipleSubscriptionOnOptionContractsTickResolution(string ticker, S
                         case TickType.Quote:
                             incomingSymbolDataByTickType[(tick.Symbol, tick.TickType)] += 1;
                             break;
-                    };
+                    }
                 }
             };
 
diff --git a/QuantConnect.ThetaData/ThetaDataProvider.cs b/QuantConnect.ThetaData/ThetaDataProvider.cs
