serverless/lib/plugins/aws/deploy/tests/uploadDeploymentPackage.js

'use strict';

const sinon = require('sinon');
const os = require('os');
const path = require('path');
const BbPromise = require('bluebird');
const expect = require('chai').expect;
const AwsDeploy = require('../index');
const Serverless = require('../../../../Serverless');

describe('uploadDeploymentPackage', () => {
  let serverless;
  let awsDeploy;

  beforeEach(() => {
    serverless = new Serverless();
    const options = {
      stage: 'dev',
      region: 'us-east-1',
    };
    awsDeploy = new AwsDeploy(serverless, options);
    awsDeploy.serverless.cli = new serverless.classes.CLI();
  });

  describe('#setServerlessDeploymentBucketName()', () => {
    it('should store the name of the Serverless deployment bucket in the "this" variable', () => {
      const getServerlessDeploymentBucketNameStub = sinon
        .stub(awsDeploy.sdk, 'getServerlessDeploymentBucketName')
        .returns(BbPromise.resolve('new-service-dev-us-east-1-12345678'));

      return awsDeploy.setServerlessDeploymentBucketName().then(() => {
        expect(awsDeploy.bucketName).to.equal('new-service-dev-us-east-1-12345678');
        expect(getServerlessDeploymentBucketNameStub.calledOnce).to.be.equal(true);
        expect(getServerlessDeploymentBucketNameStub
          .calledWith(awsDeploy.options.stage, awsDeploy.options.region));
        awsDeploy.sdk.getServerlessDeploymentBucketName.restore();
      });
    });
  });

  describe('#getServiceObjectsFromS3Bucket()', () => {
    it('should resolve if no service objects are found', () => {
      const serviceObjects = {
        Contents: [],
      };

      const listObjectsStub = sinon
        .stub(awsDeploy.sdk, 'request').returns(BbPromise.resolve(serviceObjects));

      return awsDeploy.getServiceObjectsFromS3Bucket().then(() => {
        expect(listObjectsStub.calledOnce).to.be.equal(true);
        expect(listObjectsStub.calledWith(awsDeploy.options.stage, awsDeploy.options.region));
        awsDeploy.sdk.request.restore();
      });
    });

    it('should return all to be removed service objects (except the last 4)', () => {
      const serviceObjects = {
        Contents: [
          {
            Key: 'first-service-1.zip',
          },
          {
            Key: 'first-service-8.zip',
          },
          {
            Key: 'first-service-2.zip',
          },
          {
            Key: 'first-service-5.zip',
          },
          {
            Key: 'first-service-6.zip',
          },
          {
            Key: 'first-service-4.zip',
          },
          {
            Key: 'first-service-7.zip',
          },
          {
            Key: 'first-service-3.zip',
          },
        ],
      };

      const listObjectsStub = sinon
        .stub(awsDeploy.sdk, 'request').returns(BbPromise.resolve(serviceObjects));

      return awsDeploy.getServiceObjectsFromS3Bucket().then((objectsToRemove) => {
        expect(objectsToRemove).to.not.include({ Key: 'first-service-5.zip' });
        expect(objectsToRemove).to.not.include({ Key: 'first-service-6.zip' });
        expect(objectsToRemove).to.not.include({ Key: 'first-service-7.zip' });
        expect(objectsToRemove).to.not.include({ Key: 'first-service-8.zip' });
        expect(listObjectsStub.calledOnce).to.be.equal(true);
        expect(listObjectsStub.calledWith(awsDeploy.options.stage, awsDeploy.options.region));
        awsDeploy.sdk.request.restore();
      });
    });

    it('should resolve if there are less than 4 service files available', () => {
      const serviceObjects = {
        Contents: [
          {
            Key: 'first-service-3.zip',
          },
          {
            Key: 'first-service-1.zip',
          },
          {
            Key: 'first-service-2.zip',
          },
        ],
      };

      const listObjectsStub = sinon
        .stub(awsDeploy.sdk, 'request').returns(BbPromise.resolve(serviceObjects));

      return awsDeploy.getServiceObjectsFromS3Bucket().then((objectsToRemove) => {
        expect(objectsToRemove).to.equal(undefined);
        expect(listObjectsStub.calledOnce).to.be.equal(true);
        expect(listObjectsStub.calledWith(awsDeploy.options.stage, awsDeploy.options.region));
        awsDeploy.sdk.request.restore();
      });
    });

    it('should resolve if there are exactly 4 service files available', () => {
      const serviceObjects = {
        Contents: [
          {
            Key: 'first-service-1.zip',
          },
          {
            Key: 'first-service-2.zip',
          },
          {
            Key: 'first-service-4.zip',
          },
          {
            Key: 'first-service-3.zip',
          },
        ],
      };

      const listObjectsStub = sinon
        .stub(awsDeploy.sdk, 'request').returns(BbPromise.resolve(serviceObjects));

      return awsDeploy.getServiceObjectsFromS3Bucket().then((objectsToRemove) => {
        expect(objectsToRemove).to.equal(undefined);
        expect(listObjectsStub.calledOnce).to.be.equal(true);
        expect(listObjectsStub.calledWith(awsDeploy.options.stage, awsDeploy.options.region));
        awsDeploy.sdk.request.restore();
      });
    });
  });

  describe('#cleanupS3Bucket()', () => {
    let deleteObjectsStub;

    beforeEach(() => {
      deleteObjectsStub = sinon
        .stub(awsDeploy.sdk, 'request').returns(BbPromise.resolve());
    });

    it('should resolve if no service objects are found in the S3 bucket', () => awsDeploy
      .cleanupS3Bucket().then(() => {
        expect(deleteObjectsStub.calledOnce).to.be.equal(false);
        awsDeploy.sdk.request.restore();
      })
    );

    it('should remove all old service files from the S3 bucket if available', () => {
      const serviceObjects = [{ Key: 'first-service' }, { Key: 'second-service' }];

      return awsDeploy.cleanupS3Bucket(serviceObjects).then(() => {
        expect(deleteObjectsStub.calledOnce).to.be.equal(true);
        expect(deleteObjectsStub.calledWith(awsDeploy.options.stage, awsDeploy.options.region));
        awsDeploy.sdk.request.restore();
      });
    });
  });

  describe('#uploadPackageToS3Bucket()', () => {
    it('it should upload whole service package', () => {
      const artifactFilePath = 'artifact.zip';
      awsDeploy.serverless.service.package.individually = false;
      awsDeploy.serverless.service.package.artifact = artifactFilePath;

      const uploadZipFileToS3BucketStub = sinon
        .stub(awsDeploy, 'uploadZipFileToS3Bucket').returns(BbPromise.resolve());

      return awsDeploy.uploadPackageToS3Bucket().then(() => {
        expect(uploadZipFileToS3BucketStub.calledOnce).to.be.equal(true);
        expect(uploadZipFileToS3BucketStub.args[0][0]).to.be.equal(artifactFilePath);
        awsDeploy.uploadZipFileToS3Bucket.restore();
      });
    });

    it('it should upload individual function packages', () => {
      const artifactFilePath = 'artifact.zip';
      awsDeploy.serverless.service.package.individually = true;
      awsDeploy.serverless.service.functions = {
        'test-one': {
          name: 'test-one',
          artifact: artifactFilePath,
        },
      };

      const uploadZipFileToS3BucketStub = sinon
        .stub(awsDeploy, 'uploadZipFileToS3Bucket').returns(BbPromise.resolve());

      return awsDeploy.uploadPackageToS3Bucket().then(() => {
        expect(uploadZipFileToS3BucketStub.calledOnce).to.be.equal(true);
        expect(uploadZipFileToS3BucketStub.args[0][0]).to.be.equal(artifactFilePath);
        awsDeploy.uploadZipFileToS3Bucket.restore();
      });
    });
  });

  describe('#uploadZipFileToS3Bucket()', () => {
    it('should upload the zip file to the S3 bucket', () => {
      const tmpDirPath = path.join(os.tmpdir(), (new Date()).getTime().toString());
      const artifactFilePath = path.join(tmpDirPath, 'artifact.zip');
      serverless.utils.writeFileSync(artifactFilePath, 'artifact.zip file content');

      const putObjectStub = sinon
        .stub(awsDeploy.sdk, 'request').returns(BbPromise.resolve());

      return awsDeploy.uploadZipFileToS3Bucket(artifactFilePath).then(() => {
        expect(putObjectStub.calledOnce).to.be.equal(true);
        expect(putObjectStub.calledWith(awsDeploy.options.stage, awsDeploy.options.region));
        awsDeploy.sdk.request.restore();
      });
    });
  });

  describe('#uploadDeploymentPackage()', () => {
    it('should resolve if no deploy', () => {
      awsDeploy.options.noDeploy = true;

      const setServerlessDeploymentBucketNameStub = sinon
        .stub(awsDeploy, 'setServerlessDeploymentBucketName').returns(BbPromise.resolve());
      const getServiceObjectsFromS3BucketStub = sinon
        .stub(awsDeploy, 'getServiceObjectsFromS3Bucket').returns(BbPromise.resolve());
      const cleanupS3BucketStub = sinon
        .stub(awsDeploy, 'cleanupS3Bucket').returns(BbPromise.resolve());
      const uploadZipFileToS3BucketStub = sinon
        .stub(awsDeploy, 'uploadZipFileToS3Bucket').returns(BbPromise.resolve());

      return awsDeploy.uploadDeploymentPackage().then(() => {
        expect(setServerlessDeploymentBucketNameStub.called).to.be.equal(false);
        expect(getServiceObjectsFromS3BucketStub.called).to.be.equal(false);
        expect(cleanupS3BucketStub.called).to.be.equal(false);
        expect(uploadZipFileToS3BucketStub.called).to.be.equal(false);

        awsDeploy.setServerlessDeploymentBucketName.restore();
        awsDeploy.getServiceObjectsFromS3Bucket.restore();
        awsDeploy.cleanupS3Bucket.restore();
        awsDeploy.uploadZipFileToS3Bucket.restore();
      });
    });

    it('should run promise chain in order', () => {
      const setServerlessDeploymentBucketNameStub = sinon
        .stub(awsDeploy, 'setServerlessDeploymentBucketName').returns(BbPromise.resolve());
      const getServiceObjectsFromS3BucketStub = sinon
        .stub(awsDeploy, 'getServiceObjectsFromS3Bucket').returns(BbPromise.resolve());
      const cleanupS3BucketStub = sinon
        .stub(awsDeploy, 'cleanupS3Bucket').returns(BbPromise.resolve());
      const uploadZipFileToS3BucketStub = sinon
        .stub(awsDeploy, 'uploadZipFileToS3Bucket').returns(BbPromise.resolve());

      return awsDeploy.uploadDeploymentPackage().then(() => {
        expect(setServerlessDeploymentBucketNameStub.calledOnce).to.be.equal(true);
        expect(getServiceObjectsFromS3BucketStub.calledAfter(setServerlessDeploymentBucketNameStub))
          .to.be.equal(true);
        expect(cleanupS3BucketStub.calledAfter(getServiceObjectsFromS3BucketStub))
          .to.be.equal(true);
        expect(uploadZipFileToS3BucketStub.calledAfter(cleanupS3BucketStub)).to.be.equal(true);

        awsDeploy.setServerlessDeploymentBucketName.restore();
        awsDeploy.getServiceObjectsFromS3Bucket.restore();
        awsDeploy.cleanupS3Bucket.restore();
        awsDeploy.uploadZipFileToS3Bucket.restore();
      });
    });
  });
});