updated stepfiles to work with new result cursor

Author: RagnarW

test/tck/steps/bolt_compability_steps.py

@@ -80,15 +80,14 @@ 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 = {"as_string": send_string("RETURN " + as_cypher_text(context.expected)),
-                       "as_parameters": send_parameters("RETURN {input}", {'input': context.expected})}
+    context.results = [ send_string("RETURN " + as_cypher_text(context.expected)).stream(), send_parameters("RETURN {input}", {'input': context.expected}).stream()]
 
 
 @step("the value given in the result should be the same as what was sent")
 def step_impl(context):
     assert len(context.results) > 0
-    for result in context.results.values():
-        result_value = result[0].values()[0]
+    for result in context.results:
+        result_value = result.next().values()[0]
         assert result_value == context.expected
 
 

test/tck/steps/cypher_compability_steps.py

@@ -31,28 +31,30 @@ def step_impl(context, statement):
     send_string(statement)
 
 
-@when("running: (?P<statement>.+)")
+@step("running: (?P<statement>.+)")
 def step_impl(context, statement):
-    context.results = {"as_string": send_string(statement)}
+    context.rcs = [send_string(statement)]
+    context.results = [x.stream() for x in context.rcs]
 
 
-@then("result")
-def step_impl(context):
-    result = context.results["as_string"]
-    given = driver_result_to_comparable_result(result)
-    expected = table_to_comparable_result(context.table)
-    if not unordered_equal(given, expected):
-        raise Exception("Does not match given: \n%s expected: \n%s" % (given, expected))
-
-
-@when('running parametrized: (?P<statement>.+)')
+@step('running parametrized: (?P<statement>.+)')
 def step_impl(context, statement):
     assert len(context.table.rows) == 1
     keys = context.table.headings
     values = context.table.rows[0]
     parameters = {keys[i]: parse_values(values[i]) for i in range(len(keys))}
 
-    context.results = {"as_string": send_parameters(statement, parameters)}
+    context.rcs = [send_parameters(statement, parameters)]
+    context.results = [x.stream() for x in context.rcs]
+
+
+@then("result")
+def step_impl(context):
+    expected = table_to_comparable_result(context.table)
+    for result in context.results:
+        given = driver_result_to_comparable_result(result)
+        if not unordered_equal(given, expected):
+            raise Exception("Does not match given: \n%s expected: \n%s" % (given, expected))
 
 
 def _driver_value_to_comparable(val):

test/tck/steps/driver_result_api_steps.py

@@ -120,14 +120,26 @@ def step_impl(context, plan_type):
             assert getattr(plan, row[0].replace(" ", "_")) is not None
 
 
-@step("the summaries collection of `notifications` is empty")
+@step("the summaries `notifications` is empty list")
 def step_impl(context):
     for summary in context.summaries:
         assert len(summary.notifications) == 0
 
 
-@step("the summaries collection of `notifications` is not empty")
+@step("the summaries `notifications` has one notification with")
 def step_impl(context):
+
     for summary in context.summaries:
-        print(summary.notifications)
-        assert len(summary.notifications) != 0
+        assert len(summary.notifications) == 1
+        notification = summary.notifications[0]
+        for row in context.table:
+            if row[0] == 'position':
+                position = getattr(notification, row[0].replace(" ","_"))
+                expected_position = parse_values(row[1])
+                for position_key, value in expected_position.items():
+                    assert value == getattr(position, position_key.replace(" ", "_"))
+            else:
+                assert getattr(notification, row[0].replace(" ","_")) == parse_values(row[1])
+
+
+

test/tck/tck_util.py

@@ -23,20 +23,17 @@
 from neo4j.v1 import GraphDatabase
 
 driver = GraphDatabase.driver("bolt://localhost")
+session = driver.session()
 
 
 def send_string(text):
-    session = driver.session()
     cursor = session.run(text)
-    session.close()
-    return list(cursor.stream())
+    return cursor
 
 
 def send_parameters(statement, parameters):
-    session = driver.session()
     cursor = session.run(statement, parameters)
-    session.close()
-    return list(cursor.stream())
+    return cursor
 
 
 def to_unicode(val):