pocket-messaging
Version:
A small cryptographic messaging library written in TypeScript both for browser and nodejs supporting TCP and WebSockets
583 lines (527 loc) • 19.7 kB
text/typescript
import { TestSuite, Test, AfterAll, BeforeAll, expect } from 'testyts';
import {HandshakeFactory} from "../src/HandshakeFactory";
import {TCPClient} from "pocket-sockets";
const assert = require("assert");
@TestSuite()
export class HandshakeFactoryConstructor {
@Test()
public successful_call() {
assert.doesNotThrow(() => {
let handshakeFactory = new HandshakeFactory({
pingInterval: 0,
socketFactoryConfig: {
maxConnections: 9
},
keyPair: {
publicKey: Buffer.alloc(0),
secretKey: Buffer.alloc(0)
},
discriminator: Buffer.alloc(0)
});
//@ts-ignore
assert(Object.keys(handshakeFactory.getHandshakeFactoryConfig().socketFactoryConfig).length == 1);
//@ts-ignore
assert(handshakeFactory.getHandshakeFactoryConfig().socketFactoryConfig.maxConnections == 9);
//@ts-ignore
assert(Object.keys(handshakeFactory.stats.counters).length == 0);
//@ts-ignore
assert(Object.keys(handshakeFactory.handlers).length == 0);
//@ts-ignore
assert(handshakeFactory.serverClientSockets.length == 0);
//@ts-ignore
assert(handshakeFactory._isClosed == false);
//@ts-ignore
assert(handshakeFactory._isShutdown == false);
});
}
}
@TestSuite()
export class HandshakeFactoryHandleOnConnect {
@Test()
public successful_call_client() {
assert.doesNotThrow(async () => {
let handshakeFactory = new HandshakeFactory({
pingInterval: 0,
socketFactoryConfig: {
client: {
socketType: "TCP",
clientOptions: {
"host": "host.com",
"port": 99
},
reconnectDelay: 0,
},
server: {
socketType: "WebSocket",
serverOptions: {
"host": "host.com",
"port": 99
},
deniedIPs: ["192.168.5.5"],
allowedIPs: ["127.0.0.1", "localhost"],
},
maxConnections: 0
},
keyPair: {
publicKey: Buffer.alloc(0),
secretKey: Buffer.alloc(0)
},
discriminator: Buffer.alloc(0),
serverPublicKey: Buffer.alloc(0),
});
//@ts-ignore
const clientSocket = new TCPClient(handshakeFactory.getHandshakeFactoryConfig().socketFactoryConfig.client.clientOptions);
//@ts-ignore
const callback = await handshakeFactory.handleOnConnect(clientSocket, /*isServer=*/ false);
});
}
@Test()
public successful_call_server() {
assert.doesNotThrow(async () => {
let handshakeFactory = new HandshakeFactory({
pingInterval: 0,
socketFactoryConfig: {
client: {
socketType: "TCP",
clientOptions: {
"host": "host.com",
"port": 99
},
reconnectDelay: 0,
},
server: {
socketType: "WebSocket",
serverOptions: {
"host": "host.com",
"port": 99
},
deniedIPs: ["192.168.5.5"],
allowedIPs: ["127.0.0.1", "localhost"],
},
maxConnections: 0
},
keyPair: {
publicKey: Buffer.alloc(0),
secretKey: Buffer.alloc(0)
},
discriminator: Buffer.alloc(0),
serverPublicKey: Buffer.alloc(0),
});
//@ts-ignore
const clientSocket = new TCPClient(handshakeFactory.getHandshakeFactoryConfig().socketFactoryConfig.client.clientOptions);
//@ts-ignore
const callback = await handshakeFactory.handleOnConnect(clientSocket, /*isServer=*/ true);
});
}
@Test()
public successful_call_client_missing_serverPublicKey() {
assert.doesNotThrow(async () => {
let handshakeFactory = new HandshakeFactory({
pingInterval: 0,
socketFactoryConfig: {
client: {
socketType: "TCP",
clientOptions: {
"host": "host.com",
"port": 99
},
reconnectDelay: 0,
},
server: {
socketType: "WebSocket",
serverOptions: {
"host": "host.com",
"port": 99
},
deniedIPs: ["192.168.5.5"],
allowedIPs: ["127.0.0.1", "localhost"],
},
maxConnections: 0
},
keyPair: {
publicKey: Buffer.alloc(0),
secretKey: Buffer.alloc(0)
},
discriminator: Buffer.alloc(0)
});
//@ts-ignore
const clientSocket = new TCPClient(handshakeFactory.getHandshakeFactoryConfig().socketFactoryConfig.client.clientOptions);
let clientSocketCloseCalled = false;
//@ts-ignore
clientSocket.close = function() {
clientSocketCloseCalled = true;
};
//@ts-ignore
const callback = await handshakeFactory.handleOnConnect(clientSocket, /*isServer=*/ false);
//@ts-ignore
assert(clientSocketCloseCalled == true);
});
}
@Test()
public successful_call_client_handshake_error() {
assert.doesNotThrow(async () => {
let handshakeFactory = new HandshakeFactory({
pingInterval: 0,
socketFactoryConfig: {
client: {
socketType: "TCP",
clientOptions: {
"host": "host.com",
"port": 99
},
reconnectDelay: 0,
},
server: {
socketType: "WebSocket",
serverOptions: {
"host": "host.com",
"port": 99
},
deniedIPs: ["192.168.5.5"],
allowedIPs: ["127.0.0.1", "localhost"],
},
maxConnections: 0
},
keyPair: {
publicKey: Buffer.alloc(0),
secretKey: Buffer.alloc(0)
},
discriminator: Buffer.alloc(0),
serverPublicKey: Buffer.alloc(0),
});
//@ts-ignore
const clientSocket = new TCPClient(handshakeFactory.getHandshakeFactoryConfig().socketFactoryConfig.client.clientOptions);
//@ts-ignore
handshakeFactory.triggerEvent = function(name, ...args: any[]) {
assert(name == "HANDSHAKE_ERROR" || name == "ERROR");
if (name === "HANDSHAKE_ERROR") {
assert(args[0].message == "Socket not instantiated");
}
else {
assert(args[0] == "HANDSHAKE_ERROR");
assert(args[1][0].message == "Socket not instantiated");
}
};
//@ts-ignore
const callback = await handshakeFactory.handleOnConnect(clientSocket, /*isServer=*/ false);
});
}
}
@TestSuite()
export class HandshakeFactoryInit {
@Test()
public successful_call() {
assert.doesNotThrow(async () => {
let handshakeFactory = new HandshakeFactory({
pingInterval: 0,
socketFactoryConfig: {
client: {
socketType: "TCP",
clientOptions: {
"host": "host.com",
"port": 99
},
reconnectDelay: 0,
},
server: {
socketType: "WebSocket",
serverOptions: {
"host": "host.com",
"port": 99
},
deniedIPs: ["192.168.5.5"],
allowedIPs: ["127.0.0.1", "localhost"],
},
maxConnections: 0
},
keyPair: {
publicKey: Buffer.alloc(0),
secretKey: Buffer.alloc(0)
},
discriminator: Buffer.alloc(0),
serverPublicKey: Buffer.alloc(0),
});
const handleOnConnectFn = function(){
};
//@ts-ignore
handshakeFactory.handleOnConnect = handleOnConnectFn;
handshakeFactory.onConnect = function(fn){
onConnectCalled = true;
assert(fn == handleOnConnectFn);
};
let onConnectCalled = false;
handshakeFactory.onConnect = function(){
onConnectCalled = true;
};
//@ts-ignore
handshakeFactory.init();
//@ts-ignore
assert(onConnectCalled == true);
});
}
}
@TestSuite()
export class HandshakeFactoryIncreaseDecreaseClientsCounter {
@Test()
public successful_call() {
assert.doesNotThrow(async () => {
let handshakeFactory = new HandshakeFactory({
pingInterval: 0,
socketFactoryConfig: {
client: {
socketType: "TCP",
clientOptions: {
"host": "host.com",
"port": 99
},
reconnectDelay: 0,
},
server: {
socketType: "WebSocket",
serverOptions: {
"host": "host.com",
"port": 99
},
deniedIPs: ["192.168.5.5"],
allowedIPs: ["127.0.0.1", "localhost"],
},
maxConnections: 0
},
keyPair: {
publicKey: Buffer.alloc(0),
secretKey: Buffer.alloc(0)
},
discriminator: Buffer.alloc(0),
serverPublicKey: Buffer.alloc(0),
});
//@ts-ignore
let counter = handshakeFactory.readCounter("ABBA");
assert(counter == 0);
//@ts-ignore
handshakeFactory.increaseCounter("ABBA");
//@ts-ignore
counter = handshakeFactory.readCounter("ABBA");
assert(counter == 1);
//@ts-ignore
handshakeFactory.increaseCounter("ABBA");
//@ts-ignore
counter = handshakeFactory.readCounter("ABBA");
assert(counter == 2);
//@ts-ignore
handshakeFactory.decreaseCounter("ABBA");
//@ts-ignore
counter = handshakeFactory.readCounter("ABBA");
assert(counter == 1);
});
}
}
@TestSuite()
export class HandshakeFactoryCheckClientsOverflow {
@Test()
public configuration_undefined() {
assert.doesNotThrow(async () => {
let handshakeFactory = new HandshakeFactory({
pingInterval: 0,
socketFactoryConfig: {
client: {
socketType: "TCP",
clientOptions: {
"host": "host.com",
"port": 99
},
reconnectDelay: 0,
},
server: {
socketType: "WebSocket",
serverOptions: {
"host": "host.com",
"port": 99
},
deniedIPs: ["192.168.5.5"],
allowedIPs: ["127.0.0.1", "localhost"],
},
maxConnections: 0
},
keyPair: {
publicKey: Buffer.alloc(0),
secretKey: Buffer.alloc(0)
},
discriminator: Buffer.alloc(0),
serverPublicKey: Buffer.alloc(0),
});
//@ts-ignore
let overflows = handshakeFactory.checkClientsOverflow("ABBA");
assert(overflows == false);
});
}
@Test()
public overflows() {
assert.doesNotThrow(async () => {
let handshakeFactory = new HandshakeFactory({
pingInterval: 0,
socketFactoryConfig: {
client: {
socketType: "TCP",
clientOptions: {
"host": "host.com",
"port": 99
},
reconnectDelay: 0,
},
server: {
socketType: "WebSocket",
serverOptions: {
"host": "host.com",
"port": 99
},
deniedIPs: ["192.168.5.5"],
allowedIPs: ["127.0.0.1", "localhost"],
},
maxConnections: 1
},
keyPair: {
publicKey: Buffer.alloc(0),
secretKey: Buffer.alloc(0)
},
discriminator: Buffer.alloc(0),
serverPublicKey: Buffer.alloc(0),
maxConnectionsPerClient: 1
});
//@ts-ignore
handshakeFactory.increaseCounter("ABBA");
//@ts-ignore
let overflows = handshakeFactory.checkClientsOverflow("ABBA");
assert(overflows == true);
});
}
@Test()
public within_range() {
assert.doesNotThrow(async () => {
let handshakeFactory = new HandshakeFactory({
pingInterval: 0,
socketFactoryConfig: {
client: {
socketType: "TCP",
clientOptions: {
"host": "host.com",
"port": 99
},
reconnectDelay: 0,
},
server: {
socketType: "WebSocket",
serverOptions: {
"host": "host.com",
"port": 99
},
deniedIPs: ["192.168.5.5"],
allowedIPs: ["127.0.0.1", "localhost"],
},
maxConnections: 1
},
keyPair: {
publicKey: Buffer.alloc(0),
secretKey: Buffer.alloc(0)
},
discriminator: Buffer.alloc(0),
serverPublicKey: Buffer.alloc(0),
maxConnectionsPerClient: 2
});
//@ts-ignore
handshakeFactory.increaseCounter("ABBA");
//@ts-ignore
let overflows = handshakeFactory.checkClientsOverflow("ABBA");
assert(overflows == false);
});
}
}
@TestSuite()
export class HandshakeFactoryOnHandshakeError {
@Test()
public successful_call() {
assert.doesNotThrow(async () => {
let handshakeFactory = new HandshakeFactory({
pingInterval: 0,
socketFactoryConfig: {
client: {
socketType: "TCP",
clientOptions: {
"host": "host.com",
"port": 99
},
reconnectDelay: 0,
},
server: {
socketType: "WebSocket",
serverOptions: {
"host": "host.com",
"port": 99
},
deniedIPs: ["192.168.5.5"],
allowedIPs: ["127.0.0.1", "localhost"],
},
maxConnections: 0
},
keyPair: {
publicKey: Buffer.alloc(0),
secretKey: Buffer.alloc(0)
},
discriminator: Buffer.alloc(0),
serverPublicKey: Buffer.alloc(0),
});
//@ts-ignore
handshakeFactory.hookEvent = function(name, callback) {
assert(name == "HANDSHAKE_ERROR");
assert(callback == cb);
};
const cb = function() {
}
handshakeFactory.onHandshakeError(cb);
});
}
}
@TestSuite()
export class HandshakeFactoryOnHandshake {
@Test()
public successful_call() {
assert.doesNotThrow(async () => {
let handshakeFactory = new HandshakeFactory({
pingInterval: 0,
socketFactoryConfig: {
client: {
socketType: "TCP",
clientOptions: {
"host": "host.com",
"port": 99
},
reconnectDelay: 0,
},
server: {
socketType: "WebSocket",
serverOptions: {
"host": "host.com",
"port": 99
},
deniedIPs: ["192.168.5.5"],
allowedIPs: ["127.0.0.1", "localhost"],
},
maxConnections: 0
},
keyPair: {
publicKey: Buffer.alloc(0),
secretKey: Buffer.alloc(0)
},
discriminator: Buffer.alloc(0),
serverPublicKey: Buffer.alloc(0),
});
//@ts-ignore
handshakeFactory.hookEvent = function(name, callback) {
assert(name == "HANDSHAKE");
assert(callback == cb);
};
const cb = function() {
}
handshakeFactory.onHandshake(cb);
});
}
}