@eleven-am/pondsocket 0.1.169 → 0.1.171

package/endpoint/endpoint.js

@@ -1,299 +0,0 @@
-"use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _EndpointEngine_instances, _EndpointEngine_middleware, _EndpointEngine_lobbyEngines, _EndpointEngine_channels, _EndpointEngine_sockets, _EndpointEngine_parentEngine, _EndpointEngine_joinChannel, _EndpointEngine_broadcastMessage, _EndpointEngine_retrieveChannel, _EndpointEngine_handleMessage, _EndpointEngine_readMessage, _EndpointEngine_buildError, _EndpointEngine_leaveChannel, _Endpoint_engine;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Endpoint = exports.EndpointEngine = void 0;
-const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
-const zod_1 = require("zod");
-const middleware_1 = require("../abstracts/middleware");
-const pondError_1 = require("../errors/pondError");
-const joinRequest_1 = require("../lobby/joinRequest");
-const joinResponse_1 = require("../lobby/joinResponse");
-const lobby_1 = require("../lobby/lobby");
-const matcher_1 = require("../matcher/matcher");
-class EndpointEngine {
-    constructor(parent) {
-        _EndpointEngine_instances.add(this);
-        _EndpointEngine_middleware.set(this, void 0);
-        _EndpointEngine_lobbyEngines.set(this, void 0);
-        _EndpointEngine_channels.set(this, void 0);
-        _EndpointEngine_sockets.set(this, void 0);
-        _EndpointEngine_parentEngine.set(this, void 0);
-        __classPrivateFieldSet(this, _EndpointEngine_sockets, new Map(), "f");
-        __classPrivateFieldSet(this, _EndpointEngine_middleware, new middleware_1.Middleware(), "f");
-        __classPrivateFieldSet(this, _EndpointEngine_lobbyEngines, new Map(), "f");
-        __classPrivateFieldSet(this, _EndpointEngine_parentEngine, parent, "f");
-        __classPrivateFieldSet(this, _EndpointEngine_channels, new Map(), "f");
-    }
-    get parent() {
-        return __classPrivateFieldGet(this, _EndpointEngine_parentEngine, "f");
-    }
-    /**
-     * @desc Adds a new PondChannel to this path on this endpoint
-     * @param path - The path to add the channel to
-     * @param handler - The handler to use to authenticate the client
-     *
-     * @example
-     * const channel = endpoint.createChannel('/chat', (request, response) => {
-     *     if (request.user.assigns.admin)
-     *         response.accept();
-     *
-     *     else
-     *         response.decline('You are not an admin', 403);
-     * });
-     */
-    createChannel(path, handler) {
-        const pondChannel = new lobby_1.LobbyEngine(this, path);
-        __classPrivateFieldGet(this, _EndpointEngine_middleware, "f").use((user, joinParams, next) => {
-            const event = (0, matcher_1.parseAddress)(path, user.channelName);
-            if (event) {
-                const channel = pondChannel.getChannel(user.channelName) || pondChannel.createChannel(user.channelName);
-                const request = new joinRequest_1.JoinRequest(user, joinParams, channel);
-                const response = new joinResponse_1.JoinResponse(user, channel);
-                request._parseQueries(path);
-                __classPrivateFieldGet(this, _EndpointEngine_channels, "f").set(user.channelName, channel);
-                return handler(request, response);
-            }
-            next();
-        });
-        __classPrivateFieldGet(this, _EndpointEngine_lobbyEngines, "f").set(path, pondChannel);
-        return new lobby_1.PondChannel(pondChannel);
-    }
-    /**
-     * @desc Gets all clients connected to this endpoint
-     */
-    getClients() {
-        return [...__classPrivateFieldGet(this, _EndpointEngine_sockets, "f").values()];
-    }
-    /**
-     * @desc Closes specific clients connected to this endpoint
-     * @param clientIds - The id for the client / clients to close
-     */
-    closeConnection(clientIds) {
-        const clients = typeof clientIds === 'string' ? [clientIds] : clientIds;
-        this.getClients()
-            .forEach(({ clientId, socket }) => {
-            if (clients.includes(clientId)) {
-                socket.close();
-            }
-        });
-    }
-    /**
-     * @desc Manages a new socket connection
-     * @param cache - The socket cache
-     */
-    manageSocket(cache) {
-        __classPrivateFieldGet(this, _EndpointEngine_sockets, "f").set(cache.clientId, cache);
-        const socket = cache.socket;
-        socket.addEventListener('message', (message) => {
-            __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_readMessage).call(this, cache, message.data);
-        });
-        socket.addEventListener('close', () => {
-            __classPrivateFieldGet(this, _EndpointEngine_sockets, "f").delete(cache.clientId);
-            cache.subscriptions.forEach((unsubscribe) => unsubscribe());
-        });
-        socket.addEventListener('error', () => {
-            __classPrivateFieldGet(this, _EndpointEngine_sockets, "f").delete(cache.clientId);
-            cache.subscriptions.forEach((unsubscribe) => unsubscribe());
-        });
-        const event = {
-            event: pondsocket_common_1.Events.CONNECTION,
-            action: pondsocket_common_1.ServerActions.CONNECT,
-            channelName: pondsocket_common_1.SystemSender.ENDPOINT,
-            requestId: (0, pondsocket_common_1.uuid)(),
-            payload: {},
-        };
-        this.sendMessage(socket, event);
-    }
-    /**
-     * @desc Retrieves a user from the endpoint
-     * @param clientId - The id of the user to retrieve
-     * @private
-     */
-    getUser(clientId) {
-        const user = __classPrivateFieldGet(this, _EndpointEngine_sockets, "f").get(clientId);
-        if (!user) {
-            throw new pondError_1.EndpointError(`GatewayEngine: User ${clientId} does not exist`, 404);
-        }
-        return user;
-    }
-    /**
-     * @desc Subscribes a user to a channel, Will join the channel if it exists or add to pending subscriptions
-     * @param userId - The id of the user to subscribe
-     * @param channel - The name of the channel to subscribe to
-     */
-    subscribeTo(userId, channel) {
-        const user = this.getUser(userId);
-        const channelEngine = __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_retrieveChannel).call(this, channel);
-        const onMessage = this.sendMessage.bind(this, user.socket);
-        const subscription = channelEngine.addUser(userId, user.assigns, onMessage);
-        user.subscriptions.set(channel, subscription);
-    }
-    /**
-     * @desc Unsubscribes a user from a channel
-     * @param userId - The id of the user to unsubscribe
-     * @param channel - The name of the channel to unsubscribe from
-     */
-    unsubscribeFrom(userId, channel) {
-        const user = this.getUser(userId);
-        const unsubscribe = user.subscriptions.get(channel);
-        if (unsubscribe) {
-            unsubscribe();
-            user.subscriptions.delete(channel);
-            return;
-        }
-        throw new pondError_1.EndpointError(`GatewayEngine: Channel ${channel} does not exist`, 404);
-    }
-    /**
-     * @desc Sends a message to a client
-     * @param socket - The socket to send the message to
-     * @param message - The message to send
-     */
-    sendMessage(socket, message) {
-        socket.send(JSON.stringify(message));
-    }
-}
-exports.EndpointEngine = EndpointEngine;
-_EndpointEngine_middleware = new WeakMap(), _EndpointEngine_lobbyEngines = new WeakMap(), _EndpointEngine_channels = new WeakMap(), _EndpointEngine_sockets = new WeakMap(), _EndpointEngine_parentEngine = new WeakMap(), _EndpointEngine_instances = new WeakSet(), _EndpointEngine_joinChannel = function _EndpointEngine_joinChannel(channel, socket, joinParams, requestId) {
-    const cache = Object.assign(Object.assign({}, socket), { requestId, channelName: channel });
-    __classPrivateFieldGet(this, _EndpointEngine_middleware, "f").run(cache, joinParams, () => {
-        throw new pondError_1.EndpointError(`GatewayEngine: Channel ${channel} does not exist`, 404);
-    });
-}, _EndpointEngine_broadcastMessage = function _EndpointEngine_broadcastMessage(cache, message) {
-    const engine = __classPrivateFieldGet(this, _EndpointEngine_channels, "f").get(message.channelName);
-    if (!engine) {
-        throw new pondError_1.EndpointError(`GatewayEngine: Channel ${message.channelName} does not exist`, 404);
-    }
-    engine.broadcastMessage(cache.clientId, message);
-}, _EndpointEngine_retrieveChannel = function _EndpointEngine_retrieveChannel(channel) {
-    let channelEngine;
-    for (const [path, manager] of __classPrivateFieldGet(this, _EndpointEngine_lobbyEngines, "f")) {
-        const event = (0, matcher_1.parseAddress)(path, channel);
-        if (event) {
-            channelEngine = manager.getChannel(channel) || manager.createChannel(channel);
-            break;
-        }
-    }
-    if (!channelEngine) {
-        throw new pondError_1.EndpointError(`GatewayEngine: Channel ${channel} does not exist`, 400);
-    }
-    return channelEngine;
-}, _EndpointEngine_handleMessage = function _EndpointEngine_handleMessage(cache, message) {
-    switch (message.action) {
-        case pondsocket_common_1.ClientActions.JOIN_CHANNEL:
-            __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_joinChannel).call(this, message.channelName, cache, message.payload, message.requestId);
-            break;
-        case pondsocket_common_1.ClientActions.LEAVE_CHANNEL:
-            __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_leaveChannel).call(this, message.channelName, cache);
-            break;
-        case pondsocket_common_1.ClientActions.BROADCAST:
-            __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_broadcastMessage).call(this, cache, message);
-            break;
-        default:
-            throw new Error(`GatewayEngine: Action ${message.action} does not exist`);
-    }
-}, _EndpointEngine_readMessage = function _EndpointEngine_readMessage(cache, message) {
-    try {
-        const data = JSON.parse(message);
-        const result = pondsocket_common_1.clientMessageSchema.parse(data);
-        __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_handleMessage).call(this, cache, result);
-    }
-    catch (e) {
-        this.sendMessage(cache.socket, __classPrivateFieldGet(this, _EndpointEngine_instances, "m", _EndpointEngine_buildError).call(this, e));
-    }
-}, _EndpointEngine_buildError = function _EndpointEngine_buildError(error) {
-    const event = {
-        event: pondsocket_common_1.ErrorTypes.INVALID_MESSAGE,
-        action: pondsocket_common_1.ServerActions.ERROR,
-        channelName: pondsocket_common_1.SystemSender.ENDPOINT,
-        requestId: (0, pondsocket_common_1.uuid)(),
-        payload: {},
-    };
-    if (error instanceof SyntaxError) {
-        event.payload = {
-            message: 'Invalid JSON',
-        };
-    }
-    else if (error instanceof Error) {
-        event.event = pondsocket_common_1.ErrorTypes.INTERNAL_SERVER_ERROR;
-        event.payload = {
-            message: error.message,
-        };
-    }
-    else if (error instanceof pondError_1.PresenceError) {
-        event.event = pondsocket_common_1.ErrorTypes.PRESENCE_ERROR;
-        event.channelName = error.channel;
-        event.payload = {
-            message: error.message,
-            code: error.code,
-            action: error.event,
-        };
-    }
-    else if (error instanceof pondError_1.ChannelError) {
-        event.event = pondsocket_common_1.ErrorTypes.CHANNEL_ERROR;
-        event.channelName = error.channel;
-        event.payload = {
-            message: error.message,
-            code: error.code,
-        };
-    }
-    else if (error instanceof pondError_1.EndpointError) {
-        event.event = pondsocket_common_1.ErrorTypes.ENDPOINT_ERROR;
-        event.payload = {
-            message: error.message,
-            code: error.code,
-        };
-    }
-    else if (error instanceof zod_1.ZodError) {
-        const message = error.errors.map((error) => {
-            if ('expected' in error && 'received' in error) {
-                return `Expected ${error.path.join('.')} to be ${error.expected}, but received ${error.received}`;
-            }
-            return `${error.path.join('.')} ${error.message}`;
-        }).join(', ');
-        event.payload = {
-            message,
-            code: 400,
-        };
-    }
-    else {
-        event.payload = {
-            message: 'Unknown error',
-        };
-    }
-    return event;
-}, _EndpointEngine_leaveChannel = function _EndpointEngine_leaveChannel(channel, socket) {
-    const unsubscribe = socket.subscriptions.get(channel);
-    if (!unsubscribe) {
-        throw new pondError_1.EndpointError(`GatewayEngine: Channel ${channel} does not exist`, 404);
-    }
-    unsubscribe();
-    socket.subscriptions.delete(channel);
-};
-class Endpoint {
-    constructor(engine) {
-        _Endpoint_engine.set(this, void 0);
-        __classPrivateFieldSet(this, _Endpoint_engine, engine, "f");
-    }
-    createChannel(path, handler) {
-        return __classPrivateFieldGet(this, _Endpoint_engine, "f").createChannel(path, handler);
-    }
-    closeConnection(clientIds) {
-        __classPrivateFieldGet(this, _Endpoint_engine, "f").closeConnection(clientIds);
-    }
-    getClients() {
-        return __classPrivateFieldGet(this, _Endpoint_engine, "f").getClients().map(({ socket }) => socket);
-    }
-}
-exports.Endpoint = Endpoint;
-_Endpoint_engine = new WeakMap();

package/endpoint/endpoint.test.js

@@ -1,299 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createEndpointEngine = void 0;
-const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
-const superwstest_1 = __importDefault(require("superwstest"));
-const pondSocket_1 = require("../server/pondSocket");
-const createEndpointEngine = (socket) => ({
-    createChannel: jest.fn(),
-    listConnections: jest.fn(),
-    getClients: jest.fn(),
-    broadcast: jest.fn(),
-    closeConnection: jest.fn(),
-    manageSocket: jest.fn(),
-    getUser: () => socket,
-    subscribeTo: jest.fn(),
-    unsubscribeFrom: jest.fn(),
-    sendMessage: (socket, msg) => socket.send(JSON.stringify(msg)),
-    getPubSubClient: () => ({
-        publish: jest.fn(),
-        subscribeToPresence: jest.fn(),
-        subscribe: jest.fn(),
-        getPresence: () => new Promise((resolve) => setTimeout(() => resolve([]), 100)),
-    }),
-});
-exports.createEndpointEngine = createEndpointEngine;
-describe('endpoint', () => {
-    let socket;
-    let server;
-    beforeEach((done) => {
-        socket = new pondSocket_1.PondSocket();
-        server = socket.listen(3000, 'localhost', () => {
-            done();
-        });
-    });
-    afterEach((done) => {
-        server.close(() => {
-            done();
-        });
-    });
-    it('should be able to close a single socket', () => __awaiter(void 0, void 0, void 0, function* () {
-        let count = 0;
-        const endpoint = socket.createEndpoint('/api/:room', (req, res) => {
-            if (req.params.room === 'socket') {
-                res.accept();
-                count++;
-                setTimeout(() => {
-                    endpoint.closeConnection(req.id);
-                }, 1000);
-            }
-            else {
-                res.decline();
-            }
-        });
-        yield (0, superwstest_1.default)(server)
-            .ws('/api/socket')
-            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
-            .wait(200)
-            .expectClosed();
-        expect(count).toBe(1);
-    }));
-    it('should be able to list connections', () => __awaiter(void 0, void 0, void 0, function* () {
-        const endpoint = socket.createEndpoint('/api/:room', (req, res) => {
-            if (req.params.room === 'socket') {
-                res.accept();
-                const connections = endpoint.getClients();
-                expect(connections).toHaveLength(1);
-            }
-            else {
-                res.decline();
-            }
-        });
-        yield (0, superwstest_1.default)(server)
-            .ws('/api/socket')
-            .expectUpgrade((res) => expect(res.statusCode).toBe(101));
-    }));
-    it('should be able to refuse connections to the endpoint', () => __awaiter(void 0, void 0, void 0, function* () {
-        let count = 0;
-        socket.createEndpoint('/api/:path', (req, res) => {
-            count++;
-            expect(req.params.path).toBe('socket');
-            res.decline();
-        });
-        yield (0, superwstest_1.default)(server)
-            .ws('/api/socket')
-            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
-            .expectMessage(expect.objectContaining({
-            action: pondsocket_common_1.ServerActions.ERROR,
-            event: pondsocket_common_1.ErrorTypes.UNAUTHORIZED_CONNECTION,
-            channelName: pondsocket_common_1.SystemSender.ENDPOINT,
-            payload: {
-                message: 'Unauthorized connection',
-                code: 401,
-            },
-        }))
-            .expectClosed();
-        expect(count).toBe(1);
-    }));
-    it('should be able to accept connections on this handler', () => __awaiter(void 0, void 0, void 0, function* () {
-        const message = {
-            action: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
-            channelName: '/test/socket',
-            event: 'TEST',
-            payload: {},
-        };
-        const endpoint = socket.createEndpoint('/api/:room', (req, res) => {
-            if (req.params.room === 'socket') {
-                res.accept();
-            }
-            else {
-                res.decline();
-            }
-        });
-        endpoint.createChannel('/test/:room', (req, res) => {
-            expect(req.event.params.room).toBeDefined();
-            res.accept().assign({
-                assigns: {
-                    status: 'online',
-                },
-            });
-        });
-        yield (0, superwstest_1.default)(server)
-            .ws('/api/socket')
-            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
-            .sendJson(message)
-            .close()
-            .expectClosed();
-        yield (0, superwstest_1.default)(server)
-            .ws('/api/socket')
-            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
-            .sendJson(Object.assign(Object.assign({}, message), { channelName: '/socket/socket' }))
-            .expectMessage(expect.objectContaining({
-            action: pondsocket_common_1.ServerActions.SYSTEM,
-            channelName: '/socket/socket',
-            event: pondsocket_common_1.Events.ACKNOWLEDGE,
-            payload: {},
-        }))
-            .close()
-            .expectClosed();
-    }));
-    it('should send an error when the channel exists but other things happen', () => __awaiter(void 0, void 0, void 0, function* () {
-        const message = {
-            action: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
-            channelName: '/test/socket',
-            event: 'TEST',
-            payload: {},
-        };
-        const endpoint = socket.createEndpoint('/api/:room', (_, res) => {
-            res.accept();
-        });
-        endpoint.createChannel('/test/:room', (req, res) => {
-            expect(req.event.params.room).toBeDefined();
-            res.decline('Something went wrong');
-        });
-        yield (0, superwstest_1.default)(server)
-            .ws('/api/socket')
-            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
-            .sendJson(message)
-            .expectMessage(expect.objectContaining({
-            action: pondsocket_common_1.ServerActions.ERROR,
-            channelName: '/test/socket',
-            event: pondsocket_common_1.ErrorTypes.UNAUTHORIZED_JOIN_REQUEST,
-            payload: {
-                message: 'Request to join channel /test/socket rejected: Something went wrong',
-                code: 403,
-            },
-        }))
-            .close()
-            .expectClosed();
-    }));
-    it('should be able to track the presence of its users', () => __awaiter(void 0, void 0, void 0, function* () {
-        const message = {
-            action: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
-            channelName: '/test/socket',
-            event: 'TEST',
-            payload: {},
-        };
-        const endpoint = socket.createEndpoint('/api/:room', (_, res) => {
-            res.accept();
-        });
-        endpoint.createChannel('/test/:room', (req, res) => {
-            expect(req.event.params.room).toBeDefined();
-            res
-                .accept()
-                .trackPresence({
-                status: 'online',
-            });
-        });
-        yield (0, superwstest_1.default)(server)
-            .ws('/api/socket')
-            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
-            .sendJson(message)
-            .expectMessage(expect.objectContaining({
-            action: pondsocket_common_1.ServerActions.SYSTEM,
-            channelName: '/test/socket',
-            event: pondsocket_common_1.Events.ACKNOWLEDGE,
-            payload: {},
-        }))
-            .close();
-    }));
-    it('should throw an error if accept, reject is called more than once', () => __awaiter(void 0, void 0, void 0, function* () {
-        socket.createEndpoint('/api/:room', (_, res) => {
-            res.reply('hello', {
-                test: 'test',
-            });
-            res.accept();
-            expect(() => res.decline()).toThrowError('Cannot execute response more than once');
-        });
-        yield (0, superwstest_1.default)(server)
-            .ws('/api/socket')
-            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
-            .expectMessage(expect.objectContaining({
-            action: pondsocket_common_1.ServerActions.BROADCAST,
-            channelName: pondsocket_common_1.SystemSender.ENDPOINT,
-            event: 'hello',
-            payload: {
-                test: 'test',
-            },
-        }));
-    }));
-    it('should be able to connect, join a channel and send a message', () => __awaiter(void 0, void 0, void 0, function* () {
-        const message = {
-            action: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
-            channelName: '/test/socket',
-            event: 'TEST',
-            payload: {},
-        };
-        const endpoint = socket.createEndpoint('/api/:room', (_, res) => {
-            res.accept();
-        });
-        const channel = endpoint.createChannel('/test/:room', (req, res) => {
-            expect(req.event.params.room).toBeDefined();
-            res.accept();
-        });
-        channel.onEvent('echo', (req, res) => {
-            res.reply('echo', req.event.payload);
-        });
-        channel.onEvent('broadcast', (req) => {
-            const internal = channel.getChannel('/test/socket');
-            expect(internal).toBeDefined();
-            internal.broadcast('broadcast', Object.assign(Object.assign({}, req.event.payload), { broadcast: true }));
-        });
-        yield (0, superwstest_1.default)(server)
-            .ws('/api/socket')
-            .expectUpgrade((res) => expect(res.statusCode).toBe(101))
-            .sendJson(message)
-            .expectMessage(expect.objectContaining({
-            action: pondsocket_common_1.ServerActions.SYSTEM,
-            channelName: '/test/socket',
-            event: pondsocket_common_1.Events.ACKNOWLEDGE,
-            payload: {},
-        }))
-            .sendJson({
-            addresses: pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER,
-            action: pondsocket_common_1.ClientActions.BROADCAST,
-            channelName: '/test/socket',
-            event: 'echo',
-            payload: {
-                test: 'test',
-            },
-        })
-            .expectMessage(expect.objectContaining({
-            action: pondsocket_common_1.ServerActions.SYSTEM,
-            channelName: '/test/socket',
-            event: 'echo',
-            payload: {
-                test: 'test',
-            },
-        }))
-            .sendJson({
-            action: pondsocket_common_1.ClientActions.BROADCAST,
-            channelName: '/test/socket',
-            event: 'broadcast',
-            payload: {
-                test: 'test',
-            },
-        })
-            .expectMessage(expect.objectContaining({
-            action: pondsocket_common_1.ServerActions.SYSTEM,
-            channelName: '/test/socket',
-            event: 'broadcast',
-            payload: {
-                test: 'test',
-                broadcast: true,
-            },
-        }));
-    }));
-});