test

package.json

@@ -9,18 +9,24 @@
     "backend": "node js/test/TestBackend.js",
     "frontend": "node js/test/TestFrontend.js",
     "build": "npm run clean && tsc && npm run webpack",
-    "clean": "rm -rf js"
+    "clean": "rm -rf js",
+    "test": "mocha js/test/Test.js"
   },
   "author": "",
   "license": "ISC",
   "devDependencies": {
+    "@types/expect": "^1.20.4",
     "@types/express": "^4.17.0",
+    "@types/mocha": "^5.2.7",
     "@types/node": "^11.13.19",
+    "chai": "^4.2.0",
+    "mocha": "^6.2.0",
+    "terser-webpack-plugin": "^2.1.0",
     "ts-loader": "^5.3.3",
+    "ts-mocha": "^6.0.0",
     "typescript": "^3.5.3",
     "webpack": "^4.40.2",
-    "webpack-cli": "^3.3.9",
+    "webpack-cli": "^3.3.9"
-    "terser-webpack-plugin": "^2.1.0"
   },
   "dependencies": {
     "bsock": "^0.1.9",

src/Backend.ts

@@ -9,7 +9,8 @@ import * as I from './Interfaces';
 
 export class RPCServer<
     SubResType = {}
->{
+> implements I.Destroyable{
+        
     private ws = http.createServer()
     private io = bsock.createServer()
     private visibility:T.Visibility
@@ -78,4 +79,9 @@ export class RPCServer<
             ...this.exporters.flatMap(exporter => U.rpcHooker(socket, exporter))
         ]
     }
+
+    async destroy(): Promise<void> {
+        this.io.close()
+        this.ws.close()
+    }
 }

src/Frontend.ts

@@ -47,6 +47,7 @@ export class RPCSocket implements I.Socket{
     
     public async connect(){
         this.socket = await bsock.connect(this.port, this.server, this.tls)
+        this.on('error', () => {})
 
         const info:T.ExtendedRpcInfo[] = await this.info()
         info.forEach(i => {

src/Interfaces.ts

@@ -6,13 +6,16 @@ export interface Exporter<T = {}>{
     exportRPCs() : T.RPC<T>[]
 }
 
-export interface Socket {
+export interface Socket extends Destroyable {
     port: number
     hook: (rpcname: T.Name, ...args: T.Any[]) => I.Socket
     unhook: (rpcname:T.Name) => I.Socket
     call: (rpcname:T.Name, ...args: T.Any[]) => Promise<T.Any>
     fire: (rpcname:T.Name, ...args: T.Any[]) => Promise<T.Any>
     on: T.OnFunction    
-    destroy: ()=>void
+    close() : void
-    close: ()=>void
+}
+
+export interface Destroyable{
+    destroy() : void
 }

test/TestBackend.ts

@@ -1,84 +0,0 @@
-import { RPCServer } from '../src/Backend'
-import { SubscriptionResponse, ErrorResponse, SuccessResponse } from '../src/Types'
-import { HookRPC } from '../src/Types'
-import * as uuidv4 from "uuid/v4"
-import { makeSubResponse } from '../src/Utils'
-
-let subcallback
-
-new RPCServer(20000, [{
-    name: "HelloWorldRPCGroup",
-    exportRPCs: () => [
-        {
-            name: 'echo',
-            call: async (s:string) => s,
-        },{
-            name: 'simpleSubscribe',
-            hook: async(callback) => {
-                subcallback =  callback
-                return makeSubResponse()
-            }
-        },{
-            name: 'subscribe',
-            hook: async (callback):Promise<any> => {
-                subcallback = callback
-                return makeSubResponse()
-            },
-            onClose: (res, rpc) => { 
-                console.log("Specific close handler for", rpc.name, res)
-                subcallback = null 
-            },
-            onCallback: (...args) => { console.log.apply(console, args) }
-        },
-        function add(...args:number[]):number {return args.reduce((a,b)=>a+b, 0)},
-        function triggerCallback(...messages:any[]):number {return subcallback.apply({}, messages)},
-    ]
-}])
-
-new RPCServer<{ topic: string }>(20001, [{
-    name: "HelloWorldRPCGroup",
-    exportRPCs: () => [
-        {
-            name: 'echo',
-            call: async (s:string) => s,
-        },{
-            name: 'simpleSubscribe',
-            hook: async(callback) => {
-                subcallback =  callback
-                return {
-                    result: "Success",
-                    uuid: uuidv4(),
-                    topic: ""
-                }
-            }
-        },{
-            name: 'subscribe',
-            hook: async (callback) => {
-                subcallback = callback
-                return {
-                    result: "Success",
-                    uuid: uuidv4(),
-                    topic: ""
-                }
-            },
-            onClose: (res, rpc) => { 
-                console.log("Specific close handler for", rpc.name, res)
-                subcallback = null 
-            },
-            onCallback: (...args:any) => { console.log.apply(console, args) }
-        },
-        function add(...args:number[]):number {return args.reduce((a,b)=>a+b, 0)},
-        function triggerCallback(...messages:any[]):number {return subcallback.apply({}, messages)},
-    ]
-}])
-
-try{
-    new RPCServer(20001, [{
-        name: "bad",
-        exportRPCs: ()  => [
-            (aaa,bbb,ccc) => { return aaa+bbb+ccc }
-        ]
-    }])
-}catch(badRPCError){
-    console.log("expected bad-RPC error happened: "+ !!badRPCError, String(badRPCError))
-}

test/TestFrontend.ts

@@ -1,36 +0,0 @@
-import { RPCSocket } from '../src/Frontend'
-const client = new RPCSocket(20000, 'localhost')
-client.connect().then(async _ => {
-    await client.info().then(console.log)
-    
-    await client["HelloWorldRPCGroup"].echo("x")
-    .then(hopefullyX => console.log("echo('x') returned x: ", hopefullyX === "x", hopefullyX))
-
-    await client["HelloWorldRPCGroup"].add(1,2,3)
-    .then(hopefully6 => console.log("add(1,2,3) returned 6: ", hopefully6 === 6, hopefully6))
-
-    let counter = 0
-    const handler = (s) => {
-        counter++
-        if(counter === 3)
-        console.log("subscribe call counter met", counter === 3)
-    }
-
-    await client["HelloWorldRPCGroup"].subscribe(handler)
-    await Promise.all([
-        client["HelloWorldRPCGroup"].triggerCallback("test1", "test1", "test1", ),
-        client["HelloWorldRPCGroup"].triggerCallback("test2", "test2", "test2", ),
-        client["HelloWorldRPCGroup"].triggerCallback("test3", "test3", "test3", ),
-    ])
-
-    counter = 0
-    const simplehandler = (s) => {
-        counter++
-        if(counter === 3)
-            console.log("simpleSubscribe call counter met", counter === 3)
-    }
-    await client["HelloWorldRPCGroup"].simpleSubscribe(simplehandler)
-    client["HelloWorldRPCGroup"].triggerCallback("simple1", "simple1", "simple1", )
-    client["HelloWorldRPCGroup"].triggerCallback("simple2", "simple2", "simple2", )
-    client["HelloWorldRPCGroup"].triggerCallback("simple3", "simple3", "simple3", )
-})