Merge pull request #72 from serverless/add-function-handler-validation

Add function handler validation

Author: pmuens

shared/validate.js

@@ -1,12 +1,14 @@
 'use strict';
 
 const BbPromise = require('bluebird');
+const _ = require('lodash');
 
 module.exports = {
   validate() {
     return BbPromise.bind(this)
       .then(this.validateServicePath)
-      .then(this.validateServiceName);
+      .then(this.validateServiceName)
+      .then(this.validateHandlers);
   },
 
   validateServicePath() {
@@ -31,4 +33,22 @@ module.exports = {
 
     return BbPromise.resolve();
   },
+
+  validateHandlers() {
+    const functions = this.serverless.service.functions;
+
+    _.forEach(functions, (funcVal, funcKey) => {
+      if (funcVal.handler.includes('/') || funcVal.handler.includes('.')) {
+        const errorMessage = [
+          `The "handler" property for the function "${funcKey}" is invalid.`,
+          ' Handlers should be plain strings referencing only the exported function name',
+          ' without characters such as "." or "/" (so e.g. "http" instead of "index.http").',
+          ' Do you want to nest your functions code in a subdirectory?',
+          ' Google solves this by utilizing the "main" config in the projects package.json file.',
+          ' Please check the docs for more info.',
+        ].join('');
+        throw new Error(errorMessage);
+      }
+    });
+  },
 };

shared/validate.test.js

@@ -27,23 +27,28 @@ describe('Validate', () => {
   describe('#validate()', () => {
     let validateServicePathStub;
     let validateServiceNameStub;
+    let validateHandlersStub;
 
     beforeEach(() => {
       validateServicePathStub = sinon.stub(googleCommand, 'validateServicePath')
         .returns(BbPromise.resolve());
       validateServiceNameStub = sinon.stub(googleCommand, 'validateServiceName')
         .returns(BbPromise.resolve());
+      validateHandlersStub = sinon.stub(googleCommand, 'validateHandlers')
+        .returns(BbPromise.resolve());
     });
 
     afterEach(() => {
       googleCommand.validateServicePath.restore();
       googleCommand.validateServiceName.restore();
+      googleCommand.validateHandlers.restore();
     });
 
     it('should run promise chain', () => googleCommand
       .validate().then(() => {
         expect(validateServicePathStub.calledOnce).toEqual(true);
         expect(validateServiceNameStub.calledAfter(validateServicePathStub));
+        expect(validateHandlersStub.calledAfter(validateServiceNameStub));
       }));
   });
 
@@ -80,4 +85,29 @@ describe('Validate', () => {
       expect(() => googleCommand.validateServiceName()).not.toThrow(Error);
     });
   });
+
+  describe('#validateHandlers()', () => {
+    it('should throw an error if the handler name contains an invalid character', () => {
+      googleCommand.serverless.service.functions = {
+        foo: {
+          handler: 'invalid.handler',
+        },
+        bar: {
+          handler: 'invalid/handler',
+        },
+      };
+
+      expect(() => googleCommand.validateHandlers()).toThrow(Error);
+    });
+
+    it('should not throw an error if the function handler is valid', () => {
+      googleCommand.serverless.service.functions = {
+        foo: {
+          handler: 'validHandler',
+        },
+      };
+
+      expect(() => googleCommand.validateHandlers()).not.toThrow(Error);
+    });
+  });
 });