def test_can_hydrate_path(self):
g = Graph()
gh = Graph.Hydrator(g)
alice = gh.hydrate_node(1, {"Person"}, {"name": "Alice", "age": 33})
bob = gh.hydrate_node(2, {"Person"}, {"name": "Bob", "age": 44})
carol = gh.hydrate_node(3, {"Person"}, {"name": "Carol", "age": 55})
r = [
gh.hydrate_unbound_relationship(1, "KNOWS", {"since": 1999}),
gh.hydrate_unbound_relationship(2, "DISLIKES", {})
]
path = gh.hydrate_path([alice, bob, carol], r, [1, 1, -2, 2])
self.assertEqual(path.start_node, alice)
self.assertEqual(path.end_node, carol)
self.assertEqual(path.nodes, (alice, bob, carol))
expected_alice_knows_bob = gh.hydrate_relationship(
1, alice.id, bob.id, "KNOWS", {"since": 1999})
expected_carol_dislikes_bob = gh.hydrate_relationship(
2, carol.id, bob.id, "DISLIKES", {})
self.assertEqual(
path.relationships,
(expected_alice_knows_bob, expected_carol_dislikes_bob))
self.assertEqual(
list(path),
[expected_alice_knows_bob, expected_carol_dislikes_bob])
self.assertTrue(repr(path))
def test_node_repr():
g = Graph()
gh = Graph.Hydrator(g)
alice = gh.hydrate_node(1, {"Person"}, {"name": "Alice"})
assert repr(
alice
) == "<Node id=1 labels=frozenset({'Person'}) properties={'name': 'Alice'}>"
def test_relationship_repr():
g = Graph()
gh = Graph.Hydrator(g)
alice = gh.hydrate_node(1, {"Person"}, {"name": "Alice"})
bob = gh.hydrate_node(2, {"Person"}, {"name": "Bob"})
alice_knows_bob = gh.hydrate_relationship(1, alice.id, bob.id, "KNOWS",
{"since": 1999})
assert repr(
alice_knows_bob
) == "<Relationship id=1 nodes=(<Node id=1 labels=frozenset({'Person'}) properties={'name': 'Alice'}>, <Node id=2 labels=frozenset({'Person'}) properties={'name': 'Bob'}>) type='KNOWS' properties={'since': 1999}>"
def test_path_hashing(self):
g = Graph()
gh = Graph.Hydrator(g)
alice = gh.hydrate_node(1, {"Person"}, {"name": "Alice", "age": 33})
bob = gh.hydrate_node(2, {"Person"}, {"name": "Bob", "age": 44})
carol = gh.hydrate_node(3, {"Person"}, {"name": "Carol", "age": 55})
alice_knows_bob = gh.hydrate_relationship(1, alice.id, bob.id, "KNOWS",
{"since": 1999})
carol_dislikes_bob = gh.hydrate_relationship(2, carol.id, bob.id,
"DISLIKES", {})
path_1 = Path(alice, alice_knows_bob, carol_dislikes_bob)
path_2 = Path(alice, alice_knows_bob, carol_dislikes_bob)
self.assertEqual(hash(path_1), hash(path_2))
def test_path_repr():
g = Graph()
gh = Graph.Hydrator(g)
alice = gh.hydrate_node(1, {"Person"}, {"name": "Alice"})
bob = gh.hydrate_node(2, {"Person"}, {"name": "Bob"})
carol = gh.hydrate_node(3, {"Person"}, {"name": "Carol"})
alice_knows_bob = gh.hydrate_relationship(1, alice.id, bob.id, "KNOWS",
{"since": 1999})
carol_dislikes_bob = gh.hydrate_relationship(2, carol.id, bob.id,
"DISLIKES", {})
path = Path(alice, alice_knows_bob, carol_dislikes_bob)
assert repr(
path
) == "<Path start=<Node id=1 labels=frozenset({'Person'}) properties={'name': 'Alice'}> end=<Node id=3 labels=frozenset({'Person'}) properties={'name': 'Carol'}> size=2>"
def test_path_equality():
g = Graph()
gh = Graph.Hydrator(g)
alice = gh.hydrate_node(1, {"Person"}, {"name": "Alice", "age": 33})
bob = gh.hydrate_node(2, {"Person"}, {"name": "Bob", "age": 44})
carol = gh.hydrate_node(3, {"Person"}, {"name": "Carol", "age": 55})
alice_knows_bob = gh.hydrate_relationship(1, alice.id, bob.id, "KNOWS",
{"since": 1999})
carol_dislikes_bob = gh.hydrate_relationship(2, carol.id, bob.id,
"DISLIKES", {})
path_1 = Path(alice, alice_knows_bob, carol_dislikes_bob)
path_2 = Path(alice, alice_knows_bob, carol_dislikes_bob)
assert path_1 == path_2
assert path_1 != "this is not a path"
def test_can_create_relationship(self):
g = Graph()
gh = Graph.Hydrator(g)
alice = gh.hydrate_node(1, {"Person"}, {"name": "Alice", "age": 33})
bob = gh.hydrate_node(2, {"Person"}, {"name": "Bob", "age": 44})
alice_knows_bob = gh.hydrate_relationship(1, alice.id, bob.id, "KNOWS",
{"since": 1999})
self.assertEqual(alice_knows_bob.start_node, alice)
self.assertEqual(alice_knows_bob.type, "KNOWS")
self.assertEqual(alice_knows_bob.end_node, bob)
self.assertEqual(set(alice_knows_bob.keys()), {"since"})
self.assertEqual(set(alice_knows_bob.values()), {1999})
self.assertEqual(set(alice_knows_bob.items()), {("since", 1999)})
self.assertEqual(alice_knows_bob.get("since"), 1999)
self.assertTrue(repr(alice_knows_bob))
def test_null_properties(self):
g = Graph()
gh = Graph.Hydrator(g)
stuff = gh.hydrate_node(1, (), {
"good": ["puppies", "kittens"],
"bad": None
})
self.assertEqual(set(stuff.keys()), {"good"})
self.assertEqual(stuff.get("good"), ["puppies", "kittens"])
self.assertIsNone(stuff.get("bad"))
self.assertEqual(len(stuff), 1)
self.assertEqual(stuff["good"], ["puppies", "kittens"])
self.assertIsNone(stuff["bad"])
self.assertIn("good", stuff)
self.assertNotIn("bad", stuff)
def test_can_create_relationship():
g = Graph()
gh = Graph.Hydrator(g)
alice = gh.hydrate_node(1, {"Person"}, {"name": "Alice", "age": 33})
bob = gh.hydrate_node(2, {"Person"}, {"name": "Bob", "age": 44})
alice_knows_bob = gh.hydrate_relationship(1, alice.id, bob.id, "KNOWS",
{"since": 1999})
assert isinstance(alice_knows_bob, Relationship)
assert alice_knows_bob.start_node == alice
assert alice_knows_bob.type == "KNOWS"
assert alice_knows_bob.end_node == bob
assert set(alice_knows_bob.keys()) == {"since"}
assert set(alice_knows_bob.values()) == {1999}
assert set(alice_knows_bob.items()) == {("since", 1999)}
assert alice_knows_bob.get("since") == 1999
def test_null_properties():
g = Graph()
gh = Graph.Hydrator(g)
stuff = gh.hydrate_node(1, (), {
"good": ["puppies", "kittens"],
"bad": None
})
assert isinstance(stuff, Node)
assert set(stuff.keys()) == {"good"}
assert stuff.get("good") == ["puppies", "kittens"]
assert stuff.get("bad") is None
assert len(stuff) == 1
assert stuff["good"] == ["puppies", "kittens"]
assert stuff["bad"] is None
assert "good" in stuff
assert "bad" not in stuff
def test_can_create_node(self):
g = Graph()
gh = Graph.Hydrator(g)
alice = gh.hydrate_node(1, {"Person"}, {"name": "Alice", "age": 33})
self.assertEqual(alice.labels, {"Person"})
self.assertEqual(set(alice.keys()), {"name", "age"})
self.assertEqual(set(alice.values()), {"Alice", 33})
self.assertEqual(set(alice.items()), {("name", "Alice"), ("age", 33)})
self.assertEqual(alice.get("name"), "Alice")
self.assertEqual(alice.get("age"), 33)
self.assertTrue(repr(alice))
self.assertEqual(len(alice), 2)
self.assertEqual(alice["name"], "Alice")
self.assertEqual(alice["age"], 33)
self.assertIn("name", alice)
self.assertIn("age", alice)
self.assertEqual(set(iter(alice)), {"name", "age"})
def test_can_create_node():
g = Graph()
gh = Graph.Hydrator(g)
alice = gh.hydrate_node(1, {"Person"}, {"name": "Alice", "age": 33})
assert isinstance(alice, Node)
assert alice.labels == {"Person"}
assert set(alice.keys()) == {"name", "age"}
assert set(alice.values()) == {"Alice", 33}
assert set(alice.items()) == {("name", "Alice"), ("age", 33)}
assert alice.get("name") == "Alice"
assert alice.get("age") == 33
assert len(alice) == 2
assert alice["name"] == "Alice"
assert alice["age"] == 33
assert "name" in alice
assert "age" in alice
assert set(iter(alice)) == {"name", "age"}
def test_can_create_path():
g = Graph()
gh = Graph.Hydrator(g)
alice = gh.hydrate_node(1, {"Person"}, {"name": "Alice", "age": 33})
bob = gh.hydrate_node(2, {"Person"}, {"name": "Bob", "age": 44})
carol = gh.hydrate_node(3, {"Person"}, {"name": "Carol", "age": 55})
alice_knows_bob = gh.hydrate_relationship(1, alice.id, bob.id, "KNOWS",
{"since": 1999})
carol_dislikes_bob = gh.hydrate_relationship(2, carol.id, bob.id,
"DISLIKES", {})
path = Path(alice, alice_knows_bob, carol_dislikes_bob)
assert isinstance(path, Path)
assert path.start_node == alice
assert path.end_node == carol
assert path.nodes == (alice, bob, carol)
assert path.relationships == (alice_knows_bob, carol_dislikes_bob)
assert list(path) == [alice_knows_bob, carol_dislikes_bob]
def test_can_create_path(self):
g = Graph()
gh = Graph.Hydrator(g)
alice = gh.hydrate_node(1, {"Person"}, {"name": "Alice", "age": 33})
bob = gh.hydrate_node(2, {"Person"}, {"name": "Bob", "age": 44})
carol = gh.hydrate_node(3, {"Person"}, {"name": "Carol", "age": 55})
alice_knows_bob = gh.hydrate_relationship(1, alice.id, bob.id, "KNOWS",
{"since": 1999})
carol_dislikes_bob = gh.hydrate_relationship(2, carol.id, bob.id,
"DISLIKES", {})
path = Path(alice, alice_knows_bob, carol_dislikes_bob)
self.assertEqual(path.start_node, alice)
self.assertEqual(path.end_node, carol)
self.assertEqual(path.nodes, (alice, bob, carol))
self.assertEqual(path.relationships,
(alice_knows_bob, carol_dislikes_bob))
self.assertEqual(list(path), [alice_knows_bob, carol_dislikes_bob])
self.assertTrue(repr(path))
def __init__(self):
super(DataHydrator, self).__init__()
self.graph = Graph()
self.graph_hydrator = Graph.Hydrator(self.graph)
self.hydration_functions = {
b"N": self.graph_hydrator.hydrate_node,
b"R": self.graph_hydrator.hydrate_relationship,
b"r": self.graph_hydrator.hydrate_unbound_relationship,
b"P": self.graph_hydrator.hydrate_path,
b"X": hydrate_point,
b"Y": hydrate_point,
b"D": hydrate_date,
b"T": hydrate_time, # time zone offset
b"t": hydrate_time, # no time zone
b"F": hydrate_datetime, # time zone offset
b"f": hydrate_datetime, # time zone name
b"d": hydrate_datetime, # no time zone
b"E": hydrate_duration,
}
def test_can_hydrate_path():
g = Graph()
gh = Graph.Hydrator(g)
alice = gh.hydrate_node(1, {"Person"}, {"name": "Alice", "age": 33})
bob = gh.hydrate_node(2, {"Person"}, {"name": "Bob", "age": 44})
carol = gh.hydrate_node(3, {"Person"}, {"name": "Carol", "age": 55})
r = [
gh.hydrate_unbound_relationship(1, "KNOWS", {"since": 1999}),
gh.hydrate_unbound_relationship(2, "DISLIKES", {})
]
path = gh.hydrate_path([alice, bob, carol], r, [1, 1, -2, 2])
assert path.start_node == alice
assert path.end_node == carol
assert path.nodes == (alice, bob, carol)
expected_alice_knows_bob = gh.hydrate_relationship(1, alice.id, bob.id,
"KNOWS",
{"since": 1999})
expected_carol_dislikes_bob = gh.hydrate_relationship(
2, carol.id, bob.id, "DISLIKES", {})
assert path.relationships == (expected_alice_knows_bob,
expected_carol_dislikes_bob)
assert list(path) == [
expected_alice_knows_bob, expected_carol_dislikes_bob
]
