mulocal-socket/test/socket.js

Local socket emulation for mudb

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var test = require("tape");
var __1 = require("../");
var socket_1 = require("mudb/socket");
function noop() { }
function id() {
    return Math.random().toString(36).substr(2);
}
test('socket initial state', function (t) {
    var socket = __1.createLocalSocket({
        sessionId: id(),
        server: __1.createLocalSocketServer(),
    });
    t.equals(socket.state, socket_1.MuSocketState.INIT, 'should be INIT');
    t.end();
});
test('socket.open() - when INIT', function (t) {
    t.plan(5);
    var unreliableMessageFromClient = 0;
    var reliableMessagesFromClient = 0;
    var server = __1.createLocalSocketServer();
    server.start({
        ready: noop,
        connection: function (serverSocket) { return serverSocket.open({
            ready: function () {
                clientSocket.send('unreliable message from client', true);
                clientSocket.send('another unreliable message from client', true);
                clientSocket.send('reliable message from client', false);
                clientSocket.send('another reliable message from client', false);
                clientSocket.open({
                    ready: function () {
                        t.equals(clientSocket.state, socket_1.MuSocketState.OPEN, 'should change socket state to OPEN');
                        t.equals(unreliableMessageFromClient, 2, 'should send pending unreliable messages');
                        t.equals(reliableMessagesFromClient, 2, 'should send pending reliable messages');
                        clientSocket._duplex.send('unreliable message from server');
                    },
                    message: function () {
                        t.pass('should set message handler');
                        clientSocket.close();
                    },
                    close: function (error) { return t.equals(error, undefined, 'should set close handler'); },
                });
            },
            message: function (_, unreliable) {
                if (unreliable) {
                    ++unreliableMessageFromClient;
                }
                else {
                    ++reliableMessagesFromClient;
                }
            },
            close: noop,
        }); },
        close: noop,
    });
    var clientSocket = __1.createLocalSocket({
        sessionId: id(),
        server: server,
    });
});
test('socket.open() - when OPEN', function (t) {
    t.plan(1);
    var socket = __1.createLocalSocket({
        sessionId: id(),
        server: __1.createLocalSocketServer(),
    });
    socket.open({
        ready: function () { return socket.open({
            ready: noop,
            message: noop,
            close: noop,
        }); },
        message: noop,
        close: function (error) { return t.equals(typeof error, 'string', 'should invoke close handler with error message'); },
    });
});
test('socket.open() - when CLOSED', function (t) {
    t.plan(1);
    var socket = __1.createLocalSocket({
        sessionId: id(),
        server: __1.createLocalSocketServer(),
    });
    socket.open({
        ready: function () {
            socket.close();
            socket.open({
                ready: noop,
                message: noop,
                close: noop,
            });
        },
        message: noop,
        close: function (error) {
            if (error) {
                t.equals(typeof error, 'string', 'should invoke close handler with error message');
            }
        },
    });
});
test('socket.send() - when OPEN', function (t) {
    t.plan(1);
    var server = __1.createLocalSocketServer();
    server.start({
        ready: noop,
        connection: function (serverSocket) { return serverSocket.open({
            ready: function () { return clientSocket.open({
                ready: function () { return clientSocket.send('unreliable message from client'); },
                message: noop,
                close: noop,
            }); },
            message: function () { return t.pass('should send messages to server'); },
            close: noop,
        }); },
        close: noop,
    });
    var clientSocket = __1.createLocalSocket({
        sessionId: id(),
        server: server,
    });
});
test('socket.send() - when INIT', function (t) {
    t.plan(2);
    var unreliableMessagesReceived = 0;
    var reliableMessagesReceived = 0;
    var server = __1.createLocalSocketServer();
    server.start({
        ready: noop,
        connection: function (serverSocket) { return serverSocket.open({
            ready: function () {
                clientSocket.send('unreliable message', true);
                clientSocket.send('another unreliable message', true);
                clientSocket.send('reliable message', false);
                clientSocket.send('another reliable message', false);
                clientSocket.open({
                    ready: function () {
                        t.equals(unreliableMessagesReceived, 2, 'should save unreliable messages until socket is OPEN');
                        t.equals(reliableMessagesReceived, 2, 'should save reliable messages until socket is OPEN');
                    },
                    message: noop,
                    close: noop,
                });
            },
            message: function (_, unreliable) {
                if (unreliable) {
                    ++unreliableMessagesReceived;
                }
                else {
                    ++reliableMessagesReceived;
                }
            },
            close: noop,
        }); },
        close: noop,
    });
    var clientSocket = __1.createLocalSocket({
        sessionId: id(),
        server: server,
    });
});
test('socket.send() - when CLOSED', function (t) {
    t.plan(1);
    var server = __1.createLocalSocketServer();
    server.start({
        ready: noop,
        connection: function (serverSocket) { return serverSocket.open({
            ready: function () {
                clientSocket.close();
                clientSocket.send('message never got sent');
                t.pass('should return silently');
            },
            message: function () { return t.fail('should not invoke message handler'); },
            close: noop,
        }); },
        close: noop,
    });
    var clientSocket = __1.createLocalSocket({
        sessionId: id(),
        server: server,
    });
});
test('socket.close() - when OPEN', function (t) {
    t.plan(4);
    var server = __1.createLocalSocketServer();
    server.start({
        ready: noop,
        connection: function (serverSocket) { return serverSocket.open({
            ready: function () { return clientSocket.open({
                ready: function () { return clientSocket.close(); },
                message: noop,
                close: function (error) {
                    t.equals(error, undefined, 'should invoke close handler without error message');
                    t.equals(clientSocket.state, socket_1.MuSocketState.CLOSED, 'should change socket state to CLOSED');
                },
            }); },
            message: noop,
            close: function (error) {
                t.equals(server.clients.length, 0, 'should remove connection from server');
                t.equals(serverSocket.state, socket_1.MuSocketState.CLOSED, 'should also close server socket');
            },
        }); },
        close: noop,
    });
    var clientSocket = __1.createLocalSocket({
        sessionId: id(),
        server: server,
    });
});
test('socket.close() - when INIT', function (t) {
    var socket = __1.createLocalSocket({
        sessionId: id(),
        server: __1.createLocalSocketServer(),
    });
    socket.close();
    t.equals(socket.state, socket_1.MuSocketState.CLOSED, 'should change socket state to CLOSED');
    t.end();
});
test('socket.close() - when CLOSED', function (t) {
    t.plan(1);
    var callsToOnClose = 0;
    var socket = __1.createLocalSocket({
        sessionId: id(),
        server: __1.createLocalSocketServer(),
    });
    socket.open({
        ready: function () {
            socket.close();
            socket.close();
            t.equals(callsToOnClose, 1, 'should not invoke close handler');
        },
        message: noop,
        close: function () { return ++callsToOnClose; },
    });
});
//# sourceMappingURL=socket.js.map