def setUp(self):
self.new_key = 'six'
self.mapping = {
'one': {
'key': 1
},
'two': {
'key': 2,
'extra': True
},
'three': {
'key': 3,
'type': 'node'
},
'four': {
'key': 4,
'weight': 1.33
},
'five': {
'key': 5,
'weight': 3.11
}
}
self.storage_instance = DictStorage
self.storage = DictStorage(self.mapping)
def test_dictstorage_keysview_comparison(self):
"""
Test the DictStorage view based keys comparison methods
"""
keyview = self.storage.keys()
other = DictStorage({'two': 2, 'three': 3, 'four': 4, 'six': 6})
self.assertSetEqual(keyview & other.keys(), {'four', 'two', 'three'})
self.assertSetEqual(keyview | other.keys(), {'six', 'three', 'two', 'four', 'five', 'one'})
self.assertSetEqual(keyview - other.keys(), {'five', 'one'})
self.assertSetEqual(keyview ^ other.keys(), {'five', 'one', 'six'})
def setUp(self):
self.new_key = (5, 6)
self.mapping = {
(1, 2): {
'key': 1
},
(2, 1): {
'key': 2,
'extra': True
},
(3, 2): {
'key': 3,
'type': 'node'
},
(4, 5): {
'key': 4,
'weight': 1.33
},
(2, 5): {
'key': 5,
'weight': 3.11
}
}
self.storage_instance = DictStorage
self.storage = DictStorage(self.mapping)
def init_arraystorage_driver(nodes, edges, data):
"""
ArrayStorage specific driver initiation method
Returns a ArrayStorage instance for nodes and edges and a AdjacencyView
for adjacency based on the initiated nodes and edges stores.
:param nodes: Nodes to initiate nodes DictStorage instance
:type nodes: :py:list, :py:dict,
:graphit:graph_arraystorage_driver:DictStorage
:param edges: Edges to initiate edges DictStorage instance
:type edges: :py:list, :py:dict,
:graphit:graph_arraystorage_driver:DictStorage
:param data: graph data attributes to initiate data DictStorage instance
:type data: :py:list, :py:dict,
:graphit:graph_dictstorage_driver:DictStorage
:return: Nodes and edges storage instances and Adjacency view.
"""
node_storage = ArrayStorage(nodes)
edge_storage = ArrayStorage(edges)
data_storage = DictStorage(data)
adjacency_storage = AdjacencyView(node_storage, edge_storage)
return node_storage, edge_storage, adjacency_storage, data_storage
def test_dictstorage_valuesview_comparison(self):
"""
Test the DictStorage view based values comparison methods
"""
values = self.storage.values()
self.storage[self.new_key] = 6
other = DictStorage(dict([(k, v) for k, v in self.mapping.items() if k in ['two', 'three', 'four']]))
other[self.new_key] = 6
self.assertItemsEqual(values & other.values(), [6, {'key': 3, 'type': 'node'}, {'key': 4, 'weight': 1.33},
{'extra': True, 'key': 2}])
self.assertItemsEqual(values | other.values(), [6, {'key': 3, 'type': 'node'}, {'key': 1},
{'key': 4, 'weight': 1.33}, {'key': 5, 'weight': 3.11},
{'extra': True, 'key': 2}])
self.assertItemsEqual(values - other.values(), [{'key': 1}, {'key': 5, 'weight': 3.11}])
self.assertItemsEqual(values ^ other.values(), [{'key': 1}, {'key': 5, 'weight': 3.11}])
class TestDictStorageNodes(_BaseStorageDriverTests, UnittestPythonCompatibility):
"""
Unit tests for DictStorage class storing nodes
"""
def setUp(self):
self.new_key = 'six'
self.mapping = {'one': {'key': 1},
'two': {'key': 2, 'extra': True},
'three': {'key': 3, 'type': 'node'},
'four': {'key': 4, 'weight': 1.33},
'five': {'key': 5, 'weight': 3.11}}
self.storage_instance = DictStorage
self.storage = DictStorage(self.mapping)
def test_dictstorage_view_magicmethods(self):
"""
Test dictionary magic methods for a default dictionary
and for on with a selective view on the main dict.
"""
# Selective view
self.storage.set_view(['one', 'three'])
self.assertEqual(len(self.storage), 2)
self.assertTrue('one' in self.storage)
self.assertFalse('five' in self.storage)
if MAJOR_PY_VERSION == 2:
self.assertEqual(str(self.storage), "[u'one', u'three']")
else:
self.assertEqual(str(self.storage), "['one', 'three']")
self.assertEqual(repr(self.storage), '<DictStorage object {0}: 2 items>'.format(id(self.storage)))
def test_dictstorage_keysview_comparison(self):
"""
Test the DictStorage view based keys comparison methods
"""
keyview = self.storage.keys()
other = DictStorage({'two': 2, 'three': 3, 'four': 4, 'six': 6})
self.assertSetEqual(keyview & other.keys(), {'four', 'two', 'three'})
self.assertSetEqual(keyview | other.keys(), {'six', 'three', 'two', 'four', 'five', 'one'})
self.assertSetEqual(keyview - other.keys(), {'five', 'one'})
self.assertSetEqual(keyview ^ other.keys(), {'five', 'one', 'six'})
def test_dictstorage_valuesview_comparison(self):
"""
Test the DictStorage view based values comparison methods
"""
values = self.storage.values()
self.storage[self.new_key] = 6
other = DictStorage(dict([(k, v) for k, v in self.mapping.items() if k in ['two', 'three', 'four']]))
other[self.new_key] = 6
self.assertItemsEqual(values & other.values(), [6, {'key': 3, 'type': 'node'}, {'key': 4, 'weight': 1.33},
{'extra': True, 'key': 2}])
self.assertItemsEqual(values | other.values(), [6, {'key': 3, 'type': 'node'}, {'key': 1},
{'key': 4, 'weight': 1.33}, {'key': 5, 'weight': 3.11},
{'extra': True, 'key': 2}])
self.assertItemsEqual(values - other.values(), [{'key': 1}, {'key': 5, 'weight': 3.11}])
self.assertItemsEqual(values ^ other.values(), [{'key': 1}, {'key': 5, 'weight': 3.11}])
def test_dictstorage_valuesview_contain(self):
"""
Test valuesview __contain__
"""
values = self.storage.values()
key = random.choice(list(self.mapping.keys()))
self.assertTrue(self.mapping[key] in values)
def test_dictstorage_itemsview_contain(self, items=None):
"""
Test itemview __contain__
"""
items = self.storage.items()
key = random.choice(list(self.mapping.keys()))
self.assertTrue((key, self.mapping[key]) in items)
def test_dictstorage_itemsview(self):
"""
Test Python dict items method. This should be the python 3.x compatible
items view object.
"""
items = self.storage.items()
# Adding a new item should be reflected in the Values View
self.storage[self.new_key] = 6
self.mapping[self.new_key] = 6
self.assertTrue(len(items) == 6)
self.assertViewEqual(self.mapping.items(), items)
def test_dictstorage_keysview(self):
"""
Test Python dict keys method. This should be the python 3.x compatible
keys view object.
"""
keys = self.storage.keys()
# Adding a new item should be reflected in the Keys View
self.storage[self.new_key] = 6
self.mapping[self.new_key] = 6
self.assertTrue(len(keys) == 6)
self.assertViewEqual(self.mapping.keys(), keys)
def test_dictstorage_valuesview(self):
"""
Test Python dict values method. This should be the python 3.x compatible
values view object.
"""
values = self.storage.values()
# Adding a new item should be reflected in the Values View
self.storage[self.new_key] = 6
self.mapping[self.new_key] = 6
self.assertTrue(len(values) == 6)
self.assertViewEqual(self.mapping.values(), values)