rpclibrary/test/Test.ts

import { describe, it } from "mocha";

import { RPCServer } from '../src/Backend'
import * as uuidv4 from "uuid/v4"
import { RPCSocket } from "../src/Frontend";
import { SubscriptionResponse } from "../src/Types";

const add = (...args:number[]) => {return args.reduce((a,b)=>a+b, 0)}
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: "test"
                    }
                }
            },{
                name: 'subscribe',
                hook: async (callback) => {
                    subcallback = callback
                    return {
                        result: "Success",
                        uuid: uuidv4(),
                        topic: "test"
                    }
                },
                onClose: (res, rpc) => { 
                    console.log("onClose", rpc.name === 'subscribe' && res?"OK":"")
                    subcallback = null 
                },
                onCallback: (...args:any) => { 
                    console.log("onCallback", args[0] === "test" && args[1] === "callback"?"OK":"")                    
                }
            },
            add,
            function triggerCallback(...messages:any[]):number {return subcallback.apply({}, messages)},
        ]
    }],{
        connectionHandler: (socket) => { console.log("connectionHandler OK") },
        closeHandler: (socket) => { console.log("closeHandler OK") },
        errorHandler: (socket, err) => { console.error("errorHandler OK SO YOU SHOULDN'T SEE THIS"); throw err }
    })
}


describe('RPCServer', () => {
    let server: RPCServer<{ topic: string }, any>

    before((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(() => {
        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 add up to 6', (done) => {
        client['test'].add(1,2,3).then(x => {
            if(x === 6)
                done()
            else
                done(new Error('add 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_")
        })
    })
})

describe('It should do unhook', () => {
    let candy = "OK"
    let cb: Function
    let client: RPCSocket
    let server: RPCServer<{topic: string}> 

    before(async() => {
        server = new RPCServer<{ topic: string }>(20000, [{
            name: "test",
            exportRPCs: () => [{
                name: 'subscribe',
                hook: async(callback):Promise<SubscriptionResponse<{topic:string}>> => {
                    cb = <Function> callback
                    return {
                        result: "Success",
                        uuid: uuidv4(),
                        topic: "test"
                    }
                }
            }, 
            function checkCandy():string { cb(candy); return candy },
            function stealCandy():string { candy = "_OK"; cb(candy); cb = (...any) => console.log.apply(console,["Server:", ...any]); return candy }
        ]
        }],{
            connectionHandler: (socket) => { console.log("connectionHandler OK") },
            closeHandler: (socket) => { console.log("closeHandler OK") },
            errorHandler: (socket, err) => { console.error("errorHandler OK SO YOU SHOULDN'T SEE THIS"); throw err }
        })
        client = new RPCSocket(20000, "localhost")
        return await client.connect()
    })

    after(() => {
        client.destroy()
        server.destroy()
    })

    it('Unhook+unsubscribe should stop callbacks', (done) => {
        client['test'].subscribe(c => console.log("Client: "+c)).then( async (res: SubscriptionResponse) => {
            const r1 = await client['test'].checkCandy()
            const r3 = await client['test'].stealCandy()
            client.unhook(res.uuid)
            console.log("---- No client output below this line")
            const r2 = await client['test'].checkCandy()
            const r4 = await client['test'].checkCandy()
            console.log("---- More output below")

            if(r1 === "OK" && r3 === "_OK" && r2 === "_OK" && r4 === "_OK")
                done()
            else
                done(new Error("Results did not match: "+[r1,r2,r3,r4]))
        })
    })
})