@eleven-am/pondsocket 0.1.8 → 0.1.9

package/pondSocket/pondResponse.js

@@ -1,22 +1,46 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EndpointResponse = exports.PondChannelResponse = exports.ChannelResponse = exports.PondResponse = void 0;
-const enums_1 = require("./enums");
-class PondResponse {
-}
-exports.PondResponse = PondResponse;
-class ChannelResponse extends PondResponse {
-    constructor(clientId, channel, resolver) {
-        super();
-        this._clientId = clientId;
-        this._channel = channel;
-        this._resolver = resolver;
-        this._hasExecuted = false;
+var enums_1 = require("./enums");
+var PondResponse = /** @class */ (function () {
+    function PondResponse() {
     }
-    get hasExecuted() {
-        return this._hasExecuted;
+    return PondResponse;
+}());
+exports.PondResponse = PondResponse;
+var ChannelResponse = /** @class */ (function (_super) {
+    __extends(ChannelResponse, _super);
+    function ChannelResponse(clientId, channel, resolver) {
+        var _this = _super.call(this) || this;
+        _this._clientId = clientId;
+        _this._channel = channel;
+        _this._resolver = resolver;
+        _this._hasExecuted = false;
+        return _this;
     }
-    accept(assigns) {
+    Object.defineProperty(ChannelResponse.prototype, "hasExecuted", {
+        get: function () {
+            return this._hasExecuted;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    ChannelResponse.prototype.accept = function (assigns) {
         if (this._hasExecuted)
             throw new Error('Response has already been sent');
         this._hasExecuted = true;
@@ -27,8 +51,8 @@ class ChannelResponse extends PondResponse {
             this._channel.data = assigns.channelData || {};
         }
         this._resolver(false);
-    }
-    reject(message, errorCode) {
+    };
+    ChannelResponse.prototype.reject = function (message, errorCode) {
         if (this._hasExecuted)
             throw new Error('Response has already been sent');
         this._hasExecuted = true;
@@ -38,8 +62,8 @@ class ChannelResponse extends PondResponse {
             throw new Error('Cannot reject a message sent by the server');
         this._channel.respondToClient('error', { message: message, code: errorCode }, this._clientId, enums_1.ServerActions.ERROR);
         this._resolver(true);
-    }
-    send(event, payload, assigns) {
+    };
+    ChannelResponse.prototype.send = function (event, payload, assigns) {
         if (this._hasExecuted)
             throw new Error('Response has already been sent');
         this._hasExecuted = true;
@@ -51,31 +75,38 @@ class ChannelResponse extends PondResponse {
         }
         this._channel.respondToClient(event, payload, this._clientId);
         this._resolver(false);
-    }
-}
+    };
+    return ChannelResponse;
+}(PondResponse));
 exports.ChannelResponse = ChannelResponse;
-class PondChannelResponse extends PondResponse {
-    constructor(user, handler) {
-        super();
-        this._handler = handler;
-        this._user = user;
-        this._executed = false;
-    }
-    get isResolved() {
-        return this._executed;
+var PondChannelResponse = /** @class */ (function (_super) {
+    __extends(PondChannelResponse, _super);
+    function PondChannelResponse(user, handler) {
+        var _this = _super.call(this) || this;
+        _this._handler = handler;
+        _this._user = user;
+        _this._executed = false;
+        return _this;
     }
-    accept(assigns) {
+    Object.defineProperty(PondChannelResponse.prototype, "isResolved", {
+        get: function () {
+            return this._executed;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    PondChannelResponse.prototype.accept = function (assigns) {
         if (this._executed)
             throw new Error('Response has already been sent');
         this._executed = true;
-        const newAssigns = this._mergeAssigns(assigns);
+        var newAssigns = this._mergeAssigns(assigns);
         this._handler(newAssigns);
-    }
-    reject(message, errorCode) {
+    };
+    PondChannelResponse.prototype.reject = function (message, errorCode) {
         if (this._executed)
             throw new Error('Response has already been sent');
         this._executed = true;
-        const newMessage = {
+        var newMessage = {
             action: enums_1.ServerActions.ERROR,
             event: "JOIN_REQUEST_ERROR",
             channelName: enums_1.PondSenders.POND_CHANNEL,
@@ -85,36 +116,40 @@ class PondChannelResponse extends PondResponse {
             }
         };
         this._user.socket.send(JSON.stringify(newMessage));
-    }
-    send(event, payload, assigns) {
+    };
+    PondChannelResponse.prototype.send = function (event, payload, assigns) {
         if (this._executed)
             throw new Error('Response has already been sent');
         this._executed = true;
-        const newAssigns = this._mergeAssigns(assigns);
+        var newAssigns = this._mergeAssigns(assigns);
         this._handler(newAssigns, { event: event, payload: payload });
-    }
-    _mergeAssigns(assigns) {
+    };
+    PondChannelResponse.prototype._mergeAssigns = function (assigns) {
         return {
             presence: (assigns === null || assigns === void 0 ? void 0 : assigns.presence) || {},
             channelData: (assigns === null || assigns === void 0 ? void 0 : assigns.channelData) || {},
             assigns: Object.assign({}, this._user.assigns, (assigns === null || assigns === void 0 ? void 0 : assigns.assigns) || {}),
         };
-    }
-}
+    };
+    return PondChannelResponse;
+}(PondResponse));
 exports.PondChannelResponse = PondChannelResponse;
-class EndpointResponse extends PondResponse {
-    constructor(handler) {
-        super();
-        this._handler = handler;
+var EndpointResponse = /** @class */ (function (_super) {
+    __extends(EndpointResponse, _super);
+    function EndpointResponse(handler) {
+        var _this = _super.call(this) || this;
+        _this._handler = handler;
+        return _this;
     }
-    accept(assigns) {
+    EndpointResponse.prototype.accept = function (assigns) {
         this._handler((assigns === null || assigns === void 0 ? void 0 : assigns.assigns) || {}, {});
-    }
-    reject(message, errorCode) {
+    };
+    EndpointResponse.prototype.reject = function (message, errorCode) {
         this._handler({}, { error: { message: message || 'Message rejected', code: errorCode || 403 } });
-    }
-    send(event, payload, assigns) {
+    };
+    EndpointResponse.prototype.send = function (event, payload, assigns) {
         this._handler((assigns === null || assigns === void 0 ? void 0 : assigns.assigns) || {}, { message: { event: event, payload: payload } });
-    }
-}
+    };
+    return EndpointResponse;
+}(PondResponse));
 exports.EndpointResponse = EndpointResponse;

package/pondSocket/pondSocket.js

@@ -1,34 +1,51 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PondSocket = void 0;
-const http_1 = require("http");
-const ws_1 = require("ws");
-const pondBase_1 = require("../pondBase");
-const endpoint_1 = require("./endpoint");
-const socketMiddleWare_1 = require("./socketMiddleWare");
-class PondSocket extends pondBase_1.BaseClass {
-    constructor(server, socketServer) {
-        super();
-        this._server = server || new http_1.Server();
-        this._socketServer = socketServer || new ws_1.WebSocketServer({ noServer: true });
-        this._socketChain = new socketMiddleWare_1.SocketMiddleWare(this._server);
-        this._init();
+var http_1 = require("http");
+var ws_1 = require("ws");
+var pondBase_1 = require("../pondBase");
+var endpoint_1 = require("./endpoint");
+var socketMiddleWare_1 = require("./socketMiddleWare");
+var PondSocket = /** @class */ (function (_super) {
+    __extends(PondSocket, _super);
+    function PondSocket(server, socketServer) {
+        var _this = _super.call(this) || this;
+        _this._server = server || new http_1.Server();
+        _this._socketServer = socketServer || new ws_1.WebSocketServer({ noServer: true });
+        _this._socketChain = new socketMiddleWare_1.SocketMiddleWare(_this._server);
+        _this._init();
+        return _this;
     }
     /**
      * @desc Specifies the port to listen on
      * @param port - the port to listen on
      * @param callback - the callback to call when the server is listening
      */
-    listen(port, callback) {
+    PondSocket.prototype.listen = function (port, callback) {
         return this._server.listen(port, callback);
-    }
+    };
     /**
      * @desc adds a middleware to the server
      * @param middleware - the middleware to add
      */
-    useOnUpgrade(middleware) {
+    PondSocket.prototype.useOnUpgrade = function (middleware) {
         this._socketChain.use(middleware);
-    }
+    };
     /**
      * @desc Accepts a new socket upgrade request on the provided endpoint using the handler function to authenticate the socket
      * @param path - the pattern to accept || can also be a regex
@@ -47,48 +64,51 @@ class PondSocket extends pondBase_1.BaseClass {
      *    });
      * })
      */
-    createEndpoint(path, handler) {
-        const endpoint = new endpoint_1.Endpoint(this._socketServer, handler);
-        this._socketChain.use((req, socket, head, next) => {
-            const address = req.url || "";
-            const dataEndpoint = this.generateEventRequest(path, address);
+    PondSocket.prototype.createEndpoint = function (path, handler) {
+        var _this = this;
+        var endpoint = new endpoint_1.Endpoint(this._socketServer, handler);
+        this._socketChain.use(function (req, socket, head, next) {
+            var address = req.url || "";
+            var dataEndpoint = _this.generateEventRequest(path, address);
             if (!dataEndpoint)
                 return next();
             endpoint.authoriseConnection(req, socket, head, dataEndpoint);
         });
         return endpoint;
-    }
+    };
     /**
      * @desc Makes sure that every client is still connected to the pond
      * @param server - WebSocket server
      */
-    _pingClients(server) {
-        server.on("connection", (ws) => {
+    PondSocket.prototype._pingClients = function (server) {
+        server.on("connection", function (ws) {
             ws.isAlive = true;
-            ws.on("pong", () => {
+            ws.on("pong", function () {
                 ws.isAlive = true;
             });
         });
-        const interval = setInterval(() => {
-            server.clients.forEach((ws) => {
+        var interval = setInterval(function () {
+            server.clients.forEach(function (ws) {
                 if (ws.isAlive === false)
                     return ws.terminate();
                 ws.isAlive = false;
                 ws.ping();
             });
         }, 30 * 1000);
-        server.on("close", () => clearInterval(interval));
-    }
+        server.on("close", function () { return clearInterval(interval); });
+    };
     /**
      * @desc Initializes the server
      */
-    _init() {
-        this._server.on("error", (error) => {
+    PondSocket.prototype._init = function () {
+        var _this = this;
+        this._server.on("error", function (error) {
             throw new Error(error.message);
         });
-        this._server.on("listening", () => {
-            this._pingClients(this._socketServer);
+        this._server.on("listening", function () {
+            _this._pingClients(_this._socketServer);
         });
-    }
-}
+    };
+    return PondSocket;
+}(pondBase_1.BaseClass));
 exports.PondSocket = PondSocket;

package/pondSocket/server.test.js

@@ -1,56 +1,92 @@
 "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 __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const endpoint_1 = require("./endpoint");
-const pondSocket_1 = require("./pondSocket");
-const superwstest_1 = __importDefault(require("superwstest"));
-const enums_1 = require("./enums");
-const http_1 = require("http");
-const ws_1 = require("ws");
-describe('server', () => {
-    it('should be defined', () => {
+var endpoint_1 = require("./endpoint");
+var pondSocket_1 = require("./pondSocket");
+var superwstest_1 = __importDefault(require("superwstest"));
+var enums_1 = require("./enums");
+var http_1 = require("http");
+var ws_1 = require("ws");
+describe('server', function () {
+    it('should be defined', function () {
         expect(pondSocket_1.PondSocket).toBeDefined();
     });
-    it('should be instantiable', () => {
+    it('should be instantiable', function () {
         expect(new pondSocket_1.PondSocket()).toBeInstanceOf(pondSocket_1.PondSocket);
     });
-    it('should ba able to create its own server and websocket server if none is provided', () => {
-        const socket = new pondSocket_1.PondSocket();
+    it('should ba able to create its own server and websocket server if none is provided', function () {
+        var socket = new pondSocket_1.PondSocket();
         expect(socket['_server']).toBeDefined();
         expect(socket['_socketServer']).toBeDefined();
     });
-    it('should take a server and websocket server if provided', () => {
-        const server = (0, http_1.createServer)();
-        const socketServer = new ws_1.Server({ noServer: true });
-        const socket = new pondSocket_1.PondSocket(server, socketServer);
+    it('should take a server and websocket server if provided', function () {
+        var server = (0, http_1.createServer)();
+        var socketServer = new ws_1.Server({ noServer: true });
+        var socket = new pondSocket_1.PondSocket(server, socketServer);
         expect(socket['_server']).toBe(server);
         expect(socket['_socketServer']).toBe(socketServer);
     });
-    it('should be able to listen on a port', () => {
-        const socket = new pondSocket_1.PondSocket();
-        expect(socket.listen(3001, () => {
+    it('should be able to listen on a port', function () {
+        var socket = new pondSocket_1.PondSocket();
+        expect(socket.listen(3001, function () {
             console.log('socket');
         })).toBeDefined();
         socket['_server'].close();
     });
-    it('should be able to create an endpoint', () => {
-        const socket = new pondSocket_1.PondSocket();
-        const endpoint = socket.createEndpoint('/api/socket', () => {
+    it('should be able to create an endpoint', function () {
+        var socket = new pondSocket_1.PondSocket();
+        var endpoint = socket.createEndpoint('/api/socket', function () {
             console.log('socket');
         });
         expect(endpoint).toBeInstanceOf(endpoint_1.Endpoint);
         expect(endpoint['_handler']).toEqual(expect.any(Function));
     });
-    it('should be able to create multiple endpoints', () => {
-        const server = (0, http_1.createServer)();
-        const socketServer = new ws_1.Server({ noServer: true });
-        const socket = new pondSocket_1.PondSocket(server, socketServer);
-        const endpoint = socket.createEndpoint('/api/socket', () => {
+    it('should be able to create multiple endpoints', function () {
+        var server = (0, http_1.createServer)();
+        var socketServer = new ws_1.Server({ noServer: true });
+        var socket = new pondSocket_1.PondSocket(server, socketServer);
+        var endpoint = socket.createEndpoint('/api/socket', function () {
             console.log('socket');
         });
-        const endpoint2 = socket.createEndpoint('/api/socket2', () => {
+        var endpoint2 = socket.createEndpoint('/api/socket2', function () {
             console.log('socket2');
         });
         expect(endpoint).toBeInstanceOf(endpoint_1.Endpoint);
@@ -58,15 +94,15 @@ describe('server', () => {
         expect(endpoint2).toBeInstanceOf(endpoint_1.Endpoint);
         expect(endpoint2['_handler']).toEqual(expect.any(Function));
     });
-    it('should be able to reject a socket', () => {
-        const server = (0, http_1.createServer)();
-        const socketServer = new ws_1.Server({ noServer: true });
-        const socket = new pondSocket_1.PondSocket(server, socketServer);
-        const socketClient = {
+    it('should be able to reject a socket', function () {
+        var server = (0, http_1.createServer)();
+        var socketServer = new ws_1.Server({ noServer: true });
+        var socket = new pondSocket_1.PondSocket(server, socketServer);
+        var socketClient = {
             write: jest.fn(),
             destroy: jest.fn(),
         };
-        socket.listen(3001, () => {
+        socket.listen(3001, function () {
             console.log('server listening');
         });
         server.emit('upgrade', {}, socketClient);
@@ -75,62 +111,89 @@ describe('server', () => {
         expect(socketClient.write).toHaveBeenCalled();
         expect(socketClient.destroy).toHaveBeenCalled();
     });
-    it('should be able to accept a socket if a handler is provided', async () => {
-        const socket = new pondSocket_1.PondSocket();
-        const server = socket.listen(3001, () => {
-            console.log('server listening');
+    it('should be able to accept a socket if a handler is provided', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var socket, server;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    socket = new pondSocket_1.PondSocket();
+                    server = socket.listen(3001, function () {
+                        console.log('server listening');
+                    });
+                    expect(server).toBeDefined();
+                    socket.createEndpoint('/api/hello', function () {
+                        console.log('server listening');
+                    });
+                    socket.createEndpoint('/api/:path', function (req, res) {
+                        expect(req.params.path).toBe('socket');
+                        res.accept();
+                    });
+                    return [4 /*yield*/, (0, superwstest_1.default)(server)
+                            .ws('/api/socket')
+                            .expectUpgrade(function (res) { return expect(res.statusCode).toBe(101); })
+                            .close()
+                            .expectClosed()];
+                case 1:
+                    _a.sent();
+                    server.close();
+                    return [2 /*return*/];
+            }
         });
-        expect(server).toBeDefined();
-        socket.createEndpoint('/api/hello', () => {
-            console.log('server listening');
+    }); });
+    it('should be able to reject a socket if the handler rejects', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var socket, server;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    socket = new pondSocket_1.PondSocket();
+                    server = socket.listen(3001, function () {
+                        console.log('server listening');
+                    });
+                    expect(server).toBeDefined();
+                    socket.createEndpoint('/api/:path', function (req, res) {
+                        expect(req.params.path).toBe('socket');
+                        res.reject();
+                    });
+                    return [4 /*yield*/, (0, superwstest_1.default)(server)
+                            .ws('/api/socket')
+                            .expectConnectionError()];
+                case 1:
+                    _a.sent();
+                    server.close();
+                    return [2 /*return*/];
+            }
         });
-        socket.createEndpoint('/api/:path', (req, res) => {
-            expect(req.params.path).toBe('socket');
-            res.accept();
-        });
-        await (0, superwstest_1.default)(server)
-            .ws('/api/socket')
-            .expectUpgrade(res => expect(res.statusCode).toBe(101))
-            .close()
-            .expectClosed();
-        server.close();
-    });
-    it('should be able to reject a socket if the handler rejects', async () => {
-        const socket = new pondSocket_1.PondSocket();
-        const server = socket.listen(3001, () => {
-            console.log('server listening');
+    }); });
+    it('should be able to send a message after connection', function () { return __awaiter(void 0, void 0, void 0, function () {
+        var socket, server;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    socket = new pondSocket_1.PondSocket();
+                    server = socket.listen(3001, function () {
+                        console.log('server listening');
+                    });
+                    expect(server).toBeDefined();
+                    socket.createEndpoint('/api/:path', function (req, res) {
+                        expect(req.params.path).toBe('socket');
+                        res.send('testEvent', { test: 'test' });
+                    });
+                    return [4 /*yield*/, (0, superwstest_1.default)(server)
+                            .ws('/api/socket')
+                            .expectUpgrade(function (res) { return expect(res.statusCode).toBe(101); })
+                            .expectJson({
+                            action: enums_1.ServerActions.MESSAGE,
+                            event: 'testEvent',
+                            channelName: 'SERVER',
+                            payload: { test: 'test' },
+                        })
+                            .close()
+                            .expectClosed()];
+                case 1:
+                    _a.sent();
+                    server.close();
+                    return [2 /*return*/];
+            }
         });
-        expect(server).toBeDefined();
-        socket.createEndpoint('/api/:path', (req, res) => {
-            expect(req.params.path).toBe('socket');
-            res.reject();
-        });
-        await (0, superwstest_1.default)(server)
-            .ws('/api/socket')
-            .expectConnectionError();
-        server.close();
-    });
-    it('should be able to send a message after connection', async () => {
-        const socket = new pondSocket_1.PondSocket();
-        const server = socket.listen(3001, () => {
-            console.log('server listening');
-        });
-        expect(server).toBeDefined();
-        socket.createEndpoint('/api/:path', (req, res) => {
-            expect(req.params.path).toBe('socket');
-            res.send('testEvent', { test: 'test' });
-        });
-        await (0, superwstest_1.default)(server)
-            .ws('/api/socket')
-            .expectUpgrade(res => expect(res.statusCode).toBe(101))
-            .expectJson({
-            action: enums_1.ServerActions.MESSAGE,
-            event: 'testEvent',
-            channelName: 'SERVER',
-            payload: { test: 'test' },
-        })
-            .close()
-            .expectClosed();
-        server.close();
-    });
+    }); });
 });