Add Testkit support to DenoJS

Enabling the support for the acceptance tests to the generated DenoJS driver is a step
towards to release it as library.

Author: bigmontz

packages/bolt-connection/src/channel/browser/browser-channel.js

@@ -144,17 +144,26 @@ export default class WebSocketChannel {
     if (this._pending !== null) {
       this._pending.push(buffer)
     } else if (buffer instanceof ChannelBuffer) {
-      try {
-        this._ws.send(buffer._buffer)
-      } catch (error) {
-        if (this._ws.readyState !== WS_OPEN) {
-          // Websocket has been closed
-          this._handleConnectionError()
-        } else {
-          // Some other error occured
-          throw error
+      // We should wait for the connection state change before sending
+      setTimeout(() => {
+        try {
+          if (this._ws.readyState !== WS_OPEN){
+            console.log('WebSocket not open')
+            return;
+          }
+          this._ws.send(buffer._buffer)
+        } catch (error) {
+          if (this._ws.readyState !== WS_OPEN) {
+            // Websocket has been closed
+            this._handleConnectionError()
+          } else {
+            console.log('errror', error)
+            // Some other error occured
+            throw error
+          }
         }
-      }
+      }, 500)
+      console.log('after timeout')
     } else {
       throw newError("Don't know how to send buffer: " + buffer)
     }
@@ -166,14 +175,17 @@ export default class WebSocketChannel {
    */
   close () {
     return new Promise((resolve, reject) => {
-      if (this._ws && this._ws.readyState !== WS_CLOSED) {
-        this._open = false
-        this._clearConnectionTimeout()
-        this._ws.onclose = () => resolve()
-        this._ws.close()
-      } else {
-        resolve()
-      }
+      setTimeout(() => {
+        if (this._ws && this._ws.readyState !== WS_CLOSED && this._ws.readyState !== WS_CLOSING) {
+          this._open = false
+          this._clearConnectionTimeout()
+          this._ws.onclose = () => resolve()
+          this._ws.close()
+        } else {
+          resolve()
+        }
+      }, 500)
+      
     })
   }
 

packages/testkit-backend/package.json

@@ -10,8 +10,10 @@
   },
   "type": "module",
   "scripts": {
-    "build": "rollup src/index.js --config rollup.config.js",
-    "start": "node --version | grep -q v10. && node -r esm src/index.js || node --experimental-specifier-resolution=node src/index.js",
+    "build": "echo 'Error: no build script specified'",
+    "build::": "rollup src/index.js --config rollup.config.js",
+    "start::": "node --version | grep -q v10. && node -r esm src/index.js || node --experimental-specifier-resolution=node src/index.js",
+    "start": "deno run --allow-read --allow-write --allow-net --allow-env --allow-run src/index.deno.ts",
     "clean": "rm -fr node_modules public/index.js",
     "prepare": "npm run build",
     "node": "node"

packages/testkit-backend/src/cypher-native-binders.js

@@ -1,4 +1,4 @@
-import neo4j from './neo4j'
+import neo4j from './neo4j.deno.js'
 
 export function valueResponse (name, value) {
   return { name: name, data: { value: value } }

packages/testkit-backend/src/feature/common.js

@@ -1,6 +1,9 @@
-import tls from 'tls'
+
 
 const SUPPORTED_TLS = (() => {
+  const tls = {
+    DEFAULT_MAX_VERSION: false
+  }
   if (tls.DEFAULT_MAX_VERSION) {
     const min = Number(tls.DEFAULT_MIN_VERSION.split('TLSv')[1])
     const max = Number(tls.DEFAULT_MAX_VERSION.split('TLSv')[1])

packages/testkit-backend/src/feature/index.js

@@ -1,6 +1,6 @@
-import commonFeatures from './common'
-import rxFeatures from './rx'
-import asyncFeatures from './async'
+import commonFeatures from './common.js'
+import rxFeatures from './rx.js'
+import asyncFeatures from './async.js'
 
 const featuresByContext = new Map([
   ['async', asyncFeatures],

packages/testkit-backend/src/index.deno.ts

@@ -0,0 +1,138 @@
+import Context from './context.js';
+import { getShouldRunTest } from './skipped-tests/index.js';
+import neo4j from "../../neo4j-driver-deno/lib/mod.ts";
+import { createGetFeatures } from './feature/index.js';
+import * as handlers from './request-handlers.js';
+
+const listener = Deno.listen({ port: 9876 });
+let index = 0;
+const contexts = new Map<number, Context>();
+
+interface RequestHandler {
+  (c: Context, data: any, wire: any): void
+}
+
+interface RequestHandlerMap {
+  [key: string]: RequestHandler
+}
+
+addEventListener('uncaughtException', (event) => {
+  console.log('unhandled rejection', event);
+})
+
+// @ts-ignore
+const requestHandlers: RequestHandlerMap = handlers as RequestHandlerMap
+
+addEventListener('events.errorMonitor', (event) => {
+  console.log('something here ========================')
+})
+
+interface Backend {
+  openContext(contextId: number): void 
+  closeContext(contextId: number): void
+  handle(contextId: number, conn: Deno.Conn, request: { name: string, data: object }): void
+}
+
+function write(conn: Deno.Conn, response: object) {
+  const responseStr = JSON.stringify(response, (_, value) =>
+    typeof value === 'bigint' ? `${value}n` : value
+  )
+  const responseArr = ['#response begin', responseStr, '#response end'].join('\n') + '\n'
+  console.log('response', responseArr);
+  conn.write(new TextEncoder().encode(responseArr))
+    .catch(e => {
+      console.log('error writing to connection', e);
+    });
+}
+
+const descriptor = [] as string[]
+const shouldRunTest = getShouldRunTest(descriptor);
+const getFeatures = createGetFeatures(descriptor);
+
+const backend: Backend = {
+  openContext: (contextId) => {
+    console.log("Open context:", contextId);
+    contexts.set(contextId, new Context(shouldRunTest, getFeatures));
+  },
+  closeContext: (contextId) => {
+    console.log('Close context', contextId);
+    contexts.delete(contextId);
+  },
+  handle: (contextId, conn, req) => {
+    const { data, name } = req;
+    if (!contexts.has(contextId)) {
+      throw new Error(`Context ${contextId} does not exist`)
+    } else if (!(name in requestHandlers)) {
+      console.log('Unknown request: ' + name)
+      throw new Error(`Unknown request: ${name}`)
+    }
+
+    console.log('Handle', req.name, req.data);
+    
+    const handler: (c: Context, data: any, wire: any) => void = requestHandlers[name as string];
+
+    handler(contexts.get(contextId)!!, data, {
+      writeResponse: (response: object) => write(conn, response),
+      writeError: (e: Error) => {
+        console.log('writeError', e);
+        if (e.name && e instanceof neo4j.Neo4jError) {
+          if (contexts.has(contextId)) {
+            const id = contexts.get(contextId)!!.addError(e)
+            write(conn, { name: 'DriverError', data: { id, msg: e.message + ' (' + e.code + ')', code: e.code } })
+            return
+          } else {
+            console.log('Context does not exist', contextId, e)
+          }
+          return
+        }
+        write(conn, { name: 'BackendError', data: { msg: e.message } })
+
+      },
+      writeBackendError: (msg: string) => write(conn, { name: 'BackendError', data: { msg } })
+    });
+  }
+}
+
+for await (const conn of listener) {
+  const contextId = index++;
+  handleConnection(conn, contextId)
+}
+
+async function handleConnection( conn: Deno.Conn, contextId: number): Promise<void> {
+  backend.openContext(contextId);
+  let inRequest = false
+  let requestString = ''
+  for await (const message of Deno.iter(conn)) {
+    const rawTxtMessage = new TextDecoder().decode(message);
+    const lines = rawTxtMessage.split('\n');
+    for (const line of lines) {
+      switch (line) {
+        case '#request begin':
+          if(inRequest) {
+            throw new Error('Already in request');
+          }
+          inRequest = true;
+          break;
+        case '#request end':
+          if(!inRequest) {
+            throw new Error('Not in request');
+          }
+          const request = JSON.parse(requestString);
+          backend.handle(contextId, conn, request);
+          inRequest = false;
+          requestString = '';
+          break
+        case '':
+          // ignore empty lines
+          break;
+        default:
+          if(!inRequest) {
+            throw new Error('Not in request');
+          }
+          requestString += line;
+          break
+      }
+    }
+  }
+  backend.closeContext(contextId);
+}

packages/testkit-backend/src/neo4j.deno.js

@@ -0,0 +1,3 @@
+import neo4j from '../../neo4j-driver-deno/lib/mod.ts'
+
+export default neo4j

packages/testkit-backend/src/request-handlers.js

@@ -1,4 +1,4 @@
-import neo4j from './neo4j'
+import neo4j from './neo4j.deno.js'
 import { cypherToNative } from './cypher-native-binders.js'
 import * as responses from './responses.js'
 
@@ -52,7 +52,7 @@ export function NewDriver (context, data, wire) {
     userAgent,
     resolver,
     useBigInt: true,
-    logging: neo4j.logging.console(process.env.LOG_LEVEL || context.logLevel)
+    logging: neo4j.logging.console('debug')
   }
   if ('encrypted' in data) {
     config.encrypted = data.encrypted ? 'ENCRYPTION_ON' : 'ENCRYPTION_OFF'

packages/testkit-backend/src/skipped-tests/browser.js

@@ -1,4 +1,4 @@
-import skip, { ifEndsWith, ifEquals, ifStartsWith } from './skip'
+import skip, { ifEndsWith, ifEquals, ifStartsWith } from './skip.js'
 const skippedTests = [
   skip(
     "Browser doesn't support socket timeouts",

packages/testkit-backend/src/skipped-tests/common.js

@@ -1,21 +1,6 @@
-import skip, { ifEquals, ifEndsWith, endsWith, ifStartsWith, startsWith, not } from './skip'
+import skip, { ifEquals, ifEndsWith } from './skip'
 
 const skippedTests = [
-  skip(
-    'Driver does not return offset for old DateTime implementations',
-    ifStartsWith('stub.types.test_temporal_types.TestTemporalTypes')
-      .and(not(startsWith('stub.types.test_temporal_types.TestTemporalTypesV5')))
-      .and(endsWith('test_zoned_date_time')),
-    ifEquals('neo4j.datatypes.test_temporal_types.TestDataTypes.test_nested_datetime'),
-    ifEquals('neo4j.datatypes.test_temporal_types.TestDataTypes.test_should_echo_all_timezone_ids'),
-    ifEquals('neo4j.datatypes.test_temporal_types.TestDataTypes.test_cypher_created_datetime')
-  ),
-  skip(
-    'Using numbers out of bound',
-    ifEquals('neo4j.datatypes.test_temporal_types.TestDataTypes.test_should_echo_temporal_type'),
-    ifEquals('neo4j.datatypes.test_temporal_types.TestDataTypes.test_nested_duration'),
-    ifEquals('neo4j.datatypes.test_temporal_types.TestDataTypes.test_duration_components')
-  ),
   skip(
     'Testkit implemenation is deprecated',
     ifEquals('stub.basic_query.test_basic_query.TestBasicQuery.test_5x0_populates_node_only_element_id'),

packages/testkit-backend/src/skipped-tests/index.js

@@ -1,6 +1,6 @@
-import commonSkippedTests from './common'
-import browserSkippedTests from './browser'
-import rxSessionSkippedTests from './rx'
+import commonSkippedTests from './common.js'
+import browserSkippedTests from './browser.js'
+import rxSessionSkippedTests from './rx.js'
 
 const skippedTestsByContext = new Map([
   ['browser', browserSkippedTests],

packages/testkit-backend/src/skipped-tests/rx.js

@@ -1,4 +1,4 @@
-import { skip, ifEquals } from './skip'
+import { skip, ifEquals } from './skip.js'
 
 const skippedTests = [
   skip(