@eleven-am/pondsocket 0.1.169 → 0.1.170

package/channel/channel.test.js

@@ -1,435 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createParentEngine = void 0;
-const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
-const channel_1 = require("./channel");
-const eventRequest_1 = require("./eventRequest");
-const eventResponse_1 = require("./eventResponse");
-const endpoint_test_1 = require("../endpoint/endpoint.test");
-const createParentEngine = () => {
-    const socket = {
-        clientId: 'test2',
-        assigns: { assign: 'assign' },
-        channelName: 'channel',
-        requestId: 'requestId',
-        subscriptions: new Map(),
-        socket: {
-            send: jest.fn(),
-        },
-    };
-    const lobbyEngineMock = {
-        onEvent: jest.fn(),
-        onLeave: jest.fn(),
-        broadcast: jest.fn(),
-        execute: jest.fn(),
-        getChannel: jest.fn(),
-        destroyChannel: jest.fn(),
-        listChannels: jest.fn(),
-        createChannel: jest.fn(),
-        parent: (0, endpoint_test_1.createEndpointEngine)(socket),
-        middleware: {
-            run: jest.fn(),
-        },
-    };
-    return {
-        parentEngine: lobbyEngineMock,
-        socket,
-    };
-};
-exports.createParentEngine = createParentEngine;
-describe('ChannelEngine', () => {
-    it('should add user to channel', () => {
-        const onMessage = jest.fn();
-        const { parentEngine } = (0, exports.createParentEngine)();
-        const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
-        expect(channelEngine.size).toEqual(0);
-        expect(channelEngine.getUserData('test')).not.toBeDefined();
-        channelEngine.addUser('test', { test: 1 }, onMessage);
-        expect(channelEngine.size).toEqual(1);
-        expect(channelEngine.getUserData('test')).toEqual({
-            assigns: { test: 1 },
-            presence: {},
-            id: 'test',
-        });
-    });
-    it('should throw error if user is already in channel', () => {
-        const onMessage = jest.fn();
-        const { parentEngine } = (0, exports.createParentEngine)();
-        const channelEngine = new channel_1.ChannelEngine('testChannel', parentEngine);
-        channelEngine.addUser('test', { test: 1 }, onMessage);
-        expect(() => {
-            channelEngine.addUser('test', { test: 1 }, onMessage);
-        }).toThrow('ChannelEngine: User with id test already exists in channel testChannel');
-    });
-    it('should throw error if user is not in channel: updateAssigns', () => {
-        const { parentEngine } = (0, exports.createParentEngine)();
-        const channelEngine = new channel_1.ChannelEngine('testChannel', parentEngine);
-        expect(() => {
-            channelEngine.updateAssigns('test', { test: 2 });
-        }).toThrow('ChannelEngine: User with id test does not exist in channel testChannel');
-    });
-    it('should throw error if user is not in channel: removeUser', () => {
-        const { parentEngine } = (0, exports.createParentEngine)();
-        const channelEngine = new channel_1.ChannelEngine('testChannel', parentEngine);
-        expect(() => {
-            channelEngine.kickUser('test', 'test reason');
-        }).toThrow('ChannelEngine: Invalid recipients test some users do not exist in channel testChannel');
-    });
-    it('should update a users assigns', () => {
-        const onMessage = jest.fn();
-        const { parentEngine } = (0, exports.createParentEngine)();
-        const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
-        channelEngine.addUser('test', { test: 1 }, onMessage);
-        expect(channelEngine.getUserData('test')).toEqual({
-            assigns: { test: 1 },
-            presence: {},
-            id: 'test',
-        });
-        channelEngine.updateAssigns('test', { test: 2 });
-        expect(channelEngine.getUserData('test')).toEqual({
-            assigns: { test: 2 },
-            presence: {},
-            id: 'test',
-        });
-    });
-    it('should be able to get users assigns in the channel', () => {
-        const onMessage = jest.fn();
-        const { parentEngine } = (0, exports.createParentEngine)();
-        const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
-        expect(channelEngine.getAssigns()).toEqual({});
-        channelEngine.addUser('test', { test: 1 }, onMessage);
-        expect(channelEngine.getAssigns()).toEqual({
-            test: { test: 1 },
-        });
-        channelEngine.addUser('test2', { test: 2 }, onMessage);
-        expect(channelEngine.getAssigns()).toEqual({
-            test: { test: 1 },
-            test2: { test: 2 },
-        });
-    });
-    it('should be able to track presence', () => {
-        const onMessage = jest.fn();
-        const { parentEngine } = (0, exports.createParentEngine)();
-        const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
-        channelEngine.addUser('test', { test: 1 }, onMessage);
-        expect(channelEngine.getUserData('test')).toEqual({
-            assigns: { test: 1 },
-            presence: {},
-            id: 'test',
-        });
-        channelEngine.presenceEngine.trackPresence('test', { test: 2 });
-        expect(channelEngine.presenceEngine).toBeDefined();
-        expect(channelEngine.getUserData('test')).toEqual({
-            assigns: { test: 1 },
-            presence: { test: 2 },
-            id: 'test',
-        });
-    });
-    it('should throw error if channel is already tracking the users presence', () => {
-        const onMessage = jest.fn();
-        const { parentEngine } = (0, exports.createParentEngine)();
-        const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
-        channelEngine.addUser('test', { test: 1 }, onMessage);
-        channelEngine.presenceEngine.trackPresence('test', { test: 2 });
-        expect(() => {
-            channelEngine.presenceEngine.trackPresence('test', { test: 2 });
-        }).toThrow('PresenceEngine: Presence with key test already exists');
-    });
-    it('should be able to list presence', () => {
-        var _a;
-        const onMessage = jest.fn();
-        const { parentEngine } = (0, exports.createParentEngine)();
-        const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
-        channelEngine.addUser('test', { test: 1 }, onMessage);
-        channelEngine.addUser('test2', { test: 2 }, onMessage);
-        channelEngine.presenceEngine.trackPresence('test', { test: 2 });
-        expect(onMessage).toHaveBeenCalledWith(expect.objectContaining({
-            channelName: 'test',
-            action: pondsocket_common_1.ServerActions.PRESENCE,
-            event: pondsocket_common_1.PresenceEventTypes.JOIN,
-            payload: {
-                presence: [{ test: 2 }],
-                changed: {
-                    test: 2,
-                },
-            },
-        }));
-        channelEngine.presenceEngine.trackPresence('test2', { test: 3 });
-        expect((_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence()).toEqual({
-            test: { test: 2 },
-            test2: { test: 3 },
-        });
-        expect(onMessage).toHaveBeenCalledTimes(5);
-    });
-    it('should update a users presence', () => {
-        var _a;
-        const onMessage = jest.fn();
-        const { parentEngine } = (0, exports.createParentEngine)();
-        const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
-        channelEngine.addUser('test', { test: 1 }, onMessage);
-        channelEngine.presenceEngine.trackPresence('test', { test: 2 });
-        expect(channelEngine.getUserData('test')).toEqual({
-            assigns: { test: 1 },
-            presence: { test: 2 },
-            id: 'test',
-        });
-        (_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.updatePresence('test', { test: 3 });
-        expect(channelEngine.getUserData('test')).toEqual({
-            assigns: { test: 1 },
-            presence: { test: 3 },
-            id: 'test',
-        });
-    });
-    it('should remove user from channel', () => {
-        const onMessage = jest.fn();
-        const { parentEngine, socket } = (0, exports.createParentEngine)();
-        const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
-        const unsub = channelEngine.addUser('test1', { test: 1 }, onMessage);
-        socket.subscriptions.set('test', unsub);
-        expect(channelEngine.size).toEqual(1);
-        expect(channelEngine.getUserData('test1')).toBeDefined();
-        channelEngine.kickUser('test1', 'test reason');
-        expect(channelEngine.size).toEqual(0);
-        expect(channelEngine.getUserData('test')).not.toBeDefined();
-    });
-    it('should untrack presence when user is removed', () => {
-        var _a;
-        const onMessage = jest.fn();
-        const { parentEngine, socket } = (0, exports.createParentEngine)();
-        const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
-        const unsub = channelEngine.addUser('test1', { test: 1 }, onMessage);
-        socket.subscriptions.set('test', unsub);
-        channelEngine.presenceEngine.trackPresence('test1', { test: 2 });
-        channelEngine.addUser('test2', { test: 1 }, onMessage);
-        channelEngine.presenceEngine.trackPresence('test2', { test: 2 });
-        expect(channelEngine.presenceEngine.getPresence()).toEqual({
-            test1: { test: 2 },
-            test2: { test: 2 },
-        });
-        onMessage.mockClear();
-        channelEngine.kickUser('test1', 'test reason');
-        expect((_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence()).toEqual({
-            test2: { test: 2 },
-        });
-        expect(onMessage).toHaveBeenCalledWith(expect.objectContaining({
-            channelName: 'test',
-            event: pondsocket_common_1.PresenceEventTypes.LEAVE,
-            action: pondsocket_common_1.ServerActions.PRESENCE,
-            payload: {
-                presence: [{ test: 2 }],
-                changed: {
-                    test: 2,
-                },
-            },
-        }));
-    });
-    it('should throw error if user is not in channel and isPond is false', () => {
-        const { parentEngine } = (0, exports.createParentEngine)();
-        const channelEngine = new channel_1.ChannelEngine('testChannel', parentEngine);
-        // add a user to the channel
-        channelEngine.addUser('test', { test: 1 }, jest.fn());
-        // track the added user's presence
-        channelEngine.presenceEngine.trackPresence('test', { test: 2 });
-        // we do this because we want to initialize the presence engine
-        // the engine is not initialized by default when a channel is created
-        expect(() => {
-            var _a;
-            // now we try to untrack the presence of a user that is not in the channel
-            (_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.removePresence('test1');
-        }).toThrow('PresenceEngine: Presence with key test1 does not exist');
-    });
-    it('should not throw error if user is not in channel and isPond is true', () => {
-        const { parentEngine } = (0, exports.createParentEngine)();
-        const channelEngine = new channel_1.ChannelEngine('testChannel', parentEngine);
-        // add a user to the channel
-        channelEngine.addUser('test', { test: 1 }, jest.fn());
-        // track the added user's presence
-        channelEngine.presenceEngine.trackPresence('test', { test: 2 });
-        // we do this because we want to initialize the presence engine
-        // the engine is not initialized by default when a xhannel is created
-        expect(() => {
-            var _a;
-            // now we try to untrack the presence of a user that is not in the channel
-            (_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.removePresence('test');
-        }).not.toThrow();
-    });
-    it('should be able to kick a user from the channel', () => {
-        const onMessage = jest.fn();
-        const { parentEngine, socket } = (0, exports.createParentEngine)();
-        const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
-        channelEngine.addUser('test1', { test: 1 }, onMessage);
-        const unsub = channelEngine.addUser('test2', { test: 1 }, onMessage);
-        onMessage.mockClear();
-        socket.subscriptions.set('test', unsub);
-        channelEngine.kickUser('test1', 'test reason');
-        expect(channelEngine.size).toEqual(1);
-        expect(channelEngine.getUserData('test2')).not.toBeDefined();
-        expect(onMessage.mock.calls[0][0]).toStrictEqual(expect.objectContaining({
-            action: pondsocket_common_1.ServerActions.SYSTEM,
-            channelName: 'test',
-            event: 'kicked_out',
-            payload: {
-                code: 403,
-                message: 'test reason',
-            },
-        }));
-        expect(onMessage.mock.calls[1][0]).toStrictEqual(expect.objectContaining({
-            action: pondsocket_common_1.ServerActions.SYSTEM,
-            channelName: 'test',
-            event: 'kicked',
-            payload: {
-                reason: 'test reason',
-                userId: 'test1',
-            },
-        }));
-        expect(onMessage).toHaveBeenCalledTimes(2);
-    });
-    it('should call destroy on parent engine', () => {
-        const { parentEngine } = (0, exports.createParentEngine)();
-        const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
-        channelEngine.destroy('test');
-        expect(parentEngine.destroyChannel).toHaveBeenCalled();
-    });
-    it('should broadcast a message to all users', () => {
-        const onMessage = jest.fn();
-        const { parentEngine } = (0, exports.createParentEngine)();
-        const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
-        channelEngine.addUser('test', { test: 1 }, onMessage);
-        channelEngine.addUser('test2', { test: 1 }, onMessage);
-        onMessage.mockClear();
-        channelEngine.sendMessage(pondsocket_common_1.SystemSender.CHANNEL, pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.BROADCAST, 'test', { test: 2 });
-        expect(onMessage.mock.calls[0][0]).toStrictEqual(expect.objectContaining({
-            action: pondsocket_common_1.ServerActions.BROADCAST,
-            channelName: 'test',
-            event: 'test',
-            payload: {
-                test: 2,
-            },
-        }));
-        expect(onMessage).toHaveBeenCalledTimes(2);
-        onMessage.mockClear();
-        channelEngine.sendMessage('test2', pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, pondsocket_common_1.ServerActions.BROADCAST, 'test', { test: 3 });
-        expect(onMessage).toHaveBeenCalledTimes(1);
-        onMessage.mockClear();
-        // when user is not in channel it throws an error
-        expect(() => {
-            channelEngine.sendMessage('test3', pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, pondsocket_common_1.ServerActions.BROADCAST, 'test', { test: 3 });
-        }).toThrow('ChannelEngine: User with id test3 does not exist in channel test');
-    });
-    it('should broadcast a message to all users except sender', () => {
-        const onMessage = jest.fn();
-        const { parentEngine } = (0, exports.createParentEngine)();
-        const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
-        channelEngine.addUser('test', { test: 1 }, onMessage);
-        channelEngine.addUser('test2', { test: 1 }, onMessage);
-        onMessage.mockClear();
-        channelEngine.sendMessage('test2', pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, pondsocket_common_1.ServerActions.BROADCAST, 'test', { test: 2 });
-        expect(onMessage.mock.calls[0][0]).toStrictEqual(expect.objectContaining({
-            action: pondsocket_common_1.ServerActions.BROADCAST,
-            channelName: 'test',
-            event: 'test',
-            payload: {
-                test: 2,
-            },
-        }));
-        expect(onMessage).toHaveBeenCalledTimes(1);
-        // when user is not in channel it throws an error
-        expect(() => {
-            channelEngine.sendMessage('test3', pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, pondsocket_common_1.ServerActions.BROADCAST, 'test', { test: 3 });
-        }).toThrow('ChannelEngine: User with id test3 does not exist in channel test');
-        // when sender is channel itself it throws an error
-        expect(() => {
-            channelEngine.sendMessage(pondsocket_common_1.SystemSender.CHANNEL, pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, pondsocket_common_1.ServerActions.BROADCAST, 'test', { test: 3 });
-        }).toThrow(`ChannelEngine: Cannot use ${pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER} with ${pondsocket_common_1.SystemSender.CHANNEL}`);
-    });
-    it('should broadcast a message to  specific users', () => {
-        const onMessage = jest.fn();
-        const { parentEngine } = (0, exports.createParentEngine)();
-        const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
-        channelEngine.addUser('test', { test: 1 }, onMessage);
-        channelEngine.addUser('test2', { test: 1 }, onMessage);
-        channelEngine.addUser('test3', { test: 1 }, onMessage);
-        onMessage.mockClear();
-        channelEngine.sendMessage('test2', ['test', 'test3'], pondsocket_common_1.ServerActions.BROADCAST, 'test', { test: 2 });
-        expect(onMessage.mock.calls[0][0]).toStrictEqual(expect.objectContaining({
-            action: pondsocket_common_1.ServerActions.BROADCAST,
-            channelName: 'test',
-            event: 'test',
-            payload: {
-                test: 2,
-            },
-        }));
-        expect(onMessage.mock.calls[1][0]).toStrictEqual(expect.objectContaining({
-            action: pondsocket_common_1.ServerActions.BROADCAST,
-            channelName: 'test',
-            event: 'test',
-            payload: {
-                test: 2,
-            },
-        }));
-        expect(onMessage).toHaveBeenCalledTimes(2);
-        // when recipient is not in channel it throws an error
-        expect(() => {
-            channelEngine.sendMessage('test3', ['test', 'test3', 'test4'], pondsocket_common_1.ServerActions.BROADCAST, 'test', { test: 3 });
-        }).toThrow('ChannelEngine: Invalid recipients test,test3,test4 some users do not exist in channel test');
-        // when sender is not in channel it throws an error
-        expect(() => {
-            channelEngine.sendMessage('test4', ['test', 'test3'], pondsocket_common_1.ServerActions.BROADCAST, 'test', { test: 3 });
-        }).toThrow('ChannelEngine: User with id test4 does not exist in channel test');
-    });
-    it('should broadcast messages while also triggering the onMessage callback', () => {
-        const onMessage = jest.fn();
-        const { parentEngine } = (0, exports.createParentEngine)();
-        const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
-        parentEngine.middleware.run = (req, res) => {
-            expect(req).toBeInstanceOf(eventRequest_1.EventRequest);
-            expect(res).toBeInstanceOf(eventResponse_1.EventResponse);
-        };
-        expect(() => channelEngine.broadcastMessage('test2', {
-            action: pondsocket_common_1.ClientActions.BROADCAST,
-            channelName: 'test',
-            event: 'test',
-            payload: { test: 1 },
-            requestId: (0, pondsocket_common_1.uuid)(),
-        })).toThrow('ChannelEngine: User with id test2 does not exist in channel test');
-        channelEngine.addUser('test2', { test: 1 }, onMessage);
-        onMessage.mockClear();
-        channelEngine.broadcastMessage('test2', {
-            action: pondsocket_common_1.ClientActions.BROADCAST,
-            channelName: 'test',
-            event: 'test',
-            payload: { test: 1 },
-            requestId: (0, pondsocket_common_1.uuid)(),
-        });
-        // This is because the message didn't perform any sort of broadcast
-        expect(onMessage).toHaveBeenCalledTimes(0);
-        let count = 0;
-        onMessage.mockClear();
-        parentEngine.middleware.run = (req, res, next) => {
-            expect(req).toBeInstanceOf(eventRequest_1.EventRequest);
-            expect(res).toBeInstanceOf(eventResponse_1.EventResponse);
-            count++;
-            next();
-        };
-        channelEngine.broadcastMessage('test2', {
-            action: pondsocket_common_1.ClientActions.BROADCAST,
-            channelName: 'test',
-            event: 'test',
-            payload: { test: 1 },
-            requestId: (0, pondsocket_common_1.uuid)(),
-        });
-        // proves that the message was received by the parent engine
-        expect(count).toBe(1);
-        // however the onMessage callback was not called
-        // because the message was never handled by the parent engine
-        expect(onMessage).toHaveBeenCalledWith(expect.objectContaining({
-            action: pondsocket_common_1.ServerActions.ERROR,
-            channelName: 'test',
-            event: pondsocket_common_1.ErrorTypes.HANDLER_NOT_FOUND,
-            payload: {
-                code: 404,
-                message: 'A handler did not respond to the event',
-            },
-        }));
-    });
-});

package/channel/eventRequest.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventRequest = void 0;
-const channel_1 = require("./channel");
-const abstractRequest_1 = require("../abstracts/abstractRequest");
-const pondError_1 = require("../errors/pondError");
-class EventRequest extends abstractRequest_1.AbstractRequest {
-    constructor(event, engine) {
-        super(event.event, engine, event.payload);
-        this._internalEvent = event;
-    }
-    get user() {
-        const assigns = this._engine.getUserData(this._internalEvent.sender);
-        if (!assigns) {
-            const message = `ChannelRequest: User with id ${this._internalEvent.sender} does not exist in channel ${this._engine.name}`;
-            const code = 404;
-            throw new pondError_1.ChannelError(message, code, this._engine.name);
-        }
-        return assigns;
-    }
-    get channel() {
-        return new channel_1.Channel(this._engine);
-    }
-}
-exports.EventRequest = EventRequest;

package/channel/eventRequest.test.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const eventRequest_1 = require("./eventRequest");
-const eventResponse_test_1 = require("./eventResponse.test");
-describe('ChannelRequest', () => {
-    it('should create a new ChannelRequest', () => {
-        const { channelEngine } = (0, eventResponse_test_1.createChannelEngine)();
-        const event = (0, eventResponse_test_1.createChannelEvent)(channelEngine.name);
-        const channelRequest = new eventRequest_1.EventRequest(event, channelEngine);
-        expect(channelRequest).toBeDefined();
-    });
-    it('should return the payload', () => {
-        const { channelEngine } = (0, eventResponse_test_1.createChannelEngine)();
-        const event = (0, eventResponse_test_1.createChannelEvent)(channelEngine.name);
-        const channelRequest = new eventRequest_1.EventRequest(event, channelEngine);
-        channelRequest._parseQueries('event');
-        expect(channelRequest.event.payload).toEqual(event.payload);
-    });
-    it('should return the user', () => {
-        const { channelEngine } = (0, eventResponse_test_1.createChannelEngine)();
-        const event = (0, eventResponse_test_1.createChannelEvent)(channelEngine.name);
-        const channelRequest = new eventRequest_1.EventRequest(event, channelEngine);
-        // because the user in the event does not exist in the channel, this should throw an error
-        expect(() => channelRequest.user).toThrow();
-        // add the user to the channel
-        channelEngine.addUser(event.sender, { assign: 'assign' }, () => { });
-        // now the user should be returned
-        expect(channelRequest.user).toEqual(channelEngine.getUserData(event.sender));
-    });
-});

package/channel/eventResponse.test.js

@@ -1,175 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createChannelEvent = exports.createChannelEngine = void 0;
-const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
-const channel_1 = require("./channel");
-const channel_test_1 = require("./channel.test");
-const eventResponse_1 = require("./eventResponse");
-const createChannelEngine = () => {
-    const { parentEngine, socket } = (0, channel_test_1.createParentEngine)();
-    const channelEngine = new channel_1.ChannelEngine('test', parentEngine);
-    return {
-        channelEngine,
-        parentEngine,
-        socket,
-    };
-};
-exports.createChannelEngine = createChannelEngine;
-const createChannelEvent = (name) => {
-    const responseEvent = {
-        event: 'event',
-        payload: {
-            payload: 'payload',
-        },
-        sender: 'sender',
-        action: pondsocket_common_1.ServerActions.BROADCAST,
-        channelName: name,
-        requestId: 'requestId',
-    };
-    return responseEvent;
-};
-exports.createChannelEvent = createChannelEvent;
-const createChannelResponse = () => {
-    const { channelEngine, socket } = (0, exports.createChannelEngine)();
-    const event = (0, exports.createChannelEvent)(channelEngine.name);
-    const unsub = channelEngine.addUser(event.sender, { assign: 'assign' }, () => { });
-    socket.subscriptions.set(channelEngine.name, unsub);
-    channelEngine.addUser('tester', { assign: 'assign' }, () => { });
-    const response = new eventResponse_1.EventResponse(event, channelEngine);
-    return {
-        channelEngine,
-        event,
-        response,
-    };
-};
-describe('ChannelResponse', () => {
-    it('should create a new ChannelResponse', () => {
-        const { response } = createChannelResponse();
-        expect(response).toBeDefined();
-    });
-    it('should send a direct message', () => {
-        const { response, channelEngine, event } = createChannelResponse();
-        jest.spyOn(channelEngine, 'sendMessage');
-        response.reply('event', { payload: 'payload' });
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith(pondsocket_common_1.SystemSender.CHANNEL, [event.sender], pondsocket_common_1.ServerActions.SYSTEM, 'event', { payload: 'payload' }, 'requestId');
-    });
-    it('should broadcast a message', () => {
-        const { response, channelEngine } = createChannelResponse();
-        jest.spyOn(channelEngine, 'sendMessage');
-        response.broadcast('event', { payload: 'payload' });
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith('sender', pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_1.ServerActions.BROADCAST, 'event', { payload: 'payload' }, 'requestId');
-    });
-    it('should broadcastFromUser a message', () => {
-        const { response, channelEngine } = createChannelResponse();
-        jest.spyOn(channelEngine, 'sendMessage');
-        response.broadcastFrom('event', { payload: 'payload' });
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith('sender', pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, pondsocket_common_1.ServerActions.BROADCAST, 'event', { payload: 'payload' }, 'requestId');
-    });
-    it('should sendToUsers a message', () => {
-        const { response, channelEngine } = createChannelResponse();
-        jest.spyOn(channelEngine, 'sendMessage');
-        response.broadcastTo('event', { payload: 'payload' }, 'tester');
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith('sender', ['tester'], pondsocket_common_1.ServerActions.BROADCAST, 'event', { payload: 'payload' }, 'requestId');
-        channelEngine.sendMessage.mockClear();
-        response.broadcastTo('event', { payload: 'payload' }, ['tester', 'sender']);
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith('sender', ['tester', 'sender'], pondsocket_common_1.ServerActions.BROADCAST, 'event', { payload: 'payload' }, 'requestId');
-    });
-    it('should fail to send to non existing users', () => {
-        const { response } = createChannelResponse();
-        expect(() => response.broadcastTo('event', { payload: 'payload' }, ['non_existing_user']))
-            .toThrow('ChannelEngine: Invalid recipients non_existing_user some users do not exist in channel test');
-    });
-    it('should track a trackPresence', () => {
-        const { response, channelEngine } = createChannelResponse();
-        jest.spyOn(channelEngine.presenceEngine, 'trackPresence');
-        response.trackPresence({ status: 'online' });
-        expect(channelEngine.presenceEngine.trackPresence).toHaveBeenCalledWith('sender', { status: 'online' });
-    });
-    it('should update a users assign data', () => {
-        const { response, channelEngine } = createChannelResponse();
-        jest.spyOn(channelEngine, 'updateAssigns');
-        response.assign({ assign: 'updated' });
-        expect(channelEngine.updateAssigns).toHaveBeenCalledWith('sender', { assign: 'updated' });
-    });
-    it('should evict a user', () => {
-        const { response, channelEngine } = createChannelResponse();
-        jest.spyOn(channelEngine, 'kickUser');
-        response.evictUser('recipient');
-        expect(channelEngine.kickUser).toHaveBeenCalledWith('sender', 'recipient');
-    });
-    it('should destroy the channel', () => {
-        const { channelEngine, socket } = (0, exports.createChannelEngine)();
-        const event = (0, exports.createChannelEvent)(channelEngine.name);
-        const unsub = channelEngine.addUser(event.sender, { assign: 'assign' }, () => { });
-        socket.subscriptions.set(channelEngine.name, unsub);
-        const response = new eventResponse_1.EventResponse(event, channelEngine);
-        jest.spyOn(channelEngine, 'destroy');
-        response.closeChannel('recipient');
-        expect(channelEngine.destroy).toHaveBeenCalledWith('recipient');
-    });
-    it('should call the presence engine when the trackPresence is called', () => {
-        const { response, channelEngine } = createChannelResponse();
-        jest.spyOn(channelEngine.presenceEngine, 'trackPresence');
-        expect(channelEngine.presenceEngine.trackPresence).not.toHaveBeenCalled();
-        response.trackPresence({ status: 'online' });
-        expect(channelEngine.presenceEngine.trackPresence).toHaveBeenCalledWith('sender', { status: 'online' });
-    });
-    it('should throw an error if trackPresence is called twice', () => {
-        const { response, channelEngine } = createChannelResponse();
-        jest.spyOn(channelEngine.presenceEngine, 'trackPresence');
-        expect(channelEngine.presenceEngine.trackPresence).not.toHaveBeenCalled();
-        response.trackPresence({ status: 'online' });
-        expect(channelEngine.presenceEngine.trackPresence).toHaveBeenCalledWith('sender', { status: 'online' });
-        expect(() => response.trackPresence({ status: 'online' })).toThrow('PresenceEngine: Presence with key sender already exists');
-    });
-    it('should throw an error if trackPresence is called for a non existing user', () => {
-        const { response, channelEngine } = createChannelResponse();
-        jest.spyOn(channelEngine.presenceEngine, 'trackPresence');
-        expect(channelEngine.presenceEngine.trackPresence).not.toHaveBeenCalled();
-        expect(() => response.trackPresence({ status: 'online' }, 'non_existent_user'))
-            .toThrow('ChannelEngine: Invalid recipients non_existent_user some users do not exist in channel test');
-    });
-    it('should update the presence of a user that is already tracked', () => {
-        var _a, _b;
-        const { response, channelEngine } = createChannelResponse();
-        jest.spyOn(channelEngine.presenceEngine, 'trackPresence');
-        expect(channelEngine.presenceEngine.trackPresence).not.toHaveBeenCalled();
-        response.trackPresence({ status: 'online' });
-        expect(channelEngine.presenceEngine.trackPresence).toHaveBeenCalledWith('sender', { status: 'online' });
-        expect((_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence()).toEqual({
-            sender: { status: 'online' },
-        });
-        response.updatePresence({ status: 'offline' });
-        expect((_b = channelEngine.presenceEngine) === null || _b === void 0 ? void 0 : _b.getPresence()).toEqual({
-            sender: { status: 'offline' },
-        });
-    });
-    it('should throw an error if updatePresence is called for a non existing user', () => {
-        const { response, channelEngine } = createChannelResponse();
-        jest.spyOn(channelEngine.presenceEngine, 'trackPresence');
-        expect(channelEngine.presenceEngine.trackPresence).not.toHaveBeenCalled();
-        response.trackPresence({ status: 'online' });
-        expect(() => response.updatePresence({ status: 'online' }, 'non_existent_user'))
-            .toThrow('PresenceEngine: Presence with key non_existent_user does not exist');
-    });
-    it('should unTrack a trackPresence', () => {
-        var _a, _b;
-        const { response, channelEngine } = createChannelResponse();
-        response.trackPresence({ status: 'online' });
-        expect((_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence()).toEqual({
-            sender: { status: 'online' },
-        });
-        response.removePresence();
-        expect((_b = channelEngine.presenceEngine) === null || _b === void 0 ? void 0 : _b.getPresence()).toEqual({});
-    });
-    it('should throw an error if unTrackPresence is called for a non existing user', () => {
-        var _a;
-        const { response, channelEngine } = createChannelResponse();
-        response.trackPresence({ status: 'online' });
-        expect((_a = channelEngine.presenceEngine) === null || _a === void 0 ? void 0 : _a.getPresence()).toEqual({
-            sender: { status: 'online' },
-        });
-        expect(() => response.removePresence('non_existent_user'))
-            .toThrow('PresenceEngine: Presence with key non_existent_user does not exist');
-    });
-});