@eleven-am/pondsocket 0.1.49 → 0.1.51

package/server/channel/channelEngine.test.js

@@ -1,377 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createParentEngine = void 0;
-const channelEngine_1 = require("./channelEngine");
-const enums_1 = require("../../enums");
-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: enums_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: enums_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(enums_1.SystemSender.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(enums_1.SystemSender.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/server/channel/channelRequest.test.js

@@ -1,29 +0,0 @@
-"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));
-    });
-});

package/server/channel/channelResponse.test.js

@@ -1,164 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createChannelEvent = exports.createChannelEngine = void 0;
-const channelEngine_1 = require("./channelEngine");
-const channelEngine_test_1 = require("./channelEngine.test");
-const eventResponse_1 = require("./eventResponse");
-const enums_1 = require("../../enums");
-const createChannelEngine = () => {
-    const parentEngine = (0, channelEngine_test_1.createParentEngine)();
-    return new channelEngine_1.ChannelEngine('test', parentEngine);
-};
-exports.createChannelEngine = createChannelEngine;
-const createChannelEvent = () => {
-    const responseEvent = {
-        event: 'event',
-        payload: {
-            payload: 'payload',
-        },
-        sender: 'sender',
-        action: channelEngine_1.ServerActions.BROADCAST,
-        recipients: ['recipient'],
-    };
-    return responseEvent;
-};
-exports.createChannelEvent = createChannelEvent;
-const createChannelResponse = () => {
-    const channelEngine = (0, exports.createChannelEngine)();
-    const event = (0, exports.createChannelEvent)();
-    channelEngine.addUser(event.sender, { assign: 'assign' }, () => { });
-    channelEngine.addUser(event.recipients[0], { 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 return the responseSent', () => {
-        const { response } = createChannelResponse();
-        expect(response.responseSent).toEqual(false);
-    });
-    it('should accept the request', () => {
-        const { response } = createChannelResponse();
-        response.accept();
-        expect(response.responseSent).toEqual(true);
-    });
-    it('should reject the request', () => {
-        const { response, channelEngine, event } = createChannelResponse();
-        jest.spyOn(channelEngine, 'sendMessage');
-        response.reject();
-        expect(response.responseSent).toEqual(true);
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith(enums_1.SystemSender.CHANNEL, [event.sender], channelEngine_1.ServerActions.ERROR, enums_1.ErrorTypes.UNAUTHORIZED_BROADCAST, { message: 'Unauthorized request',
-            code: 403 });
-    });
-    it('should send a direct message', () => {
-        const { response, channelEngine, event } = createChannelResponse();
-        jest.spyOn(channelEngine, 'sendMessage');
-        response.send('event', { payload: 'payload' });
-        expect(response.responseSent).toEqual(true);
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith(enums_1.SystemSender.CHANNEL, [event.sender], channelEngine_1.ServerActions.SYSTEM, 'event', { payload: 'payload' });
-    });
-    it('should broadcast a message', () => {
-        const { response, channelEngine } = createChannelResponse();
-        jest.spyOn(channelEngine, 'sendMessage');
-        response.broadcast('event', { payload: 'payload' });
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith('sender', 'all_users', channelEngine_1.ServerActions.BROADCAST, 'event', { payload: 'payload' });
-    });
-    it('should broadcastFromUser a message', () => {
-        const { response, channelEngine } = createChannelResponse();
-        jest.spyOn(channelEngine, 'sendMessage');
-        response.broadcastFromUser('event', { payload: 'payload' });
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith('sender', 'all_except_sender', channelEngine_1.ServerActions.BROADCAST, 'event', { payload: 'payload' });
-    });
-    it('should sendToUsers a message', () => {
-        const { response, channelEngine } = createChannelResponse();
-        jest.spyOn(channelEngine, 'sendMessage');
-        response.sendToUsers('event', { payload: 'payload' }, ['recipient']);
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith('sender', ['recipient'], channelEngine_1.ServerActions.BROADCAST, 'event', { payload: 'payload' });
-    });
-    it('should fail to send to non existing users', () => {
-        const { event, response, channelEngine } = createChannelResponse();
-        jest.spyOn(channelEngine, 'sendMessage');
-        event.recipients = ['non_existing_user'];
-        expect(() => response.accept()).toThrowError(new Error('ChannelEngine: Users non_existing_user are not in channel test'));
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith(event.sender, ['non_existing_user'], channelEngine_1.ServerActions.BROADCAST, event.event, event.payload);
-        expect(() => response.sendToUsers('event', { payload: 'payload' }, ['non_existing_user']))
-            .toThrowError(new Error('ChannelEngine: Users non_existing_user are not in channel test'));
-    });
-    it('should track a trackPresence', () => {
-        const { response, channelEngine } = createChannelResponse();
-        jest.spyOn(channelEngine, 'trackPresence');
-        response.trackPresence({ status: 'online' });
-        expect(channelEngine.trackPresence).toHaveBeenCalledWith('sender', { status: 'online' });
-    });
-    it('should untrack a trackPresence', () => {
-        const { response, channelEngine } = createChannelResponse();
-        jest.spyOn(channelEngine, 'unTrackPresence');
-        response.unTrackPresence();
-        expect(channelEngine.unTrackPresence).toHaveBeenCalledWith('sender');
-    });
-    it('should broadcast an error if untrackPresence is called twice', () => {
-        const { response, channelEngine } = createChannelResponse();
-        jest.spyOn(channelEngine, 'sendMessage');
-        // because by default the user is not tracked and the presence engine only exists after a first trackPresence
-        // we need to call trackPresence first
-        response.trackPresence({ status: 'online' });
-        response.unTrackPresence();
-        response.unTrackPresence();
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith(enums_1.SystemSender.CHANNEL, ['sender'], channelEngine_1.ServerActions.ERROR, enums_1.ErrorTypes.PRESENCE_LEAVE_FAILED, {
-            message: 'PresenceEngine: Presence with key sender does not exist',
-            code: 500,
-        });
-    });
-    it('should updatePresence', () => {
-        const { response, channelEngine } = createChannelResponse();
-        jest.spyOn(channelEngine, 'updatePresence');
-        response.trackPresence({ status: 'online' });
-        response.updatePresence({ status: 'updated' });
-        expect(channelEngine.updatePresence).toHaveBeenCalledWith('sender', { status: 'updated' });
-    });
-    it('should update a users assign data', () => {
-        const { response, channelEngine } = createChannelResponse();
-        jest.spyOn(channelEngine, 'updateAssigns');
-        response.accept({ 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');
-        expect(response.responseSent).toEqual(true);
-    });
-    it('should destroy the channel', () => {
-        const { response, channelEngine } = createChannelResponse();
-        jest.spyOn(channelEngine, 'destroy');
-        response.closeChannel('recipient');
-        expect(channelEngine.destroy).toHaveBeenCalledWith('recipient');
-        expect(response.responseSent).toEqual(true);
-    });
-    it('should set hasResponseSent to true when calling send, accept, reject, end', () => {
-        const { response } = createChannelResponse();
-        expect(response.responseSent).toEqual(false);
-        response.send('event', { payload: 'payload' });
-        expect(response.responseSent).toEqual(true);
-        const { response: response2 } = createChannelResponse();
-        expect(response2.responseSent).toEqual(false);
-        response2.accept();
-        expect(response2.responseSent).toEqual(true);
-        const { response: response3 } = createChannelResponse();
-        expect(response3.responseSent).toEqual(false);
-        response3.reject();
-        expect(response3.responseSent).toEqual(true);
-        const { response: response4 } = createChannelResponse();
-        expect(response4.responseSent).toEqual(false);
-        response4.end();
-        expect(response4.responseSent).toEqual(true);
-    });
-});