[Fix #2418] Allow function event definitions to be variables

lib/Serverless.js

@@ -84,6 +84,9 @@ class Serverless {
     // (https://github.com/serverless/serverless/issues/2041)
     this.variables.populateService(this.pluginManager.cliOptions);
 
+    // validate the service configuration, now that variables are loaded
+    this.service.validate();
+
     // trigger the plugin lifecycle when there's something which should be processed
     return this.pluginManager.run(this.processedInput.commands);
   }

lib/classes/Service.js

@@ -152,10 +152,6 @@ class Service {
           if (!functionObj.events) {
             that.functions[functionName].events = [];
           }
-          if (!_.isArray(functionObj.events)) {
-            throw new SError(`Events for "${functionName}" must be an array,` +
-                             ` not an ${typeof functionObj.events}`);
-          }
 
           if (!functionObj.name) {
             that.functions[functionName].name =
@@ -167,6 +163,17 @@ class Service {
       });
   }
 
+  validate() {
+    _.forEach(this.functions, (functionObj, functionName) => {
+      if (!_.isArray(functionObj.events)) {
+        throw new SError(`Events for "${functionName}" must be an array,` +
+                          ` not an ${typeof functionObj.events}`);
+      }
+    });
+
+    return this;
+  }
+
   update(data) {
     return _.merge(this, data);
   }

lib/classes/Service.test.js

@@ -392,36 +392,52 @@ describe('Service', () => {
         YAML.dump(serverlessYml));
 
       const serverless = new Serverless({ servicePath: tmpDirPath });
-      serviceInstance = new Service(serverless);
+      serverless.service = new Service(serverless);
+      serverless.variables.service = serverless.service;
 
-      return serviceInstance.load().then(() => {
-        expect(serverless.service.functions).to.deep.equal({});
+      return serverless.service.load().then(() => {
+        // if we reach this, then no error was thrown
+        // populate variables in service configuration
+        serverless.variables.populateService();
+
+        // validate the service configuration, now that variables are loaded
+        serviceInstance.validate();
+
+        expect(serviceInstance.functions.functionA.events).to.deep.equal({});
+      }).catch(() => {
+        // make assertion fail intentionally to let us know something is wrong
+        expect(1).to.equal(2);
       });
     });
 
-    it("should throw error if a function's event is not an array", () => {
+    it('should throw error if a function\'s event is not an array or a variable', () => {
       const SUtils = new Utils();
       const serverlessYml = {
         service: 'service-name',
         provider: 'aws',
         functions: {
           functionA: {
-            events: {},
+            events: 'not an array or a variable',
           },
         },
       };
       SUtils.writeFileSync(path.join(tmpDirPath, 'serverless.yml'),
         YAML.dump(serverlessYml));
 
       const serverless = new Serverless({ servicePath: tmpDirPath });
-      serviceInstance = new Service(serverless);
-
-      return serviceInstance.load().then(() => {
-        // if we reach this, then no error was thrown as expected
-        // so make assertion fail intentionally to let us know something is wrong
-        expect(1).to.equal(2);
-      }).catch(e => {
-        expect(e.name).to.be.equal('ServerlessError');
+      serverless.service = new Service(serverless);
+
+      return serverless.service.load().then(() => {
+        // validate the service configuration, now that variables are loaded
+        try {
+          serverless.service.validate();
+
+          // if we reach this, then no error was thrown as expected
+          // so make assertion fail intentionally to let us know something is wrong
+          expect(1).to.equal(2);
+        } catch (e) {
+          expect(e.name).to.be.equal('ServerlessError');
+        }
       });
     });