Resolve / #244

.eslintrc.js

@@ -2,6 +2,7 @@ module.exports = {
   env: {
     es6: true,
     node: true,
+    mocha: true,
   },
   extends: "eslint:recommended",
   parserOptions: {

index.js

@@ -434,13 +434,29 @@ class ServerlessWSGI {
   }
 
   findHandler() {
-    return _.findKey(this.serverless.service.functions, (fun) =>
-      _.includes(fun.handler, "wsgi_handler.handler")
-    );
+    const functionName = this.options.function || this.options.f;
+
+    if (functionName) {
+      // If the function name is specified, return it directly
+      if (this.serverless.service.functions[functionName]) {
+        return functionName;
+      } else {
+        throw new Error(`Function "${functionName}" not found.`);
+      }
+    } else {
+      return _.findKey(this.serverless.service.functions, (fun) =>
+        _.includes(fun.handler, "wsgi_handler.handler")
+      );
+    }
   }
 
   invokeHandler(command, data, local) {
-    const handlerFunction = this.findHandler();
+    let handlerFunction;
+    try {
+      handlerFunction = this.findHandler();
+    } catch (error) {
+      return BbPromise.reject(error.message);
+    }
 
     if (!handlerFunction) {
       return BbPromise.reject(

index.test.js

@@ -1,6 +1,6 @@
 "use strict";
 
 /* global describe it */
 const chai = require("chai");
 const expect = chai.expect;
 const sinon = require("sinon");
@@ -1545,8 +1545,8 @@
   });
 
   describe("exec", () => {
-    const mockCli = Object({log: () => {}});
-    
+    const mockCli = Object({ log: () => {} });
+
     it("fails when invoked without command or file", () => {
       var plugin = new Plugin(
         {
@@ -1681,7 +1681,7 @@
   });
 
   describe("exec local", () => {
-    const mockCli = {log: () => {}};
+    const mockCli = { log: () => {} };
 
     it("fails when invoked without command or file", () => {
       var plugin = new Plugin(
@@ -1788,7 +1788,7 @@
   });
 
   describe("command", () => {
-    const mockCli = {log: () => {}};
+    const mockCli = { log: () => {} };
 
     it("fails when no wsgi handler is set", () => {
       var plugin = new Plugin(
@@ -1915,7 +1915,7 @@
   });
 
   describe("command local", () => {
-    const mockCli = {log: () => {}};
+    const mockCli = { log: () => {} };
 
     it("fails when no wsgi handler is set", () => {
       var plugin = new Plugin(
@@ -2046,34 +2046,48 @@
   });
 
   describe("manage", () => {
-    const mockCli = Object({log: () => {}});
+    const mockCli = {
+      log: sinon.spy(),
+    };
 
-    it("calls handler to execute manage commands remotely from argument", () => {
-      var plugin = new Plugin(
+    let plugin;
+    let sandbox;
+
+    beforeEach(() => {
+      sandbox = sinon.createSandbox();
+      plugin = new Plugin(
         {
           config: { servicePath: "/tmp" },
           service: {
             provider: { runtime: "python2.7" },
             custom: { wsgi: { app: "api.app" } },
-            functions: { app: { handler: "wsgi_handler.handler" } },
+            functions: {
+              app: { handler: "wsgi_handler.handler" },
+              otherFunc: { handler: "other_handler.handler" },
+            },
           },
           classes: { Error: Error },
           cli: mockCli,
           pluginManager: {
             cliOptions: {},
-            run: (command) =>
-              new BbPromise((resolve) => {
-                expect(command).to.deep.equal(["invoke"]);
-                console.log('[0, "manage command output"]'); // eslint-disable-line no-console
-                resolve();
-              }),
+            run: sandbox.stub().resolves(),
           },
         },
         { command: "check" }
       );
+    });
+
+    afterEach(() => {
+      sandbox.restore();
+    });
+
+    it("calls handler to execute manage commands remotely from argument", () => {
+      plugin.serverless.pluginManager.run.callsFake((command) => {
+        expect(command).to.deep.equal(["invoke"]);
+        console.log('[0, "manage command output"]');
+        return BbPromise.resolve();
+      });
 
-      var sandbox = sinon.createSandbox();
-      let loggerSpy = sandbox.spy(mockCli, "log");
       return plugin.hooks["wsgi:manage:manage"]().then(() => {
         expect(plugin.serverless.pluginManager.cliOptions.f).to.equal("app");
         expect(plugin.options.function).to.equal("app");
@@ -2083,14 +2097,65 @@
         expect(plugin.options.data).to.equal(
           '{"_serverless-wsgi":{"command":"manage","data":"check"}}'
         );
-        expect(loggerSpy.calledWith("manage command output")).to.be.true;
-        sandbox.restore();
+        expect(mockCli.log.calledWith("manage command output")).to.be.true;
       });
     });
+
+    it("uses the function specified by --function", () => {
+      plugin.options.function = "otherFunc";
+
+      return plugin.hooks["wsgi:manage:manage"]().then(() => {
+        expect(plugin.serverless.pluginManager.cliOptions.f).to.equal(
+          "otherFunc"
+        );
+        expect(plugin.options.function).to.equal("otherFunc");
+      });
+    });
+
+    it("uses the function specified by -f", () => {
+      plugin.options.f = "otherFunc";
+
+      return plugin.hooks["wsgi:manage:manage"]().then(() => {
+        expect(plugin.serverless.pluginManager.cliOptions.f).to.equal(
+          "otherFunc"
+        );
+        expect(plugin.options.function).to.equal("otherFunc");
+      });
+    });
+
+    it("throws an error when specified function is not found", () => {
+      plugin.options.function = "nonExistentFunc";
+
+      return expect(plugin.hooks["wsgi:manage:manage"]()).to.be.rejectedWith(
+        'Function "nonExistentFunc" not found.'
+      );
+    });
+
+    it("falls back to finding wsgi handler when no function is specified", () => {
+      delete plugin.options.function;
+      delete plugin.options.f;
+
+      return plugin.hooks["wsgi:manage:manage"]().then(() => {
+        expect(plugin.serverless.pluginManager.cliOptions.f).to.equal("app");
+        expect(plugin.options.function).to.equal("app");
+      });
+    });
+
+    it("rejects when no wsgi handler is found and no function is specified", () => {
+      delete plugin.options.function;
+      delete plugin.options.f;
+      plugin.serverless.service.functions = {
+        someFunc: { handler: "some_handler.handler" },
+      };
+
+      return expect(plugin.hooks["wsgi:manage:manage"]()).to.be.rejectedWith(
+        "No functions were found with handler: wsgi_handler.handler"
+      );
+    });
   });
 
   describe("manage local", () => {
-    const mockCli = Object({log: () => {}});
+    const mockCli = Object({ log: () => {} });
 
     it("calls handler to execute manage commands locally from argument", () => {
       var plugin = new Plugin(
@@ -2137,7 +2202,7 @@
   });
 
   describe("flask", () => {
-    const mockCli = Object({log: () => {}});
+    const mockCli = Object({ log: () => {} });
     it("calls handler to execute flask commands remotely from argument", () => {
       var plugin = new Plugin(
         {
@@ -2180,7 +2245,7 @@
   });
 
   describe("flask local", () => {
-    const mockCli = Object({log: () => {}});
+    const mockCli = Object({ log: () => {} });
     it("calls handler to execute flask commands locally from argument", () => {
       var plugin = new Plugin(
         {