systemlynx 1.5.0 → 1.7.0

package/API.md

@@ -51,25 +51,84 @@ Welcome to the docs! Following is a list of the objects used and created when de
 ---
 
 <details>
-   <summary><b><a href="https://github.com/Odion100/SystemLynx/tasksjs2.0/API.md">ClientModule</a></b></summary>
+   <summary><b><a href="https://github.com/Odion100/SystemLynx/tasksjs2.0/API.md">ServerModule</a></b></summary>
     
-- [**[created_method]([args...] [,callback])**]() 
-- [**on(name, constructor [,options])**]() 
-- [**emit()**]()
+- [**...constructedMethods**]()
+- [**on(name, callback)**]() 
+- [**emit(name, data)**]()
 
 </details>
 
 <details>
-   <summary><b><a href="https://github.com/Odion100/SystemLynx/tasksjs2.0/API.md">module</a></b></summary>
+   <summary><b><a href="https://github.com/Odion100/SystemLynx/tasksjs2.0/API.md">ClientModule</a></b></summary>
     
-- [**[created_method]([args...] [,callback])**]() 
-- [**on(name, constructor [,options])**]() 
-- [**emit()**]()
+- [**...loadedMethods**]() 
+- [**on(name, callback)**]() 
+- [**emit(name, data)**]()
 
 </details>
 
 ---
 
+## Service
+
+In SystemLynx a **Service** is a class used to host objects that can be later loaded into a client application using a SystemLynx **Client.** Get a handle on a SystemLynx **Service** by de-structuring the SystemLynx export.
+
+```javascript
+const { Service } = require(“systemlynx”)
+```
+
+## Service.module(name, constructor)
+
+Use the `Service.module(name, constructor/object)` method to create a **ServerModule**, which is an object that is hosted by a **SystemLynx Service**. This will allows you to later load an instance of that object into a client application. The **Service.module(name, constructor)** method takes the (string) name assigned to the object as the first argument, and the object itself, or a constructor function, as the second argument, and will return the constructed **ServerModule.** See the examples below.
+
+```javascript
+const { Service } = require("systemlynx");
+
+const UsersConstructor = {
+  add:function(data) {
+   return { message: "You have successfully called Users.add(...)" };
+  }
+};
+constr OrdersConstructor = function () {
+  const Orders = this;
+
+  Orders.find = function (arg1, arg2) {
+    return { message: "You have successfully called the Orders.find(...)" };
+  };
+}
+
+const Users = Service.module("Users", UsersConstructor);
+
+const Orders = Service.module("Orders", OrdersConstructor);
+```
+
+## Service.startService(options)
+
+Use the `Service.startService(options)` method to setup hosting and routing for the **Service**. Calling this method will start an **ExpressJS** Server and a **Socket.io** WebSocket Server, and allow the modules created by the **Service** to be loaded into a client application. This method returns a promise that will resolve once the Express server is running.
+
+```javascript
+const { Service } = require("systemlynx");
+const route = "my-route/whatever";
+const port = 8100;
+const host = "localhost";
+
+const promise = Service.startService({ route, port, host });
+```
+
+Following is a list of options that can be passed to the **Service.startService(options)** method.
+
+| Name          |  Type   | O/R/C | Description                                                                                                                                            |
+| :------------ | :-----: | :---: | :----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| route         | string  |   R   | The route from which the service can be loaded.                                                                                                        |
+| port          | number  |   R   | The port on which to start the Express server.                                                                                                         |
+| host          | string  |   O   | The host from which the **Service** can be reached.                                                                                                    |
+| socketPort    | string  |   R   | The port on which to start the Socket.io Websocket server. <br/><br/> Default value : **_random for digit number_**                                    |
+| useRest       | boolean |   O   | When this is true a RESTful route will be created for any **ServerModule** method which is named after a REST method <br/><br/> Default value: `false` |
+| useService    | boolean |   O   | The route from which the service can be loaded.                                                                                                        |
+| staticRouting | boolean |   O   | The route from which the service can be loaded.                                                                                                        |
+| middleware    | string  |   R   | The route from which the service can be loaded.                                                                                                        |
+
 ## App
 
 **App** combinds the both functionalites of SystemLynx Service and Client into one object, while also providing a module interface and lifecycle events. Access the App instance by deconcatanating from the object return when loading SystemLynx `require("systemlynx")`.

package/README.md

@@ -1,6 +1,6 @@
 # SystemLynx JS ![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg) ![PRs Welcome](https://img.shields.io/badge/PRs-welcome-blue.svg) ![JS 100%](https://img.shields.io/badge/JavaScript-100%25-green)
 
-SystemLynx is a framework for developing modular web APIs in NodeJS. It's a wrapper on top of ExpressJS and Socket.io. With SystemLynx, instead of developing a server with endpoints, you can simply export objects from a server into a client application. Basically any objects hosted by a SystemLynx Service can be loaded and used by a SystemLynx Client.
+SystemLynx is a framework for developing modular web APIs in NodeJS. It's a wrapper on top of ExpressJS and Socket.io. With SystemLynx, instead of creating a server with many endpoints, you can simply create objects and load those objects from a server into a client application. Basically any objects hosted by a SystemLynx Service can be loaded and used by a SystemLynx Client.
 
 SystemLynx comes with the following objects that are used for web app development:
 
@@ -8,13 +8,13 @@ SystemLynx comes with the following objects that are used for web app developmen
 const { App, Service, Client, LoadBalancer } = require("systemlynx");
 ```
 
-Call `require("systemlynx")` and de-concatenate from the object it returns. The main abstractions used for client-to-server interactions are the following:
+Call `require("systemlynx")` and destructrue from the object it returns. The main abstractions used for client-to-server interactions are the following:
 
 - **Service** - Used to create and host objects that can be loaded and used by a SystemLynx Client.
 - **Client** - Used in a client application to load a **Service**, which contains all the objects added to the **Service**.
 - **App** - Provides a modular interface and lifecycle methods for asynchronously creating and loading **Services**.
 
-Find the full [API Documentation](https://github.com/Odion100/SystemLynx/blob/tasksjs2.0/API.md#tasksjs-api-documentation) here.
+Find the full [API Documentation](https://github.com/Odion100/SystemLynx/blob/master/API.md#tasksjs-api-documentation) here.
 
 ---
 
@@ -57,7 +57,7 @@ Service.module("Orders", function () {
   const Orders = this;
 
   Orders.find = async function (arg1, arg2) {
-    console.log(data);
+    console.log(arg1, arg2);
     return { message: "You have successfully called the Orders.find method" };
   };
 });
@@ -82,8 +82,8 @@ Service.module("Users", Users);
 Service.module("Orders", function () {
   const Orders = this;
 
-  Orders.find = function (arg1, arg2) {
-    console.log(data);
+  Orders.find = async function (arg1, arg2) {
+    console.log(arg1, arg2);
     return { message: "You have successfully called the Orders.find method" };
   };
 });
@@ -165,8 +165,8 @@ Service.module("Users", Users);
 Service.module("Orders", function () {
   const Orders = this;
 
-  Orders.find = function (arg1, arg2) {
-    console.log(data);
+  Orders.find = async function (arg1, arg2) {
+    console.log(arg1, arg2);
     return { message: "You have successfully called the Orders.find method" };
   };
 });

package/index.test.js

@@ -35,6 +35,7 @@ describe("SystemLynx Objects", () => {
         "module",
         "on",
         "emit",
+        "use",
         "startService",
         "loadService",
         "onLoad",
@@ -43,6 +44,7 @@ describe("SystemLynx Objects", () => {
       .that.respondsTo("module")
       .that.respondsTo("on")
       .that.respondsTo("emit")
+      .that.respondsTo("use")
       .that.respondsTo("startService")
       .that.respondsTo("loadService")
       .that.respondsTo("onLoad")
@@ -67,14 +69,7 @@ describe("SystemLynx Objects", () => {
   it("should return a SystemLynx LoadBalancer", () => {
     expect(LoadBalancer)
       .to.be.an("object")
-      .that.has.all.keys(
-        "startService",
-        "Server",
-        "WebSocket",
-        "defaultModule",
-        "clones",
-        "module"
-      )
+      .that.has.all.keys("startService", "Server", "WebSocket", "clones", "module")
       .that.respondsTo("startService")
       .that.respondsTo("Server")
       .that.respondsTo("WebSocket")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "systemlynx",
-  "version": "1.5.0",
+  "version": "1.7.0",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -9,9 +9,7 @@
   },
   "dependencies": {
     "body-parser": "^1.18.3",
-    "chai-as-promised": "^7.1.1",
     "express": "^4.16.4",
-    "jest": "^24.9.0",
     "mime": "^2.4.0",
     "multer": "^1.4.2",
     "request": "^2.88.0",
@@ -30,7 +28,9 @@
   "homepage": "https://github.com/Odion100/SystemLynx#readme",
   "devDependencies": {
     "chai": "^4.3.4",
+    "chai-as-promised": "^7.1.1",
     "cz-conventional-changelog": "^3.3.0",
+    "jest": "^24.9.0",
     "mocha": "^6.2.0"
   },
   "config": {

package/systemlynx/App/App.js

@@ -1,22 +1,25 @@
 "use strict";
 const { isNode } = require("../../utils/ProcessChecker");
-const ServiceFactory = require("../Service/Service");
-const SystemObject = require("./components/SystemObject");
-const Dispatcher = require("../Dispatcher/Dispatcher");
+const SystemLynxService = require("../Service/Service");
+const SystemLynxDispatcher = require("../Dispatcher/Dispatcher");
 const initializeApp = require("./components/initializeApp");
+const SystemLynxContext = require("../utils/SystemContext");
+const System = require("../utils/System");
 
 module.exports = function SystemLynxApp() {
-  const { on, emit } = Dispatcher();
-  const App = { emit };
-  const system = { Services: [], Modules: [], configurations: {}, App, routing: null };
-  const systemObject = SystemObject(system);
-  setTimeout(() => initializeApp(system), 0);
-
-  App.on = (name, callback) => on(name, callback.bind(systemObject));
+  const system = new System();
+  const systemContext = SystemLynxContext(system);
+  const App = SystemLynxDispatcher(undefined, systemContext);
+  const plugins = [];
+  setTimeout(() => {
+    plugins.forEach((plugin) => {
+      if (typeof plugin === "function") plugin.apply({}, [App, system]);
+    });
+    initializeApp(system, App, systemContext);
+  }, 0);
 
   if (isNode) {
-    system.Service = ServiceFactory();
-    system.Service.defaultModule = systemObject;
+    system.Service = SystemLynxService(systemContext);
 
     App.startService = (options) => {
       system.routing = options;
@@ -24,33 +27,25 @@ module.exports = function SystemLynxApp() {
     };
 
     App.module = (name, __constructor) => {
-      system.Modules.push({
-        name,
-        __constructor,
-      });
+      system.modules.push({ name, __constructor });
       return App;
     };
   }
 
   App.loadService = (name, url) => {
-    system.Services.push({
-      name,
-      url,
-      onLoad: null,
-      client: {},
-    });
+    system.services.push({ name, url, onLoad: null, client: {} });
     return App;
   };
 
   App.onLoad = (handler) => {
-    const service = system.Services[system.Services.length - 1];
+    const service = system.services[system.services.length - 1];
     service.onLoad = handler;
     return App;
   };
 
   App.config = (__constructor) => {
     if (typeof __constructor === "function")
-      system.configurations = { __constructor, module: SystemObject(system) };
+      system.configurations = { __constructor, module: SystemLynxContext(system) };
     else
       throw Error(
         "[SystemLynx][App][Error]: App.config(...) methods requires a constructor function as its first parameter."
@@ -58,5 +53,9 @@ module.exports = function SystemLynxApp() {
     return App;
   };
 
+  App.use = (plugin) => {
+    plugins.push(plugin);
+    return App;
+  };
   return App;
 };

package/systemlynx/App/components/initializeApp.js

@@ -1,7 +1,7 @@
 const loadModules = require("./loadModules");
 const loadServices = require("./loadServices");
 
-module.exports = async function initApp(system) {
+module.exports = async function initApp(system, App, systemContext) {
   let configComplete = false;
   const continuationERROR = () => {
     if (!configComplete)
@@ -16,7 +16,7 @@ module.exports = async function initApp(system) {
   };
 
   try {
-    await loadServices(system);
+    await loadServices(system, App, systemContext);
   } catch (err) {
     throw `[SystemLynx][App][Error]: Initialization Error - failed to load all services`;
   }
@@ -26,8 +26,8 @@ module.exports = async function initApp(system) {
     system.configurations.__constructor.apply(system.configurations.module, [
       () => {
         configComplete = true;
-        loadModules(system);
+        loadModules(system, App);
       },
     ]);
-  } else loadModules(system);
+  } else loadModules(system, App);
 };

package/systemlynx/App/components/loadModules.js

@@ -1,10 +1,10 @@
-const Dispatcher = require("../../Dispatcher/Dispatcher");
-
-module.exports = async function loadModules(system) {
-  system.Modules.forEach(
+module.exports = async function loadModules(system, App) {
+  system.modules.forEach(
     (mod) => (mod.module = system.Service.module(mod.name, mod.__constructor))
   );
 
-  if (system.routing) await system.Service.startService(system.routing);
-  system.App.emit("ready", system);
+  if (system.routing) {
+    system.connectionData = await system.Service.startService(system.routing);
+  }
+  App.emit("ready", system);
 };

package/systemlynx/App/components/loadServices.js

@@ -1,11 +1,14 @@
-const Client = require("../../Client/Client")();
-module.exports = ({ Services, App }) => {
+const SystemLynxClient = require("../../Client/Client");
+
+module.exports = ({ services }, App, systemContext) => {
+  const Client = SystemLynxClient(systemContext);
+
   return Promise.all(
-    Services.map(serviceData => {
+    services.map((serviceData) => {
       const { url, limit, wait, name, onLoad } = serviceData;
-      return new Promise(resolve => {
+      return new Promise((resolve) => {
         Client.loadService(url, { limit, wait })
-          .then(service => {
+          .then((service) => {
             serviceData.client = service;
             if (typeof onLoad === "function") {
               onLoad(serviceData.client);
@@ -17,7 +20,7 @@ module.exports = ({ Services, App }) => {
             );
             resolve();
           })
-          .catch(err => {
+          .catch((err) => {
             console.warn(err);
             App.emit("failed_connection", { err, ...serviceData });
             resolve();

package/systemlynx/App/tests/App.test.js

@@ -1,11 +1,11 @@
 const { expect } = require("chai");
-const AppFactory = require("../App");
+const SystemLynxApp = require("../App");
 const HttpClient = require("../../HttpClient/HttpClient")();
-const ServiceFactory = require("../../Service/Service");
+const SystemLynxService = require("../../Service/Service");
 
-describe("App Factory", () => {
+describe("SystemLynxApp()", () => {
   it("should return a SystemLynx App", () => {
-    const App = AppFactory();
+    const App = SystemLynxApp();
 
     expect(App)
       .to.be.an("object")
@@ -13,6 +13,7 @@ describe("App Factory", () => {
         "module",
         "on",
         "emit",
+        "use",
         "startService",
         "loadService",
         "onLoad",
@@ -21,6 +22,7 @@ describe("App Factory", () => {
       .that.respondsTo("module")
       .that.respondsTo("on")
       .that.respondsTo("emit")
+      .that.respondsTo("use")
       .that.respondsTo("startService")
       .that.respondsTo("loadService")
       .that.respondsTo("onLoad")
@@ -29,7 +31,7 @@ describe("App Factory", () => {
 });
 describe("App: Loading Services", () => {
   it("should be able to use App.loadService(str_url) to load as hosted Service", async () => {
-    const Service = ServiceFactory();
+    const Service = SystemLynxService();
     const route = "test-service";
     const port = "8503";
 
@@ -41,13 +43,13 @@ describe("App: Loading Services", () => {
     await Service.startService({ route, port });
 
     await new Promise((resolve) => {
-      const App = AppFactory();
+      const App = SystemLynxApp();
       App.loadService("test", `http://localhost:${port}/${route}`).on(
         "ready",
         (system) => {
-          expect(system.Services[0]).to.be.an("object");
+          expect(system.services[0]).to.be.an("object");
 
-          expect(system.Services[0].client)
+          expect(system.services[0].client)
             .to.be.an("object")
             .that.has.all.keys("emit", "on", "resetConnection", "disconnect", "mod")
             .that.respondsTo("emit")
@@ -61,7 +63,7 @@ describe("App: Loading Services", () => {
   });
 
   it("should be able to use App.loadService(...).onLoad(handler) to fire a callback when the Service connects", async () => {
-    const Service = ServiceFactory();
+    const Service = SystemLynxService();
     const route = "test-service";
     const port = "8422";
     const url = `http://localhost:${port}/${route}`;
@@ -74,7 +76,7 @@ describe("App: Loading Services", () => {
     await Service.startService({ route, port });
 
     await new Promise((resolve) => {
-      const App = AppFactory();
+      const App = SystemLynxApp();
       App.loadService("test", url).onLoad((test) => {
         expect(test)
           .to.be.an("object")
@@ -89,7 +91,7 @@ describe("App: Loading Services", () => {
   });
 
   it('should use App.on("service_loaded[:name]", callback) to fire when a Service has loaded', async () => {
-    const Service = ServiceFactory();
+    const Service = SystemLynxService();
     const route = "test-service";
     const port = "8423";
     const url = `http://localhost:${port}/${route}`;
@@ -101,7 +103,7 @@ describe("App: Loading Services", () => {
     await Service.startService({ route, port });
 
     await new Promise((resolve) => {
-      const App = AppFactory();
+      const App = SystemLynxApp();
       App.loadService("test", url)
         .on("service_loaded", (test) => {
           expect(test)
@@ -124,7 +126,7 @@ describe("App: Loading Services", () => {
   });
 
   it("should be accessible to SystemObjects via the module.useService method", async () => {
-    const Service = ServiceFactory();
+    const Service = SystemLynxService();
     const route = "test-service";
     const port = "8442";
     const url = `http://localhost:${port}/${route}`;
@@ -137,7 +139,7 @@ describe("App: Loading Services", () => {
     await Service.startService({ route, port });
 
     await new Promise((resolve) => {
-      const App = AppFactory();
+      const App = SystemLynxApp();
       App.loadService("test", url)
         .module("module_name", function () {
           const test = this.useService("test");
@@ -156,7 +158,7 @@ describe("App: Loading Services", () => {
 
 describe("App SystemObjects: Initializing Modules,  Modules and configurations", () => {
   it("should be able to use App.module to initialize a module", async () => {
-    const App = AppFactory();
+    const App = SystemLynxApp();
     return new Promise((resolve) =>
       App.module("test", function () {
         expect(this)
@@ -181,7 +183,7 @@ describe("App SystemObjects: Initializing Modules,  Modules and configurations",
     );
   });
   it("should be able to use App.startService to start as Service", async () => {
-    const App = AppFactory();
+    const App = SystemLynxApp();
     const route = "test-service";
     const port = "8493";
     const url = `http://localhost:${port}/${route}`;
@@ -207,7 +209,7 @@ describe("App SystemObjects: Initializing Modules,  Modules and configurations",
     expect(connData.serviceUrl).to.equal(url);
   });
   it("should be able to use App.module to add a hosted Module to the Service", async () => {
-    const App = AppFactory();
+    const App = SystemLynxApp();
     const route = "test-service";
     const port = "8494";
     const url = `http://localhost:${port}/${route}`;
@@ -252,8 +254,10 @@ describe("App SystemObjects: Initializing Modules,  Modules and configurations",
   });
 
   it('should be able to use App.on("ready", callback) fire a callback when App initialization is complete', async () => {
-    const App = AppFactory();
-
+    const App = SystemLynxApp();
+    const route = "system-test";
+    const port = "4242";
+    App.startService({ route, port });
     App.module("mod", function () {
       this.test = () => {};
       this.test2 = () => {};
@@ -267,11 +271,11 @@ describe("App SystemObjects: Initializing Modules,  Modules and configurations",
         expect(system)
           .to.be.an("object")
           .that.has.all.keys(
-            "Services",
+            "services",
             "Service",
-            "Modules",
+            "modules",
+            "connectionData",
             "configurations",
-            "App",
             "routing"
           );
         resolve();
@@ -279,8 +283,8 @@ describe("App SystemObjects: Initializing Modules,  Modules and configurations",
     );
   });
 
-  it("should be able to use App.config(constructor) to construct a configuartion module", async () => {
-    const App = AppFactory();
+  it("should be able to use App.config(constructor) to construct a configuration module", async () => {
+    const App = SystemLynxApp();
 
     App.module("mod", function () {
       this.test = () => {};
@@ -310,10 +314,41 @@ describe("App SystemObjects: Initializing Modules,  Modules and configurations",
     );
   });
 });
+describe("Use App.use(SystemLynxPlugin), to initializing Modules, and load Services", () => {
+  it("should allow for adding new modules and services before app initialization", async () => {
+    const Service = SystemLynxService();
+    const route = "test-service";
+    const port = "8520";
+    const pluginUrl = `http://localhost:${port}/${route}`;
+    Service.module("mod", function () {
+      this.test = () => {};
+      this.test2 = () => {};
+    });
+    await Service.startService({ route, port });
 
-describe("SystemObjects", () => {
+    const plugin = (App, system) => {
+      App.loadService("PluginService", pluginUrl);
+      App.module("plugin", { testMethod: (data) => data });
+    };
+    await new Promise((resolve) => {
+      const App = SystemLynxApp();
+      App.module("testModule", { testFunction: () => data })
+        .use(plugin)
+        .on("ready", (system) => {
+          expect(system.services).to.have.lengthOf(1);
+          expect(system.services[0]).to.be.an("object");
+          expect(system.services[0]).to.have.property("name", "PluginService");
+          expect(system.services[0]).to.have.property("url", pluginUrl);
+          expect(system.modules).to.have.lengthOf(2);
+          expect(system.modules[1]).to.have.property("name", "plugin");
+          resolve();
+        });
+    });
+  });
+});
+describe("SystemContext", () => {
   it("should be able to use this.useModule and this.useService within modules and Module", () => {
-    const App = AppFactory();
+    const App = SystemLynxApp();
     App.module("mod1", function () {
       expect(this)
         .to.be.an("object")
@@ -333,6 +368,7 @@ describe("SystemObjects", () => {
         const config = this.useConfig();
         expect(mod1.testPassed).to.equal(true);
         expect(config.configPassed).to.equal(true);
+        this.testPassed = true;
       })
       .config(function (next) {
         expect(this)
@@ -353,7 +389,68 @@ describe("SystemObjects", () => {
         const config = this.useConfig();
         expect(mod1.testPassed).to.equal(true);
         expect(config.configPassed).to.equal(true);
+      })
+      .on("ready", function () {
+        expect(this)
+          .to.be.an("object")
+          .that.respondsTo("useService")
+          .that.respondsTo("useModule")
+          .that.respondsTo("useConfig");
+        const mod2 = this.useModule("mod2");
+        const config = this.useConfig();
+        expect(mod2.testPassed).to.equal(true);
+        expect(config.configPassed).to.equal(true);
       });
     return new Promise((resolve) => App.on("ready", () => resolve()));
   });
+  it("[SystemLynx][App][Client][on] should have access to systemContext during event callbacks.", async () => {
+    const AppBackend = SystemLynxApp();
+    const eventName = "testing-this";
+    const _route = "test-service";
+    const _port = "8900";
+    const _url = `http://localhost:${_port}/${_route}`;
+    AppBackend.module("EventTesterModule", function () {
+      this.sendEvent = () => this.emit(eventName, { testPassed: true });
+
+      //testing local event callback context
+      this.on(eventName, function () {
+        console.log("Aww man... here we go again!", this);
+        expect(this)
+          .to.be.an("object")
+          .that.respondsTo("useService")
+          .that.respondsTo("useModule")
+          .that.respondsTo("useConfig");
+      });
+    });
+    await AppBackend.startService({ route: _route, port: _port });
+
+    const AppClient = SystemLynxApp();
+    const route = "test-service";
+    const port = "8901";
+
+    AppClient.startService({ route, port }).loadService("buAPI", _url);
+    await new Promise((resolve) =>
+      AppClient.on("ready", function () {
+        const { EventTesterModule } = this.useService("buAPI");
+        EventTesterModule.on(eventName, function (data, event) {
+          console.log("Ladies and gentleman... another one!");
+          expect(this)
+            .to.be.an("object")
+            .that.respondsTo("useService")
+            .that.respondsTo("useModule")
+            .that.respondsTo("useConfig");
+          expect(data).to.deep.equal({ testPassed: true });
+          expect(event)
+            .to.be.an("object")
+            .that.has.all.keys("id", "name", "data", "type");
+          expect(event.name).to.equal(eventName);
+          expect(event.data).to.deep.equal({ testPassed: true });
+          expect(event.id).to.be.a("string");
+          expect(event.type).to.equal("WebSocket");
+          resolve();
+        });
+        EventTesterModule.sendEvent(eventName);
+      })
+    );
+  });
 });