architect · ryanblock · Mar 25, 2024 · Feb 26, 2024 · Mar 25, 2024
diff --git a/changelog.md b/changelog.md
@@ -4,6 +4,11 @@
 
 ## [5.0.3] 2024-02-13
 
+### Changed
+
+- Updated dependencies
+
+
 ### Fixed
 
 - Fixed issue where entirely custom Lambda-based projects may error when trying to print the project's URL(s) after deploying

diff --git a/package.json b/package.json
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "test": "npm run lint && npm run test:integration && npm run coverage",
-    "test:unit": "cross-env tape 'test/unit/**/*-test.js' | tap-arc",
+    "test:unit": "cross-env AWS_ACCESS_KEY_ID=\"blah\" AWS_SECRET_ACCESS_KEY=\"blah\" tape 'test/unit/**/*-test.js' | tap-arc",
     "test:slow": "cross-env tape 'test/slow/**/*-test.js' | tap-arc",
     "test:integration": "cross-env AWS_ACCESS_KEY_ID=\"blah\" AWS_SECRET_ACCESS_KEY=\"blah\" tape 'test/integration/**/*-test.js' | tap-arc",
     "coverage": "nyc --reporter=lcov --reporter=text npm run test:unit",
@@ -32,17 +32,17 @@
   },
   "homepage": "https://github.com/architect/deploy#readme",
   "dependencies": {
-    "@architect/create": "~5.0.1",
-    "@architect/hydrate": "~4.0.2",
-    "@architect/inventory": "~4.0.3",
-    "@architect/package": "~9.0.1",
-    "@architect/utils": "~4.0.2",
+    "@architect/create": "~5.0.2",
+    "@architect/hydrate": "~4.0.3",
+    "@architect/inventory": "~4.0.4",
+    "@architect/package": "~9.0.2",
+    "@architect/utils": "~4.0.4",
     "@aws-lite/apigatewayv2": "^0.0.4",
-    "@aws-lite/client": "^0.17.1",
+    "@aws-lite/client": "~0.20.0",
     "@aws-lite/cloudformation": "^0.0.4",
     "@aws-lite/cloudfront": "^0.0.8",
     "@aws-lite/lambda": "^0.0.5",
-    "@aws-lite/s3": "^0.1.18",
+    "@aws-lite/s3": "^0.1.20",
     "@aws-lite/ssm": "^0.2.3",
     "chalk": "4.1.2",
     "fs-extra": "~11.2.0",
@@ -60,12 +60,12 @@
   "devDependencies": {
     "@architect/eslint-config": "~2.1.2",
     "cross-env": "~7.0.3",
-    "eslint": "~8.56.0",
-    "mock-tmp": "~0.0.2",
+    "eslint": "~8.57.0",
+    "mock-tmp": "~0.0.3",
     "nyc": "~15.1.0",
     "proxyquire": "~2.1.3",
     "tap-arc": "~1.2.2",
-    "tape": "~5.7.4"
+    "tape": "~5.7.5"
   },
   "eslintConfig": {
     "extends": "@architect/eslint-config"

diff --git a/test/integration/static/index-test.js b/test/integration/static/index-test.js
@@ -1,15 +1,10 @@
-/* let test = require('tape')
+let test = require('tape')
 let { join } = require('path')
 let mockTmp = require('mock-tmp')
 let proxyquire = require('proxyquire')
 let inventory = require('@architect/inventory')
 let { updater } = require('@architect/utils')
 
-// Necessary to run test solo
-require('aws-sdk/lib/maintenance_mode_message').suppress = true
-let aws = require('aws-sdk')
-let awsMock = require('aws-sdk-mock')
-
 let published
 function publish (params, callback) {
   published = params
@@ -56,18 +51,16 @@ function staticDeploy (t, cwd, callback) {
     }
   })
 }
-*/
+
 /**
  * Notes:
  * - Unfortunately, proxyquire seems to have a nested file folder + `@global` bug, so we can't run this from index
  *   - Instead, we have to run inventory ourselves on each test, which kinda sucks
  * - Also, it'd be nice to test the CloudFormation stackname code path
  */
-/*
 test('Set up env', t => {
   t.plan(1)
   t.ok(staticDeployMod, 'Static asset deployment module is present')
-  new aws.S3()
 })
 
 test(`Skip static deploy if @static isn't defined`, t => {
@@ -168,8 +161,6 @@ test(`Respect prefix setting in project manifest`, t => {
 
 test('Teardown', t => {
   t.plan(1)
-  awsMock.restore()
   reset()
   t.pass('Done')
 })
-*/
diff --git a/test/integration/static/publish/index-test.js b/test/integration/static/publish/index-test.js
@@ -1,10 +1,8 @@
-/* let test = require('tape')
+let test = require('tape')
+let awsLite = require('@aws-lite/client')
 let { join } = require('path')
 let mockTmp = require('mock-tmp')
 let proxyquire = require('proxyquire')
-require('aws-sdk/lib/maintenance_mode_message').suppress = true
-let aws = require('aws-sdk')
-let awsMock = require('aws-sdk-mock')
 let _inventory = require('@architect/inventory')
 let { updater } = require('@architect/utils')
 
@@ -28,44 +26,46 @@ let sut = proxyquire(filePath, {
   './s3/delete-files': deleteFiles
 })
 
-let s3
+let aws
 let defaultParams = () => ({
+  aws,
   Bucket: 'a-bucket',
   folder: 'public',
   inventory,
   prune: false,
   region: 'us-west-1',
-  s3,
   update: updater('Deploy')
 })
 
 let arc = '@app\nan-app\n@static'
 let content = 'hi there'
-let cwd = mockTmp({
-  'app.arc': arc,
-  public: {
-    'index.html':     content,
-    'something.json': content,
-    'index.js':       content,
-  },
-})
 
 function setup () {
   putted = undefined
   deleted = undefined
   params = defaultParams()
+  awsLite.testing.mock('S3.HeadObject', '')
+  awsLite.testing.mock('S3.PutObject', '')
+  awsLite.testing.mock('S3.ListObjectsV2', '')
+  awsLite.testing.mock('S3.DeleteObjects', '')
 }
 
 test('Set up env', async t => {
-  t.plan(2)
+  t.plan(3)
   t.ok(sut, 'S3 publish module is present')
 
-  awsMock.mock('S3', 'headObject', (params, callback) => callback())
-  awsMock.mock('S3', 'putObject', (params, callback) => callback())
-  awsMock.mock('S3', 'listObjectsV2', (params, callback) => callback())
-  awsMock.mock('S3', 'deleteObjects', (params, callback) => callback())
-  s3 = new aws.S3()
+  aws = await awsLite({ region: 'us-west-2', plugins: [ import('@aws-lite/s3') ] })
+  awsLite.testing.enable()
+  t.ok(awsLite.testing.isEnabled(), 'AWS client testing enabled')
 
+  let cwd = mockTmp({
+    'app.arc': arc,
+    public: {
+      'index.html':     content,
+      'something.json': content,
+      'index.js':       content,
+    },
+  })
   inventory = await _inventory({ cwd })
   t.ok(inventory, 'Got inventory obj')
 })
@@ -123,8 +123,7 @@ test(`Static asset deletion (deployAction is 'delete')`, t => {
 
 test('Teardown', t => {
   t.plan(1)
-  awsMock.restore()
   mockTmp.reset()
-  t.pass('Done')
+  awsLite.testing.disable()
+  t.notOk(awsLite.testing.isEnabled(), 'Done')
 })
-*/
diff --git a/test/unit/direct/deploy-test.js b/test/unit/direct/deploy-test.js
@@ -1,5 +1,6 @@
-/* let proxyquire = require('proxyquire')
+let proxyquire = require('proxyquire')
 let test = require('tape')
+let awsLite = require('@aws-lite/client')
 let { updater } = require('@architect/utils')
 let inventory = require('@architect/inventory')
 let { join } = require('path')
@@ -8,15 +9,10 @@ let mocks = { resources: [
   { ResourceType: 'AWS::Lambda::Function', LogicalResourceId: 'GetIndexHTTPLambda' },
 ] }
 
-// Necessary to run test solo
-require('aws-sdk/lib/maintenance_mode_message').suppress = true
-let aws = require('aws-sdk')
-let awsMock = require('aws-sdk-mock')
-
 function fakeGetResources (params, callback) {
   callback(null, mocks.resources)
 }
-let didHydrate
+let aws, didHydrate
 function fakeUpdateLambda (params, callback) {
   didHydrate = params.shouldHydrate
   callback()
@@ -43,6 +39,7 @@ function directDeploy (t, rawArc, lambdas, callback) {
   inventory({ rawArc }, function (err, result) {
     if (err) t.fail(err)
     else {
+      params.aws = aws
       params.inventory = result
       params.specificLambdasToDeploy = lambdas
       directDeployMod(params, err => {
@@ -53,14 +50,13 @@ function directDeploy (t, rawArc, lambdas, callback) {
   })
 }
 
-test('Set up env', t => {
-  t.plan(1)
+test('Set up env', async t => {
+  t.plan(2)
   t.ok(directDeployMod, 'Direct deployment module is present')
-
-  awsMock.mock('CloudFormation', 'describeStacks', function (params, callback) {
-    callback(null, { Stacks: false })
-  })
-  new aws.CloudFormation()
+  aws = await awsLite({ region: 'us-west-2', plugins: [ import('@aws-lite/cloudformation') ] })
+  awsLite.testing.enable()
+  awsLite.testing.mock('CloudFormation.DescribeStacks', { Stacks: false })
+  t.ok(awsLite.testing.isEnabled(), 'AWS client testing enabled')
 })
 
 test('Should be able to deploy an HTTP POST function directly when a root handler function is defined', t => {
@@ -106,7 +102,6 @@ if (!process.platform.startsWith('win')) {
 
 test('Teardown', t => {
   t.plan(1)
-  awsMock.restore()
-  t.pass('Done')
+  awsLite.testing.disable()
+  t.notOk(awsLite.testing.isEnabled(), 'Done')
 })
- */
diff --git a/test/unit/static/publish/s3/delete-files/index-test.js b/test/unit/static/publish/s3/delete-files/index-test.js
@@ -1,14 +1,11 @@
-/* let test = require('tape')
+let test = require('tape')
+let awsLite = require('@aws-lite/client')
 let { join, sep } = require('path')
-require('aws-sdk/lib/maintenance_mode_message').suppress = true
-let aws = require('aws-sdk')
-let awsMock = require('aws-sdk-mock')
-
-let listObjCalls = []
-let delObjCalls = []
-let filesOnS3 = { Contents: [] }
-
 let cwd = process.cwd()
+let filePath = join(cwd, 'src', 'static', 'publish', 's3', 'delete-files')
+let sut = require(filePath)
+
+let aws
 let files = [
   'index.html',
   'folder/something.json',
@@ -17,8 +14,8 @@ let files = [
 let localFiles = arr => arr.map(f => join(cwd, 'public', f.replace('/', sep)))
 let noop = () => {}
 let defaultParams = () => {
-  let s3 = new aws.S3()
   return {
+    aws,
     Bucket: 'a-bucket',
     files: localFiles(files),
     fingerprint: false,
@@ -27,43 +24,39 @@ let defaultParams = () => {
     inventory: { inv: { _project: { cwd } } },
     prefix: undefined,
     region: 'us-west-1',
-    s3,
     staticManifest: {},
     update: { status: noop, raw: noop },
   }
 }
+let filesOnS3 = () => ({ Contents: files.map(Key => ({ Key })) })
+let s3DeleteObjects = params => ({ Deleted: params.Delete.Objects })
+
 
-let filePath = join(cwd, 'src', 'static', 'publish', 's3', 'delete-files')
-let sut = require(filePath)
 
 function reset () {
-  listObjCalls = []
-  delObjCalls = []
-  filesOnS3 = { Contents: [] }
+  awsLite.testing.reset()
 }
 
-test('Set up env', t => {
-  t.plan(1)
+test('Set up env', async t => {
+  t.plan(2)
   t.ok(sut, 'S3 file delete module is present')
-  awsMock.mock('S3', 'listObjectsV2', (params, callback) => {
-    listObjCalls.push(params)
-    callback(null, filesOnS3)
-  })
-  awsMock.mock('S3', 'deleteObjects', (params, callback) => {
-    delObjCalls.push(params)
-    callback(null, { Deleted: params.Delete.Objects })
-  })
+
+  aws = await awsLite({ region: 'us-west-2', plugins: [ import('@aws-lite/s3') ] })
+  awsLite.testing.enable()
+  t.ok(awsLite.testing.isEnabled(), 'AWS client testing enabled')
 })
 
 test('Do not prune if there is nothing to prune', t => {
   t.plan(2)
 
   let params = defaultParams()
-  filesOnS3 = { Contents: files.map(Key => ({ Key })) }
+  awsLite.testing.mock('S3.ListObjectsV2', filesOnS3())
   sut(params, err => {
     if (err) t.fail(err)
-    t.equal(listObjCalls.length, 1, 'S3.listObjectsV2 called once')
-    t.equal(delObjCalls.length, 0, 'S3.deleteObjects not called')
+    let listObjCalls = awsLite.testing.getAllRequests('S3.ListObjectsV2')
+    let delObjCalls = awsLite.testing.getAllRequests('S3.DeleteObjects')
+    t.equal(listObjCalls.length, 1, 'S3.ListObjectsV2 called once')
+    t.notOk(delObjCalls, 'S3.DeleteObjects not called')
     reset()
   })
 })
@@ -73,12 +66,15 @@ test('Prune if there is something to prune', t => {
 
   let params = defaultParams()
   params.files.pop() // Create a pruning opportunity
-  filesOnS3 = { Contents: files.map(Key => ({ Key })) }
+  awsLite.testing.mock('S3.ListObjectsV2', filesOnS3())
+  awsLite.testing.mock('S3.DeleteObjects', s3DeleteObjects)
   sut(params, err => {
     if (err) t.fail(err)
-    t.equal(listObjCalls.length, 1, 'S3.listObjectsV2 called once')
-    t.equal(delObjCalls.length, 1, 'S3.deleteObjects called once')
-    t.equal(delObjCalls[0].Delete.Objects[0].Key, files[files.length - 1], `Pruned correct file: ${files[files.length - 1]}`)
+    let listObjCalls = awsLite.testing.getAllRequests('S3.ListObjectsV2')
+    let delObjCalls = awsLite.testing.getAllRequests('S3.DeleteObjects')
+    t.equal(listObjCalls.length, 1, 'S3.ListObjectsV2 called once')
+    t.equal(delObjCalls.length, 1, 'S3.DeleteObjects called once')
+    t.equal(delObjCalls[0].request.Delete.Objects[0].Key, files[files.length - 1], `Pruned correct file: ${files[files.length - 1]}`)
     reset()
   })
 })
@@ -88,26 +84,32 @@ test('Prune respects ignore', t => {
 
   let params = defaultParams()
   params.files.pop() // Create a pruning opportunity
-  filesOnS3 = { Contents: files.map(Key => ({ Key })) }
+  awsLite.testing.mock('S3.ListObjectsV2', filesOnS3())
   params.ignore = [ 'index.js' ]
   sut(params, err => {
     if (err) t.fail(err)
-    t.equal(listObjCalls.length, 1, 'S3.listObjectsV2 called once')
-    t.equal(delObjCalls.length, 0, 'S3.deleteObjects not called')
+    let listObjCalls = awsLite.testing.getAllRequests('S3.ListObjectsV2')
+    let delObjCalls = awsLite.testing.getAllRequests('S3.DeleteObjects')
+    t.equal(listObjCalls.length, 1, 'S3.ListObjectsV2 called once')
+    t.notOk(delObjCalls, 'S3.DeleteObjects not called')
     reset()
   })
 })
 
 test('Prune does not prefix if prefix is not set', t => {
-  t.plan(2)
+  t.plan(3)
 
   let params = defaultParams()
   params.files.pop() // Create a pruning opportunity
-  filesOnS3 = { Contents: files.map(Key => ({ Key })) }
+  awsLite.testing.mock('S3.ListObjectsV2', filesOnS3())
+  awsLite.testing.mock('S3.DeleteObjects', s3DeleteObjects)
   sut(params, err => {
     if (err) t.fail(err)
-    t.equal(listObjCalls.length, 1, 'S3.listObjectsV2 called once')
-    t.notOk(listObjCalls[0].Prefix, 'S3.listObjectsV2 not called with prefix')
+    let listObjCalls = awsLite.testing.getAllRequests('S3.ListObjectsV2')
+    let delObjCalls = awsLite.testing.getAllRequests('S3.DeleteObjects')
+    t.equal(listObjCalls.length, 1, 'S3.ListObjectsV2 called once')
+    t.notOk(listObjCalls[0].request.Prefix, 'S3.ListObjectsV2 not called with prefix')
+    t.equal(delObjCalls.length, 1, 'S3.DeleteObjects called once')
     reset()
   })
 })
@@ -119,14 +121,17 @@ test('Prune respects prefix setting', t => {
   let prefix = 'a-prefix'
   params.prefix = prefix
   params.files.pop() // Create a pruning opportunity
-  filesOnS3 = { Contents: files.map(Key => ({ Key: `${prefix}/${Key}` })) }
+  awsLite.testing.mock('S3.ListObjectsV2', { Contents: files.map(Key => ({ Key: `${prefix}/${Key}` })) })
+  awsLite.testing.mock('S3.DeleteObjects', s3DeleteObjects)
   sut(params, err => {
     if (err) t.fail(err)
-    t.equal(listObjCalls.length, 1, 'S3.listObjectsV2 called once')
-    t.ok(listObjCalls[0].Prefix, 'S3.listObjectsV2 called with prefix')
-    t.equal(delObjCalls.length, 1, 'S3.deleteObjects called once')
+    let listObjCalls = awsLite.testing.getAllRequests('S3.ListObjectsV2')
+    let delObjCalls = awsLite.testing.getAllRequests('S3.DeleteObjects')
+    t.equal(listObjCalls.length, 1, 'S3.ListObjectsV2 called once')
+    t.ok(listObjCalls[0].request.Prefix, 'S3.ListObjectsV2 called with prefix')
+    t.equal(delObjCalls.length, 1, 'S3.DeleteObjects called once')
     let file = `${prefix}/${files[files.length - 1]}`
-    t.equal(delObjCalls[0].Delete.Objects[0].Key, file, `Pruned correct file: ${file}`)
+    t.equal(delObjCalls[0].request.Delete.Objects[0].Key, file, `Pruned correct file: ${file}`)
     reset()
   })
 })
@@ -142,16 +147,19 @@ test('Prune respects fingerprint setting', t => {
   }
   params.files.pop() // Create a pruning opportunity
   let pruneThis = 'index-df330f3f12.js'
-  filesOnS3 = { Contents: [
+  awsLite.testing.mock('S3.ListObjectsV2', { Contents: [
     { Key: 'index-df330f3f12.html' },
     { Key: 'folder/something-df330f3f12.json' },
     { Key: pruneThis }
-  ] }
+  ] })
+  awsLite.testing.mock('S3.DeleteObjects', s3DeleteObjects)
   sut(params, err => {
     if (err) t.fail(err)
-    t.equal(listObjCalls.length, 1, 'S3.listObjectsV2 called once')
-    t.equal(delObjCalls.length, 1, 'S3.deleteObjects called once')
-    t.equal(delObjCalls[0].Delete.Objects[0].Key, pruneThis, `Pruned correct file: ${pruneThis}`)
+    let listObjCalls = awsLite.testing.getAllRequests('S3.ListObjectsV2')
+    let delObjCalls = awsLite.testing.getAllRequests('S3.DeleteObjects')
+    t.equal(listObjCalls.length, 1, 'S3.ListObjectsV2 called once')
+    t.equal(delObjCalls.length, 1, 'S3.DeleteObjects called once')
+    t.equal(delObjCalls[0].request.Delete.Objects[0].Key, pruneThis, `Pruned correct file: ${pruneThis}`)
     reset()
   })
 })
@@ -169,16 +177,19 @@ test('Prune respects both prefix & fingerprint settings together', t => {
   }
   params.files.pop() // Create a pruning opportunity
   let pruneThis = `${prefix}/index-df330f3f12.js`
-  filesOnS3 = { Contents: [
+  awsLite.testing.mock('S3.ListObjectsV2', { Contents: [
     { Key: `${prefix}/index-df330f3f12.html`, },
     { Key: `${prefix}/folder/something-df330f3f12.json` },
     { Key: pruneThis }
-  ] }
+  ] })
+  awsLite.testing.mock('S3.DeleteObjects', s3DeleteObjects)
   sut(params, err => {
     if (err) t.fail(err)
-    t.equal(listObjCalls.length, 1, 'S3.listObjectsV2 called once')
-    t.equal(delObjCalls.length, 1, 'S3.deleteObjects called once')
-    t.equal(delObjCalls[0].Delete.Objects[0].Key, pruneThis, `Pruned correct file: ${pruneThis}`)
+    let listObjCalls = awsLite.testing.getAllRequests('S3.ListObjectsV2')
+    let delObjCalls = awsLite.testing.getAllRequests('S3.DeleteObjects')
+    t.equal(listObjCalls.length, 1, 'S3.ListObjectsV2 called once')
+    t.equal(delObjCalls.length, 1, 'S3.DeleteObjects called once')
+    t.equal(delObjCalls[0].request.Delete.Objects[0].Key, pruneThis, `Pruned correct file: ${pruneThis}`)
     reset()
   })
 })
@@ -199,23 +210,25 @@ test('Prune respects both prefix & fingerprint settings together in nested folde
     'a-folder/something.json': 'a-folder/something-df330f3f12.json'
   }
   let pruneThis = `${prefix}/a-folder/index-df330f3f12.js`
-  filesOnS3 = { Contents: [
+  awsLite.testing.mock('S3.ListObjectsV2', { Contents: [
     { Key: `${prefix}/index-df330f3f12.html`, },
     { Key: `${prefix}/a-folder/something-df330f3f12.json` },
     { Key: pruneThis }
-  ] }
+  ] })
+  awsLite.testing.mock('S3.DeleteObjects', s3DeleteObjects)
   sut(params, err => {
     if (err) t.fail(err)
-    t.equal(listObjCalls.length, 1, 'S3.listObjectsV2 called once')
-    t.equal(delObjCalls.length, 1, 'S3.deleteObjects called once')
-    t.equal(delObjCalls[0].Delete.Objects[0].Key, pruneThis, `Pruned correct file: ${pruneThis}`)
+    let listObjCalls = awsLite.testing.getAllRequests('S3.ListObjectsV2')
+    let delObjCalls = awsLite.testing.getAllRequests('S3.DeleteObjects')
+    t.equal(listObjCalls.length, 1, 'S3.ListObjectsV2 called once')
+    t.equal(delObjCalls.length, 1, 'S3.DeleteObjects called once')
+    t.equal(delObjCalls[0].request.Delete.Objects[0].Key, pruneThis, `Pruned correct file: ${pruneThis}`)
     reset()
   })
 })
 
 test('Teardown', t => {
   t.plan(1)
-  awsMock.restore()
-  t.pass('Done')
+  awsLite.testing.disable()
+  t.notOk(awsLite.testing.isEnabled(), 'Done')
 })
- */
diff --git a/test/unit/static/publish/s3/put-files/index-test.js b/test/unit/static/publish/s3/put-files/index-test.js
@@ -1,18 +1,20 @@
-/* let test = require('tape')
+let test = require('tape')
+let awsLite = require('@aws-lite/client')
 let mockTmp = require('mock-tmp')
 let proxyquire = require('proxyquire')
 let { join, sep } = require('path')
-require('aws-sdk/lib/maintenance_mode_message').suppress = true
-let aws = require('aws-sdk')
-let awsMock = require('aws-sdk-mock')
 let crypto = require('crypto')
 let { pathToUnix } = require('@architect/utils')
 let cwd = process.cwd()
+let filePath = join(process.cwd(), 'src', 'static', 'publish', 's3', 'put-files')
+let putParams = proxyquire(filePath, {
+  './put-params': ({ Bucket, Key, Body }) => ({
+    Bucket, Key, Body,
+  })
+})
 
-let headObjCalls = []
-let putObjCalls = []
+let aws, tmp
 let CacheControl
-let s3, tmp
 
 function createFileData (diff) {
   return {
@@ -29,68 +31,60 @@ let update = () => {}
 update.raw = () => {}
 
 let params = () => ({
+  aws,
   Bucket: 'a-bucket',
   files,
   fingerprint: false,
   publicDir: 'public',
   prefix: undefined,
   region: 'us-west-1',
-  s3,
   staticManifest: {},
   update,
 })
 
-let _putParams = ({ Bucket, Key, Body }) => ({
-  Bucket, Key, Body,
-})
-
-let filePath = join(process.cwd(), 'src', 'static', 'publish', 's3', 'put-files')
-let putParams = proxyquire(filePath, {
-  './put-params': _putParams
-})
+function headObject (params) {
+  let hash = crypto.createHash('md5').update(fileData[params.Key]).digest('hex')
+  let ETag = `"${hash}"` // AWS double quotes because lol
+  return { ETag, CacheControl }
+}
 
 function setup (data) {
-  headObjCalls = []
-  putObjCalls = []
   CacheControl = undefined
   tmp = mockTmp(data)
   files = Object.keys(data).map(f => f.replace('/', sep))
   process.chdir(tmp)
 }
 function reset () {
+  awsLite.testing.reset()
   mockTmp.reset()
   process.chdir(cwd)
 }
 
-test('Set up env', t => {
-  t.plan(1)
+test('Set up env', async t => {
+  t.plan(2)
   t.ok(putParams, 'S3 file put module is present')
 
-  awsMock.mock('S3', 'headObject', (params, callback) => {
-    headObjCalls.push(params)
-    let hash = crypto.createHash('md5').update(fileData[params.Key]).digest('hex')
-    let ETag = `"${hash}"` // AWS double quotes because lol
-    callback(null, { ETag, CacheControl })
-  })
-  awsMock.mock('S3', 'putObject', (params, callback) => {
-    putObjCalls.push(params)
-    callback()
-  })
-  s3 = new aws.S3()
+  aws = await awsLite({ region: 'us-west-2', plugins: [ import('@aws-lite/s3') ] })
+  awsLite.testing.enable()
+  t.ok(awsLite.testing.isEnabled(), 'AWS client testing enabled')
 })
 
 test('Basic publish test', t => {
   t.plan(4)
   setup(createFileData(true)) // True mutates file contents, causing an upload
+  awsLite.testing.mock('S3.HeadObject', headObject)
+  awsLite.testing.mock('S3.PutObject', {})
 
   putParams(params(), (err, uploaded, notModified) => {
     if (err) t.fail(err)
+    let headObjCalls = awsLite.testing.getAllRequests('S3.HeadObject')
+    let putObjCalls = awsLite.testing.getAllRequests('S3.PutObject')
     let headCallsAreGood =  (headObjCalls.length === files.length) &&
-                            files.every(f => headObjCalls.some(h => h.Key === pathToUnix(f)))
+                            files.every(f => headObjCalls.some(h => h.request.Key === pathToUnix(f)))
     let putCallsAreGood =   (putObjCalls.length === files.length) &&
-                            files.every(f => putObjCalls.some(h => h.Key === pathToUnix(f)))
-    t.ok(headCallsAreGood, 'S3.headObject called once for each file')
-    t.ok(putCallsAreGood, 'S3.putObject called once for each file')
+                            files.every(f => putObjCalls.some(h => h.request.Key === pathToUnix(f)))
+    t.ok(headCallsAreGood, 'S3.HeadObject called once for each file')
+    t.ok(putCallsAreGood, 'S3.PutObject called once for each file')
     t.equal(notModified, 0, 'Returned correct quantity of skipped files')
     t.equal(putObjCalls.length, uploaded, 'Returned correct quantity of published files')
     reset()
@@ -100,13 +94,17 @@ test('Basic publish test', t => {
 test('Skip publishing files that have not been updated', t => {
   t.plan(4)
   setup(createFileData())
+  awsLite.testing.mock('S3.HeadObject', headObject)
+  awsLite.testing.mock('S3.PutObject', {})
 
   putParams(params(), (err, uploaded, notModified) => {
     if (err) t.fail(err)
+    let headObjCalls = awsLite.testing.getAllRequests('S3.HeadObject')
+    let putObjCalls = awsLite.testing.getAllRequests('S3.PutObject')
     let headCallsAreGood =  (headObjCalls.length === files.length) &&
-                            files.every(f => headObjCalls.some(h => h.Key === pathToUnix(f)))
-    t.ok(headCallsAreGood, 'S3.headObject called once for each file')
-    t.equal(putObjCalls.length, 0, 'S3.putObject not called on updated files')
+                            files.every(f => headObjCalls.some(h => h.request.Key === pathToUnix(f)))
+    t.ok(headCallsAreGood, 'S3.HeadObject called once for each file')
+    t.equal(putObjCalls.length, 0, 'S3.PutObject not called on updated files')
     t.equal(headObjCalls.length, notModified, 'Returned correct quantity of skipped files')
     t.equal(putObjCalls.length, uploaded, 'Returned correct quantity of published files')
     reset()
@@ -116,16 +114,20 @@ test('Skip publishing files that have not been updated', t => {
 test('Re-publish files if cache-control header does not match', t => {
   t.plan(4)
   setup(createFileData())
+  awsLite.testing.mock('S3.HeadObject', headObject)
+  awsLite.testing.mock('S3.PutObject', {})
 
   CacheControl = 'foo'
   putParams({ fingerprint: 'external', ...params() }, (err, uploaded, notModified) => {
     if (err) t.fail(err)
+    let headObjCalls = awsLite.testing.getAllRequests('S3.HeadObject')
+    let putObjCalls = awsLite.testing.getAllRequests('S3.PutObject')
     let headCallsAreGood =  (headObjCalls.length === files.length) &&
-                            files.every(f => headObjCalls.some(h => h.Key === pathToUnix(f)))
+                            files.every(f => headObjCalls.some(h => h.request.Key === pathToUnix(f)))
     let putCallsAreGood =   (putObjCalls.length === files.length) &&
-                            files.every(f => putObjCalls.some(h => h.Key === pathToUnix(f)))
-    t.ok(headCallsAreGood, 'S3.headObject called once for each file')
-    t.ok(putCallsAreGood, 'S3.putObject called once for each file')
+                            files.every(f => putObjCalls.some(h => h.request.Key === pathToUnix(f)))
+    t.ok(headCallsAreGood, 'S3.HeadObject called once for each file')
+    t.ok(putCallsAreGood, 'S3.PutObject called once for each file')
     t.equal(notModified, 0, 'Returned correct quantity of skipped files')
     t.equal(putObjCalls.length, uploaded, 'Returned correct quantity of published files')
     reset()
@@ -134,7 +136,6 @@ test('Re-publish files if cache-control header does not match', t => {
 
 test('Teardown', t => {
   t.plan(1)
-  awsMock.restore()
-  t.pass('Done')
+  awsLite.testing.disable()
+  t.notOk(awsLite.testing.isEnabled(), 'Done')
 })
- */