smartsocket/test/test.expressserver.ts

118 lines
3.4 KiB
TypeScript
Raw Normal View History

2019-04-24 15:57:16 +00:00
// tslint:disable-next-line:no-implicit-dependencies
import { expect, tap } from '@pushrocks/tapbundle';
import * as isohash from '@pushrocks/isohash';
2019-04-24 15:57:16 +00:00
import * as smartexpress from '@pushrocks/smartexpress';
import smartsocket = require('../ts/index');
let testSmartsocket: smartsocket.Smartsocket;
let testSmartsocketClient: smartsocket.SmartsocketClient;
let testSocketRole1: smartsocket.SocketRole;
2019-09-09 21:58:32 +00:00
let testSocketFunction1: smartsocket.SocketFunction<any>;
2019-04-24 15:57:16 +00:00
let myseServer: smartexpress.Server;
const testConfig = {
2020-12-16 01:38:57 +00:00
port: 3005,
2019-04-24 15:57:16 +00:00
};
// class smartsocket
tap.test('should create a new smartsocket', async () => {
testSmartsocket = new smartsocket.Smartsocket({ port: testConfig.port });
expect(testSmartsocket).be.instanceOf(smartsocket.Smartsocket);
});
tap.test('Should accept an smartExpressServer as server', async () => {
myseServer = new smartexpress.Server({
cors: true,
forceSsl: false,
2020-09-24 18:04:11 +00:00
port: testConfig.port,
2019-04-24 15:57:16 +00:00
});
testSmartsocket.setExternalServer('smartexpress', myseServer);
await myseServer.start();
});
// class socketrole
tap.test('should add a socketrole', async () => {
testSocketRole1 = new smartsocket.SocketRole({
name: 'testRole1',
passwordHash: await isohash.sha256FromString('testPassword'),
2019-04-24 15:57:16 +00:00
});
testSmartsocket.addSocketRoles([testSocketRole1]);
});
// class SocketFunction
tap.test('should register a new Function', async () => {
testSocketFunction1 = new smartsocket.SocketFunction({
allowedRoles: [testSocketRole1],
2019-08-12 20:31:40 +00:00
funcDef: async (dataArg, socketConnectionArg) => {
2019-04-24 15:57:16 +00:00
return dataArg;
},
2020-09-24 18:04:11 +00:00
funcName: 'testFunction1',
2019-04-24 15:57:16 +00:00
});
2019-08-12 20:31:40 +00:00
testSmartsocket.addSocketFunction(testSocketFunction1);
console.log(testSmartsocket.socketFunctions);
});
tap.test('should start listening when .started is called', async () => {
await testSmartsocket.start();
2019-04-24 15:57:16 +00:00
});
// class SmartsocketClient
tap.test('should react to a new websocket connection from client', async () => {
testSmartsocketClient = new smartsocket.SmartsocketClient({
port: testConfig.port,
url: 'http://localhost',
password: 'testPassword',
alias: 'testClient1',
2020-09-24 18:04:11 +00:00
role: 'testRole1',
2019-04-24 15:57:16 +00:00
});
2019-08-12 20:31:40 +00:00
testSmartsocketClient.addSocketFunction(testSocketFunction1);
console.log(testSmartsocketClient.socketFunctions);
await testSmartsocketClient.connect();
2019-04-24 15:57:16 +00:00
});
2019-08-12 20:31:40 +00:00
2020-09-24 18:04:11 +00:00
tap.test('client should disconnect and reconnect', async (tools) => {
2019-08-12 20:31:40 +00:00
await testSmartsocketClient.disconnect();
await tools.delayFor(100);
await testSmartsocketClient.connect();
2019-04-24 15:57:16 +00:00
});
tap.test('2 clients should connect in parallel', async () => {
// TODO: implement parallel test
});
tap.test('should be able to make a functionCall from client to server', async () => {
2020-12-16 02:20:28 +00:00
const totalCycles = 20000;
2020-12-16 01:38:57 +00:00
let counter = 0;
let startTime = Date.now();
while (counter < totalCycles) {
2020-12-16 02:20:28 +00:00
const randomString = `hello ${Math.random()}`;
const response: any = await testSmartsocketClient.serverCall('testFunction1', {
value1: randomString,
2020-12-16 01:38:57 +00:00
});
2020-12-16 02:20:28 +00:00
expect(response.value1).to.equal(randomString);
2020-12-16 01:38:57 +00:00
if (counter % 100 === 0) {
2020-12-16 02:20:28 +00:00
console.log(
`processed 100 more messages in ${Date.now() - startTime}ms. ${
totalCycles - counter
} messages to go.`
);
2020-12-16 01:38:57 +00:00
startTime = Date.now();
2020-12-16 02:20:28 +00:00
}
2020-12-16 01:38:57 +00:00
counter++;
}
2019-04-24 15:57:16 +00:00
});
2019-08-12 20:46:57 +00:00
tap.test('should be able to make a functionCall from server to client', async () => {});
2019-04-24 15:57:16 +00:00
// terminate
tap.test('should close the server', async () => {
await testSmartsocket.stop();
await myseServer.stop();
});
tap.start();