Merge branch '1.0' into 1.0-tck-tests

Author: RagnarW

examples/test_examples.py

@@ -158,7 +158,7 @@ def test_transaction_commit(self):
         tx.commit()
         # end::transaction-commit[]
         result = session.run("MATCH (p:Person {name: 'Guinevere'}) RETURN count(p)")
-        record = next(result)
+        record = next(iter(result))
         assert record["count(p)"] == 1
         session.close()
 
@@ -171,7 +171,7 @@ def test_transaction_rollback(self):
         tx.rollback()
         # end::transaction-rollback[]
         result = session.run("MATCH (p:Person {name: 'Merlin'}) RETURN count(p)")
-        record = next(result)
+        record = next(iter(result))
         assert record["count(p)"] == 0
         session.close()
 

neo4j/.DS_Store

@@ -215,7 +215,7 @@ def __init__(self, sock, **config):
         # Determine auth details
         try:
             self.auth_dict = vars(config["auth"])
-        except KeyError:
+        except (KeyError, TypeError):
             self.auth_dict = {}
 
         # Pick up the server certificate, if any

neo4j/v1/connection.py

@@ -206,19 +206,14 @@ def on_failure(metadata):
         pull_all_response.on_failure = on_failure
 
     def __iter__(self):
-        return self
-
-    def __next__(self):
-        if self._buffer:
+        while self._buffer:
             values = self._buffer.popleft()
-            return Record(self.keys(), tuple(map(hydrated, values)))
-        elif self._consumed:
-            raise StopIteration()
-        else:
-            fetch = self.connection.fetch
-            while not self._buffer and not self._consumed:
-                fetch()
-            return self.__next__()
+            yield Record(self.keys(), tuple(map(hydrated, values)))
+        while not self._consumed:
+            self.connection.fetch()
+            while self._buffer:
+                values = self._buffer.popleft()
+                yield Record(self.keys(), tuple(map(hydrated, values)))
 
     def keys(self):
         """ Return the keys for the records.
@@ -228,14 +223,18 @@ def keys(self):
             self.connection.fetch()
         return self._keys
 
+    def buffer(self):
+        if self.connection and not self.connection.closed:
+            while not self._consumed:
+                self.connection.fetch()
+            self.connection = None
+
     def consume(self):
         """ Consume the remainder of this result and return the
         summary.
         """
         if self.connection and not self.connection.closed:
-            fetch = self.connection.fetch
-            while not self._consumed:
-                fetch()
+            list(self)
             self.connection = None
         return self._summary
 
@@ -334,11 +333,11 @@ def __repr__(self):
 
     @property
     def contains_updates(self):
-        return self.nodes_created or self.nodes_deleted or \
+        return bool(self.nodes_created or self.nodes_deleted or \
                self.relationships_created or self.relationships_deleted or \
                self.properties_set or self.labels_added or self.labels_removed or \
                self.indexes_added or self.indexes_removed or \
-               self.constraints_added or self.constraints_removed
+               self.constraints_added or self.constraints_removed)
 
 
 #: A plan describes how the database will execute your statement.
@@ -419,13 +418,6 @@ def __init__(self, driver):
         self.transaction = None
         self.last_result = None
 
-    def __del__(self):
-        try:
-            if not self.connection.closed:
-                self.connection.close()
-        except AttributeError:
-            pass
-
     def __enter__(self):
         return self
 
@@ -480,7 +472,7 @@ def close(self):
         """ Recycle this session through the driver it came from.
         """
         if self.last_result:
-            self.last_result.consume()
+            self.last_result.buffer()
         self.driver.recycle(self)
 
     def begin_transaction(self):

neo4j/v1/session.py

@@ -25,14 +25,13 @@
 of these classes.
 """
 
-
 from .packstream import Structure
 
 
 class Entity(object):
     """ Base class for Node and Relationship.
     """
-    identity = None
+    id = None
     properties = None
 
     def __init__(self, properties=None, **kwproperties):
@@ -41,15 +40,15 @@ def __init__(self, properties=None, **kwproperties):
 
     def __eq__(self, other):
         try:
-            return self.identity == other.identity
+            return self.id == other.id
         except AttributeError:
             return False
 
     def __ne__(self, other):
         return not self.__eq__(other)
 
     def __hash__(self):
-        return hash(self.identity)
+        return hash(self.id)
 
     def __len__(self):
         return len(self.properties)
@@ -82,18 +81,18 @@ class Node(Entity):
     labels = None
 
     @classmethod
-    def hydrate(cls, identity, labels, properties=None):
+    def hydrate(cls, id_, labels, properties=None):
         inst = cls(labels, properties)
-        inst.identity = identity
+        inst.id = id_
         return inst
 
     def __init__(self, labels=None, properties=None, **kwproperties):
         super(Node, self).__init__(properties, **kwproperties)
         self.labels = set(labels or set())
 
     def __repr__(self):
-        return "<Node identity=%r labels=%r properties=%r>" % \
-               (self.identity, self.labels, self.properties)
+        return "<Node id=%r labels=%r properties=%r>" % \
+               (self.id, self.labels, self.properties)
 
 
 class BaseRelationship(Entity):
@@ -113,9 +112,9 @@ class Relationship(BaseRelationship):
     end = None
 
     @classmethod
-    def hydrate(cls, identity, start, end, type, properties=None):
+    def hydrate(cls, id_, start, end, type, properties=None):
         inst = cls(start, end, type, properties)
-        inst.identity = identity
+        inst.id = id_
         return inst
 
     def __init__(self, start, end, type, properties=None, **kwproperties):
@@ -126,12 +125,12 @@ def __init__(self, start, end, type, properties=None, **kwproperties):
         self.end = end
 
     def __repr__(self):
-        return "<Relationship identity=%r start=%r end=%r type=%r properties=%r>" % \
-               (self.identity, self.start, self.end, self.type, self.properties)
+        return "<Relationship id=%r start=%r end=%r type=%r properties=%r>" % \
+               (self.id, self.start, self.end, self.type, self.properties)
 
     def unbind(self):
         inst = UnboundRelationship(self.type, self.properties)
-        inst.identity = self.identity
+        inst.id = self.id
         return inst
 
 
@@ -140,21 +139,21 @@ class UnboundRelationship(BaseRelationship):
     """
 
     @classmethod
-    def hydrate(cls, identity, type, properties=None):
+    def hydrate(cls, id_, type, properties=None):
         inst = cls(type, properties)
-        inst.identity = identity
+        inst.id = id_
         return inst
 
     def __init__(self, type, properties=None, **kwproperties):
         super(UnboundRelationship, self).__init__(type, properties, **kwproperties)
 
     def __repr__(self):
-        return "<UnboundRelationship identity=%r type=%r properties=%r>" % \
-               (self.identity, self.type, self.properties)
+        return "<UnboundRelationship id=%r type=%r properties=%r>" % \
+               (self.id, self.type, self.properties)
 
     def bind(self, start, end):
         inst = Relationship(start, end, self.type, self.properties)
-        inst.identity = self.identity
+        inst.id = self.id
         return inst
 
 
@@ -174,9 +173,9 @@ 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.identity, next_node.identity))
+                entities.append(rels[rel_index - 1].bind(last_node.id, next_node.id))
             else:
-                entities.append(rels[-rel_index - 1].bind(next_node.identity, last_node.identity))
+                entities.append(rels[-rel_index - 1].bind(next_node.id, last_node.id))
             entities.append(next_node)
             last_node = next_node
         return cls(*entities)
@@ -187,7 +186,7 @@ def __init__(self, start_node, *rels_and_nodes):
 
     def __repr__(self):
         return "<Path start=%r end=%r size=%s>" % \
-               (self.start.identity, self.end.identity, len(self))
+               (self.start.id, self.end.id, len(self))
 
     def __eq__(self, other):
         try:

neo4j/v1/types.py

@@ -23,8 +23,8 @@
 failing_features = {}
 
 
-def before_all(context):
-    context.config.setup_logging()
+# def before_all(context):
+#     context.config.setup_logging()
 
 
 def before_feature(context, feature):
@@ -34,8 +34,11 @@ def before_feature(context, feature):
 
 
 def before_scenario(context, scenario):
+    context.runners = []
     if "reset_database" in scenario.tags:
-        tck_util.send_string("MATCH (n) DETACH DELETE n")
+        session = tck_util.driver.session()
+        session.run("MATCH (n) DETACH DELETE n")
+        session.close()
     if "equality_test" in scenario.tags:
         context.values = {}
 
@@ -59,8 +62,10 @@ def after_all(context):
         raise Exception("\tTCK FAILED!")
 
 
-
 def after_scenario(context, scenario):
-    if scenario.status != "passed":
-        raise Exception("%s did not pass" %scenario)
+    pass
+    for runner in tck_util.runners:
+        runner.close()
+    # if scenario.status != "passed":
+    #     raise Exception("%s did not pass" %scenario)
 

test/tck/environment.py

@@ -181,19 +181,21 @@ def get_path(string_path):
     string_path = string_path[1:-1]
     n, string_path = get_node(string_path)
     list_of_nodes_and_rel = [n]
-    n.identity = ++id
+    id+=1
+    n.id = id
     while string_path != '':
         r, string_path, point_up = get_relationship(string_path)
         n, string_path = get_node(string_path)
-        n.identity = ++id
+        id+=1
+        n.id = id
         if point_up:
-            r.start = list_of_nodes_and_rel[-1].identity
-            r.end = n.identity
-            r.identity = 0
+            r.start = list_of_nodes_and_rel[-1].id
+            r.end = n.id
+            r.id = 0
         else:
-            r.start = n.identity
-            r.end = list_of_nodes_and_rel[-1].identity
-            r.identity = 0
+            r.start = n.id
+            r.end = list_of_nodes_and_rel[-1].id
+            r.id = 0
         list_of_nodes_and_rel.append(r)
         list_of_nodes_and_rel.append(n)
     path = Path(list_of_nodes_and_rel[0], *list_of_nodes_and_rel[1:])

test/tck/resultparser.py

@@ -24,6 +24,7 @@
 
 from behave import *
 
+from test.tck import tck_util
 from test.tck.resultparser import parse_values
 from test.tck.tck_util import to_unicode, Type, send_string, send_parameters, string_to_type
 
@@ -33,7 +34,9 @@
 
 @given("A running database")
 def step_impl(context):
-    send_string("RETURN 1")
+    session = tck_util.driver.session()
+    session.run("RETURN 1")
+    session.close()
 
 
 @given("a value (?P<input>.+)")
@@ -80,22 +83,21 @@ def step_impl(context, size, type):
 
 @when("the driver asks the server to echo this (?P<unused>.+) back")
 def step_impl(context, unused):
-    context.results = [ send_string("RETURN " + as_cypher_text(context.expected)), send_parameters("RETURN {input}", {'input': context.expected})]
+    str_runner = tck_util.Runner("RETURN " + as_cypher_text(context.expected)).run()
+    param_runner = tck_util.Runner("RETURN {input}", {'input': context.expected}).run()
+    context.runners += [str_runner, param_runner]
+    context.results = [str_runner.result, param_runner.result]
 
 
 @step("the value given in the result should be the same as what was sent")
 def step_impl(context):
     assert len(context.results) > 0
-    print(context.results[0])
-    print(list(context.results[0]))
     for result in context.results:
-        print(result)
-        for record in result:
-            print(record)
-        assert len(list(result)) == 1
-        result_value = result.record().values()[0]
+        records = list(result)
+        assert len(records) == 1
+        assert len(records[0].values()) == 1
+        result_value = records[0].values()[0]
         assert result_value == context.expected
-        assert result.at_end()
 
 
 def as_cypher_text(expected):