@ryinner/web-socket-manager/dist/websocket.test.js

simple ws manager

import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
import { mockWebSocket, webSocketSpy } from './__mocks__/WebSocket';
import WebSocketManager from './websocket';
vi.stubGlobal('WebSocket', mockWebSocket);
describe('WebsocketManager', () => {
    beforeEach(() => {
        vi.useFakeTimers();
    });
    afterEach(() => {
        vi.restoreAllMocks();
    });
    test('isOpen', () => {
        const webSocket = new WebSocketManager({ url: 'wss' });
        webSocket.webSocketInstance = { readyState: mockWebSocket.OPEN };
        expect(webSocket.isOpen()).toBeTruthy();
    });
    test('isClose', () => {
        const webSocket = new WebSocketManager({ url: 'wss' });
        webSocket.webSocketInstance = { readyState: mockWebSocket.CLOSED };
        expect(webSocket.isClose()).toBeTruthy();
    });
    test('isClosing', () => {
        const webSocket = new WebSocketManager({ url: 'wss' });
        webSocket.webSocketInstance = { readyState: mockWebSocket.CLOSING };
        expect(webSocket.isClosing()).toBeTruthy();
    });
    test('isValidWebSocketAnswer', () => {
        const webSocket = new WebSocketManager({ url: 'wss' });
        expect(webSocket.isValidWebSocketAnswer({ method: test })).toBeTruthy();
    });
    test('isIntervaledOperation', () => {
        const webSocket = new WebSocketManager({ url: 'wss' });
        expect(webSocket.isIntervaledOperation({ method: test, interval: true })).toBeTruthy();
    });
    test('isWebSocket', () => {
        const webSocket = new WebSocketManager({ url: 'wss' });
        expect(webSocket.isWebSocket()).toBeFalsy();
        webSocket.isTesting = true;
        expect(webSocket.isWebSocket()).toBeTruthy();
    });
    test('pickOperationStrategy', () => {
        const webSocket = new WebSocketManager({ url: 'wss' });
        webSocket.addOperation({
            method: 'test',
            request: () => ({}),
            interval: true
        });
        webSocket.addOperation({
            method: 'test2',
            request: () => ({})
        });
        webSocket.addOperation({
            method: 'test3',
            request: () => ({}),
            interval: 1000
        });
        webSocket.onOpenHandler();
        const firstOperation = webSocket.findOperation('test');
        expect(firstOperation._interval).not.toBe(undefined);
        expect(webSocket.findOperation('test2')._interval).toBe(undefined);
        expect(webSocket.findOperation('test3').interval).toBe(1000);
    });
    test('onErrorHandler', () => {
        const webSocket = new WebSocketManager({ url: 'wss' });
        webSocket.onErrorHandler({});
        expect(webSocketSpy.close).toHaveBeenCalledOnce();
    });
    test('onMessageHandler', () => {
        const webSocket = new WebSocketManager({ url: 'wss' });
        const spy = vi.fn();
        webSocket.addOperation({
            method: 'test',
            request: () => ({ data: 123 }),
            handlers: [spy]
        });
        const fixture = { method: 'test', data: { data: 'test' } };
        webSocket.onMessageHandler({ data: JSON.stringify(fixture) });
        expect(spy).toHaveBeenCalledOnce();
    });
    test('onCloseHandler', () => {
        const webSocket = new WebSocketManager({ url: 'wss' });
        webSocket.addOperation({
            method: 'test',
            request: () => ({ data: 123 }),
            handlers: [() => { }],
            interval: true
        });
        webSocket.onOpenHandler();
        webSocket.onCloseHandler({ wasClean: true });
        expect(webSocket.reconnectInterval).equal(undefined);
        webSocket.onCloseHandler({ wasClean: false });
        expect(webSocket.reconnectInterval).not.equal(undefined);
        expect(webSocket.findOperation('test')._interval).not.toBe(0);
    });
    test('addHandlers', () => {
        const webSocket = new WebSocketManager({ url: 'wss' });
        webSocket.addOperation({
            method: 'test',
            request: () => ({ data: 123 }),
            interval: true
        });
        const operation = webSocket.findOperation('test');
        webSocket.addHandlers(operation, [() => { }]);
        expect(operation?.handlers?.length).toBe(1);
    });
    test('removeHandler', () => {
        const webSocket = new WebSocketManager({ url: 'wss' });
        const handler = () => { };
        webSocket.addOperation({
            method: 'test',
            request: () => ({ data: 123 }),
            handlers: [handler]
        });
        webSocket.removeHandler('test', handler);
        expect(webSocket.findOperation('test')?.handlers?.length).toBe(0);
    });
    test('removeOperation', () => {
        const webSocket = new WebSocketManager({ url: 'wss' });
        webSocket.addOperation({
            method: 'test',
            request: () => ({ data: 123 })
        });
        webSocket.removeOperation('test');
        expect(webSocket.findOperation('test')).toBe(undefined);
    });
    test('addOperation', () => {
        const webSocket = new WebSocketManager({ url: 'wss' });
        webSocket.addOperation({
            method: 'test',
            request: () => ({ data: 123 }),
            handlers: [() => { }]
        });
        webSocket.addOperation({
            method: 'test',
            request: () => ({ data: 123 }),
            handlers: [() => { }]
        });
        const operation = webSocket.findOperation('test');
        expect(operation).not.toBe(undefined);
        expect(operation?.handlers?.length).toBe(2);
    });
    test('getWs', () => {
        const webSocket = new WebSocketManager({ url: 'wss' });
        webSocket.webSocketInstance = { readyState: mockWebSocket.OPEN };
        webSocket.isTesting = true;
        webSocket.open();
        expect(mockWebSocket).toHaveBeenCalledTimes(0);
        webSocket.webSocketInstance = { readyState: mockWebSocket.CLOSED };
        webSocket.open();
        expect(mockWebSocket).toHaveBeenCalledTimes(1);
    });
});
//# sourceMappingURL=websocket.test.js.map