Added step file for Cypher compatibility suite. Also refactured test code

Author: RagnarW

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "neokit"]
-	path = neokit
-	url = https://github.com/nigelsmall/neokit.git

neokit

@@ -1 +1 @@
-Subproject commit db7ab3580be3f0e09fcb2352408750f45c14a70e
+Subproject commit 23ffc81c7a1a1f16369aa1cea71d77d256e57c8d

runtests.sh

@@ -62,8 +62,7 @@ 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}"
-EXAMPLES_RUNNER="coverage run -m ${UNITTEST} discover -vfs examples"
-BEHAVE_RUNNER="behave test/tck"
+BEHAVE_RUNNER="behave --tags=-db,-in_dev test/tck"
 if [ ${RUNNING} -eq 1 ]
 then
     ${TEST_RUNNER}

test/tck/environment.py

@@ -23,20 +23,18 @@
 from behave.log_capture import capture
 from test.tck import tck_util
 
+
 def before_all(context):
     context.config.setup_logging()
 
-def before_scenario(context,scenario):
-    #Empty database
-    tck_util.send_string("MATCH (n) DETACH DELETE n")
+
+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")
 
 
-@capture
-def after_scenario(context, scenario):
-    for step in scenario.steps:
-        if step.status == 'failed':
-            logging.error("Scenario :'%s' at step: '%s' failed! ", scenario.name, step.name)
-        if step.status == 'skipped':
-            logging.warn("Scenario :'%s' at step: '%s' was skipped! ", scenario.name, step.name)
-        if step.status == 'passed':
-            logging.debug("Scenario :'%s' at step: '%s' was passed! ", scenario.name, step.name)
+def before_scenario(context, scenario):
+    if "reset_database" in scenario.tags:
+        tck_util.send_string("MATCH (n) DETACH DELETE n")

test/tck/steps/bolt_type_steps.py renamed to test/tck/steps/bolt_compability_steps.py

@@ -18,12 +18,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import random
+import string
+
 from behave import *
-import json
 
 from neo4j.v1 import GraphDatabase
 from test.tck import tck_util
+from test.tck.tck_util import to_unicode
 
+from neo4j.v1 import compat
 use_step_matcher("re")
 
 
@@ -34,17 +38,17 @@ def step_impl(context):
 
 @given("a value (?P<input>.+) of type (?P<bolt_type>.+)")
 def step_impl(context, input, bolt_type):
-    context.expected = tck_util.get_bolt_value(bolt_type, input)
+    context.expected = get_bolt_value(bolt_type, input)
 
 
 @given("a value  of type (?P<bolt_type>.+)")
 def step_impl(context, bolt_type):
-    context.expected = tck_util.get_bolt_value(bolt_type, u' ')
+    context.expected = get_bolt_value(bolt_type, u' ')
 
 
 @given("a list value (?P<input>.+) of type (?P<bolt_type>.+)")
 def step_impl(context, input, bolt_type):
-    context.expected = tck_util.get_list_from_feature_file(input, bolt_type)
+    context.expected = get_list_from_feature_file(input, bolt_type)
 
 
 @given("an empty list L")
@@ -59,35 +63,35 @@ def step_impl(context):
 
 @given("a String of size (?P<size>\d+)")
 def step_impl(context, size):
-    context.expected = tck_util.get_random_string(int(size))
+    context.expected = get_random_string(int(size))
 
 
 @given("a List of size (?P<size>\d+) and type (?P<type>.+)")
 def step_impl(context, size, type):
-    context.expected = tck_util.get_list_of_random_type(int(size), type)
+    context.expected = get_list_of_random_type(int(size), type)
 
 
 @given("a Map of size (?P<size>\d+) and type (?P<type>.+)")
 def step_impl(context, size, type):
-    context.expected = tck_util.get_dict_of_random_type(int(size), type)
+    context.expected = get_dict_of_random_type(int(size), type)
 
 
 @step("adding a table of lists to the list L")
 def step_impl(context):
     for row in context.table:
-        context.L.append(tck_util.get_list_from_feature_file(row[1], row[0]))
+        context.L.append(get_list_from_feature_file(row[1], row[0]))
 
 
 @step("adding a table of values to the list L")
 def step_impl(context):
     for row in context.table:
-        context.L.append(tck_util.get_bolt_value(row[0], row[1]))
+        context.L.append(get_bolt_value(row[0], row[1]))
 
 
 @step("adding a table of values to the map M")
 def step_impl(context):
     for row in context.table:
-        context.M['a%d' % len(context.M)] = tck_util.get_bolt_value(row[0], row[1])
+        context.M['a%d' % len(context.M)] = get_bolt_value(row[0], row[1])
 
 
 @step("adding map M to list L")
@@ -98,7 +102,7 @@ def step_impl(context):
 @when("adding a table of lists to the map M")
 def step_impl(context):
     for row in context.table:
-        context.M['a%d' % len(context.M)] = tck_util.get_list_from_feature_file(row[1], row[0])
+        context.M['a%d' % len(context.M)] = get_list_from_feature_file(row[1], row[0])
 
 
 @step("adding a copy of map M to map M")
@@ -109,34 +113,26 @@ def step_impl(context):
 @when("the driver asks the server to echo this value back")
 def step_impl(context):
     context.results = {}
-    context.results["as_string"] = tck_util.send_string("RETURN " + tck_util.as_cypher_text(context.expected))
+    context.results["as_string"] = tck_util.send_string("RETURN " + as_cypher_text(context.expected))
     context.results["as_parameters"] = tck_util.send_parameters("RETURN {input}", {'input': context.expected})
 
 
 @when("the driver asks the server to echo this list back")
 def step_impl(context):
     context.expected = context.L
     context.results = {}
-    context.results["as_string"] = tck_util.send_string("RETURN " + tck_util.as_cypher_text(context.expected))
+    context.results["as_string"] = tck_util.send_string("RETURN " + as_cypher_text(context.expected))
     context.results["as_parameters"] = tck_util.send_parameters("RETURN {input}", {'input': context.expected})
 
 
 @when("the driver asks the server to echo this map back")
 def step_impl(context):
     context.expected = context.M
     context.results = {}
-    context.results["as_string"] = tck_util.send_string("RETURN " + tck_util.as_cypher_text(context.expected))
+    context.results["as_string"] = tck_util.send_string("RETURN " + as_cypher_text(context.expected))
     context.results["as_parameters"] = tck_util.send_parameters("RETURN {input}", {'input': context.expected})
 
 
-@then("the result returned from the server should be a single record with a single value")
-def step_impl(context):
-    assert context.results
-    for result in context.results.values():
-        assert len(result) == 1
-        assert len(result[0]) == 1
-
-
 @step("the value given in the result should be the same as what was sent")
 def step_impl(context):
     assert len(context.results) > 0
@@ -181,83 +177,96 @@ def step_impl(context):
     assert True
 
 
-@given("init: (?P<statement>.+);")
-def step_impl(context, statement):
-    tck_util.send_string(statement)
-
-
-@when("running: (?P<statement>.+);")
-def step_impl(context, statement):
-    context.results = {"as_string": tck_util.send_string(statement)}
-
-
-@given("an empty database")
-def step_impl(context):
-    tck_util.send_string("MATCH (n) DETACH DELETE n")
-
-
-@then("result should be a path p containing")
-def step_impl(context):
-    result = context.results["as_string"]
-    given = tck_util.result_to_set(result)
-    expected = tck_util.text_path_to_set(context.table)
-    if given != expected:
-        raise Exception("Path does not match given: %s expected: %s" % (given, expected))
-
-
-@then("result should be integer\(s\)")
-def step_impl(context):
-    result = context.results["as_string"]
-    given = tck_util.result_to_set(result)
-    expected = tck_util.text_int_to_set(context.table)
-    if given != expected:
-        raise Exception("Integers does not match given: %s expected: %s" % (given, expected))
-
-
-@then("result should be node\(s\)")
-def step_impl(context):
-    result = context.results["as_string"]
-    given = tck_util.result_to_set(result)
-    expected = tck_util.text_node_to_set(context.table)
-    if given != expected:
-        raise Exception("Nodes does not match given: %s expected: %s" % (given, expected))
-
-
-@then("result should be string\(s\)")
-def step_impl(context):
-    result = context.results["as_string"]
-    given = tck_util.result_to_set(result)
-    expected = tck_util.text_string_to_set(context.table)
-    if given != expected:
-        raise Exception("Strings does not match given: %s expected: %s" % (given, expected))
-
-
-@then("result should be relationship\(s\)")
-def step_impl(context):
-    result = context.results["as_string"]
-    given = tck_util.result_to_set(result)
-    expected = tck_util.text_relationship_to_set(context.table)
-    if given != expected:
-        raise Exception("Relationship does not match given: %s expected: %s" % (given, expected))
-
-
-@then("result should be empty")
-def step_impl(context):
-    assert context.results
-    for result in context.results.values():
-        assert len(result) == 0
+def get_bolt_value(type, value):
+    if type == 'Integer':
+        return int(value)
+    if type == 'Float':
+        return float(value)
+    if type == 'String':
+        return to_unicode(value)
+    if type == 'Null':
+        return None
+    if type == 'Boolean':
+        return bool(value)
+    raise ValueError('No such type : %s' % type)
+
+
+def as_cypher_text(expected):
+    if expected is None:
+        return "Null"
+    if isinstance(expected, (str, compat.string)):
+        return '"' + expected + '"'
+    if isinstance(expected, float):
+        return repr(expected).replace('+', '')
+    if isinstance(expected, list):
+        l = u'['
+        for i, val in enumerate(expected):
+            l += as_cypher_text(val)
+            if i < len(expected) - 1:
+                l += u','
+        l += u']'
+        return l
+    if isinstance(expected, dict):
+        d = u'{'
+        for i, (key, val) in enumerate(expected.items()):
+            d += to_unicode(key) + ':'
+            d += as_cypher_text(val)
+            if i < len(expected.items()) - 1:
+                d += u','
+        d += u'}'
+        return d
+    else:
+        return to_unicode(expected)
+
+
+def get_list_from_feature_file(string_list, bolt_type):
+    inputs = string_list.strip('[]')
+    inputs = inputs.split(',')
+    list_to_return = []
+    for value in inputs:
+        list_to_return.append(get_bolt_value(bolt_type, value))
+    return list_to_return
+
+
+def get_random_string(size):
+    return u''.join(
+            random.SystemRandom().choice(list(string.ascii_uppercase + string.digits + string.ascii_lowercase)) for _ in
+            range(size))
+
+
+def get_random_bool():
+    return bool(random.randint(0, 1))
+
+
+def _get_random_func(type):
+    def get_none():
+        return None
+
+    if type == 'Integer':
+        fu = random.randint
+        args = [-9223372036854775808, 9223372036854775808]
+    elif type == 'Float':
+        fu = random.random
+        args = []
+    elif type == 'String':
+        fu = get_random_string
+        args = [3]
+    elif type == 'Null':
+        fu = get_none
+        args = []
+    elif type == 'Boolean':
+        fu = get_random_bool
+        args = []
+    else:
+        raise ValueError('No such type : %s' % type)
+    return (fu, args)
 
 
-@then('result should be node "(?P<n1>.+)" node "(?P<n2>.+)" and int "(?P<len>\d+)"')
-def step_impl(context, n1, n2, len):
-    result = context.results["as_string"]
-    given = tck_util.result_to_set(result)
-    expected = tck_util.node_node_int_to_values(n1, n2, len)
-    if given != expected:
-        raise Exception("Mixed response does not match given: %s expected: %s" % (given, expected))
+def get_list_of_random_type(size, type):
+    fu, args = _get_random_func(type)
+    return [fu(*args) for _ in range(size)]
 
 
-@when('running "(?P<parameters>.+)": (?P<statement>.+);')
-def step_impl(context, parameters, statement):
-    parameters = json.loads(parameters)
-    context.results = {"as_string": tck_util.send_parameters(statement, parameters)}
+def get_dict_of_random_type(size, type):
+    fu, args = _get_random_func(type)
+    return {'a%d' % i: fu(*args) for i in range(size)}