Updated to fit with latest feature files. There are no longer tests for sending

path/node/relationship as parameters since this is not supported.

Author: RagnarW

neo4j/__init__.py

@@ -19,4 +19,4 @@
 # limitations under the License.
 
 
-from neo4j.meta import version as __version__
+from .meta import version as __version__

neo4j/v1/connection.py

@@ -29,7 +29,7 @@
 from socket import create_connection, SHUT_RDWR
 from struct import pack as struct_pack, unpack as struct_unpack, unpack_from as struct_unpack_from
 
-from neo4j.meta import version
+from ..meta import version
 from .compat import hex2, secure_socket
 from .exceptions import ProtocolError
 from .packstream import Packer, Unpacker
@@ -220,7 +220,7 @@ def __init__(self, sock, **config):
         self.responses = deque()
 
         # Determine the user agent and ensure it is a Unicode value
-        user_agent = config.get("user-agent", DEFAULT_USER_AGENT)
+        user_agent = config.get("user_agent", DEFAULT_USER_AGENT)
         if isinstance(user_agent, bytes):
             user_agent = user_agent.decode("UTF-8")
 

neo4j/v1/session.py

@@ -99,7 +99,7 @@ def session(self, **config):
             >>> session = driver.session()
 
         """
-        return Session(connect(self.host, self.port, **config))
+        return Session(connect(self.host, self.port, **dict(self.config, **config)))
 
 
 class Result(list):

neo4j/v1/typesystem.py

@@ -119,6 +119,8 @@ def hydrate(cls, identity, start, end, type, properties=None):
         return inst
 
     def __init__(self, start, end, type, properties=None, **kwproperties):
+        assert isinstance(start, int)
+        assert isinstance(end, int)
         super(Relationship, self).__init__(type, properties, **kwproperties)
         self.start = start
         self.end = end
@@ -172,10 +174,11 @@ def hydrate(cls, nodes, rels, sequence):
             assert rel_index != 0
             next_node = nodes[sequence[2 * i + 1]]
             if rel_index > 0:
-                entities.append(rels[rel_index - 1].bind(last_node, next_node))
+                entities.append(rels[rel_index - 1].bind(last_node.identity, next_node.identity))
             else:
-                entities.append(rels[-rel_index - 1].bind(next_node, last_node))
+                entities.append(rels[-rel_index - 1].bind(next_node.identity, last_node.identity))
             entities.append(next_node)
+            last_node = next_node
         return cls(*entities)
 
     def __init__(self, start_node, *rels_and_nodes):

test/tck/configure_feature_files.py

@@ -4,7 +4,7 @@
 
 
 def clean_up():
-    dir_path = (os.path.dirname(os.path.realpath(__file__)))#'test/tck/'
+    dir_path = (os.path.dirname(os.path.realpath(__file__)))
     files = os.listdir(dir_path)
     for f in files:
         if not os.path.isdir(f) and ".feature" in f:

test/tck/steps/bolt_type_steps.py

@@ -38,16 +38,6 @@ def step_impl(context):
     context.M = {}
 
 
-@given("an empty node N")
-def step_impl(context):
-    context.N = Node()
-
-
-@given("a node N with properties and labels")
-def step_impl(context):
-    context.N = Node({"Person"}, {"name": "Alice", "age": 33})
-
-
 @given("a String of size (?P<size>\d+)")
 def step_impl(context, size):
     context.expected = tck_util.get_random_string(int(size))
@@ -120,13 +110,6 @@ def step_impl(context):
     context.results["as_parameters"] = tck_util.send_parameters("RETURN {input}", {'input': context.expected})
 
 
-@when("the driver asks the server to echo this node back")
-def step_impl(context):
-    context.expected = context.N
-    context.results = {}
-    context.results["as_parameters"] = tck_util.send_parameters("RETURN {input}", {'input': context.expected})
-
-
 @then("the result returned from the server should be a single record with a single value")
 def step_impl(context):
     assert len(context.results) > 0
@@ -154,88 +137,4 @@ def step_impl(context):
         assert result_value.values() == context.expected.values()
         assert result_value.items() == context.expected.items()
         assert len(result_value) == len(context.expected)
-        assert iter(result_value) == iter(context.expected)
-
-
-##CURRENTLY NOT SUPPORTED IN PYTHON DRIVERS
-
-@given("a relationship R")
-def step_impl(context):
-    alice = Node({"Person"}, {"name": "Alice", "age": 33})
-    bob = Node({"Person"}, {"name": "Bob", "age": 44})
-    context.R = Relationship(alice, bob, "KNOWS", {"since": 1999})
-
-
-@when("the driver asks the server to echo this relationship R back")
-def step_impl(context):
-    context.expected = context.R
-    context.results = {}
-    context.results["as_parameters"] = tck_util.send_parameters("RETURN {input}", {'input': context.expected})
-
-
-@step("the relationship value given in the result should be the same as what was sent")
-def step_impl(context):
-    assert len(context.results) > 0
-    for result in context.results.values():
-        result_value = result[0].values()[0]
-        assert result_value == context.expected
-        assert result_value.start == context.expected.start
-        assert result_value.type == context.expected.type
-        assert result_value.end == context.expected.end
-        assert result_value.items() == context.expected.items()
-        assert result_value.keys() == context.expected.keys()
-        assert result_value.values() == context.expected.values()
-
-
-@given("a zero length path P")
-def step_impl(context):
-    context.P = Path(Node({"Person"}, {"name": "Alice", "age": 33}))
-
-
-@given("a arbitrary long path P")
-def step_impl(context):
-    alice = Node({"Person"}, {"name": "Alice", "age": 33})
-    bob = Node({"Person"}, {"name": "Bob", "age": 44})
-    carol = Node({"Person"}, {"name": "Carol", "age": 55})
-    alice_knows_bob = Relationship(alice, bob, "KNOWS", {"since": 1999})
-    carol_dislikes_bob = Relationship(carol, bob, "DISLIKES")
-    context.P = Path(alice, alice_knows_bob, bob, carol_dislikes_bob, carol)
-
-
-@when("the driver asks the server to echo this path back")
-def step_impl(context):
-    context.expected = context.P
-    context.results = {}
-    context.results["as_parameters"] = tck_util.send_parameters("RETURN {input}", {'input': context.expected})
-
-
-@step("the path value given in the result should be the same as what was sent")
-def step_impl(context):
-    assert len(context.results) > 0
-    for result in context.results.values():
-        result_value = result[0].values()[0]
-        assert result_value == context.expected
-        assert result_value.start == context.expected.start
-        assert result_value.end == context.expected.end
-        assert result_value.nodes == context.expected.nodes
-        assert result_value.relationships == context.expected.relationships
-        assert list(result_value) == list(context.expected)
-
-
-@given("a Node with great amount of properties and labels")
-def step_impl(context):
-    context.N = Node(tck_util.get_list_of_random_type(1000, "String"),
-                     tck_util.get_dict_of_random_type(1000, "String"))
-
-
-@given("a path P of size (?P<size>\d+)")
-def step_impl(context, size):
-    nodes_and_rels = [Node({tck_util.get_random_string(5)}, tck_util.get_dict_of_random_type(3, "String"))]
-    for i in range(1, int(12)):
-        n = nodes_and_rels.append(Node({tck_util.get_random_string(5)}, tck_util.get_dict_of_random_type(3, "String")))
-        r = Relationship(nodes_and_rels[-1], n, tck_util.get_random_string(4),
-                         tck_util.get_dict_of_random_type(3, "String"))
-        nodes_and_rels.append(r)
-        nodes_and_rels.append(n)
-
-    context.P = Path(nodes_and_rels[0], nodes_and_rels[1:])
+        assert iter(result_value) == iter(context.expected)

test/test_examples.py

@@ -60,7 +60,7 @@ def test_statement_without_parameters(self):
         result = session.run("CREATE (p:Person { name: 'The One' })")
         ones_created = result.summary.statistics.nodes_created
         print("There were {0} the ones created.".format(ones_created))
-        #end::statement-without-parameterst[]
+        #end::statement-without-parameters[]
         assert ones_created == 1
         session.close()
 

test/test_typesystem.py

@@ -57,35 +57,35 @@ def test_null_properties(self):
 
     def test_node_equality(self):
         node_1 = Node()
-        node_1.identity = "node/1234"
+        node_1.identity = 1234
         node_2 = Node()
-        node_2.identity = "node/1234"
+        node_2.identity = 1234
         node_3 = Node()
-        node_3.identity = "node/5678"
+        node_3.identity = 5678
         assert node_1 == node_2
         assert node_1 != node_3
         assert node_1 != "this is not a node"
 
     def test_node_hashing(self):
         node_1 = Node()
-        node_1.identity = "node/1234"
+        node_1.identity = 1234
         node_2 = Node()
-        node_2.identity = "node/1234"
+        node_2.identity = 1234
         node_3 = Node()
-        node_3.identity = "node/5678"
+        node_3.identity = 5678
         assert hash(node_1) == hash(node_2)
         assert hash(node_1) != hash(node_3)
 
 
 class RelationshipTestCase(TestCase):
 
     def test_can_create_relationship(self):
-        alice = Node({"Person"}, {"name": "Alice", "age": 33})
-        bob = Node({"Person"}, {"name": "Bob", "age": 44})
-        alice_knows_bob = Relationship(alice, bob, "KNOWS", {"since": 1999})
-        assert alice_knows_bob.start is alice
+        alice = Node.hydrate(1, {"Person"}, {"name": "Alice", "age": 33})
+        bob = Node.hydrate(2, {"Person"}, {"name": "Bob", "age": 44})
+        alice_knows_bob = Relationship(alice.identity, bob.identity, "KNOWS", {"since": 1999})
+        assert alice_knows_bob.start == alice.identity
         assert alice_knows_bob.type == "KNOWS"
-        assert alice_knows_bob.end is bob
+        assert alice_knows_bob.end == bob.identity
         assert set(alice_knows_bob.keys()) == {"since"}
         assert set(alice_knows_bob.values()) == {1999}
         assert set(alice_knows_bob.items()) == {("since", 1999)}
@@ -108,11 +108,11 @@ def test_can_create_unbound_relationship(self):
 class PathTestCase(TestCase):
 
     def test_can_create_path(self):
-        alice = Node({"Person"}, {"name": "Alice", "age": 33})
-        bob = Node({"Person"}, {"name": "Bob", "age": 44})
-        carol = Node({"Person"}, {"name": "Carol", "age": 55})
-        alice_knows_bob = Relationship(alice, bob, "KNOWS", {"since": 1999})
-        carol_dislikes_bob = Relationship(carol, bob, "DISLIKES")
+        alice = Node.hydrate(1, {"Person"}, {"name": "Alice", "age": 33})
+        bob = Node.hydrate(2, {"Person"}, {"name": "Bob", "age": 44})
+        carol = Node.hydrate(3, {"Person"}, {"name": "Carol", "age": 55})
+        alice_knows_bob = Relationship(alice.identity, bob.identity, "KNOWS", {"since": 1999})
+        carol_dislikes_bob = Relationship(carol.identity, bob.identity, "DISLIKES")
         path = Path(alice, alice_knows_bob, bob, carol_dislikes_bob, carol)
         assert path.start == alice
         assert path.end == carol
@@ -122,11 +122,11 @@ def test_can_create_path(self):
         assert repr(path)
 
     def test_can_hydrate_path(self):
-        alice = Node({"Person"}, {"name": "Alice", "age": 33})
-        bob = Node({"Person"}, {"name": "Bob", "age": 44})
-        carol = Node({"Person"}, {"name": "Carol", "age": 55})
-        alice_knows_bob = Relationship(alice, bob, "KNOWS", {"since": 1999})
-        carol_dislikes_bob = Relationship(carol, bob, "DISLIKES")
+        alice = Node.hydrate(1, {"Person"}, {"name": "Alice", "age": 33})
+        bob = Node.hydrate(2, {"Person"}, {"name": "Bob", "age": 44})
+        carol = Node.hydrate(3, {"Person"}, {"name": "Carol", "age": 55})
+        alice_knows_bob = Relationship(alice.identity, bob.identity, "KNOWS", {"since": 1999})
+        carol_dislikes_bob = Relationship(carol.identity, bob.identity, "DISLIKES")
         path = Path.hydrate([alice, bob, carol],
                             [alice_knows_bob.unbind(), carol_dislikes_bob.unbind()],
                             [1, 1, -2, 2])
@@ -138,22 +138,22 @@ def test_can_hydrate_path(self):
         assert repr(path)
 
     def test_path_equality(self):
-        alice = Node({"Person"}, {"name": "Alice", "age": 33})
-        bob = Node({"Person"}, {"name": "Bob", "age": 44})
-        carol = Node({"Person"}, {"name": "Carol", "age": 55})
-        alice_knows_bob = Relationship(alice, bob, "KNOWS", {"since": 1999})
-        carol_dislikes_bob = Relationship(carol, bob, "DISLIKES")
+        alice = Node.hydrate(1, {"Person"}, {"name": "Alice", "age": 33})
+        bob = Node.hydrate(2, {"Person"}, {"name": "Bob", "age": 44})
+        carol = Node.hydrate(3, {"Person"}, {"name": "Carol", "age": 55})
+        alice_knows_bob = Relationship(alice.identity, bob.identity, "KNOWS", {"since": 1999})
+        carol_dislikes_bob = Relationship(carol.identity, bob.identity, "DISLIKES")
         path_1 = Path(alice, alice_knows_bob, bob, carol_dislikes_bob, carol)
         path_2 = Path(alice, alice_knows_bob, bob, carol_dislikes_bob, carol)
         assert path_1 == path_2
         assert path_1 != "this is not a path"
 
     def test_path_hashing(self):
-        alice = Node({"Person"}, {"name": "Alice", "age": 33})
-        bob = Node({"Person"}, {"name": "Bob", "age": 44})
-        carol = Node({"Person"}, {"name": "Carol", "age": 55})
-        alice_knows_bob = Relationship(alice, bob, "KNOWS", {"since": 1999})
-        carol_dislikes_bob = Relationship(carol, bob, "DISLIKES")
+        alice = Node.hydrate(1, {"Person"}, {"name": "Alice", "age": 33})
+        bob = Node.hydrate(2, {"Person"}, {"name": "Bob", "age": 44})
+        carol = Node.hydrate(3, {"Person"}, {"name": "Carol", "age": 55})
+        alice_knows_bob = Relationship(alice.identity, bob.identity, "KNOWS", {"since": 1999})
+        carol_dislikes_bob = Relationship(carol.identity, bob.identity, "DISLIKES")
         path_1 = Path(alice, alice_knows_bob, bob, carol_dislikes_bob, carol)
         path_2 = Path(alice, alice_knows_bob, bob, carol_dislikes_bob, carol)
         assert hash(path_1) == hash(path_2)
@@ -163,11 +163,11 @@ class HydrationTestCase(TestCase):
 
     def test_can_hydrate_node_structure(self):
         struct = Structure(3, b'N')
-        struct.append("node/123")
+        struct.append(123)
         struct.append(["Person"])
         struct.append({"name": "Alice"})
         alice = hydrated(struct)
-        assert alice.identity == "node/123"
+        assert alice.identity == 123
         assert alice.labels == {"Person"}
         assert set(alice.keys()) == {"name"}
         assert alice.get("name") == "Alice"
@@ -180,26 +180,26 @@ def test_hydrating_unknown_structure_returns_same(self):
 
     def test_can_hydrate_in_list(self):
         struct = Structure(3, b'N')
-        struct.append("node/123")
+        struct.append(123)
         struct.append(["Person"])
         struct.append({"name": "Alice"})
         alice_in_list = hydrated([struct])
         assert isinstance(alice_in_list, list)
         alice, = alice_in_list
-        assert alice.identity == "node/123"
+        assert alice.identity == 123
         assert alice.labels == {"Person"}
         assert set(alice.keys()) == {"name"}
         assert alice.get("name") == "Alice"
 
     def test_can_hydrate_in_dict(self):
         struct = Structure(3, b'N')
-        struct.append("node/123")
+        struct.append(123)
         struct.append(["Person"])
         struct.append({"name": "Alice"})
         alice_in_dict = hydrated({"foo": struct})
         assert isinstance(alice_in_dict, dict)
         alice = alice_in_dict["foo"]
-        assert alice.identity == "node/123"
+        assert alice.identity == 123
         assert alice.labels == {"Person"}
         assert set(alice.keys()) == {"name"}
         assert alice.get("name") == "Alice"