Merge branch '1.0' into 1.0-tls

Conflicts:
	neo4j/v1/session.py
	test/test_session.py

Author: technige

docs/source/index.rst

@@ -32,7 +32,7 @@ Session API
 .. autoclass:: neo4j.v1.ResultSummary
    :members:
 
-.. autoclass:: neo4j.v1.StatementStatistics
+.. autoclass:: neo4j.v1.Counters
    :members:
 
 

examples/test_examples.py

@@ -19,16 +19,17 @@
 # limitations under the License.
 
 
-from unittest import TestCase
+from test.util import ServerTestCase
 
 # tag::minimal-example-import[]
 from neo4j.v1 import GraphDatabase
 # end::minimal-example-import[]
 
 
-class FreshDatabaseTestCase(TestCase):
+class FreshDatabaseTestCase(ServerTestCase):
 
     def setUp(self):
+        ServerTestCase.setUp(self)
         session = GraphDatabase.driver("bolt://localhost").session()
         session.run("MATCH (n) DETACH DELETE n")
         session.close()
@@ -43,9 +44,9 @@ def test_minimal_working_example(self):
 
         session.run("CREATE (neo:Person {name:'Neo', age:23})")
 
-        cursor = session.run("MATCH (p:Person) WHERE p.name = 'Neo' RETURN p.age")
-        while cursor.next():
-            print("Neo is %d years old." % cursor["p.age"])
+        result = session.run("MATCH (p:Person) WHERE p.name = 'Neo' RETURN p.age")
+        while result.next():
+            print("Neo is %d years old." % result["p.age"])
 
         session.close()
         # end::minimal-example[]
@@ -104,34 +105,34 @@ def test_result_cursor(self):
         session = driver.session()
         # tag::result-cursor[]
         search_term = "hammer"
-        cursor = session.run("MATCH (tool:Tool) WHERE tool.name CONTAINS {term} "
+        result = session.run("MATCH (tool:Tool) WHERE tool.name CONTAINS {term} "
                              "RETURN tool.name", {"term": search_term})
         print("List of tools called %r:" % search_term)
-        while cursor.next():
-            print(cursor["tool.name"])
+        while result.next():
+            print(result["tool.name"])
         # end::result-cursor[]
         session.close()
 
     def test_cursor_nesting(self):
         driver = GraphDatabase.driver("bolt://localhost")
         session = driver.session()
         # tag::retain-result-query[]
-        cursor = session.run("MATCH (person:Person) WHERE person.dept = {dept} "
+        result = session.run("MATCH (person:Person) WHERE person.dept = {dept} "
                              "RETURN id(person) AS minion", {"dept": "IT"})
-        while cursor.next():
+        while result.next():
             session.run("MATCH (person) WHERE id(person) = {id} "
                         "MATCH (boss:Person) WHERE boss.name = {boss} "
-                        "CREATE (person)-[:REPORTS_TO]->(boss)", {"id": cursor["minion"], "boss": "Bob"})
+                        "CREATE (person)-[:REPORTS_TO]->(boss)", {"id": result["minion"], "boss": "Bob"})
         # end::retain-result-query[]
         session.close()
 
     def test_result_retention(self):
         driver = GraphDatabase.driver("bolt://localhost")
         session = driver.session()
         # tag::retain-result-process[]
-        cursor = session.run("MATCH (person:Person) WHERE person.dept = {dept} "
+        result = session.run("MATCH (person:Person) WHERE person.dept = {dept} "
                              "RETURN id(person) AS minion", {"dept": "IT"})
-        minion_records = list(cursor.stream())
+        minion_records = list(result.stream())
 
         for record in minion_records:
             session.run("MATCH (person) WHERE id(person) = {id} "
@@ -148,10 +149,10 @@ def test_transaction_commit(self):
         tx.run("CREATE (p:Person {name: 'The One'})")
         tx.commit()
         # end::transaction-commit[]
-        cursor = session.run("MATCH (p:Person {name: 'The One'}) RETURN count(p)")
-        assert cursor.next()
-        assert cursor["count(p)"] == 1
-        assert cursor.at_end()
+        result = session.run("MATCH (p:Person {name: 'The One'}) RETURN count(p)")
+        assert result.next()
+        assert result["count(p)"] == 1
+        assert result.at_end
         session.close()
 
     def test_transaction_rollback(self):
@@ -162,30 +163,33 @@ def test_transaction_rollback(self):
         tx.run("CREATE (p:Person {name: 'The One'})")
         tx.rollback()
         # end::transaction-rollback[]
-        cursor = session.run("MATCH (p:Person {name: 'The One'}) RETURN count(p)")
-        assert cursor.next()
-        assert cursor["count(p)"] == 0
-        assert cursor.at_end()
+        result = session.run("MATCH (p:Person {name: 'The One'}) RETURN count(p)")
+        assert result.next()
+        assert result["count(p)"] == 0
+        assert result.at_end
         session.close()
 
     def test_result_summary_query_profile(self):
         driver = GraphDatabase.driver("bolt://localhost")
         session = driver.session()
         # tag::result-summary-query-profile[]
-        cursor = session.run("PROFILE MATCH (p:Person {name: {name}}) "
+        result = session.run("PROFILE MATCH (p:Person {name: {name}}) "
                              "RETURN id(p)", {"name": "The One"})
-        summary = cursor.summarize()
-        print(summary.statement_type)
-        print(summary.profile)
+        while result.next():
+            pass  # skip the records to get to the summary
+        print(result.summary.statement_type)
+        print(result.summary.profile)
         # end::result-summary-query-profile[]
         session.close()
 
     def test_result_summary_notifications(self):
         driver = GraphDatabase.driver("bolt://localhost")
         session = driver.session()
         # tag::result-summary-notifications[]
-        summary = session.run("EXPLAIN MATCH (a), (b) RETURN a,b").summarize()
-        for notification in summary.notifications:
+        result = session.run("EXPLAIN MATCH (a), (b) RETURN a,b")
+        while result.next():
+            pass  # skip the records to get to the summary
+        for notification in result.summary.notifications:
             print(notification)
         # end::result-summary-notifications[]
         session.close()

neo4j/__main__.py

@@ -75,8 +75,8 @@ def main():
                         stdout.write("%s\r\n" % "\t".join(map(repr, record)))
                     if has_results:
                         stdout.write("\r\n")
-                    if args.summarize:
-                        summary = cursor.summarize()
+                    if args.summary:
+                        summary = cursor.summary
                         stdout.write("Statement      : %r\r\n" % summary.statement)
                         stdout.write("Parameters     : %r\r\n" % summary.parameters)
                         stdout.write("Statement Type : %r\r\n" % summary.statement_type)

neo4j/v1/connection.py

@@ -224,7 +224,7 @@ def on_failure(metadata):
         self.append(INIT, (self.user_agent,), response=response)
         self.send()
         while not response.complete:
-            self.fetch_next()
+            self.fetch()
 
     def __del__(self):
         self.close()
@@ -258,9 +258,9 @@ def on_failure(metadata):
 
         self.append(RESET, response=response)
         self.send()
-        fetch_next = self.fetch_next
+        fetch = self.fetch
         while not response.complete:
-            fetch_next()
+            fetch()
 
     def send(self):
         """ Send all queued messages to the server.
@@ -271,7 +271,7 @@ def send(self):
             raise ProtocolError("Cannot write to a defunct connection")
         self.channel.send()
 
-    def fetch_next(self):
+    def fetch(self):
         """ Receive exactly one message from the server.
         """
         if self.closed:
@@ -342,9 +342,8 @@ def match_or_trust(self, host, der_encoded_certificate):
             with open(self.path) as f_in:
                 for line in f_in:
                     known_host, _, known_cert = line.strip().partition(":")
+                    known_cert = known_cert.encode("utf-8")
                     if host == known_host:
-                        print("Received: %s" % base64_encoded_certificate)
-                        print("Known: %s" % known_cert)
                         return base64_encoded_certificate == known_cert
         # First use (no hosts match)
         try:

neo4j/v1/exceptions.py

@@ -38,3 +38,10 @@ def __init__(self, data):
         for key, value in data.items():
             if not key.startswith("_"):
                 setattr(self, key, value)
+
+
+class ResultError(Exception):
+    """ Raised when the cursor encounters a problem.
+    """
+
+    pass

neo4j/v1/session.py

@@ -34,7 +34,7 @@ class which can be used to obtain `Driver` instances that are used for
 from .compat import integer, string, urlparse
 from .connection import connect, Response, RUN, PULL_ALL
 from .constants import SECURITY_NONE, SECURITY_VERIFIED, SECURITY_DEFAULT
-from .exceptions import CypherError
+from .exceptions import CypherError, ResultError
 from .typesystem import hydrated
 
 
@@ -144,7 +144,7 @@ def __init__(self, connection, statement, parameters):
         self._keys = None
         self._connection = connection
         self._current = None
-        self._next = deque()
+        self._record_buffer = deque()
         self._position = -1
         self._summary = None
         self._consumed = False
@@ -166,38 +166,40 @@ def next(self):
         """ Advance to the next record, if available, and return a boolean
         to indicate whether or not the cursor has moved.
         """
-        if self._next:
-            values = self._next.popleft()
+        if self._record_buffer:
+            values = self._record_buffer.popleft()
             self._current = Record(self.keys(), tuple(map(hydrated, values)))
             self._position += 1
             return True
         elif self._consumed:
             return False
         else:
-            self._connection.fetch_next()
+            self._connection.fetch()
             return self.next()
 
     def record(self):
         """ Return the current record.
         """
         return self._current
 
+    @property
     def position(self):
         """ Return the current cursor position.
         """
         return self._position
 
+    @property
     def at_end(self):
         """ Return ``True`` if at the end of the record stream, ``False``
         otherwise.
         """
-        if self._next:
+        if self._record_buffer:
             return False
         elif self._consumed:
             return True
         else:
-            self._connection.fetch_next()
-            return self.at_end()
+            self._connection.fetch()
+            return self.at_end
 
     def stream(self):
         """ Yield all subsequent records.
@@ -216,7 +218,7 @@ def keys(self):
         """
         # Fetch messages until we have the header or a failure
         while self._keys is None and not self._consumed:
-            self._connection.fetch_next()
+            self._connection.fetch()
         return self._keys
 
     def get(self, item, default=None):
@@ -228,27 +230,33 @@ def get(self, item, default=None):
         except (IndexError, KeyError):
             return default
 
-    def summarize(self):
-        """ Consume the remainder of this result and produce a summary.
+    @property
+    def summary(self):
+        """ Return the summary from the trailing metadata. Note that this is
+        only available once the entire result stream has been consumed.
+        Attempting to access the summary before then will raise an error.
 
         :rtype: ResultSummary
+        :raises ResultError: if the entire result has not yet been consumed
         """
-        self._consume()
-        return self._summary
+        if self._consumed:
+            return self._summary
+        else:
+            raise ResultError("Summary not available until the entire result has been consumed")
 
     def _consume(self):
         # Consume the remainder of this result, triggering all appropriate callback functions.
-        fetch_next = self._connection.fetch_next
+        fetch = self._connection.fetch
         while not self._consumed:
-            fetch_next()
+            fetch()
 
     def _on_header(self, metadata):
         # Called on receipt of the result header.
         self._keys = metadata["fields"]
 
     def _on_record(self, values):
         # Called on receipt of each result record.
-        self._next.append(values)
+        self._record_buffer.append(values)
 
     def _on_footer(self, metadata):
         # Called on receipt of the result footer.
@@ -274,8 +282,8 @@ class ResultSummary(object):
     #: The type of statement (``'r'`` = read-only, ``'rw'`` = read/write).
     statement_type = None
 
-    #: A set of statistical information held in a :class:`.StatementStatistics` instance.
-    statistics = None
+    #: A set of statistical information held in a :class:`.Counters` instance.
+    counters = None
 
     #: A :class:`.Plan` instance
     plan = None
@@ -293,7 +301,7 @@ def __init__(self, statement, parameters, **metadata):
         self.statement = statement
         self.parameters = parameters
         self.statement_type = metadata.get("type")
-        self.statistics = StatementStatistics(metadata.get("stats", {}))
+        self.counters = Counters(metadata.get("stats", {}))
         if "plan" in metadata:
             self.plan = make_plan(metadata["plan"])
         if "profile" in metadata:
@@ -308,7 +316,7 @@ def __init__(self, statement, parameters, **metadata):
                                                    notification["description"], position))
 
 
-class StatementStatistics(object):
+class Counters(object):
     """ Set of statistics from a Cypher statement execution.
     """
 

runtests.sh

@@ -62,7 +62,8 @@ echo "Running tests with $(python --version)"
 pip install --upgrade -r ${DRIVER_HOME}/test_requirements.txt
 echo ""
 TEST_RUNNER="coverage run -m ${UNITTEST} discover -vfs ${TEST}"
-BEHAVE_RUNNER="behave --tags=-db,-in_dev test/tck"
+EXAMPLES_RUNNER="coverage run -m ${UNITTEST} discover -vfs examples"
+BEHAVE_RUNNER="behave --tags=-db --tags=-in_dev test/tck"
 if [ ${RUNNING} -eq 1 ]
 then
     ${TEST_RUNNER}

test/tck/configure_feature_files.py

@@ -56,4 +56,4 @@ def _download_tar(url, file_name):
         tar.close()
     except ImportError:
         from urllib import request
-        request.urlretrieve(url, file_name)
+        request.urlretrieve(url, file_name)

test/tck/environment.py

@@ -27,11 +27,15 @@ def before_all(context):
 
 def before_feature(context, feature):
     # Workaround. Behave has a different way of tagging than cucumber
-    if "reset_database" in feature.tags:
-        for scenario in feature.scenarios:
-            scenario.tags.append("reset_database")
-
+    for scenario in feature.scenarios:
+        scenario.tags += feature.tags
 
 def before_scenario(context, scenario):
     if "reset_database" in scenario.tags:
-        tck_util.send_string("MATCH (n) DETACH DELETE n")
+        tck_util.send_string("MATCH (n) DETACH DELETE n")
+
+
+def after_scenario(context, scenario):
+    if scenario.status != "passed":
+        raise Exception("%s did not pass" %scenario)
+