aws-spa/lib/acm.spec.js

A no-brainer script to deploy a single page app on AWS

"use strict";

var _acm = require("./acm");

var _awsServices = require("./aws-services");

var _testHelper = require("./test-helper");

jest.mock('inquirer', () => {
  return {
    __esModule: true,
    default: {
      prompt: jest.fn()
    }
  };
});
describe('acm', () => {
  describe('getCertificateARN', () => {
    const listCertificatesMock = jest.spyOn(_awsServices.acm, 'listCertificates');
    const describeCertificateMock = jest.spyOn(_awsServices.acm, 'describeCertificate');
    const waitForMock = jest.spyOn(_awsServices.waitUntil, 'certificateValidated');
    afterEach(() => {
      listCertificatesMock.mockReset();
      describeCertificateMock.mockReset();
      waitForMock.mockReset();
    });
    it('should get the list of certificates (1 page)', async () => {
      listCertificatesMock.mockReturnValue((0, _testHelper.awsResolve)({
        CertificateSummaryList: [{
          CertificateArn: 'arn:aws:acm:us-east-1:123456789:certificate/xxx'
        }]
      }));
      describeCertificateMock.mockReturnValue((0, _testHelper.awsResolve)({
        Certificate: {
          Status: 'ISSUED',
          DomainName: '*.example.com',
          CertificateArn: 'arn:aws:acm:us-east-1:123456789:certificate/xxx'
        }
      }));
      const arn = await (0, _acm.getCertificateARN)('hello.example.com');
      expect(arn).toEqual('arn:aws:acm:us-east-1:123456789:certificate/xxx');
      expect(listCertificatesMock).toHaveBeenCalledTimes(1);
    });
    it('should get the list of certificates (2 page)', async () => {
      listCertificatesMock.mockReturnValueOnce((0, _testHelper.awsResolve)({
        CertificateSummaryList: [{
          CertificateArn: 'arn:aws:acm:us-east-1:123456789:certificate/xxx'
        }],
        NextToken: 'xxx'
      })).mockReturnValueOnce((0, _testHelper.awsResolve)({
        CertificateSummaryList: [{
          CertificateArn: 'arn:aws:acm:us-east-1:123456789:certificate/yyy'
        }]
      }));
      describeCertificateMock.mockReturnValueOnce((0, _testHelper.awsResolve)({
        Certificate: {
          Status: 'ISSUED',
          DomainName: 'hello2.example.com',
          CertificateArn: 'arn:aws:acm:us-east-1:123456789:certificate/xxx'
        }
      })).mockReturnValueOnce((0, _testHelper.awsResolve)({
        Certificate: {
          Status: 'ISSUED',
          DomainName: '*.example.com',
          CertificateArn: 'arn:aws:acm:us-east-1:123456789:certificate/yyy'
        }
      }));
      const arn = await (0, _acm.getCertificateARN)('hello.example.com');
      expect(arn).toEqual('arn:aws:acm:us-east-1:123456789:certificate/yyy');
      expect(listCertificatesMock).toHaveBeenCalledTimes(2);
    });
    it('should check alternative names', async () => {
      listCertificatesMock.mockReturnValue((0, _testHelper.awsResolve)({
        CertificateSummaryList: [{
          CertificateArn: 'arn:aws:acm:us-east-1:123456789:certificate/xxx'
        }]
      }));
      describeCertificateMock.mockReturnValue((0, _testHelper.awsResolve)({
        Certificate: {
          DomainName: 'example.com',
          Status: 'ISSUED',
          CertificateArn: 'arn:aws:acm:us-east-1:123456789:certificate/xxx',
          SubjectAlternativeNames: ['staging.example.com', '*.example.com']
        }
      }));
      const arn = await (0, _acm.getCertificateARN)('hello.example.com');
      expect(arn).toEqual('arn:aws:acm:us-east-1:123456789:certificate/xxx');
    });
    it('should ignored non issued or pending certificates', async () => {
      listCertificatesMock.mockReturnValue((0, _testHelper.awsResolve)({
        CertificateSummaryList: [{
          CertificateArn: 'arn:aws:acm:us-east-1:123456789:certificate/xxx'
        }]
      }));
      describeCertificateMock.mockReturnValue((0, _testHelper.awsResolve)({
        Certificate: {
          DomainName: '*.example.com',
          Status: 'REVOKED',
          CertificateArn: 'arn:aws:acm:us-east-1:123456789:certificate/xxx'
        }
      }));
      const arn = await (0, _acm.getCertificateARN)('hello.example.com');
      expect(arn).toEqual(null);
    });
    it('should check return null if no certificate is found', async () => {
      listCertificatesMock.mockReturnValue((0, _testHelper.awsResolve)({
        CertificateSummaryList: [{
          CertificateArn: 'arn:aws:acm:us-east-1:123456789:certificate/xxx'
        }]
      }));
      describeCertificateMock.mockReturnValue((0, _testHelper.awsResolve)({
        Certificate: {
          DomainName: 'example.com',
          Status: 'ISSUED',
          CertificateArn: 'arn:aws:acm:us-east-1:123456789:certificate/xxx'
        }
      }));
      const arn = await (0, _acm.getCertificateARN)('hello.example.com');
      expect(arn).toEqual(null);
    });
    it('should use an ISSUED certificate before a PENDING_VALIDATION certificate', async () => {
      listCertificatesMock.mockReturnValue((0, _testHelper.awsResolve)({
        CertificateSummaryList: [{
          CertificateArn: 'arn:aws:acm:us-east-1:123456789:certificate/pending'
        }, {
          CertificateArn: 'arn:aws:acm:us-east-1:123456789:certificate/issued'
        }]
      }));
      describeCertificateMock.mockReturnValueOnce((0, _testHelper.awsResolve)({
        Certificate: {
          DomainName: '*.example.com',
          Status: 'PENDING_VALIDATION',
          CertificateArn: 'arn:aws:acm:us-east-1:123456789:certificate/pending'
        }
      })).mockReturnValueOnce((0, _testHelper.awsResolve)({
        Certificate: {
          DomainName: 'hello.example.com',
          Status: 'ISSUED',
          CertificateArn: 'arn:aws:acm:us-east-1:123456789:certificate/issued'
        }
      }));
      const arn = await (0, _acm.getCertificateARN)('hello.example.com');
      expect(arn).toEqual('arn:aws:acm:us-east-1:123456789:certificate/issued');
    });
    it('should waitFor a PENDING_VALIDATION certificate', async () => {
      listCertificatesMock.mockReturnValue((0, _testHelper.awsResolve)({
        CertificateSummaryList: [{
          CertificateArn: 'arn:aws:acm:us-east-1:123456789:certificate/pending'
        }]
      }));
      describeCertificateMock.mockReturnValue((0, _testHelper.awsResolve)({
        Certificate: {
          DomainName: '*.example.com',
          Status: 'PENDING_VALIDATION',
          CertificateArn: 'arn:aws:acm:us-east-1:123456789:certificate/pending'
        }
      }));
      waitForMock.mockReturnValue((0, _testHelper.awsResolve)());
      const arn = await (0, _acm.getCertificateARN)('hello.example.com');
      expect(arn).toEqual('arn:aws:acm:us-east-1:123456789:certificate/pending');
      expect(waitForMock).toHaveBeenCalledTimes(1);
    });
  });
  describe('domainNameMatch', () => {
    it('should handle exact domain name match', () => {
      expect((0, _acm.domainNameMatch)('hello.example.com', 'hello.example.com')).toEqual(true);
    });
    it('should handle wildcare domain name match', () => {
      expect((0, _acm.domainNameMatch)('*.example.com', 'hello.example.com')).toEqual(true);
    });
    it('should not match different domain name', () => {
      expect((0, _acm.domainNameMatch)('*.example.com', 'hello.example2.com')).toEqual(false);
    });
    it('should not match different domain name', () => {
      expect((0, _acm.domainNameMatch)('hello.example.com', 'hello2.example.com')).toEqual(false);
    });
  });
  describe('createCertificate', () => {
    const requestCertificateMock = jest.spyOn(_awsServices.acm, 'requestCertificate');
    const waitForMock = jest.spyOn(_awsServices.waitUntil, 'certificateValidated');
    const describeCertificateMock = jest.spyOn(_awsServices.acm, 'describeCertificate');
    const changeResourceRecordSetsMock = jest.spyOn(_awsServices.route53, 'changeResourceRecordSets');
    afterEach(() => {
      requestCertificateMock.mockReset();
      waitForMock.mockReset();
      describeCertificateMock.mockReset();
      changeResourceRecordSetsMock.mockReset();
    });
    it('should request a certificate', async () => {
      requestCertificateMock.mockReturnValue((0, _testHelper.awsResolve)({
        CertificateArn: 'arn:aws:acm:us-east-1:123456789:certificate/xxx'
      }));
      describeCertificateMock.mockReturnValue((0, _testHelper.awsResolve)({
        Certificate: {
          DomainValidationOptions: [{
            DomainName: 'hello.example.com',
            ResourceRecord: {
              Name: '_sOmESTrAnGeChArAcTeRs.example.com',
              Type: 'CNAME',
              Value: '_sOmESTrAnGeChArAcTeRs'
            }
          }]
        }
      }));
      changeResourceRecordSetsMock.mockReturnValue((0, _testHelper.awsResolve)());
      waitForMock.mockReturnValue((0, _testHelper.awsResolve)());
      await (0, _acm.createCertificate)('hello.example.com', 'hostedZoneId', 0);
      expect(requestCertificateMock).toHaveBeenCalledTimes(1);
      const requestCertificateParams = requestCertificateMock.mock.calls[0][0];
      expect(requestCertificateParams.DomainName).toEqual('hello.example.com');
      expect(requestCertificateParams.ValidationMethod).toEqual('DNS');
      expect(waitForMock).toHaveBeenCalledWith(expect.anything(), {
        CertificateArn: 'arn:aws:acm:us-east-1:123456789:certificate/xxx'
      });
      expect(changeResourceRecordSetsMock).toHaveBeenCalledTimes(1);
      const changeResourceRecordSetsMockParams = changeResourceRecordSetsMock.mock.calls[0][0];
      expect(changeResourceRecordSetsMockParams.ChangeBatch.Changes[0].ResourceRecordSet.Name).toEqual('_sOmESTrAnGeChArAcTeRs.example.com');
      expect(changeResourceRecordSetsMockParams.ChangeBatch.Changes[0].ResourceRecordSet.Type).toEqual('CNAME');
      expect(changeResourceRecordSetsMockParams.ChangeBatch.Changes[0].ResourceRecordSet.ResourceRecords[0].Value).toEqual('_sOmESTrAnGeChArAcTeRs');
    });
  });
});