def setUp(self):
self.label = 'test'
self.schema = {
'test1': {'type': 'integer'},
'test2': {'type': 'string'},
}
self.data = (fake_node() for _ in range(20))
graph = Mock()
graph.find = Mock(
side_effect=lambda label, limit: (fake_node() for _ in range(limit is None and 4 or min(4, limit))))
graph.node = Mock(side_effect=lambda i: fake_node())
graph.pull = Mock()
graph.push = Mock()
graph.create = Mock(side_effect=lambda *e: (fake_node() for _ in range(len(e))))
graph.delete = Mock(side_effect=lambda *e: e)
self.r = GraphEntityRepository(self.label, self.schema)
self.r._g = graph
class GraphEntityRepositoryTest(TestCase):
def setUp(self):
self.label = 'test'
self.schema = {
'test1': {'type': 'integer'},
'test2': {'type': 'string'},
}
self.data = (fake_node() for _ in range(20))
graph = Mock()
graph.find = Mock(
side_effect=lambda label, limit: (fake_node() for _ in range(limit is None and 4 or min(4, limit))))
graph.node = Mock(side_effect=lambda i: fake_node())
graph.pull = Mock()
graph.push = Mock()
graph.create = Mock(side_effect=lambda *e: (fake_node() for _ in range(len(e))))
graph.delete = Mock(side_effect=lambda *e: e)
self.r = GraphEntityRepository(self.label, self.schema)
self.r._g = graph
@parameterized.expand([
(0, None, 4),
(2, None, 2),
(2, 2, 2),
(0, 10, 4),
(2, 10, 2),
])
def test_all(self, skip, limit, expected_length):
actual = self.r.all(skip, limit)
self.r._g.find.assert_called_once_with(self.label, limit=limit and skip + limit or None)
actual = list(actual)
self.assertEqual(len(actual), expected_length)
def test_find(self):
identities = [1, 2, 3]
actual = self.r.find(identities)
self.assertEqual(self.r._g.node.call_count, len(identities))
self.assertTrue(self.r._g.pull.called)
self.assertEqual(len(actual), len(identities))
def test_find_nonexistent_nodes(self):
identities = [1, 2, 3]
self.r._g.pull = Mock(side_effect=py2neo.GraphError)
with self.assertRaises(errors.NotFoundError):
self.r.find(identities)
@parameterized.expand([
(0, None, 4),
(0, 2, 2),
(2, 2, 2),
(0, 10, 4),
(2, 10, 2),
])
def test_where(self, skip, limit, expected_length):
self.r._g.find = Mock(
side_effect=lambda p, q, r, limit=None: (fake_node() for _ in range(limit is None and 4 or min(limit, 4))))
actual = self.r.where(test1=10, skip=skip, limit=limit)
self.assertIsInstance(actual, list)
self.assertEqual(len(actual), expected_length)
def test_where_identity(self):
actual = self.r.where(_id=10)
self.assertIsInstance(actual, list)
self.assertEqual(len(actual), 1)
def test_where_raises_error_with_multiple_keys(self):
with self.assertRaises(ValueError):
self.r.where(test1=10, test2='test')
def test_create(self):
data = [fake_node().properties]
actual = self.r.create(data)
self.assertTrue(self.r._g.create.called)
self.assertIsInstance(actual, list)
self.assertEqual(len(actual), 1)
def test_update(self):
n = fake_node()
data = [n.properties]
data[0]['_id'] = n._id
actual = self.r.update(data)
self.assertTrue(self.r._g.push.called)
self.assertIsInstance(actual, list)
self.assertEqual(len(actual), 1)
def test_delete(self):
entities = [{'_id': d._id} for d in self.data]
actual = self.r.delete(entities)
self.assertTrue(self.r._g.delete.called)
self.assertIsInstance(actual, list)
self.assertEqual(len(actual), len(entities))
