Added statement result tck tests

Author: RagnarW

neo4j/v1/connection.py

@@ -31,6 +31,8 @@
 from socket import create_connection, SHUT_RDWR, error as SocketError
 from struct import pack as struct_pack, unpack as struct_unpack, unpack_from as struct_unpack_from
 
+import errno
+
 from .constants import DEFAULT_PORT, DEFAULT_USER_AGENT, KNOWN_HOSTS, MAGIC_PREAMBLE, \
     TRUST_DEFAULT, TRUST_ON_FIRST_USE
 from .compat import hex2
@@ -374,6 +376,8 @@ def connect(host, port=None, ssl_context=None, **config):
     """
 
     # Establish a connection to the host and port specified
+    # Catches refused connections see:
+    # https://docs.python.org/2/library/errno.html
     port = port or DEFAULT_PORT
     if __debug__: log_info("~~ [CONNECT] %s %d", host, port)
     try:

neo4j/v1/session.py

@@ -103,13 +103,12 @@ class Driver(object):
     def __init__(self, url, **config):
         self.url = url
         parsed = urlparse(self.url)
-        transports = ['bolt']
-        if parsed.scheme in transports:
+        if parsed.scheme == "bolt":
             self.host = parsed.hostname
             self.port = parsed.port
         else:
-            raise ProtocolError("Unsupported transport: '%s' in url: '%s'. Supported transports are: '%s'." %
-                                (parsed.scheme, url, transports))
+            raise ProtocolError("Unsupported URI scheme: '%s' in url: '%s'. Currently only supported 'bolt'." %
+                                (parsed.scheme, url))
         self.config = config
         self.max_pool_size = config.get("max_pool_size", DEFAULT_MAX_POOL_SIZE)
         self.session_pool = deque()
@@ -241,7 +240,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()
-        return self._keys
+        return tuple(self._keys)
 
     def buffer(self):
         if self.connection and not self.connection.closed:
@@ -264,9 +263,9 @@ def single(self):
         records = list(self)
         num_records = len(records)
         if num_records == 0:
-            raise ResultError("No records found in stream")
+            raise ResultError("Cannot retrieve a single record, because this result is empty.")
         elif num_records != 1:
-            raise ResultError("Multiple records found in stream")
+            raise ResultError("Expected a result with a single record, but this result contains at least one more.")
         else:
             return records[0]
 
@@ -486,9 +485,11 @@ def run(self, statement, parameters=None):
         :rtype: :class:`.StatementResult`
         """
         if self.transaction:
-            raise ProtocolError("Please close the currently open transaction object before running more "
-                                "statements/transactions in the current session.")
+            raise ProtocolError("Statements cannot be run directly on a session with an open transaction;"
+                                " either run from within the transaction or use a different session.")
+        return self._run(statement, parameters)
 
+    def _run(self, statement, parameters=None):
         # Ensure the statement is a Unicode value
         if isinstance(statement, bytes):
             statement = statement.decode("UTF-8")
@@ -521,6 +522,8 @@ def close(self):
         """
         if self.last_result:
             self.last_result.buffer()
+        if self.transaction:
+            self.transaction.close()
         self.driver.recycle(self)
 
     def begin_transaction(self):
@@ -529,8 +532,8 @@ def begin_transaction(self):
         :return: new :class:`.Transaction` instance.
         """
         if self.transaction:
-            raise ProtocolError("Please close the currently open transaction object before running more "
-                                "statements/transactions in the current session.")
+            raise ProtocolError("You cannot begin a transaction on a session with an open transaction;"
+                                " either run from within the transaction or use a different session.")
         self.transaction = Transaction(self)
         return self.transaction
 
@@ -558,7 +561,7 @@ class Transaction(object):
 
     def __init__(self, session):
         self.session = session
-        self.session.run("BEGIN")
+        self.session._run("BEGIN")
 
     def __enter__(self):
         return self
@@ -576,7 +579,7 @@ def run(self, statement, parameters=None):
         :return:
         """
         assert not self.closed
-        return self.session.run(statement, parameters)
+        return self.session._run(statement, parameters)
 
     def commit(self):
         """ Mark this transaction as successful and close in order to
@@ -597,9 +600,9 @@ def close(self):
         """
         assert not self.closed
         if self.success:
-            self.session.run("COMMIT")
+            self.session._run("COMMIT")
         else:
-            self.session.run("ROLLBACK")
+            self.session._run("ROLLBACK")
         self.closed = True
         self.session.transaction = None
 

runtests.sh

@@ -83,7 +83,7 @@ echo ""
 
 TEST_RUNNER="coverage run -m ${UNITTEST} discover -vfs ${TEST}"
 EXAMPLES_RUNNER="coverage run -m ${UNITTEST} discover -vfs examples"
-BEHAVE_RUNNER="behave --tags=-db --tags=-in_dev test/tck"
+BEHAVE_RUNNER="behave --tags=-db --tags=-tls --tags=-fixed_session_pool test/tck"
 
 if [ ${RUNNING} -eq 1 ]
 then
@@ -112,4 +112,4 @@ else
 
     fi
 
-fi
+fi

test/tck/environment.py

@@ -59,7 +59,6 @@ def after_all(context):
 
 
 def after_scenario(context, scenario):
-    pass
     for runner in tck_util.runners:
         runner.close()
 

test/tck/resultparser.py

@@ -21,7 +21,7 @@
 import json
 import re
 from neo4j.v1 import Node, Relationship, Path
-from tck_util import TestValue
+from test_value import TestValue
 
 
 def parse_values_to_comparable(row):

test/tck/steps/cypher_compability_steps.py

@@ -21,8 +21,7 @@
 from behave import *
 
 from test.tck import tck_util
-from test.tck.tck_util import TestValue
-from test.tck.resultparser import parse_values, parse_values_to_comparable
+from test.tck.resultparser import parse_values
 
 use_step_matcher("re")
 
@@ -54,51 +53,10 @@ def step_impl(context, statement):
 
 @then("result")
 def step_impl(context):
-    expected = table_to_comparable_result(context.table)
+    expected = tck_util.table_to_comparable_result(context.table)
     assert(len(context.results) > 0)
     for result in context.results:
         records = list(result)
-        given = driver_result_to_comparable_result(records)
-        if not unordered_equal(given, expected):
+        given = tck_util.driver_result_to_comparable_result(records)
+        if not tck_util.unordered_equal(given, expected):
             raise Exception("Does not match given: \n%s expected: \n%s" % (given, expected))
-
-
-def _driver_value_to_comparable(val):
-    if isinstance(val, list):
-        l = [_driver_value_to_comparable(v) for v in val]
-        return l
-    else:
-        return TestValue(val)
-
-
-def table_to_comparable_result(table):
-    result = []
-    keys = table.headings
-    for row in table:
-        result.append(
-                {keys[i]: parse_values_to_comparable(row[i]) for i in range(len(row))})
-    return result
-
-
-def driver_result_to_comparable_result(result):
-    records = []
-    for record in result:
-        records.append({key: _driver_value_to_comparable(record[key]) for key in record})
-    return records
-
-
-def unordered_equal(given, expected):
-    l1 = given[:]
-    l2 = expected[:]
-    assert isinstance(l1, list)
-    assert isinstance(l2, list)
-    assert len(l1) == len(l2)
-    for d1 in l1:
-        size = len(l2)
-        for d2 in l2:
-            if d1 == d2:
-                l2.remove(d2)
-                break
-        if size == len(l2):
-            return False
-    return True

test/tck/steps/driver_result_api_steps.py

@@ -63,8 +63,6 @@ def step_impl(context, expected):
 def step_impl(context):
     for summary in context.summaries:
         for row in context.table:
-            print(row[0].replace(" ","_"))
-            print(getattr(summary.counters, row[0].replace(" ","_")))
             assert getattr(summary.counters, row[0].replace(" ","_")) == parse_values(row[1])
 
 

test/tck/steps/errror_reporting_steps.py renamed to test/tck/steps/error_reporting_steps.py

@@ -23,7 +23,7 @@
 from neo4j.v1.exceptions import ProtocolError, CypherError
 from test.tck import tck_util
 
-from neo4j.v1 import compat, GraphDatabase, basic_auth
+from neo4j.v1 import GraphDatabase
 
 use_step_matcher("re")
 
@@ -45,6 +45,8 @@ def step_impl(context):
         context.session.run("CREATE (:n)")
     except Exception as e:
         context.exception = e
+    finally:
+        context.session.close()
 
 
 @step("I start a new `Transaction` with the same session before closing the previous")
@@ -53,12 +55,16 @@ def step_impl(context):
         context.session.begin_transaction()
     except Exception as e:
         context.exception = e
+    finally:
+        context.session.close()
 
 
 @step("I run a non valid cypher statement")
 def step_impl(context):
     try:
-        context.driver.session().run("NOT VALID").consume()
+        s = context.driver.session()
+        print(s.transaction)
+        s.run("NOT VALID").consume()
     except Exception as e:
         context.exception = e
 
@@ -83,6 +89,7 @@ def step_impl(context):
 
 @step("it throws a `ClientException`")
 def step_impl(context):
+    print(context.exception)
     assert context.exception is not None
     assert type(context.exception) == ProtocolError or type(context.exception) == CypherError
     assert isinstance(context.exception, ProtocolError) or isinstance(context.exception, CypherError)