@eleven-am/pondsocket 0.1.43 → 0.1.46

package/enums.d.ts

@@ -0,0 +1,48 @@
+export enum PresenceEventTypes {
+    JOIN = 'JOIN',
+    LEAVE = 'LEAVE',
+    UPDATE = 'UPDATE'
+}
+
+export enum ServerActions {
+    PRESENCE = 'PRESENCE',
+    SYSTEM = 'SYSTEM',
+    BROADCAST = 'BROADCAST',
+    ERROR = 'ERROR',
+}
+
+export enum ClientActions {
+    JOIN_CHANNEL = 'JOIN_CHANNEL',
+    LEAVE_CHANNEL = 'LEAVE_CHANNEL',
+    BROADCAST = 'BROADCAST',
+}
+
+export enum PondState {
+    CONNECTING = 'CONNECTING',
+    OPEN = 'OPEN',
+    CLOSING = 'CLOSING',
+    CLOSED = 'CLOSED',
+}
+
+export enum ChannelState {
+    IDLE = 'IDLE',
+    JOINING = 'JOINING',
+    JOINED = 'JOINED',
+    STALLED = 'STALLED',
+    CLOSED = 'CLOSED',
+}
+
+export enum ErrorTypes {
+    UNAUTHORIZED_JOIN_REQUEST = 'UNAUTHORIZED_JOIN_REQUEST',
+    UNAUTHORIZED_BROADCAST = 'UNAUTHORIZED_BROADCAST',
+    INVALID_MESSAGE = 'INVALID_MESSAGE',
+    HANDLER_NOT_FOUND = 'HANDLER_NOT_FOUND',
+    PRESENCE_LEAVE_FAILED = 'PRESENCE_LEAVE_FAILED',
+    INTERNAL_SERVER_ERROR = 'INTERNAL_SERVER_ERROR',
+}
+
+export enum SystemSender {
+    SERVER = 'SERVER',
+    ENDPOINT = 'ENDPOINT',
+    CHANNEL = 'CHANNEL',
+}

package/enums.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PondState = exports.ClientActions = exports.ServerActions = exports.PresenceEventTypes = void 0;
+exports.SystemSender = exports.ErrorTypes = exports.ChannelState = exports.PondState = exports.ClientActions = exports.ServerActions = exports.PresenceEventTypes = void 0;
 var PresenceEventTypes;
 (function (PresenceEventTypes) {
     PresenceEventTypes["JOIN"] = "JOIN";
@@ -27,3 +27,26 @@ var PondState;
     PondState["CLOSING"] = "CLOSING";
     PondState["CLOSED"] = "CLOSED";
 })(PondState = exports.PondState || (exports.PondState = {}));
+var ChannelState;
+(function (ChannelState) {
+    ChannelState["IDLE"] = "IDLE";
+    ChannelState["JOINING"] = "JOINING";
+    ChannelState["JOINED"] = "JOINED";
+    ChannelState["STALLED"] = "STALLED";
+    ChannelState["CLOSED"] = "CLOSED";
+})(ChannelState = exports.ChannelState || (exports.ChannelState = {}));
+var ErrorTypes;
+(function (ErrorTypes) {
+    ErrorTypes["UNAUTHORIZED_JOIN_REQUEST"] = "UNAUTHORIZED_JOIN_REQUEST";
+    ErrorTypes["UNAUTHORIZED_BROADCAST"] = "UNAUTHORIZED_BROADCAST";
+    ErrorTypes["INVALID_MESSAGE"] = "INVALID_MESSAGE";
+    ErrorTypes["HANDLER_NOT_FOUND"] = "HANDLER_NOT_FOUND";
+    ErrorTypes["PRESENCE_LEAVE_FAILED"] = "PRESENCE_LEAVE_FAILED";
+    ErrorTypes["INTERNAL_SERVER_ERROR"] = "INTERNAL_SERVER_ERROR";
+})(ErrorTypes = exports.ErrorTypes || (exports.ErrorTypes = {}));
+var SystemSender;
+(function (SystemSender) {
+    SystemSender["SERVER"] = "SERVER";
+    SystemSender["ENDPOINT"] = "ENDPOINT";
+    SystemSender["CHANNEL"] = "CHANNEL";
+})(SystemSender = exports.SystemSender || (exports.SystemSender = {}));

package/node.js

@@ -13,14 +13,14 @@ class PondClient extends client_1.default {
     connect(backoff = 1) {
         const socket = new WebSocket(this._address.toString());
         socket.onopen = () => {
-            this._connectionState.publish(enums_1.PondState.OPEN);
+            this._connectionState.next(enums_1.PondState.OPEN);
         };
         socket.onmessage = (message) => {
             const data = JSON.parse(message.data);
-            this._broadcaster.publish(data);
+            this._broadcaster.next(data);
         };
         socket.onerror = () => {
-            this._connectionState.publish(enums_1.PondState.CLOSED);
+            this._connectionState.next(enums_1.PondState.CLOSED);
             setTimeout(() => {
                 this.connect(backoff * 2);
             }, backoff * 1000);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eleven-am/pondsocket",
-  "version": "0.1.43",
+  "version": "0.1.46",
   "description": "PondSocket is a fast simple socket server",
   "keywords": [
     "socket",
@@ -21,8 +21,8 @@
   },
   "author": "Roy OSSAI",
   "license": "GPL-3.0",
-  "main": "index.js",
-  "types": "index.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Eleven-am/pondSocket.git"

package/server/channel/channelEngine.js

@@ -14,6 +14,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChannelEngine = exports.ServerActions = void 0;
 const eventRequest_1 = require("./eventRequest");
 const eventResponse_1 = require("./eventResponse");
+const enums_1 = require("../../enums");
 const presenceEngine_1 = require("../presence/presenceEngine");
 const subjectUtils_1 = require("../utils/subjectUtils");
 var ServerActions;
@@ -69,12 +70,12 @@ class ChannelEngine {
      * @param reason - The reason for kicking the user
      */
     kickUser(userId, reason) {
-        this.sendMessage('channel', [userId], ServerActions.SYSTEM, 'kicked_out', {
+        this.sendMessage(enums_1.SystemSender.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', {
+        this.sendMessage(enums_1.SystemSender.CHANNEL, 'all_users', ServerActions.SYSTEM, 'kicked', {
             userId,
             reason,
         });
@@ -84,7 +85,7 @@ class ChannelEngine {
      * @param reason - The reason for self-destructing the channel
      */
     destroy(reason) {
-        this.sendMessage('channel', 'all_users', ServerActions.ERROR, 'destroyed', {
+        this.sendMessage(enums_1.SystemSender.CHANNEL, 'all_users', ServerActions.ERROR, 'destroyed', {
             message: 'Channel has been destroyed',
             reason,
         });
@@ -106,7 +107,7 @@ class ChannelEngine {
         }
         this._presenceEngine.trackPresence(userId, presence, (change) => {
             const { type } = change, rest = __rest(change, ["type"]);
-            this.sendMessage('channel', [userId], ServerActions.PRESENCE, type, rest);
+            this.sendMessage(enums_1.SystemSender.CHANNEL, [userId], ServerActions.PRESENCE, type, rest);
         });
     }
     /**
@@ -198,7 +199,7 @@ class ChannelEngine {
      * @private
      */
     sendMessage(sender, recipient, action, event, payload) {
-        if (!this._users.has(sender) && sender !== 'channel') {
+        if (!this._users.has(sender) && sender !== enums_1.SystemSender.CHANNEL) {
             throw new Error(`ChannelEngine: User with id ${sender} does not exist in channel ${this.name}`);
         }
         this._receiver.next({
@@ -228,7 +229,7 @@ class ChannelEngine {
         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', {
+            this.sendMessage(enums_1.SystemSender.CHANNEL, [userId], ServerActions.ERROR, enums_1.ErrorTypes.HANDLER_NOT_FOUND, {
                 message: 'A handler did not respond to the event',
                 code: 404,
             });
@@ -260,7 +261,7 @@ class ChannelEngine {
                 users = allUsers;
                 break;
             case 'all_except_sender':
-                if (sender === 'channel') {
+                if (sender === enums_1.SystemSender.CHANNEL) {
                     throw new Error('ChannelEngine: Cannot send to all users except sender when sender is channel');
                 }
                 users = allUsers.filter((user) => user !== sender);

package/server/channel/channelEngine.test.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createParentEngine = void 0;
 const channelEngine_1 = require("./channelEngine");
-const presenceEngine_1 = require("../presence/presenceEngine");
+const enums_1 = require("../../enums");
 const createParentEngine = () => {
     const parentEngine = {
         destroyChannel: jest.fn(),
@@ -122,7 +122,7 @@ describe('ChannelEngine', () => {
         expect(onMessage).toHaveBeenCalledWith({
             channelName: 'test',
             action: channelEngine_1.ServerActions.PRESENCE,
-            event: presenceEngine_1.PresenceEventTypes.JOIN,
+            event: enums_1.PresenceEventTypes.JOIN,
             payload: {
                 presence: [{ test: 2 }],
                 changed: {
@@ -208,7 +208,7 @@ describe('ChannelEngine', () => {
         });
         expect(onMessage).toHaveBeenCalledWith({
             channelName: 'test',
-            event: presenceEngine_1.PresenceEventTypes.LEAVE,
+            event: enums_1.PresenceEventTypes.LEAVE,
             action: channelEngine_1.ServerActions.PRESENCE,
             payload: {
                 presence: [{ test: 2 }],
@@ -290,7 +290,7 @@ describe('ChannelEngine', () => {
         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 });
+        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',
@@ -334,7 +334,7 @@ describe('ChannelEngine', () => {
         }).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 });
+            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', () => {

package/server/channel/channelResponse.test.js

@@ -4,6 +4,7 @@ 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);
@@ -26,10 +27,13 @@ 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,
+    return {
+        channelEngine,
         event,
-        response };
+        response,
+    };
 };
 describe('ChannelResponse', () => {
     it('should create a new ChannelResponse', () => {
@@ -50,7 +54,7 @@ describe('ChannelResponse', () => {
         jest.spyOn(channelEngine, 'sendMessage');
         response.reject();
         expect(response.responseSent).toEqual(true);
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith('channel', [event.sender], channelEngine_1.ServerActions.ERROR, 'error_channel', { message: 'Unauthorized request',
+        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', () => {
@@ -58,7 +62,7 @@ describe('ChannelResponse', () => {
         jest.spyOn(channelEngine, 'sendMessage');
         response.send('event', { payload: 'payload' });
         expect(response.responseSent).toEqual(true);
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith('channel', [event.sender], channelEngine_1.ServerActions.SYSTEM, 'event', { payload: 'payload' });
+        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();
@@ -75,10 +79,18 @@ describe('ChannelResponse', () => {
     it('should sendToUsers a message', () => {
         const { response, channelEngine } = createChannelResponse();
         jest.spyOn(channelEngine, 'sendMessage');
-        channelEngine.addUser('recipient', { assign: 'assign' }, () => { });
         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');
@@ -99,7 +111,7 @@ describe('ChannelResponse', () => {
         response.trackPresence({ status: 'online' });
         response.unTrackPresence();
         response.unTrackPresence();
-        expect(channelEngine.sendMessage).toHaveBeenCalledWith('channel', ['sender'], channelEngine_1.ServerActions.ERROR, 'error_channel', {
+        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,
         });
@@ -131,4 +143,22 @@ describe('ChannelResponse', () => {
         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);
+    });
 });

package/server/channel/eventResponse.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventResponse = void 0;
 const channelEngine_1 = require("./channelEngine");
+const enums_1 = require("../../enums");
 const abstractResponse_1 = require("../abstracts/abstractResponse");
 class EventResponse extends abstractResponse_1.PondResponse {
     constructor(event, engine) {
@@ -22,7 +23,7 @@ class EventResponse extends abstractResponse_1.PondResponse {
      */
     accept(assigns) {
         this._manageAssigns(assigns);
-        this._engine.sendMessage('channel', [this._event.sender], this._event.action, this._event.event, this._event.payload);
+        this._engine.sendMessage(this._event.sender, this._event.recipients, this._event.action, this._event.event, this._event.payload);
         this._hasExecuted = true;
         return this;
     }
@@ -35,8 +36,10 @@ class EventResponse extends abstractResponse_1.PondResponse {
     reject(message, errorCode, assigns) {
         this._manageAssigns(assigns);
         const text = message || 'Unauthorized request';
-        this._engine.sendMessage('channel', [this._event.sender], channelEngine_1.ServerActions.ERROR, 'error_channel', { message: text,
-            code: errorCode || 403 });
+        this._engine.sendMessage(enums_1.SystemSender.CHANNEL, [this._event.sender], channelEngine_1.ServerActions.ERROR, enums_1.ErrorTypes.UNAUTHORIZED_BROADCAST, {
+            message: text,
+            code: errorCode || 403,
+        });
         this._hasExecuted = true;
         return this;
     }
@@ -47,7 +50,7 @@ class EventResponse extends abstractResponse_1.PondResponse {
      * @param assigns - the data to assign to the client
      */
     send(event, payload, assigns) {
-        this._engine.sendMessage('channel', [this._event.sender], channelEngine_1.ServerActions.SYSTEM, event, payload);
+        this._engine.sendMessage(enums_1.SystemSender.CHANNEL, [this._event.sender], channelEngine_1.ServerActions.SYSTEM, event, payload);
         return this.accept(assigns);
     }
     /**
@@ -106,8 +109,10 @@ class EventResponse extends abstractResponse_1.PondResponse {
             this._engine.unTrackPresence(userId);
         }
         catch (e) {
-            this._engine.sendMessage('channel', [userId], channelEngine_1.ServerActions.ERROR, 'error_channel', { message: e.message,
-                code: 500 });
+            this._engine.sendMessage(enums_1.SystemSender.CHANNEL, [userId], channelEngine_1.ServerActions.ERROR, enums_1.ErrorTypes.PRESENCE_LEAVE_FAILED, {
+                message: e.message,
+                code: 500,
+            });
         }
         return this;
     }

package/server/endpoint/endpoint.js

@@ -1,15 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Endpoint = exports.ClientActions = void 0;
+exports.Endpoint = void 0;
 const connectionResponse_1 = require("./connectionResponse");
+const enums_1 = require("../../enums");
 const channelEngine_1 = require("../channel/channelEngine");
 const matchPattern_1 = require("../utils/matchPattern");
-var ClientActions;
-(function (ClientActions) {
-    ClientActions["JOIN_CHANNEL"] = "JOIN_CHANNEL";
-    ClientActions["LEAVE_CHANNEL"] = "LEAVE_CHANNEL";
-    ClientActions["BROADCAST"] = "BROADCAST";
-})(ClientActions = exports.ClientActions || (exports.ClientActions = {}));
 class Endpoint {
     constructor(server) {
         this._server = server;
@@ -53,7 +48,7 @@ class Endpoint {
                 event,
                 payload,
                 action: channelEngine_1.ServerActions.BROADCAST,
-                channelName: 'SERVER',
+                channelName: enums_1.SystemSender.ENDPOINT,
             };
             this._sendMessage(socket, message);
         });
@@ -99,7 +94,7 @@ class Endpoint {
                 if (data.message) {
                     const newMessage = {
                         event: data.message.event,
-                        channelName: 'SERVER',
+                        channelName: enums_1.SystemSender.ENDPOINT,
                         payload: data.message.payload,
                         action: channelEngine_1.ServerActions.SYSTEM,
                     };
@@ -176,15 +171,15 @@ class Endpoint {
      */
     _handleMessage(cache, message) {
         switch (message.action) {
-            case ClientActions.JOIN_CHANNEL:
+            case enums_1.ClientActions.JOIN_CHANNEL:
                 this._joinChannel(message.channelName, cache, message.payload);
                 break;
-            case ClientActions.LEAVE_CHANNEL:
+            case enums_1.ClientActions.LEAVE_CHANNEL:
                 this._execute(message.channelName, (channel) => {
                     channel.removeUser(cache.clientId);
                 });
                 break;
-            case ClientActions.BROADCAST:
+            case enums_1.ClientActions.BROADCAST:
                 this._execute(message.channelName, (channel) => {
                     channel.broadcastMessage(cache.clientId, message);
                 });
@@ -201,9 +196,9 @@ class Endpoint {
      */
     _readMessage(cache, message) {
         const errorMessage = {
-            event: 'error',
+            event: enums_1.ErrorTypes.INVALID_MESSAGE,
             action: channelEngine_1.ServerActions.ERROR,
-            channelName: 'ENDPOINT',
+            channelName: enums_1.SystemSender.ENDPOINT,
             payload: {},
         };
         try {
@@ -238,6 +233,7 @@ class Endpoint {
                 this._sendMessage(cache.socket, errorMessage);
             }
             else if (e instanceof Error) {
+                errorMessage.event = enums_1.ErrorTypes.INTERNAL_SERVER_ERROR;
                 errorMessage.payload = {
                     message: e.message,
                 };

package/server/endpoint/endpoint.test.js

@@ -13,14 +13,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const superwstest_1 = __importDefault(require("superwstest"));
-const endpoint_1 = require("./endpoint");
 const enums_1 = require("../../enums");
 const pondChannel_1 = require("../pondChannel/pondChannel");
 const pondSocket_1 = require("../server/pondSocket");
 const createPondSocket = () => {
     const mock = jest.fn();
     const socket = new pondSocket_1.PondSocket();
-    const server = socket.listen(3001, mock);
+    // GET RANDOM PORT FROM 6000 - 50000
+    const port = Math.floor(Math.random() * (50000 - 6000 + 1) + 6000);
+    const server = socket.listen(port, mock);
     const createPondChannel = () => new pondChannel_1.PondChannel();
     return { socket,
         server,
@@ -93,7 +94,7 @@ describe('endpoint', () => {
             .expectUpgrade((res) => expect(res.statusCode).toBe(101))
             .expectJson({
             event: 'Hello',
-            channelName: 'SERVER',
+            channelName: enums_1.SystemSender.ENDPOINT,
             action: enums_1.ServerActions.SYSTEM,
             payload: {
                 room: 'socket',
@@ -101,7 +102,7 @@ describe('endpoint', () => {
         })
             .expectJson({
             event: 'TEST',
-            channelName: 'SERVER',
+            channelName: enums_1.SystemSender.ENDPOINT,
             action: enums_1.ServerActions.BROADCAST,
             payload: {
                 message: 'Hello everyone',
@@ -114,7 +115,7 @@ describe('endpoint', () => {
             .expectUpgrade((res) => expect(res.statusCode).toBe(101))
             .expectJson({
             event: 'Hello',
-            channelName: 'SERVER',
+            channelName: enums_1.SystemSender.ENDPOINT,
             action: enums_1.ServerActions.SYSTEM,
             payload: {
                 room: 'secondSocket',
@@ -122,7 +123,7 @@ describe('endpoint', () => {
         })
             .expectJson({
             event: 'TEST',
-            channelName: 'SERVER',
+            channelName: enums_1.SystemSender.ENDPOINT,
             action: enums_1.ServerActions.BROADCAST,
             payload: {
                 message: 'Hello everyone',
@@ -134,7 +135,7 @@ describe('endpoint', () => {
     }));
     it('should be able to accept connections on this handler', () => __awaiter(void 0, void 0, void 0, function* () {
         const message = {
-            action: endpoint_1.ClientActions.JOIN_CHANNEL,
+            action: enums_1.ClientActions.JOIN_CHANNEL,
             channelName: '/test/socket',
             event: 'TEST',
             payload: {},
@@ -196,7 +197,7 @@ describe('endpoint', () => {
         });
         endpoint.addChannel('/test/:room', testPond);
         const message = {
-            action: endpoint_1.ClientActions.JOIN_CHANNEL,
+            action: enums_1.ClientActions.JOIN_CHANNEL,
             channelName: '/test/socket',
             event: 'TEST',
             payload: {},
@@ -212,8 +213,8 @@ describe('endpoint', () => {
             .expectUpgrade((res) => expect(res.statusCode).toBe(101))
             .sendJson(Object.assign(Object.assign({}, message), { channelName: '/socket/socket' }))
             .expectJson({
-            event: 'error',
-            channelName: 'ENDPOINT',
+            event: enums_1.ErrorTypes.INTERNAL_SERVER_ERROR,
+            channelName: enums_1.SystemSender.ENDPOINT,
             action: enums_1.ServerActions.ERROR,
             payload: {
                 message: 'GatewayEngine: Channel /socket/socket does not exist',
@@ -233,7 +234,8 @@ describe('endpoint', () => {
         const channel = createPondChannel();
         channel.onEvent(':room', (req, res) => {
             if (req.event.params.room === 'TEST') {
-                res.accept().broadcast(req.event.event, req.event.payload);
+                res.accept()
+                    .broadcast(req.event.event, req.event.payload);
             }
             else if (req.event.params.room === 'TEST2') {
                 res.reject();
@@ -247,7 +249,7 @@ describe('endpoint', () => {
         });
         endpoint.addChannel('/test/:room', channel);
         const message = {
-            action: endpoint_1.ClientActions.JOIN_CHANNEL,
+            action: enums_1.ClientActions.JOIN_CHANNEL,
             channelName: '/test/socket',
             event: 'TEST',
             payload: {},
@@ -255,33 +257,39 @@ describe('endpoint', () => {
         yield (0, superwstest_1.default)(server)
             .ws('/api/socket')
             .expectUpgrade((res) => expect(res.statusCode).toBe(101))
-            .sendJson(message)
-            .sendJson(Object.assign(Object.assign({}, message), { event: 'TEST2', action: endpoint_1.ClientActions.BROADCAST }))
+            .sendJson(message) // Join the channel
+            .sendJson(Object.assign(Object.assign({}, message), { channelName: '/test/socket', action: enums_1.ClientActions.BROADCAST }))
             .expectJson({
-            event: 'error_channel',
+            payload: {},
+            event: 'TEST',
             channelName: '/test/socket',
-            action: enums_1.ServerActions.ERROR,
-            payload: {
-                message: 'Unauthorized request',
-                code: 403,
-            },
+            action: enums_1.ServerActions.BROADCAST,
         })
-            .sendJson(Object.assign(Object.assign({}, message), { channelName: '/test/socket', action: endpoint_1.ClientActions.BROADCAST }))
             .expectJson({
             payload: {},
             event: 'TEST',
             channelName: '/test/socket',
             action: enums_1.ServerActions.BROADCAST,
         })
-            .sendJson(Object.assign(Object.assign({}, message), { event: 'TEST3', action: endpoint_1.ClientActions.BROADCAST }))
+            .sendJson(Object.assign(Object.assign({}, message), { event: 'TEST2', channelName: '/test/socket', action: enums_1.ClientActions.BROADCAST }))
             .expectJson({
-            event: 'error_channel',
+            action: enums_1.ServerActions.ERROR,
+            event: enums_1.ErrorTypes.UNAUTHORIZED_BROADCAST,
+            payload: {
+                message: 'Unauthorized request',
+                code: 403,
+            },
             channelName: '/test/socket',
+        })
+            .sendJson(Object.assign(Object.assign({}, message), { event: 'TEST3', channelName: '/test/socket', action: enums_1.ClientActions.BROADCAST }))
+            .expectJson({
             action: enums_1.ServerActions.ERROR,
+            event: enums_1.ErrorTypes.UNAUTHORIZED_BROADCAST,
             payload: {
                 message: 'choke on my balls',
                 code: 403,
             },
+            channelName: '/test/socket',
         })
             .close()
             .expectClosed();
@@ -302,7 +310,7 @@ describe('endpoint', () => {
         });
         endpoint.addChannel('/test/:room', channel);
         const message = {
-            action: endpoint_1.ClientActions.JOIN_CHANNEL,
+            action: enums_1.ClientActions.JOIN_CHANNEL,
             channelName: '/test/socket',
             event: 'TEST',
             payload: {},
@@ -343,7 +351,7 @@ describe('endpoint', () => {
         });
         endpoint.addChannel('/test/:room', channel);
         const message = {
-            action: endpoint_1.ClientActions.LEAVE_CHANNEL,
+            action: enums_1.ClientActions.LEAVE_CHANNEL,
             channelName: '/test/socket',
             event: 'TEST',
             payload: {},
@@ -353,7 +361,7 @@ describe('endpoint', () => {
             .expectUpgrade((res) => expect(res.statusCode).toBe(101))
             .sendJson(message)
             .expectJson({
-            event: 'error',
+            event: enums_1.ErrorTypes.INTERNAL_SERVER_ERROR,
             channelName: 'ENDPOINT',
             action: enums_1.ServerActions.ERROR,
             payload: {
@@ -361,7 +369,7 @@ describe('endpoint', () => {
             },
         })
             // now join the channel
-            .sendJson(Object.assign(Object.assign({}, message), { action: endpoint_1.ClientActions.JOIN_CHANNEL }))
+            .sendJson(Object.assign(Object.assign({}, message), { action: enums_1.ClientActions.JOIN_CHANNEL }))
             .expectJson({
             event: 'TEST',
             channelName: '/test/socket',
@@ -396,7 +404,7 @@ describe('endpoint', () => {
             .expectUpgrade((res) => expect(res.statusCode).toBe(101))
             .expectJson({
             event: 'TEST',
-            channelName: 'SERVER',
+            channelName: enums_1.SystemSender.ENDPOINT,
             action: enums_1.ServerActions.SYSTEM,
             payload: {
                 test: 'test',
@@ -408,12 +416,13 @@ describe('endpoint', () => {
             .expectUpgrade((res) => expect(res.statusCode).toBe(101))
             .expectJson({
             event: 'TEST',
-            channelName: 'SERVER',
+            channelName: enums_1.SystemSender.ENDPOINT,
             action: enums_1.ServerActions.SYSTEM,
             payload: {
                 test: 'test',
             },
         })
             .expectClosed();
+        server.close();
     }));
 });