Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
import {
afterEach,
beforeAll,
beforeEach,
describe,
expect,
test,
} from 'vitest';
import type { WebSocketServer, WebSocket as WsWebSocket } from 'ws';
import type { WebsocketBuffer } from '../';
import {
ArrayQueue,
type Backoff,
ConstantBackoff,
Websocket,
WebsocketBuilder,
WebsocketEvent,
type WebsocketEventListenerParams,
} from '../';
import { JsonSerializer } from '../core/serializers/json-serializer';
import { untilEvent } from '../utils/until-event';
import {
closeServer,
getListenersWithOptions,
onStringMessageReceived,
startServer,
stopClient,
stopServer,
waitForClientToConnectToServer,
} from './websocket-test-utils';
describe('Testsuite for Websocket', () => {
const port: number = process.env.PORT ? parseInt(process.env.PORT) : 41337;
const url: string = process.env.URL ?? `ws://localhost:${port}`;
const serverTimeout: number = process.env.SERVER_TIMEOUT
? parseInt(process.env.SERVER_TIMEOUT)
: 5_000;
const clientTimeout: number = process.env.CLIENT_TIMEOUT
? parseInt(process.env.CLIENT_TIMEOUT)
: 5_000;
const testTimeout: number = process.env.TEST_TIMEOUT
? parseInt(process.env.TEST_TIMEOUT)
: 10_000;
let client: Websocket | undefined; // subject under test
let server: WebSocketServer | undefined; // websocket server used for testing
/** Before all tests, log the test configuration. */
beforeAll(() =>
console.log(
`Testing websocket on ${url}, server timeout: ${serverTimeout}ms, client timeout: ${clientTimeout}ms`
)
);
/** Before each test, start a websocket server on the given port. */
beforeEach(async () => {
await startServer(port, serverTimeout).then((s) => {
server = s;
});
}, testTimeout);
/** After each test, stop the websocket server. */
afterEach(async () => {
await stopClient(client, clientTimeout).then(() => {
client = undefined;
});
await stopServer(server, serverTimeout).then(() => {
server = undefined;
});
}, testTimeout);
describe('Getter/setter tests', () => {
describe('Url', () => {
test('Websocket should return the correct url', () => {
const client = new Websocket(url);
expect(client.url).toBe(url);
});
});
describe('Protocols', () => {
test('Websocket should return the correct protocols when protocols are a string', () => {
const protocols = 'protocol1';
const client = new Websocket(url, protocols);
expect(client.protocols).toEqual(protocols);
});
test('Websocket should return the correct protocols when protocols are an array', () => {
const protocols = ['protocol1', 'protocol2'];
const client = new Websocket(url, protocols);
expect(client.protocols).toEqual(protocols);
});
test('Websocket should return the correct protocols when protocols are undefined', () => {
const client = new Websocket(url);
expect(client.protocols).toBeUndefined();
});
});
describe('Buffer', () => {
test('Websocket should return the correct buffer when buffer is undefined', () => {
const client = new Websocket(url);
expect(client.buffer).toBeUndefined();
});
test('Websocket should return the correct buffer when buffer is set', () => {
const buffer: WebsocketBuffer = new ArrayQueue();
const client = new Websocket(url, undefined, { buffer });
expect(client.buffer).toBe(buffer);
});
});
describe('MaxRetries', () => {
test('Websocket should return the correct maxRetries when maxRetries is undefined', () => {
const client = new Websocket(url);
expect(client.maxRetries).toBeUndefined();
});
test('Websocket should return the correct maxRetries when maxRetries is set', () => {
const maxRetries = 5;
const client = new Websocket(url, undefined, { retry: { maxRetries } });
expect(client.maxRetries).toBe(maxRetries);
});
});
describe('InstantReconnect', () => {
test('Websocket should return the correct instantReconnect when instantReconnect is undefined', () => {
const client = new Websocket(url);
expect(client.instantReconnect).toBeUndefined();
});
test('Websocket should return the correct instantReconnect when instantReconnect is set', () => {
const instantReconnect = true;
const client = new Websocket(url, undefined, {
retry: { instantReconnect },
});
expect(client.instantReconnect).toBe(instantReconnect);
});
});
describe('Backoff', () => {
test('Websocket should return the correct backoff when backoff is undefined', () => {
const client = new Websocket(url);
expect(client.backoff).toBeUndefined();
});
test('Websocket should return the correct backoff when backoff is set', () => {
const backoff: Backoff = new ConstantBackoff(1000);
const client = new Websocket(url, undefined, { retry: { backoff } });
expect(client.backoff).toBe(backoff);
});
});
describe('ClosedByUser', () => {
test('Websocket should return false after initialization', () => {
const client = new Websocket(url);
expect(client.closedByUser).toBe(false);
});
test('Websocket should return true after the client closes the connection', async () => {
await new Promise<WebsocketEventListenerParams<WebsocketEvent.Close>>(
(resolve) => {
client = new WebsocketBuilder(url)
.onOpen((instance) => instance.close())
.onClose((instance, ev) => resolve([instance, ev]))
.build();
}
).then(([instance, ev]) => {
expect(instance).toBe(client);
expect(ev.type).toBe(WebsocketEvent.Close);
expect(instance.closedByUser).toBe(true);
});
});
test('Websocket should return false if the server closes the connection', async () => {
await new Promise<WebsocketEventListenerParams<WebsocketEvent.Close>>(
(resolve) => {
client = new WebsocketBuilder(url)
.onOpen(() => closeServer(server))
.onClose((instance, ev) => resolve([instance, ev]))
.build();
}
).then(([instance, ev]) => {
expect(instance).toBe(client);
expect(ev.type).toBe(WebsocketEvent.Close);
expect(instance.closedByUser).toBe(false);
});
});
});
describe('LastConnection', () => {
test('Websocket should return undefined after initialization', () => {
const client = new Websocket(url);
expect(client.lastConnection).toBeUndefined();
});
test('Websocket should return the correct date after the client connects to the server', async () => {
await new Promise<WebsocketEventListenerParams<WebsocketEvent.Open>>(
(resolve) => {
client = new WebsocketBuilder(url)
.onOpen((instance, ev) => resolve([instance, ev]))
.build();
}
).then(([instance, ev]) => {
expect(instance).toBe(client);
expect(ev.type).toBe(WebsocketEvent.Open);
expect(instance.lastConnection).not.toBeUndefined();
});
});
});
describe('UnderlyingWebsocket', () => {
test('Websocket should return native websocket after initialization', async () => {
const client = new Websocket(url);
await untilEvent(client, WebsocketEvent.UrlResolved);
expect(client.underlyingWebsocket).not.toBeUndefined();
expect(client.underlyingWebsocket).toBeInstanceOf(WebSocket);
});
test('Websocket should return the underlying websocket after the client connects to the server', async () => {
await new Promise<WebsocketEventListenerParams<WebsocketEvent.Open>>(
(resolve) => {
client = new WebsocketBuilder(url)
.onOpen((instance, ev) => resolve([instance, ev]))
.build();
}
).then(([instance, ev]) => {
expect(instance).toBe(client);
expect(ev.type).toBe(WebsocketEvent.Open);
expect(instance.underlyingWebsocket).not.toBeUndefined();
expect(instance.underlyingWebsocket).toBeInstanceOf(WebSocket);
});
});
test('Websocket should return the underlying websocket after the client closes the connection', async () => {
await new Promise<WebsocketEventListenerParams<WebsocketEvent.Close>>(
(resolve) => {
client = new WebsocketBuilder(url)
.onOpen((instance) => instance.close())
.onClose((instance, ev) => resolve([instance, ev]))
.build();
}
).then(([instance, ev]) => {
expect(instance).toBe(client);
expect(ev.type).toBe(WebsocketEvent.Close);
expect(instance.underlyingWebsocket).not.toBeUndefined();
expect(instance.underlyingWebsocket).toBeInstanceOf(WebSocket);
expect(instance.underlyingWebsocket!.readyState).toBe(
WebSocket.CLOSED
);
});
});
test('Websocket should return the underlying websocket after the server closes the connection', async () => {
await new Promise<WebsocketEventListenerParams<WebsocketEvent.Close>>(
(resolve) => {
client = new WebsocketBuilder(url)
.onOpen(() => closeServer(server))
.onClose((instance, ev) => resolve([instance, ev]))
.build();
}
).then(([instance, ev]) => {
expect(instance).toBe(client);
expect(ev.type).toBe(WebsocketEvent.Close);
expect(instance.underlyingWebsocket).not.toBeUndefined();
expect(instance.underlyingWebsocket).toBeInstanceOf(WebSocket);
expect(instance.underlyingWebsocket!.readyState).toBe(
WebSocket.CLOSED
);
});
});
});
describe('ReadyState', () => {
test('Websocket should return the correct readyState after initialization', async () => {
const client = new Websocket(url);
await untilEvent(client, WebsocketEvent.UrlResolved);
expect(client.readyState).toBe(WebSocket.CONNECTING);
});
test('Websocket should return the correct readyState after the client connects to the server', async () => {
await new Promise<WebsocketEventListenerParams<WebsocketEvent.Open>>(
(resolve) => {
client = new WebsocketBuilder(url)
.onOpen((instance, ev) => resolve([instance, ev]))
.build();
}
).then(([instance, ev]) => {
expect(instance).toBe(client);
expect(ev.type).toBe(WebsocketEvent.Open);
expect(instance.readyState).toBe(WebSocket.OPEN);
});
});
test('Websocket should return the correct readyState after the client closes the connection', async () => {
await new Promise<WebsocketEventListenerParams<WebsocketEvent.Close>>(
(resolve) => {
client = new WebsocketBuilder(url)
.onOpen((instance) => instance.close())
.onClose((instance, ev) => resolve([instance, ev]))
.build();
}
).then(([instance, ev]) => {
expect(instance).toBe(client);
expect(ev.type).toBe(WebsocketEvent.Close);
expect(instance.readyState).toBe(WebSocket.CLOSED);
});
});
});
describe('BufferedAmount', () => {
test('Websocket should return the correct bufferedAmount after initialization', async () => {
const client = new Websocket(url);
await untilEvent(client, WebsocketEvent.UrlResolved);
expect(client.bufferedAmount).toBe(0);
});
});
describe('Extensions', () => {
test('Websocket should return the correct extensions after initialization', async () => {
const client = new Websocket(url);
await untilEvent(client, WebsocketEvent.UrlResolved);
expect(client.extensions).toBe('');
});
});
describe('BinaryType', () => {
test('Websocket should return the correct binaryType after initialization', () => {
const client = new Websocket(url);
expect(client.binaryType).toBe('blob');
});
test('Websocket should return the correct binaryType after setting it', () => {
const client = new Websocket(url);
client.binaryType = 'arraybuffer';
expect(client.binaryType).toBe('arraybuffer');
});
});
});
describe('Event tests', () => {
describe('Open', () => {
test(
"Websocket should fire 'open' when connecting to a server and the underlying websocket should be in readyState 'OPEN'",
async () => {
await new Promise<WebsocketEventListenerParams<WebsocketEvent.Open>>(
(resolve) => {
client = new WebsocketBuilder(url)
.onOpen((instance, ev) => resolve([instance, ev]))
.build();
}
).then(([instance, ev]) => {
expect(instance).toBe(client);
expect(ev.type).toBe(WebsocketEvent.Open);
expect(instance.underlyingWebsocket).not.toBeUndefined();
expect(instance.underlyingWebsocket!.readyState).toBe(
WebSocket.OPEN
);
});
},
testTimeout
);
test("Websocket should fire 'open' when reconnecting to a server and the underlying websocket should be in readyState 'OPEN'", async () => {
await new Promise<WebsocketEventListenerParams<WebsocketEvent.Open>>(
(resolve) => {
client = new WebsocketBuilder(url)
.withBackoff(new ConstantBackoff(0))
.onOpen((instance, ev) => resolve([instance, ev]))
.build();
}
).then(([instance, ev]) => {
expect(instance).toBe(client);
expect(ev.type).toBe(WebsocketEvent.Open);
expect(instance.underlyingWebsocket).not.toBeUndefined();
expect(instance.underlyingWebsocket!.readyState).toBe(WebSocket.OPEN);
});
});
test("Websocket shouldn't fire 'open' when it was removed from the event listeners", async () => {
let timesOpenFired = 0;
const onOpen = () => timesOpenFired++;
const clientConnectionPromise = waitForClientToConnectToServer(
server,
clientTimeout
);
await new Promise<WebsocketEventListenerParams<WebsocketEvent.Open>>(
(resolve) => {
client = new WebsocketBuilder(url)
.withBackoff(new ConstantBackoff(100)) // try to reconnect after 100ms, 'open' should only fire once
.onOpen(
(i, ev) => {
timesOpenFired++;
resolve([i, ev]);
},
{ once: true }
) // initial 'open' event, should only fire once
.build();
}
);
// this resolves after the client has connected to the server, disconnect it right after
await clientConnectionPromise;
expect(timesOpenFired).toBe(1);
expect(
getListenersWithOptions(client, WebsocketEvent.Open)
).toHaveLength(0); // since the initial listener was a 'once'-listener, this should be empty
client!.addEventListener(WebsocketEvent.Open, onOpen); // add a new listener
expect(
getListenersWithOptions(client, WebsocketEvent.Open)
).toHaveLength(1); // since the initial listener was a 'once'-listener, this should be empty
server?.clients.forEach((c: WsWebSocket) => c.close());
// wait for the client to reconnect after 100ms
await waitForClientToConnectToServer(server, clientTimeout);
await new Promise((resolve) => setTimeout(resolve, 100)); // wait some extra time for client-side event to be fired
expect(timesOpenFired).toBe(2);
expect(
getListenersWithOptions(client, WebsocketEvent.Open)
).toHaveLength(1); // since the initial listener was a 'once'-listener, this should be empty
// remove the event-listener, disconnect again
client!.removeEventListener(WebsocketEvent.Open, onOpen);
expect(
getListenersWithOptions(client, WebsocketEvent.Open)
).toHaveLength(0);
server?.clients.forEach((c: WsWebSocket) => c.close());
// wait for the client to reconnect after 100ms, 'open' should not fire again and timesOpenFired will still be 2
await waitForClientToConnectToServer(server, clientTimeout);
await new Promise((resolve) => setTimeout(resolve, 100));
expect(timesOpenFired).toBe(2);
});
});
describe('Close', () => {
test(
"Websocket should fire 'close' when the server closes the connection and the underlying websocket should be in readyState 'CLOSED'",
async () => {
await new Promise<WebsocketEventListenerParams<WebsocketEvent.Close>>(
(resolve) => {
client = new WebsocketBuilder(url)
.onOpen(() => closeServer(server))
.onClose((instance, ev) => resolve([instance, ev]))
.build();
}
).then(([instance, ev]) => {
expect(instance).toBe(client);
expect(ev.type).toBe(WebsocketEvent.Close);
expect(instance.closedByUser).toBe(false);
expect(instance.underlyingWebsocket).not.toBeUndefined();
expect(instance.underlyingWebsocket!.readyState).toBe(
WebSocket.CLOSED
);
});
},
testTimeout
);
test("Websocket should fire 'close' when the client closes the connection and the underlying websocket should be in readyState 'CLOSED'", async () => {
await new Promise<WebsocketEventListenerParams<WebsocketEvent.Close>>(
(resolve) => {
client = new WebsocketBuilder(url)
.onOpen((instance) => instance.close())
.onClose((instance, ev) => resolve([instance, ev]))
.build();
}
).then(([instance, ev]) => {
expect(instance).toBe(client);
expect(ev.type).toBe(WebsocketEvent.Close);
expect(instance.closedByUser).toBe(true);
expect(instance.underlyingWebsocket).not.toBeUndefined();
expect(instance.underlyingWebsocket!.readyState).toBe(
WebSocket.CLOSED
);
});
});
test("Websocket should fire 'close' when the server closes the connection with a status code other than 1000 and the underlying websocket should be in readyState 'CLOSED'", async () => {
await new Promise<WebsocketEventListenerParams<WebsocketEvent.Close>>(
(resolve) => {
client = new WebsocketBuilder(url)
.onOpen(() =>
server?.clients.forEach((client: WsWebSocket) =>
client.close(1001, 'CLOSE_GOING_AWAY')
)
)
.onClose((instance, ev) => resolve([instance, ev]))
.build();
}
).then(([instance, ev]) => {
expect(instance).toBe(client);
expect(ev.type).toBe(WebsocketEvent.Close);
expect(ev.code).toBe(1001);
expect(ev.reason).toBe('CLOSE_GOING_AWAY');
expect(ev.wasClean).toBe(true);
expect(instance.closedByUser).toBe(false);
expect(instance.underlyingWebsocket).not.toBeUndefined();
expect(instance.underlyingWebsocket!.readyState).toBe(
WebSocket.CLOSED
);
});
});
test("Websocket should fire 'close' when the client closes the connection with a status code other than 1000 and the underlying websocket should be in readyState 'CLOSED'", async () => {
await new Promise<WebsocketEventListenerParams<WebsocketEvent.Close>>(
(resolve) => {
client = new WebsocketBuilder(url)
.onOpen((instance) =>
instance.close(4000, 'APPLICATION_IS_SHUTTING_DOWN')
)
.onClose((instance, ev) => resolve([instance, ev]))
.build();
}
).then(([instance, ev]) => {
expect(instance).toBe(client);
expect(ev.type).toBe(WebsocketEvent.Close);
expect(ev.code).toBe(4000);
expect(ev.reason).toBe('APPLICATION_IS_SHUTTING_DOWN');
expect(ev.wasClean).toBe(true);
expect(instance.closedByUser).toBe(true);
expect(instance.underlyingWebsocket).not.toBeUndefined();
expect(instance.underlyingWebsocket!.readyState).toBe(
WebSocket.CLOSED
);
});
});
});
describe('Error', () => {
test("Websocket should fire 'error' when the server rejects the connection and the underlying websocket should be in readyState 'CLOSED", async () => {
await stopServer(server, serverTimeout).then(() => {
server = undefined;
});
await new Promise<WebsocketEventListenerParams<WebsocketEvent.Error>>(
(resolve) => {
client = new WebsocketBuilder(url)
.onError((instance, ev) => resolve([instance, ev]))
.build();
}
).then(([instance, ev]) => {
expect(instance).toBe(client);
expect(ev.type).toBe(WebsocketEvent.Error);
expect(instance.underlyingWebsocket).not.toBeUndefined();
expect(instance.underlyingWebsocket!.readyState).toBe(
WebSocket.CLOSED
);
});
});
});
describe('Message', () => {
test("Websocket should fire 'message' when the server sends a message", async () => {
await new Promise<WebsocketEventListenerParams<WebsocketEvent.Message>>(
(resolve) => {
client = new WebsocketBuilder(url)
.onOpen(() =>
server?.clients.forEach((client: WsWebSocket) =>
client.send('Hello')
)
)
.onMessage((instance, ev) => {
expect(ev.data).toBe('Hello');
resolve([instance, ev]);
})
.build();
}
).then(([instance, ev]) => {
expect(instance).toBe(client);
expect(ev.type).toBe(WebsocketEvent.Message);
expect(ev.data).toBe('Hello');
});
});
});
describe('Retry & Reconnect', () => {
test("Websocket should not emit 'retry' on the first connection attempt, emit it when retrying and emit 'reconnect' when it reconnects", async () => {
let [openCount, retryCount, reconnectCount] = [0, 0, 0];
const onOpen = () => openCount++;
const onRetry = () => retryCount++;
const onReconnect = () => reconnectCount++;
await new Promise<WebsocketEventListenerParams<WebsocketEvent.Open>>(
(resolve) => {
client = new WebsocketBuilder(url)
.withBackoff(new ConstantBackoff(0)) // immediately retry
.onOpen((instance, ev) => resolve([instance, ev]))
.onOpen(onOpen)
.onRetry(onRetry)
.onReconnect(onReconnect)
.build();
}
).then(([instance, ev]) => {
expect(instance).toBe(client);
expect(ev.type).toBe(WebsocketEvent.Open);
});
// give some time for all handlers to be called
await new Promise((resolve) => setTimeout(resolve, 100));
expect(openCount).toBe(1);
expect(retryCount).toBe(0);
expect(reconnectCount).toBe(0);
// disconnect all clients and give some time for the retry to happen
server?.clients.forEach((client: WsWebSocket) => client.close());
await new Promise((resolve) => setTimeout(resolve, 100));
// ws should have retried & reconnect
expect(openCount).toBe(2);
expect(retryCount).toBe(1);
expect(reconnectCount).toBe(1);
});
});
});
describe('Reconnect behaviour', () => {
describe('InstantReconnect', () => {
test('Websocket should try to reconnect immediately when instantReconnect is true', async () => {
let [openCount, retryCount, reconnectCount] = [0, 0, 0];
const onOpen = () => openCount++;
const onRetry = () => retryCount++;
const onReconnect = () => reconnectCount++;
await new Promise<WebsocketEventListenerParams<WebsocketEvent.Open>>(
(resolve) => {
client = new WebsocketBuilder(url)
.withBackoff(new ConstantBackoff(1000)) // retry after 1 second
.withInstantReconnect(true) // reconnect immediately, don't wait for the backoff for the first retry
.onOpen((instance, ev) => resolve([instance, ev]))
.onOpen(onOpen)
.onRetry(onRetry)
.onReconnect(onReconnect)
.build();
}
).then(([instance, ev]) => {
expect(instance).toBe(client);
expect(ev.type).toBe(WebsocketEvent.Open);
});
// give some time for all handlers to be called
await new Promise((resolve) => setTimeout(resolve, 100));
expect(openCount).toBe(1);
expect(retryCount).toBe(0);
expect(reconnectCount).toBe(0);
// disconnect all clients and give some time for the retry to happen
server?.clients.forEach((client: WsWebSocket) => client.close());
await new Promise((resolve) => setTimeout(resolve, 100));
// ws should have retried & reconnect
expect(openCount).toBe(2);
expect(retryCount).toBe(1);
expect(reconnectCount).toBe(1);
});
test('Websocket should not try to reconnect immediately when instantReconnect is false', async () => {
let [openCount, retryCount, reconnectCount] = [0, 0, 0];
const onOpen = () => openCount++;
const onRetry = () => retryCount++;
const onReconnect = () => reconnectCount++;
await new Promise<WebsocketEventListenerParams<WebsocketEvent.Open>>(
(resolve) => {
client = new WebsocketBuilder(url)
.withBackoff(new ConstantBackoff(1000)) // retry after 1 second
.withInstantReconnect(false) // reconnect immediately, don't wait for the backoff for the first retry
.onOpen((instance, ev) => resolve([instance, ev]))
.onOpen(onOpen)
.onRetry(onRetry)
.onReconnect(onReconnect)
.build();
}
).then(([instance, ev]) => {
expect(instance).toBe(client);
expect(ev.type).toBe(WebsocketEvent.Open);
});
// give some time for all handlers to be called
await new Promise((resolve) => setTimeout(resolve, 100));
expect(openCount).toBe(1);
expect(retryCount).toBe(0);
expect(reconnectCount).toBe(0);
// disconnect all clients and give some time for the retry to happen
server?.clients.forEach((client: WsWebSocket) => client.close());
await new Promise((resolve) => setTimeout(resolve, 100));
// ws shouldn't have retried & reconnect
expect(openCount).toBe(1);
expect(retryCount).toBe(0);
expect(reconnectCount).toBe(0);
// give some time for the retry to happen
await new Promise((resolve) => setTimeout(resolve, 1000));
expect(openCount).toBe(2);
expect(retryCount).toBe(1);
expect(reconnectCount).toBe(1);
});
});
describe('MaxRetries', () => {
test('Websocket should stop trying to reconnect when maxRetries is reached', async () => {
let [openCount, retryCount, reconnectCount] = [0, 0, 0];
const onOpen = () => openCount++;
const onRetry = () => retryCount++;
const onReconnect = () => reconnectCount++;
await new Promise<WebsocketEventListenerParams<WebsocketEvent.Open>>(
(resolve) => {
client = new WebsocketBuilder(url)
.withBackoff(new ConstantBackoff(0)) // retry after 1 second
.withMaxRetries(5) // retry 5 times
.onOpen((instance, ev) => resolve([instance, ev]))
.onOpen(onOpen)
.onRetry(onRetry)
.onReconnect(onReconnect)
.build();
}
).then(([instance, ev]) => {
expect(instance).toBe(client);
expect(ev.type).toBe(WebsocketEvent.Open);
});
// give some time for all handlers to be called
await new Promise((resolve) => setTimeout(resolve, 100));
expect(openCount).toBe(1);
expect(retryCount).toBe(0);
expect(reconnectCount).toBe(0);
// stop server so that the client can't reconnect
await stopServer(server, serverTimeout);
await new Promise((resolve) => setTimeout(resolve, 100));
// ws should have retried but not reconnect
expect(openCount).toBe(1);
expect(retryCount).toBe(5);
expect(reconnectCount).toBe(0);
});
});
});
describe('Send', () => {
test('Websocket should send a message to the server and the server should receive it', async () => {
const serverReceivedMessage = new Promise<string>((resolve) => {
server?.on('connection', (client: WsWebSocket) => {
client?.on(
'message',
onStringMessageReceived((str: string) => {
resolve(str);
})
);
});
});
await new Promise<WebsocketEventListenerParams<WebsocketEvent.Open>>(
(resolve) => {
client = new WebsocketBuilder(url)
.onOpen((instance, ev) => {
instance.send('Hello');
resolve([instance, ev]);
})
.build();
}
).then(([instance, ev]) => {
expect(instance).toBe(client);
expect(ev.type).toBe(WebsocketEvent.Open);
expect(instance.underlyingWebsocket).not.toBeUndefined();
expect(instance.underlyingWebsocket!.readyState).toBe(WebSocket.OPEN);
});
await serverReceivedMessage.then((message) =>
expect(message).toBe('Hello')
);
});
test('Websocket should send a message to the server and the server should receive it as a Uint8Array', async () => {
const serverReceivedMessage = new Promise<Uint8Array>((resolve) => {
server?.on('connection', (client: WsWebSocket) => {
client?.on('message', (message: Uint8Array) => {
resolve(message);
});
});
});
await new Promise<WebsocketEventListenerParams<WebsocketEvent.Open>>(
(resolve) => {
client = new WebsocketBuilder(url)
.onOpen((instance, ev) => {
instance.send(new Uint8Array([1, 2, 3]));
resolve([instance, ev]);
})
.build();
}
).then(([instance, ev]) => {
expect(instance).toBe(client);
expect(ev.type).toBe(WebsocketEvent.Open);
expect(instance.underlyingWebsocket).not.toBeUndefined();
expect(instance.underlyingWebsocket!.readyState).toBe(WebSocket.OPEN);
});
await serverReceivedMessage.then((message) => {
expect(Buffer.from(message).equals(Buffer.from([1, 2, 3]))).toBe(true);
});
});
test('Websocket should buffer messages sent before the connection is open and send them when the connection is open', async () => {
const messagesReceived: string[] = [];
const serverReceivedMessages = new Promise<string[]>((resolve) => {
server?.on('connection', (client: WsWebSocket) => {
client?.on(
'message',
onStringMessageReceived((str: string) => {
messagesReceived.push(str);
if (messagesReceived.length === 2) {
resolve(messagesReceived);
}
})
);
});
});
await new Promise<WebsocketEventListenerParams<WebsocketEvent.Open>>(
(resolve) => {
client = new WebsocketBuilder(url)
.withBuffer(new ArrayQueue())
.onOpen((instance, ev) => {
setTimeout(() => {
instance.send('Hello2');
resolve([instance, ev]);
}, 100);
})
.build();
client.send('Hello1'); // This message should be buffered
}
).then(([instance, ev]) => {
expect(instance).toBe(client);
expect(ev.type).toBe(WebsocketEvent.Open);
expect(instance.underlyingWebsocket).not.toBeUndefined();
expect(instance.underlyingWebsocket!.readyState).toBe(WebSocket.OPEN);
});
await serverReceivedMessages.then((messages) => {
expect(messages).toEqual(['Hello1', 'Hello2']);
});
});
test('Websocket send should short circuit if the websocket was closed by user', async () => {
await new Promise<WebsocketEventListenerParams<WebsocketEvent.Open>>(
(resolve) => {
client = new WebsocketBuilder(url)
.onOpen((instance, ev) => resolve([instance, ev]))
.build();
}
).then(([instance, ev]) => {
expect(instance).toBe(client);
expect(ev.type).toBe(WebsocketEvent.Open);
expect(instance.underlyingWebsocket).not.toBeUndefined();
expect(instance.underlyingWebsocket!.readyState).toBe(WebSocket.OPEN);
// close the websocket and send a message
instance.close();
instance.send('This send should short circuit');
});
});
});
describe('Send/Receive with serializer', () => {
test('Websocket should send a message to the server and the server should receive it', async () => {
let client: Websocket<Record<any, any>, Record<any, any>> | undefined;
const serverReceivedMessage = new Promise<string>((resolve) => {
server?.on('connection', (client: WsWebSocket) => {
client?.on(
'message',
onStringMessageReceived((str: string) => {
resolve(str);
})
);
});
});
await new Promise<
WebsocketEventListenerParams<
WebsocketEvent.Open,
Record<any, any>,
Record<any, any>
>
>((resolve) => {
client = new WebsocketBuilder(url)
.withSerializer(
new JsonSerializer<Record<any, any>, Record<any, any>>()
)
.onOpen((instance, ev) => {
instance.send({ message: 'Hello' });
resolve([instance, ev]);
})
.build();
}).then(([instance, ev]) => {
expect(instance).toBe(client);
expect(ev.type).toBe(WebsocketEvent.Open);
});
await serverReceivedMessage.then((message) =>
expect(message).toBe(JSON.stringify({ message: 'Hello' }))
);
stopClient(client as any, clientTimeout);
});
test('Websocket should buffer messages sent before the connection is open and send them when the connection is open', async () => {
let client: Websocket<Record<any, any>, Record<any, any>> | undefined;
const messagesReceived: string[] = [];
const serverReceivedMessages = new Promise<string[]>((resolve) => {
server?.on('connection', (client: WsWebSocket) => {
client?.on(
'message',
onStringMessageReceived((str: string) => {
messagesReceived.push(str);
if (messagesReceived.length === 2) {
resolve(messagesReceived);
}
})
);
});
});
await new Promise<
WebsocketEventListenerParams<
WebsocketEvent.Open,
Record<any, any>,
Record<any, any>
>
>((resolve) => {
client = new WebsocketBuilder(url)
.withSerializer(
new JsonSerializer<Record<any, any>, Record<any, any>>()
)
.withBuffer(new ArrayQueue())
.onOpen((instance, ev) => {
setTimeout(() => {
instance.send({ message: 'Hello2' });
resolve([instance, ev]);
}, 100);
})
.build();
client.send({ message: 'Hello1' }); // This message should be buffered
}).then(([instance, ev]) => {
expect(instance).toBe(client);
expect(ev.type).toBe(WebsocketEvent.Open);
expect(instance.underlyingWebsocket).not.toBeUndefined();
expect(instance.underlyingWebsocket!.readyState).toBe(WebSocket.OPEN);
});
await serverReceivedMessages.then((messages) => {
expect(messages).toEqual([
JSON.stringify({ message: 'Hello1' }),
JSON.stringify({ message: 'Hello2' }),
]);
});
stopClient(client as any, clientTimeout);
});
test('Websocket client should receive deserialized messages correctly', async () => {
let client: Websocket<Record<any, any>, Record<any, any>> | undefined;
await new Promise<
WebsocketEventListenerParams<
WebsocketEvent.Open,
Record<any, any>,
Record<any, any>
>
>((resolve) => {
client = new WebsocketBuilder(url)
.withSerializer(
new JsonSerializer<Record<any, any>, Record<any, any>>()
)
.onOpen(() => {
server?.clients.forEach((c: WsWebSocket) => {
c.send(JSON.stringify({ message: 'Hello' }));
});
})
.onMessage((instance, ev) => {
console.log('ev', ev.data);
expect(ev.data).toEqual({ message: 'Hello' });
resolve([instance, ev]);
})
.build();
}).then(([instance, ev]) => {
expect(instance).toBe(client);
expect(ev.type).toBe(WebsocketEvent.Message);
});
stopClient(client as any, clientTimeout);
});
});
});