def setUp(self):
super().setUp()
self.no_args = node.Node()
self.no_props = node.Node(node_id=1, alias="alias", label="l")
self.props_only = node.Node(properties={"a": "a", "b": 10})
self.no_label = node.Node(node_id=1,
alias="alias",
properties={"a": "a"})
def test_comparision(self):
node1 = node.Node(node_id=1)
node2 = node.Node(node_id=2)
node3 = node.Node(node_id=3)
edge1 = edge.Edge(node1, None, node2)
self.assertEqual(edge1, edge.Edge(node1, None, node2))
self.assertNotEqual(edge1, edge.Edge(node1, "bla", node2))
self.assertNotEqual(edge1, edge.Edge(node1, None, node3))
self.assertNotEqual(edge1, edge.Edge(node3, None, node2))
self.assertNotEqual(edge1, edge.Edge(node2, None, node1))
self.assertNotEqual(
edge1, edge.Edge(node1, None, node2, properties={"a": 10}))
def test_init(self):
with self.assertRaises(AssertionError):
edge.Edge(None, None, None)
with self.assertRaises(AssertionError):
edge.Edge(node.Node(), None, None)
with self.assertRaises(AssertionError):
edge.Edge(None, None, node.Node())
self.assertIsInstance(
edge.Edge(node.Node(node_id=1), None, node.Node(node_id=2)),
edge.Edge)
def test_toString(self):
props_result = edge.Edge(node.Node(),
None,
node.Node(),
properties={
"a": "a",
"b": 10
}).toString()
self.assertEqual(props_result, '{a:"a",b:10}')
no_props_result = edge.Edge(node.Node(),
None,
node.Node(),
properties={}).toString()
self.assertEqual(no_props_result, '')
def test_compare(self):
node_1 = node.Node(node_id=1)
node_2 = node.Node(node_id=2)
edge_1 = edge.Edge(node_1, None, node_2)
self.assertEqual(path.Path.new_empty_path(),
path.Path.new_empty_path())
self.assertEqual(path.Path(nodes=[node_1, node_2], edges=[edge_1]),
path.Path(nodes=[node_1, node_2], edges=[edge_1]))
self.assertNotEqual(path.Path(nodes=[node_1], edges=[]),
path.Path(nodes=[], edges=[]))
self.assertNotEqual(path.Path(nodes=[node_1], edges=[]),
path.Path(nodes=[], edges=[]))
self.assertNotEqual(path.Path(nodes=[node_1], edges=[]),
path.Path(nodes=[node_2], edges=[]))
self.assertNotEqual(path.Path(nodes=[node_1], edges=[edge_1]),
path.Path(nodes=[node_1], edges=[]))
self.assertNotEqual(path.Path(nodes=[node_1], edges=[edge_1]),
path.Path(nodes=[node_2], edges=[edge_1]))
def test_wrong_flows(self):
node_1 = node.Node(node_id=1)
node_2 = node.Node(node_id=2)
node_3 = node.Node(node_id=3)
edge_1 = edge.Edge(node_1, None, node_2)
edge_2 = edge.Edge(node_1, None, node_3)
p = path.Path.new_empty_path()
with self.assertRaises(AssertionError):
p.add_edge(edge_1)
p.add_node(node_1)
with self.assertRaises(AssertionError):
p.add_node(node_2)
p.add_edge(edge_1)
with self.assertRaises(AssertionError):
p.add_edge(edge_2)
def test_nodes_and_edges(self):
node_1 = node.Node(node_id=1)
node_2 = node.Node(node_id=2)
edge_1 = edge.Edge(node_1, None, node_2)
p = path.Path.new_empty_path()
self.assertEqual(p.nodes(), [])
p.add_node(node_1)
self.assertEqual([], p.edges())
self.assertEqual(0, p.edge_count())
self.assertEqual([node_1], p.nodes())
self.assertEqual(node_1, p.get_node(0))
self.assertEqual(node_1, p.first_node())
self.assertEqual(node_1, p.last_node())
self.assertEqual(1, p.nodes_count())
p.add_edge(edge_1)
self.assertEqual([edge_1], p.edges())
self.assertEqual(1, p.edge_count())
self.assertEqual(edge_1, p.get_relationship(0))
p.add_node(node_2)
self.assertEqual([node_1, node_2], p.nodes())
self.assertEqual(node_1, p.first_node())
self.assertEqual(node_2, p.last_node())
self.assertEqual(2, p.nodes_count())
def test_stringify(self):
john = node.Node(alias='a',
label='person',
properties={
'name': 'John Doe',
'age': 33,
'someArray': [1, 2, 3]
})
japan = node.Node(alias='b',
label='country',
properties={'name': 'Japan'})
edge_with_relation = edge.Edge(john,
'visited',
japan,
properties={'purpose': 'pleasure'})
self.assertEqual(
'(a:person{age:33,name:"John Doe",someArray:[1, 2, 3]})'
'-[:visited{purpose:"pleasure"}]->'
'(b:country{name:"Japan"})', str(edge_with_relation))
edge_no_relation_no_props = edge.Edge(japan, '', john)
self.assertEqual(
'(b:country{name:"Japan"})'
'-[]->'
'(a:person{age:33,name:"John Doe",someArray:[1, 2, 3]})',
str(edge_no_relation_no_props))
edge_only_props = edge.Edge(john,
'',
japan,
properties={
'a': 'b',
'c': 3
})
self.assertEqual(
'(a:person{age:33,name:"John Doe",someArray:[1, 2, 3]})'
'-[{a:"b",c:3}]->'
'(b:country{name:"Japan"})', str(edge_only_props))
def test_comparision(self):
self.assertEqual(node.Node(), node.Node())
self.assertEqual(node.Node(node_id=1), node.Node(node_id=1))
self.assertNotEqual(node.Node(node_id=1), node.Node(node_id=2))
self.assertEqual(node.Node(node_id=1, alias="a"),
node.Node(node_id=1, alias="b"))
self.assertEqual(node.Node(node_id=1, alias="a"),
node.Node(node_id=1, alias="a"))
self.assertEqual(node.Node(node_id=1, label="a"),
node.Node(node_id=1, label="a"))
self.assertNotEqual(node.Node(node_id=1, label="a"),
node.Node(node_id=1, label="b"))
self.assertEqual(node.Node(node_id=1, alias="a", label="l"),
node.Node(node_id=1, alias="a", label="l"))
self.assertNotEqual(node.Node(alias="a", label="l"),
node.Node(alias="a", label="l1"))
self.assertEqual(node.Node(properties={"a": 10}),
node.Node(properties={"a": 10}))
self.assertNotEqual(node.Node(), node.Node(properties={"a": 10}))