@mapbox/cloudfriend 9.2.0 → 9.2.1

package/test/shortcuts.test.js

@@ -3,7 +3,6 @@
 const cp = require('child_process');
 const path = require('path');
 const fs = require('fs');
-const test = require('tape');
 const cf = require('..');
 const fixtures = require('./fixtures/shortcuts');
 const util = require('util');
@@ -13,7 +12,7 @@ const update = !!process.env.UPDATE;
 
 const noUndefined = (template) => JSON.parse(JSON.stringify(template));
 
-test('[shortcuts] fixture validation', async (assert) => {
+describe('[shortcuts] fixture validation', () => {
   // Runs cfn-lint, ignoring "warnings". Install via pip or Homebrew to run these
   // tests locally.
   const cfnLint = (filepath) => new Promise((resolve, reject) => {
@@ -27,36 +26,25 @@ test('[shortcuts] fixture validation', async (assert) => {
     .readdirSync(path.join(__dirname, 'fixtures', 'shortcuts'))
     .filter((filename) => path.extname(filename) === '.json');
 
-  while (toValidate.length) {
-    const filename = toValidate.shift();
+  test.each(toValidate)('%s fixture passes validation', async (filename) => {
     await Promise.all([
-      cfnLint(path.join(__dirname, 'fixtures', 'shortcuts', filename))
-        .then(() => assert.pass(`${filename} fixture passed validation`))
-        .catch((err) => {
-          assert.fail(`${filename} fixture fails validation`);
-          console.log(err.message);
-        }),
+      cfnLint(path.join(__dirname, 'fixtures', 'shortcuts', filename)),
       sleep(1000)
     ]);
-  }
-
-  assert.end();
+  });
 });
 
-test('[shortcuts] lambda', (assert) => {
-  assert.throws(
-    () => new cf.shortcuts.Lambda(),
-    'Options required',
-    'throws without options'
-  );
-  assert.throws(
-    () => new cf.shortcuts.Lambda({}),
-    /You must provide a LogicalName, and Code/,
-    'throws without required parameters'
-  );
+describe('[shortcuts] lambda', () => {
+  test('throws without options', () => {
+    expect(() => new cf.shortcuts.Lambda()).toThrow('Options required');
+  });
+
+  test('throws without required parameters', () => {
+    expect(() => new cf.shortcuts.Lambda({})).toThrow(/You must provide a LogicalName, and Code/);
+  });
 
-  assert.throws(
-    () => new cf.shortcuts.Lambda({
+  test('throws for RoleArn and Statements both provided', () => {
+    expect(() => new cf.shortcuts.Lambda({
       LogicalName: 'MyLambda',
       Code: {
         S3Bucket: 'my-code-bucket',
@@ -68,469 +56,400 @@ test('[shortcuts] lambda', (assert) => {
         Action: 's3:GetObject',
         Resource: 'arn:aws:s3:::my-bucket/*'
       }]
-    }),
-    /You cannot specify both Statements and a RoleArn/,
-    'throws for RoleArn and Statements both provided'
-  );
-
-  let lambda = new cf.shortcuts.Lambda({
-    LogicalName: 'MyLambda',
-    Code: {
-      S3Bucket: 'my-code-bucket',
-      S3Key: 'path/to/code.zip'
-    }
+    })).toThrow(/You cannot specify both Statements and a RoleArn/);
   });
 
-  let template = cf.merge(lambda);
-  if (update) fixtures.update('lambda-defaults', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('lambda-defaults'),
-    'expected resources generated using all default values'
-  );
+  test('expected resources generated using all default values', () => {
+    const lambda = new cf.shortcuts.Lambda({
+      LogicalName: 'MyLambda',
+      Code: {
+        S3Bucket: 'my-code-bucket',
+        S3Key: 'path/to/code.zip'
+      }
+    });
 
-  const lambdaWithRetain = new cf.shortcuts.Lambda({
-    LogicalName: 'MyLambda',
-    Code: { S3Bucket: 'my-code-bucket', S3Key: 'path/to/code.zip' },
-    LogPolicyDeletionPolicy: 'Retain'
+    const template = cf.merge(lambda);
+    if (update) fixtures.update('lambda-defaults', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('lambda-defaults'));
   });
-  const templateWithRetain = cf.merge(lambdaWithRetain);
-  assert.equal(
-    templateWithRetain.Resources.MyLambdaLogPolicy.DeletionPolicy,
-    'Retain',
-    'LogPolicyDeletionPolicy=Retain sets DeletionPolicy on IAM Policy resource'
-  );
 
-  lambda = new cf.shortcuts.Lambda({
-    LogicalName: 'MyLambda',
-    Code: {
-      ImageUri: 'MyImage'
-    }
+  test('LogPolicyDeletionPolicy=Retain sets DeletionPolicy on IAM Policy resource', () => {
+    const lambdaWithRetain = new cf.shortcuts.Lambda({
+      LogicalName: 'MyLambda',
+      Code: { S3Bucket: 'my-code-bucket', S3Key: 'path/to/code.zip' },
+      LogPolicyDeletionPolicy: 'Retain'
+    });
+    const templateWithRetain = cf.merge(lambdaWithRetain);
+    expect(templateWithRetain.Resources.MyLambdaLogPolicy.DeletionPolicy).toBe('Retain');
   });
 
-  template = cf.merge(lambda);
-  if (update) fixtures.update('lambda-docker', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('lambda-docker'),
-    'expected resources generated using all default values and a docker image'
-  );
+  test('expected resources generated using all default values and a docker image', () => {
+    const lambda = new cf.shortcuts.Lambda({
+      LogicalName: 'MyLambda',
+      Code: {
+        ImageUri: 'MyImage'
+      }
+    });
 
-  lambda = new cf.shortcuts.Lambda({
-    LogicalName: 'MyLambda',
-    Code: {
-      ZipFile: 'fake code'
-    }
+    const template = cf.merge(lambda);
+    if (update) fixtures.update('lambda-docker', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('lambda-docker'));
   });
 
-  template = cf.merge(lambda);
-  if (update) fixtures.update('lambda-zipfile', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('lambda-zipfile'),
-    'expected resources generated using all default values and inline code'
-  );
+  test('expected resources generated using all default values and inline code', () => {
+    const lambda = new cf.shortcuts.Lambda({
+      LogicalName: 'MyLambda',
+      Code: {
+        ZipFile: 'fake code'
+      }
+    });
 
-  lambda = new cf.shortcuts.Lambda({
-    LogicalName: 'MyLambda',
-    Code: {
-      S3Bucket: 'my-code-bucket',
-      S3Key: 'path/to/code.zip'
-    },
-    RoleArn: cf.getAtt('CustomLambdaRole', 'Arn')
-  });
-
-  template = cf.merge(lambda, {
-    Resources: {
-      'CustomLambdaRole': {
-        Type: 'AWS::IAM::Role',
-        Properties: {
-          AssumeRolePolicyDocument: {}
+    const template = cf.merge(lambda);
+    if (update) fixtures.update('lambda-zipfile', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('lambda-zipfile'));
+  });
+
+  test('expected resources generated if RoleArn provided', () => {
+    const lambda = new cf.shortcuts.Lambda({
+      LogicalName: 'MyLambda',
+      Code: {
+        S3Bucket: 'my-code-bucket',
+        S3Key: 'path/to/code.zip'
+      },
+      RoleArn: cf.getAtt('CustomLambdaRole', 'Arn')
+    });
+
+    const template = cf.merge(lambda, {
+      Resources: {
+        'CustomLambdaRole': {
+          Type: 'AWS::IAM::Role',
+          Properties: {
+            AssumeRolePolicyDocument: {}
+          }
         }
       }
-    }
+    });
+    if (update) fixtures.update('lambda-provided-role', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('lambda-provided-role'));
   });
-  if (update) fixtures.update('lambda-provided-role', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('lambda-provided-role'),
-    'expected resources generated if RoleArn provided'
-  );
 
-  lambda = new cf.shortcuts.Lambda({
-    LogicalName: 'MyLambda',
-    Code: {
-      S3Bucket: 'my-code-bucket',
-      S3Key: 'path/to/code.zip'
-    },
-    DeadLetterConfig: {
-      TargetArn: 'arn:aws:sqs:us-east-1:123456789012:queue/fake'
-    },
-    Description: 'my description',
-    Environment: { Variables: { MyCoolEnv: 'a' } },
-    FunctionName: 'my-function',
-    Handler: 'index.something',
-    KmsKeyArn: 'arn:aws:kms:us-east-1:123456789012:key/fake',
-    Layers: ['arn:aws:lambda:us-east-2:590474943231:layer:AWS-Parameters-and-Secrets-Lambda-Extension:4'],
-    MemorySize: 512,
-    ReservedConcurrentExecutions: 10,
-    Runtime: 'nodejs22.x',
-    Tags: [{ Key: 'a', Value: 'b' }],
-    Timeout: 30,
-    TracingConfig: { Mode: 'Active' },
-    VpcConfig: {
-      SecurityGroupIds: ['sg-12345678'],
-      SubnetIds: ['fake']
-    },
-    Condition: 'Always',
-    DependsOn: 'AnotherThing',
-    Statement: [
-      {
-        Effect: 'Allow',
-        Action: 's3:GetObject',
-        Resource: 'arn:aws:s3:::fake/data'
-      }
-    ],
-    AlarmName: 'my-alarm',
-    AlarmDescription: 'some alarm',
-    AlarmActions: ['devnull@mapbox.com'],
-    Period: 120,
-    EvaluationPeriods: 2,
-    Statistic: 'Minimum',
-    Threshold: 10,
-    ComparisonOperator: 'LessThanThreshold',
-    TreatMissingData: 'breaching',
-    EvaluateLowSampleCountPercentile: 'ignore',
-    ExtendedStatistics: 'p100',
-    OKActions: ['devnull@mapbox.com'],
-    LogRetentionInDays: 30
-  });
-
-  template = cf.merge(
-    { Conditions: { Always: cf.equals('1', '1') } },
-    { Resources: { AnotherThing: { Type: 'AWS::SNS::Topic' } } },
-    lambda
-  );
-  if (update) fixtures.update('lambda-full', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('lambda-full'),
-    'expected resources generated using no default values'
-  );
+  test('expected resources generated using no default values', () => {
+    const lambda = new cf.shortcuts.Lambda({
+      LogicalName: 'MyLambda',
+      Code: {
+        S3Bucket: 'my-code-bucket',
+        S3Key: 'path/to/code.zip'
+      },
+      DeadLetterConfig: {
+        TargetArn: 'arn:aws:sqs:us-east-1:123456789012:queue/fake'
+      },
+      Description: 'my description',
+      Environment: { Variables: { MyCoolEnv: 'a' } },
+      FunctionName: 'my-function',
+      Handler: 'index.something',
+      KmsKeyArn: 'arn:aws:kms:us-east-1:123456789012:key/fake',
+      Layers: ['arn:aws:lambda:us-east-2:590474943231:layer:AWS-Parameters-and-Secrets-Lambda-Extension:4'],
+      MemorySize: 512,
+      ReservedConcurrentExecutions: 10,
+      Runtime: 'nodejs22.x',
+      Tags: [{ Key: 'a', Value: 'b' }],
+      Timeout: 30,
+      TracingConfig: { Mode: 'Active' },
+      VpcConfig: {
+        SecurityGroupIds: ['sg-12345678'],
+        SubnetIds: ['fake']
+      },
+      Condition: 'Always',
+      DependsOn: 'AnotherThing',
+      Statement: [
+        {
+          Effect: 'Allow',
+          Action: 's3:GetObject',
+          Resource: 'arn:aws:s3:::fake/data'
+        }
+      ],
+      AlarmName: 'my-alarm',
+      AlarmDescription: 'some alarm',
+      AlarmActions: ['devnull@mapbox.com'],
+      Period: 120,
+      EvaluationPeriods: 2,
+      Statistic: 'Minimum',
+      Threshold: 10,
+      ComparisonOperator: 'LessThanThreshold',
+      TreatMissingData: 'breaching',
+      EvaluateLowSampleCountPercentile: 'ignore',
+      ExtendedStatistics: 'p100',
+      OKActions: ['devnull@mapbox.com'],
+      LogRetentionInDays: 30
+    });
 
-  lambda = new cf.shortcuts.Lambda({
-    LogicalName: 'MyLambda',
-    Code: {
-      S3Bucket: 'my-code-bucket',
-      S3Key: 'path/to/code.zip'
-    },
-    LogPolicyName: 'CustomLogPolicyName'
+    const template = cf.merge(
+      { Conditions: { Always: cf.equals('1', '1') } },
+      { Resources: { AnotherThing: { Type: 'AWS::SNS::Topic' } } },
+      lambda
+    );
+    if (update) fixtures.update('lambda-full', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('lambda-full'));
   });
 
-  template = cf.merge(lambda);
-  assert.equal(
-    template.Resources.MyLambdaLogPolicy.Properties.PolicyName,
-    'CustomLogPolicyName',
-    'LogPolicyName parameter correctly overrides the default policy name'
-  );
+  test('LogPolicyName parameter correctly overrides the default policy name', () => {
+    const lambda = new cf.shortcuts.Lambda({
+      LogicalName: 'MyLambda',
+      Code: {
+        S3Bucket: 'my-code-bucket',
+        S3Key: 'path/to/code.zip'
+      },
+      LogPolicyName: 'CustomLogPolicyName'
+    });
 
-  assert.end();
+    const template = cf.merge(lambda);
+    expect(template.Resources.MyLambdaLogPolicy.Properties.PolicyName).toBe('CustomLogPolicyName');
+  });
 });
 
-test('[shortcuts] queue-lambda', (assert) => {
-  assert.throws(
-    () => new cf.shortcuts.QueueLambda(),
-    'Options required',
-    'throws without options'
-  );
-  assert.throws(
-    () => new cf.shortcuts.QueueLambda({}),
-    /You must provide a LogicalName, and Code/,
-    'throws without basic lambda required parameters'
-  );
+describe('[shortcuts] queue-lambda', () => {
+  test('throws without options', () => {
+    expect(() => new cf.shortcuts.QueueLambda()).toThrow('Options required');
+  });
 
-  assert.throws(
-    () =>
-      new cf.shortcuts.QueueLambda({
-        LogicalName: 'MyLambda',
-        Code: {
-          S3Bucket: 'my-code-bucket',
-          S3Key: 'path/to/code.zip'
-        }
-      }),
-    /You must provide an EventSourceArn and ReservedConcurrentExecutions/,
-    'throws without queue-lambda required parameters'
-  );
+  test('throws without basic lambda required parameters', () => {
+    expect(() => new cf.shortcuts.QueueLambda({})).toThrow(/You must provide a LogicalName, and Code/);
+  });
 
-  assert.throws(
-    () =>
-      new cf.shortcuts.QueueLambda({
-        LogicalName: 'MyLambda',
-        Code: {
-          S3Bucket: 'my-code-bucket',
-          S3Key: 'path/to/code.zip'
-        },
-        EventSourceArn: 'arn:aws:sqs:us-east-1:123456789012:queue/fake',
-        ReservedConcurrentExecutions: -1
-      }),
-    /ReservedConcurrentExecutions must be greater than or equal to 0/,
-    'throws when ReservedConcurrentExecutions is a negative number'
-  );
+  test('throws without queue-lambda required parameters', () => {
+    expect(() => new cf.shortcuts.QueueLambda({
+      LogicalName: 'MyLambda',
+      Code: {
+        S3Bucket: 'my-code-bucket',
+        S3Key: 'path/to/code.zip'
+      }
+    })).toThrow(/You must provide an EventSourceArn and ReservedConcurrentExecutions/);
+  });
 
-  const zeroLambda = new cf.shortcuts.QueueLambda({
-    LogicalName: 'MyLambda',
-    Code: {
-      S3Bucket: 'my-code-bucket',
-      S3Key: 'path/to/code.zip'
-    },
-    EventSourceArn: 'arn:aws:sqs:us-east-1:123456789012:queue/fake',
-    ReservedConcurrentExecutions: 0
-  });
-  const zeroTemplate = cf.merge(zeroLambda);
-  if (update) fixtures.update('queue-lambda-zero', zeroTemplate);
-  assert.deepEqual(
-    noUndefined(zeroTemplate),
-    fixtures.get('queue-lambda-zero'),
-    'expected resources generated'
-  );
+  test('throws when ReservedConcurrentExecutions is a negative number', () => {
+    expect(() => new cf.shortcuts.QueueLambda({
+      LogicalName: 'MyLambda',
+      Code: {
+        S3Bucket: 'my-code-bucket',
+        S3Key: 'path/to/code.zip'
+      },
+      EventSourceArn: 'arn:aws:sqs:us-east-1:123456789012:queue/fake',
+      ReservedConcurrentExecutions: -1
+    })).toThrow(/ReservedConcurrentExecutions must be greater than or equal to 0/);
+  });
 
-  const lambda = new cf.shortcuts.QueueLambda({
-    LogicalName: 'MyLambda',
-    Code: {
-      S3Bucket: 'my-code-bucket',
-      S3Key: 'path/to/code.zip'
-    },
-    EventSourceArn: 'arn:aws:sqs:us-east-1:123456789012:queue/fake',
-    ReservedConcurrentExecutions: 10
-  });
-
-  const template = cf.merge(lambda);
-  if (update) fixtures.update('queue-lambda', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('queue-lambda'),
-    'expected resources generated'
-  );
+  test('expected resources generated with zero concurrency', () => {
+    const zeroLambda = new cf.shortcuts.QueueLambda({
+      LogicalName: 'MyLambda',
+      Code: {
+        S3Bucket: 'my-code-bucket',
+        S3Key: 'path/to/code.zip'
+      },
+      EventSourceArn: 'arn:aws:sqs:us-east-1:123456789012:queue/fake',
+      ReservedConcurrentExecutions: 0
+    });
+    const zeroTemplate = cf.merge(zeroLambda);
+    if (update) fixtures.update('queue-lambda-zero', zeroTemplate);
+    expect(noUndefined(zeroTemplate)).toEqual(fixtures.get('queue-lambda-zero'));
+  });
+
+  test('expected resources generated', () => {
+    const lambda = new cf.shortcuts.QueueLambda({
+      LogicalName: 'MyLambda',
+      Code: {
+        S3Bucket: 'my-code-bucket',
+        S3Key: 'path/to/code.zip'
+      },
+      EventSourceArn: 'arn:aws:sqs:us-east-1:123456789012:queue/fake',
+      ReservedConcurrentExecutions: 10
+    });
 
-  assert.end();
+    const template = cf.merge(lambda);
+    if (update) fixtures.update('queue-lambda', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('queue-lambda'));
+  });
 });
 
-test('[shortcuts] scheduled-lambda', (assert) => {
-  assert.throws(
-    () => new cf.shortcuts.ScheduledLambda(),
-    'Options required',
-    'throws without options'
-  );
-  assert.throws(
-    () => new cf.shortcuts.ScheduledLambda({}),
-    /You must provide a LogicalName, and Code/,
-    'throws without basic lambda required parameters'
-  );
+describe('[shortcuts] scheduled-lambda', () => {
+  test('throws without options', () => {
+    expect(() => new cf.shortcuts.ScheduledLambda()).toThrow('Options required');
+  });
 
-  assert.throws(
-    () =>
-      new cf.shortcuts.ScheduledLambda({
-        LogicalName: 'MyLambda',
-        Code: {
-          S3Bucket: 'my-code-bucket',
-          S3Key: 'path/to/code.zip'
-        }
-      }),
-    /You must provide a ScheduleExpression/,
-    'throws without scheduled-lambda required parameters'
-  );
+  test('throws without basic lambda required parameters', () => {
+    expect(() => new cf.shortcuts.ScheduledLambda({})).toThrow(/You must provide a LogicalName, and Code/);
+  });
 
-  let lambda = new cf.shortcuts.ScheduledLambda({
-    LogicalName: 'MyLambda',
-    Code: {
-      S3Bucket: 'my-code-bucket',
-      S3Key: 'path/to/code.zip'
-    },
-    ScheduleExpression: 'rate(1 hour)'
-  });
-
-  let template = cf.merge(lambda);
-  if (update) fixtures.update('scheduled-lambda-defaults', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('scheduled-lambda-defaults'),
-    'expected resources generated with defaults'
-  );
+  test('throws without scheduled-lambda required parameters', () => {
+    expect(() => new cf.shortcuts.ScheduledLambda({
+      LogicalName: 'MyLambda',
+      Code: {
+        S3Bucket: 'my-code-bucket',
+        S3Key: 'path/to/code.zip'
+      }
+    })).toThrow(/You must provide a ScheduleExpression/);
+  });
 
-  lambda = new cf.shortcuts.ScheduledLambda({
-    LogicalName: 'MyLambda',
-    Code: {
-      S3Bucket: 'my-code-bucket',
-      S3Key: 'path/to/code.zip'
-    },
-    ScheduleRoleArn: 'arn:aws:iam::012345678901:role/MyCoolRole',
-    ScheduleGroupName: 'my-cool-stack',
-    ScheduleExpression: 'rate(1 hour)',
-    State: 'DISABLED'
-  });
-
-  template = cf.merge(lambda);
-  if (update) fixtures.update('scheduled-lambda-full', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('scheduled-lambda-full'),
-    'expected resources generated without defaults'
-  );
+  test('expected resources generated with defaults', () => {
+    const lambda = new cf.shortcuts.ScheduledLambda({
+      LogicalName: 'MyLambda',
+      Code: {
+        S3Bucket: 'my-code-bucket',
+        S3Key: 'path/to/code.zip'
+      },
+      ScheduleExpression: 'rate(1 hour)'
+    });
 
-  assert.end();
+    const template = cf.merge(lambda);
+    if (update) fixtures.update('scheduled-lambda-defaults', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('scheduled-lambda-defaults'));
+  });
+
+  test('expected resources generated without defaults', () => {
+    const lambda = new cf.shortcuts.ScheduledLambda({
+      LogicalName: 'MyLambda',
+      Code: {
+        S3Bucket: 'my-code-bucket',
+        S3Key: 'path/to/code.zip'
+      },
+      ScheduleRoleArn: 'arn:aws:iam::012345678901:role/MyCoolRole',
+      ScheduleGroupName: 'my-cool-stack',
+      ScheduleExpression: 'rate(1 hour)',
+      State: 'DISABLED'
+    });
+
+    const template = cf.merge(lambda);
+    if (update) fixtures.update('scheduled-lambda-full', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('scheduled-lambda-full'));
+  });
 });
 
-test('[shortcuts] event-lambda', (assert) => {
-  assert.throws(
-    () => new cf.shortcuts.EventLambda(),
-    'Options required',
-    'throws without options'
-  );
-  assert.throws(
-    () => new cf.shortcuts.EventLambda({}),
-    /You must provide a LogicalName, and Code/,
-    'throws without basic lambda required parameters'
-  );
+describe('[shortcuts] event-lambda', () => {
+  test('throws without options', () => {
+    expect(() => new cf.shortcuts.EventLambda()).toThrow('Options required');
+  });
 
-  assert.throws(
-    () =>
-      new cf.shortcuts.EventLambda({
-        LogicalName: 'MyLambda',
-        Code: {
-          S3Bucket: 'my-code-bucket',
-          S3Key: 'path/to/code.zip'
-        }
-      }),
-    /You must provide an EventPattern/,
-    'throws without event-lambda required parameters'
-  );
+  test('throws without basic lambda required parameters', () => {
+    expect(() => new cf.shortcuts.EventLambda({})).toThrow(/You must provide a LogicalName, and Code/);
+  });
 
-  let lambda = new cf.shortcuts.EventLambda({
-    LogicalName: 'MyLambda',
-    Code: {
-      S3Bucket: 'my-code-bucket',
-      S3Key: 'path/to/code.zip'
-    },
-    EventPattern: {
-      source: ['aws.ec2'],
-      'detail-type': ['EC2 Instance State-change Notification'],
-      detail: {
-        state: ['running']
+  test('throws without event-lambda required parameters', () => {
+    expect(() => new cf.shortcuts.EventLambda({
+      LogicalName: 'MyLambda',
+      Code: {
+        S3Bucket: 'my-code-bucket',
+        S3Key: 'path/to/code.zip'
       }
-    }
+    })).toThrow(/You must provide an EventPattern/);
   });
 
-  let template = cf.merge(lambda);
-  if (update) fixtures.update('event-lambda-defaults', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('event-lambda-defaults'),
-    'expected resources generated with defaults'
-  );
-
-  lambda = new cf.shortcuts.EventLambda({
-    LogicalName: 'MyLambda',
-    Code: {
-      S3Bucket: 'my-code-bucket',
-      S3Key: 'path/to/code.zip'
-    },
-    EventPattern: {
-      source: ['aws.ec2'],
-      'detail-type': ['EC2 Instance State-change Notification'],
-      detail: {
-        state: ['running']
+  test('expected resources generated with defaults', () => {
+    const lambda = new cf.shortcuts.EventLambda({
+      LogicalName: 'MyLambda',
+      Code: {
+        S3Bucket: 'my-code-bucket',
+        S3Key: 'path/to/code.zip'
+      },
+      EventPattern: {
+        source: ['aws.ec2'],
+        'detail-type': ['EC2 Instance State-change Notification'],
+        detail: {
+          state: ['running']
+        }
       }
-    },
-    State: 'DISABLED'
+    });
+
+    const template = cf.merge(lambda);
+    if (update) fixtures.update('event-lambda-defaults', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('event-lambda-defaults'));
   });
 
-  template = cf.merge(lambda);
-  if (update) fixtures.update('event-lambda-full', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('event-lambda-full'),
-    'expected resources generated without defaults'
-  );
+  test('expected resources generated without defaults', () => {
+    const lambda = new cf.shortcuts.EventLambda({
+      LogicalName: 'MyLambda',
+      Code: {
+        S3Bucket: 'my-code-bucket',
+        S3Key: 'path/to/code.zip'
+      },
+      EventPattern: {
+        source: ['aws.ec2'],
+        'detail-type': ['EC2 Instance State-change Notification'],
+        detail: {
+          state: ['running']
+        }
+      },
+      State: 'DISABLED'
+    });
 
-  assert.end();
+    const template = cf.merge(lambda);
+    if (update) fixtures.update('event-lambda-full', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('event-lambda-full'));
+  });
 });
 
-test('[shortcuts] stream-lambda', (assert) => {
-  assert.throws(
-    () => new cf.shortcuts.StreamLambda(),
-    'Options required',
-    'throws without options'
-  );
-  assert.throws(
-    () => new cf.shortcuts.StreamLambda({}),
-    /You must provide a LogicalName, and Code/,
-    'throws without basic lambda required parameters'
-  );
+describe('[shortcuts] stream-lambda', () => {
+  test('throws without options', () => {
+    expect(() => new cf.shortcuts.StreamLambda()).toThrow('Options required');
+  });
 
-  assert.throws(
-    () =>
-      new cf.shortcuts.StreamLambda({
-        LogicalName: 'MyLambda',
-        Code: {
-          S3Bucket: 'my-code-bucket',
-          S3Key: 'path/to/code.zip'
-        }
-      }),
-    /You must provide an EventSourceArn/,
-    'throws without stream-lambda required parameters'
-  );
+  test('throws without basic lambda required parameters', () => {
+    expect(() => new cf.shortcuts.StreamLambda({})).toThrow(/You must provide a LogicalName, and Code/);
+  });
 
-  let lambda = new cf.shortcuts.StreamLambda({
-    LogicalName: 'MyLambda',
-    Code: {
-      S3Bucket: 'my-code-bucket',
-      S3Key: 'path/to/code.zip'
-    },
-    EventSourceArn: 'arn:aws:kinesis:us-east-1:123456789012:stream/fake'
-  });
-
-  let template = cf.merge(lambda);
-  if (update) fixtures.update('stream-lambda-defaults', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('stream-lambda-defaults'),
-    'expected resources generated via defaults'
-  );
+  test('throws without stream-lambda required parameters', () => {
+    expect(() => new cf.shortcuts.StreamLambda({
+      LogicalName: 'MyLambda',
+      Code: {
+        S3Bucket: 'my-code-bucket',
+        S3Key: 'path/to/code.zip'
+      }
+    })).toThrow(/You must provide an EventSourceArn/);
+  });
 
-  lambda = new cf.shortcuts.StreamLambda({
-    LogicalName: 'MyLambda',
-    Code: {
-      S3Bucket: 'my-code-bucket',
-      S3Key: 'path/to/code.zip'
-    },
-    EventSourceArn: 'arn:aws:kinesis:us-east-1:123456789012:stream/fake',
-    FilterCriteria: {
-      Filters: [
-        {
-          Pattern: JSON.stringify({ eventName: ['INSERT', 'MODIFY'] })
-        }
-      ]
-    },
-    BatchSize: 10000,
-    MaximumBatchingWindowInSeconds: 300,
-    Enabled: false,
-    StartingPosition: 'TRIM_HORIZON'
-  });
-
-  template = cf.merge(lambda);
-  if (update) fixtures.update('stream-lambda-no-defaults', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('stream-lambda-no-defaults'),
-    'expected resources generated without defaults'
-  );
+  test('expected resources generated via defaults', () => {
+    const lambda = new cf.shortcuts.StreamLambda({
+      LogicalName: 'MyLambda',
+      Code: {
+        S3Bucket: 'my-code-bucket',
+        S3Key: 'path/to/code.zip'
+      },
+      EventSourceArn: 'arn:aws:kinesis:us-east-1:123456789012:stream/fake'
+    });
+
+    const template = cf.merge(lambda);
+    if (update) fixtures.update('stream-lambda-defaults', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('stream-lambda-defaults'));
+  });
 
-  assert.end();
+  test('expected resources generated without defaults', () => {
+    const lambda = new cf.shortcuts.StreamLambda({
+      LogicalName: 'MyLambda',
+      Code: {
+        S3Bucket: 'my-code-bucket',
+        S3Key: 'path/to/code.zip'
+      },
+      EventSourceArn: 'arn:aws:kinesis:us-east-1:123456789012:stream/fake',
+      FilterCriteria: {
+        Filters: [
+          {
+            Pattern: JSON.stringify({ eventName: ['INSERT', 'MODIFY'] })
+          }
+        ]
+      },
+      BatchSize: 10000,
+      MaximumBatchingWindowInSeconds: 300,
+      Enabled: false,
+      StartingPosition: 'TRIM_HORIZON'
+    });
+
+    const template = cf.merge(lambda);
+    if (update) fixtures.update('stream-lambda-no-defaults', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('stream-lambda-no-defaults'));
+  });
 });
 
-test('[shortcuts] StreamLambda FilterCriteria', (assert) => {
-  assert.throws(
-    () => new cf.shortcuts.StreamLambda({
+describe('[shortcuts] StreamLambda FilterCriteria', () => {
+  test('FilterCriteria must be a JSON-like object', () => {
+    expect(() => new cf.shortcuts.StreamLambda({
       LogicalName: 'MyLambda',
       Code: {
         S3Bucket: 'my-code-bucket',
@@ -538,11 +457,11 @@ test('[shortcuts] StreamLambda FilterCriteria', (assert) => {
       },
       EventSourceArn: 'arn:aws:kinesis:us-east-1:123456789012:stream/fake',
       FilterCriteria: ['test']
-    }),
-    '`FilterCriteria` must be a JSON-like object',
-  );
-  assert.throws(
-    () => new cf.shortcuts.StreamLambda({
+    })).toThrow();
+  });
+
+  test('FilterCriteria must contain property Filter of type array', () => {
+    expect(() => new cf.shortcuts.StreamLambda({
       LogicalName: 'MyLambda',
       Code: {
         S3Bucket: 'my-code-bucket',
@@ -550,11 +469,11 @@ test('[shortcuts] StreamLambda FilterCriteria', (assert) => {
       },
       EventSourceArn: 'arn:aws:kinesis:us-east-1:123456789012:stream/fake',
       FilterCriteria: {}
-    }),
-    '`FilterCriteria` must contain property `Filter` of type array',
-  );
-  assert.throws(
-    () => new cf.shortcuts.StreamLambda({
+    })).toThrow();
+  });
+
+  test('FilterCriteria.Filter must be an array', () => {
+    expect(() => new cf.shortcuts.StreamLambda({
       LogicalName: 'MyLambda',
       Code: {
         S3Bucket: 'my-code-bucket',
@@ -564,11 +483,11 @@ test('[shortcuts] StreamLambda FilterCriteria', (assert) => {
       FilterCriteria: {
         Filter: 613
       }
-    }),
-    '`FilterCriteria` must contain property `Filter` of type array',
-  );
-  assert.throws(
-    () => new cf.shortcuts.StreamLambda({
+    })).toThrow();
+  });
+
+  test('FilterCriteria.Filter objects must have Pattern property', () => {
+    expect(() => new cf.shortcuts.StreamLambda({
       LogicalName: 'MyLambda',
       Code: {
         S3Bucket: 'my-code-bucket',
@@ -585,11 +504,11 @@ test('[shortcuts] StreamLambda FilterCriteria', (assert) => {
           }
         ]
       }
-    }),
-    'An object in `FilterCriteria.Filter` was missing the required property `Pattern`',
-  );
-  assert.throws(
-    () => new cf.shortcuts.StreamLambda({
+    })).toThrow();
+  });
+
+  test('FilterCriteria.Filter Pattern must be JSON parseable string', () => {
+    expect(() => new cf.shortcuts.StreamLambda({
       LogicalName: 'MyLambda',
       Code: {
         S3Bucket: 'my-code-bucket',
@@ -606,930 +525,798 @@ test('[shortcuts] StreamLambda FilterCriteria', (assert) => {
           }
         ]
       }
-    }),
-    'An object in `FilterCriteria.Filter` contains a `Pattern` property that is not a JSON parseable string',
-  );
-  assert.end();
+    })).toThrow();
+  });
 });
 
-test('[shortcuts] log-subscription-lambda', (assert) => {
-  assert.throws(
-    () => new cf.shortcuts.LogSubscriptionLambda(),
-    'Options required',
-    'throws without options'
-  );
-  assert.throws(
-    () => new cf.shortcuts.LogSubscriptionLambda({}),
-    /You must provide a LogicalName, and Code/,
-    'throws without basic lambda required parameters'
-  );
+describe('[shortcuts] log-subscription-lambda', () => {
+  test('throws without options', () => {
+    expect(() => new cf.shortcuts.LogSubscriptionLambda()).toThrow('Options required');
+  });
 
-  assert.throws(
-    () =>
-      new cf.shortcuts.LogSubscriptionLambda({
-        LogicalName: 'MyLambda',
-        Code: {
-          S3Bucket: 'my-code-bucket',
-          S3Key: 'path/to/code.zip'
-        }
-      }),
-    /You must provide a LogGroupName/,
-    'throws without log-subscription-lambda required parameters'
-  );
+  test('throws without basic lambda required parameters', () => {
+    expect(() => new cf.shortcuts.LogSubscriptionLambda({})).toThrow(/You must provide a LogicalName, and Code/);
+  });
 
-  let lambda = new cf.shortcuts.LogSubscriptionLambda({
-    LogicalName: 'MyLambda',
-    Code: {
-      S3Bucket: 'my-code-bucket',
-      S3Key: 'path/to/code.zip'
-    },
-    LogGroupName: 'my-log-group'
-  });
-
-  let template = cf.merge(lambda);
-  if (update) fixtures.update('log-subscription-lambda-defaults', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('log-subscription-lambda-defaults'),
-    'expected resources generated via defaults'
-  );
+  test('throws without log-subscription-lambda required parameters', () => {
+    expect(() => new cf.shortcuts.LogSubscriptionLambda({
+      LogicalName: 'MyLambda',
+      Code: {
+        S3Bucket: 'my-code-bucket',
+        S3Key: 'path/to/code.zip'
+      }
+    })).toThrow(/You must provide a LogGroupName/);
+  });
 
-  lambda = new cf.shortcuts.LogSubscriptionLambda({
-    LogicalName: 'MyLambda',
-    Code: {
-      S3Bucket: 'my-code-bucket',
-      S3Key: 'path/to/code.zip'
-    },
-    FilterPattern: '{ $.errorCode = 400 }',
-    LogGroupName: 'my-log-group'
-  });
-
-  template = cf.merge(lambda);
-  if (update) fixtures.update('log-subscription-lambda-no-defaults', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('log-subscription-lambda-no-defaults'),
-    'expected resources generated without defaults'
-  );
+  test('expected resources generated via defaults', () => {
+    const lambda = new cf.shortcuts.LogSubscriptionLambda({
+      LogicalName: 'MyLambda',
+      Code: {
+        S3Bucket: 'my-code-bucket',
+        S3Key: 'path/to/code.zip'
+      },
+      LogGroupName: 'my-log-group'
+    });
 
-  assert.end();
+    const template = cf.merge(lambda);
+    if (update) fixtures.update('log-subscription-lambda-defaults', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('log-subscription-lambda-defaults'));
+  });
+
+  test('expected resources generated without defaults', () => {
+    const lambda = new cf.shortcuts.LogSubscriptionLambda({
+      LogicalName: 'MyLambda',
+      Code: {
+        S3Bucket: 'my-code-bucket',
+        S3Key: 'path/to/code.zip'
+      },
+      FilterPattern: '{ $.errorCode = 400 }',
+      LogGroupName: 'my-log-group'
+    });
+
+    const template = cf.merge(lambda);
+    if (update) fixtures.update('log-subscription-lambda-no-defaults', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('log-subscription-lambda-no-defaults'));
+  });
 });
 
-test('[shortcuts] queue', (assert) => {
-  assert.throws(
-    () => new cf.shortcuts.Queue(),
-    'Options required',
-    'throws without options'
-  );
-  assert.throws(
-    () => new cf.shortcuts.Queue({}),
-    /You must provide a LogicalName/,
-    'throws without required parameters'
-  );
+describe('[shortcuts] queue', () => {
+  test('throws without options', () => {
+    expect(() => new cf.shortcuts.Queue()).toThrow('Options required');
+  });
 
-  let queue = new cf.shortcuts.Queue({
-    LogicalName: 'MyQueue'
+  test('throws without required parameters', () => {
+    expect(() => new cf.shortcuts.Queue({})).toThrow(/You must provide a LogicalName/);
   });
 
-  let template = cf.merge(queue);
-  if (update) fixtures.update('queue-defaults', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('queue-defaults'),
-    'expected resources generated for full defaults'
-  );
+  test('expected resources generated for full defaults', () => {
+    const queue = new cf.shortcuts.Queue({
+      LogicalName: 'MyQueue'
+    });
 
-  queue = new cf.shortcuts.Queue({
-    LogicalName: 'MyQueue',
-    VisibilityTimeout: 60,
-    maxReceiveCount: 100,
-    DelaySeconds: 60,
-    KmsMasterKeyId: 'alias/my-key',
-    KmsDataKeyReusePeriondSeconds: 86400,
-    MaximumMessageSize: 1024,
-    MessageRetentionPeriod: 60,
-    QueueName: 'my-queue',
-    ReceiveMessageWaitTimeSeconds: 20,
-    Condition: 'Always',
-    DependsOn: 'AnotherThing',
-    TopicName: 'my-topic',
-    DisplayName: 'topic-display-name',
-    DeadLetterVisibilityTimeout: 60
-  });
-
-  template = cf.merge(
-    { Conditions: { Always: cf.equals('1', '1') } },
-    { Resources: { AnotherThing: { Type: 'AWS::SNS::Topic' } } },
-    queue
-  );
-  if (update) fixtures.update('queue-full', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('queue-full'),
-    'expected resources generated no defaults'
-  );
+    const template = cf.merge(queue);
+    if (update) fixtures.update('queue-defaults', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('queue-defaults'));
+  });
 
-  queue = new cf.shortcuts.Queue({
-    LogicalName: 'MyQueue',
-    ExistingTopicArn: 'arn:aws:sns:us-east-1:111122223333:MyTopic'
+  test('expected resources generated no defaults', () => {
+    const queue = new cf.shortcuts.Queue({
+      LogicalName: 'MyQueue',
+      VisibilityTimeout: 60,
+      maxReceiveCount: 100,
+      DelaySeconds: 60,
+      KmsMasterKeyId: 'alias/my-key',
+      KmsDataKeyReusePeriondSeconds: 86400,
+      MaximumMessageSize: 1024,
+      MessageRetentionPeriod: 60,
+      QueueName: 'my-queue',
+      ReceiveMessageWaitTimeSeconds: 20,
+      Condition: 'Always',
+      DependsOn: 'AnotherThing',
+      TopicName: 'my-topic',
+      DisplayName: 'topic-display-name',
+      DeadLetterVisibilityTimeout: 60
+    });
+
+    const template = cf.merge(
+      { Conditions: { Always: cf.equals('1', '1') } },
+      { Resources: { AnotherThing: { Type: 'AWS::SNS::Topic' } } },
+      queue
+    );
+    if (update) fixtures.update('queue-full', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('queue-full'));
   });
-  template = cf.merge(queue);
-  if (update) fixtures.update('queue-external-topic', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('queue-external-topic'),
-    'expected resources generated for external topic'
-  );
 
-  queue = new cf.shortcuts.Queue({
-    LogicalName: 'MyQueue',
-    ExistingTopicArn: { Ref: 'TopicForOtherThing' }
+  test('expected resources generated for external topic', () => {
+    const queue = new cf.shortcuts.Queue({
+      LogicalName: 'MyQueue',
+      ExistingTopicArn: 'arn:aws:sns:us-east-1:111122223333:MyTopic'
+    });
+    const template = cf.merge(queue);
+    if (update) fixtures.update('queue-external-topic', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('queue-external-topic'));
   });
-  template = cf.merge(
-    { Resources: { TopicForOtherThing: { Type: 'AWS::SNS::Topic' } } },
-    queue
-  );
-  if (update) fixtures.update('queue-external-topic-ref', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('queue-external-topic-ref'),
-    'expected resources generated for external topic identified by ref'
-  );
 
-  queue = new cf.shortcuts.Queue({
-    LogicalName: 'MyFifoQueue',
-    FifoQueue: true
+  test('expected resources generated for external topic identified by ref', () => {
+    const queue = new cf.shortcuts.Queue({
+      LogicalName: 'MyQueue',
+      ExistingTopicArn: { Ref: 'TopicForOtherThing' }
+    });
+    const template = cf.merge(
+      { Resources: { TopicForOtherThing: { Type: 'AWS::SNS::Topic' } } },
+      queue
+    );
+    if (update) fixtures.update('queue-external-topic-ref', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('queue-external-topic-ref'));
   });
-  template = cf.merge(queue);
-  if (update) fixtures.update('queue-fifo', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('queue-fifo'),
-    'expected resources generated for FIFO queue'
-  );
 
-  queue = new cf.shortcuts.Queue({
-    LogicalName: 'MyFifoQueue',
-    QueueName: 'custom-and-fancy',
-    FifoQueue: true
-  });
-  template = cf.merge(queue);
-  if (update) fixtures.update('queue-fifo-queuename', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('queue-fifo-queuename'),
-    'expected resources generated for FIFO queue with specified QueueName'
-  );
+  test('expected resources generated for FIFO queue', () => {
+    const queue = new cf.shortcuts.Queue({
+      LogicalName: 'MyFifoQueue',
+      FifoQueue: true
+    });
+    const template = cf.merge(queue);
+    if (update) fixtures.update('queue-fifo', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('queue-fifo'));
+  });
 
-  queue = new cf.shortcuts.Queue({
-    LogicalName: 'MyFifoFalseQueue',
-    FifoQueue: false
+  test('expected resources generated for FIFO queue with specified QueueName', () => {
+    const queue = new cf.shortcuts.Queue({
+      LogicalName: 'MyFifoQueue',
+      QueueName: 'custom-and-fancy',
+      FifoQueue: true
+    });
+    const template = cf.merge(queue);
+    if (update) fixtures.update('queue-fifo-queuename', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('queue-fifo-queuename'));
   });
-  template = cf.merge(queue);
-  assert.equal(
-    template.Resources.MyFifoFalseQueue.Properties.FifoQueue,
-    undefined,
-    'the FifoQueue value false is converted to undefined, to pass CFN validation'
-  );
 
-  assert.end();
+  test('the FifoQueue value false is converted to undefined, to pass CFN validation', () => {
+    const queue = new cf.shortcuts.Queue({
+      LogicalName: 'MyFifoFalseQueue',
+      FifoQueue: false
+    });
+    const template = cf.merge(queue);
+    expect(template.Resources.MyFifoFalseQueue.Properties.FifoQueue).toBeUndefined();
+  });
 });
 
-test('[shortcuts] s3 kinesis firehose', (assert) => {
-  assert.throws(
-    () => new cf.shortcuts.S3KinesisFirehose(),
-    'Options required',
-    'throws without options'
-  );
-  assert.throws(
-    () => new cf.shortcuts.S3KinesisFirehose({}),
-    /You must provide a LogicalName/,
-    'throws without required LogicalName parameter'
-  );
+describe('[shortcuts] s3 kinesis firehose', () => {
+  test('throws without options', () => {
+    expect(() => new cf.shortcuts.S3KinesisFirehose()).toThrow('Options required');
+  });
 
-  assert.throws(
-    () => new cf.shortcuts.S3KinesisFirehose({
-      LogicalName: 'MyKinesisFirehose'
-    }),
-    /You must provide a DestinationBucket/,
-    'throws without required DestinationBucket parameter'
-  );
+  test('throws without required LogicalName parameter', () => {
+    expect(() => new cf.shortcuts.S3KinesisFirehose({})).toThrow(/You must provide a LogicalName/);
+  });
 
-  let firehose = new cf.shortcuts.S3KinesisFirehose({
-    LogicalName: 'MyKinesisFirehose',
-    DestinationBucket: 'mah-bukkit'
+  test('throws without required DestinationBucket parameter', () => {
+    expect(() => new cf.shortcuts.S3KinesisFirehose({
+      LogicalName: 'MyKinesisFirehose'
+    })).toThrow(/You must provide a DestinationBucket/);
   });
 
-  let template = cf.merge(firehose);
-  if (update) fixtures.update('firehose-defaults', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('firehose-defaults'),
-    'expected resources generated for full defaults'
-  );
+  test('expected resources generated for full defaults', () => {
+    const firehose = new cf.shortcuts.S3KinesisFirehose({
+      LogicalName: 'MyKinesisFirehose',
+      DestinationBucket: 'mah-bukkit'
+    });
 
-  firehose = new cf.shortcuts.S3KinesisFirehose({
-    LogicalName: 'MyKinesisFirehose',
-    DestinationBucket: 'mah-bukkit',
-    KinesisStreamARN: 'arn:aws:kinesis:us-east-1:111122223333:stream/my-stream'
+    const template = cf.merge(firehose);
+    if (update) fixtures.update('firehose-defaults', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('firehose-defaults'));
   });
 
-  template = cf.merge(
-    { Conditions: { Always: cf.equals('1', '1') } },
-    { Resources: { AnotherThing: { Type: 'AWS::SNS::Topic' } } },
-    firehose
-  );
-  if (update) fixtures.update('firehose-with-stream', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('firehose-with-stream'),
-    'expected resources generated with stream'
-  );
+  test('expected resources generated with stream', () => {
+    const firehose = new cf.shortcuts.S3KinesisFirehose({
+      LogicalName: 'MyKinesisFirehose',
+      DestinationBucket: 'mah-bukkit',
+      KinesisStreamARN: 'arn:aws:kinesis:us-east-1:111122223333:stream/my-stream'
+    });
 
-  assert.end();
+    const template = cf.merge(
+      { Conditions: { Always: cf.equals('1', '1') } },
+      { Resources: { AnotherThing: { Type: 'AWS::SNS::Topic' } } },
+      firehose
+    );
+    if (update) fixtures.update('firehose-with-stream', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('firehose-with-stream'));
+  });
 });
 
-test('[shortcuts] role', (assert) => {
-  assert.throws(
-    () => new cf.shortcuts.Role(),
-    'Options required',
-    'throws without options'
-  );
-  assert.throws(
-    () => new cf.shortcuts.Role({}),
-    /You must provide a LogicalName and AssumeRolePrincipals/,
-    'throws without required parameters'
-  );
+describe('[shortcuts] role', () => {
+  test('throws without options', () => {
+    expect(() => new cf.shortcuts.Role()).toThrow('Options required');
+  });
 
-  let role = new cf.shortcuts.Role({
-    LogicalName: 'MyRole',
-    AssumeRolePrincipals: [{ Service: 'ec2.amazonaws.com' }]
+  test('throws without required parameters', () => {
+    expect(() => new cf.shortcuts.Role({})).toThrow(/You must provide a LogicalName and AssumeRolePrincipals/);
   });
 
-  let template = cf.merge(role);
-  if (update) fixtures.update('role-defaults', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('role-defaults'),
-    'expected resources generated with defaults'
-  );
+  test('expected resources generated with defaults', () => {
+    const role = new cf.shortcuts.Role({
+      LogicalName: 'MyRole',
+      AssumeRolePrincipals: [{ Service: 'ec2.amazonaws.com' }]
+    });
 
-  role = new cf.shortcuts.Role({
-    LogicalName: 'MyRole',
-    AssumeRolePrincipals: [{ Service: 'ec2.amazonaws.com' }],
-    Statement: [
-      {
-        Effect: 'Allow',
-        Action: 's3:GetObject',
-        Resource: 'arn:aws:s3:::fake/data'
-      }
-    ],
-    ManagedPolicyArns: ['arn:aws:iam::123456789012:policy/fake'],
-    MaxSessionDuration: 3600,
-    Path: '/fake/',
-    RoleName: 'my-role',
-    Tags: [{ Key: 'pipeline-name', Value: 'test' }],
-    Condition: 'Always',
-    DependsOn: 'AnotherThing'
-  });
-
-  template = cf.merge(
-    { Conditions: { Always: cf.equals('1', '1') } },
-    { Resources: { AnotherThing: { Type: 'AWS::SNS::Topic' } } },
-    role
-  );
-  if (update) fixtures.update('role-no-defaults', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('role-no-defaults'),
-    'expected resources generated without defaults'
-  );
+    const template = cf.merge(role);
+    if (update) fixtures.update('role-defaults', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('role-defaults'));
+  });
 
-  assert.end();
+  test('expected resources generated without defaults', () => {
+    const role = new cf.shortcuts.Role({
+      LogicalName: 'MyRole',
+      AssumeRolePrincipals: [{ Service: 'ec2.amazonaws.com' }],
+      Statement: [
+        {
+          Effect: 'Allow',
+          Action: 's3:GetObject',
+          Resource: 'arn:aws:s3:::fake/data'
+        }
+      ],
+      ManagedPolicyArns: ['arn:aws:iam::123456789012:policy/fake'],
+      MaxSessionDuration: 3600,
+      Path: '/fake/',
+      RoleName: 'my-role',
+      Tags: [{ Key: 'pipeline-name', Value: 'test' }],
+      Condition: 'Always',
+      DependsOn: 'AnotherThing'
+    });
+
+    const template = cf.merge(
+      { Conditions: { Always: cf.equals('1', '1') } },
+      { Resources: { AnotherThing: { Type: 'AWS::SNS::Topic' } } },
+      role
+    );
+    if (update) fixtures.update('role-no-defaults', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('role-no-defaults'));
+  });
 });
 
-test('[shortcuts] cross-account role', (assert) => {
-  assert.throws(
-    () => new cf.shortcuts.CrossAccountRole(),
-    'Options required',
-    'throws without options'
-  );
-  assert.throws(
-    () => new cf.shortcuts.CrossAccountRole({}),
-    /You must provide a LogicalName and Accounts/,
-    'throws without required parameters'
-  );
+describe('[shortcuts] cross-account role', () => {
+  test('throws without options', () => {
+    expect(() => new cf.shortcuts.CrossAccountRole()).toThrow('Options required');
+  });
 
-  let role = new cf.shortcuts.CrossAccountRole({
-    LogicalName: 'MyRole',
-    Accounts: [
-      '123456789012',
-      'arn:aws:iam::123456789012:root',
-      { 'Fn::Sub': 'arn:aws:iam::${AWS::AccountId}:root' }
-    ]
-  });
-
-  let template = cf.merge(role);
-  if (update) fixtures.update('cross-account-role-defaults', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('cross-account-role-defaults'),
-    'expected resources generated with defaults'
-  );
+  test('throws without required parameters', () => {
+    expect(() => new cf.shortcuts.CrossAccountRole({})).toThrow(/You must provide a LogicalName and Accounts/);
+  });
 
-  role = new cf.shortcuts.CrossAccountRole({
-    LogicalName: 'MyRole',
-    Accounts: [
-      '123456789012',
-      'arn:aws:iam::123456789012:root',
-      { 'Fn::Sub': 'arn:aws:iam::${AWS::AccountId}:root' }
-    ],
-    Statement: [
-      {
-        Effect: 'Allow',
-        Action: 's3:GetObject',
-        Resource: 'arn:aws:s3:::fake/data'
-      }
-    ],
-    ManagedPolicyArns: ['arn:aws:iam::123456789012:policy/fake'],
-    MaxSessionDuration: 3600,
-    Path: '/fake/',
-    RoleName: 'my-role',
-    Condition: 'Always',
-    DependsOn: 'AnotherThing'
-  });
-
-  template = cf.merge(
-    { Conditions: { Always: cf.equals('1', '1') } },
-    { Resources: { AnotherThing: { Type: 'AWS::SNS::Topic' } } },
-    role
-  );
-  if (update) fixtures.update('cross-account-role-no-defaults', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('cross-account-role-no-defaults'),
-    'expected resources generated without defaults'
-  );
+  test('expected resources generated with defaults', () => {
+    const role = new cf.shortcuts.CrossAccountRole({
+      LogicalName: 'MyRole',
+      Accounts: [
+        '123456789012',
+        'arn:aws:iam::123456789012:root',
+        { 'Fn::Sub': 'arn:aws:iam::${AWS::AccountId}:root' }
+      ]
+    });
+
+    const template = cf.merge(role);
+    if (update) fixtures.update('cross-account-role-defaults', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('cross-account-role-defaults'));
+  });
+
+  test('expected resources generated without defaults', () => {
+    const role = new cf.shortcuts.CrossAccountRole({
+      LogicalName: 'MyRole',
+      Accounts: [
+        '123456789012',
+        'arn:aws:iam::123456789012:root',
+        { 'Fn::Sub': 'arn:aws:iam::${AWS::AccountId}:root' }
+      ],
+      Statement: [
+        {
+          Effect: 'Allow',
+          Action: 's3:GetObject',
+          Resource: 'arn:aws:s3:::fake/data'
+        }
+      ],
+      ManagedPolicyArns: ['arn:aws:iam::123456789012:policy/fake'],
+      MaxSessionDuration: 3600,
+      Path: '/fake/',
+      RoleName: 'my-role',
+      Condition: 'Always',
+      DependsOn: 'AnotherThing'
+    });
 
-  assert.end();
+    const template = cf.merge(
+      { Conditions: { Always: cf.equals('1', '1') } },
+      { Resources: { AnotherThing: { Type: 'AWS::SNS::Topic' } } },
+      role
+    );
+    if (update) fixtures.update('cross-account-role-no-defaults', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('cross-account-role-no-defaults'));
+  });
 });
 
-test('[shortcuts] service role', (assert) => {
-  assert.throws(
-    () => new cf.shortcuts.ServiceRole(),
-    'Options required',
-    'throws without options'
-  );
-  assert.throws(
-    () => new cf.shortcuts.ServiceRole({}),
-    /You must provide a LogicalName and Service/,
-    'throws without required parameters'
-  );
+describe('[shortcuts] service role', () => {
+  test('throws without options', () => {
+    expect(() => new cf.shortcuts.ServiceRole()).toThrow('Options required');
+  });
 
-  let role = new cf.shortcuts.ServiceRole({
-    LogicalName: 'MyRole',
-    Service: 'lambda'
+  test('throws without required parameters', () => {
+    expect(() => new cf.shortcuts.ServiceRole({})).toThrow(/You must provide a LogicalName and Service/);
   });
 
-  let template = cf.merge(role);
-  if (update) fixtures.update('service-role-defaults', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('service-role-defaults'),
-    'expected resources generated with defaults'
-  );
+  test('expected resources generated with defaults', () => {
+    const role = new cf.shortcuts.ServiceRole({
+      LogicalName: 'MyRole',
+      Service: 'lambda'
+    });
 
-  role = new cf.shortcuts.ServiceRole({
-    LogicalName: 'MyRole',
-    Service: 'lambda.amazonaws.com'
+    const template = cf.merge(role);
+    if (update) fixtures.update('service-role-defaults', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('service-role-defaults'));
   });
 
-  template = cf.merge(role);
-  if (update) fixtures.update('service-role-no-url-suffix', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('service-role-no-url-suffix'),
-    'expected resources generated, service for which AWS::URLSuffix is invalid'
-  );
+  test('expected resources generated, service for which AWS::URLSuffix is invalid', () => {
+    const role = new cf.shortcuts.ServiceRole({
+      LogicalName: 'MyRole',
+      Service: 'lambda.amazonaws.com'
+    });
 
-  role = new cf.shortcuts.ServiceRole({
-    LogicalName: 'MyRole',
-    Service: 'ec2'
+    const template = cf.merge(role);
+    if (update) fixtures.update('service-role-no-url-suffix', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('service-role-no-url-suffix'));
   });
 
-  template = cf.merge(role);
-  if (update) fixtures.update('service-role-url-suffix', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('service-role-url-suffix'),
-    'expected resources generated, service for which AWS::URLSuffix is invalid'
-  );
+  test('expected resources generated, service for which AWS::URLSuffix is valid', () => {
+    const role = new cf.shortcuts.ServiceRole({
+      LogicalName: 'MyRole',
+      Service: 'ec2'
+    });
 
-  role = new cf.shortcuts.ServiceRole({
-    LogicalName: 'MyRole',
-    Service: 'ec2.amazonaws.com'
+    const template = cf.merge(role);
+    if (update) fixtures.update('service-role-url-suffix', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('service-role-url-suffix'));
   });
 
-  template = cf.merge(role);
-  if (update)
-    fixtures.update('service-role-url-suffix-with-replacement', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('service-role-url-suffix-with-replacement'),
-    'expected resources generated, service for which AWS::URLSuffix is invalid specified with a suffix'
-  );
+  test('expected resources generated, service for which AWS::URLSuffix is invalid specified with a suffix', () => {
+    const role = new cf.shortcuts.ServiceRole({
+      LogicalName: 'MyRole',
+      Service: 'ec2.amazonaws.com'
+    });
 
-  role = new cf.shortcuts.ServiceRole({
-    LogicalName: 'MyRole',
-    Service: 'lambda.amazonaws.com',
-    Statement: [
-      {
-        Effect: 'Allow',
-        Action: 's3:GetObject',
-        Resource: 'arn:aws:s3:::fake/data'
-      }
-    ],
-    ManagedPolicyArns: ['arn:aws:iam::123456789012:policy/fake'],
-    MaxSessionDuration: 3600,
-    Path: '/fake/',
-    RoleName: 'my-role',
-    Condition: 'Always',
-    DependsOn: 'AnotherThing'
-  });
-
-  template = cf.merge(
-    { Conditions: { Always: cf.equals('1', '1') } },
-    { Resources: { AnotherThing: { Type: 'AWS::SNS::Topic' } } },
-    role
-  );
-  if (update) fixtures.update('service-role-no-defaults', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('service-role-no-defaults'),
-    'expected resources generated without defaults'
-  );
+    const template = cf.merge(role);
+    if (update) fixtures.update('service-role-url-suffix-with-replacement', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('service-role-url-suffix-with-replacement'));
+  });
+
+  test('expected resources generated without defaults', () => {
+    const role = new cf.shortcuts.ServiceRole({
+      LogicalName: 'MyRole',
+      Service: 'lambda.amazonaws.com',
+      Statement: [
+        {
+          Effect: 'Allow',
+          Action: 's3:GetObject',
+          Resource: 'arn:aws:s3:::fake/data'
+        }
+      ],
+      ManagedPolicyArns: ['arn:aws:iam::123456789012:policy/fake'],
+      MaxSessionDuration: 3600,
+      Path: '/fake/',
+      RoleName: 'my-role',
+      Condition: 'Always',
+      DependsOn: 'AnotherThing'
+    });
 
-  assert.end();
+    const template = cf.merge(
+      { Conditions: { Always: cf.equals('1', '1') } },
+      { Resources: { AnotherThing: { Type: 'AWS::SNS::Topic' } } },
+      role
+    );
+    if (update) fixtures.update('service-role-no-defaults', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('service-role-no-defaults'));
+  });
 });
 
-test('[shortcuts] glue database', (assert) => {
-  assert.throws(
-    () => new cf.shortcuts.GlueDatabase(),
-    'Options required',
-    'throws without options'
-  );
-  assert.throws(
-    () => new cf.shortcuts.GlueDatabase({}),
-    /You must provide a LogicalName and Name/,
-    'throws without required parameters'
-  );
+describe('[shortcuts] glue database', () => {
+  test('throws without options', () => {
+    expect(() => new cf.shortcuts.GlueDatabase()).toThrow('Options required');
+  });
 
-  let db = new cf.shortcuts.GlueDatabase({
-    LogicalName: 'MyDatabase',
-    Name: 'my_database'
+  test('throws without required parameters', () => {
+    expect(() => new cf.shortcuts.GlueDatabase({})).toThrow(/You must provide a LogicalName and Name/);
   });
 
-  let template = cf.merge(db);
-  if (update) fixtures.update('glue-database-defaults', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('glue-database-defaults'),
-    'expected resources generated with defaults'
-  );
+  test('expected resources generated with defaults', () => {
+    const db = new cf.shortcuts.GlueDatabase({
+      LogicalName: 'MyDatabase',
+      Name: 'my_database'
+    });
 
-  db = new cf.shortcuts.GlueDatabase({
-    LogicalName: 'MyDatabase',
-    Name: 'my_database',
-    CatalogId: '123456',
-    Description: 'my_database description',
-    LocationUri: 'fakeuri',
-    Parameters: { thing: 'a' },
-    Condition: 'Always',
-    DependsOn: 'AnotherThing'
-  });
-
-  template = cf.merge(
-    { Conditions: { Always: cf.equals('1', '1') } },
-    { Resources: { AnotherThing: { Type: 'AWS::SNS::Topic' } } },
-    db
-  );
-  if (update) fixtures.update('glue-database-no-defaults', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('glue-database-no-defaults'),
-    'expected resources generated without defaults'
-  );
+    const template = cf.merge(db);
+    if (update) fixtures.update('glue-database-defaults', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('glue-database-defaults'));
+  });
+
+  test('expected resources generated without defaults', () => {
+    const db = new cf.shortcuts.GlueDatabase({
+      LogicalName: 'MyDatabase',
+      Name: 'my_database',
+      CatalogId: '123456',
+      Description: 'my_database description',
+      LocationUri: 'fakeuri',
+      Parameters: { thing: 'a' },
+      Condition: 'Always',
+      DependsOn: 'AnotherThing'
+    });
 
-  assert.end();
+    const template = cf.merge(
+      { Conditions: { Always: cf.equals('1', '1') } },
+      { Resources: { AnotherThing: { Type: 'AWS::SNS::Topic' } } },
+      db
+    );
+    if (update) fixtures.update('glue-database-no-defaults', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('glue-database-no-defaults'));
+  });
 });
 
-test('[shortcuts] glue table', (assert) => {
-  assert.throws(
-    () => new cf.shortcuts.GlueTable(),
-    'Options required',
-    'throws without options'
-  );
-  assert.throws(
-    () => new cf.shortcuts.GlueTable({}),
-    /You must provide a LogicalName, Name, DatabaseName, and Columns/,
-    'throws without required parameters'
-  );
+describe('[shortcuts] glue table', () => {
+  test('throws without options', () => {
+    expect(() => new cf.shortcuts.GlueTable()).toThrow('Options required');
+  });
 
-  let db = new cf.shortcuts.GlueTable({
-    LogicalName: 'MyTable',
-    DatabaseName: 'my_database',
-    Name: 'my_table',
-    Columns: [
-      { Name: 'column', Type: 'string' }
-    ]
-  });
-
-  let template = cf.merge(db);
-  if (update) fixtures.update('glue-table-defaults', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('glue-table-defaults'),
-    'expected resources generated with defaults'
-  );
+  test('throws without required parameters', () => {
+    expect(() => new cf.shortcuts.GlueTable({})).toThrow(/You must provide a LogicalName, Name, DatabaseName, and Columns/);
+  });
 
-  db = new cf.shortcuts.GlueTable({
-    LogicalName: 'MyTable',
-    DatabaseName: 'my_database',
-    Name: 'my_table',
-    Columns: [
-      { Name: 'column', Type: 'string' }
-    ],
-    CatalogId: '1234',
-    Owner: 'Team',
-    Parameters: { table: 'params' },
-    Description: 'my_table description',
-    Retention: 12,
-    TableType: 'EXTERNAL_TABLE',
-    ViewExpandedText: '/* Presto View */',
-    ViewOriginalText: '/* Presto View: abc123= */',
-    BucketColumns: ['column'],
-    Compressed: true,
-    InputFormat: 'fake.input.format',
-    Location: 's3://fake/location',
-    OutputFormat: 'fake.output.format',
-    StorageParameters: { storage: 'parameters' },
-    SerdeInfo: {
-      SerializationLibrary: 'fake.serde'
-    },
-    SkewedColumns: {
-      SkewedColumnNames: ['column'],
-      SkewedColumnValueLocationMap: { fake: 'map' },
-      SkewedColumnValues: ['value']
-    },
-    SortColumns: [
-      { Column: 'column', SortOrder: 0 }
-    ],
-    StoredAsSubdirectory: true,
-    Condition: 'Always',
-    DependsOn: 'AnotherThing'
-  });
-
-  template = cf.merge(
-    { Conditions: { Always: cf.equals('1', '1') } },
-    { Resources: { AnotherThing: { Type: 'AWS::SNS::Topic' } } },
-    db
-  );
-  if (update) fixtures.update('glue-table-no-defaults', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('glue-table-no-defaults'),
-    'expected resources generated without defaults'
-  );
+  test('expected resources generated with defaults', () => {
+    const db = new cf.shortcuts.GlueTable({
+      LogicalName: 'MyTable',
+      DatabaseName: 'my_database',
+      Name: 'my_table',
+      Columns: [
+        { Name: 'column', Type: 'string' }
+      ]
+    });
+
+    const template = cf.merge(db);
+    if (update) fixtures.update('glue-table-defaults', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('glue-table-defaults'));
+  });
 
-  assert.end();
+  test('expected resources generated without defaults', () => {
+    const db = new cf.shortcuts.GlueTable({
+      LogicalName: 'MyTable',
+      DatabaseName: 'my_database',
+      Name: 'my_table',
+      Columns: [
+        { Name: 'column', Type: 'string' }
+      ],
+      CatalogId: '1234',
+      Owner: 'Team',
+      Parameters: { table: 'params' },
+      Description: 'my_table description',
+      Retention: 12,
+      TableType: 'EXTERNAL_TABLE',
+      ViewExpandedText: '/* Presto View */',
+      ViewOriginalText: '/* Presto View: abc123= */',
+      BucketColumns: ['column'],
+      Compressed: true,
+      InputFormat: 'fake.input.format',
+      Location: 's3://fake/location',
+      OutputFormat: 'fake.output.format',
+      StorageParameters: { storage: 'parameters' },
+      SerdeInfo: {
+        SerializationLibrary: 'fake.serde'
+      },
+      SkewedColumns: {
+        SkewedColumnNames: ['column'],
+        SkewedColumnValueLocationMap: { fake: 'map' },
+        SkewedColumnValues: ['value']
+      },
+      SortColumns: [
+        { Column: 'column', SortOrder: 0 }
+      ],
+      StoredAsSubdirectory: true,
+      Condition: 'Always',
+      DependsOn: 'AnotherThing'
+    });
+
+    const template = cf.merge(
+      { Conditions: { Always: cf.equals('1', '1') } },
+      { Resources: { AnotherThing: { Type: 'AWS::SNS::Topic' } } },
+      db
+    );
+    if (update) fixtures.update('glue-table-no-defaults', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('glue-table-no-defaults'));
+  });
 });
 
-test('[shortcuts] glue json table', (assert) => {
-  assert.throws(
-    () => new cf.shortcuts.GlueJsonTable(),
-    'Options required',
-    'throws without options'
-  );
-  assert.throws(
-    () => new cf.shortcuts.GlueJsonTable({}),
-    /You must provide a Location/,
-    'throws without required parameters'
-  );
+describe('[shortcuts] glue json table', () => {
+  test('throws without options', () => {
+    expect(() => new cf.shortcuts.GlueJsonTable()).toThrow('Options required');
+  });
 
-  let db = new cf.shortcuts.GlueJsonTable({
-    LogicalName: 'MyTable',
-    DatabaseName: 'my_database',
-    Name: 'my_table',
-    Columns: [
-      { Name: 'column', Type: 'string' }
-    ],
-    Location: 's3://fake/location'
-  });
-
-  let template = cf.merge(db);
-  if (update) fixtures.update('glue-json-table-defaults', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('glue-json-table-defaults'),
-    'expected resources generated with defaults'
-  );
+  test('throws without required parameters', () => {
+    expect(() => new cf.shortcuts.GlueJsonTable({})).toThrow(/You must provide a Location/);
+  });
 
-  db = new cf.shortcuts.GlueJsonTable({
-    LogicalName: 'MyTable',
-    DatabaseName: 'my_database',
-    Name: 'my_table',
-    Columns: [
-      { Name: 'column', Type: 'string' }
-    ],
-    CatalogId: '1234',
-    Owner: 'Team',
-    Parameters: { table: 'params' },
-    Description: 'my_table description',
-    Retention: 12,
-    TableType: 'EXTERNAL_TABLE',
-    ViewExpandedText: '/* Presto View */',
-    ViewOriginalText: '/* Presto View: abc123= */',
-    BucketColumns: ['column'],
-    Compressed: true,
-    Location: 's3://fake/location',
-    InputFormat: 'fake.input.format',
-    OutputFormat: 'fake.output.format',
-    StorageParameters: { storage: 'parameters' },
-    SerdeInfo: {
-      SerializationLibrary: 'fake.serde'
-    },
-    SkewedColumns: {
-      SkewedColumnNames: ['column'],
-      SkewedColumnValueLocationMap: { fake: 'map' },
-      SkewedColumnValues: ['value']
-    },
-    SortColumns: [
-      { Column: 'column', SortOrder: 0 }
-    ],
-    StoredAsSubdirectory: true,
-    Condition: 'Always',
-    DependsOn: 'AnotherThing'
-  });
-
-  template = cf.merge(
-    { Conditions: { Always: cf.equals('1', '1') } },
-    { Resources: { AnotherThing: { Type: 'AWS::SNS::Topic' } } },
-    db
-  );
-  if (update) fixtures.update('glue-json-table-no-defaults', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('glue-json-table-no-defaults'),
-    'expected resources generated without defaults'
-  );
+  test('expected resources generated with defaults', () => {
+    const db = new cf.shortcuts.GlueJsonTable({
+      LogicalName: 'MyTable',
+      DatabaseName: 'my_database',
+      Name: 'my_table',
+      Columns: [
+        { Name: 'column', Type: 'string' }
+      ],
+      Location: 's3://fake/location'
+    });
 
-  assert.end();
+    const template = cf.merge(db);
+    if (update) fixtures.update('glue-json-table-defaults', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('glue-json-table-defaults'));
+  });
+
+  test('expected resources generated without defaults', () => {
+    const db = new cf.shortcuts.GlueJsonTable({
+      LogicalName: 'MyTable',
+      DatabaseName: 'my_database',
+      Name: 'my_table',
+      Columns: [
+        { Name: 'column', Type: 'string' }
+      ],
+      CatalogId: '1234',
+      Owner: 'Team',
+      Parameters: { table: 'params' },
+      Description: 'my_table description',
+      Retention: 12,
+      TableType: 'EXTERNAL_TABLE',
+      ViewExpandedText: '/* Presto View */',
+      ViewOriginalText: '/* Presto View: abc123= */',
+      BucketColumns: ['column'],
+      Compressed: true,
+      Location: 's3://fake/location',
+      InputFormat: 'fake.input.format',
+      OutputFormat: 'fake.output.format',
+      StorageParameters: { storage: 'parameters' },
+      SerdeInfo: {
+        SerializationLibrary: 'fake.serde'
+      },
+      SkewedColumns: {
+        SkewedColumnNames: ['column'],
+        SkewedColumnValueLocationMap: { fake: 'map' },
+        SkewedColumnValues: ['value']
+      },
+      SortColumns: [
+        { Column: 'column', SortOrder: 0 }
+      ],
+      StoredAsSubdirectory: true,
+      Condition: 'Always',
+      DependsOn: 'AnotherThing'
+    });
+
+    const template = cf.merge(
+      { Conditions: { Always: cf.equals('1', '1') } },
+      { Resources: { AnotherThing: { Type: 'AWS::SNS::Topic' } } },
+      db
+    );
+    if (update) fixtures.update('glue-json-table-no-defaults', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('glue-json-table-no-defaults'));
+  });
 });
 
-test('[shortcuts] glue orc table', (assert) => {
-  assert.throws(
-    () => new cf.shortcuts.GlueOrcTable(),
-    'Options required',
-    'throws without options'
-  );
-  assert.throws(
-    () => new cf.shortcuts.GlueOrcTable({}),
-    /You must provide a Location/,
-    'throws without required parameters'
-  );
+describe('[shortcuts] glue orc table', () => {
+  test('throws without options', () => {
+    expect(() => new cf.shortcuts.GlueOrcTable()).toThrow('Options required');
+  });
 
-  let db = new cf.shortcuts.GlueOrcTable({
-    LogicalName: 'MyTable',
-    DatabaseName: 'my_database',
-    Name: 'my_table',
-    Columns: [
-      { Name: 'column', Type: 'string' }
-    ],
-    Location: 's3://fake/location'
-  });
-
-  let template = cf.merge(db);
-  if (update) fixtures.update('glue-orc-table-defaults', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('glue-orc-table-defaults'),
-    'expected resources generated with defaults'
-  );
+  test('throws without required parameters', () => {
+    expect(() => new cf.shortcuts.GlueOrcTable({})).toThrow(/You must provide a Location/);
+  });
 
-  db = new cf.shortcuts.GlueOrcTable({
-    LogicalName: 'MyTable',
-    DatabaseName: 'my_database',
-    Name: 'my_table',
-    Columns: [
-      { Name: 'column', Type: 'string' }
-    ],
-    CatalogId: '1234',
-    Owner: 'Team',
-    Parameters: { table: 'params' },
-    Description: 'my_table description',
-    Retention: 12,
-    TableType: 'EXTERNAL_TABLE',
-    ViewExpandedText: '/* Presto View */',
-    ViewOriginalText: '/* Presto View: abc123= */',
-    BucketColumns: ['column'],
-    Compressed: true,
-    Location: 's3://fake/location',
-    InputFormat: 'fake.input.format',
-    OutputFormat: 'fake.output.format',
-    StorageParameters: { storage: 'parameters' },
-    SerdeInfo: {
-      SerializationLibrary: 'fake.serde'
-    },
-    SkewedColumns: {
-      SkewedColumnNames: ['column'],
-      SkewedColumnValueLocationMap: { fake: 'map' },
-      SkewedColumnValues: ['value']
-    },
-    SortColumns: [
-      { Column: 'column', SortOrder: 0 }
-    ],
-    StoredAsSubdirectory: true,
-    Condition: 'Always',
-    DependsOn: 'AnotherThing'
-  });
-
-  template = cf.merge(
-    { Conditions: { Always: cf.equals('1', '1') } },
-    { Resources: { AnotherThing: { Type: 'AWS::SNS::Topic' } } },
-    db
-  );
-  if (update) fixtures.update('glue-orc-table-no-defaults', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('glue-orc-table-no-defaults'),
-    'expected resources generated without defaults'
-  );
+  test('expected resources generated with defaults', () => {
+    const db = new cf.shortcuts.GlueOrcTable({
+      LogicalName: 'MyTable',
+      DatabaseName: 'my_database',
+      Name: 'my_table',
+      Columns: [
+        { Name: 'column', Type: 'string' }
+      ],
+      Location: 's3://fake/location'
+    });
+
+    const template = cf.merge(db);
+    if (update) fixtures.update('glue-orc-table-defaults', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('glue-orc-table-defaults'));
+  });
+
+  test('expected resources generated without defaults', () => {
+    const db = new cf.shortcuts.GlueOrcTable({
+      LogicalName: 'MyTable',
+      DatabaseName: 'my_database',
+      Name: 'my_table',
+      Columns: [
+        { Name: 'column', Type: 'string' }
+      ],
+      CatalogId: '1234',
+      Owner: 'Team',
+      Parameters: { table: 'params' },
+      Description: 'my_table description',
+      Retention: 12,
+      TableType: 'EXTERNAL_TABLE',
+      ViewExpandedText: '/* Presto View */',
+      ViewOriginalText: '/* Presto View: abc123= */',
+      BucketColumns: ['column'],
+      Compressed: true,
+      Location: 's3://fake/location',
+      InputFormat: 'fake.input.format',
+      OutputFormat: 'fake.output.format',
+      StorageParameters: { storage: 'parameters' },
+      SerdeInfo: {
+        SerializationLibrary: 'fake.serde'
+      },
+      SkewedColumns: {
+        SkewedColumnNames: ['column'],
+        SkewedColumnValueLocationMap: { fake: 'map' },
+        SkewedColumnValues: ['value']
+      },
+      SortColumns: [
+        { Column: 'column', SortOrder: 0 }
+      ],
+      StoredAsSubdirectory: true,
+      Condition: 'Always',
+      DependsOn: 'AnotherThing'
+    });
 
-  assert.end();
+    const template = cf.merge(
+      { Conditions: { Always: cf.equals('1', '1') } },
+      { Resources: { AnotherThing: { Type: 'AWS::SNS::Topic' } } },
+      db
+    );
+    if (update) fixtures.update('glue-orc-table-no-defaults', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('glue-orc-table-no-defaults'));
+  });
 });
 
-test('[shortcuts] glue parquet table', (assert) => {
-  assert.throws(
-    () => new cf.shortcuts.GlueParquetTable(),
-    'Options required',
-    'throws without options'
-  );
-  assert.throws(
-    () => new cf.shortcuts.GlueParquetTable({}),
-    /You must provide a Location/,
-    'throws without required parameters'
-  );
+describe('[shortcuts] glue parquet table', () => {
+  test('throws without options', () => {
+    expect(() => new cf.shortcuts.GlueParquetTable()).toThrow('Options required');
+  });
 
-  let db = new cf.shortcuts.GlueParquetTable({
-    LogicalName: 'MyTable',
-    DatabaseName: 'my_database',
-    Name: 'my_table',
-    Columns: [
-      { Name: 'column', Type: 'string' }
-    ],
-    Location: 's3://fake/location'
-  });
-
-  let template = cf.merge(db);
-  if (update) fixtures.update('glue-parquet-table-defaults', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('glue-parquet-table-defaults'),
-    'expected resources generated with defaults'
-  );
+  test('throws without required parameters', () => {
+    expect(() => new cf.shortcuts.GlueParquetTable({})).toThrow(/You must provide a Location/);
+  });
 
-  db = new cf.shortcuts.GlueParquetTable({
-    LogicalName: 'MyTable',
-    DatabaseName: 'my_database',
-    Name: 'my_table',
-    Columns: [
-      { Name: 'column', Type: 'string' }
-    ],
-    CatalogId: '1234',
-    Owner: 'Team',
-    Parameters: { table: 'params' },
-    Description: 'my_table description',
-    Retention: 12,
-    TableType: 'EXTERNAL_TABLE',
-    ViewExpandedText: '/* Presto View */',
-    ViewOriginalText: '/* Presto View: abc123= */',
-    BucketColumns: ['column'],
-    Compressed: true,
-    Location: 's3://fake/location',
-    InputFormat: 'fake.input.format',
-    OutputFormat: 'fake.output.format',
-    StorageParameters: { storage: 'parameters' },
-    SerdeInfo: {
-      SerializationLibrary: 'fake.serde'
-    },
-    SkewedColumns: {
-      SkewedColumnNames: ['column'],
-      SkewedColumnValueLocationMap: { fake: 'map' },
-      SkewedColumnValues: ['value']
-    },
-    SortColumns: [
-      { Column: 'column', SortOrder: 0 }
-    ],
-    StoredAsSubdirectory: true,
-    Condition: 'Always',
-    DependsOn: 'AnotherThing'
-  });
-
-  template = cf.merge(
-    { Conditions: { Always: cf.equals('1', '1') } },
-    { Resources: { AnotherThing: { Type: 'AWS::SNS::Topic' } } },
-    db
-  );
-  if (update) fixtures.update('glue-parquet-table-no-defaults', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('glue-parquet-table-no-defaults'),
-    'expected resources generated without defaults'
-  );
+  test('expected resources generated with defaults', () => {
+    const db = new cf.shortcuts.GlueParquetTable({
+      LogicalName: 'MyTable',
+      DatabaseName: 'my_database',
+      Name: 'my_table',
+      Columns: [
+        { Name: 'column', Type: 'string' }
+      ],
+      Location: 's3://fake/location'
+    });
+
+    const template = cf.merge(db);
+    if (update) fixtures.update('glue-parquet-table-defaults', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('glue-parquet-table-defaults'));
+  });
+
+  test('expected resources generated without defaults', () => {
+    const db = new cf.shortcuts.GlueParquetTable({
+      LogicalName: 'MyTable',
+      DatabaseName: 'my_database',
+      Name: 'my_table',
+      Columns: [
+        { Name: 'column', Type: 'string' }
+      ],
+      CatalogId: '1234',
+      Owner: 'Team',
+      Parameters: { table: 'params' },
+      Description: 'my_table description',
+      Retention: 12,
+      TableType: 'EXTERNAL_TABLE',
+      ViewExpandedText: '/* Presto View */',
+      ViewOriginalText: '/* Presto View: abc123= */',
+      BucketColumns: ['column'],
+      Compressed: true,
+      Location: 's3://fake/location',
+      InputFormat: 'fake.input.format',
+      OutputFormat: 'fake.output.format',
+      StorageParameters: { storage: 'parameters' },
+      SerdeInfo: {
+        SerializationLibrary: 'fake.serde'
+      },
+      SkewedColumns: {
+        SkewedColumnNames: ['column'],
+        SkewedColumnValueLocationMap: { fake: 'map' },
+        SkewedColumnValues: ['value']
+      },
+      SortColumns: [
+        { Column: 'column', SortOrder: 0 }
+      ],
+      StoredAsSubdirectory: true,
+      Condition: 'Always',
+      DependsOn: 'AnotherThing'
+    });
 
-  assert.end();
+    const template = cf.merge(
+      { Conditions: { Always: cf.equals('1', '1') } },
+      { Resources: { AnotherThing: { Type: 'AWS::SNS::Topic' } } },
+      db
+    );
+    if (update) fixtures.update('glue-parquet-table-no-defaults', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('glue-parquet-table-no-defaults'));
+  });
 });
 
-test('[shortcuts] glue view', (assert) => {
-  assert.throws(
-    () => new cf.shortcuts.GluePrestoView(),
-    'Options required',
-    'throws without options'
-  );
-  assert.throws(
-    () => new cf.shortcuts.GluePrestoView({}),
-    /You must provide a DatabaseName, Columns, and OriginalSql/,
-    'throws without required parameters'
-  );
+describe('[shortcuts] glue view', () => {
+  test('throws without options', () => {
+    expect(() => new cf.shortcuts.GluePrestoView()).toThrow('Options required');
+  });
 
-  let db = new cf.shortcuts.GluePrestoView({
-    LogicalName: 'MyView',
-    DatabaseName: 'my_database',
-    Name: 'my_view',
-    Columns: [
-      { Name: 'column', Type: 'string' }
-    ],
-    OriginalSql: 'SELECT * FROM another.table'
-  });
-
-  let template = cf.merge(db);
-  if (update) fixtures.update('glue-view-defaults', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('glue-view-defaults'),
-    'expected resources generated with defaults'
-  );
+  test('throws without required parameters', () => {
+    expect(() => new cf.shortcuts.GluePrestoView({})).toThrow(/You must provide a DatabaseName, Columns, and OriginalSql/);
+  });
 
-  db = new cf.shortcuts.GluePrestoView({
-    LogicalName: 'MyTable',
-    DatabaseName: 'my_database',
-    Name: 'my_view',
-    Columns: [
-      { Name: 'column', Type: 'string' }
-    ],
-    OriginalSql: 'SELECT * FROM another.table',
-    CatalogId: '1234',
-    Owner: 'Team',
-    Parameters: { table: 'params' },
-    Description: 'my_view description',
-    Retention: 12,
-    TableType: 'EXTERNAL_TABLE',
-    BucketColumns: ['column'],
-    Compressed: true,
-    Location: 's3://fake/location',
-    InputFormat: 'fake.input.format',
-    OutputFormat: 'fake.output.format',
-    StorageParameters: { storage: 'parameters' },
-    SerdeInfo: {
-      SerializationLibrary: 'fake.serde'
-    },
-    SkewedColumns: {
-      SkewedColumnNames: ['column'],
-      SkewedColumnValueLocationMap: { fake: 'map' },
-      SkewedColumnValues: ['value']
-    },
-    SortColumns: [
-      { Column: 'column', SortOrder: 0 }
-    ],
-    StoredAsSubdirectory: true,
-    SqlVariables: { env: { Ref: 'AWS::StackName' } },
-    Condition: 'Always',
-    DependsOn: 'AnotherThing'
-  });
-
-  template = cf.merge(
-    { Conditions: { Always: cf.equals('1', '1') } },
-    { Resources: { AnotherThing: { Type: 'AWS::SNS::Topic' } } },
-    db
-  );
-  if (update) fixtures.update('glue-view-no-defaults', template);
-  assert.deepEqual(
-    noUndefined(template),
-    fixtures.get('glue-view-no-defaults'),
-    'expected resources generated without defaults'
-  );
+  test('expected resources generated with defaults', () => {
+    const db = new cf.shortcuts.GluePrestoView({
+      LogicalName: 'MyView',
+      DatabaseName: 'my_database',
+      Name: 'my_view',
+      Columns: [
+        { Name: 'column', Type: 'string' }
+      ],
+      OriginalSql: 'SELECT * FROM another.table'
+    });
 
-  assert.end();
+    const template = cf.merge(db);
+    if (update) fixtures.update('glue-view-defaults', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('glue-view-defaults'));
+  });
+
+  test('expected resources generated without defaults', () => {
+    const db = new cf.shortcuts.GluePrestoView({
+      LogicalName: 'MyTable',
+      DatabaseName: 'my_database',
+      Name: 'my_view',
+      Columns: [
+        { Name: 'column', Type: 'string' }
+      ],
+      OriginalSql: 'SELECT * FROM another.table',
+      CatalogId: '1234',
+      Owner: 'Team',
+      Parameters: { table: 'params' },
+      Description: 'my_view description',
+      Retention: 12,
+      TableType: 'EXTERNAL_TABLE',
+      BucketColumns: ['column'],
+      Compressed: true,
+      Location: 's3://fake/location',
+      InputFormat: 'fake.input.format',
+      OutputFormat: 'fake.output.format',
+      StorageParameters: { storage: 'parameters' },
+      SerdeInfo: {
+        SerializationLibrary: 'fake.serde'
+      },
+      SkewedColumns: {
+        SkewedColumnNames: ['column'],
+        SkewedColumnValueLocationMap: { fake: 'map' },
+        SkewedColumnValues: ['value']
+      },
+      SortColumns: [
+        { Column: 'column', SortOrder: 0 }
+      ],
+      StoredAsSubdirectory: true,
+      SqlVariables: { env: { Ref: 'AWS::StackName' } },
+      Condition: 'Always',
+      DependsOn: 'AnotherThing'
+    });
+
+    const template = cf.merge(
+      { Conditions: { Always: cf.equals('1', '1') } },
+      { Resources: { AnotherThing: { Type: 'AWS::SNS::Topic' } } },
+      db
+    );
+    if (update) fixtures.update('glue-view-no-defaults', template);
+    expect(noUndefined(template)).toEqual(fixtures.get('glue-view-no-defaults'));
+  });
 });
 
 const normalizeDeployment = (template) => {
@@ -1540,230 +1327,192 @@ const normalizeDeployment = (template) => {
   return JSON.parse(str);
 };
 
-test('[shortcuts] hookshot passthrough', (assert) => {
-  assert.throws(
-    () => new cf.shortcuts.hookshot.Passthrough(),
-    'Options required',
-    'throws without options'
-  );
-  assert.throws(
-    () => new cf.shortcuts.hookshot.Passthrough({}),
-    /You must provide a Prefix, and PassthroughTo/,
-    'throws without required parameters'
-  );
+describe('[shortcuts] hookshot passthrough', () => {
+  test('throws without options', () => {
+    expect(() => new cf.shortcuts.hookshot.Passthrough()).toThrow('Options required');
+  });
 
-  assert.throws(
-    () =>
-      new cf.shortcuts.hookshot.Passthrough({
-        Prefix: 'Pass',
-        PassthroughTo: 'Destination',
-        LoggingLevel: 'HAM'
-      }),
-    /LoggingLevel must be one of OFF, INFO, or ERROR/,
-    'throws with invalid LoggingLevel'
-  );
+  test('throws without required parameters', () => {
+    expect(() => new cf.shortcuts.hookshot.Passthrough({})).toThrow(/You must provide a Prefix, and PassthroughTo/);
+  });
 
-  assert.throws(
-    () =>
-      new cf.shortcuts.hookshot.Passthrough({
-        Prefix: 'Pass',
-        PassthroughTo: 'Destination',
-        LoggingLevel: 'INFO',
-        Runtime: 'python3.7'
-      }),
-    /Only valid nodejs runtimes are supported for hookshot lambdas, received: 'python3.7'/,
-    'throws with invalid lambda Runtime python3.7'
-  );
+  test('throws with invalid LoggingLevel', () => {
+    expect(() => new cf.shortcuts.hookshot.Passthrough({
+      Prefix: 'Pass',
+      PassthroughTo: 'Destination',
+      LoggingLevel: 'HAM'
+    })).toThrow(/LoggingLevel must be one of OFF, INFO, or ERROR/);
+  });
 
-  assert.throws(
-    () =>
-      new cf.shortcuts.hookshot.Passthrough({
-        Prefix: 'Pass',
-        PassthroughTo: 'Destination',
-        LoggingLevel: 'INFO',
-        Runtime: 'nodejs16.x'
-      }),
-    /Only nodejs runtimes >= 18 are supported for hookshot lambdas, received: 'nodejs16.x'/,
-    'throws with invalid lambda Runtime nodejs16.x'
-  );
+  test('throws with invalid lambda Runtime python3.7', () => {
+    expect(() => new cf.shortcuts.hookshot.Passthrough({
+      Prefix: 'Pass',
+      PassthroughTo: 'Destination',
+      LoggingLevel: 'INFO',
+      Runtime: 'python3.7'
+    })).toThrow(/Only valid nodejs runtimes are supported for hookshot lambdas, received: 'python3.7'/);
+  });
 
-  const to = new cf.shortcuts.Lambda({
+  test('throws with invalid lambda Runtime nodejs16.x', () => {
+    expect(() => new cf.shortcuts.hookshot.Passthrough({
+      Prefix: 'Pass',
+      PassthroughTo: 'Destination',
+      LoggingLevel: 'INFO',
+      Runtime: 'nodejs16.x'
+    })).toThrow(/Only nodejs runtimes >= 18 are supported for hookshot lambdas, received: 'nodejs16.x'/);
+  });
+
+  const getDestinationLambda = () => new cf.shortcuts.Lambda({
     LogicalName: 'Destination',
     Code: {
       ZipFile: 'module.exports.handler = (e, c, cb) => cb();'
     }
   });
 
-  let passthrough = new cf.shortcuts.hookshot.Passthrough({
-    Prefix: 'Pass',
-    PassthroughTo: 'Destination'
+  test('expected resources generated with defaults', () => {
+    const to = getDestinationLambda();
+    const passthrough = new cf.shortcuts.hookshot.Passthrough({
+      Prefix: 'Pass',
+      PassthroughTo: 'Destination'
+    });
+
+    const template = cf.merge(passthrough, to);
+    if (update) fixtures.update('hookshot-passthrough', template);
+    expect(normalizeDeployment(noUndefined(template))).toEqual(normalizeDeployment(fixtures.get('hookshot-passthrough')));
   });
 
-  let template = cf.merge(passthrough, to);
-  if (update) fixtures.update('hookshot-passthrough', template);
-  assert.deepEqual(
-    normalizeDeployment(noUndefined(template)),
-    normalizeDeployment(fixtures.get('hookshot-passthrough')),
-    'expected resources generated with defaults'
-  );
+  test('expected resources generated with alarm config', () => {
+    const to = getDestinationLambda();
+    const passthrough = new cf.shortcuts.hookshot.Passthrough({
+      Prefix: 'Pass',
+      PassthroughTo: 'Destination',
+      AlarmActions: ['devnull@mapbox.com']
+    });
 
-  passthrough = new cf.shortcuts.hookshot.Passthrough({
-    Prefix: 'Pass',
-    PassthroughTo: 'Destination',
-    AlarmActions: ['devnull@mapbox.com']
+    const template = cf.merge(passthrough, to);
+    if (update) fixtures.update('hookshot-passthrough-alarms', template);
+    expect(normalizeDeployment(noUndefined(template))).toEqual(normalizeDeployment(fixtures.get('hookshot-passthrough-alarms')));
   });
 
-  template = cf.merge(passthrough, to);
-  if (update) fixtures.update('hookshot-passthrough-alarms', template);
-  assert.deepEqual(
-    normalizeDeployment(noUndefined(template)),
-    normalizeDeployment(fixtures.get('hookshot-passthrough-alarms')),
-    'expected resources generated with alarm config'
-  );
+  test('expected resources generated with configured LoggingLevel', () => {
+    const to = getDestinationLambda();
+    const passthrough = new cf.shortcuts.hookshot.Passthrough({
+      Prefix: 'Pass',
+      PassthroughTo: 'Destination',
+      LoggingLevel: 'INFO'
+    });
 
-  passthrough = new cf.shortcuts.hookshot.Passthrough({
-    Prefix: 'Pass',
-    PassthroughTo: 'Destination',
-    LoggingLevel: 'INFO'
+    const template = cf.merge(passthrough, to);
+    if (update) fixtures.update('hookshot-passthrough-logging', template);
+    expect(normalizeDeployment(noUndefined(template))).toEqual(normalizeDeployment(fixtures.get('hookshot-passthrough-logging')));
   });
 
-  template = cf.merge(passthrough, to);
-  if (update) fixtures.update('hookshot-passthrough-logging', template);
-  assert.deepEqual(
-    normalizeDeployment(noUndefined(template)),
-    normalizeDeployment(fixtures.get('hookshot-passthrough-logging')),
-    'expected resources generated with configured LoggingLevel'
-  );
+  test('expected resources generated with detailed logging and metrics', () => {
+    const to = getDestinationLambda();
+    const passthrough = new cf.shortcuts.hookshot.Passthrough({
+      Prefix: 'Pass',
+      PassthroughTo: 'Destination',
+      DataTraceEnabled: true,
+      MetricsEnabled: true
+    });
 
-  passthrough = new cf.shortcuts.hookshot.Passthrough({
-    Prefix: 'Pass',
-    PassthroughTo: 'Destination',
-    DataTraceEnabled: true,
-    MetricsEnabled: true
+    const template = cf.merge(passthrough, to);
+    if (update) fixtures.update('hookshot-passthrough-enhanced-logging', template);
+    expect(normalizeDeployment(noUndefined(template))).toEqual(normalizeDeployment(fixtures.get('hookshot-passthrough-enhanced-logging')));
   });
 
-  template = cf.merge(passthrough, to);
-  if (update)
-    fixtures.update('hookshot-passthrough-enhanced-logging', template);
-  assert.deepEqual(
-    normalizeDeployment(noUndefined(template)),
-    normalizeDeployment(fixtures.get('hookshot-passthrough-enhanced-logging')),
-    'expected resources generated with detailed logging and metrics'
-  );
-
-  passthrough = new cf.shortcuts.hookshot.Passthrough({
-    Prefix: 'Pass',
-    PassthroughTo: 'Destination',
-    DataTraceEnabled: true,
-    MetricsEnabled: true,
-    LoggingLevel: 'INFO'
-  });
-
-  template = cf.merge(passthrough, to);
-  if (update)
-    fixtures.update('hookshot-passthrough-full-blown-logging', template);
-  assert.deepEqual(
-    normalizeDeployment(noUndefined(template)),
-    normalizeDeployment(
-      fixtures.get('hookshot-passthrough-full-blown-logging')
-    ),
-    'LoggingLevel respected with detailed logging and metrics'
-  );
+  test('LoggingLevel respected with detailed logging and metrics', () => {
+    const to = getDestinationLambda();
+    const passthrough = new cf.shortcuts.hookshot.Passthrough({
+      Prefix: 'Pass',
+      PassthroughTo: 'Destination',
+      DataTraceEnabled: true,
+      MetricsEnabled: true,
+      LoggingLevel: 'INFO'
+    });
 
-  passthrough = new cf.shortcuts.hookshot.Passthrough({
-    Prefix: 'Pass',
-    PassthroughTo: 'Destination',
-    AccessLogFormat: '{ "requestId":"$context.requestId" }'
+    const template = cf.merge(passthrough, to);
+    if (update) fixtures.update('hookshot-passthrough-full-blown-logging', template);
+    expect(normalizeDeployment(noUndefined(template))).toEqual(normalizeDeployment(fixtures.get('hookshot-passthrough-full-blown-logging')));
   });
 
-  template = cf.merge(passthrough, to);
-  if (update)
-    fixtures.update('hookshot-passthrough-access-log-format', template);
-  assert.deepEqual(
-    normalizeDeployment(noUndefined(template)),
-    normalizeDeployment(fixtures.get('hookshot-passthrough-access-log-format')),
-    'expected resources generated with access logs'
-  );
+  test('expected resources generated with access logs', () => {
+    const to = getDestinationLambda();
+    const passthrough = new cf.shortcuts.hookshot.Passthrough({
+      Prefix: 'Pass',
+      PassthroughTo: 'Destination',
+      AccessLogFormat: '{ "requestId":"$context.requestId" }'
+    });
 
-  assert.end();
+    const template = cf.merge(passthrough, to);
+    if (update) fixtures.update('hookshot-passthrough-access-log-format', template);
+    expect(normalizeDeployment(noUndefined(template))).toEqual(normalizeDeployment(fixtures.get('hookshot-passthrough-access-log-format')));
+  });
 });
 
-test('[shortcuts] hookshot github', (assert) => {
-  assert.throws(
-    () => new cf.shortcuts.hookshot.Github(),
-    /You must provide a Prefix, and PassthroughTo/,
-    'throws without required parameters'
-  );
+describe('[shortcuts] hookshot github', () => {
+  test('throws without required parameters', () => {
+    expect(() => new cf.shortcuts.hookshot.Github()).toThrow(/You must provide a Prefix, and PassthroughTo/);
+  });
 
-  assert.throws(
-    () =>
-      new cf.shortcuts.hookshot.Github({
-        Prefix: 'Pass',
-        PassthroughTo: 'Destination',
-        Runtime: 'python3.7'
-      }),
-    /Only valid nodejs runtimes are supported for hookshot lambdas, received: 'python3.7'/,
-    'throws with invalid lambda Runtime python3.7'
-  );
+  test('throws with invalid lambda Runtime python3.7', () => {
+    expect(() => new cf.shortcuts.hookshot.Github({
+      Prefix: 'Pass',
+      PassthroughTo: 'Destination',
+      Runtime: 'python3.7'
+    })).toThrow(/Only valid nodejs runtimes are supported for hookshot lambdas, received: 'python3.7'/);
+  });
 
-  assert.throws(
-    () =>
-      new cf.shortcuts.hookshot.Github({
-        Prefix: 'Pass',
-        PassthroughTo: 'Destination',
-        Runtime: 'nodejs16.x'
-      }),
-    /Only nodejs runtimes >= 18 are supported for hookshot lambdas, received: 'nodejs16.x'/,
-    'throws with invalid lambda Runtime nodejs16.x'
-  );
+  test('throws with invalid lambda Runtime nodejs16.x', () => {
+    expect(() => new cf.shortcuts.hookshot.Github({
+      Prefix: 'Pass',
+      PassthroughTo: 'Destination',
+      Runtime: 'nodejs16.x'
+    })).toThrow(/Only nodejs runtimes >= 18 are supported for hookshot lambdas, received: 'nodejs16.x'/);
+  });
 
-  const to = new cf.shortcuts.Lambda({
+  const getDestinationLambda = () => new cf.shortcuts.Lambda({
     LogicalName: 'Destination',
     Code: {
       ZipFile: 'module.exports.handler = (e, c, cb) => cb();'
     }
   });
 
-  let github = new cf.shortcuts.hookshot.Github({
-    Prefix: 'Pass',
-    PassthroughTo: 'Destination'
-  });
-
-  let template = cf.merge(github, to);
-  if (update) fixtures.update('hookshot-github', template);
-  assert.deepEqual(
-    normalizeDeployment(noUndefined(template)),
-    normalizeDeployment(fixtures.get('hookshot-github')),
-    'expected resources generated with defaults'
-  );
+  test('expected resources generated with defaults', () => {
+    const to = getDestinationLambda();
+    const github = new cf.shortcuts.hookshot.Github({
+      Prefix: 'Pass',
+      PassthroughTo: 'Destination'
+    });
 
-  github = new cf.shortcuts.hookshot.Github({
-    Prefix: 'Pass',
-    PassthroughTo: 'Destination',
-    WebhookSecret: 'abc123'
+    const template = cf.merge(github, to);
+    if (update) fixtures.update('hookshot-github', template);
+    expect(normalizeDeployment(noUndefined(template))).toEqual(normalizeDeployment(fixtures.get('hookshot-github')));
   });
 
-  template = cf.merge(github, to);
-  if (update) fixtures.update('hookshot-github-secret-string', template);
-  assert.deepEqual(
-    normalizeDeployment(noUndefined(template)),
-    normalizeDeployment(fixtures.get('hookshot-github-secret-string')),
-    'expected resources generated when secret passed as string'
-  );
+  test('expected resources generated when secret passed as string', () => {
+    const to = getDestinationLambda();
+    const github = new cf.shortcuts.hookshot.Github({
+      Prefix: 'Pass',
+      PassthroughTo: 'Destination',
+      WebhookSecret: 'abc123'
+    });
 
-  github = new cf.shortcuts.hookshot.Github({
-    Prefix: 'Pass',
-    PassthroughTo: 'Destination',
-    WebhookSecret: cf.ref('SomeParameter')
-  });
-  const Parameters = { SomeParameter: { Type: 'String' } };
-  template = cf.merge(github, to, { Parameters });
-  if (update) fixtures.update('hookshot-github-secret-ref', template);
-  assert.deepEqual(
-    normalizeDeployment(noUndefined(template)),
-    normalizeDeployment(fixtures.get('hookshot-github-secret-ref')),
-    'expected resources generated when secret passed as ref'
-  );
+    const template = cf.merge(github, to);
+    if (update) fixtures.update('hookshot-github-secret-string', template);
+    expect(normalizeDeployment(noUndefined(template))).toEqual(normalizeDeployment(fixtures.get('hookshot-github-secret-string')));
+  });
 
-  assert.end();
+  test('expected resources generated when secret passed as ref', () => {
+    const to = getDestinationLambda();
+    const github = new cf.shortcuts.hookshot.Github({
+      Prefix: 'Pass',
+      PassthroughTo: 'Destination',
+      WebhookSecret: cf.ref('SomeParameter')
+    });
+    const Parameters = { SomeParameter: { Type: 'String' } };
+    const template = cf.merge(github, to, { Parameters });
+    if (update) fixtures.update('hookshot-github-secret-ref', template);
+    expect(normalizeDeployment(noUndefined(template))).toEqual(normalizeDeployment(fixtures.get('hookshot-github-secret-ref')));
+  });
 });