Add Plugins unit tests

Author: javierbrea

jest.config.js

@@ -17,10 +17,10 @@ module.exports = {
   // An object that configures minimum threshold enforcement for coverage results
   coverageThreshold: {
     global: {
-      branches: 93,
-      functions: 93,
-      lines: 93,
-      statements: 93
+      branches: 100,
+      functions: 100,
+      lines: 100,
+      statements: 100
     }
   },
 

lib/core/Plugins.js

@@ -51,12 +51,14 @@ class Plugins {
   }
 
   _catchInitError(error) {
+    this._pluginsInitialized = this._pluginsInitialized - 1;
     tracer.error("Error initializating plugin");
     tracer.debug(error);
     return Promise.resolve();
   }
 
   _catchStartError(error) {
+    this._pluginsStarted = this._pluginsStarted - 1;
     tracer.error("Error starting plugin");
     tracer.debug(error);
     return Promise.resolve();
@@ -102,65 +104,57 @@ class Plugins {
   }
 
   _initPlugins(pluginIndex = 0) {
-    if (!this._pluginsInstances[pluginIndex]) {
+    if (pluginIndex === this._pluginsInstances.length) {
       return Promise.resolve();
     }
+    this._pluginsInitialized++;
     tracer.debug(`Initializing plugin ${pluginIndex}`);
     const initNextPlugin = () => {
       return this._initPlugins(pluginIndex + 1);
     };
 
     if (!this._pluginsInstances[pluginIndex].init) {
+      this._pluginsInitialized = this._pluginsInitialized - 1;
       return initNextPlugin();
     }
     let pluginInit;
     try {
       pluginInit = this._pluginsInstances[pluginIndex].init();
     } catch (error) {
-      return this._catchInitError(error);
+      return this._catchInitError(error).then(initNextPlugin);
     }
 
     if (!isPromise(pluginInit)) {
-      this._pluginsInitialized++;
-      return Promise.resolve();
+      return initNextPlugin();
     }
-    return pluginInit
-      .then(() => {
-        this._pluginsInitialized++;
-        return Promise.resolve();
-      })
-      .then(initNextPlugin)
-      .catch(this._catchInitError);
+    return pluginInit.catch(this._catchInitError).then(initNextPlugin);
   }
 
   _startPlugins(pluginIndex = 0) {
-    if (!this._pluginsInstances[pluginIndex]) {
+    if (pluginIndex === this._pluginsInstances.length) {
       return Promise.resolve();
     }
+    this._pluginsStarted++;
     tracer.debug(`Starting plugin ${pluginIndex}`);
     const startNextPlugin = () => {
       return this._startPlugins(pluginIndex + 1);
     };
+
     if (!this._pluginsInstances[pluginIndex].start) {
+      this._pluginsStarted = this._pluginsStarted - 1;
       return startNextPlugin();
     }
     let pluginStart;
     try {
       pluginStart = this._pluginsInstances[pluginIndex].start();
     } catch (error) {
-      return this._catchStartError(error);
+      return this._catchStartError(error).then(startNextPlugin);
     }
+
     if (!isPromise(pluginStart)) {
-      this._pluginsStarted++;
-      return Promise.resolve();
+      return startNextPlugin();
     }
-    return pluginStart
-      .then(() => {
-        this._pluginsStarted++;
-        return Promise.resolve();
-      })
-      .then(startNextPlugin)
-      .catch(this._catchStartError);
+    return pluginStart.catch(this._catchStartError).then(startNextPlugin);
   }
 }
 

test/unit/core/Plugins.spec.js

@@ -66,10 +66,13 @@ describe("Settings", () => {
       expect(tracer.verbose.calledWith("Registered 0 plugins")).toEqual(true);
     });
 
-    it("should register function plugins", async () => {
-      const fooPlugin = () => {};
+    it("should register function plugins executing them passing the core", async () => {
+      expect.assertions(3);
+      const fooPlugin = sinon.spy();
       plugins = new Plugins([fooPlugin], coreInstance);
       await plugins.register();
+      expect(fooPlugin.calledWith(coreInstance)).toEqual(true);
+      expect(fooPlugin.callCount).toEqual(1);
       expect(tracer.verbose.calledWith("Registered 1 plugins")).toEqual(true);
     });
 
@@ -121,4 +124,142 @@ describe("Settings", () => {
       expect(tracer.verbose.calledWith("Registered 3 plugins")).toEqual(true);
     });
   });
+
+  describe("init method", () => {
+    it("should do nothing if there are no plugins to register", async () => {
+      plugins = new Plugins(null, coreInstance);
+      await plugins.register();
+      await plugins.init();
+      expect(tracer.verbose.calledWith("Initializated 0 plugins")).toEqual(true);
+    });
+
+    it("should init object plugins with an init property", async () => {
+      expect.assertions(2);
+      const fooPlugin = {
+        init: sinon.spy()
+      };
+      plugins = new Plugins([fooPlugin], coreInstance);
+      await plugins.register();
+      await plugins.init();
+      expect(fooPlugin.init.callCount).toEqual(1);
+      expect(tracer.verbose.calledWith("Initializated 1 plugins")).toEqual(true);
+    });
+
+    it("should accept init methods non returning a Promise", async () => {
+      expect.assertions(1);
+      const fooPlugin = {
+        init: () => true
+      };
+      const fooPlugin2 = {
+        init: () => Promise.resolve()
+      };
+      plugins = new Plugins([fooPlugin, fooPlugin2], coreInstance);
+      await plugins.register();
+      await plugins.init();
+      expect(tracer.verbose.calledWith("Initializated 2 plugins")).toEqual(true);
+    });
+
+    it("should catch init method errors", async () => {
+      expect.assertions(1);
+      const fooPlugin = {
+        init: () => {
+          throw new Error();
+        }
+      };
+      const fooPlugin2 = {
+        init: () => Promise.resolve()
+      };
+      const fooPlugin3 = {
+        init: () => Promise.resolve()
+      };
+      plugins = new Plugins([fooPlugin, fooPlugin2, fooPlugin3], coreInstance);
+      await plugins.register();
+      await plugins.init();
+      expect(tracer.verbose.calledWith("Initializated 2 plugins")).toEqual(true);
+    });
+
+    it("should accept plugins with no init method", async () => {
+      expect.assertions(1);
+      const fooPlugin = {};
+      const fooPlugin2 = {
+        init: () => Promise.resolve()
+      };
+      const fooPlugin3 = {
+        init: () => Promise.resolve()
+      };
+      plugins = new Plugins([fooPlugin, fooPlugin2, fooPlugin3], coreInstance);
+      await plugins.register();
+      await plugins.init();
+      expect(tracer.verbose.calledWith("Initializated 2 plugins")).toEqual(true);
+    });
+  });
+
+  describe("start method", () => {
+    it("should do nothing if there are no plugins to register", async () => {
+      plugins = new Plugins(null, coreInstance);
+      await plugins.register();
+      await plugins.start();
+      expect(tracer.verbose.calledWith("Started 0 plugins")).toEqual(true);
+    });
+
+    it("should start object plugins with an init property", async () => {
+      expect.assertions(2);
+      const fooPlugin = {
+        start: sinon.spy()
+      };
+      plugins = new Plugins([fooPlugin], coreInstance);
+      await plugins.register();
+      await plugins.start();
+      expect(fooPlugin.start.callCount).toEqual(1);
+      expect(tracer.verbose.calledWith("Started 1 plugins")).toEqual(true);
+    });
+
+    it("should accept start methods non returning a Promise", async () => {
+      expect.assertions(1);
+      const fooPlugin = {
+        start: () => true
+      };
+      const fooPlugin2 = {
+        start: () => Promise.resolve()
+      };
+      plugins = new Plugins([fooPlugin, fooPlugin2], coreInstance);
+      await plugins.register();
+      await plugins.start();
+      expect(tracer.verbose.calledWith("Started 2 plugins")).toEqual(true);
+    });
+
+    it("should catch start method errors", async () => {
+      expect.assertions(1);
+      const fooPlugin = {
+        start: () => {
+          throw new Error();
+        }
+      };
+      const fooPlugin2 = {
+        start: () => Promise.resolve()
+      };
+      const fooPlugin3 = {
+        start: () => Promise.resolve()
+      };
+      plugins = new Plugins([fooPlugin, fooPlugin2, fooPlugin3], coreInstance);
+      await plugins.register();
+      await plugins.start();
+      expect(tracer.verbose.calledWith("Started 2 plugins")).toEqual(true);
+    });
+
+    it("should accept plugins with no start method", async () => {
+      expect.assertions(1);
+      const fooPlugin = {};
+      const fooPlugin2 = {
+        start: () => Promise.resolve()
+      };
+      const fooPlugin3 = {
+        start: () => Promise.resolve()
+      };
+      plugins = new Plugins([fooPlugin, fooPlugin2, fooPlugin3], coreInstance);
+      await plugins.register();
+      await plugins.start();
+      expect(tracer.verbose.calledWith("Started 2 plugins")).toEqual(true);
+    });
+  });
 });