@eleven-am/pondsocket-client 0.0.2

package/core/channel.test.js

@@ -0,0 +1,762 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+const channel_1 = require("./channel");
+const createChannel = (params = {}) => {
+    const publisher = jest.fn();
+    const state = new pondsocket_common_1.SimpleBehaviorSubject(true);
+    const receiver = new pondsocket_common_1.SimpleSubject();
+    const channel = new channel_1.Channel(publisher, state, 'test', receiver, params);
+    return {
+        channel,
+        publisher,
+        state,
+        receiver,
+    };
+};
+describe('Channel', () => {
+    it('should correctly send a join message', () => {
+        const { channel, publisher, state } = createChannel();
+        expect(publisher).not.toHaveBeenCalled();
+        expect(state.value).toBe(true);
+        channel.join();
+        expect(publisher).toHaveBeenCalledWith(expect.objectContaining({
+            action: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
+            channelName: 'test',
+            addresses: pondsocket_common_1.ChannelReceiver.ALL_USERS,
+            event: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
+            payload: {},
+        }));
+        const { channel: channel2, publisher: publisher2, state: state2 } = createChannel();
+        state2.publish(false);
+        expect(state2.value).toBe(false);
+        expect(publisher2).not.toHaveBeenCalled();
+        channel2.join();
+        expect(publisher2).not.toHaveBeenCalled();
+        state2.publish(true);
+        expect(publisher2).toHaveBeenCalledWith(expect.objectContaining({
+            action: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
+            channelName: 'test',
+            addresses: pondsocket_common_1.ChannelReceiver.ALL_USERS,
+            event: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
+            payload: {},
+        }));
+        const { channel: channel3 } = createChannel();
+        channel3.leave();
+        expect(() => channel3.join())
+            .toThrow('This channel has been closed');
+    });
+    it('should correctly send a leave message', () => {
+        const { channel, publisher, receiver } = createChannel();
+        expect(channel.channelState).toBe(pondsocket_common_1.ChannelState.IDLE);
+        channel.join();
+        expect(channel.channelState).toBe(pondsocket_common_1.ChannelState.JOINING);
+        receiver.publish({
+            requestId: 'test',
+            action: pondsocket_common_1.ServerActions.SYSTEM,
+            channelName: 'test',
+            event: 'SYSTEM',
+            payload: {
+                event: 'JOIN',
+            },
+        });
+        expect(channel.channelState).toBe(pondsocket_common_1.ChannelState.JOINING);
+        // once the server responds with an ack, the channel state should be joined
+        receiver.publish({
+            requestId: 'test',
+            action: pondsocket_common_1.ServerActions.SYSTEM,
+            channelName: 'test',
+            event: pondsocket_common_1.Events.ACKNOWLEDGE,
+            payload: {
+                event: 'JOIN',
+            },
+        });
+        expect(channel.channelState).toBe(pondsocket_common_1.ChannelState.JOINED);
+        channel.leave();
+        expect(channel.channelState).toBe(pondsocket_common_1.ChannelState.CLOSED);
+        expect(publisher).toHaveBeenCalledWith(expect.objectContaining({
+            action: pondsocket_common_1.ClientActions.LEAVE_CHANNEL,
+            channelName: 'test',
+            addresses: pondsocket_common_1.ChannelReceiver.ALL_USERS,
+            event: pondsocket_common_1.ClientActions.LEAVE_CHANNEL,
+            payload: {},
+        }));
+    });
+    it('should notify subscribers when the channel state changes', () => {
+        const { channel, receiver } = createChannel();
+        const stateListener = jest.fn();
+        channel.onChannelStateChange(stateListener);
+        expect(stateListener).toHaveBeenCalledWith(pondsocket_common_1.ChannelState.IDLE);
+        channel.join();
+        receiver.publish({
+            requestId: 'test',
+            action: 'SYSTEM',
+            channelName: 'test',
+            event: pondsocket_common_1.Events.ACKNOWLEDGE,
+            payload: {
+                event: 'JOIN',
+            },
+        });
+        expect(stateListener).toHaveBeenCalledWith(pondsocket_common_1.ChannelState.JOINED);
+        channel.leave();
+        expect(stateListener).toHaveBeenCalledWith(pondsocket_common_1.ChannelState.CLOSED);
+    });
+    it('should notify subscribers when state changes BOOLEAN', () => {
+        const { channel, receiver, state, publisher } = createChannel();
+        const stateListener = jest.fn();
+        expect(channel.isClosed()).toBe(false);
+        expect(channel.isConnected()).toBe(false);
+        expect(channel.isStalled()).toBe(false);
+        channel.onConnectionChange(stateListener);
+        expect(stateListener).toHaveBeenCalledWith(false);
+        expect(channel.isClosed()).toBe(false);
+        expect(channel.isConnected()).toBe(false);
+        expect(channel.isStalled()).toBe(false);
+        channel.join();
+        expect(channel.isConnected()).toBe(false);
+        expect(channel.isStalled()).toBe(false);
+        receiver.publish({
+            requestId: 'test',
+            action: 'SYSTEM',
+            channelName: 'test',
+            event: pondsocket_common_1.Events.ACKNOWLEDGE,
+            payload: {
+                event: 'JOIN',
+            },
+        });
+        expect(stateListener).toHaveBeenCalledWith(true);
+        expect(channel.isConnected()).toBe(true);
+        expect(channel.isStalled()).toBe(false);
+        publisher.mockClear();
+        state.publish(false);
+        expect(publisher).not.toHaveBeenCalled();
+        expect(channel.isStalled()).toBe(true);
+        expect(channel.isConnected()).toBe(true);
+        state.publish(true);
+        expect(publisher).toHaveBeenCalledTimes(1);
+        receiver.publish({
+            requestId: 'test',
+            action: 'SYSTEM',
+            channelName: 'test',
+            event: pondsocket_common_1.Events.ACKNOWLEDGE,
+            payload: {
+                event: 'JOIN',
+            },
+        });
+        expect(channel.isStalled()).toBe(false);
+        expect(channel.isConnected()).toBe(true);
+        channel.leave();
+        expect(channel.isClosed()).toBe(true);
+        expect(channel.isConnected()).toBe(false);
+        expect(channel.isStalled()).toBe(false);
+        expect(stateListener).toHaveBeenCalledWith(false);
+    });
+    it('should correctly send a message', () => {
+        const { channel, publisher, state, receiver } = createChannel();
+        expect(channel.channelState).toBe(pondsocket_common_1.ChannelState.IDLE);
+        expect(publisher).not.toHaveBeenCalled();
+        // when the socket is connected but the channel is not joined, the message would not be queued
+        channel.broadcast('test', { test: false });
+        expect(publisher).not.toHaveBeenCalled();
+        channel.join();
+        publisher.mockClear();
+        receiver.publish({
+            requestId: 'test',
+            action: 'SYSTEM',
+            channelName: 'test',
+            event: pondsocket_common_1.Events.ACKNOWLEDGE,
+            payload: {
+                event: 'JOIN',
+            },
+        });
+        // however once the channel is joined, the message should be sent
+        channel.broadcast('test', { test: true });
+        expect(publisher).toHaveBeenCalledWith(expect.objectContaining({
+            action: pondsocket_common_1.ClientActions.BROADCAST,
+            addresses: pondsocket_common_1.ChannelReceiver.ALL_USERS,
+            channelName: 'test',
+            event: 'test',
+            payload: {
+                test: true,
+            },
+        }));
+        // if for some reason the socket is disconnected, the message should be queued
+        publisher.mockClear();
+        state.publish(false);
+        expect(state.value).toBe(false);
+        channel.broadcast('test', { test: true });
+        expect(publisher).not.toHaveBeenCalled();
+        // once the socket is reconnected, a join message should be sent and the queued messages should be sent
+        publisher.mockClear();
+        state.publish(true);
+        expect(publisher).toHaveBeenCalledWith(expect.objectContaining({
+            addresses: pondsocket_common_1.ChannelReceiver.ALL_USERS,
+            action: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
+            channelName: 'test',
+            event: pondsocket_common_1.ClientActions.JOIN_CHANNEL,
+            payload: {},
+        }));
+        // until it receives an ack message the queued messages should not be sent
+        expect(publisher).toHaveBeenCalledTimes(1);
+        receiver.publish({
+            requestId: 'test',
+            action: 'SYSTEM',
+            channelName: 'test',
+            event: pondsocket_common_1.Events.ACKNOWLEDGE,
+            payload: {
+                event: 'JOIN',
+            },
+        });
+        expect(publisher).toHaveBeenCalledWith(expect.objectContaining({
+            action: pondsocket_common_1.ClientActions.BROADCAST,
+            addresses: pondsocket_common_1.ChannelReceiver.ALL_USERS,
+            channelName: 'test',
+            event: 'test',
+            payload: {
+                test: true,
+            },
+        }));
+        // if the channel is closed, the message should not be sent, and should not be queued
+        publisher.mockClear();
+        channel.leave();
+        // the leave message should be sent
+        expect(publisher).toHaveBeenCalledWith(expect.objectContaining({
+            action: pondsocket_common_1.ClientActions.LEAVE_CHANNEL,
+            channelName: 'test',
+            event: pondsocket_common_1.ClientActions.LEAVE_CHANNEL,
+            addresses: pondsocket_common_1.ChannelReceiver.ALL_USERS,
+            payload: {},
+        }));
+        expect(channel.channelState).toBe(pondsocket_common_1.ChannelState.CLOSED);
+        channel.broadcast('test', { test: true });
+        expect(publisher).toHaveBeenCalledTimes(1);
+    });
+    // The presence system tests
+    it('should notify subscribers when a user joins the channel', () => {
+        const { channel, receiver } = createChannel();
+        const presenceListener = jest.fn();
+        channel.onJoin(presenceListener);
+        expect(presenceListener).not.toHaveBeenCalled();
+        // usually the server wouldn't send a presence if the channel is not joined
+        // but for testing purposes, we'll just send it anyway
+        receiver.publish({
+            requestId: 'test',
+            action: pondsocket_common_1.ServerActions.PRESENCE,
+            event: pondsocket_common_1.PresenceEventTypes.JOIN,
+            channelName: 'test',
+            payload: {
+                changed: {
+                    id: 'test',
+                    status: 'online',
+                },
+                presence: [
+                    {
+                        id: 'test',
+                        status: 'online',
+                    },
+                    {
+                        id: 'test2',
+                        status: 'online',
+                    },
+                ],
+            },
+        });
+        expect(presenceListener).toHaveBeenCalledWith({
+            id: 'test',
+            status: 'online',
+        });
+        presenceListener.mockClear();
+        receiver.publish({
+            requestId: 'test',
+            action: pondsocket_common_1.ServerActions.PRESENCE,
+            event: pondsocket_common_1.PresenceEventTypes.UPDATE,
+            channelName: 'test',
+            payload: {
+                changed: {
+                    id: 'test',
+                    status: 'online',
+                },
+                presence: [
+                    {
+                        id: 'test',
+                        status: 'online',
+                    },
+                    {
+                        id: 'test2',
+                        status: 'online',
+                    },
+                ],
+            },
+        });
+        expect(presenceListener).not.toHaveBeenCalled();
+        // also, if a presence event is received for a different channel, it should not be sent to the listener
+        receiver.publish({
+            requestId: 'test',
+            action: pondsocket_common_1.ServerActions.PRESENCE,
+            event: pondsocket_common_1.PresenceEventTypes.JOIN,
+            channelName: 'test2',
+            payload: {
+                changed: {
+                    id: 'test',
+                    status: 'online',
+                },
+                presence: [
+                    {
+                        id: 'test',
+                        status: 'online',
+                    },
+                    {
+                        id: 'test2',
+                        status: 'online',
+                    },
+                ],
+            },
+        });
+        expect(presenceListener).not.toHaveBeenCalled();
+    });
+    it('should notify subscribers when a user leaves the channel', () => {
+        const { channel, receiver } = createChannel();
+        const presenceListener = jest.fn();
+        channel.onLeave(presenceListener);
+        expect(presenceListener).not.toHaveBeenCalled();
+        // usually the server wouldn't send a presence if the channel is not joined
+        // but for testing purposes, we'll just send it anyway
+        receiver.publish({
+            requestId: 'test',
+            action: pondsocket_common_1.ServerActions.PRESENCE,
+            event: pondsocket_common_1.PresenceEventTypes.LEAVE,
+            channelName: 'test',
+            payload: {
+                changed: {
+                    id: 'test',
+                    status: 'online',
+                },
+                presence: [
+                    {
+                        id: 'test',
+                        status: 'online',
+                    },
+                    {
+                        id: 'test2',
+                        status: 'online',
+                    },
+                ],
+            },
+        });
+        expect(presenceListener).toHaveBeenCalledWith({
+            id: 'test',
+            status: 'online',
+        });
+        presenceListener.mockClear();
+        receiver.publish({
+            requestId: 'test',
+            action: pondsocket_common_1.ServerActions.PRESENCE,
+            event: pondsocket_common_1.PresenceEventTypes.UPDATE,
+            channelName: 'test',
+            payload: {
+                changed: {
+                    id: 'test',
+                    status: 'online',
+                },
+                presence: [
+                    {
+                        id: 'test',
+                        status: 'online',
+                    },
+                    {
+                        id: 'test2',
+                        status: 'online',
+                    },
+                ],
+            },
+        });
+        expect(presenceListener).not.toHaveBeenCalled();
+        // also, if a presence event is received for a different channel, it should not be sent to the listener
+        receiver.publish({
+            requestId: 'test',
+            action: pondsocket_common_1.ServerActions.PRESENCE,
+            event: pondsocket_common_1.PresenceEventTypes.LEAVE,
+            channelName: 'test2',
+            payload: {
+                changed: {
+                    id: 'test',
+                    status: 'online',
+                },
+                presence: [
+                    {
+                        id: 'test',
+                        status: 'online',
+                    },
+                    {
+                        id: 'test2',
+                        status: 'online',
+                    },
+                ],
+            },
+        });
+        expect(presenceListener).not.toHaveBeenCalled();
+    });
+    it('should notify subscribers when a user updates their presence', () => {
+        const { channel, receiver } = createChannel();
+        const presenceListener = jest.fn();
+        channel.onUsersChange(presenceListener);
+        expect(presenceListener).not.toHaveBeenCalled();
+        // usually the server wouldn't send a presence if the channel is not joined
+        // but for testing purposes, we'll just send it anyway
+        receiver.publish({
+            requestId: 'test',
+            action: pondsocket_common_1.ServerActions.PRESENCE,
+            event: pondsocket_common_1.PresenceEventTypes.UPDATE,
+            channelName: 'test',
+            payload: {
+                changed: {
+                    id: 'test',
+                    status: 'online',
+                },
+                presence: [
+                    {
+                        id: 'test',
+                        status: 'online',
+                    },
+                    {
+                        id: 'test2',
+                        status: 'online',
+                    },
+                ],
+            },
+        });
+        expect(presenceListener).toHaveBeenCalledWith([
+            {
+                id: 'test',
+                status: 'online',
+            },
+            {
+                id: 'test2',
+                status: 'online',
+            },
+        ]);
+        expect(channel.getPresence()).toBe(presenceListener.mock.calls[0][0]);
+        presenceListener.mockClear();
+        // if we receive a leave or join event, it should be sent to the listener
+        // this is because we are listening for all presence events
+        receiver.publish({
+            requestId: 'test',
+            action: pondsocket_common_1.ServerActions.PRESENCE,
+            event: pondsocket_common_1.PresenceEventTypes.JOIN,
+            channelName: 'test',
+            payload: {
+                changed: {
+                    id: 'test',
+                    status: 'online',
+                },
+                presence: [
+                    {
+                        id: 'test',
+                        status: 'online',
+                    },
+                ],
+            },
+        });
+        expect(presenceListener).toHaveBeenCalledWith([
+            {
+                id: 'test',
+                status: 'online',
+            },
+        ]);
+        expect(channel.getPresence()).toBe(presenceListener.mock.calls[0][0]);
+        presenceListener.mockClear();
+        // also, if a presence event is received for a different channel, it should not be sent to the listener
+        receiver.publish({
+            requestId: 'test',
+            action: pondsocket_common_1.ServerActions.PRESENCE,
+            event: pondsocket_common_1.PresenceEventTypes.UPDATE,
+            channelName: 'test2',
+            payload: {
+                changed: {
+                    id: 'test',
+                    status: 'online',
+                },
+                presence: [
+                    {
+                        id: 'test',
+                        status: 'online',
+                    },
+                    {
+                        id: 'test2',
+                        status: 'online',
+                    },
+                ],
+            },
+        });
+        expect(presenceListener).not.toHaveBeenCalled();
+        // we once again send a presence event for the same channel, but this time it should be sent to the listener
+        receiver.publish({
+            requestId: 'test',
+            action: pondsocket_common_1.ServerActions.PRESENCE,
+            event: pondsocket_common_1.PresenceEventTypes.UPDATE,
+            channelName: 'test',
+            payload: {
+                changed: {
+                    id: 'test',
+                    status: 'away',
+                },
+                presence: [
+                    {
+                        id: 'test',
+                        status: 'away',
+                    },
+                    {
+                        id: 'test2',
+                        status: 'online',
+                    },
+                ],
+            },
+        });
+        expect(presenceListener).toHaveBeenCalledWith([
+            {
+                id: 'test',
+                status: 'away',
+            },
+            {
+                id: 'test2',
+                status: 'online',
+            },
+        ]);
+        expect(channel.getPresence()).toBe(presenceListener.mock.calls[0][0]);
+    });
+    it('should notify subscribers when any presence event occurs', () => {
+        const { channel, receiver } = createChannel();
+        const presenceListener = jest.fn();
+        channel.onPresenceChange(presenceListener);
+        expect(presenceListener).not.toHaveBeenCalled();
+        // usually the server wouldn't send a presence if the channel is not joined
+        // but for testing purposes, we'll just send it anyway
+        receiver.publish({
+            requestId: 'test',
+            action: pondsocket_common_1.ServerActions.PRESENCE,
+            event: pondsocket_common_1.PresenceEventTypes.UPDATE,
+            channelName: 'test',
+            payload: {
+                changed: {
+                    id: 'test',
+                    status: 'online',
+                },
+                presence: [
+                    {
+                        id: 'test',
+                        status: 'online',
+                    },
+                    {
+                        id: 'test2',
+                        status: 'online',
+                    },
+                ],
+            },
+        });
+        expect(presenceListener).toHaveBeenCalledWith({
+            changed: {
+                id: 'test',
+                status: 'online',
+            },
+            presence: [
+                {
+                    id: 'test',
+                    status: 'online',
+                },
+                {
+                    id: 'test2',
+                    status: 'online',
+                },
+            ],
+        });
+    });
+    // message events
+    it('should notify subscribers when a message is received', () => {
+        const { channel, receiver } = createChannel();
+        const messageListener = jest.fn();
+        channel.onMessage(messageListener);
+        expect(messageListener).not.toHaveBeenCalled();
+        receiver.publish({
+            requestId: 'test',
+            action: pondsocket_common_1.ServerActions.BROADCAST,
+            event: 'message',
+            channelName: 'test',
+            payload: {
+                id: 'test',
+                message: 'test',
+            },
+        });
+        expect(messageListener).toHaveBeenCalledWith('message', {
+            id: 'test',
+            message: 'test',
+        });
+        // if a message event is received for a different channel, it should not be sent to the listener
+        receiver.publish({
+            requestId: 'test',
+            action: pondsocket_common_1.ServerActions.BROADCAST,
+            event: 'message',
+            channelName: 'test2',
+            payload: {
+                id: 'test',
+                message: 'test',
+            },
+        });
+        expect(messageListener).toHaveBeenCalledTimes(1);
+        // we can also subscribe to a specific message event
+        const specificMessageListener = jest.fn();
+        channel.onMessageEvent('test', specificMessageListener);
+        expect(specificMessageListener).not.toHaveBeenCalled();
+        receiver.publish({
+            requestId: 'test',
+            action: pondsocket_common_1.ServerActions.BROADCAST,
+            event: 'test',
+            channelName: 'test',
+            payload: {
+                id: 'test',
+                message: 'test',
+            },
+        });
+        expect(specificMessageListener).toHaveBeenCalledWith({
+            id: 'test',
+            message: 'test',
+        });
+        specificMessageListener.mockClear();
+        // if a message event is received for the same channel, but a different event, it should not be sent to the listener
+        receiver.publish({
+            requestId: 'test',
+            action: pondsocket_common_1.ServerActions.BROADCAST,
+            event: 'test2',
+            channelName: 'test',
+            payload: {
+                id: 'test',
+                message: 'test',
+            },
+        });
+        expect(specificMessageListener).not.toHaveBeenCalled();
+        // if a message event is received for a different channel, it should not be sent to the listener
+        receiver.publish({
+            requestId: 'test',
+            action: pondsocket_common_1.ServerActions.BROADCAST,
+            event: 'test',
+            channelName: 'test2',
+            payload: {
+                id: 'test',
+                message: 'test',
+            },
+        });
+        expect(specificMessageListener).not.toHaveBeenCalled();
+    });
+    it('should be able to broadcast a message', () => {
+        const { channel, receiver, publisher } = createChannel();
+        channel.join();
+        publisher.mockClear();
+        receiver.publish({
+            requestId: 'test',
+            action: 'SYSTEM',
+            channelName: 'test',
+            event: pondsocket_common_1.Events.ACKNOWLEDGE,
+            payload: {
+                event: 'JOIN',
+            },
+        });
+        channel.sendMessage('test', {
+            test: 'test',
+        }, ['test1']);
+        expect(publisher).toHaveBeenCalledWith(expect.objectContaining({
+            action: pondsocket_common_1.ClientActions.BROADCAST,
+            channelName: 'test',
+            event: 'test',
+            payload: {
+                test: 'test',
+            },
+            addresses: ['test1'],
+        }));
+        publisher.mockClear();
+        channel.broadcastFrom('test', {
+            test: 'test',
+        });
+        expect(publisher).toHaveBeenCalledWith(expect.objectContaining({
+            action: pondsocket_common_1.ClientActions.BROADCAST,
+            channelName: 'test',
+            event: 'test',
+            payload: {
+                test: 'test',
+            },
+            addresses: pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER,
+        }));
+        publisher.mockClear();
+        channel.broadcast('test', {
+            test: 'test',
+        });
+        expect(publisher).toHaveBeenCalledWith(expect.objectContaining({
+            action: pondsocket_common_1.ClientActions.BROADCAST,
+            channelName: 'test',
+            event: 'test',
+            payload: {
+                test: 'test',
+            },
+            addresses: pondsocket_common_1.ChannelReceiver.ALL_USERS,
+        }));
+    });
+    it('should be able to wait for a message', () => __awaiter(void 0, void 0, void 0, function* () {
+        const state = new pondsocket_common_1.SimpleBehaviorSubject(true);
+        const receiver = new pondsocket_common_1.SimpleSubject();
+        const params = {};
+        const publisher = (data) => {
+            if (data.event === 'WAITING') {
+                // if the server response with another request id, it should not be sent to the listener
+                receiver.publish({
+                    requestId: 'test',
+                    action: pondsocket_common_1.ServerActions.BROADCAST,
+                    event: 'test',
+                    channelName: 'test',
+                    payload: {
+                        id: 'test',
+                        response: 'test-response',
+                    },
+                });
+                // if the server response with the same request id, it should be sent to the listener
+                receiver.publish({
+                    requestId: data.requestId,
+                    action: pondsocket_common_1.ServerActions.BROADCAST,
+                    event: 'test',
+                    channelName: 'test',
+                    payload: {
+                        id: 'test',
+                        response: 'second-test-response',
+                    },
+                });
+            }
+        };
+        const channel = new channel_1.Channel(publisher, state, 'test', receiver, params);
+        channel.join();
+        receiver.publish({
+            requestId: 'test',
+            action: 'SYSTEM',
+            channelName: 'test',
+            event: pondsocket_common_1.Events.ACKNOWLEDGE,
+            payload: {
+                event: 'JOIN',
+            },
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        // @ts-expect-error - this is a test
+        const response = yield channel.sendForResponse('WAITING', {
+            id: 'test',
+            message: 'test',
+        });
+        expect(response).toEqual({
+            id: 'test',
+            response: 'second-test-response',
+        });
+    }));
+});