Improved Testkit integration

* Support for more testkit messages and parameters

 - StartTest
   + SkipTest
   + RunTest
 - NewDriver.userAgent
 - NewDriver.resolverRegistered
   + ResolverResolutionRequired
   + ResolverResolutionCompleted
 - ResultConsume

Made backend fail on receiving unexpected message parameters

* Testkitbackend sends neo4j error code

* Testkitbackend supports more NewDriver options

connectionTimeoutMs
domainNameResolverRegistered if it's False

* Testkitbackend supports VerifyConnectivity message

* More debug logging in testkitbackend

Author: robsdedude

testkitbackend/backend.py

@@ -14,17 +14,78 @@
 # 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 json import loads, dumps
 from inspect import getmembers, isfunction
-import testkitbackend.requests as requests
+from json import loads, dumps
+import logging
+import sys
+import traceback
+
 from neo4j.exceptions import Neo4jError, DriverError, ServiceUnavailable
 
+import testkitbackend.requests as requests
+
+handler = logging.StreamHandler(sys.stdout)
+handler.setLevel(logging.DEBUG)
+logging.getLogger("neo4j").addHandler(handler)
+logging.getLogger("neo4j").setLevel(logging.DEBUG)
+
+log = logging.getLogger("testkitbackend")
+log.addHandler(handler)
+log.setLevel(logging.DEBUG)
+
+
+class Request(dict):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._seen_keys = set()
+
+    def __getitem__(self, item):
+        self._seen_keys.add(item)
+        return super().__getitem__(item)
+
+    def get(self, item, default=None):
+        self._seen_keys.add(item)
+        return super(Request, self).get(item, default)
+
+    def mark_all_as_read(self, recursive=False):
+        self._seen_keys = set(self.keys())
+        if recursive:
+            for val in self.values():
+                if isinstance(val, Request):
+                    val.mark_all_as_read(recursive=True)
+
+    def mark_item_as_read(self, item, recursive=False):
+        self._seen_keys.add(item)
+        if recursive:
+            value = super().__getitem__(item)
+            if isinstance(value, Request):
+                value.mark_all_as_read(recursive=True)
+
+    def mark_item_as_read_if_equals(self, item, value, recursive=False):
+        if super().__getitem__(item) == value:
+            self.mark_item_as_read(item, recursive=recursive)
+
+    @property
+    def unseen_keys(self):
+        assert not any(isinstance(v, dict) and not isinstance(v, Request)
+                       for v in self.values())
+        unseen = set(self.keys()) - self._seen_keys
+        for k, v in self.items():
+            if isinstance(v, Request):
+                unseen.update(k + "." + u for u in v.unseen_keys)
+        return unseen
+
+    @property
+    def seen_all_keys(self):
+        return not self.unseen_keys
+
 
 class Backend:
     def __init__(self, rd, wr):
         self._rd = rd
         self._wr = wr
         self.drivers = {}
+        self.address_resolutions = {}
         self.sessions = {}
         self.results = {}
         self.errors = {}
@@ -61,30 +122,47 @@ def _process(self, request):
         """ Process a received request by retrieving handler that
         corresponds to the request name.
         """
-        request = loads(request)
-        if not isinstance(request, dict):
-            raise Exception("Request is not an object")
-        name = request.get('name', 'invalid')
-        handler = self._requestHandlers.get(name)
-        if not handler:
-            raise Exception("No request handler for " + name)
-        data = request["data"]
         try:
+            request = loads(request, object_pairs_hook=Request)
+            if not isinstance(request, Request):
+                raise Exception("Request is not an object")
+            name = request.get('name', 'invalid')
+            handler = self._requestHandlers.get(name)
+            if not handler:
+                raise Exception("No request handler for " + name)
+            data = request["data"]
+            log.info("<<< " + name + dumps(data))
             handler(self, data)
-        except Neo4jError or DriverError or ServiceUnavailable as e:
+            unsused_keys = request.unseen_keys
+            if unsused_keys:
+                raise NotImplementedError(
+                    "Backend does not support some properties of the " + name +
+                    " request: " + ", ".join(unsused_keys)
+                )
+        except (Neo4jError, DriverError) as e:
+            log.debug(traceback.format_exc())
+            if isinstance(e, Neo4jError):
+                msg = "" if e.message is None else str(e.message)
+            else:
+                msg = str(e.args[0]) if e.args else ""
+
             key = self.next_key()
             self.errors[key] = e
-            self.send_response("DriverError", {"id": key})
+            payload = {"id": key, "errorType": str(type(e)), "msg": msg}
+            if isinstance(e, Neo4jError):
+                payload["code"] = e.code
+            self.send_response("DriverError", payload)
         except Exception as e:
-            from traceback import print_exception
-            print_exception(type(e), e, e.__traceback__)
-            self.send_response("BackendError", {"msg": "%s: %s" % (e.__class__.__name__, e)})
+            traceback.print_exception(type(e), e, e.__traceback__)
+            self.send_response("BackendError",
+                               {"msg": "%s: %s" % (type(e), e)})
 
     def send_response(self, name, data):
         """ Sends a response to backend.
         """
         response = {"name": name, "data": data}
         response = dumps(response)
+        log.info(">>> " + name + dumps(data))
         self._wr.write(b"#response begin\n")
         self._wr.write(bytes(response+"\n", "utf-8"))
         self._wr.write(b"#response end\n")

testkitbackend/fromtestkit.py

@@ -15,43 +15,57 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-def toCypherAndParams(data):
-    cypher = data["cypher"]
+from neo4j.work.simple import Query
+
+
+def to_cypher_and_params(data):
+    from .backend import Request
     params = data["params"]
     # Optional
     if params is None:
-        return cypher, None
+        return data["cypher"], None
     # Transform the params to Python native
-    for p in params:
-        params[p] = toParam(params[p])
-    return cypher, params
+    params_dict = {p: to_param(params[p]) for p in params}
+    return data["cypher"], params_dict
+
+
+def to_meta_and_timeout(data):
+    from .backend import Request
+    metadata = data.get('txMeta', None)
+    if isinstance(metadata, Request):
+        metadata.mark_all_as_read()
+    timeout = data.get('timeout', None)
+    if timeout:
+        timeout = float(timeout) / 1000
+    return metadata, timeout
+
+
+def to_query_and_params(data):
+    cypher, param = to_cypher_and_params(data)
+    metadata, timeout = to_meta_and_timeout(data)
+    query = Query(cypher, metadata=metadata, timeout=timeout)
+    return query, param
 
 
-def toParam(m):
+def to_param(m):
     """ Converts testkit parameter format to driver (python) parameter
     """
-    data = m["data"]
+    value = m["data"]["value"]
     name = m["name"]
     if name == "CypherString":
-        return str(data["value"])
+        return str(value)
     if name == "CypherBool":
-        return bool(data["value"])
+        return bool(value)
     if name == "CypherInt":
-        return int(data["value"])
+        return int(value)
     if name == "CypherFloat":
-        return float(data["value"])
+        return float(value)
     if name == "CypherString":
-        return str(data["value"])
+        return str(value)
     if name == "CypherNull":
         return None
     if name == "CypherList":
-        ls = []
-        for x in data["value"]:
-            ls.append(toParam(x))
-        return ls
+        return [to_param(v) for v in value]
     if name == "CypherMap":
-        mp = {}
-        for k, v in data["value"].items():
-            mp[k] = toParam(v)
-        return mp
+        return {k: to_param(value[k]) for k in value}
     raise Exception("Unknown param type " + name)