@eleven-am/pondsocket 0.1.11 → 0.1.12

package/dist/server/channel/channelEngine.js

@@ -0,0 +1,279 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelEngine = exports.ServerActions = void 0;
+const eventRequest_1 = require("./eventRequest");
+const eventResponse_1 = require("./eventResponse");
+const presenceEngine_1 = require("../presence/presenceEngine");
+const subjectUtils_1 = require("../utils/subjectUtils");
+var ServerActions;
+(function (ServerActions) {
+    ServerActions["PRESENCE"] = "PRESENCE";
+    ServerActions["SYSTEM"] = "SYSTEM";
+    ServerActions["BROADCAST"] = "BROADCAST";
+    ServerActions["ERROR"] = "ERROR";
+})(ServerActions = exports.ServerActions || (exports.ServerActions = {}));
+class ChannelEngine {
+    constructor(name, parent) {
+        this.name = name;
+        this._receiver = new subjectUtils_1.Subject();
+        this._users = new Map();
+        this._parentEngine = parent;
+    }
+    /**
+     * @desc Adds a user to the channel
+     * @param userId - The id of the user to add
+     * @param assigns - The assigns to add to the user
+     * @param onMessage - The callback to call when a message is received
+     */
+    addUser(userId, assigns, onMessage) {
+        const oldUser = this._users.get(userId);
+        if (oldUser) {
+            throw new Error(`ChannelEngine: User with id ${userId} already exists in channel ${this.name}`);
+        }
+        this._users.set(userId, assigns);
+        return this._subscribe(userId, onMessage);
+    }
+    /**
+     * @desc Removes a user from the channel
+     * @param userId - The id of the user to remove
+     * @param isPond - Whether the user is a pond or not
+     */
+    removeUser(userId, isPond = false) {
+        const user = this._users.get(userId);
+        if (user) {
+            this._users.delete(userId);
+            this.unTrackPresence(userId, true);
+            this._receiver.unsubscribe(userId);
+            if (this._users.size === 0) {
+                this._parentEngine.destroyChannel();
+            }
+        }
+        else if (!isPond) {
+            throw new Error(`ChannelEngine: User with id ${userId} does not exist in channel ${this.name}`);
+        }
+    }
+    /**
+     * @desc Kicks a user from the channel
+     * @param userId - The id of the user to kick
+     * @param reason - The reason for kicking the user
+     */
+    kickUser(userId, reason) {
+        this.sendMessage('channel', [userId], ServerActions.SYSTEM, 'kicked_out', {
+            message: 'You have been kicked out of the channel',
+            reason,
+        });
+        this.removeUser(userId);
+        this.sendMessage('channel', 'all_users', ServerActions.SYSTEM, 'kicked', {
+            userId,
+            reason,
+        });
+    }
+    /**
+     * @desc Self destructs the channel
+     * @param reason - The reason for self-destructing the channel
+     */
+    destroy(reason) {
+        this.sendMessage('channel', 'all_users', ServerActions.ERROR, 'destroyed', {
+            message: 'Channel has been destroyed',
+            reason,
+        });
+        this._parentEngine.destroyChannel();
+        this._users.forEach((_, userId) => this._receiver.unsubscribe(userId));
+    }
+    /**
+     * @desc Begins tracking a user's presence
+     * @param userId - The id of the user to track
+     * @param presence - The initial presence of the user
+     */
+    trackPresence(userId, presence) {
+        this._presenceEngine = this._presenceEngine || new presenceEngine_1.PresenceEngine();
+        if (!this._users.has(userId)) {
+            throw new Error(`ChannelEngine: User with id ${userId} does not exist in channel ${this.name}`);
+        }
+        if (this._presenceEngine.getUserPresence(userId)) {
+            throw new Error(`ChannelEngine: User with id ${userId} already has a presence subscription in channel ${this.name}`);
+        }
+        this._presenceEngine.trackPresence(userId, presence, (change) => {
+            const { type } = change, rest = __rest(change, ["type"]);
+            this.sendMessage('channel', [userId], ServerActions.PRESENCE, type, rest);
+        });
+    }
+    /**
+     * @desc Updates a user's presence
+     * @param userId - The id of the user to update
+     * @param presence - The new presence of the user
+     */
+    updatePresence(userId, presence) {
+        if (!this._users.has(userId)) {
+            throw new Error(`ChannelEngine: User with id ${userId} does not exist in channel ${this.name}`);
+        }
+        if (this._presenceEngine) {
+            this._presenceEngine.updatePresence(userId, presence);
+        }
+        else {
+            throw new Error('ChannelEngine: Presence engine is not initialized');
+        }
+    }
+    /**
+     * @desc Updates a user's assigns
+     * @param userId - The id of the user to update
+     * @param assigns - The new assigns of the user
+     */
+    updateAssigns(userId, assigns) {
+        const user = this._users.get(userId);
+        if (user) {
+            this._users.set(userId, Object.assign(Object.assign({}, user), assigns));
+        }
+        else {
+            throw new Error(`ChannelEngine: User with id ${userId} does not exist in channel ${this.name}`);
+        }
+    }
+    /**
+     * @desc Gets the data of a user
+     * @param userId - The id of the user to get
+     */
+    getUserData(userId) {
+        const presence = this._presenceEngine ? this._presenceEngine.getUserPresence(userId) : {};
+        if (this._users.has(userId)) {
+            return {
+                id: userId,
+                assigns: this._users.get(userId),
+                presence: presence || {},
+            };
+        }
+        return undefined;
+    }
+    /**
+     * @desc Gets the assign data of all users
+     */
+    getAssigns() {
+        const assigns = {};
+        this._users.forEach((value, key) => {
+            assigns[key] = value;
+        });
+        return assigns;
+    }
+    /**
+     * @desc Gets the presence data of all users
+     */
+    getPresence() {
+        if (this._presenceEngine) {
+            return this._presenceEngine.getPresence();
+        }
+        return {};
+    }
+    /**
+     * @desc Stops tracking a user's presence
+     * @param userId - The id of the user to be untracked
+     * @param isPond - Whether the user is a pond
+     */
+    unTrackPresence(userId, isPond = false) {
+        if (this._presenceEngine) {
+            if (isPond && this._presenceEngine.getUserPresence(userId)) {
+                this._presenceEngine.removePresence(userId);
+            }
+            else if (!isPond) {
+                this._presenceEngine.removePresence(userId);
+            }
+        }
+    }
+    /**
+     * @desc Sends a message to a specified set of users, from a specified sender
+     * @param sender - The sender of the message
+     * @param recipient - The users to send the message to
+     * @param action - The action of the message
+     * @param event - The event name
+     * @param payload - The payload of the message
+     * @private
+     */
+    sendMessage(sender, recipient, action, event, payload) {
+        if (!this._users.has(sender) && sender !== 'channel') {
+            throw new Error(`ChannelEngine: User with id ${sender} does not exist in channel ${this.name}`);
+        }
+        this._receiver.next({
+            sender,
+            recipients: this._getUsersFromRecipients(recipient, sender),
+            action,
+            payload,
+            event,
+        });
+    }
+    /**
+     * @desc Handles a message from a user
+     * @param userId - The id of the user who sent the message
+     * @param message - The message received
+     */
+    broadcastMessage(userId, message) {
+        if (!this._users.has(userId)) {
+            throw new Error(`ChannelEngine: User with id ${userId} does not exist in channel ${this.name}`);
+        }
+        const responseEvent = {
+            event: message.event,
+            payload: message.payload,
+            action: ServerActions.BROADCAST,
+            sender: userId,
+            recipients: this._getUsersFromRecipients(message.addresses || 'all_users', userId),
+        };
+        const request = new eventRequest_1.EventRequest(responseEvent, this);
+        const response = new eventResponse_1.EventResponse(responseEvent, this);
+        this._parentEngine.execute(request, response, () => {
+            this.sendMessage('channel', [userId], ServerActions.ERROR, 'error_no_handler', {
+                message: 'A handler did not respond to the event',
+                code: 404,
+            });
+        });
+    }
+    /**
+     * @desc Subscribes to a user's messages
+     * @param userId - The id of the user to subscribe to
+     * @param onMessage - The callback to call when a message is received
+     * @private
+     */
+    _subscribe(userId, onMessage) {
+        this._receiver.subscribe(userId, (event) => {
+            if (event.recipients.includes(userId)) {
+                onMessage({
+                    action: event.action,
+                    event: event.event,
+                    payload: event.payload,
+                    channelName: this.name,
+                });
+            }
+        });
+    }
+    _getUsersFromRecipients(recipients, sender) {
+        const allUsers = Array.from(this._users.keys());
+        let users;
+        switch (recipients) {
+            case 'all_users':
+                users = allUsers;
+                break;
+            case 'all_except_sender':
+                if (sender === 'channel') {
+                    throw new Error('ChannelEngine: Cannot send to all users except sender when sender is channel');
+                }
+                users = allUsers.filter((user) => user !== sender);
+                break;
+            default:
+                const absentUsers = recipients.filter((user) => !allUsers.includes(user));
+                if (absentUsers.length > 0) {
+                    throw new Error(`ChannelEngine: Users ${absentUsers.join(', ')} are not in channel ${this.name}`);
+                }
+                users = recipients;
+                break;
+        }
+        return users;
+    }
+}
+exports.ChannelEngine = ChannelEngine;

package/dist/server/channel/channelEngine.test.js

@@ -0,0 +1,377 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createParentEngine = void 0;
+const channelEngine_1 = require("./channelEngine");
+const presenceEngine_1 = require("../presence/presenceEngine");
+const createParentEngine = () => {
+    const parentEngine = {
+        destroyChannel: jest.fn(),
+        execute: jest.fn(),
+    };
+    return parentEngine;
+};
+exports.createParentEngine = createParentEngine;
+describe('ChannelEngine', () => {
+    it('should add user to channel', () => {
+        const onMessage = jest.fn();
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channelEngine_1.ChannelEngine('test', parentEngine);
+        expect(channelEngine['_users'].size).toEqual(0);
+        expect(channelEngine.getUserData('test')).not.toBeDefined();
+        channelEngine.addUser('test', { test: 1 }, onMessage);
+        expect(channelEngine['_users'].size).toEqual(1);
+        expect(channelEngine['_users'].get('test')).toEqual({ test: 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 channelEngine_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 update a users assigns', () => {
+        const onMessage = jest.fn();
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channelEngine_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 throw error if user is not in channel', () => {
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channelEngine_1.ChannelEngine('testChannel', parentEngine);
+        expect(() => {
+            channelEngine.updateAssigns('test', { test: 2 });
+        }).toThrow('ChannelEngine: User with id test does not exist in channel testChannel');
+    });
+    it('should be able to get users assigns in the channel', () => {
+        const onMessage = jest.fn();
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channelEngine_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 channelEngine_1.ChannelEngine('test', parentEngine);
+        channelEngine.addUser('test', { test: 1 }, onMessage);
+        expect(channelEngine.getUserData('test')).toEqual({
+            assigns: { test: 1 },
+            presence: {},
+            id: 'test',
+        });
+        expect(channelEngine['_presenceEngine']).not.toBeDefined();
+        channelEngine.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 user is not in channel', () => {
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channelEngine_1.ChannelEngine('testChannel', parentEngine);
+        expect(() => {
+            channelEngine.trackPresence('test', { test: 2 });
+        }).toThrow('ChannelEngine: User with id test does not exist in channel testChannel');
+    });
+    it('should throw error if channel is already tracking the users presence', () => {
+        const onMessage = jest.fn();
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channelEngine_1.ChannelEngine('test', parentEngine);
+        channelEngine.addUser('test', { test: 1 }, onMessage);
+        channelEngine.trackPresence('test', { test: 2 });
+        expect(() => {
+            channelEngine.trackPresence('test', { test: 2 });
+        }).toThrow('ChannelEngine: User with id test already has a presence subscription in channel test');
+    });
+    it('should be able to list presence', () => {
+        const onMessage = jest.fn();
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channelEngine_1.ChannelEngine('test', parentEngine);
+        expect(channelEngine.getPresence()).toEqual({});
+        channelEngine.addUser('test', { test: 1 }, onMessage);
+        channelEngine.addUser('test2', { test: 2 }, onMessage);
+        channelEngine.trackPresence('test', { test: 2 });
+        expect(onMessage).toHaveBeenCalledWith({
+            channelName: 'test',
+            action: channelEngine_1.ServerActions.PRESENCE,
+            event: presenceEngine_1.PresenceEventTypes.JOIN,
+            payload: {
+                presence: [{ test: 2 }],
+                changed: {
+                    test: 2,
+                },
+            },
+        });
+        channelEngine.trackPresence('test2', { test: 3 });
+        expect(channelEngine.getPresence()).toEqual({
+            test: { test: 2 },
+            test2: { test: 3 },
+        });
+        expect(onMessage).toHaveBeenCalledTimes(3);
+    });
+    it('should update a users presence', () => {
+        const onMessage = jest.fn();
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channelEngine_1.ChannelEngine('test', parentEngine);
+        channelEngine.addUser('test', { test: 1 }, onMessage);
+        channelEngine.trackPresence('test', { test: 2 });
+        expect(channelEngine.getUserData('test')).toEqual({
+            assigns: { test: 1 },
+            presence: { test: 2 },
+            id: 'test',
+        });
+        channelEngine.updatePresence('test', { test: 3 });
+        expect(channelEngine.getUserData('test')).toEqual({
+            assigns: { test: 1 },
+            presence: { test: 3 },
+            id: 'test',
+        });
+    });
+    it('should throw error if user is not in channel', () => {
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channelEngine_1.ChannelEngine('testChannel', parentEngine);
+        expect(() => {
+            channelEngine.updatePresence('test', { test: 2 });
+        }).toThrow('ChannelEngine: User with id test does not exist in channel testChannel');
+    });
+    it('should throw error if user is not tracking presence', () => {
+        const onMessage = jest.fn();
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channelEngine_1.ChannelEngine('test', parentEngine);
+        channelEngine.addUser('test', { test: 1 }, onMessage);
+        expect(() => {
+            channelEngine.updatePresence('test', { test: 2 });
+        }).toThrow('ChannelEngine: Presence engine is not initialized');
+    });
+    it('should remove user from channel', () => {
+        const onMessage = jest.fn();
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channelEngine_1.ChannelEngine('test', parentEngine);
+        channelEngine.addUser('test', { test: 1 }, onMessage);
+        expect(channelEngine['_users'].size).toEqual(1);
+        expect(channelEngine.getUserData('test')).toBeDefined();
+        channelEngine.removeUser('test');
+        expect(channelEngine['_users'].size).toEqual(0);
+        expect(channelEngine.getUserData('test')).not.toBeDefined();
+    });
+    it('should throw error if user is not in channel', () => {
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channelEngine_1.ChannelEngine('testChannel', parentEngine);
+        expect(() => {
+            channelEngine.removeUser('test');
+        }).toThrow('ChannelEngine: User with id test does not exist in channel testChannel');
+    });
+    it('should untrack presence when user is removed', () => {
+        const onMessage = jest.fn();
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channelEngine_1.ChannelEngine('test', parentEngine);
+        channelEngine.addUser('test', { test: 1 }, onMessage);
+        channelEngine.trackPresence('test', { test: 2 });
+        channelEngine.addUser('test2', { test: 1 }, onMessage);
+        channelEngine.trackPresence('test2', { test: 2 });
+        expect(channelEngine.getPresence()).toEqual({
+            test: { test: 2 },
+            test2: { test: 2 },
+        });
+        onMessage.mockClear();
+        channelEngine.removeUser('test');
+        expect(channelEngine.getPresence()).toEqual({
+            test2: { test: 2 },
+        });
+        expect(onMessage).toHaveBeenCalledWith({
+            channelName: 'test',
+            event: presenceEngine_1.PresenceEventTypes.LEAVE,
+            action: channelEngine_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 channelEngine_1.ChannelEngine('testChannel', parentEngine);
+        // add a user to the channel
+        channelEngine.addUser('test', { test: 1 }, jest.fn());
+        // track the added user's presence
+        channelEngine.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(() => {
+            // now we try to untrack the presence of a user that is not in the channel
+            channelEngine.unTrackPresence('test1', false);
+        }).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 channelEngine_1.ChannelEngine('testChannel', parentEngine);
+        // add a user to the channel
+        channelEngine.addUser('test', { test: 1 }, jest.fn());
+        // track the added user's presence
+        channelEngine.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(() => {
+            // now we try to untrack the presence of a user that is not in the channel
+            channelEngine.unTrackPresence('test', true);
+        }).not.toThrow();
+    });
+    it('should be able to kick a user from the channel', () => {
+        const onMessage = jest.fn();
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channelEngine_1.ChannelEngine('test', parentEngine);
+        channelEngine.addUser('test', { test: 1 }, onMessage);
+        channelEngine.addUser('test2', { test: 1 }, onMessage);
+        channelEngine.kickUser('test2', 'test reason');
+        expect(channelEngine['_users'].size).toEqual(1);
+        expect(channelEngine.getUserData('test2')).not.toBeDefined();
+        expect(onMessage.mock.calls[0][0]).toStrictEqual({
+            action: channelEngine_1.ServerActions.SYSTEM,
+            channelName: 'test',
+            event: 'kicked_out',
+            payload: {
+                reason: 'test reason',
+                message: 'You have been kicked out of the channel',
+            },
+        });
+        expect(onMessage.mock.calls[1][0]).toStrictEqual({
+            action: channelEngine_1.ServerActions.SYSTEM,
+            channelName: 'test',
+            event: 'kicked',
+            payload: {
+                reason: 'test reason',
+                userId: 'test2',
+            },
+        });
+        expect(onMessage).toHaveBeenCalledTimes(2);
+    });
+    it('should call destroy on parent engine', () => {
+        const parentEngine = (0, exports.createParentEngine)();
+        const channelEngine = new channelEngine_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)();
+        parentEngine.execute = (_, res) => {
+            res.accept();
+        };
+        const channelEngine = new channelEngine_1.ChannelEngine('test', parentEngine);
+        channelEngine.addUser('test', { test: 1 }, onMessage);
+        channelEngine.addUser('test2', { test: 1 }, onMessage);
+        channelEngine.sendMessage('channel', 'all_users', channelEngine_1.ServerActions.BROADCAST, 'test', { test: 2 });
+        expect(onMessage.mock.calls[0][0]).toStrictEqual({
+            action: channelEngine_1.ServerActions.BROADCAST,
+            channelName: 'test',
+            event: 'test',
+            payload: {
+                test: 2,
+            },
+        });
+        expect(onMessage).toHaveBeenCalledTimes(2);
+        onMessage.mockClear();
+        channelEngine.sendMessage('test2', 'all_except_sender', channelEngine_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', 'all_except_sender', channelEngine_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)();
+        parentEngine.execute = (_, res) => {
+            res.accept();
+        };
+        const channelEngine = new channelEngine_1.ChannelEngine('test', parentEngine);
+        channelEngine.addUser('test', { test: 1 }, onMessage);
+        channelEngine.addUser('test2', { test: 1 }, onMessage);
+        channelEngine.sendMessage('test2', 'all_except_sender', channelEngine_1.ServerActions.BROADCAST, 'test', { test: 2 });
+        expect(onMessage.mock.calls[0][0]).toStrictEqual({
+            action: channelEngine_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', 'all_except_sender', channelEngine_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('channel', 'all_except_sender', channelEngine_1.ServerActions.BROADCAST, 'test', { test: 3 });
+        }).toThrow('ChannelEngine: Cannot send to all users except sender when sender is channel');
+    });
+    it('should broadcast a message to  specific users', () => {
+        const onMessage = jest.fn();
+        const parentEngine = (0, exports.createParentEngine)();
+        parentEngine.execute = (_, res) => {
+            res.accept();
+        };
+        const channelEngine = new channelEngine_1.ChannelEngine('test', parentEngine);
+        channelEngine.addUser('test', { test: 1 }, onMessage);
+        channelEngine.addUser('test2', { test: 1 }, onMessage);
+        channelEngine.addUser('test3', { test: 1 }, onMessage);
+        channelEngine.sendMessage('test2', ['test', 'test3'], channelEngine_1.ServerActions.BROADCAST, 'test', { test: 2 });
+        expect(onMessage.mock.calls[0][0]).toStrictEqual({
+            action: channelEngine_1.ServerActions.BROADCAST,
+            channelName: 'test',
+            event: 'test',
+            payload: {
+                test: 2,
+            },
+        });
+        expect(onMessage.mock.calls[1][0]).toStrictEqual({
+            action: channelEngine_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'], channelEngine_1.ServerActions.BROADCAST, 'test', { test: 3 });
+        }).toThrow('ChannelEngine: Users test4 are not in channel test');
+        // when sender is not in channel it throws an error
+        expect(() => {
+            channelEngine.sendMessage('test4', ['test', 'test3'], channelEngine_1.ServerActions.BROADCAST, 'test', { test: 3 });
+        }).toThrow('ChannelEngine: User with id test4 does not exist in channel test');
+    });
+});

package/dist/server/channel/channelRequest.test.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const channelResponse_test_1 = require("./channelResponse.test");
+const eventRequest_1 = require("./eventRequest");
+describe('ChannelRequest', () => {
+    it('should create a new ChannelRequest', () => {
+        const channelEngine = (0, channelResponse_test_1.createChannelEngine)();
+        const event = (0, channelResponse_test_1.createChannelEvent)();
+        const channelRequest = new eventRequest_1.EventRequest(event, channelEngine);
+        expect(channelRequest).toBeDefined();
+    });
+    it('should return the payload', () => {
+        const channelEngine = (0, channelResponse_test_1.createChannelEngine)();
+        const event = (0, channelResponse_test_1.createChannelEvent)();
+        const channelRequest = new eventRequest_1.EventRequest(event, channelEngine);
+        expect(channelRequest.event.payload).toEqual(event.payload);
+    });
+    it('should return the user', () => {
+        const channelEngine = (0, channelResponse_test_1.createChannelEngine)();
+        const event = (0, channelResponse_test_1.createChannelEvent)();
+        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));
+    });
+});