def test_size_of_thing_with_relationships(self):
class Thing:
def relationships(self):
return [1, 2, 3]
obj = Thing()
assert size(obj) == 3
def test_graph_union(self):
graph_1 = (alice_knows_bob | alice_likes_carol | carol_dislikes_bob)
graph_2 = (carol_dislikes_bob | carol_married_to_dave
| dave_works_for_dave)
graph = graph_1 | graph_2
assert order(graph) == 4
assert size(graph) == 5
assert graph.nodes() == (alice | bob | carol | dave).nodes()
def test_graph_intersection(self):
graph_1 = (alice_knows_bob | alice_likes_carol | carol_dislikes_bob)
graph_2 = (carol_dislikes_bob | carol_married_to_dave
| dave_works_for_dave)
graph = graph_1 & graph_2
assert order(graph) == 2
assert size(graph) == 1
assert graph.nodes() == (bob | carol).nodes()
def test_graph_difference(self):
graph_1 = (alice_knows_bob | alice_likes_carol | carol_dislikes_bob)
graph_2 = (carol_dislikes_bob | carol_married_to_dave
| dave_works_for_dave)
graph = graph_1 - graph_2
assert order(graph) == 3
assert size(graph) == 2
assert graph.nodes() == (alice | bob | carol).nodes()
def test_record_can_be_converted_to_subgraph(self):
keys = ["a", "b", "ab", "msg"]
values = [alice, bob, alice_knows_bob, "hello, world"]
record = Record(keys, values)
subgraph = record.subgraph()
assert order(subgraph) == 2
assert size(subgraph) == 1
assert subgraph.nodes() == {alice, bob}
assert subgraph.relationships() == {alice_knows_bob}
def test_loop(self):
assert dave_works_for_dave.start_node() == dave
assert dave_works_for_dave.end_node() == dave
assert list(
walk(dave_works_for_dave)) == [dave, dave_works_for_dave, dave]
assert order(dave_works_for_dave) == 1
assert size(dave_works_for_dave) == 1
assert set(dave_works_for_dave.nodes()) == {dave}
assert set(
dave_works_for_dave.relationships()) == {dave_works_for_dave}
def test_relationship(self):
assert alice_knows_bob.start_node() == alice
assert alice_knows_bob.end_node() == bob
assert list(walk(alice_knows_bob)) == [alice, alice_knows_bob, bob]
assert alice_knows_bob.type() == "KNOWS"
assert dict(alice_knows_bob) == {"since": 1999}
assert alice_knows_bob["since"] == 1999
assert order(alice_knows_bob) == 2
assert size(alice_knows_bob) == 1
assert set(alice_knows_bob.nodes()) == {alice, bob}
assert set(alice_knows_bob.relationships()) == {alice_knows_bob}
def test_construction_of_path_length_0(self):
sequence = [alice]
path = Path(*sequence)
assert order(path) == 1
assert size(path) == 0
assert len(path) == 0
assert set(path.nodes()) == {alice}
assert set(path.relationships()) == set()
assert path.start_node() == alice
assert path.end_node() == alice
assert len(path) == 0
assert list(walk(path)) == sequence
def test_construction_of_path_length_1(self):
sequence = [alice, alice_knows_bob, bob]
path = Path(*sequence)
assert order(path) == 2
assert size(path) == 1
assert len(path) == 1
assert set(path.nodes()) == {alice, bob}
assert set(path.relationships()) == {alice_knows_bob}
assert path.start_node() == alice
assert path.end_node() == bob
assert len(path) == 1
assert list(walk(path)) == sequence
def test_graph_symmetric_difference(self):
graph_1 = (alice_knows_bob | alice_likes_carol | carol_dislikes_bob)
graph_2 = (carol_dislikes_bob | carol_married_to_dave
| dave_works_for_dave)
graph = graph_1 ^ graph_2
assert order(graph) == 4
assert size(graph) == 4
assert graph.nodes() == (alice | bob | carol | dave).nodes()
assert graph.relationships() == frozenset(alice_knows_bob
| alice_likes_carol
| carol_married_to_dave
| dave_works_for_dave)
def test_node(self):
assert alice.start_node() == alice
assert alice.end_node() == alice
assert alice.__bool__()
assert alice.__nonzero__()
assert len(alice) == 2
assert list(walk(alice)) == [alice]
assert set(alice.labels()) == {"Person", "Employee"}
assert dict(alice) == {"name": "Alice", "age": 33}
assert dict(alice)["name"] == "Alice"
assert alice["name"] == "Alice"
assert order(alice) == 1
assert size(alice) == 0
assert set(alice.nodes()) == {alice}
assert set(alice.relationships()) == set()
def test_construction_of_path_with_loop(self):
sequence = [
carol, carol_married_to_dave, dave, dave_works_for_dave, dave
]
path = Path(*sequence)
assert order(path) == 2
assert size(path) == 2
assert len(path) == 2
assert set(path.nodes()) == {carol, dave}
assert set(path.relationships()) == {
carol_married_to_dave, dave_works_for_dave
}
assert path.start_node() == carol
assert path.end_node() == dave
assert len(path) == 2
assert list(walk(path)) == sequence
def test_construction_of_path_with_revisits(self):
sequence = [
alice, alice_knows_bob, bob, carol_dislikes_bob, carol,
alice_likes_carol, alice, alice_knows_bob, bob
]
path = Path(*sequence)
assert order(path) == 3
assert size(path) == 3
assert len(path) == 4
assert set(path.nodes()) == {alice, bob, carol}
assert set(path.relationships()) == {
alice_knows_bob, alice_likes_carol, carol_dislikes_bob
}
assert path.start_node() == alice
assert path.end_node() == bob
assert len(path) == 4
assert list(walk(path)) == sequence
def test_can_create_nodes_and_relationship(self):
self.graph.delete_all()
a = Node()
b = Node()
c = Node()
ab = Relationship(a, "TO", b)
bc = Relationship(b, "TO", c)
ca = Relationship(c, "TO", a)
self.graph.create(ab | bc | ca)
assert remote(a)
assert remote(b)
assert remote(c)
assert remote(ab)
assert ab.start_node() == a
assert ab.end_node() == b
assert remote(bc)
assert bc.start_node() == b
assert bc.end_node() == c
assert remote(ca)
assert ca.start_node() == c
assert ca.end_node() == a
assert order(self.graph) == 3
assert size(self.graph) == 3
def test_size_of_non_graphy_thing(self):
with self.assertRaises(TypeError):
_ = size("this string is not graphy")
def test_can_infer_nodes_through_relationships(self):
subgraph = Subgraph([], [alice_knows_bob])
assert order(subgraph) == 2
assert size(subgraph) == 1
assert subgraph.nodes() == {alice, bob}
assert subgraph.relationships() == {alice_knows_bob}
def test_size(self):
assert size(self.walkable) == 2
def test_size(self):
assert size(alice) == 0
def test_size(self):
assert size(self.subgraph) == 5
def test_size(self):
assert size(self.path) == 2
def test_size(self):
assert size(self.loop) == 1
def test_size(self):
assert size(alice_knows_bob) == 1