@creator.co/wapi 1.2.5 → 1.2.6

package/tests/Config/Config.test.ts

@@ -1,6 +1,6 @@
 import { SSMClient, GetParameterCommand } from '@aws-sdk/client-ssm'
 import { mockClient } from 'aws-sdk-client-mock'
-import { expect } from 'chai'
+import { expect as c_expect } from 'chai'
 
 import Configuration from '../../src/Config/Configuration'
 import { SampleConfig, SampleConfigSchema } from '../Test.utils'
@@ -22,8 +22,8 @@ describe(`Optional remote environment`, () => {
     } catch (e) {
       err = e
     }
-    expect(err).is.not.null
-    expect(err?.['message']).is.not.null
+    c_expect(err).is.not.null
+    c_expect(err?.['message']).is.not.null
   })
 
   test('Optional value with null value', async () => {
@@ -33,13 +33,13 @@ describe(`Optional remote environment`, () => {
       },
     })
     const token = await config.asyncGet('TOKEN_SECRET_FALSY')
-    expect(token).is.undefined
+    c_expect(token).is.undefined
   })
 
   test('Optional value with empty response', async () => {
     SSMMock.on(GetParameterCommand).resolves({})
     const token = await config.asyncGet('TOKEN_SECRET_FALSY')
-    expect(token).is.undefined
+    c_expect(token).is.undefined
   })
 
   test('Optional value with valid response', async () => {
@@ -50,14 +50,14 @@ describe(`Optional remote environment`, () => {
       },
     })
     const token = await config.asyncGet('TOKEN_SECRET_FALSY')
-    expect(token).is.not.undefined
-    expect(token).to.be.equals(value)
+    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!'))
     const token = await config.asyncGet('TOKEN_SECRET_FALSY')
-    expect(token).is.undefined
+    c_expect(token).is.undefined
   })
 })
 
@@ -76,8 +76,8 @@ describe(`Required remote environment`, () => {
     } catch (e) {
       err = e
     }
-    expect(err).is.not.null
-    expect(err?.['message']).is.not.null
+    c_expect(err).is.not.null
+    c_expect(err?.['message']).is.not.null
   })
 
   test('Required value with null value', async () => {
@@ -92,8 +92,8 @@ describe(`Required remote environment`, () => {
     } catch (e) {
       err = e
     }
-    expect(err).is.not.null
-    expect(err?.['message']).is.not.null
+    c_expect(err).is.not.null
+    c_expect(err?.['message']).is.not.null
   })
 
   test('Required value with empty response', async () => {
@@ -104,8 +104,8 @@ describe(`Required remote environment`, () => {
     } catch (e) {
       err = e
     }
-    expect(err).is.not.null
-    expect(err?.['message']).is.not.null
+    c_expect(err).is.not.null
+    c_expect(err?.['message']).is.not.null
   })
 
   test('Required value with valid response', async () => {
@@ -116,8 +116,8 @@ describe(`Required remote environment`, () => {
       },
     })
     const token = await config.asyncGet('TOKEN_SECRET')
-    expect(token).is.not.undefined
-    expect(token).to.be.equals(value)
+    c_expect(token).is.not.undefined
+    c_expect(token).to.be.equals(value)
   })
 
   test('Required value rejection', async () => {
@@ -128,8 +128,8 @@ describe(`Required remote environment`, () => {
     } catch (e) {
       err = e
     }
-    expect(err).is.not.null
-    expect(err?.['message']).is.not.null
+    c_expect(err).is.not.null
+    c_expect(err?.['message']).is.not.null
   })
 })
 
@@ -140,7 +140,7 @@ describe(`Optional local environment`, () => {
 
   test('Optional value with null value', async () => {
     const token = config.get('PATH123')
-    expect(token).is.undefined
+    c_expect(token).is.undefined
   })
 })
 
@@ -156,15 +156,15 @@ describe(`Required local environment`, () => {
     } catch (e) {
       err = e
     }
-    expect(err).is.not.null
-    expect(err?.['message']).is.not.null
+    c_expect(err).is.not.null
+    c_expect(err?.['message']).is.not.null
   })
 
   test('Required value with valid response', async () => {
     const key = 'PATH'
     const v = config.get(key)
-    expect(v).is.not.null
-    expect(v).to.be.equals(process.env[key])
+    c_expect(v).is.not.null
+    c_expect(v).to.be.equals(process.env[key])
   })
 })
 
@@ -179,14 +179,14 @@ describe(`Caching test`, () => {
       },
     })
     const v = await config.asyncGet(key)
-    expect(v).is.not.null
-    expect(v).to.be.equals(value)
+    c_expect(v).is.not.null
+    c_expect(v).to.be.equals(value)
     // subsequent fetch
     SSMMock.reset()
     SSMMock.on(GetParameterCommand).rejects(new Error('failed!'))
     const v2 = await config.asyncGet(key)
-    expect(v2).is.not.null
-    expect(v2).to.be.equals(value)
+    c_expect(v2).is.not.null
+    c_expect(v2).to.be.equals(value)
   })
 })
 

package/tests/Config/EnvironmentVar.test.ts

@@ -17,9 +17,15 @@ function testRemoteEnv(mock, type, command) {
 
     test('Does not accept sync resolve', async () => {
       mock.on(command).resolves({
-        Parameter: {
-          Value: undefined,
-        },
+        ...(type == EnvironmentType.PlainRemote
+          ? {
+              Parameter: {
+                Value: undefined,
+              },
+            }
+          : {
+              SecretString: undefined,
+            }),
       })
       let err = null
       try {
@@ -34,9 +40,15 @@ function testRemoteEnv(mock, type, command) {
 
     test('Optional value with null value', async () => {
       mock.on(command).resolves({
-        Parameter: {
-          Value: undefined,
-        },
+        ...(type == EnvironmentType.PlainRemote
+          ? {
+              Parameter: {
+                Value: undefined,
+              },
+            }
+          : {
+              SecretString: undefined,
+            }),
       })
       const env = new EnvironmentVar('abc', type, true)
       const token = await env.resolve()
@@ -53,9 +65,15 @@ function testRemoteEnv(mock, type, command) {
     test('Optional value with valid response', async () => {
       const value = 'abc'
       mock.on(command).resolves({
-        Parameter: {
-          Value: value,
-        },
+        ...(type == EnvironmentType.PlainRemote
+          ? {
+              Parameter: {
+                Value: value,
+              },
+            }
+          : {
+              SecretString: value,
+            }),
       })
       const env = new EnvironmentVar(value, type, true)
       const token = await env.resolve()
@@ -80,9 +98,15 @@ function testRemoteEnv(mock, type, command) {
 
     test('Does not accept sync resolve', async () => {
       mock.on(command).resolves({
-        Parameter: {
-          Value: undefined,
-        },
+        ...(type == EnvironmentType.PlainRemote
+          ? {
+              Parameter: {
+                Value: undefined,
+              },
+            }
+          : {
+              SecretString: undefined,
+            }),
       })
       let err = null
       try {
@@ -97,9 +121,15 @@ function testRemoteEnv(mock, type, command) {
 
     test('Required fails when null', async () => {
       mock.on(command).resolves({
-        Parameter: {
-          Value: undefined,
-        },
+        ...(type == EnvironmentType.PlainRemote
+          ? {
+              Parameter: {
+                Value: undefined,
+              },
+            }
+          : {
+              SecretString: undefined,
+            }),
       })
       let err = null
       try {
@@ -129,9 +159,15 @@ function testRemoteEnv(mock, type, command) {
     test('Required value with valid response', async () => {
       const value = 'abc'
       mock.on(command).resolves({
-        Parameter: {
-          Value: value,
-        },
+        ...(type == EnvironmentType.PlainRemote
+          ? {
+              Parameter: {
+                Value: value,
+              },
+            }
+          : {
+              SecretString: value,
+            }),
       })
       const env = new EnvironmentVar(value, type)
       const token = await env.resolve()

package/tests/Publisher/Publisher.test.ts

@@ -28,7 +28,7 @@ describe('Encryption', () => {
     })
     const res = await provider.publishOnTopic(msg, topic)
     expect(res).is.not.null
-    expect(res.MessageId).to.be.equals(messageId)
+    expect(res?.MessageId).to.be.equals(messageId)
   })
 
   test('Publishes with success (additional props)', async () => {
@@ -45,7 +45,7 @@ describe('Encryption', () => {
       FifoGroup: 123,
     })
     expect(res).is.not.null
-    expect(res.MessageId).to.be.equals(messageId)
+    expect(res?.MessageId).to.be.equals(messageId)
   })
 
   test('Publish failure', async () => {
@@ -53,7 +53,7 @@ describe('Encryption', () => {
     const topic = '123'
     SNSMock.on(PublishCommand).rejects(new Error('failed!'))
     const res = await provider.publishOnTopic(msg, topic)
-    expect(res).is.null
+    expect(res).is.undefined
   })
 })
 

package/tests/Server/lib/ContainerServer.test.ts

@@ -1,5 +1,4 @@
-import { expect as j_expect } from '@jest/globals'
-import { expect } from 'chai'
+import { expect as c_expect } from 'chai'
 import * as request from 'supertest'
 import { z } from 'zod'
 
@@ -37,7 +36,7 @@ describe('Container server routing', () => {
       .get(Globals.Listener_HTTP_DefaultHealthCheckRoute)
       .expect('Content-Type', 'text/html; charset=utf-8')
       .expect(200)
-    expect(res.text).to.be.equals('Healthy!')
+    c_expect(res.text).to.be.equals('Healthy!')
     // Not handled
     await request(defaultUrl)
       .get(`/abc`)
@@ -46,8 +45,8 @@ describe('Container server routing', () => {
 
     // Unload
     await server.stop('Error')
-    j_expect(mockExit).toHaveBeenCalledTimes(1)
-    j_expect(mockExit).toBeCalledWith(1)
+    expect(mockExit).toHaveBeenCalledTimes(1)
+    expect(mockExit).toBeCalledWith(1)
   })
 
   test('Simple route', async () => {
@@ -68,14 +67,14 @@ describe('Container server routing', () => {
       .get(Globals.Listener_HTTP_DefaultHealthCheckRoute)
       .expect('Content-Type', 'text/html; charset=utf-8')
       .expect(200)
-    expect(res.text).to.be.equals('Healthy!')
+    c_expect(res.text).to.be.equals('Healthy!')
     // Found route
     const resG = await request(defaultUrl)
       .get(`/abc`)
       .expect('Content-Type', 'application/json; charset=utf-8')
       .expect(200)
-    expect(resG.body['name']).to.be.deep.equals('abc')
-    expect(resG.body['transactionID']).to.not.be.null
+    c_expect(resG.body['name']).to.be.deep.equals('abc')
+    c_expect(resG.body['transactionID']).to.not.be.null
     // Found route, but not method
     await request(defaultUrl)
       .post(`/abc`)
@@ -88,8 +87,8 @@ describe('Container server routing', () => {
       .expect(404)
     // Unload
     await server.stop('Error')
-    j_expect(mockExit).toHaveBeenCalledTimes(1)
-    j_expect(mockExit).toBeCalledWith(1)
+    expect(mockExit).toHaveBeenCalledTimes(1)
+    expect(mockExit).toBeCalledWith(1)
   })
 })
 
@@ -117,11 +116,11 @@ describe('Container server basics', () => {
           .get(Globals.Listener_HTTP_DefaultHealthCheckRoute)
           .expect('Content-Type', 'text/html; charset=utf-8')
           .expect(200)
-        expect(res.text).to.be.equals('Healthy!')
+        c_expect(res.text).to.be.equals('Healthy!')
         // Unload
         await server.stop()
-        j_expect(mockExit).toHaveBeenCalledTimes(1)
-        j_expect(mockExit).toBeCalledWith(0)
+        expect(mockExit).toHaveBeenCalledTimes(1)
+        expect(mockExit).toBeCalledWith(0)
         resolve(null)
       }, 2000)
     })
@@ -133,8 +132,8 @@ describe('Container server basics', () => {
     process.emit('SIGINT')
     return new Promise(resolve => {
       setTimeout(async () => {
-        j_expect(mockExit).toHaveBeenCalledTimes(1)
-        j_expect(mockExit).toBeCalledWith(0)
+        expect(mockExit).toHaveBeenCalledTimes(1)
+        expect(mockExit).toBeCalledWith(0)
         resolve(null)
       }, 2000)
     })
@@ -147,8 +146,8 @@ describe('Container server basics', () => {
     process.emit('unhandledRejection')
     return new Promise(resolve => {
       setTimeout(async () => {
-        j_expect(mockExit).toHaveBeenCalledTimes(1)
-        j_expect(mockExit).toBeCalledWith(0)
+        expect(mockExit).toHaveBeenCalledTimes(1)
+        expect(mockExit).toBeCalledWith(0)
         resolve(null)
       }, 2000)
     })
@@ -170,11 +169,11 @@ describe('Container server validation', () => {
   })
 
   function validateValidationFailure(res: any, failureCount?: number) {
-    expect(res.body['err']).to.be.equals(Globals.ErrorResponseValidationFail)
-    expect(res.body['errCode']).to.be.equals(Globals.ErrorCode_InvalidInput)
-    expect(res.body['transactionID']).to.not.be.null
-    expect(res.body['transactionID']).to.be.an('string')
-    expect(res.body['validationFailure']?.length).to.be.equals(failureCount || 4)
+    c_expect(res.body['err']).to.be.equals(Globals.ErrorResponseValidationFail)
+    c_expect(res.body['errCode']).to.be.equals(Globals.ErrorCode_InvalidInput)
+    c_expect(res.body['transactionID']).to.not.be.null
+    c_expect(res.body['transactionID']).to.be.an('string')
+    c_expect(res.body['validationFailure']?.length).to.be.equals(failureCount || 4)
   }
 
   test('Validates empty body', async () => {

package/tests/Server/lib/container/GenericHandler.test.ts

@@ -1,6 +1,5 @@
-import { expect as j_expect } from '@jest/globals'
 import { APIGatewayProxyEvent, Context } from 'aws-lambda'
-import { expect } from 'chai'
+import { expect as c_expect } from 'chai'
 import { Request, Response } from 'express'
 
 import Globals from '../../../../src/Globals'
@@ -28,11 +27,11 @@ describe('GenericHandler success invocation path', () => {
     const resp = observableResponse()
     const handlerResp = await handler(<Request>(<unknown>{}), resp)
     //
-    expect(handlerResp).to.be.undefined
-    j_expect(resp.send).not.toBeCalled()
-    j_expect(resp.json).toBeCalledWith(JSON.parse(v.body))
-    j_expect(resp.status).toBeCalledWith(v.statusCode)
-    j_expect(resp.header).not.toBeCalled()
+    c_expect(handlerResp).to.be.undefined
+    expect(resp.send).not.toBeCalled()
+    expect(resp.json).toBeCalledWith(JSON.parse(v.body))
+    expect(resp.status).toBeCalledWith(v.statusCode)
+    expect(resp.header).not.toBeCalled()
   })
 
   test('Simple success w/ headers', async () => {
@@ -47,11 +46,11 @@ describe('GenericHandler success invocation path', () => {
     const resp = observableResponse()
     const handlerResp = await handler(<Request>(<unknown>{}), resp)
     //
-    expect(handlerResp).to.be.undefined
-    j_expect(resp.send).not.toBeCalled()
-    j_expect(resp.json).toBeCalledWith(JSON.parse(v.body))
-    j_expect(resp.status).toBeCalledWith(v.statusCode)
-    j_expect(resp.header).toBeCalledTimes(Object.keys(v.headers).length)
+    c_expect(handlerResp).to.be.undefined
+    expect(resp.send).not.toBeCalled()
+    expect(resp.json).toBeCalledWith(JSON.parse(v.body))
+    expect(resp.status).toBeCalledWith(v.statusCode)
+    expect(resp.header).toBeCalledTimes(Object.keys(v.headers).length)
   })
 
   test('Simple success w/ null body', async () => {
@@ -65,11 +64,11 @@ describe('GenericHandler success invocation path', () => {
     const resp = observableResponse()
     const handlerResp = await handler(<Request>(<unknown>{}), resp)
     //
-    expect(handlerResp).to.be.undefined
-    j_expect(resp.send).not.toBeCalled()
-    j_expect(resp.json).toBeCalledWith({})
-    j_expect(resp.status).toBeCalledWith(v.statusCode)
-    j_expect(resp.header).toBeCalledTimes(Object.keys(v.headers).length)
+    c_expect(handlerResp).to.be.undefined
+    expect(resp.send).not.toBeCalled()
+    expect(resp.json).toBeCalledWith({})
+    expect(resp.status).toBeCalledWith(v.statusCode)
+    expect(resp.header).toBeCalledTimes(Object.keys(v.headers).length)
   })
 })
 
@@ -81,14 +80,14 @@ describe('GenericHandler failure invocation path', () => {
     const resp = observableResponse()
     const handlerResp = await handler(<Request>(<unknown>{}), resp)
     //
-    expect(handlerResp).to.be.undefined
-    j_expect(resp.send).not.toBeCalled()
-    j_expect(resp.header).not.toBeCalled()
-    j_expect(resp.json).toBeCalledWith({
+    c_expect(handlerResp).to.be.undefined
+    expect(resp.send).not.toBeCalled()
+    expect(resp.header).not.toBeCalled()
+    expect(resp.json).toBeCalledWith({
       err: Globals.Resp_MSG_INVALIDRESP,
       errCode: Globals.Resp_CODE_INVALIDRESP,
     })
-    j_expect(resp.status).toBeCalledWith(Globals.Resp_STATUSCODE_INVALIDRESP)
+    expect(resp.status).toBeCalledWith(Globals.Resp_STATUSCODE_INVALIDRESP)
   })
 
   test('Error response', async () => {
@@ -99,13 +98,13 @@ describe('GenericHandler failure invocation path', () => {
     const resp = observableResponse()
     const handlerResp = await handler(<Request>(<unknown>{}), resp)
     //
-    expect(handlerResp).to.be.undefined
-    j_expect(resp.send).not.toBeCalled()
-    j_expect(resp.header).not.toBeCalled()
-    j_expect(resp.json).toBeCalledWith({
+    c_expect(handlerResp).to.be.undefined
+    expect(resp.send).not.toBeCalled()
+    expect(resp.header).not.toBeCalled()
+    expect(resp.json).toBeCalledWith({
       err,
     })
-    j_expect(resp.status).toBeCalledWith(400)
+    expect(resp.status).toBeCalledWith(400)
   })
 
   test('Exception response', async () => {
@@ -116,15 +115,15 @@ describe('GenericHandler failure invocation path', () => {
     const resp = observableResponse()
     const handlerResp = await handler(<Request>(<unknown>{}), resp)
     //
-    expect(handlerResp).to.be.undefined
-    j_expect(resp.send).not.toBeCalled()
-    j_expect(resp.header).not.toBeCalled()
-    j_expect(resp.json).toBeCalledWith({
+    c_expect(handlerResp).to.be.undefined
+    expect(resp.send).not.toBeCalled()
+    expect(resp.header).not.toBeCalled()
+    expect(resp.json).toBeCalledWith({
       ...err,
       err: Globals.Resp_MSG_EXCEPTION,
       errCode: Globals.Resp_CODE_EXCEPTION,
     })
-    j_expect(resp.status).toBeCalledWith(Globals.Resp_STATUSCODE_EXCEPTION)
+    expect(resp.status).toBeCalledWith(Globals.Resp_STATUSCODE_EXCEPTION)
   })
 })
 

package/tests/Server/lib/container/GenericHandlerEvent.test.ts

@@ -17,7 +17,7 @@ describe('GenericHandlerEvent invocation paths', () => {
     )
     const resp = await event.invoke()
     expect(resp).to.not.be.null
-    expect(resp.err).to.be.null
+    expect(resp.err).to.be.undefined
     expect(resp.data).to.be.equals('Success')
   })
 
@@ -94,7 +94,7 @@ describe('GenericHandlerEvent event test', () => {
     )
     const resp = await event.invoke()
     expect(resp).to.not.be.null
-    expect(resp.err).to.be.null
+    expect(resp.err).to.be.undefined
     expect(resp.data).to.be.equals('Success')
   })
 })

package/tests/Server/lib/container/HealthHandler.test.ts

@@ -1,5 +1,4 @@
-import { expect as j_expect } from '@jest/globals'
-import { expect } from 'chai'
+import { expect as c_expect } from 'chai'
 import { Request, Response } from 'express'
 
 import HealthHandler from '../../../../src/Server/lib/container/HealthHandler'
@@ -19,11 +18,11 @@ describe('HealthHandler invocation path', () => {
     const resp = observableResponse()
     const handlerResp = await HealthHandler(<Request>(<unknown>{}), resp)
     //
-    expect(handlerResp).to.be.undefined
-    j_expect(resp.send).toBeCalledWith('Healthy!')
-    j_expect(resp.json).not.toBeCalled()
-    j_expect(resp.status).not.toBeCalled()
-    j_expect(resp.header).not.toBeCalled()
+    c_expect(handlerResp).to.be.undefined
+    expect(resp.send).toBeCalledWith('Healthy!')
+    expect(resp.json).not.toBeCalled()
+    expect(resp.status).not.toBeCalled()
+    expect(resp.header).not.toBeCalled()
   })
 })