Пример #1
0
def test_can_bind_relationship_to_resource():
    uri = "http://localhost:7474/db/relationship/1"
    relationship = Relationship({}, "", {})
    relationship.bind(uri)
    assert relationship.bound
    assert isinstance(relationship.resource, Resource)
    assert relationship.resource.uri == uri
    relationship.unbind()
    assert not relationship.bound
    with pytest.raises(BindError):
        r = relationship.resource
Пример #2
0
def test_cannot_use_a_pointer_that_does_not_refer_to_a_node(graph):
    alice = Node(name="Alice")
    bob = Node(name="Bob")
    alice_knows_bob = Relationship(0, "KNOWS", 1)
    broken_relationship = Relationship(0, "KNOWS", 2)
    statement = CreateStatement(graph)
    statement.create(alice)
    statement.create(bob)
    statement.create(alice_knows_bob)
    try:
        statement.create(broken_relationship)
    except ValueError:
        assert True
    else:
        assert False
Пример #3
0
def test_can_bind_relationship_to_resource():
    uri = "http://localhost:7474/db/relationship/1"
    metadata = {
        "start": "http://localhost:7474/db/node/1",
        "end": "http://localhost:7474/db/node/2",
    }
    relationship = Relationship({}, "", {})
    # Pass in metadata to avoid callback to server
    relationship.bind(uri, metadata=metadata)
    assert relationship.bound
    assert isinstance(relationship.resource, Resource)
    assert relationship.resource.uri == uri
    relationship.unbind()
    assert not relationship.bound
    with pytest.raises(BindError):
        _ = relationship.resource
Пример #4
0
def test_can_write_relationship_with_properties():
    r = Representation()
    r.write(
        Relationship({"name": "Fred"}, ("LIVES WITH", {
            "place": "Bedrock"
        }), {"name": "Wilma"}))
    written = repr(r)
    assert written == '({name:"Fred"})-[:`LIVES WITH` {place:"Bedrock"}]->({name:"Wilma"})'
Пример #5
0
def test_cannot_use_a_pointer_that_is_out_of_range(graph):
    broken_relationship = Relationship(10, "KNOWS", 11)
    statement = CreateStatement(graph)
    try:
        statement.create(broken_relationship)
    except IndexError:
        assert True
    else:
        assert False
Пример #6
0
def test_a_unique_relationship_is_really_unique(graph):
    results = graph.cypher.stream("CREATE (a)-[ab:KNOWS]->(b) RETURN a, ab, b")
    alice, alice_knows_bob, bob = next(results).values
    assert alice.degree == 1
    assert bob.degree == 1
    statement = CreateStatement(graph)
    statement.create_unique(Relationship(alice, "KNOWS", bob))
    statement.execute()
    assert alice.degree == 1
    assert bob.degree == 1
Пример #7
0
def test_can_create_a_relationship_to_two_existing_nodes(graph):
    alice = graph.cypher.execute_one("CREATE (a {name:'Alice'}) RETURN a")
    bob = graph.cypher.execute_one("CREATE (b {name:'Bob'}) RETURN b")
    alice_knows_bob = Relationship(alice, "KNOWS", bob)
    statement = CreateStatement(graph)
    statement.create(alice_knows_bob)
    created = statement.execute()
    assert created == (alice_knows_bob, )
    assert alice_knows_bob.bound
    assert alice_knows_bob.start_node is alice
    assert alice_knows_bob.end_node is bob
Пример #8
0
def test_can_create_two_nodes_and_a_relationship(graph):
    alice = Node(name="Alice")
    bob = Node(name="Bob")
    alice_knows_bob = Relationship(alice, "KNOWS", bob)
    statement = CreateStatement(graph)
    statement.create(alice)
    statement.create(bob)
    statement.create(alice_knows_bob)
    created = statement.execute()
    assert created == (alice, bob, alice_knows_bob)
    assert alice.bound
    assert bob.bound
    assert alice_knows_bob.bound
    assert alice_knows_bob.start_node is alice
    assert alice_knows_bob.end_node is bob
Пример #9
0
 def _create_in_index(self, cls, index, key, value, abstract, query=None):
     uri = self._uri_for(self._index(cls, index), query=query)
     if cls is Node:
         node = Node.cast(abstract)
         return self.append_post(uri, {
             "key": key,
             "value": value,
             "properties": node.properties,
         })
     elif cls is Relationship:
         relationship = Relationship.cast(abstract)
         return self.append_post(uri, {
             "key": key,
             "value": value,
             "start": self._uri_for(abstract.start_node),
             "type": str(abstract.type),
             "end": self._uri_for(abstract.end_node),
             "properties": relationship.properties,
         })
     else:
         raise TypeError(cls)
Пример #10
0
def test_unique_path_not_unique_exception(graph):
    results = graph.cypher.stream(
        "CREATE (a)-[ab:KNOWS]->(b), (a)-[:KNOWS]->(b) RETURN a, ab, b")
    alice, alice_knows_bob, bob = next(results).values
    assert alice.degree == 2
    assert bob.degree == 2
    statement = CreateStatement(graph)
    statement.create_unique(Relationship(alice, "KNOWS", bob))
    try:
        statement.execute()
    except CypherError as error:
        assert error.exception == "UniquePathNotUniqueException"
        assert error.fullname in [
            None, "org.neo4j.cypher.UniquePathNotUniqueException"
        ]
        assert error.statement == (
            "START _0n0=node({_0n0}),_0n1=node({_0n1})\n"
            "CREATE UNIQUE (_0n0)-[_0r0:KNOWS]->(_0n1)\n"
            "RETURN _0n0,_0n1,_0r0")
    else:
        assert False
Пример #11
0
def test_can_bind_relationship_to_resource():
    uri = "http://localhost:7474/db/relationship/1"
    metadata = {
        "start": "http://localhost:7474/db/node/1",
        "end": "http://localhost:7474/db/node/2",
    }
    relationship = Relationship({}, "", {})
    # Pass in metadata to avoid callback to server
    relationship.bind(uri, metadata=metadata)
    assert relationship.bound
    assert isinstance(relationship.resource, Resource)
    assert relationship.resource.uri == uri
    relationship.unbind()
    assert not relationship.bound
    with pytest.raises(BindError):
        _ = relationship.resource
Пример #12
0
 def _create_in_index(self, cls, index, key, value, abstract, query=None):
     uri = self._uri_for(self._index(cls, index), query=query)
     if cls is Node:
         node = Node.cast(abstract)
         return self.append_post(uri, {
             "key": key,
             "value": value,
             "properties": node.properties,
         })
     elif cls is Relationship:
         relationship = Relationship.cast(abstract)
         return self.append_post(
             uri, {
                 "key": key,
                 "value": value,
                 "start": self._uri_for(abstract.start_node),
                 "type": str(abstract.type),
                 "end": self._uri_for(abstract.end_node),
                 "properties": relationship.properties,
             })
     else:
         raise TypeError(cls)
Пример #13
0
 def __init__(self, *type_, **properties):
     CypherTask.__init__(self)
     self.__relationship = Relationship(*labels, **properties)
     self.__return = False
Пример #14
0
def test_can_write_simple_relationship():
    r = Representation()
    r.write(Relationship({}, "KNOWS", {}))
    written = repr(r)
    assert written == "()-[:KNOWS]->()"