@eleven-am/pondsocket 0.1.125 → 0.1.127

package/channel/eventResponse.test.js

@@ -0,0 +1,197 @@
+"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 = (0, channel_test_1.createParentEngine)();
+    return new channel_1.ChannelEngine('test', parentEngine);
+};
+exports.createChannelEngine = createChannelEngine;
+const createChannelEvent = (name) => {
+    const responseEvent = {
+        event: 'event',
+        payload: {
+            payload: 'payload',
+        },
+        sender: 'sender',
+        action: pondsocket_common_1.ServerActions.BROADCAST,
+        recipients: ['recipient'],
+        channelName: name,
+        requestId: 'requestId',
+    };
+    return responseEvent;
+};
+exports.createChannelEvent = createChannelEvent;
+const createChannelResponse = () => {
+    const channelEngine = (0, exports.createChannelEngine)();
+    const event = (0, exports.createChannelEvent)(channelEngine.name);
+    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 accept the request', () => {
+        const { response, channelEngine } = createChannelResponse();
+        jest.spyOn(channelEngine, 'sendMessage');
+        response.accept();
+        expect(channelEngine.sendMessage).toHaveBeenCalledWith('requestId', 'sender', ['recipient'], pondsocket_common_1.ServerActions.BROADCAST, 'event', { payload: 'payload' });
+    });
+    it('should reject the request', () => {
+        const { response, channelEngine, event } = createChannelResponse();
+        jest.spyOn(channelEngine, 'sendMessage');
+        response.reject();
+        expect(channelEngine.sendMessage).toHaveBeenCalledWith('requestId', pondsocket_common_1.SystemSender.CHANNEL, [event.sender], pondsocket_common_1.ServerActions.ERROR, pondsocket_common_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(channelEngine.sendMessage).toHaveBeenCalledWith('requestId', pondsocket_common_1.SystemSender.CHANNEL, [event.sender], pondsocket_common_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('requestId', 'sender', pondsocket_common_1.ChannelReceiver.ALL_USERS, pondsocket_common_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('requestId', 'sender', pondsocket_common_1.ChannelReceiver.ALL_EXCEPT_SENDER, pondsocket_common_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('requestId', 'sender', ['recipient'], pondsocket_common_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()).toThrow('ChannelEngine: Invalid recipients non_existing_user some users do not exist in channel test');
+        expect(channelEngine.sendMessage).toHaveBeenCalledWith('requestId', event.sender, ['non_existing_user'], pondsocket_common_1.ServerActions.BROADCAST, event.event, event.payload);
+        expect(() => response.sendToUsers('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.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');
+    });
+    it('should destroy the channel', () => {
+        const { response, channelEngine } = createChannelResponse();
+        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.accept();
+        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.accept();
+        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();
+        response.accept();
+        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.accept();
+        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.accept();
+        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.unTrackPresence();
+        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.unTrackPresence('non_existent_user'))
+            .toThrow('PresenceEngine: Presence with key non_existent_user does not exist');
+    });
+    it('should throw an error if accept, reject / send is called more than once', () => {
+        const { response, channelEngine } = createChannelResponse();
+        jest.spyOn(channelEngine, 'sendMessage');
+        expect(channelEngine.sendMessage).not.toHaveBeenCalled();
+        response.accept();
+        expect(channelEngine.sendMessage).toHaveBeenCalledWith('requestId', 'sender', ['recipient'], pondsocket_common_1.ServerActions.BROADCAST, 'event', { payload: 'payload' });
+        expect(() => response.accept()).toThrow('Event response has already been executed');
+        expect(() => response.reject()).toThrow('Event response has already been executed');
+        expect(() => response.send('event', { payload: 'payload' })).toThrow('Event response has already been executed');
+    });
+});

package/endpoint/endpoint.js

@@ -10,16 +10,18 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _Endpoint_instances, _Endpoint_middleware, _Endpoint_channels, _Endpoint_sockets, _Endpoint_sendMessage, _Endpoint_joinChannel, _Endpoint_execute, _Endpoint_handleMessage, _Endpoint_readMessage, _Endpoint_isObjectEmpty;
+var _Endpoint_instances, _Endpoint_middleware, _Endpoint_channels, _Endpoint_sockets, _Endpoint_sendMessage, _Endpoint_joinChannel, _Endpoint_execute, _Endpoint_handleMessage, _Endpoint_readMessage;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Endpoint = void 0;
+const pondsocket_common_1 = require("@eleven-am/pondsocket-common");
+const zod_1 = require("zod");
 const middleware_1 = require("../abstracts/middleware");
-const enums_1 = require("../enums");
 const pondError_1 = require("../errors/pondError");
 const joinRequest_1 = require("../lobby/joinRequest");
 const joinResponse_1 = require("../lobby/joinResponse");
 const lobby_1 = require("../lobby/lobby");
 const matcher_1 = require("../matcher/matcher");
+const schema_1 = require("../schema");
 class Endpoint {
     constructor() {
         _Endpoint_instances.add(this);
@@ -83,8 +85,9 @@ class Endpoint {
             const message = {
                 event,
                 payload,
-                action: enums_1.ServerActions.BROADCAST,
-                channelName: enums_1.SystemSender.ENDPOINT,
+                requestId: (0, pondsocket_common_1.uuid)(),
+                action: pondsocket_common_1.ServerActions.BROADCAST,
+                channelName: pondsocket_common_1.SystemSender.ENDPOINT,
             };
             __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_sendMessage).call(this, socket, message);
         });
@@ -125,8 +128,8 @@ class Endpoint {
 exports.Endpoint = Endpoint;
 _Endpoint_middleware = new WeakMap(), _Endpoint_channels = new WeakMap(), _Endpoint_sockets = new WeakMap(), _Endpoint_instances = new WeakSet(), _Endpoint_sendMessage = function _Endpoint_sendMessage(socket, message) {
     socket.send(JSON.stringify(message));
-}, _Endpoint_joinChannel = function _Endpoint_joinChannel(channel, socket, joinParams) {
-    const cache = Object.assign(Object.assign({}, socket), { channelName: channel });
+}, _Endpoint_joinChannel = function _Endpoint_joinChannel(channel, socket, joinParams, requestId) {
+    const cache = Object.assign(Object.assign({}, socket), { requestId, channelName: channel });
     __classPrivateFieldGet(this, _Endpoint_middleware, "f").run(cache, joinParams, () => {
         throw new pondError_1.EndpointError(`GatewayEngine: Channel ${channel} does not exist`, 404);
     });
@@ -141,15 +144,15 @@ _Endpoint_middleware = new WeakMap(), _Endpoint_channels = new WeakMap(), _Endpo
     throw new Error(`GatewayEngine: Channel ${channel} does not exist`);
 }, _Endpoint_handleMessage = function _Endpoint_handleMessage(cache, message) {
     switch (message.action) {
-        case enums_1.ClientActions.JOIN_CHANNEL:
-            __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_joinChannel).call(this, message.channelName, cache, message.payload);
+        case pondsocket_common_1.ClientActions.JOIN_CHANNEL:
+            __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_joinChannel).call(this, message.channelName, cache, message.payload, message.requestId);
             break;
-        case enums_1.ClientActions.LEAVE_CHANNEL:
+        case pondsocket_common_1.ClientActions.LEAVE_CHANNEL:
             __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_execute).call(this, message.channelName, (channel) => {
                 channel.removeUser(cache.clientId);
             });
             break;
-        case enums_1.ClientActions.BROADCAST:
+        case pondsocket_common_1.ClientActions.BROADCAST:
             __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_execute).call(this, message.channelName, (channel) => {
                 channel.broadcastMessage(cache.clientId, message);
             });
@@ -159,49 +162,37 @@ _Endpoint_middleware = new WeakMap(), _Endpoint_channels = new WeakMap(), _Endpo
     }
 }, _Endpoint_readMessage = function _Endpoint_readMessage(cache, message) {
     const errorMessage = {
-        event: enums_1.ErrorTypes.INVALID_MESSAGE,
-        action: enums_1.ServerActions.ERROR,
-        channelName: enums_1.SystemSender.ENDPOINT,
+        event: pondsocket_common_1.ErrorTypes.INVALID_MESSAGE,
+        action: pondsocket_common_1.ServerActions.ERROR,
+        channelName: pondsocket_common_1.SystemSender.ENDPOINT,
+        requestId: (0, pondsocket_common_1.uuid)(),
         payload: {},
     };
     try {
         const data = JSON.parse(message);
-        if (!data.action) {
-            errorMessage.payload = {
-                message: 'No action provided',
-            };
-        }
-        else if (!data.channelName) {
-            errorMessage.payload = {
-                message: 'No channel name provided',
-            };
-        }
-        else if (!data.payload) {
+        const result = schema_1.clientMessageSchema.parse(data);
+        __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_handleMessage).call(this, cache, result);
+    }
+    catch (e) {
+        if (e instanceof zod_1.ZodError) {
             errorMessage.payload = {
-                message: 'No payload provided',
+                message: e.message,
+                code: 400,
             };
         }
-        if (!__classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_isObjectEmpty).call(this, errorMessage.payload)) {
-            __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_sendMessage).call(this, cache.socket, errorMessage);
-        }
-        else {
-            __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_handleMessage).call(this, cache, data);
-        }
-    }
-    catch (e) {
-        if (e instanceof SyntaxError) {
+        else if (e instanceof SyntaxError) {
             errorMessage.payload = {
                 message: 'Invalid JSON',
             };
         }
         else if (e instanceof Error) {
-            errorMessage.event = enums_1.ErrorTypes.INTERNAL_SERVER_ERROR;
+            errorMessage.event = pondsocket_common_1.ErrorTypes.INTERNAL_SERVER_ERROR;
             errorMessage.payload = {
                 message: e.message,
             };
         }
         else if (e instanceof pondError_1.PresenceError) {
-            errorMessage.event = enums_1.ErrorTypes.PRESENCE_ERROR;
+            errorMessage.event = pondsocket_common_1.ErrorTypes.PRESENCE_ERROR;
             errorMessage.channelName = e.channel;
             errorMessage.payload = {
                 message: e.message,
@@ -210,7 +201,7 @@ _Endpoint_middleware = new WeakMap(), _Endpoint_channels = new WeakMap(), _Endpo
             };
         }
         else if (e instanceof pondError_1.ChannelError) {
-            errorMessage.event = enums_1.ErrorTypes.CHANNEL_ERROR;
+            errorMessage.event = pondsocket_common_1.ErrorTypes.CHANNEL_ERROR;
             errorMessage.channelName = e.channel;
             errorMessage.payload = {
                 message: e.message,
@@ -218,14 +209,17 @@ _Endpoint_middleware = new WeakMap(), _Endpoint_channels = new WeakMap(), _Endpo
             };
         }
         else if (e instanceof pondError_1.EndpointError) {
-            errorMessage.event = enums_1.ErrorTypes.ENDPOINT_ERROR;
+            errorMessage.event = pondsocket_common_1.ErrorTypes.ENDPOINT_ERROR;
             errorMessage.payload = {
                 message: e.message,
                 code: e.code,
             };
         }
+        else {
+            errorMessage.payload = {
+                message: 'Unknown error',
+            };
+        }
         __classPrivateFieldGet(this, _Endpoint_instances, "m", _Endpoint_sendMessage).call(this, cache.socket, errorMessage);
     }
-}, _Endpoint_isObjectEmpty = function _Endpoint_isObjectEmpty(obj) {
-    return Object.keys(obj).length === 0;
 };

package/endpoint/endpoint.test.js

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