Added statement result tck tests

Author: RagnarW

neo4j/v1/session.py

@@ -241,7 +241,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 +264,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]
 
@@ -478,16 +478,19 @@ def healthy(self):
         return None if connection.closed else not connection.defunct
 
     def run(self, statement, parameters=None):
+        if self.transaction:
+            raise ProtocolError("Please close the currently open transaction object before running more "
+                                "statements/transactions in the current session.")
+        return self._run(statement, parameters)
+
+    def _run(self, statement, parameters=None):
         """ Run a parameterised Cypher statement.
 
         :param statement: Cypher statement to execute
         :param parameters: dictionary of parameters
         :return: Cypher result
         :rtype: :class:`.StatementResult`
         """
-        if self.transaction:
-            raise ProtocolError("Please close the currently open transaction object before running more "
-                                "statements/transactions in the current session.")
 
         # Ensure the statement is a Unicode value
         if isinstance(statement, bytes):
@@ -521,6 +524,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):
@@ -558,7 +563,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 +581,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 +602,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=-in_dev --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)