Fx bug in BoundedList for Python 3.4 and add tests (#199)

* fix bug in BoundedList for python 3.4 and add tests

collections.deque.copy() was introduced in python 3.5, this commit changes
that by the deque constructor and adds some tests to BoundedList and BoundedDict
to avoid similar problems in the future.

Also, improve docstrings of BoundedList and BoundedDict classes

opentelemetry-sdk/src/opentelemetry/sdk/util.py

@@ -42,7 +42,11 @@ def ns_to_iso_str(nanoseconds):
 
 
 class BoundedList(Sequence):
-    """An append only list with a fixed max size."""
+    """An append only list with a fixed max size.
+
+    Calls to `append` and `extend` will drop the oldest elements if there is
+    not enough room.
+    """
 
     def __init__(self, maxlen):
         self.dropped = 0
@@ -62,7 +66,7 @@ def __len__(self):
 
     def __iter__(self):
         with self._lock:
-            return iter(self._dq.copy())
+            return iter(deque(self._dq))
 
     def append(self, item):
         with self._lock:
@@ -89,7 +93,11 @@ def from_seq(cls, maxlen, seq):
 
 
 class BoundedDict(MutableMapping):
-    """A dict with a fixed max capacity."""
+    """An ordered dict with a fixed max capacity.
+
+    Oldest elements are dropped when the dict is full and a new element is
+    added.
+    """
 
     def __init__(self, maxlen):
         if not isinstance(maxlen, int):

opentelemetry-sdk/tests/test_util.py

@@ -0,0 +1,213 @@
+# Copyright 2019, OpenTelemetry Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import collections
+import unittest
+
+from opentelemetry.sdk.util import BoundedDict, BoundedList
+
+
+class TestBoundedList(unittest.TestCase):
+    base = [52, 36, 53, 29, 54, 99, 56, 48, 22, 35, 21, 65, 10, 95, 42, 60]
+
+    def test_raises(self):
+        """Test corner cases
+
+        - negative list size
+        - access out of range indexes
+        """
+        with self.assertRaises(ValueError):
+            BoundedList(-1)
+
+        blist = BoundedList(4)
+        blist.append(37)
+        blist.append(13)
+
+        with self.assertRaises(IndexError):
+            _ = blist[2]
+
+        with self.assertRaises(IndexError):
+            _ = blist[4]
+
+        with self.assertRaises(IndexError):
+            _ = blist[-3]
+
+    def test_from_seq(self):
+        list_len = len(self.base)
+        base_copy = list(self.base)
+        blist = BoundedList.from_seq(list_len, base_copy)
+
+        self.assertEqual(len(blist), list_len)
+
+        # modify base_copy and test that blist is not changed
+        for idx in range(list_len):
+            base_copy[idx] = idx * base_copy[idx]
+
+        for idx in range(list_len):
+            self.assertEqual(blist[idx], self.base[idx])
+
+        # test that iter yields the correct number of elements
+        self.assertEqual(len(tuple(blist)), list_len)
+
+        # sequence too big
+        with self.assertRaises(ValueError):
+            BoundedList.from_seq(list_len / 2, self.base)
+
+    def test_append_no_drop(self):
+        """Append max capacity elements to the list without dropping elements."""
+        # create empty list
+        list_len = len(self.base)
+        blist = BoundedList(list_len)
+        self.assertEqual(len(blist), 0)
+
+        # fill list
+        for item in self.base:
+            blist.append(item)
+
+        self.assertEqual(len(blist), list_len)
+        self.assertEqual(blist.dropped, 0)
+
+        for idx in range(list_len):
+            self.assertEqual(blist[idx], self.base[idx])
+
+        # test __iter__ in BoundedList
+        for idx, val in enumerate(blist):
+            self.assertEqual(val, self.base[idx])
+
+    def test_append_drop(self):
+        """Append more than max capacity elements and test that oldest ones are dropped."""
+        list_len = len(self.base)
+        # create full BoundedList
+        blist = BoundedList.from_seq(list_len, self.base)
+
+        # try to append more items
+        for val in self.base:
+            # should drop the element without raising exceptions
+            blist.append(2 * val)
+
+        self.assertEqual(len(blist), list_len)
+        self.assertEqual(blist.dropped, list_len)
+
+        # test that new elements are in the list
+        for idx in range(list_len):
+            self.assertEqual(blist[idx], 2 * self.base[idx])
+
+    def test_extend_no_drop(self):
+        # create empty list
+        list_len = len(self.base)
+        blist = BoundedList(list_len)
+        self.assertEqual(len(blist), 0)
+
+        # fill list
+        blist.extend(self.base)
+
+        self.assertEqual(len(blist), list_len)
+        self.assertEqual(blist.dropped, 0)
+
+        for idx in range(list_len):
+            self.assertEqual(blist[idx], self.base[idx])
+
+        # test __iter__ in BoundedList
+        for idx, val in enumerate(blist):
+            self.assertEqual(val, self.base[idx])
+
+    def test_extend_drop(self):
+        list_len = len(self.base)
+        # create full BoundedList
+        blist = BoundedList.from_seq(list_len, self.base)
+        other_list = [13, 37, 51, 91]
+
+        # try to extend with more elements
+        blist.extend(other_list)
+
+        self.assertEqual(len(blist), list_len)
+        self.assertEqual(blist.dropped, len(other_list))
+
+
+class TestBoundedDict(unittest.TestCase):
+    base = collections.OrderedDict(
+        [
+            ("name", "Firulais"),
+            ("age", 7),
+            ("weight", 13),
+            ("vaccinated", True),
+        ]
+    )
+
+    def test_negative_maxlen(self):
+        with self.assertRaises(ValueError):
+            BoundedDict(-1)
+
+    def test_from_map(self):
+        dic_len = len(self.base)
+        base_copy = collections.OrderedDict(self.base)
+        bdict = BoundedDict.from_map(dic_len, base_copy)
+
+        self.assertEqual(len(bdict), dic_len)
+
+        # modify base_copy and test that bdict is not changed
+        base_copy["name"] = "Bruno"
+        base_copy["age"] = 3
+
+        for key in self.base:
+            self.assertEqual(bdict[key], self.base[key])
+
+        # test that iter yields the correct number of elements
+        self.assertEqual(len(tuple(bdict)), dic_len)
+
+        # map too big
+        with self.assertRaises(ValueError):
+            BoundedDict.from_map(dic_len / 2, self.base)
+
+    def test_bounded_dict(self):
+        # create empty dict
+        dic_len = len(self.base)
+        bdict = BoundedDict(dic_len)
+        self.assertEqual(len(bdict), 0)
+
+        # fill dict
+        for key in self.base:
+            bdict[key] = self.base[key]
+
+        self.assertEqual(len(bdict), dic_len)
+        self.assertEqual(bdict.dropped, 0)
+
+        for key in self.base:
+            self.assertEqual(bdict[key], self.base[key])
+
+        # test __iter__ in BoundedDict
+        for key in bdict:
+            self.assertEqual(bdict[key], self.base[key])
+
+        # updating an existing element should not drop
+        bdict["name"] = "Bruno"
+        self.assertEqual(bdict.dropped, 0)
+
+        # try to append more elements
+        for key in self.base:
+            bdict["new-" + key] = self.base[key]
+
+        self.assertEqual(len(bdict), dic_len)
+        self.assertEqual(bdict.dropped, dic_len)
+
+        # test that elements in the dict are the new ones
+        for key in self.base:
+            self.assertEqual(bdict["new-" + key], self.base[key])
+
+        # delete an element
+        del bdict["new-name"]
+        self.assertEqual(len(bdict), dic_len - 1)
+
+        with self.assertRaises(KeyError):
+            _ = bdict["new-name"]