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/TestValue.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python
+# -*- encoding: utf-8 -*-
+
+# Copyright (c) 2002-2016 "Neo Technology,"
+# Network Engine for Objects in Lund AB [http://neotechnology.com]
+#
+# This file is part of Neo4j.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from neo4j.v1 import Node, Relationship, Path
+from neo4j.v1 import string
+
+
+class TestValue:
+    content = None
+
+    def __init__(self, entity):
+        self.content = {}
+        if isinstance(entity, Node):
+            self.content = self.create_node(entity)
+        elif isinstance(entity, Relationship):
+            self.content = self.create_relationship(entity)
+        elif isinstance(entity, Path):
+            self.content = self.create_path(entity)
+        elif isinstance(entity, int) or isinstance(entity, float) or isinstance(entity,
+                                                                                (str, string)) or entity is None:
+            self.content['value'] = entity
+        else:
+            raise ValueError("Do not support object type: %s" % entity)
+
+    def __hash__(self):
+        return hash(repr(self))
+
+    def __eq__(self, other):
+        return self.content == other.content
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
+    def __repr__(self):
+        return str(self.content)
+
+    def create_node(self, entity):
+        content = {'properties': entity.properties, 'labels': entity.labels, 'obj': "node"}
+
+        return content
+
+    def create_path(self, entity):
+        content = {}
+        prev_id = entity.start.id
+        p = []
+        for i, rel in enumerate(list(entity)):
+            n = entity.nodes[i + 1]
+            current_id = n.id
+            if rel.start == prev_id and rel.end == current_id:
+                rel.start = i
+                rel.end = i + 1
+            elif rel.start == current_id and rel.end == prev_id:
+                rel.start = i + 1
+                rel.end = i
+            else:
+                raise ValueError(
+                    "Relationships end and start should point to surrounding nodes. Rel: %s N1id: %s N2id: %s. At entity#%s" % (
+                        rel, current_id, prev_id, i))
+            p += [self.create_relationship(rel, True), self.create_node(n)]
+            prev_id = current_id
+        content['path'] = p
+        content['obj'] = "path"
+        content['start'] = self.create_node(entity.start)
+        return content
+
+    def create_relationship(self, entity, include_start_end=False):
+        content = {'obj': "relationship"}
+        if include_start_end:
+            self.content['start'] = entity.start
+            self.content['end'] = entity.end
+        content['type'] = entity.type
+        content['properties'] = entity.properties
+        return content

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 TestValue 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)