@furystack/websocket-api/esm/websocket-integration.spec.js

HTTP Api FuryStack package

import { addStore, InMemoryStore, StoreManager, User } from '@furystack/core';
import { getPort } from '@furystack/core/port-generator';
import { Injector } from '@furystack/inject';
import { DefaultSession, HttpUserContext, ServerManager, useHttpAuthentication, useRestService, } from '@furystack/rest-service';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { WebSocket } from 'ws';
import { WhoAmI } from './actions/whoami.js';
import { useWebsockets } from './helpers.js';
describe('WebSocket Integration tests', () => {
    const host = 'localhost';
    const path = '/ws';
    let i;
    let client;
    let port;
    beforeEach(async () => {
        i = new Injector();
        port = getPort();
        await useRestService({
            injector: i,
            api: {},
            root: '',
            port,
            hostName: host,
        });
        addStore(i, new InMemoryStore({ model: User, primaryKey: 'username' })).addStore(new InMemoryStore({ model: DefaultSession, primaryKey: 'sessionId' }));
        useHttpAuthentication(i, {});
        useWebsockets(i, { actions: [WhoAmI], path, port, host });
        await new Promise((resolve, reject) => {
            i.getInstance(ServerManager)
                .getOrCreate({ port })
                .then(() => {
                client = new WebSocket(`ws://${host}:${port}/ws`);
                client
                    .on('open', () => {
                    resolve();
                })
                    .on('error', reject);
            })
                .catch(reject);
        });
    });
    afterEach(async () => {
        await i[Symbol.asyncDispose]();
    });
    const getWhoAmIResult = async (subjectClient) => {
        return new Promise((resolve, reject) => {
            subjectClient.once('message', (data) => {
                resolve(JSON.parse(data.toString()));
            });
            subjectClient.once('error', reject);
            subjectClient.send('whoami');
        });
    };
    describe('Authentication', () => {
        it('Should be unauthenticated by default', async () => {
            expect((await getWhoAmIResult(client)).currentUser).toBe(null);
        });
    });
    it('Should be authenticated, roles should be updated and should be logged out', async () => {
        const testUser = { username: 'test', password: 'test', roles: [] };
        const userStore = i.getInstance(StoreManager).getStoreFor(User, 'username');
        await userStore.add(testUser);
        const userCtx = i.getInstance(HttpUserContext);
        let cookie = '';
        await userCtx.cookieLogin(testUser, {
            setHeader: (_setCookie, cookieValue) => {
                cookie = cookieValue;
            },
        });
        const authenticatedClient = await new Promise((done, reject) => {
            const cl = new WebSocket(`ws://${host}:${port}/ws`, {
                headers: { cookie },
            });
            cl.once('open', () => {
                done(cl);
            }).once('error', reject);
        });
        const whoAmIResult = await getWhoAmIResult(authenticatedClient);
        expect(whoAmIResult.currentUser).toEqual(testUser);
        await userStore.update(testUser.username, { ...testUser, roles: ['newFancyRole'] });
        const updatedWhoAmIResult = await getWhoAmIResult(authenticatedClient);
        expect(updatedWhoAmIResult.currentUser.roles).toEqual(['newFancyRole']);
        await userCtx.cookieLogout({
            headers: {
                cookie,
            },
        }, {
            setHeader: vi.fn(),
        });
        const loggedOutWhoAmIResult = await getWhoAmIResult(authenticatedClient);
        expect(loggedOutWhoAmIResult.currentUser).toBe(null);
    });
});
//# sourceMappingURL=websocket-integration.spec.js.map