bump

test/Test.ts

@@ -0,0 +1,135 @@
+import { describe, it, beforeEach } from "mocha";
+import { expect } from "chai";
+
+
+import { RPCServer } from '../src/Backend'
+import * as uuidv4 from "uuid/v4"
+import { RPCSocket } from "../src/Frontend";
+
+function makeServer(){
+    let subcallback
+    return new RPCServer<{ topic: string }>(20000, [{
+        name: "test",
+        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)},
+        ]
+    }])
+}
+
+let server: RPCServer<{ topic: string}>
+
+describe('RPCServer', () => {
+    before(async(done) => {
+        server = makeServer()
+        done()
+    })
+    
+    after(async() => {
+        await server.destroy()
+    })
+
+    it('new RPCServer() should fail on bad RPC', (done) => {
+        try{
+            new RPCServer(20001, [{
+                name: "bad",
+                exportRPCs: ()  => [
+                    (aaa,bbb,ccc) => { return aaa+bbb+ccc }
+                ]
+            }])
+            done(new Error("Didn't fail with bad RPC"))
+        }catch(badRPCError){
+            done()
+        }
+    })
+})
+
+
+describe('RPCSocket', () => {
+    let client: RPCSocket
+    let server: RPCServer<{topic: string}>
+
+    before(async() => {
+        server = makeServer()
+        client = new RPCSocket(20000, "localhost")
+        return await client.connect()
+    })
+
+    after(async() => {
+        client.destroy()
+        server.destroy()
+    })
+
+
+    it('should have rpc echo', (done) => {
+        client['test'].echo("x").then(x => {
+            if(x === 'x')
+                done()
+            else
+                done(new Error('echo RPC response did not match'))   
+        })
+    })
+
+    it('should subscribe with success', (done) => {
+        client['test'].simpleSubscribe(console.log).then(res => {
+            if(res.result === 'Success'){
+                done()
+            }else{
+                console.error(res)
+                done(new Error('Subscribe did not return success'))
+            }
+        })
+    })
+
+    it('subscribe should call back', (done) => {
+        client['test'].subscribe((...args: any) => {
+            if(args[0] === "test" && args[1] === "callback")
+                done()
+            else   
+                done(new Error("Bad callback value "+ args))    
+        }).then( async () => {
+            await client['test'].triggerCallback("test", "callback")
+        })
+    })
+
+    it('simpleSubscribe should call back', (done) => {
+        client['test'].simpleSubscribe((...args: any) => {
+            if(args[0] === "test_" && args[1] === "callback_")
+                done()
+            else   
+                done(new Error("Bad callback value "+ args))    
+        }).then( async () => {
+            await client['test'].triggerCallback("test_", "callback_")
+        })
+    })
+
+})