[enh] #1084 WS2P: testing exchanges

app/lib/ws2p/WS2PConnection.ts

 import {Key, verify} from "../common-libs/crypto/keyring"
+import {WS2PMessageHandler} from "./impl/WS2PMessageHandler"
 const ws = require('ws')
 const nuuid = require('node-uuid');
 
@@ -179,7 +180,7 @@ export class WS2PPubkeyLocalAuth implements WS2PLocalAuth {
 }
 
 export interface WS2PRequest {
-  message:string
+  name:string
 }
 
 /**
@@ -209,7 +210,7 @@ export class WS2PConnection {
   constructor(
     private ws:any,
     private onWsOpened:Promise<void>,
-    private onDataMessage:(json:any, ws:any)=>void,
+    private messageHandler:WS2PMessageHandler,
     private localAuth:WS2PLocalAuth,
     private remoteAuth:WS2PRemoteAuth,
     private options:{
@@ -224,7 +225,7 @@ export class WS2PConnection {
 
   static newConnectionToAddress(
     address:string,
-    onDataMessage:(json:any, ws:any)=>void,
+    messageHandler:WS2PMessageHandler,
     localAuth:WS2PLocalAuth,
     remoteAuth:WS2PRemoteAuth,
     options:{
@@ -240,12 +241,12 @@ export class WS2PConnection {
     const onWsOpened:Promise<void> = new Promise(res => {
       websocket.on('open', () => res())
     })
-    return new WS2PConnection(websocket, onWsOpened, onDataMessage, localAuth, remoteAuth, options, expectedPub)
+    return new WS2PConnection(websocket, onWsOpened, messageHandler, localAuth, remoteAuth, options, expectedPub)
   }
 
   static newConnectionFromWebSocketServer(
     websocket:any,
-    onDataMessage:(json:any, ws:any)=>void,
+    messageHandler:WS2PMessageHandler,
     localAuth:WS2PLocalAuth,
     remoteAuth:WS2PRemoteAuth,
     options:{
@@ -257,7 +258,7 @@ export class WS2PConnection {
     },
     expectedPub:string = "") {
     const onWsOpened = Promise.resolve()
-    return new WS2PConnection(websocket, onWsOpened, onDataMessage, localAuth, remoteAuth, options, expectedPub)
+    return new WS2PConnection(websocket, onWsOpened, messageHandler, localAuth, remoteAuth, options, expectedPub)
   }
 
   get nbRequests() {
@@ -389,7 +390,8 @@ export class WS2PConnection {
 
                 // Request message
                 else if (data.reqId && typeof data.reqId === "string") {
-                  this.onDataMessage(data, this.ws)
+                  const body = await this.messageHandler.handleRequestMessage(data)
+                  this.ws.send(JSON.stringify({ resId: data.reqId, body }))
                 }
 
                 // Answer message
@@ -407,7 +409,7 @@ export class WS2PConnection {
                 // Push message
                 else {
                   this.nbPushsByRemoteCount++
-                  this.onDataMessage(data, this.ws)
+                  await this.messageHandler.handlePushMessage(data)
                 }
               }
             }

app/lib/ws2p/WS2PRequester.ts

+import {WS2PConnection} from "./WS2PConnection"
+
+enum WS2P_REQ {
+  CURRENT
+}
+
+export class WS2PRequester {
+
+  private constructor(
+    protected ws2pc:WS2PConnection) {}
+
+  static fromConnection(ws2pc:WS2PConnection) {
+    return new WS2PRequester(ws2pc)
+  }
+
+  getCurrent() {
+    return this.query(WS2P_REQ.CURRENT)
+  }
+
+  private query(req:WS2P_REQ) {
+    return this.ws2pc.request({
+      name: WS2P_REQ[req]
+    })
+  }
+}
\ No newline at end of file

app/lib/ws2p/WS2PResponder.ts

+import {WS2PReqMapper} from "./WS2PReqMapper"
+
+enum WS2P_REQ {
+  CURRENT
+}
+
+export enum WS2P_REQERROR {
+  UNKNOWN_REQUEST
+}
+
+export async function WS2PResponder(data:any, handler:WS2PReqMapper) {
+
+  /**********
+   * REQUEST
+   *********/
+  if (data.reqId && typeof data.reqId === "string") {
+
+    let body:any = {}
+
+    if (data.body && data.body.name) {
+      switch (data.body.name) {
+        case WS2P_REQ[WS2P_REQ.CURRENT]:
+          body = await handler.getCurrent()
+          break;
+        default:
+          throw Error(WS2P_REQERROR[WS2P_REQERROR.UNKNOWN_REQUEST])
+      }
+    }
+
+    return body
+  }
+
+  /**********
+   *  PUSH
+   *********/
+  else {
+
+  }
+}
\ No newline at end of file

app/lib/ws2p/impl/WS2PMessageHandler.ts

+import {WS2PResponse} from "./WS2PResponse"
+export interface WS2PMessageHandler {
+
+  handlePushMessage(json:any): Promise<void>
+  handleRequestMessage(json:any): Promise<WS2PResponse>
+}
\ No newline at end of file

app/lib/ws2p/impl/WS2PReqMapperByServer.ts

+import {Server} from "../../../../server"
+import {WS2PReqMapper} from "../interface/WS2PReqMapper"
+
+export class WS2PReqMapperByServer implements WS2PReqMapper {
+
+  private constructor(protected server:Server) {}
+
+  async getCurrent() {
+    return this.server.BlockchainService.current()
+  }
+}
\ No newline at end of file

app/lib/ws2p/impl/WS2PResponse.ts

+
+export interface WS2PResponse {
+}
\ No newline at end of file

app/lib/ws2p/interface/WS2PReqMapper.ts

+import {BlockDTO} from "../../dto/BlockDTO"
+
+export interface WS2PReqMapper {
+
+  getCurrent(): Promise<BlockDTO>
+}
\ No newline at end of file

test/integration/tools/toolbox.ts

@@ -15,11 +15,16 @@ import {ConfDTO} from "../../../app/lib/dto/ConfDTO"
 import {FileDAL} from "../../../app/lib/dal/fileDAL"
 import {MembershipDTO} from "../../../app/lib/dto/MembershipDTO"
 import {TransactionDTO} from "../../../app/lib/dto/TransactionDTO"
+import {Key} from "../../../app/lib/common-libs/crypto/keyring"
+import {WS2PConnection, WS2PPubkeyLocalAuth, WS2PPubkeyRemoteAuth} from "../../../app/lib/ws2p/WS2PConnection"
+import {WS2PResponse} from "../../../app/lib/ws2p/impl/WS2PResponse"
+import {WS2PMessageHandler} from "../../../app/lib/ws2p/impl/WS2PMessageHandler"
 
 const assert      = require('assert');
 const _           = require('underscore');
 const rp          = require('request-promise');
 const es          = require('event-stream');
+const WebSocketServer = require('ws').Server
 const httpTest    = require('../tools/http');
 const sync        = require('../tools/sync');
 const commit      = require('../tools/commit');
@@ -550,3 +555,41 @@ export class TestingServer {
     }
   }
 }
+
+export async function newWS2PBidirectionnalConnection(k1:Key, k2:Key, serverHandler:WS2PMessageHandler) {
+  let i = 1
+  let port = PORT++
+  const wss = new WebSocketServer({ port })
+  let s1:WS2PConnection
+  let c1:WS2PConnection
+  return await new Promise<{
+    p1:WS2PConnection,
+    p2:WS2PConnection,
+    wss:any
+  }>(resolveBefore => {
+    wss.on('connection', async (ws:any) => {
+      switch (i) {
+        case 1:
+          s1 = WS2PConnection.newConnectionFromWebSocketServer(ws, serverHandler, new WS2PPubkeyLocalAuth(k1), new WS2PPubkeyRemoteAuth(k1), {
+            connectionTimeout: 100,
+            requestTimeout: 100
+          });
+          s1.connect().catch((e:any) => console.error('WS2P: newConnectionFromWebSocketServer connection error'))
+          break;
+      }
+      resolveBefore({
+        p1: s1,
+        p2: c1,
+        wss
+      })
+      i++
+    })
+    c1 = WS2PConnection.newConnectionToAddress('localhost:' + port, new (class EmptyHandler implements WS2PMessageHandler {
+      async handlePushMessage(json: any): Promise<void> {
+      }
+      async handleRequestMessage(json: any): Promise<WS2PResponse> {
+        return {}
+      }
+    }), new WS2PPubkeyLocalAuth(k2), new WS2PPubkeyRemoteAuth(k2))
+  })
+}
\ No newline at end of file

test/integration/ws2p_connection.ts

@@ -7,6 +7,8 @@ import {
 } from "../../app/lib/ws2p/WS2PConnection"
 import {Key, verify} from "../../app/lib/common-libs/crypto/keyring"
 import {assertThrows} from "./tools/toolbox"
+import {WS2PMessageHandler} from "../../app/lib/ws2p/impl/WS2PMessageHandler"
+import {WS2PResponse} from "../../app/lib/ws2p/impl/WS2PResponse"
 const assert = require('assert');
 const WebSocketServer = require('ws').Server
 
@@ -35,8 +37,8 @@ describe('WS2P', () => {
       })
 
       it('should be able to create a connection', async () => {
-        const ws2p = WS2PConnection.newConnectionToAddress('localhost:20902', () => {}, new WS2PNoLocalAuth(), new WS2PNoRemoteAuth())
-        const res = await ws2p.request({ message: 'head' })
+        const ws2p = WS2PConnection.newConnectionToAddress('localhost:20902', new WS2PMutedHandler(), new WS2PNoLocalAuth(), new WS2PNoRemoteAuth())
+        const res = await ws2p.request({ name: 'head' })
         assert.deepEqual({ bla: 'aa' }, res)
       })
     })
@@ -86,39 +88,39 @@ describe('WS2P', () => {
 
       it('should refuse the connection if the server does not answer', async () => {
         const keypair = new Key('HgTTJLAQ5sqfknMq7yLPZbehtuLSsKj9CxWN7k8QvYJd', '51w4fEShBk1jCMauWu4mLpmDVfHksKmWcygpxriqCEZizbtERA6de4STKRkQBpxmMUwsKXRjSzuQ8ECwmqN1u2DP')
-        const ws2p = WS2PConnection.newConnectionToAddress('localhost:20903', () => {}, new WS2PPubkeyLocalAuth(keypair), new WS2PPubkeyRemoteAuth(keypair), {
+        const ws2p = WS2PConnection.newConnectionToAddress('localhost:20903', new WS2PMutedHandler(), new WS2PPubkeyLocalAuth(keypair), new WS2PPubkeyRemoteAuth(keypair), {
           connectionTimeout: 100,
           requestTimeout: 100
         })
-        await assertThrows(ws2p.request({ message: 'a' }), "WS2P connection timeout")
+        await assertThrows(ws2p.request({ name: 'a' }), "WS2P connection timeout")
       })
 
       it('should refuse the connection if the server answers with a wrong signature', async () => {
         const keypair = new Key('HgTTJLAQ5sqfknMq7yLPZbehtuLSsKj9CxWN7k8QvYJd', '51w4fEShBk1jCMauWu4mLpmDVfHksKmWcygpxriqCEZizbtERA6de4STKRkQBpxmMUwsKXRjSzuQ8ECwmqN1u2DP')
-        const ws2p = WS2PConnection.newConnectionToAddress('localhost:20903', () => {}, new WS2PPubkeyLocalAuth(keypair), new WS2PPubkeyRemoteAuth(keypair), {
+        const ws2p = WS2PConnection.newConnectionToAddress('localhost:20903', new WS2PMutedHandler(), new WS2PPubkeyLocalAuth(keypair), new WS2PPubkeyRemoteAuth(keypair), {
           connectionTimeout: 100,
           requestTimeout: 100
         })
-        await assertThrows(ws2p.request({ message: 'a' }), "Wrong signature from server ACK")
+        await assertThrows(ws2p.request({ name: 'a' }), "Wrong signature from server ACK")
       })
 
       it('should refuse the connection if the server refuses our signature', async () => {
         const keypair = new Key('HgTTJLAQ5sqfknMq7yLPZbehtuLSsKj9CxWN7k8QvYJd', '51w4fEShBk1jCMauWu4mLpmDVfHksKmWcygpxriqCEZizbtERA6de4STKRkQBpxmMUwsKXRjSzuQ8ECwmqN1u2DP')
-        const ws2p = WS2PConnection.newConnectionToAddress('localhost:20903', () => {}, new WS2PPubkeyLocalAuth(keypair), new WS2PPubkeyRemoteAuth(keypair), {
+        const ws2p = WS2PConnection.newConnectionToAddress('localhost:20903', new WS2PMutedHandler(), new WS2PPubkeyLocalAuth(keypair), new WS2PPubkeyRemoteAuth(keypair), {
           connectionTimeout: 100,
           requestTimeout: 100
         })
-        await assertThrows(ws2p.request({ message: 'a' }), "WS2P connection timeout")
+        await assertThrows(ws2p.request({ name: 'a' }), "WS2P connection timeout")
         assert.equal('Wrong signature from client CONNECT', clientAskError)
       })
 
       it('should accept the connection if the server answers with a good signature', async () => {
         const keypair = new Key('HgTTJLAQ5sqfknMq7yLPZbehtuLSsKj9CxWN7k8QvYJd', '51w4fEShBk1jCMauWu4mLpmDVfHksKmWcygpxriqCEZizbtERA6de4STKRkQBpxmMUwsKXRjSzuQ8ECwmqN1u2DP')
-        const ws2p = WS2PConnection.newConnectionToAddress('localhost:20903', () => {}, new WS2PPubkeyLocalAuth(keypair), new WS2PNoRemoteAuth(), {
+        const ws2p = WS2PConnection.newConnectionToAddress('localhost:20903', new WS2PMutedHandler(), new WS2PPubkeyLocalAuth(keypair), new WS2PNoRemoteAuth(), {
           connectionTimeout: 1000,
           requestTimeout: 1000
         })
-        const res = await ws2p.request({ message: 'head' })
+        const res = await ws2p.request({ name: 'head' })
         assert.deepEqual({ bla: 'aa' }, res)
       })
     })
@@ -138,21 +140,24 @@ describe('WS2P', () => {
         wss.on('connection', (ws:any) => {
           switch (i) {
             case 0:
-              s1 = WS2PConnection.newConnectionFromWebSocketServer(ws, (obj:any, ws:any) => {
-                if (obj.reqId) {
-                  ws.send(JSON.stringify({ resId: obj.reqId, body: { answer: 'world' } }))
+              s1 = WS2PConnection.newConnectionFromWebSocketServer(ws, new (class TmpHandler implements WS2PMessageHandler {
+                async handlePushMessage(json: any): Promise<void> {
+                }
+                async handleRequestMessage(json: any): Promise<WS2PResponse> {
+                  return { answer: 'world' }
                 }
-              }, new WS2PNoLocalAuth(), new WS2PNoRemoteAuth())
+              }), new WS2PNoLocalAuth(), new WS2PNoRemoteAuth())
               s1.connect().catch(e => console.error('WS2P: newConnectionFromWebSocketServer connection error'))
               break
             case 1:
               let j = 0
-              s2 = WS2PConnection.newConnectionFromWebSocketServer(ws, (obj:any, ws:any) => {
-                if (obj.reqId) {
-                  ws.send(JSON.stringify({ resId: obj.reqId, body: { answer: 'this is s2![j = ' + j + ']' } }))
-                  j++
+              s2 = WS2PConnection.newConnectionFromWebSocketServer(ws, new (class TmpHandler implements WS2PMessageHandler {
+                async handlePushMessage(json: any): Promise<void> {
                 }
-              }, new WS2PNoLocalAuth(), new WS2PNoRemoteAuth())
+                async handleRequestMessage(json: any): Promise<WS2PResponse> {
+                  return { answer: 'this is s2![j = ' + (j++) + ']' }
+                }
+              }), new WS2PNoLocalAuth(), new WS2PNoRemoteAuth())
               s2.connect().catch(e => console.error('WS2P: newConnectionFromWebSocketServer connection error'))
               break
           }
@@ -166,9 +171,9 @@ describe('WS2P', () => {
 
       it('should be able to create connections and make several requests', async () => {
         // connection 1
-        const c1 = WS2PConnection.newConnectionToAddress('localhost:20902', () => {}, new WS2PNoLocalAuth(), new WS2PNoRemoteAuth())
-        assert.deepEqual({ answer: 'world' }, await c1.request({ message: 'hello!' }))
-        assert.deepEqual({ answer: 'world' }, await c1.request({ message: 'hello2!' }))
+        const c1 = WS2PConnection.newConnectionToAddress('localhost:20902', new WS2PMutedHandler(), new WS2PNoLocalAuth(), new WS2PNoRemoteAuth())
+        assert.deepEqual({ answer: 'world' }, await c1.request({ name: 'hello!' }))
+        assert.deepEqual({ answer: 'world' }, await c1.request({ name: 'hello2!' }))
         assert.equal(s1.nbRequests, 0)
         assert.equal(c1.nbRequests, 2)
         assert.equal(s1.nbResponses, 0)
@@ -178,10 +183,10 @@ describe('WS2P', () => {
         assert.equal(s1.nbPushsByRemote, 0)
         assert.equal(c1.nbPushsByRemote, 0)
         // connection 2
-        const c2 = WS2PConnection.newConnectionToAddress('localhost:20902', () => {}, new WS2PNoLocalAuth(), new WS2PNoRemoteAuth())
-        assert.deepEqual({ answer: 'this is s2![j = 0]' }, await c2.request({ message: 'test?' }))
-        assert.deepEqual({ answer: 'this is s2![j = 1]' }, await c2.request({ message: 'test!' }))
-        assert.deepEqual({ answer: 'this is s2![j = 2]' }, await c2.request({ message: 'test!!!' }))
+        const c2 = WS2PConnection.newConnectionToAddress('localhost:20902', new WS2PMutedHandler(), new WS2PNoLocalAuth(), new WS2PNoRemoteAuth())
+        assert.deepEqual({ answer: 'this is s2![j = 0]' }, await c2.request({ name: 'test?' }))
+        assert.deepEqual({ answer: 'this is s2![j = 1]' }, await c2.request({ name: 'test!' }))
+        assert.deepEqual({ answer: 'this is s2![j = 2]' }, await c2.request({ name: 'test!!!' }))
         assert.equal(s1.nbRequests, 0)
         assert.equal(c2.nbRequests, 3)
         assert.equal(s1.nbResponses, 0)
@@ -216,7 +221,7 @@ describe('WS2P', () => {
         wss.on('connection', async (ws:any) => {
           switch (i) {
             case 1:
-              resolveS1(WS2PConnection.newConnectionFromWebSocketServer(ws, () => {}, new WS2PPubkeyLocalAuth(serverKeypair), new WS2PPubkeyRemoteAuth(serverKeypair), {
+              resolveS1(WS2PConnection.newConnectionFromWebSocketServer(ws, new WS2PMutedHandler(), new WS2PPubkeyLocalAuth(serverKeypair), new WS2PPubkeyRemoteAuth(serverKeypair), {
                 connectionTimeout: 100,
                 requestTimeout: 100
               }));
@@ -230,7 +235,7 @@ describe('WS2P', () => {
               }
             }
 
-              resolveS2(WS2PConnection.newConnectionFromWebSocketServer(ws, () => {}, new WS2PPubkeyLocalAuth(serverKeypair), new WS2PPubkeyNotAnsweringWithOKAuth(serverKeypair), {
+              resolveS2(WS2PConnection.newConnectionFromWebSocketServer(ws, new WS2PMutedHandler(), new WS2PPubkeyLocalAuth(serverKeypair), new WS2PPubkeyNotAnsweringWithOKAuth(serverKeypair), {
                 connectionTimeout: 100,
                 requestTimeout: 100
               }));
@@ -238,7 +243,7 @@ describe('WS2P', () => {
               break
             case 3:
 
-              resolveS3(WS2PConnection.newConnectionFromWebSocketServer(ws, () => {}, new WS2PPubkeyLocalAuth(serverKeypair), new WS2PPubkeyRemoteAuth(serverKeypair), {
+              resolveS3(WS2PConnection.newConnectionFromWebSocketServer(ws, new WS2PMutedHandler(), new WS2PPubkeyLocalAuth(serverKeypair), new WS2PPubkeyRemoteAuth(serverKeypair), {
                 connectionTimeout: 100,
                 requestTimeout: 100
               }));
@@ -246,7 +251,7 @@ describe('WS2P', () => {
               break
             case 4:
 
-              resolveS4(WS2PConnection.newConnectionFromWebSocketServer(ws, () => {}, new WS2PPubkeyLocalAuth(serverKeypair), new WS2PPubkeyRemoteAuth(serverKeypair), {
+              resolveS4(WS2PConnection.newConnectionFromWebSocketServer(ws, new WS2PMutedHandler(), new WS2PPubkeyLocalAuth(serverKeypair), new WS2PPubkeyRemoteAuth(serverKeypair), {
                 connectionTimeout: 100,
                 requestTimeout: 100
               }));
@@ -254,13 +259,13 @@ describe('WS2P', () => {
               break
 
             case 5:
-              resolveS5(WS2PConnection.newConnectionFromWebSocketServer(ws, () => {}, new WS2PPubkeyLocalAuth(serverKeypair), new WS2PPubkeyRemoteAuth(serverKeypair)));
+              resolveS5(WS2PConnection.newConnectionFromWebSocketServer(ws, new WS2PMutedHandler(), new WS2PPubkeyLocalAuth(serverKeypair), new WS2PPubkeyRemoteAuth(serverKeypair)));
               (await s5p).connect().catch((e:any) => console.error('WS2P: newConnectionFromWebSocketServer connection error'))
               break
 
             case 6:
 
-              resolveS6(WS2PConnection.newConnectionFromWebSocketServer(ws, () => {}, new WS2PPubkeyLocalAuth(serverKeypair), new WS2PPubkeyRemoteAuth(serverKeypair), {
+              resolveS6(WS2PConnection.newConnectionFromWebSocketServer(ws, new WS2PMutedHandler(), new WS2PPubkeyLocalAuth(serverKeypair), new WS2PPubkeyRemoteAuth(serverKeypair), {
                 connectionTimeout: 100,
                 requestTimeout: 100
               }));
@@ -284,17 +289,17 @@ describe('WS2P', () => {
         }
 
         const keypair = new Key('HgTTJLAQ5sqfknMq7yLPZbehtuLSsKj9CxWN7k8QvYJd', '51w4fEShBk1jCMauWu4mLpmDVfHksKmWcygpxriqCEZizbtERA6de4STKRkQBpxmMUwsKXRjSzuQ8ECwmqN1u2DP')
-        const c1 = WS2PConnection.newConnectionToAddress('localhost:20903', () => {}, new WS2PPubkeyLocalAuth(keypair), new WS2PPubkeyNotAnsweringWithACKAuth(keypair))
+        const c1 = WS2PConnection.newConnectionToAddress('localhost:20903', new WS2PMutedHandler(), new WS2PPubkeyLocalAuth(keypair), new WS2PPubkeyNotAnsweringWithACKAuth(keypair))
         c1.connect()
         const s1 = await s1p
-        await assertThrows(s1.request({ message: 'something' }), "WS2P connection timeout")
+        await assertThrows(s1.request({ name: 'something' }), "WS2P connection timeout")
       })
 
       it('should refuse the connection if the client not confirm with OK', async () => {
         const keypair = new Key('HgTTJLAQ5sqfknMq7yLPZbehtuLSsKj9CxWN7k8QvYJd', '51w4fEShBk1jCMauWu4mLpmDVfHksKmWcygpxriqCEZizbtERA6de4STKRkQBpxmMUwsKXRjSzuQ8ECwmqN1u2DP')
-        WS2PConnection.newConnectionToAddress('localhost:20903', () => {}, new WS2PPubkeyLocalAuth(keypair), new WS2PPubkeyRemoteAuth(keypair))
+        WS2PConnection.newConnectionToAddress('localhost:20903', new WS2PMutedHandler(), new WS2PPubkeyLocalAuth(keypair), new WS2PPubkeyRemoteAuth(keypair))
         const s2 = await s2p
-        await assertThrows(s2.request({ message: 'something' }), "WS2P connection timeout")
+        await assertThrows(s2.request({ name: 'something' }), "WS2P connection timeout")
       })
 
       it('should refuse the connection if the client answers with a wrong signature', async () => {
@@ -312,10 +317,10 @@ describe('WS2P', () => {
         }
 
         const keypair = new Key('HgTTJLAQ5sqfknMq7yLPZbehtuLSsKj9CxWN7k8QvYJd', '51w4fEShBk1jCMauWu4mLpmDVfHksKmWcygpxriqCEZizbtERA6de4STKRkQBpxmMUwsKXRjSzuQ8ECwmqN1u2DP')
-        const c3 = WS2PConnection.newConnectionToAddress('localhost:20903', () => {}, new WS2PPubkeyLocalAuth(keypair), new WS2PPubkeyAnsweringWithWrongSigForACK(keypair))
+        const c3 = WS2PConnection.newConnectionToAddress('localhost:20903', new WS2PMutedHandler(), new WS2PPubkeyLocalAuth(keypair), new WS2PPubkeyAnsweringWithWrongSigForACK(keypair))
         c3.connect()
         const s3 = await s3p
-        await assertThrows(s3.request({ message: 'something' }), "Wrong signature from server ACK")
+        await assertThrows(s3.request({ name: 'something' }), "Wrong signature from server ACK")
       })
 
       it('should refuse the connection if the client refuses our signature', async () => {
@@ -335,21 +340,23 @@ describe('WS2P', () => {
         }
 
         const keypair = new Key('HgTTJLAQ5sqfknMq7yLPZbehtuLSsKj9CxWN7k8QvYJd', '51w4fEShBk1jCMauWu4mLpmDVfHksKmWcygpxriqCEZizbtERA6de4STKRkQBpxmMUwsKXRjSzuQ8ECwmqN1u2DP')
-        const c4 = WS2PConnection.newConnectionToAddress('localhost:20903', () => {}, new WS2PPubkeyRefusingACKSignature(keypair), new WS2PPubkeyRemoteAuth(keypair))
+        const c4 = WS2PConnection.newConnectionToAddress('localhost:20903', new WS2PMutedHandler(), new WS2PPubkeyRefusingACKSignature(keypair), new WS2PPubkeyRemoteAuth(keypair))
         const s4 = await s4p
         await assertThrows(c4.connect(), "Wrong signature from server ACK")
       })
 
       it('should accept the connection if everything is OK on both side', async () => {
         const keypair = new Key('HgTTJLAQ5sqfknMq7yLPZbehtuLSsKj9CxWN7k8QvYJd', '51w4fEShBk1jCMauWu4mLpmDVfHksKmWcygpxriqCEZizbtERA6de4STKRkQBpxmMUwsKXRjSzuQ8ECwmqN1u2DP')
-        const c5 = WS2PConnection.newConnectionToAddress('localhost:20903', (obj:any, ws:any) => {
-          if (obj.reqId) {
-            ws.send(JSON.stringify({ resId: obj.reqId, body: { answer: 'success!' } }))
+        const c5 = WS2PConnection.newConnectionToAddress('localhost:20903', new (class TmpHandler implements WS2PMessageHandler {
+          async handlePushMessage(json: any): Promise<void> {
+          }
+          async handleRequestMessage(json: any): Promise<WS2PResponse> {
+            return { answer: 'success!' }
           }
-        }, new WS2PPubkeyLocalAuth(keypair), new WS2PPubkeyRemoteAuth(keypair))
+        }), new WS2PPubkeyLocalAuth(keypair), new WS2PPubkeyRemoteAuth(keypair))
         await c5.connect()
         const s5 = await s5p
-        assert.deepEqual({ answer: 'success!' }, await s5.request({ message: 'connection?'} ))
+        assert.deepEqual({ answer: 'success!' }, await s5.request({ name: 'connection?'} ))
       })
 
       it('should refuse the connection if the client does not send OK', async () => {
@@ -360,10 +367,10 @@ describe('WS2P', () => {
         }
 
         const keypair = new Key('HgTTJLAQ5sqfknMq7yLPZbehtuLSsKj9CxWN7k8QvYJd', '51w4fEShBk1jCMauWu4mLpmDVfHksKmWcygpxriqCEZizbtERA6de4STKRkQBpxmMUwsKXRjSzuQ8ECwmqN1u2DP')
-        const c6 = WS2PConnection.newConnectionToAddress('localhost:20903', () => {}, new WS2PPubkeyNotAnsweringWithOKAuth(keypair), new WS2PPubkeyRemoteAuth(keypair))
+        const c6 = WS2PConnection.newConnectionToAddress('localhost:20903', new WS2PMutedHandler(), new WS2PPubkeyNotAnsweringWithOKAuth(keypair), new WS2PPubkeyRemoteAuth(keypair))
         c6.connect()
         const s6 = await s6p
-        await assertThrows(s6.request({ message: 'something' }), "WS2P connection timeout")
+        await assertThrows(s6.request({ name: 'something' }), "WS2P connection timeout")
       })
     })
   })
@@ -421,3 +428,13 @@ class WS2PNoRemoteAuth implements WS2PRemoteAuth {
   async authenticationIsDone(): Promise<void> {
   }
 }
+
+class WS2PMutedHandler implements WS2PMessageHandler {
+
+  async handlePushMessage(json: any): Promise<void> {
+  }
+
+  async handleRequestMessage(json: any): Promise<WS2PResponse> {
+    return {}
+  }
+}

test/integration/ws2p_exchange.ts

+import {WS2PConnection} from "../../app/lib/ws2p/WS2PConnection"
+import {Key} from "../../app/lib/common-libs/crypto/keyring"
+import {newWS2PBidirectionnalConnection} from "./tools/toolbox"
+import {WS2PRequester} from "../../app/lib/ws2p/WS2PRequester"
+import {WS2PResponder} from "../../app/lib/ws2p/WS2PResponder"
+import {WS2PReqMapper} from "../../app/lib/ws2p/WS2PReqMapper"
+import {BlockDTO} from "../../app/lib/dto/BlockDTO"
+import {WS2PMessageHandler} from "../../app/lib/ws2p/impl/WS2PMessageHandler"
+import {WS2PResponse} from "../../app/lib/ws2p/impl/WS2PResponse"
+const assert = require('assert');
+
+describe('WS2P exchange', () => {
+
+  let wss:any
+  let c1:WS2PConnection, s1:WS2PConnection
+
+  before(async () => {
+    const serverPair = new Key('DKpQPUL4ckzXYdnDRvCRKAm1gNvSdmAXnTrJZ7LvM5Qo', '64EYRvdPpTfLGGmaX5nijLXRqWXaVz8r1Z1GtaahXwVSJGQRn7tqkxLb288zwSYzELMEG5ZhXSBYSxsTsz1m9y8F')
+    const clientPair = new Key('HgTTJLAQ5sqfknMq7yLPZbehtuLSsKj9CxWN7k8QvYJd', '51w4fEShBk1jCMauWu4mLpmDVfHksKmWcygpxriqCEZizbtERA6de4STKRkQBpxmMUwsKXRjSzuQ8ECwmqN1u2DP')
+    const res = await newWS2PBidirectionnalConnection(serverPair, clientPair, new (class TestingHandler implements WS2PMessageHandler {
+
+      async handlePushMessage(json: any): Promise<void> {
+      }
+
+      async handleRequestMessage(json: any): Promise<WS2PResponse> {
+        return await WS2PResponder(json, new (class TestingMapper implements WS2PReqMapper {
+          async getCurrent(): Promise<BlockDTO> {
+            return BlockDTO.fromJSONObject({ number: 1, hash: 'A' })
+          }
+        }))
+      }
+    }))
+    s1 = res.p1
+    c1 = res.p2
+    wss = res.wss
+  })
+
+  after((done) => {
+    wss.close(done)
+  })
+
+  it('should accept the connection if everything is OK on both side', async () => {
+    const requester1 = WS2PRequester.fromConnection(c1)
+    assert.deepEqual(await requester1.getCurrent(), {
+      "actives": [],
+      "certifications": [],
+      "currency": "",
+      "dividend": null,
+      "excluded": [],
+      "fork": false,
+      "hash": "A",
+      "identities": [],
+      "issuer": "",
+      "issuersCount": null,
+      "issuersFrame": null,
+      "issuersFrameVar": null,
+      "joiners": [],
+      "leavers": [],
+      "medianTime": null,
+      "membersCount": null,
+      "monetaryMass": 0,
+      "nonce": null,
+      "number": 1,
+      "parameters": "",
+      "powMin": null,
+      "revoked": [],
+      "signature": "",
+      "time": null,
+      "transactions": [],
+      "unitbase": null,
+      "version": 10
+    })
+  })
+})