Add GooglePackage plugin

index.js

@@ -7,6 +7,7 @@ whole provider implementation.
 */
 
 const GoogleProvider = require('./provider/googleProvider');
+const GooglePackage = require('./package/googlePackage');
 const GoogleDeploy = require('./deploy/googleDeploy');
 const GoogleRemove = require('./remove/googleRemove');
 const GoogleInvoke = require('./invoke/googleInvoke');
@@ -19,6 +20,7 @@ class GoogleIndex {
     this.options = options;
 
     this.serverless.pluginManager.addPlugin(GoogleProvider);
+    this.serverless.pluginManager.addPlugin(GooglePackage);
     this.serverless.pluginManager.addPlugin(GoogleDeploy);
     this.serverless.pluginManager.addPlugin(GoogleRemove);
     this.serverless.pluginManager.addPlugin(GoogleInvoke);

index.test.js

@@ -2,6 +2,7 @@
 
 const GoogleIndex = require('./index');
 const GoogleProvider = require('./provider/googleProvider');
+const GooglePackage = require('./package/googlePackage');
 const GoogleDeploy = require('./deploy/googleDeploy');
 const GoogleRemove = require('./remove/googleRemove');
 const GoogleInvoke = require('./invoke/googleInvoke');
@@ -36,6 +37,7 @@ describe('GoogleIndex', () => {
       const addedPlugins = serverless.plugins;
 
       expect(addedPlugins).toContain(GoogleProvider);
+      expect(addedPlugins).toContain(GooglePackage);
       expect(addedPlugins).toContain(GoogleDeploy);
       expect(addedPlugins).toContain(GoogleRemove);
       expect(addedPlugins).toContain(GoogleInvoke);

package.json

@@ -27,6 +27,7 @@
     "async": "^2.1.4",
     "bluebird": "^3.4.7",
     "chalk": "^1.1.3",
+    "fs-extra": "^3.0.1",
     "googleapis": "^16.1.0",
     "lodash": "^4.17.4"
   },

package/googlePackage.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const BbPromise = require('bluebird');
+
+const cleanupServerlessDir = require('./lib/cleanupServerlessDir');
+const validate = require('../shared/validate');
+const utils = require('../shared/utils');
+const setDeploymentBucketName = require('../shared/setDeploymentBucketName');
+const prepareDeployment = require('./lib/prepareDeployment');
+const saveCreateTemplateFile = require('./lib/writeFilesToDisk');
+const mergeServiceResources = require('./lib/mergeServiceResources');
+const generateArtifactDirectoryName = require('./lib/generateArtifactDirectoryName');
+const compileFunctions = require('./lib/compileFunctions');
+const saveUpdateTemplateFile = require('./lib/writeFilesToDisk');
+
+class GooglePackage {
+  constructor(serverless, options) {
+    this.serverless = serverless;
+    this.options = options;
+    this.provider = this.serverless.getProvider('google');
+
+    Object.assign(
+      this,
+      cleanupServerlessDir,
+      validate,
+      utils,
+      setDeploymentBucketName,
+      prepareDeployment,
+      saveCreateTemplateFile,
+      generateArtifactDirectoryName,
+      compileFunctions,
+      mergeServiceResources,
+      saveUpdateTemplateFile);
+
+    this.hooks = {
+      'package:cleanup': () => BbPromise.bind(this)
+        .then(this.cleanupServerlessDir),
+
+      'before:package:initialize': () => BbPromise.bind(this)
+        .then(this.validate)
+        .then(this.setDefaults),
+
+      'package:initialize': () => BbPromise.bind(this)
+        .then(this.setDeploymentBucketName)
+        .then(this.prepareDeployment)
+        .then(this.saveCreateTemplateFile),
+
+      'before:package:compileFunctions': () => BbPromise.bind(this)
+        .then(this.generateArtifactDirectoryName),
+
+      'package:compileFunctions': () => BbPromise.bind(this)
+        .then(this.compileFunctions),
+
+      'package:finalize': () => BbPromise.bind(this)
+        .then(this.mergeServiceResources)
+        .then(this.saveUpdateTemplateFile),
+    };
+  }
+}
+
+module.exports = GooglePackage;

package/googlePackage.test.js

@@ -0,0 +1,121 @@
+'use strict';
+
+const sinon = require('sinon');
+const BbPromise = require('bluebird');
+
+const GoogleProvider = require('../provider/googleProvider');
+const GooglePackage = require('./googlePackage');
+const Serverless = require('../test/serverless');
+
+describe('GooglePackage', () => {
+  let serverless;
+  let options;
+  let googlePackage;
+
+  beforeEach(() => {
+    serverless = new Serverless();
+    options = {
+      stage: 'my-stage',
+      region: 'my-region',
+    };
+    serverless.setProvider('google', new GoogleProvider(serverless));
+    googlePackage = new GooglePackage(serverless, options);
+  });
+
+  describe('#constructor()', () => {
+    it('should set the serverless instance', () => {
+      expect(googlePackage.serverless).toEqual(serverless);
+    });
+
+    it('should set options if provided', () => {
+      expect(googlePackage.options).toEqual(options);
+    });
+
+    it('should make the provider accessible', () => {
+      expect(googlePackage.provider).toBeInstanceOf(GoogleProvider);
+    });
+
+    describe('hooks', () => {
+      let cleanupServerlessDirStub;
+      let validateStub;
+      let setDefaultsStub;
+      let setDeploymentBucketNameStub;
+      let prepareDeploymentStub;
+      let saveCreateTemplateFileStub;
+      let generateArtifactDirectoryNameStub;
+      let compileFunctionsStub;
+      let mergeServiceResourcesStub;
+      let saveUpdateTemplateFileStub;
+
+      beforeEach(() => {
+        cleanupServerlessDirStub = sinon.stub(googlePackage, 'cleanupServerlessDir')
+          .returns(BbPromise.resolve());
+        validateStub = sinon.stub(googlePackage, 'validate')
+          .returns(BbPromise.resolve());
+        setDefaultsStub = sinon.stub(googlePackage, 'setDefaults')
+          .returns(BbPromise.resolve());
+        setDeploymentBucketNameStub = sinon.stub(googlePackage, 'setDeploymentBucketName')
+          .returns(BbPromise.resolve());
+        prepareDeploymentStub = sinon.stub(googlePackage, 'prepareDeployment')
+          .returns(BbPromise.resolve());
+        saveCreateTemplateFileStub = sinon.stub(googlePackage, 'saveCreateTemplateFile')
+          .returns(BbPromise.resolve());
+        generateArtifactDirectoryNameStub = sinon.stub(googlePackage, 'generateArtifactDirectoryName')
+          .returns(BbPromise.resolve());
+        compileFunctionsStub = sinon.stub(googlePackage, 'compileFunctions')
+          .returns(BbPromise.resolve());
+        mergeServiceResourcesStub = sinon.stub(googlePackage, 'mergeServiceResources')
+          .returns(BbPromise.resolve());
+        saveUpdateTemplateFileStub = sinon.stub(googlePackage, 'saveUpdateTemplateFile')
+          .returns(BbPromise.resolve());
+      });
+
+      afterEach(() => {
+        googlePackage.cleanupServerlessDir.restore();
+        googlePackage.validate.restore();
+        googlePackage.setDefaults.restore();
+        googlePackage.setDeploymentBucketName.restore();
+        googlePackage.prepareDeployment.restore();
+        googlePackage.saveCreateTemplateFile.restore();
+        googlePackage.generateArtifactDirectoryName.restore();
+        googlePackage.compileFunctions.restore();
+        googlePackage.mergeServiceResources.restore();
+        googlePackage.saveUpdateTemplateFile.restore();
+      });
+
+      it('should run "package:cleanup" promise chain', () => googlePackage
+        .hooks['package:cleanup']().then(() => {
+          expect(cleanupServerlessDirStub.calledOnce).toEqual(true);
+        }));
+
+      it('should run "before:package:initialize" promise chain', () => googlePackage
+        .hooks['before:package:initialize']().then(() => {
+          expect(validateStub.calledOnce).toEqual(true);
+          expect(setDefaultsStub.calledAfter(validateStub)).toEqual(true);
+        }));
+
+      it('should run "package:initialize" promise chain', () => googlePackage
+        .hooks['package:initialize']().then(() => {
+          expect(setDeploymentBucketNameStub.calledOnce).toEqual(true);
+          expect(prepareDeploymentStub.calledAfter(setDeploymentBucketNameStub)).toEqual(true);
+          expect(saveCreateTemplateFileStub.calledAfter(prepareDeploymentStub)).toEqual(true);
+        }));
+
+      it('should run "before:package:compileFunctions" promise chain', () => googlePackage
+        .hooks['before:package:compileFunctions']().then(() => {
+          expect(generateArtifactDirectoryNameStub.calledOnce).toEqual(true);
+        }));
+
+      it('should run "package:compileFunctions" promise chain', () => googlePackage
+        .hooks['package:compileFunctions']().then(() => {
+          expect(compileFunctionsStub.calledOnce).toEqual(true);
+        }));
+
+      it('should run "package:finalize" promise chain', () => googlePackage
+        .hooks['package:finalize']().then(() => {
+          expect(mergeServiceResourcesStub.calledOnce).toEqual(true);
+          expect(saveUpdateTemplateFileStub.calledAfter(mergeServiceResourcesStub)).toEqual(true);
+        }));
+    });
+  });
+});

package/lib/cleanupServerlessDir.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const BbPromise = require('bluebird');
+const path = require('path');
+const fse = require('fs-extra');
+
+module.exports = {
+  cleanupServerlessDir() {
+    if (this.serverless.config.servicePath) {
+      const serverlessDirPath = path.join(this.serverless.config.servicePath, '.serverless');
+
+      if (fse.pathExistsSync(serverlessDirPath)) {
+        fse.removeSync(serverlessDirPath);
+      }
+    }
+
+    return BbPromise.resolve();
+  },
+};

package/lib/cleanupServerlessDir.test.js

@@ -0,0 +1,77 @@
+'use strict';
+
+const path = require('path');
+
+const sinon = require('sinon');
+const fse = require('fs-extra');
+
+const GoogleProvider = require('../../provider/googleProvider');
+const GooglePackage = require('../googlePackage');
+const Serverless = require('../../test/serverless');
+
+describe('CleanupServerlessDir', () => {
+  let serverless;
+  let googlePackage;
+  let pathExistsSyncStub;
+  let removeSyncStub;
+
+  beforeEach(() => {
+    serverless = new Serverless();
+    serverless.service.service = 'my-service';
+    serverless.config = {
+      servicePath: false,
+    };
+    serverless.setProvider('google', new GoogleProvider(serverless));
+    const options = {
+      stage: 'dev',
+      region: 'us-central1',
+    };
+    googlePackage = new GooglePackage(serverless, options);
+    pathExistsSyncStub = sinon.stub(fse, 'pathExistsSync');
+    removeSyncStub = sinon.stub(fse, 'removeSync').returns();
+  });
+
+  afterEach(() => {
+    fse.pathExistsSync.restore();
+    fse.removeSync.restore();
+  });
+
+  describe('#cleanupServerlessDir()', () => {
+    it('should resolve if no servicePath is given', () => {
+      googlePackage.serverless.config.servicePath = false;
+
+      pathExistsSyncStub.returns();
+
+      return googlePackage.cleanupServerlessDir().then(() => {
+        expect(pathExistsSyncStub.calledOnce).toEqual(false);
+        expect(removeSyncStub.calledOnce).toEqual(false);
+      });
+    });
+
+    it('should remove the .serverless directory if it exists', () => {
+      const serviceName = googlePackage.serverless.service.service;
+      googlePackage.serverless.config.servicePath = serviceName;
+      const serverlessDirPath = path.join(serviceName, '.serverless');
+
+      pathExistsSyncStub.returns(true);
+
+      return googlePackage.cleanupServerlessDir().then(() => {
+        expect(pathExistsSyncStub.calledWithExactly(serverlessDirPath)).toEqual(true);
+        expect(removeSyncStub.calledWithExactly(serverlessDirPath)).toEqual(true);
+      });
+    });
+
+    it('should not remove the .serverless directory if does not exist', () => {
+      const serviceName = googlePackage.serverless.service.service;
+      googlePackage.serverless.config.servicePath = serviceName;
+      const serverlessDirPath = path.join(serviceName, '.serverless');
+
+      pathExistsSyncStub.returns(false);
+
+      return googlePackage.cleanupServerlessDir().then(() => {
+        expect(pathExistsSyncStub.calledWithExactly(serverlessDirPath)).toEqual(true);
+        expect(removeSyncStub.calledWithExactly(serverlessDirPath)).toEqual(false);
+      });
+    });
+  });
+});