Tests for Multimap

amazon/ion/core.py

@@ -490,39 +490,39 @@ class Multimap(MutableMapping):
 
     def __init__(self, *args, **kwargs):
         super(Multimap, self).__init__()
-        self.store = {}
+        self.__store = {}
         if args is not None and len(args) > 0:
             for key, value in six.iteritems(args[0]):
-                self.store[key] = MultimapValue(value)
+                self.__store[key] = MultimapValue(value)
 
     def __getitem__(self, key):
-        return self.store[key][len(self.store[key]) - 1]  # Return only one in order not to break clients
+        return self.__store[key][len(self.__store[key]) - 1]  # Return only one in order not to break clients
 
     def __delitem__(self, key):
-        del self.store[key]
+        del self.__store[key]
 
     def __setitem__(self, key, value):
-        self.store[key] = MultimapValue(value)
+        self.__store[key] = MultimapValue(value)
 
     def __len__(self):
-        return sum([len(values) for values in six.itervalues(self.store)])
+        return sum([len(values) for values in six.itervalues(self.__store)])
 
     def __iter__(self):
-        for key in six.iterkeys(self.store):
+        for key in six.iterkeys(self.__store):
             yield key
 
     def add_item(self, key, value):
-        if key in self.store:
-            self.store[key].append(value)
+        if key in self.__store:
+            self.__store[key].append(value)
         else:
             self.__setitem__(key, value)
 
     def get_all_values(self, key):
-        return self.store[key]
+        return self.__store[key]
 
     def iteritems(self):
-        for key in self.store:
-            for value in self.store[key]:
+        for key in self.__store:
+            for value in self.__store[key]:
                 yield (key, value)
 
     def items(self):
@@ -536,25 +536,25 @@ class MultimapValue(MutableSequence):
 
     def __init__(self, *args):
         if args is not None:
-            self.store = [x for x in args]
+            self.__store = [x for x in args]
         else:
-            self.store = []
+            self.__store = []
 
     def insert(self, index, value):
         self.__setitem__(index, value)
 
     def __len__(self):
-        return len(self.store)
+        return len(self.__store)
 
     def __getitem__(self, index):
-        return self.store[index]
+        return self.__store[index]
 
     def __setitem__(self, index, value):
-        self.store.insert(index, value)
+        self.__store.insert(index, value)
 
     def __delitem__(self, index):
-        del self.store[index]
+        del self.__store[index]
 
     def __iter__(self):
-        for x in self.store:
+        for x in self.__store:
             yield x

tests/test_core_multimap.py

@@ -0,0 +1,63 @@
+from amazon.ion.core import Multimap, record
+import six
+
+from tests import parametrize
+
+
+class _P(record('pairs', 'expected_all_values', 'expected_single_value', 'expected_total_len')):
+    def __str__(self):
+        return self.desc
+
+
+ALL_DATA = _P(
+    pairs=[('a', 1), ('a', 2), ('a', 3), ('a', [4, 5, 6]), ('b', 0), ('c', {'x': 'z', 'r': 's'})],
+    expected_all_values=[('a', [1, 2, 3, [4, 5, 6]]), ('b', [0]), ('c', [{'x': 'z', 'r': 's'}])],
+    expected_single_value=[('a', [4, 5, 6]), ('b', 0), ('c', {'x': 'z', 'r': 's'})],
+    expected_total_len=6
+)
+
+
+def _create_multimap_with_items(pairs):
+    m = Multimap()
+    for pair in pairs:
+        m.add_item(pair[0], pair[1])
+    return m
+
+
+@parametrize(
+    ALL_DATA
+)
+def test_add_item(p):
+    m = _create_multimap_with_items(p.pairs)
+    for expected in p.expected_all_values:
+        assert list([x for x in m.get_all_values(expected[0])]) == expected[1]
+    for expected in p.expected_single_value:
+        assert m[expected[0]] == expected[1]
+    assert p.expected_total_len == len(m)
+
+
+@parametrize(
+    (ALL_DATA, ["a"], 2),
+    (ALL_DATA, ["b"], 5),
+    (ALL_DATA, ["c"], 5),
+    (ALL_DATA, ["a", "b"], 1),
+    (ALL_DATA, ["a", "b", "c"], 0)
+)
+def test_delete_item(item):
+    m = _create_multimap_with_items(item[0].pairs)
+    p, items_to_remove, len_after_removal = item
+    for to_remove in items_to_remove:
+        del m[to_remove]
+    assert len(m) == item[2]
+
+
+@parametrize(
+    {},
+    {"a": 1},
+    {"a": 1, "b": 2, "c": [1, 2, {3: 4}]}
+)
+def test_constructor(d):
+    m = Multimap(d)
+    for k, v in six.iteritems(d):
+        assert m[k] == v
+    assert len(m) == len(d)