@creator.co/wapi 1.7.1-alpha1 → 1.7.1-alpha3

package/tests/BaseEvent/EventProcessor.test.ts

@@ -1,261 +0,0 @@
-import { expect as c_expect } from 'chai'
-
-import Response from '../../src/API/Response'
-import EventProcessor from '../../src/BaseEvent/EventProcessor'
-import Globals from '../../src/Globals'
-import { emptyQueueEvent, observableContext } from '../Test.utils'
-
-describe('EventProcessor success invocation path', () => {
-  test('Simple success', async () => {
-    const b = { name: '123' }
-    const context = observableContext()
-    const transaction = new EventProcessor(
-      emptyQueueEvent({
-        Records: [{ body: JSON.stringify(b) }, { body: JSON.stringify(b) }],
-      }),
-      context,
-      {}
-    )
-    let count = 0
-    const handlerResp = await transaction.processEvent(async (transaction, eventRecord) => {
-      c_expect(eventRecord).to.be.deep.equal(b)
-      count++
-      return Response.SuccessResponse(null)
-    })
-    // check resp
-    c_expect(count).to.be.equals(2)
-    c_expect(handlerResp).to.be.an.instanceof(Response)
-    if (handlerResp instanceof Response) {
-      c_expect(handlerResp?.getBody()).to.be.deep.equal({
-        transactionID: 'unknown',
-      })
-      c_expect(handlerResp.getCode()).to.be.equal(200)
-    }
-    // ctx
-    expect(context.fail).not.toBeCalled()
-    expect(context.done).not.toBeCalled()
-    expect(context.succeed).not.toBeCalled()
-  })
-
-  test('Simple success - do not decode', async () => {
-    const b = { name: '123' }
-    const context = observableContext()
-    const transaction = new EventProcessor(
-      emptyQueueEvent({
-        Records: [{ body: JSON.stringify(b) }, { body: JSON.stringify(b) }],
-      }),
-      context,
-      {}
-    )
-    let count = 0
-    const handlerResp = await transaction.processEvent(async (transaction, eventRecord) => {
-      c_expect(eventRecord).to.be.deep.equal(JSON.stringify(b))
-      count++
-      return Response.SuccessResponse(null)
-    }, true)
-    // check resp
-    c_expect(count).to.be.equals(2)
-    c_expect(handlerResp).to.be.an.instanceof(Response)
-    if (handlerResp instanceof Response) {
-      c_expect(handlerResp?.getBody()).to.be.deep.equal({
-        transactionID: 'unknown',
-      })
-      c_expect(handlerResp.getCode()).to.be.equal(200)
-    }
-    // ctx
-    expect(context.fail).not.toBeCalled()
-    expect(context.done).not.toBeCalled()
-    expect(context.succeed).not.toBeCalled()
-  })
-})
-
-describe('EventProcessor failure invocation path', () => {
-  test('Simple failure', async () => {
-    const b = { name: '123' }
-    const context = observableContext()
-    const transaction = new EventProcessor(
-      emptyQueueEvent({
-        Records: [
-          { body: JSON.stringify(b) },
-          { messageId: '123', body: JSON.stringify(b) },
-          { body: JSON.stringify(b) },
-        ],
-      }),
-      context,
-      {}
-    )
-    let count = 0
-    let handlerResp: any = null,
-      err: any = null
-    try {
-      handlerResp = await transaction.processEvent(async (transaction, eventRecord) => {
-        c_expect(eventRecord).to.be.deep.equal(b)
-        count++
-        return count == 1 ? Response.SuccessResponse(null) : Response.BadRequestResponse('Failed!')
-      })
-    } catch (e) {
-      err = e
-    }
-    // check resp
-    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!',
-          transactionID: 'unknown',
-        })
-      )
-    )
-    // ctx
-    expect(context.fail).not.toBeCalled()
-    expect(context.done).not.toBeCalled()
-    expect(context.succeed).not.toBeCalled()
-  })
-
-  test('Simple failure w/ null', async () => {
-    const b = { name: '123' }
-    const context = observableContext()
-    const transaction = new EventProcessor(
-      emptyQueueEvent({
-        Records: [
-          { body: JSON.stringify(b) },
-          { messageId: '123', body: JSON.stringify(b) },
-          { body: JSON.stringify(b) },
-        ],
-      }),
-      context,
-      {}
-    )
-    let count = 0
-    let handlerResp: any = null,
-      err: any = null
-    try {
-      handlerResp = await transaction.processEvent(
-        // @ts-ignore
-        async (transaction, eventRecord) => {
-          c_expect(eventRecord).to.be.deep.equal(b)
-          count++
-          return null
-        }
-      )
-    } catch (e) {
-      err = e
-    }
-    // check resp
-    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,
-          rollback: true,
-          errCode: Globals.ErrorCode_APIError,
-          transactionID: 'unknown',
-        })
-      )
-    )
-    // ctx
-    expect(context.fail).not.toBeCalled()
-    expect(context.done).not.toBeCalled()
-    expect(context.succeed).not.toBeCalled()
-  })
-
-  test('Simple failure - allow failures', async () => {
-    const b = { name: '123' }
-    const context = observableContext()
-    const transaction = new EventProcessor(
-      emptyQueueEvent({
-        Records: [{ body: JSON.stringify(b) }, { messageId: '123', body: JSON.stringify(b) }],
-      }),
-      context,
-      {},
-      true
-    )
-    let count = 0
-    const handlerResp = await transaction.processEvent(async (transaction, eventRecord) => {
-      c_expect(eventRecord).to.be.deep.equal(b)
-      count++
-      return count == 1 ? Response.SuccessResponse(null) : Response.BadRequestResponse('Failed!')
-    })
-    // check resp
-    c_expect(count).to.be.equals(2)
-    c_expect(handlerResp).to.be.deep.equal({
-      batchItemFailures: [{ itemIdentifier: '123' }],
-    })
-    // ctx
-    expect(context.fail).not.toBeCalled()
-    expect(context.done).not.toBeCalled()
-    expect(context.succeed).not.toBeCalled()
-  })
-
-  test('Simple failure w/ null response - allow failures', async () => {
-    const b = { name: '123' }
-    const context = observableContext()
-    const transaction = new EventProcessor(
-      emptyQueueEvent({
-        Records: [
-          { messageId: '456', body: JSON.stringify(b) },
-          { messageId: '123', body: JSON.stringify(b) },
-        ],
-      }),
-      context,
-      {},
-      true
-    )
-    let count = 0
-    const handlerResp = await transaction.processEvent(
-      // @ts-ignore
-      async (transaction, eventRecord) => {
-        c_expect(eventRecord).to.be.deep.equal(b)
-        count++
-        return null
-      }
-    )
-    // check resp
-    c_expect(count).to.be.equals(2)
-    c_expect(handlerResp).to.be.deep.equal({
-      batchItemFailures: [{ itemIdentifier: '456' }, { itemIdentifier: '123' }],
-    })
-    // ctx
-    expect(context.fail).not.toBeCalled()
-    expect(context.done).not.toBeCalled()
-    expect(context.succeed).not.toBeCalled()
-  })
-
-  test('Simple failure no records', async () => {
-    const context = observableContext()
-    const transaction = new EventProcessor(emptyQueueEvent(), context, {})
-    let count = 0
-    let handlerResp: any = null,
-      err: any = null
-    try {
-      handlerResp = await transaction.processEvent(
-        // @ts-ignore
-        async () => {
-          count++
-          return null
-        }
-      )
-    } catch (e) {
-      err = e
-    }
-    // check resp
-    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,
-          errCode: Globals.ErrorCode_NoRecords,
-        })
-      )
-    )
-    // ctx
-    expect(context.fail).not.toBeCalled()
-    expect(context.done).not.toBeCalled()
-    expect(context.succeed).not.toBeCalled()
-  })
-})
-
-export {}

package/tests/BaseEvent/Process.test.ts

@@ -1,49 +0,0 @@
-import { expect } from 'chai'
-
-import Response from '../../src/API/Response'
-import Process from '../../src/BaseEvent/Process'
-
-describe('Process success invocation path', () => {
-  test('Simple success', async () => {
-    const b = { name: '123' }
-    const proc = new Process({}, 100)
-    let count = 0
-    const handlerResp = await proc.execute(async () => {
-      count++
-      return Response.SuccessResponse(b)
-    })
-    // check resp
-    expect(handlerResp).to.be.undefined
-    // check iterations
-    return new Promise(resolve => {
-      setTimeout(() => {
-        expect(count).to.be.equals(2)
-        clearInterval(proc.timeout)
-        resolve(null)
-      }, 250)
-    })
-  })
-})
-
-describe('Process failure invocation path', () => {
-  test('Simple failure', async () => {
-    const proc = new Process({}, 100)
-    let count = 0
-    const handlerResp = await proc.execute(async () => {
-      count++
-      throw new Error('Failed!')
-    })
-    // check resp
-    expect(handlerResp).to.be.undefined
-    // check iterations
-    return new Promise(resolve => {
-      setTimeout(() => {
-        expect(count).to.be.equals(2)
-        clearInterval(proc.timeout)
-        resolve(null)
-      }, 250)
-    })
-  })
-})
-
-export {}

package/tests/BaseEvent/Transaction.test.ts

@@ -1,408 +0,0 @@
-import { jest } from '@jest/globals'
-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'
-
-describe('Transaction success invocation path', () => {
-  test('Simple success', async () => {
-    const b = { name: '123' }
-    const context = observableContext()
-    const transaction = new Transaction<null, typeof b>(emptyEvent(), context)
-    const handlerResp = await transaction.execute(async () => {
-      return Response.SuccessResponse(b)
-    })
-    // check resp
-    c_expect(handlerResp).to.be.null
-    // ctx
-    expect(context.fail).not.toBeCalled()
-    expect(context.done).not.toBeCalled()
-    expect(context.succeed).toBeCalledWith({
-      statusCode: 200,
-      body: JSON.stringify(b),
-      headers: defaultHeaders,
-    })
-  })
-
-  test('Simple success - sync return', async () => {
-    const b = { name: '123' }
-    const context = observableContext()
-    const transaction = new Transaction<null, typeof b>(emptyEvent(), context, {
-      syncReturn: true,
-    })
-    const handlerResp = await transaction.execute(async () => {
-      return Response.SuccessResponse(b)
-    })
-    // check resp
-    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
-    expect(context.fail).not.toBeCalled()
-    expect(context.done).not.toBeCalled()
-    expect(context.succeed).not.toBeCalled()
-  })
-})
-
-describe('Transaction error invocation path without response', () => {
-  test('Not valid response returned success', async () => {
-    const b = {
-      err: Globals.ErrorResponseInvalidServerResponse,
-      rollback: true,
-      errCode: Globals.ErrorCode_APIError,
-      transactionID: '123',
-    }
-    const context = observableContext({ awsRequestId: '123' })
-    const transaction = new Transaction<null, typeof b>(emptyEvent(), context)
-    // @ts-expect-error
-    const handlerResp = await transaction.execute(async () => {
-      return null
-    })
-    // check resp
-    c_expect(handlerResp).to.be.null
-    // ctx
-    expect(context.fail).not.toBeCalled()
-    expect(context.done).not.toBeCalled()
-    expect(context.succeed).toBeCalledWith({
-      statusCode: 400,
-      body: JSON.stringify(b),
-      headers: defaultHeaders,
-    })
-  })
-
-  test('Not valid response returned success - sync return', async () => {
-    const b = {
-      err: Globals.ErrorResponseInvalidServerResponse,
-      rollback: true,
-      errCode: Globals.ErrorCode_APIError,
-      transactionID: '123',
-    }
-    const context = observableContext()
-    const transaction = new Transaction<null, typeof b>(
-      emptyEvent({
-        requestContext: { requestId: '123' },
-      }),
-      context,
-      {
-        syncReturn: true,
-      }
-    )
-    // @ts-expect-error
-    const handlerResp = await transaction.execute(async () => {
-      return null
-    })
-    // check resp
-    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
-    expect(context.fail).not.toBeCalled()
-    expect(context.done).not.toBeCalled()
-    expect(context.succeed).not.toBeCalled()
-  })
-})
-
-describe('Transaction error invocation path with non-Response class response', () => {
-  test('Not a response-class response returned success', async () => {
-    const b = {
-      err: Globals.ErrorResponseInvalidServerResponse,
-      rollback: true,
-      errCode: Globals.ErrorCode_APIError,
-      transactionID: 'unknown',
-    }
-    const b2 = { name: 'abc' }
-    const context = observableContext()
-    const transaction = new Transaction<null, null, typeof b2>(emptyEvent(), context)
-    const handlerResp = await transaction.execute(async () => {
-      return b2
-    })
-    // check resp
-    c_expect(handlerResp).to.be.null
-    // ctx
-    expect(context.fail).not.toBeCalled()
-    expect(context.done).not.toBeCalled()
-    expect(context.succeed).toBeCalledWith({
-      statusCode: 400,
-      body: JSON.stringify(b),
-      headers: defaultHeaders,
-    })
-  })
-
-  test('Not a response-class response returned success - sync return', async () => {
-    const b2 = { name: 'abc' }
-    const context = observableContext()
-    const transaction = new Transaction<null, null, typeof b2>(emptyEvent(), context, {
-      syncReturn: true,
-    })
-    const handlerResp = await transaction.execute(async () => {
-      return b2
-    })
-    // check resp
-    c_expect(handlerResp).to.be.deep.equals(b2)
-    // ctx
-    expect(context.fail).not.toBeCalled()
-    expect(context.done).not.toBeCalled()
-    expect(context.succeed).not.toBeCalled()
-  })
-})
-
-describe('Transaction error invocation path with exception', () => {
-  test('Transaction exception', async () => {
-    const b = {
-      err: Globals.ErrorResponseUnhandledError,
-      rollback: true,
-      errCode: Globals.ErrorCode_APIError,
-      transactionID: 'unknown',
-    }
-    const context = observableContext()
-    const transaction = new Transaction<null, null, null>(emptyEvent(), context)
-    const handlerResp = await transaction.execute(async () => {
-      throw new Error('Failed!')
-    })
-    // check resp
-    c_expect(handlerResp).to.be.null
-    // ctx
-    expect(context.fail).not.toBeCalled()
-    expect(context.done).not.toBeCalled()
-    expect(context.succeed).toBeCalledWith({
-      statusCode: 400,
-      body: JSON.stringify(b),
-      headers: defaultHeaders,
-    })
-  })
-
-  test('Transaction exception - sync return', async () => {
-    const b = {
-      err: Globals.ErrorResponseUnhandledError,
-      rollback: true,
-      errCode: Globals.ErrorCode_APIError,
-      transactionID: 'unknown',
-    }
-    const context = observableContext()
-    const transaction = new Transaction<null, null, null>(emptyEvent(), context, {
-      syncReturn: true,
-    })
-    const handlerResp = await transaction.execute(async () => {
-      throw new Error('Failed!')
-    })
-    // check resp
-    c_expect(handlerResp?.getBody()).to.be.deep.equals(b)
-    c_expect(handlerResp?.getCode()).to.be.equals(400)
-    // ctx
-    expect(context.fail).not.toBeCalled()
-    expect(context.done).not.toBeCalled()
-    expect(context.succeed).not.toBeCalled()
-  })
-
-  test('Transaction exception - sync return', async () => {
-    const context = observableContext()
-    const transaction = new Transaction<null, null, null>(emptyEvent(), context, {
-      throwOnErrors: true,
-    })
-    const error = new Error('Failed!')
-    let handlerResp: any = null,
-      err: any = null
-    try {
-      handlerResp = await transaction.execute(async () => {
-        throw error
-      })
-    } catch (e) {
-      err = e
-    }
-    // check resp
-    c_expect(handlerResp).to.be.null
-    c_expect(err).to.be.deep.equals(error)
-    // ctx
-    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()
-  })
-})
-
-describe('Transaction response types', () => {
-  test('Non-response return', async () => {
-    const b = { name: '123' }
-    const b2 = {
-      err: Globals.ErrorResponseInvalidServerResponse,
-      rollback: true,
-      errCode: Globals.ErrorCode_APIError,
-      transactionID: 'unknown',
-    }
-    const context = observableContext()
-    const transaction = new Transaction<null, typeof b>(emptyEvent(), context)
-    // @ts-expect-error
-    const handlerResp = await transaction.execute(async () => {
-      return { d: 1 }
-    })
-    // check resp
-    c_expect(handlerResp).to.be.null
-    // ctx
-    expect(context.fail).not.toBeCalled()
-    expect(context.done).not.toBeCalled()
-    expect(context.succeed).toBeCalledWith({
-      statusCode: 400,
-      body: JSON.stringify(b2),
-      headers: defaultHeaders,
-    })
-  })
-
-  test('Null return', async () => {
-    const b = { name: '123' }
-    const b2 = {
-      err: Globals.ErrorResponseInvalidServerResponse,
-      rollback: true,
-      errCode: Globals.ErrorCode_APIError,
-      transactionID: 'unknown',
-    }
-    const context = observableContext()
-    const transaction = new Transaction<null, typeof b>(emptyEvent(), context)
-    // @ts-expect-error
-    const handlerResp = await transaction.execute(async () => {
-      return null
-    })
-    // check resp
-    c_expect(handlerResp).to.be.null
-    // ctx
-    expect(context.fail).not.toBeCalled()
-    expect(context.done).not.toBeCalled()
-    expect(context.succeed).toBeCalledWith({
-      statusCode: 400,
-      body: JSON.stringify(b2),
-      headers: defaultHeaders,
-    })
-  })
-
-  test('Undefined return', async () => {
-    const b = { name: '123' }
-    const b2 = {
-      err: Globals.ErrorResponseInvalidServerResponse,
-      rollback: true,
-      errCode: Globals.ErrorCode_APIError,
-      transactionID: 'unknown',
-    }
-    const context = observableContext()
-    const transaction = new Transaction<null, typeof b>(emptyEvent(), context)
-    // @ts-expect-error
-    const handlerResp = await transaction.execute(async () => {
-      return
-    })
-    // check resp
-    c_expect(handlerResp).to.be.null
-    // ctx
-    expect(context.fail).not.toBeCalled()
-    expect(context.done).not.toBeCalled()
-    expect(context.succeed).toBeCalledWith({
-      statusCode: 400,
-      body: JSON.stringify(b2),
-      headers: defaultHeaders,
-    })
-  })
-
-  test('Null inner-response return', async () => {
-    const b = { name: '123' }
-    const b2 = { transactionID: 'unknown' }
-    const context = observableContext()
-    const transaction = new Transaction<null, typeof b>(emptyEvent(), context)
-    // @ts-expect-error
-    const handlerResp = await transaction.execute(async () => {
-      return Response.SuccessResponse(null)
-    })
-    // check resp
-    c_expect(handlerResp).to.be.null
-    // ctx
-    expect(context.fail).not.toBeCalled()
-    expect(context.done).not.toBeCalled()
-    expect(context.succeed).toBeCalledWith({
-      statusCode: 200,
-      body: JSON.stringify(b2),
-      headers: defaultHeaders,
-    })
-  })
-
-  test('Wrong keys inner-response return', async () => {
-    const b = { name: '123' }
-    const b2 = {
-      notName: '123',
-      transactionID: 'unknown',
-    }
-    const context = observableContext()
-    const transaction = new Transaction<null, typeof b>(emptyEvent(), context)
-    // @ts-expect-error
-    const handlerResp = await transaction.execute(async () => {
-      return Response.SuccessResponse({ notName: '123' })
-    })
-    // check resp
-    c_expect(handlerResp).to.be.null
-    // ctx
-    expect(context.fail).not.toBeCalled()
-    expect(context.done).not.toBeCalled()
-    expect(context.succeed).toBeCalledWith({
-      statusCode: 200,
-      body: JSON.stringify(b2),
-      headers: defaultHeaders,
-    })
-  })
-})
-
-export {}