Add Plugins class unit tests

Author: javierbrea

jest.config.js

@@ -17,16 +17,16 @@ module.exports = {
   // An object that configures minimum threshold enforcement for coverage results
   coverageThreshold: {
     global: {
-      branches: 88,
-      functions: 90,
-      lines: 90,
-      statements: 90
+      branches: 93,
+      functions: 93,
+      lines: 93,
+      statements: 93
     }
   },
 
   // The glob patterns Jest uses to detect test files
   testMatch: ["**/test/unit/**/?(*.)+(spec|test).js?(x)"],
-  // testMatch: ["**/test/unit/core/Plugins.spec.js"],
+  //testMatch: ["**/test/unit/core/Plugins.spec.js"],
 
   // The test environment that will be used for testing
   testEnvironment: "node"

lib/core/Plugins.js

@@ -9,7 +9,7 @@ Unless required by applicable law or agreed to in writing, software distributed
 */
 
 const isPromise = require("is-promise");
-const { isFunction } = require("lodash");
+const { isObject, isFunction } = require("lodash");
 
 const tracer = require("./tracer");
 
@@ -62,38 +62,41 @@ class Plugins {
     return Promise.resolve();
   }
 
-  _createPluginFunction(Plugin) {
+  _registerPluginFunction(Plugin) {
     let pluginInstance;
     try {
       pluginInstance = Plugin(this._core);
+      this._pluginsRegistered++;
     } catch (error) {
-      return this._catchCreateError(error);
+      return this._catchRegisterError(error);
     }
     return pluginInstance;
   }
 
-  _createPlugin(Plugin) {
-    if (!isFunction(Plugin)) {
+  _registerPlugin(Plugin) {
+    if (isObject(Plugin) && !isFunction(Plugin)) {
+      this._pluginsRegistered++;
       return Plugin;
     }
     let pluginInstance;
     try {
       pluginInstance = new Plugin(this._core);
+      this._pluginsRegistered++;
     } catch (error) {
       if (error.message.includes("is not a constructor")) {
-        return this._createPluginFunction(Plugin);
+        return this._registerPluginFunction(Plugin);
       } else {
-        return this._catchCreateError(error);
+        return this._catchRegisterError(error);
       }
     }
     return pluginInstance;
   }
 
   _registerPlugins(pluginIndex = 0) {
-    if (!this._plugins[pluginIndex]) {
+    if (pluginIndex === this._plugins.length) {
       return Promise.resolve();
     }
-    const plugin = this._createPlugin(this._plugins[pluginIndex]);
+    const plugin = this._registerPlugin(this._plugins[pluginIndex]);
     this._pluginsInstances.push(plugin);
     return this._registerPlugins(pluginIndex + 1);
   }

test/unit/core/Core.spec.js

@@ -1,6 +1,5 @@
 /*
 Copyright 2019 Javier Brea
-Copyright 2019 XbyOrange
 
 Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
 

test/unit/core/Plugins.spec.js

@@ -0,0 +1,124 @@
+/*
+Copyright 2019 Javier Brea
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+*/
+
+const sinon = require("sinon");
+
+const CoreMocks = require("./Core.mocks.js");
+
+const Plugins = require("../../../lib/core/Plugins");
+const tracer = require("../../../lib/core/tracer");
+
+describe("Settings", () => {
+  let sandbox;
+  let coreMocks;
+  let coreInstance;
+  let plugins;
+
+  beforeEach(async () => {
+    sandbox = sinon.createSandbox();
+    sandbox.stub(tracer, "verbose");
+    sandbox.stub(tracer, "debug");
+    sandbox.stub(tracer, "error");
+    sandbox.spy(console, "log");
+    coreMocks = new CoreMocks();
+    coreInstance = coreMocks.stubs.instance;
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+    coreMocks.restore();
+  });
+
+  describe("register method", () => {
+    it("should do nothing if there are no plugins to register", async () => {
+      plugins = new Plugins(null, coreInstance);
+      await plugins.register();
+      expect(tracer.verbose.calledWith("Registered 0 plugins")).toEqual(true);
+    });
+
+    it("should register object plugins", async () => {
+      const fooPlugin = {};
+      plugins = new Plugins([fooPlugin], coreInstance);
+      await plugins.register();
+      expect(tracer.verbose.calledWith("Registered 1 plugins")).toEqual(true);
+    });
+
+    it("should not register strings as plugins", async () => {
+      expect.assertions(2);
+      plugins = new Plugins(["foo"], coreInstance);
+      await plugins.register();
+      expect(console.log.calledWith("Error registering plugin")).toEqual(true);
+      expect(tracer.verbose.calledWith("Registered 0 plugins")).toEqual(true);
+    });
+
+    it("should not register booleans as plugins", async () => {
+      expect.assertions(2);
+      plugins = new Plugins([true], coreInstance);
+      await plugins.register();
+      expect(console.log.calledWith("Error registering plugin")).toEqual(true);
+      expect(tracer.verbose.calledWith("Registered 0 plugins")).toEqual(true);
+    });
+
+    it("should register function plugins", async () => {
+      const fooPlugin = () => {};
+      plugins = new Plugins([fooPlugin], coreInstance);
+      await plugins.register();
+      expect(tracer.verbose.calledWith("Registered 1 plugins")).toEqual(true);
+    });
+
+    it("should register class plugins, instantiating them passing the core", async () => {
+      expect.assertions(3);
+      let instantiated = false;
+      let receivedCore;
+      class FooPlugin {
+        constructor(core) {
+          console.log("Created class");
+          receivedCore = core;
+          instantiated = true;
+        }
+      }
+      plugins = new Plugins([FooPlugin], coreInstance);
+      await plugins.register();
+      expect(receivedCore).toEqual(coreInstance);
+      expect(instantiated).toEqual(true);
+      expect(tracer.verbose.calledWith("Registered 1 plugins")).toEqual(true);
+    });
+
+    it("should not register class plugins if class throw an error when being created", async () => {
+      expect.assertions(2);
+      class FooPlugin {
+        constructor() {
+          throw new Error();
+        }
+      }
+      plugins = new Plugins([FooPlugin], coreInstance);
+      await plugins.register();
+      expect(console.log.calledWith("Error registering plugin")).toEqual(true);
+      expect(tracer.verbose.calledWith("Registered 0 plugins")).toEqual(true);
+    });
+
+    it("should trace the total number of registered plugins", async () => {
+      expect.assertions(2);
+      class FooPlugin {
+        constructor() {
+          throw new Error();
+        }
+      }
+      class FooPlugin2 {}
+      plugins = new Plugins(
+        [FooPlugin, FooPlugin2, () => {}, true, false, "foo", { foo: "foo" }],
+        coreInstance
+      );
+      await plugins.register();
+      expect(console.log.calledWith("Error registering plugin")).toEqual(true);
+      expect(tracer.verbose.calledWith("Registered 3 plugins")).toEqual(true);
+    });
+  });
+});