class TestIndexedRelationshipAddition(object):
@pytest.fixture(autouse=True)
def setup(self, legacy_graph):
try:
legacy_graph.delete_index(Relationship, "Friendships")
except LookupError:
pass
self.friendships = legacy_graph.get_or_create_index(Relationship, "Friendships")
self.batch = LegacyWriteBatch(legacy_graph)
self.graph = legacy_graph
def test_can_add_single_relationship(self, legacy_graph):
alice, bob, ab = self.graph.create({"name": "Alice"}, {"name": "Bob"}, (0, "KNOWS", 1))
self.batch.add_to_index(Relationship, self.friendships, "friends", "alice_&_bob", ab)
self.batch.run()
# check entries
rels = self.friendships.get("friends", "alice_&_bob")
assert len(rels) == 1
assert ab in rels
# done
self.recycling = [ab, alice, bob]
def test_can_add_two_similar_relationships(self, legacy_graph):
alice, bob, ab1, ab2 = self.graph.create(
{"name": "Alice"}, {"name": "Bob"},
(0, "KNOWS", 1), (0, "KNOWS", 1))
self.batch.add_to_index(Relationship, self.friendships, "friends", "alice_&_bob", ab1)
self.batch.add_to_index(Relationship, self.friendships, "friends", "alice_&_bob", ab2)
self.batch.run()
# check entries
entries = self.friendships.get("friends", "alice_&_bob")
assert len(entries) == 2
assert ab1 in entries
assert ab2 in entries
# done
self.recycling = [ab1, ab2, alice, bob]
def test_can_add_relationships_only_if_none_exist(self):
alice, bob, ab1, ab2 = self.graph.create(
{"name": "Alice"}, {"name": "Bob"},
(0, "KNOWS", 1), (0, "KNOWS", 1))
self.batch.get_or_add_to_index(Relationship, self.friendships,
"friends", "alice_&_bob", ab1)
self.batch.get_or_add_to_index(Relationship, self.friendships,
"friends", "alice_&_bob", ab2)
results = self.batch.submit()
assert results[0] == results[1]
# check entries
entries = self.friendships.get("friends", "alice_&_bob")
assert len(entries) == 1
assert ab1 in entries
# done
self.recycling = [ab1, ab2, alice, bob]
class TestIndexedRelationshipAddition(object):
@pytest.fixture(autouse=True)
def setup(self, graph):
try:
graph.legacy.delete_index(Relationship, "Friendships")
except LookupError:
pass
self.friendships = graph.legacy.get_or_create_index(
Relationship, "Friendships")
self.batch = LegacyWriteBatch(graph)
self.graph = graph
def test_can_add_single_relationship(self, graph):
alice, bob, ab = self.graph.create({"name": "Alice"}, {"name": "Bob"},
(0, "KNOWS", 1))
self.batch.add_to_index(Relationship, self.friendships, "friends",
"alice_&_bob", ab)
self.batch.run()
# check entries
rels = self.friendships.get("friends", "alice_&_bob")
assert len(rels) == 1
assert ab in rels
# done
self.recycling = [ab, alice, bob]
def test_can_add_two_similar_relationships(self, graph):
alice, bob, ab1, ab2 = self.graph.create({"name": "Alice"},
{"name": "Bob"},
(0, "KNOWS", 1),
(0, "KNOWS", 1))
self.batch.add_to_index(Relationship, self.friendships, "friends",
"alice_&_bob", ab1)
self.batch.add_to_index(Relationship, self.friendships, "friends",
"alice_&_bob", ab2)
self.batch.run()
# check entries
entries = self.friendships.get("friends", "alice_&_bob")
assert len(entries) == 2
assert ab1 in entries
assert ab2 in entries
# done
self.recycling = [ab1, ab2, alice, bob]
def test_can_add_relationships_only_if_none_exist(self):
alice, bob, ab1, ab2 = self.graph.create({"name": "Alice"},
{"name": "Bob"},
(0, "KNOWS", 1),
(0, "KNOWS", 1))
self.batch.get_or_add_to_index(Relationship, self.friendships,
"friends", "alice_&_bob", ab1)
self.batch.get_or_add_to_index(Relationship, self.friendships,
"friends", "alice_&_bob", ab2)
results = self.batch.submit()
assert results[0] == results[1]
# check entries
entries = self.friendships.get("friends", "alice_&_bob")
assert len(entries) == 1
assert ab1 in entries
# done
self.recycling = [ab1, ab2, alice, bob]
class TestIndexedNodeAddition(object):
@pytest.fixture(autouse=True)
def setup(self, graph):
try:
graph.legacy.delete_index(Node, "People")
except LookupError:
pass
self.people = graph.legacy.get_or_create_index(Node, "People")
self.batch = LegacyWriteBatch(graph)
self.graph = graph
def test_can_add_single_node(self):
alice, = self.graph.create({"name": "Alice Smith"})
self.batch.add_to_index(Node, self.people, "surname", "Smith", alice)
self.batch.run()
# check entries
smiths = self.people.get("surname", "Smith")
assert len(smiths) == 1
assert alice in smiths
# done
self.graph.delete(alice)
def test_can_add_two_similar_nodes(self):
alice, bob = self.graph.create({"name": "Alice Smith"},
{"name": "Bob Smith"})
self.batch.add_to_index(Node, self.people, "surname", "Smith", alice)
self.batch.add_to_index(Node, self.people, "surname", "Smith", bob)
nodes = self.batch.submit()
assert nodes[0] != nodes[1]
# check entries
smiths = self.people.get("surname", "Smith")
assert len(smiths) == 2
assert alice in smiths
assert bob in smiths
# done
self.graph.delete(alice, bob)
def test_can_add_nodes_only_if_none_exist(self):
alice, bob = self.graph.create({"name": "Alice Smith"},
{"name": "Bob Smith"})
self.batch.get_or_add_to_index(Node, self.people, "surname", "Smith",
alice)
self.batch.get_or_add_to_index(Node, self.people, "surname", "Smith",
bob)
nodes = self.batch.submit()
assert nodes[0] == nodes[1]
# check entries
smiths = self.people.get("surname", "Smith")
assert len(smiths) == 1
assert alice in smiths
# done
self.graph.delete(alice, bob)
class TestIndexedNodeAddition(object):
@pytest.fixture(autouse=True)
def setup(self, legacy_graph):
try:
legacy_graph.delete_index(Node, "People")
except LookupError:
pass
self.people = legacy_graph.get_or_create_index(Node, "People")
self.batch = LegacyWriteBatch(legacy_graph)
self.graph = legacy_graph
def test_can_add_single_node(self):
alice, = self.graph.create({"name": "Alice Smith"})
self.batch.add_to_index(Node, self.people, "surname", "Smith", alice)
self.batch.run()
# check entries
smiths = self.people.get("surname", "Smith")
assert len(smiths) == 1
assert alice in smiths
# done
self.graph.delete(alice)
def test_can_add_two_similar_nodes(self):
alice, bob = self.graph.create(
{"name": "Alice Smith"}, {"name": "Bob Smith"})
self.batch.add_to_index(Node, self.people, "surname", "Smith", alice)
self.batch.add_to_index(Node, self.people, "surname", "Smith", bob)
nodes = self.batch.submit()
assert nodes[0] != nodes[1]
# check entries
smiths = self.people.get("surname", "Smith")
assert len(smiths) == 2
assert alice in smiths
assert bob in smiths
# done
self.graph.delete(alice, bob)
def test_can_add_nodes_only_if_none_exist(self):
alice, bob = self.graph.create(
{"name": "Alice Smith"}, {"name": "Bob Smith"})
self.batch.get_or_add_to_index(Node, self.people, "surname", "Smith", alice)
self.batch.get_or_add_to_index(Node, self.people, "surname", "Smith", bob)
nodes = self.batch.submit()
assert nodes[0] == nodes[1]
# check entries
smiths = self.people.get("surname", "Smith")
assert len(smiths) == 1
assert alice in smiths
# done
self.graph.delete(alice, bob)
class TestIndexedNodeCreation(object):
@pytest.fixture(autouse=True)
def setup(self, legacy_graph):
try:
legacy_graph.delete_index(Node, "People")
except LookupError:
pass
self.people = legacy_graph.get_or_create_index(Node, "People")
self.batch = LegacyWriteBatch(legacy_graph)
self.graph = legacy_graph
def test_can_create_single_indexed_node(self):
properties = {"name": "Alice Smith"}
# need to execute a pair of commands as "create in index" not available
self.batch.create(properties)
self.batch.add_to_index(Node, self.people, "surname", "Smith", 0)
alice, index_entry = self.batch.submit()
assert isinstance(alice, Node)
assert alice.get_properties() == properties
self.graph.delete(alice)
def test_can_create_two_similarly_indexed_nodes(self):
# create Alice
alice_props = {"name": "Alice Smith"}
# need to execute a pair of commands as "create in index" not available
self.batch.create(alice_props)
self.batch.add_to_index(Node, self.people, "surname", "Smith", 0)
alice, alice_index_entry = self.batch.submit()
assert isinstance(alice, Node)
assert alice.get_properties() == alice_props
self.batch.clear()
# create Bob
bob_props = {"name": "Bob Smith"}
# need to execute a pair of commands as "create in index" not available
self.batch.create(bob_props)
self.batch.add_to_index(Node, self.people, "surname", "Smith", 0)
bob, bob_index_entry = self.batch.submit()
assert isinstance(bob, Node)
assert bob.get_properties() == bob_props
# check entries
smiths = self.people.get("surname", "Smith")
assert len(smiths) == 2
assert alice in smiths
assert bob in smiths
# done
self.graph.delete(alice, bob)
def test_can_get_or_create_uniquely_indexed_node(self):
# create Alice
alice_props = {"name": "Alice Smith"}
self.batch.get_or_create_in_index(Node, self.people, "surname", "Smith", alice_props)
alice, = self.batch.submit()
assert isinstance(alice, Node)
assert alice.get_properties() == alice_props
self.batch.clear()
# create Bob
bob_props = {"name": "Bob Smith"}
self.batch.get_or_create_in_index(Node, self.people, "surname", "Smith", bob_props)
bob, = self.batch.submit()
assert isinstance(bob, Node)
assert bob.get_properties() != bob_props
assert bob.get_properties() == alice_props
assert bob == alice
# check entries
smiths = self.people.get("surname", "Smith")
assert len(smiths) == 1
assert alice in smiths
# done
self.graph.delete(alice, bob)
class TestIndexedNodeCreation(object):
@pytest.fixture(autouse=True)
def setup(self, graph):
try:
graph.legacy.delete_index(Node, "People")
except LookupError:
pass
self.people = graph.legacy.get_or_create_index(Node, "People")
self.batch = LegacyWriteBatch(graph)
self.graph = graph
def test_can_create_single_indexed_node(self):
properties = {"name": "Alice Smith"}
# need to execute a pair of commands as "create in index" not available
self.batch.create(properties)
self.batch.add_to_index(Node, self.people, "surname", "Smith", 0)
alice, index_entry = self.batch.submit()
assert isinstance(alice, Node)
assert alice.properties == properties
self.graph.delete(alice)
def test_can_create_two_similarly_indexed_nodes(self):
# create Alice
alice_props = {"name": "Alice Smith"}
# need to execute a pair of commands as "create in index" not available
self.batch.create(alice_props)
self.batch.add_to_index(Node, self.people, "surname", "Smith", 0)
alice, alice_index_entry = self.batch.submit()
assert isinstance(alice, Node)
assert alice.properties == alice_props
self.batch.clear()
# create Bob
bob_props = {"name": "Bob Smith"}
# need to execute a pair of commands as "create in index" not available
self.batch.create(bob_props)
self.batch.add_to_index(Node, self.people, "surname", "Smith", 0)
bob, bob_index_entry = self.batch.submit()
assert isinstance(bob, Node)
assert bob.properties == bob_props
# check entries
smiths = self.people.get("surname", "Smith")
assert len(smiths) == 2
assert alice in smiths
assert bob in smiths
# done
self.graph.delete(alice, bob)
def test_can_get_or_create_uniquely_indexed_node(self):
# create Alice
alice_props = {"name": "Alice Smith"}
self.batch.get_or_create_in_index(Node, self.people, "surname",
"Smith", alice_props)
alice, = self.batch.submit()
assert isinstance(alice, Node)
assert alice.properties == alice_props
self.batch.clear()
# create Bob
bob_props = {"name": "Bob Smith"}
self.batch.get_or_create_in_index(Node, self.people, "surname",
"Smith", bob_props)
bob, = self.batch.submit()
assert isinstance(bob, Node)
assert bob.properties != bob_props
assert bob.properties == alice_props
assert bob == alice
# check entries
smiths = self.people.get("surname", "Smith")
assert len(smiths) == 1
assert alice in smiths
# done
self.graph.delete(alice, bob)