@creator.co/wapi 1.8.8 → 1.9.0

package/tests/Config/Config.test.ts

@@ -1,11 +1,11 @@
 import { SSMClient, GetParameterCommand } from '@aws-sdk/client-ssm'
-import { mockClient } from 'aws-sdk-client-mock'
 import { expect as c_expect } from 'chai'
 
 import Configuration from '../../src/Config/Configuration.js'
+import { mockAwsClient, mockAwsCommand, mockAwsResult } from '../AwsSdkTest.utils.js'
 import { SampleConfig } from '../Test.utils.js'
 
-const SSMMock = mockClient(SSMClient)
+const SSMMock = mockAwsClient(SSMClient)
 const config = new Configuration<typeof SampleConfig>(SampleConfig, 'my-prefix')
 describe(`Optional remote environment`, () => {
   // reset mock
@@ -27,35 +27,39 @@ describe(`Optional remote environment`, () => {
   })
 
   test('Optional value with null value', async () => {
-    SSMMock.on(GetParameterCommand).resolves({
-      Parameter: {
-        Value: undefined,
-      },
-    })
+    SSMMock.on(mockAwsCommand(GetParameterCommand)).resolves(
+      mockAwsResult({
+        Parameter: {
+          Value: undefined,
+        },
+      })
+    )
     const token = await config.asyncGet('TOKEN_SECRET_FALSY')
     c_expect(token).is.undefined
   })
 
   test('Optional value with empty response', async () => {
-    SSMMock.on(GetParameterCommand).resolves({})
+    SSMMock.on(mockAwsCommand(GetParameterCommand)).resolves(mockAwsResult({}))
     const token = await config.asyncGet('TOKEN_SECRET_FALSY')
     c_expect(token).is.undefined
   })
 
   test('Optional value with valid response', async () => {
     const value = 'abc'
-    SSMMock.on(GetParameterCommand).resolves({
-      Parameter: {
-        Value: value,
-      },
-    })
+    SSMMock.on(mockAwsCommand(GetParameterCommand)).resolves(
+      mockAwsResult({
+        Parameter: {
+          Value: value,
+        },
+      })
+    )
     const token = await config.asyncGet('TOKEN_SECRET_FALSY')
     c_expect(token).is.not.undefined
     c_expect(token).to.be.equals(value)
   })
 
   test('Optional value rejection', async () => {
-    SSMMock.on(GetParameterCommand).rejects(new Error('failed!'))
+    SSMMock.on(mockAwsCommand(GetParameterCommand)).rejects(new Error('failed!'))
     const token = await config.asyncGet('TOKEN_SECRET_FALSY')
     c_expect(token).is.undefined
   })
@@ -81,11 +85,13 @@ describe(`Required remote environment`, () => {
   })
 
   test('Required value with null value', async () => {
-    SSMMock.on(GetParameterCommand).resolves({
-      Parameter: {
-        Value: undefined,
-      },
-    })
+    SSMMock.on(mockAwsCommand(GetParameterCommand)).resolves(
+      mockAwsResult({
+        Parameter: {
+          Value: undefined,
+        },
+      })
+    )
     let err = null
     try {
       await config.asyncGet('TOKEN_SECRET')
@@ -97,7 +103,7 @@ describe(`Required remote environment`, () => {
   })
 
   test('Required value with empty response', async () => {
-    SSMMock.on(GetParameterCommand).resolves({})
+    SSMMock.on(mockAwsCommand(GetParameterCommand)).resolves(mockAwsResult({}))
     let err = null
     try {
       await config.asyncGet('TOKEN_SECRET')
@@ -110,18 +116,20 @@ describe(`Required remote environment`, () => {
 
   test('Required value with valid response', async () => {
     const value = 'abc'
-    SSMMock.on(GetParameterCommand).resolves({
-      Parameter: {
-        Value: value,
-      },
-    })
+    SSMMock.on(mockAwsCommand(GetParameterCommand)).resolves(
+      mockAwsResult({
+        Parameter: {
+          Value: value,
+        },
+      })
+    )
     const token = await config.asyncGet('TOKEN_SECRET')
     c_expect(token).is.not.undefined
     c_expect(token).to.be.equals(value)
   })
 
   test('Required value rejection', async () => {
-    SSMMock.on(GetParameterCommand).rejects(new Error('failed!'))
+    SSMMock.on(mockAwsCommand(GetParameterCommand)).rejects(new Error('failed!'))
     let err = null
     try {
       await config.asyncGet('TOKEN_SECRET')
@@ -185,17 +193,19 @@ describe(`Caching test`, () => {
     const value = '123'
     const key = 'TOKEN_SECRET'
     // initial fetch
-    SSMMock.on(GetParameterCommand).resolves({
-      Parameter: {
-        Value: value,
-      },
-    })
+    SSMMock.on(mockAwsCommand(GetParameterCommand)).resolves(
+      mockAwsResult({
+        Parameter: {
+          Value: value,
+        },
+      })
+    )
     const v = await config.asyncGet(key)
     c_expect(v).is.not.null
     c_expect(v).to.be.equals(value)
     // subsequent fetch
     SSMMock.reset()
-    SSMMock.on(GetParameterCommand).rejects(new Error('failed!'))
+    SSMMock.on(mockAwsCommand(GetParameterCommand)).rejects(new Error('failed!'))
     const v2 = await config.asyncGet(key)
     c_expect(v2).is.not.null
     c_expect(v2).to.be.equals(value)

package/tests/Config/EnvironmentVar.test.ts

@@ -1,12 +1,12 @@
 import { SecretsManagerClient, GetSecretValueCommand } from '@aws-sdk/client-secrets-manager'
 import { SSMClient, GetParameterCommand } from '@aws-sdk/client-ssm'
-import { mockClient } from 'aws-sdk-client-mock'
 import { expect } from 'chai'
 
 import EnvironmentVar, { EnvironmentType } from '../../src/Config/EnvironmentVar.js'
+import { mockAwsClient, mockAwsCommand, mockAwsResult } from '../AwsSdkTest.utils.js'
 
-const SSMMock = mockClient(SSMClient)
-const SecretsManagerMock = mockClient(SecretsManagerClient)
+const SSMMock = mockAwsClient(SSMClient)
+const SecretsManagerMock = mockAwsClient(SecretsManagerClient)
 
 function testRemoteEnv(mock, type, command) {
   describe(`Optional ${type} environment`, () => {
@@ -16,17 +16,19 @@ function testRemoteEnv(mock, type, command) {
     })
 
     test('Does not accept sync resolve', async () => {
-      mock.on(command).resolves({
-        ...(type == EnvironmentType.PlainRemote
-          ? {
-              Parameter: {
-                Value: undefined,
-              },
-            }
-          : {
-              SecretString: undefined,
-            }),
-      })
+      mock.on(mockAwsCommand(command)).resolves(
+        mockAwsResult({
+          ...(type == EnvironmentType.PlainRemote
+            ? {
+                Parameter: {
+                  Value: undefined,
+                },
+              }
+            : {
+                SecretString: undefined,
+              }),
+        })
+      )
       let err = null
       try {
         const env = new EnvironmentVar('abc', type, true)
@@ -39,24 +41,26 @@ function testRemoteEnv(mock, type, command) {
     })
 
     test('Optional value with null value', async () => {
-      mock.on(command).resolves({
-        ...(type == EnvironmentType.PlainRemote
-          ? {
-              Parameter: {
-                Value: undefined,
-              },
-            }
-          : {
-              SecretString: undefined,
-            }),
-      })
+      mock.on(mockAwsCommand(command)).resolves(
+        mockAwsResult({
+          ...(type == EnvironmentType.PlainRemote
+            ? {
+                Parameter: {
+                  Value: undefined,
+                },
+              }
+            : {
+                SecretString: undefined,
+              }),
+        })
+      )
       const env = new EnvironmentVar('abc', type, true)
       const token = await env.resolve()
       expect(token).is.undefined
     })
 
     test('Optional value with empty response', async () => {
-      mock.on(command).resolves({})
+      mock.on(mockAwsCommand(command)).resolves(mockAwsResult({}))
       const env = new EnvironmentVar('abc', type, true)
       const token = await env.resolve()
       expect(token).is.undefined
@@ -64,17 +68,19 @@ function testRemoteEnv(mock, type, command) {
 
     test('Optional value with valid response', async () => {
       const value = 'abc'
-      mock.on(command).resolves({
-        ...(type == EnvironmentType.PlainRemote
-          ? {
-              Parameter: {
-                Value: value,
-              },
-            }
-          : {
-              SecretString: value,
-            }),
-      })
+      mock.on(mockAwsCommand(command)).resolves(
+        mockAwsResult({
+          ...(type == EnvironmentType.PlainRemote
+            ? {
+                Parameter: {
+                  Value: value,
+                },
+              }
+            : {
+                SecretString: value,
+              }),
+        })
+      )
       const env = new EnvironmentVar(value, type, true)
       const token = await env.resolve()
       expect(token).is.not.undefined
@@ -83,7 +89,7 @@ function testRemoteEnv(mock, type, command) {
 
     test('Optional value rejection', async () => {
       const value = 'abc'
-      mock.on(command).rejects(new Error('failed!'))
+      mock.on(mockAwsCommand(command)).rejects(new Error('failed!'))
       const env = new EnvironmentVar(value, type, true)
       const token = await env.resolve()
       expect(token).is.undefined
@@ -97,17 +103,19 @@ function testRemoteEnv(mock, type, command) {
     })
 
     test('Does not accept sync resolve', async () => {
-      mock.on(command).resolves({
-        ...(type == EnvironmentType.PlainRemote
-          ? {
-              Parameter: {
-                Value: undefined,
-              },
-            }
-          : {
-              SecretString: undefined,
-            }),
-      })
+      mock.on(mockAwsCommand(command)).resolves(
+        mockAwsResult({
+          ...(type == EnvironmentType.PlainRemote
+            ? {
+                Parameter: {
+                  Value: undefined,
+                },
+              }
+            : {
+                SecretString: undefined,
+              }),
+        })
+      )
       let err = null
       try {
         const env = new EnvironmentVar('abc', type)
@@ -120,17 +128,19 @@ function testRemoteEnv(mock, type, command) {
     })
 
     test('Required fails when null', async () => {
-      mock.on(command).resolves({
-        ...(type == EnvironmentType.PlainRemote
-          ? {
-              Parameter: {
-                Value: undefined,
-              },
-            }
-          : {
-              SecretString: undefined,
-            }),
-      })
+      mock.on(mockAwsCommand(command)).resolves(
+        mockAwsResult({
+          ...(type == EnvironmentType.PlainRemote
+            ? {
+                Parameter: {
+                  Value: undefined,
+                },
+              }
+            : {
+                SecretString: undefined,
+              }),
+        })
+      )
       let err = null
       try {
         const env = new EnvironmentVar('abc', type)
@@ -144,7 +154,7 @@ function testRemoteEnv(mock, type, command) {
     })
 
     test('Required fails when empty response', async () => {
-      mock.on(command).resolves({})
+      mock.on(mockAwsCommand(command)).resolves(mockAwsResult({}))
       let err = null
       try {
         const env = new EnvironmentVar('abc', type)
@@ -158,17 +168,19 @@ function testRemoteEnv(mock, type, command) {
 
     test('Required value with valid response', async () => {
       const value = 'abc'
-      mock.on(command).resolves({
-        ...(type == EnvironmentType.PlainRemote
-          ? {
-              Parameter: {
-                Value: value,
-              },
-            }
-          : {
-              SecretString: value,
-            }),
-      })
+      mock.on(mockAwsCommand(command)).resolves(
+        mockAwsResult({
+          ...(type == EnvironmentType.PlainRemote
+            ? {
+                Parameter: {
+                  Value: value,
+                },
+              }
+            : {
+                SecretString: value,
+              }),
+        })
+      )
       const env = new EnvironmentVar(value, type)
       const token = await env.resolve()
       expect(token).is.not.undefined
@@ -176,7 +188,7 @@ function testRemoteEnv(mock, type, command) {
     })
 
     test('Required value rejection', async () => {
-      mock.on(command).rejects(new Error('failed!'))
+      mock.on(mockAwsCommand(command)).rejects(new Error('failed!'))
       let err = null
       try {
         const env = new EnvironmentVar('abc', type)

package/tests/Crypto/Crypto.test.ts

@@ -1,10 +1,10 @@
 import { DecryptCommand, EncryptCommand, KMSClient } from '@aws-sdk/client-kms'
-import { mockClient } from 'aws-sdk-client-mock'
 import { expect } from 'chai'
 
 import Crypto from '../../src/Crypto/Crypto.js'
+import { mockAwsClient, mockAwsCommand, mockAwsResult } from '../AwsSdkTest.utils.js'
 
-const KMSMock = mockClient(KMSClient)
+const KMSMock = mockAwsClient(KMSClient)
 
 function fakeEncryption(v) {
   const f = new TextEncoder().encode(v)
@@ -23,9 +23,11 @@ describe('Encryption', () => {
   const provider = new Crypto('ca-central-1', 'abc123')
   test('Encrypts json object', async () => {
     const encryptionObj = { userID: 123 }
-    KMSMock.on(EncryptCommand).resolves({
-      CiphertextBlob: new TextEncoder().encode(JSON.stringify(encryptionObj)),
-    })
+    KMSMock.on(mockAwsCommand(EncryptCommand)).resolves(
+      mockAwsResult({
+        CiphertextBlob: new TextEncoder().encode(JSON.stringify(encryptionObj)),
+      })
+    )
     const token = await provider.encryptData(encryptionObj)
     expect(token).is.not.null
     expect(token).to.be.equals(fakeEncryption(JSON.stringify(encryptionObj)))
@@ -33,9 +35,11 @@ describe('Encryption', () => {
 
   test('Encrypts string', async () => {
     const encryptionText = 'Hello encryption!'
-    KMSMock.on(EncryptCommand).resolves({
-      CiphertextBlob: new TextEncoder().encode(encryptionText),
-    })
+    KMSMock.on(mockAwsCommand(EncryptCommand)).resolves(
+      mockAwsResult({
+        CiphertextBlob: new TextEncoder().encode(encryptionText),
+      })
+    )
     const token = await provider.encryptData(encryptionText)
     expect(token).is.not.null
     expect(token).to.be.equals(fakeEncryption(encryptionText))
@@ -43,7 +47,7 @@ describe('Encryption', () => {
 
   test('Fails to encrypt a number', async () => {
     const encryptionText = 123
-    KMSMock.on(EncryptCommand).rejects(new Error('failed'))
+    KMSMock.on(mockAwsCommand(EncryptCommand)).rejects(new Error('failed'))
     const token = await provider.encryptData(encryptionText)
     expect(token).is.null
   })
@@ -58,9 +62,11 @@ describe('Decryption', () => {
   const provider = new Crypto('ca-central-1', 'abc123')
   test('Decrypts json object', async () => {
     const encryptionObj = { userID: 123 }
-    KMSMock.on(DecryptCommand).resolves({
-      Plaintext: fakeDecryption(JSON.stringify(encryptionObj)),
-    })
+    KMSMock.on(mockAwsCommand(DecryptCommand)).resolves(
+      mockAwsResult({
+        Plaintext: fakeDecryption(JSON.stringify(encryptionObj)),
+      })
+    )
     const token = await provider.decryptData(fakeEncryption(JSON.stringify(encryptionObj)))
     expect(token).is.not.null
     expect(token).to.be.equals(JSON.stringify(encryptionObj))
@@ -68,9 +74,11 @@ describe('Decryption', () => {
 
   test('Decrypts string', async () => {
     const encryptionText = 'abc123'
-    KMSMock.on(DecryptCommand).resolves({
-      Plaintext: fakeDecryption(encryptionText),
-    })
+    KMSMock.on(mockAwsCommand(DecryptCommand)).resolves(
+      mockAwsResult({
+        Plaintext: fakeDecryption(encryptionText),
+      })
+    )
     const token = await provider.decryptData(fakeEncryption(encryptionText))
     expect(token).is.not.null
     expect(token).to.be.equals(encryptionText)
@@ -78,7 +86,7 @@ describe('Decryption', () => {
 
   test('Fails to decrypt a number', async () => {
     const encryptionText = 123
-    KMSMock.on(DecryptCommand).rejects(new Error('failed'))
+    KMSMock.on(mockAwsCommand(DecryptCommand)).rejects(new Error('failed'))
     // @ts-ignore
     const token = await provider.decryptData(encryptionText)
     expect(token).is.null

package/tests/Mailer/Mailer.test.ts

@@ -1,10 +1,10 @@
 import { SESv2Client, SendEmailCommand } from '@aws-sdk/client-sesv2'
-import { mockClient } from 'aws-sdk-client-mock'
 import { expect } from 'chai'
 
 import Mailer from '../../src/Mailer/Mailer.js'
+import { mockAwsClient, mockAwsCommand, mockAwsResult } from '../AwsSdkTest.utils.js'
 
-const SESMock = mockClient(SESv2Client)
+const SESMock = mockAwsClient(SESv2Client)
 
 describe('SendRaw', () => {
   // reset mock
@@ -16,9 +16,11 @@ describe('SendRaw', () => {
 
   test('Send raw with success', async () => {
     const messageId = 'id-123'
-    SESMock.on(SendEmailCommand).resolves({
-      MessageId: messageId,
-    })
+    SESMock.on(mockAwsCommand(SendEmailCommand)).resolves(
+      mockAwsResult({
+        MessageId: messageId,
+      })
+    )
     const res = await provider.sendRawEmail('test@test.com', 'My message', 'My subject')
     expect(res).is.not.null
     console.log(res)
@@ -32,16 +34,18 @@ describe('SendRaw', () => {
     const subject = 'My subject'
     const cc = 'test@test3.com'
     const replyTo = 'test@test4.com'
-    SESMock.on(SendEmailCommand).resolves({
-      MessageId: messageId,
-    })
+    SESMock.on(mockAwsCommand(SendEmailCommand)).resolves(
+      mockAwsResult({
+        MessageId: messageId,
+      })
+    )
     const res = await provider.sendRawEmail(to, msg, subject, cc, from, replyTo)
     expect(res).is.not.null
     console.log(res)
   })
 
   test('Send raw with failure', async () => {
-    SESMock.on(SendEmailCommand).rejects(new Error('failed!'))
+    SESMock.on(mockAwsCommand(SendEmailCommand)).rejects(new Error('failed!'))
     let res: any = null,
       err: any = null
     try {

package/tests/Publisher/Publisher.test.ts

@@ -1,10 +1,10 @@
 import { SNSClient, PublishCommand } from '@aws-sdk/client-sns'
-import { mockClient } from 'aws-sdk-client-mock'
 import { expect } from 'chai'
 
 import Publisher from '../../src/Publisher/Publisher.js'
+import { mockAwsClient, mockAwsCommand, mockAwsResult } from '../AwsSdkTest.utils.js'
 
-const SNSMock = mockClient(SNSClient)
+const SNSMock = mockAwsClient(SNSClient)
 
 describe('SNS Pub-Sub', () => {
   // reset mock
@@ -20,12 +20,14 @@ describe('SNS Pub-Sub', () => {
     const msg = { text: '123' }
     const topic = '123'
     const messageId = 'id-123'
-    SNSMock.on(PublishCommand, {
+    SNSMock.on(mockAwsCommand(PublishCommand), {
       Message: JSON.stringify(msg),
       TopicArn: topic,
-    }).resolves({
-      MessageId: messageId,
-    })
+    }).resolves(
+      mockAwsResult({
+        MessageId: messageId,
+      })
+    )
     const res = await provider.publishOnTopic(msg, topic)
     expect(res).is.not.null
     expect(res?.MessageId).to.be.equals(messageId)
@@ -35,12 +37,14 @@ describe('SNS Pub-Sub', () => {
     const msg = { text: '123' }
     const topic = '123'
     const messageId = 'id-123'
-    SNSMock.on(PublishCommand, {
+    SNSMock.on(mockAwsCommand(PublishCommand), {
       Message: JSON.stringify(msg),
       TopicArn: topic,
-    }).resolves({
-      MessageId: messageId,
-    })
+    }).resolves(
+      mockAwsResult({
+        MessageId: messageId,
+      })
+    )
     const res = await provider.publishOnTopic(msg, topic, {
       FifoGroup: 123,
     })
@@ -51,7 +55,7 @@ describe('SNS Pub-Sub', () => {
   test('Publish failure', async () => {
     const msg = { text: '123' }
     const topic = '123'
-    SNSMock.on(PublishCommand).rejects(new Error('failed!'))
+    SNSMock.on(mockAwsCommand(PublishCommand)).rejects(new Error('failed!'))
     const res = await provider.publishOnTopic(msg, topic)
     expect(res).is.undefined
   })
@@ -71,12 +75,14 @@ describe('SNS SMS', () => {
     const msg = 'hello world'
     const phoneNumber = '+16042001234'
     const messageId = 'id-123'
-    SNSMock.on(PublishCommand, {
+    SNSMock.on(mockAwsCommand(PublishCommand), {
       Message: msg,
       PhoneNumber: phoneNumber,
-    }).resolves({
-      MessageId: messageId,
-    })
+    }).resolves(
+      mockAwsResult({
+        MessageId: messageId,
+      })
+    )
     const res = await provider.publishSMS(msg, phoneNumber)
     expect(res).is.not.null
     expect(res?.MessageId).to.be.equals(messageId)
@@ -85,7 +91,7 @@ describe('SNS SMS', () => {
   test('Publish failure', async () => {
     const msg = 'hello world'
     const phoneNumber = '+16042001234'
-    SNSMock.on(PublishCommand).rejects(new Error('failed!'))
+    SNSMock.on(mockAwsCommand(PublishCommand)).rejects(new Error('failed!'))
     const res = await provider.publishSMS(msg, phoneNumber)
     expect(res).is.undefined
   })