@creator.co/wapi 1.2.4 → 1.2.6

package/tests/BaseEvent/EventProcessor.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 Response from '../../src/API/Response'
 import EventProcessor from '../../src/BaseEvent/EventProcessor'
@@ -19,23 +18,23 @@ describe('EventProcessor success invocation path', () => {
     )
     let count = 0
     const handlerResp = await transaction.processEvent(async (transaction, eventRecord) => {
-      expect(eventRecord).to.be.deep.equal(b)
+      c_expect(eventRecord).to.be.deep.equal(b)
       count++
       return Response.SuccessResponse(null)
     })
     // check resp
-    expect(count).to.be.equals(2)
-    expect(handlerResp).to.be.an.instanceof(Response)
+    c_expect(count).to.be.equals(2)
+    c_expect(handlerResp).to.be.an.instanceof(Response)
     if (handlerResp instanceof Response) {
-      expect(handlerResp?.getBody()).to.be.deep.equal({
+      c_expect(handlerResp?.getBody()).to.be.deep.equal({
         transactionID: 'unknown',
       })
-      expect(handlerResp.getCode()).to.be.equal(200)
+      c_expect(handlerResp.getCode()).to.be.equal(200)
     }
     // ctx
-    j_expect(context.fail).not.toBeCalled()
-    j_expect(context.done).not.toBeCalled()
-    j_expect(context.succeed).not.toBeCalled()
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
   })
 
   test('Simple success - do not decode', async () => {
@@ -50,23 +49,23 @@ describe('EventProcessor success invocation path', () => {
     )
     let count = 0
     const handlerResp = await transaction.processEvent(async (transaction, eventRecord) => {
-      expect(eventRecord).to.be.deep.equal(JSON.stringify(b))
+      c_expect(eventRecord).to.be.deep.equal(JSON.stringify(b))
       count++
       return Response.SuccessResponse(null)
     }, true)
     // check resp
-    expect(count).to.be.equals(2)
-    expect(handlerResp).to.be.an.instanceof(Response)
+    c_expect(count).to.be.equals(2)
+    c_expect(handlerResp).to.be.an.instanceof(Response)
     if (handlerResp instanceof Response) {
-      expect(handlerResp?.getBody()).to.be.deep.equal({
+      c_expect(handlerResp?.getBody()).to.be.deep.equal({
         transactionID: 'unknown',
       })
-      expect(handlerResp.getCode()).to.be.equal(200)
+      c_expect(handlerResp.getCode()).to.be.equal(200)
     }
     // ctx
-    j_expect(context.fail).not.toBeCalled()
-    j_expect(context.done).not.toBeCalled()
-    j_expect(context.succeed).not.toBeCalled()
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
   })
 })
 
@@ -90,7 +89,7 @@ describe('EventProcessor failure invocation path', () => {
       err: any = null
     try {
       handlerResp = await transaction.processEvent(async (transaction, eventRecord) => {
-        expect(eventRecord).to.be.deep.equal(b)
+        c_expect(eventRecord).to.be.deep.equal(b)
         count++
         return count == 1 ? Response.SuccessResponse(null) : Response.BadRequestResponse('Failed!')
       })
@@ -98,9 +97,9 @@ describe('EventProcessor failure invocation path', () => {
       err = e
     }
     // check resp
-    expect(count).to.be.equals(2)
-    expect(handlerResp).to.be.null
-    expect(err).to.be.deep.equal(
+    c_expect(count).to.be.equals(2)
+    c_expect(handlerResp).to.be.null
+    c_expect(err).to.be.deep.equal(
       new Error(
         JSON.stringify({
           err: 'Failed!',
@@ -109,9 +108,9 @@ describe('EventProcessor failure invocation path', () => {
       )
     )
     // ctx
-    j_expect(context.fail).not.toBeCalled()
-    j_expect(context.done).not.toBeCalled()
-    j_expect(context.succeed).not.toBeCalled()
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
   })
 
   test('Simple failure w/ null', async () => {
@@ -135,7 +134,7 @@ describe('EventProcessor failure invocation path', () => {
       handlerResp = await transaction.processEvent(
         // @ts-ignore
         async (transaction, eventRecord) => {
-          expect(eventRecord).to.be.deep.equal(b)
+          c_expect(eventRecord).to.be.deep.equal(b)
           count++
           return null
         }
@@ -144,9 +143,9 @@ describe('EventProcessor failure invocation path', () => {
       err = e
     }
     // check resp
-    expect(count).to.be.equals(1)
-    expect(handlerResp).to.be.null
-    expect(err).to.be.deep.equal(
+    c_expect(count).to.be.equals(1)
+    c_expect(handlerResp).to.be.null
+    c_expect(err).to.be.deep.equal(
       new Error(
         JSON.stringify({
           err: Globals.ErrorResponseInvalidServerResponse,
@@ -157,9 +156,9 @@ describe('EventProcessor failure invocation path', () => {
       )
     )
     // ctx
-    j_expect(context.fail).not.toBeCalled()
-    j_expect(context.done).not.toBeCalled()
-    j_expect(context.succeed).not.toBeCalled()
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
   })
 
   test('Simple failure - allow failures', async () => {
@@ -175,19 +174,19 @@ describe('EventProcessor failure invocation path', () => {
     )
     let count = 0
     const handlerResp = await transaction.processEvent(async (transaction, eventRecord) => {
-      expect(eventRecord).to.be.deep.equal(b)
+      c_expect(eventRecord).to.be.deep.equal(b)
       count++
       return count == 1 ? Response.SuccessResponse(null) : Response.BadRequestResponse('Failed!')
     })
     // check resp
-    expect(count).to.be.equals(2)
-    expect(handlerResp).to.be.deep.equal({
+    c_expect(count).to.be.equals(2)
+    c_expect(handlerResp).to.be.deep.equal({
       batchItemFailures: [{ itemIdentifier: '123' }],
     })
     // ctx
-    j_expect(context.fail).not.toBeCalled()
-    j_expect(context.done).not.toBeCalled()
-    j_expect(context.succeed).not.toBeCalled()
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
   })
 
   test('Simple failure w/ null response - allow failures', async () => {
@@ -208,20 +207,20 @@ describe('EventProcessor failure invocation path', () => {
     const handlerResp = await transaction.processEvent(
       // @ts-ignore
       async (transaction, eventRecord) => {
-        expect(eventRecord).to.be.deep.equal(b)
+        c_expect(eventRecord).to.be.deep.equal(b)
         count++
         return null
       }
     )
     // check resp
-    expect(count).to.be.equals(2)
-    expect(handlerResp).to.be.deep.equal({
+    c_expect(count).to.be.equals(2)
+    c_expect(handlerResp).to.be.deep.equal({
       batchItemFailures: [{ itemIdentifier: '456' }, { itemIdentifier: '123' }],
     })
     // ctx
-    j_expect(context.fail).not.toBeCalled()
-    j_expect(context.done).not.toBeCalled()
-    j_expect(context.succeed).not.toBeCalled()
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
   })
 
   test('Simple failure no records', async () => {
@@ -242,9 +241,9 @@ describe('EventProcessor failure invocation path', () => {
       err = e
     }
     // check resp
-    expect(count).to.be.equals(0)
-    expect(handlerResp).to.be.null
-    expect(err).to.be.deep.equal(
+    c_expect(count).to.be.equals(0)
+    c_expect(handlerResp).to.be.null
+    c_expect(err).to.be.deep.equal(
       new Error(
         JSON.stringify({
           err: Globals.ErrorResponseNoRecords,
@@ -253,9 +252,9 @@ describe('EventProcessor failure invocation path', () => {
       )
     )
     // ctx
-    j_expect(context.fail).not.toBeCalled()
-    j_expect(context.done).not.toBeCalled()
-    j_expect(context.succeed).not.toBeCalled()
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
   })
 })
 

package/tests/BaseEvent/Process.test.ts

@@ -18,7 +18,7 @@ describe('Process success invocation path', () => {
     return new Promise(resolve => {
       setTimeout(() => {
         expect(count).to.be.equals(2)
-        clearInterval(proc.interval)
+        clearInterval(proc.timeout)
         resolve(null)
       }, 250)
     })
@@ -39,7 +39,7 @@ describe('Process failure invocation path', () => {
     return new Promise(resolve => {
       setTimeout(() => {
         expect(count).to.be.equals(2)
-        clearInterval(proc.interval)
+        clearInterval(proc.timeout)
         resolve(null)
       }, 250)
     })

package/tests/BaseEvent/Transaction.test.ts

@@ -1,8 +1,8 @@
-import { expect as j_expect } from '@jest/globals'
-import { expect } from 'chai'
+import { expect as c_expect } from 'chai'
 
 import Response from '../../src/API/Response'
 import Transaction from '../../src/BaseEvent/Transaction'
+import type { DbConfig } from '../../src/Database/types'
 import Globals from '../../src/Globals'
 import { defaultHeaders, emptyEvent, observableContext } from '../Test.utils'
 
@@ -15,11 +15,11 @@ describe('Transaction success invocation path', () => {
       return Response.SuccessResponse(b)
     })
     // check resp
-    expect(handlerResp).to.be.null
+    c_expect(handlerResp).to.be.null
     // ctx
-    j_expect(context.fail).not.toBeCalled()
-    j_expect(context.done).not.toBeCalled()
-    j_expect(context.succeed).toBeCalledWith({
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).toBeCalledWith({
       statusCode: 200,
       body: JSON.stringify(b),
       headers: defaultHeaders,
@@ -36,13 +36,13 @@ describe('Transaction success invocation path', () => {
       return Response.SuccessResponse(b)
     })
     // check resp
-    expect(handlerResp).to.be.an.instanceof(Response)
-    expect(handlerResp?.getBody()).to.be.deep.equals(b)
-    expect(handlerResp?.getCode()).to.be.equals(200)
+    c_expect(handlerResp).to.be.an.instanceof(Response)
+    c_expect(handlerResp?.getBody()).to.be.deep.equals(b)
+    c_expect(handlerResp?.getCode()).to.be.equals(200)
     // ctx
-    j_expect(context.fail).not.toBeCalled()
-    j_expect(context.done).not.toBeCalled()
-    j_expect(context.succeed).not.toBeCalled()
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
   })
 })
 
@@ -60,11 +60,11 @@ describe('Transaction error invocation path without response', () => {
       return null
     })
     // check resp
-    expect(handlerResp).to.be.null
+    c_expect(handlerResp).to.be.null
     // ctx
-    j_expect(context.fail).not.toBeCalled()
-    j_expect(context.done).not.toBeCalled()
-    j_expect(context.succeed).toBeCalledWith({
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).toBeCalledWith({
       statusCode: 400,
       body: JSON.stringify(b),
       headers: defaultHeaders,
@@ -92,13 +92,13 @@ describe('Transaction error invocation path without response', () => {
       return null
     })
     // check resp
-    expect(handlerResp).to.be.an.instanceof(Response)
-    expect(handlerResp?.getBody()).to.be.deep.equals(b)
-    expect(handlerResp?.getCode()).to.be.equals(400)
+    c_expect(handlerResp).to.be.an.instanceof(Response)
+    c_expect(handlerResp?.getBody()).to.be.deep.equals(b)
+    c_expect(handlerResp?.getCode()).to.be.equals(400)
     // ctx
-    j_expect(context.fail).not.toBeCalled()
-    j_expect(context.done).not.toBeCalled()
-    j_expect(context.succeed).not.toBeCalled()
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
   })
 })
 
@@ -117,11 +117,11 @@ describe('Transaction error invocation path with non-Response class response', (
       return b2
     })
     // check resp
-    expect(handlerResp).to.be.null
+    c_expect(handlerResp).to.be.null
     // ctx
-    j_expect(context.fail).not.toBeCalled()
-    j_expect(context.done).not.toBeCalled()
-    j_expect(context.succeed).toBeCalledWith({
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).toBeCalledWith({
       statusCode: 400,
       body: JSON.stringify(b),
       headers: defaultHeaders,
@@ -138,11 +138,11 @@ describe('Transaction error invocation path with non-Response class response', (
       return b2
     })
     // check resp
-    expect(handlerResp).to.be.deep.equals(b2)
+    c_expect(handlerResp).to.be.deep.equals(b2)
     // ctx
-    j_expect(context.fail).not.toBeCalled()
-    j_expect(context.done).not.toBeCalled()
-    j_expect(context.succeed).not.toBeCalled()
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
   })
 })
 
@@ -160,11 +160,11 @@ describe('Transaction error invocation path with exception', () => {
       throw new Error('Failed!')
     })
     // check resp
-    expect(handlerResp).to.be.null
+    c_expect(handlerResp).to.be.null
     // ctx
-    j_expect(context.fail).not.toBeCalled()
-    j_expect(context.done).not.toBeCalled()
-    j_expect(context.succeed).toBeCalledWith({
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).toBeCalledWith({
       statusCode: 400,
       body: JSON.stringify(b),
       headers: defaultHeaders,
@@ -186,12 +186,12 @@ describe('Transaction error invocation path with exception', () => {
       throw new Error('Failed!')
     })
     // check resp
-    expect(handlerResp?.getBody()).to.be.deep.equals(b)
-    expect(handlerResp?.getCode()).to.be.equals(400)
+    c_expect(handlerResp?.getBody()).to.be.deep.equals(b)
+    c_expect(handlerResp?.getCode()).to.be.equals(400)
     // ctx
-    j_expect(context.fail).not.toBeCalled()
-    j_expect(context.done).not.toBeCalled()
-    j_expect(context.succeed).not.toBeCalled()
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
   })
 
   test('Transaction exception - sync return', async () => {
@@ -210,12 +210,70 @@ describe('Transaction error invocation path with exception', () => {
       err = e
     }
     // check resp
-    expect(handlerResp).to.be.null
-    expect(err).to.be.deep.equals(error)
+    c_expect(handlerResp).to.be.null
+    c_expect(err).to.be.deep.equals(error)
     // ctx
-    j_expect(context.fail).not.toBeCalled()
-    j_expect(context.done).not.toBeCalled()
-    j_expect(context.succeed).not.toBeCalled()
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
+  })
+})
+
+describe('Transaction - db integration', () => {
+  const testResources = () => {
+    const mockTrans = {
+      select: jest.fn(),
+      closeSuccess: jest.fn(),
+      closeFailure: jest.fn(),
+    }
+    const mockCreate = jest.fn(
+      () => ({ transaction: () => new Promise(resolve => resolve(mockTrans)) }) as any
+    )
+
+    const transaction = new Transaction(emptyEvent(), observableContext())
+    transaction['databaseManager'] = {
+      create: mockCreate,
+    } as any
+
+    return {
+      transaction,
+      mockCreate,
+      mockTrans,
+    }
+  }
+
+  const config = { username: 'test' } as DbConfig<'knex'>
+
+  test('Transaction provides dbTransaction and calls closeSuccess', async () => {
+    const { mockCreate, mockTrans, transaction } = testResources()
+
+    await transaction.execute(async () => {
+      const knexTransaction = await transaction.getDbTransaction(config)
+
+      knexTransaction.select('name')
+
+      return Response.SuccessResponse(null)
+    })
+    expect(mockCreate).toBeCalledWith(config)
+    expect(mockTrans.select).toBeCalledWith('name')
+    expect(mockTrans.closeSuccess).toBeCalled()
+  })
+
+  test('Errored transaction calls closeFailure', async () => {
+    const { mockCreate, transaction, mockTrans } = testResources()
+
+    const ss = await transaction.execute(async () => {
+      const _ii = await transaction.getDbTransaction(config)
+      console.log('ii', _ii)
+      throw new Error('Something went wrong!')
+
+      return Response.SuccessResponse(null)
+    })
+
+    console.log(ss)
+
+    expect(mockCreate).toBeCalledWith(config)
+    expect(mockTrans.closeFailure).toBeCalled()
   })
 })
 

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)
   })
 })