Add unit tests

Author: jhonabreul

Common/Data/Market/DataDictionary.cs

@@ -146,7 +146,7 @@ public bool Remove(KeyValuePair<Symbol, T> item)
         /// <returns>
         /// The number of elements contained in the <see cref="T:System.Collections.Generic.ICollection`1"/>.
         /// </returns>
-        public int Count
+        public override int Count
         {
             get { return _data.Count; }
         }

Common/Data/Slice.cs

@@ -171,7 +171,7 @@ public MarginInterestRates MarginInterestRates
         /// <summary>
         /// Gets the number of symbols held in this slice
         /// </summary>
-        public virtual int Count
+        public override int Count
         {
             get { return _data.Value.Count; }
         }

Common/ExtendedDictionary.cs

@@ -31,6 +31,11 @@ namespace QuantConnect
     public abstract class ExtendedDictionary<TKey, TValue> : IExtendedDictionary<TKey, TValue>
 #pragma warning restore CA1708 // Identifiers should differ by more than case
     {
+        /// <summary>
+        /// Gets the number of elements contained in the dictionary
+        /// </summary>
+        public abstract int Count { get; }
+
         /// <summary>
         /// Removes all items from the <see cref="T:System.Collections.Generic.ICollection`1"/>.
         /// </summary>
@@ -55,6 +60,11 @@ public virtual void Clear()
         /// <exception cref="T:System.ArgumentNullException"><paramref name="key"/> is null.</exception>
         public abstract bool TryGetValue(TKey key, out TValue value);
 
+        /// <summary>
+        /// Checks if the dictionary contains the specified key.
+        /// </summary>
+        /// <param name="key">The key to locate in the dictionary</param>
+        /// <returns>true if the dictionary contains an element with the specified key; otherwise, false.</returns>
         public virtual bool ContainsKey(TKey key)
         {
             return TryGetValue(key, out _);

Common/Securities/Positions/SecurityPositionGroupModel.cs

@@ -42,7 +42,6 @@ public class SecurityPositionGroupModel : ExtendedDictionary<PositionGroupKey, I
         /// </summary>
         protected virtual IPositionGroupBuyingPowerModel PositionGroupBuyingPowerModel { get; } = new SecurityPositionGroupBuyingPowerModel();
 
-
         /// <summary>
         /// Gets the set of currently resolved position groups
         /// </summary>
@@ -64,6 +63,11 @@ private set
         /// </summary>
         public bool IsOnlyDefaultGroups => Groups.IsOnlyDefaultGroups;
 
+        /// <summary>
+        /// Gets the number of position groups in this collection
+        /// </summary>
+        public override int Count => Groups.Count;
+
         /// <summary>
         /// Gets all the available position group keys
         /// </summary>

Common/Securities/SecurityManager.cs

@@ -171,7 +171,7 @@ public void CopyTo(KeyValuePair<Symbol, Security>[] array, int number)
         /// Count of the number of securities in the collection.
         /// </summary>
         /// <remarks>IDictionary implementation</remarks>
-        public int Count
+        public override int Count
         {
             get
             {

Common/Securities/SecurityPortfolioManager.cs

@@ -189,7 +189,7 @@ public bool Contains(KeyValuePair<Symbol, SecurityHolding> pair)
         /// Count the securities objects in the portfolio.
         /// </summary>
         /// <remarks>IDictionary implementation calling the underlying Securities collection</remarks>
-        public int Count
+        public override int Count
         {
             get
             {

Tests/Common/ExtendedDictionaryTests.cs

@@ -14,8 +14,10 @@
 */
 
 using NUnit.Framework;
+using Python.Runtime;
 using QuantConnect.Statistics;
 using System.Collections.Generic;
+using System.Linq;
 
 namespace QuantConnect.Tests.Common
 {
@@ -58,5 +60,98 @@ public void RunPythonDictionaryFeatureRegressionAlgorithm()
                 parameter.ExpectedFinalStatus,
                 initialCash: 100000);
         }
+
+        [Test]
+        public void ExtendedDictionaryBehavesAsPythonDictionary()
+        {
+            using var _ = Py.GIL();
+
+            var module = PyModule.FromString("ExtendedDictionaryBehavesAsPythonDictionary",
+                    @"
+from QuantConnect.Tests.Common import ExtendedDictionaryTests
+
+def contains(dictionary, key):
+    return key in dictionary
+
+def get(dictionary, key):
+    return dictionary.get(key)
+
+def keys(dictionary):
+    return dictionary.keys()
+
+def values(dictionary):
+    return dictionary.values()
+
+def pop(dictionary, key):
+    return dictionary.pop(key)
+");
+
+            var dict = new TestDictionary
+            {
+                ["a"] = 1,
+                ["b"] = 2,
+                ["c"] = 3
+            };
+            using var pyDict = dict.ToPython();
+
+            var expectedKeys = new[] { "a", "b", "c" };
+            var keys = module.InvokeMethod("keys", pyDict).GetAndDispose<List<string>>();
+            CollectionAssert.AreEquivalent(expectedKeys, keys);
+
+            var expectedValues = new[] { 1, 2, 3 };
+            var values = module.InvokeMethod("values", pyDict).GetAndDispose<List<int>>();
+            CollectionAssert.AreEquivalent(expectedValues, values);
+
+            foreach (var (key, value) in keys.Zip(values))
+            {
+                using var pyKey = key.ToPython();
+                Assert.IsTrue(module.InvokeMethod("contains", pyDict, pyKey).As<bool>());
+                Assert.AreEqual(value, module.InvokeMethod("get", pyDict, pyKey).As<int>());
+            }
+
+            using var pyNonExistingKey = "d".ToPython();
+            Assert.IsFalse(module.InvokeMethod("contains", pyDict, pyNonExistingKey).As<bool>());
+            Assert.IsFalse(module.InvokeMethod("contains", pyDict, PyObject.None).As<bool>());
+
+            using var pyExistingKey = keys[0].ToPython();
+            using var pyExistingValue = values[0].ToPython();
+            var popped = module.InvokeMethod("pop", pyDict, pyExistingKey).As<int>();
+            Assert.AreEqual(1, popped);
+            Assert.IsFalse(module.InvokeMethod("contains", pyDict, pyExistingKey).As<bool>());
+        }
+
+        public class TestDictionary : ExtendedDictionary<string, int>
+        {
+            private readonly Dictionary<string, int> _data = new();
+
+            public override int Count => _data.Count;
+
+            public override bool IsReadOnly => false;
+
+            public override int this[string key]
+            {
+                get => _data[key];
+                set => _data[key] = value;
+            }
+
+            protected override IEnumerable<string> GetKeys => _data.Keys;
+
+            protected override IEnumerable<int> GetValues => _data.Values;
+
+            public override bool TryGetValue(string key, out int value)
+            {
+                return _data.TryGetValue(key, out value);
+            }
+
+            public override bool ContainsKey(string key)
+            {
+                return _data.ContainsKey(key);
+            }
+
+            public override bool Remove(string key)
+            {
+                return _data.Remove(key);
+            }
+        }
     }
 }