@creator.co/wapi 1.2.1-beta6 → 1.2.3

package/tests/API/Utils.test.ts

@@ -0,0 +1,157 @@
+import { expect } from 'chai'
+
+import Utils from '../../src/API/Utils'
+
+describe('isHybridlessContainer', () => {
+  test('Simple isHybridlessContainer test', () => {
+    const v = Utils.isHybridlessContainer()
+    expect(v).to.be.a('boolean')
+    // this is done, so tests are reliable based on the testing .env
+    expect(v).to.be[process.env.HYBRIDLESS_RUNTIME ? 'true' : 'false']
+  })
+})
+
+describe('isValidString', () => {
+  test('Empty string is not valid', () => {
+    const v = Utils.isValidString('')
+    expect(v).to.be.a('boolean')
+    expect(v).to.be.false
+  })
+
+  test('Number is not a valid string', () => {
+    // @ts-ignore
+    const v = Utils.isValidString(12)
+    expect(v).to.be.a('boolean')
+    expect(v).to.be.false
+  })
+
+  test('Simple string is valid', () => {
+    const v = Utils.isValidString('abc')
+    expect(v).to.be.a('boolean')
+    expect(v).to.be.true
+  })
+})
+
+describe('parseIntNullIfNaN', () => {
+  test('Null if only chars', () => {
+    const v = Utils.parseIntNullIfNaN('abc')
+    expect(v).to.be.null
+  })
+
+  test('Null if chars with numbers', () => {
+    const v = Utils.parseIntNullIfNaN('abc123')
+    expect(v).to.be.null
+  })
+
+  test('Null if null', () => {
+    // @ts-ignore
+    const v = Utils.parseIntNullIfNaN(null)
+    expect(v).to.be.null
+  })
+
+  test('Not null if starts with numbers (js behavior)', () => {
+    const v = Utils.parseIntNullIfNaN('123abc')
+    expect(v).to.be.a('number')
+    expect(v).to.be.equals(123)
+  })
+
+  test('Not null if numbers', () => {
+    const v = Utils.parseIntNullIfNaN('123')
+    expect(v).to.be.a('number')
+    expect(v).to.be.equals(123)
+  })
+
+  test('Not null if number type', () => {
+    // @ts-ignore
+    const v = Utils.parseIntNullIfNaN(123)
+    expect(v).to.be.a('number')
+    expect(v).to.be.equals(123)
+  })
+})
+
+describe('parseObjectNullIfEmpty', () => {
+  test('Null if only chars', () => {
+    const v = Utils.parseObjectNullIfEmpty('abc')
+    expect(v).to.be.null
+  })
+
+  test('Null if chars with numbers', () => {
+    const v = Utils.parseObjectNullIfEmpty('abc123')
+    expect(v).to.be.null
+  })
+
+  test('Null if null', () => {
+    // @ts-ignore
+    const v = Utils.parseObjectNullIfEmpty(null)
+    expect(v).to.be.null
+  })
+
+  test('Null if malformed object', () => {
+    const v = Utils.parseObjectNullIfEmpty('{d: 123}')
+    expect(v).to.be.null
+  })
+
+  test('Null if empty object', () => {
+    const v = Utils.parseObjectNullIfEmpty('{}')
+    expect(v).to.be.null
+  })
+
+  test('Not null if object with a key', () => {
+    const v = Utils.parseObjectNullIfEmpty('{"d": 123}')
+    expect(v).to.be.a('object')
+    expect(v?.['d']).to.be.equals(123)
+  })
+})
+
+describe('isValidNumber', () => {
+  test('Not a valid number if only chars', () => {
+    const v = Utils.isValidNumber('abc')
+    expect(v).to.be.false
+  })
+
+  test('Not a valid number if only chars and numbers', () => {
+    const v = Utils.isValidNumber('abc123')
+    expect(v).to.be.false
+  })
+
+  test('Valid number if numbers and chars after', () => {
+    const v = Utils.isValidNumber('123abc')
+    expect(v).to.be.true
+  })
+
+  test('Valid number if numbers', () => {
+    const v = Utils.isValidNumber('123')
+    expect(v).to.be.true
+  })
+})
+
+describe('caseInsensitiveObjectForKey', () => {
+  test('Get a key that is lowercase, asking uppercase', () => {
+    const v = Utils.caseInsensitiveObjectForKey({ abc: 123 }, 'ABC')
+    expect(v).to.be.a('number')
+    expect(v).to.be.equals(123)
+  })
+
+  test('Get a key that is uppercase, asking lowercase', () => {
+    const v = Utils.caseInsensitiveObjectForKey({ ABC: 123 }, 'abc')
+    expect(v).to.be.a('number')
+    expect(v).to.be.equals(123)
+  })
+
+  test('Fails gracefully if key is not found', () => {
+    const v = Utils.caseInsensitiveObjectForKey({ ABC: 123 }, 'asd')
+    expect(v).to.be.null
+  })
+
+  test('Fails gracefully for null object', () => {
+    const v = Utils.caseInsensitiveObjectForKey(null, 'abc')
+    expect(v).to.be.null
+  })
+
+  test('Fails gracefully for invalid object', () => {
+    const v = Utils.caseInsensitiveObjectForKey('', 'abc')
+    expect(v).to.be.null
+  })
+})
+
+export {}

package/tests/BaseEvent/EventProcessor.test.ts

@@ -0,0 +1,262 @@
+import { expect as j_expect } from '@jest/globals'
+import { 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) => {
+      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)
+    if (handlerResp instanceof Response) {
+      expect(handlerResp?.getBody()).to.be.deep.equal({
+        transactionID: 'unknown',
+      })
+      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()
+  })
+
+  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) => {
+      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)
+    if (handlerResp instanceof Response) {
+      expect(handlerResp?.getBody()).to.be.deep.equal({
+        transactionID: 'unknown',
+      })
+      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()
+  })
+})
+
+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) => {
+        expect(eventRecord).to.be.deep.equal(b)
+        count++
+        return count == 1 ? Response.SuccessResponse(null) : Response.BadRequestResponse('Failed!')
+      })
+    } catch (e) {
+      err = e
+    }
+    // check resp
+    expect(count).to.be.equals(2)
+    expect(handlerResp).to.be.null
+    expect(err).to.be.deep.equal(
+      new Error(
+        JSON.stringify({
+          err: 'Failed!',
+          transactionID: 'unknown',
+        })
+      )
+    )
+    // ctx
+    j_expect(context.fail).not.toBeCalled()
+    j_expect(context.done).not.toBeCalled()
+    j_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) => {
+          expect(eventRecord).to.be.deep.equal(b)
+          count++
+          return null
+        }
+      )
+    } catch (e) {
+      err = e
+    }
+    // check resp
+    expect(count).to.be.equals(1)
+    expect(handlerResp).to.be.null
+    expect(err).to.be.deep.equal(
+      new Error(
+        JSON.stringify({
+          err: Globals.ErrorResponseInvalidServerResponse,
+          rollback: true,
+          errCode: Globals.ErrorCode_APIError,
+          transactionID: 'unknown',
+        })
+      )
+    )
+    // ctx
+    j_expect(context.fail).not.toBeCalled()
+    j_expect(context.done).not.toBeCalled()
+    j_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) => {
+      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({
+      batchItemFailures: [{ itemIdentifier: '123' }],
+    })
+    // ctx
+    j_expect(context.fail).not.toBeCalled()
+    j_expect(context.done).not.toBeCalled()
+    j_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) => {
+        expect(eventRecord).to.be.deep.equal(b)
+        count++
+        return null
+      }
+    )
+    // check resp
+    expect(count).to.be.equals(2)
+    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()
+  })
+
+  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
+    expect(count).to.be.equals(0)
+    expect(handlerResp).to.be.null
+    expect(err).to.be.deep.equal(
+      new Error(
+        JSON.stringify({
+          err: Globals.ErrorResponseNoRecords,
+          errCode: Globals.ErrorCode_NoRecords,
+        })
+      )
+    )
+    // ctx
+    j_expect(context.fail).not.toBeCalled()
+    j_expect(context.done).not.toBeCalled()
+    j_expect(context.succeed).not.toBeCalled()
+  })
+})
+
+export {}

package/tests/BaseEvent/Process.test.ts

@@ -0,0 +1,49 @@
+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.interval)
+        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.interval)
+        resolve(null)
+      }, 250)
+    })
+  })
+})
+
+export {}

package/tests/BaseEvent/Transaction.test.ts

@@ -0,0 +1,222 @@
+import { expect as j_expect } from '@jest/globals'
+import { expect } from 'chai'
+
+import Response from '../../src/API/Response'
+import Transaction from '../../src/BaseEvent/Transaction'
+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
+    expect(handlerResp).to.be.null
+    // ctx
+    j_expect(context.fail).not.toBeCalled()
+    j_expect(context.done).not.toBeCalled()
+    j_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
+    expect(handlerResp).to.be.an.instanceof(Response)
+    expect(handlerResp?.getBody()).to.be.deep.equals(b)
+    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()
+  })
+})
+
+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)
+    const handlerResp = await transaction.execute(async () => {
+      return null
+    })
+    // check resp
+    expect(handlerResp).to.be.null
+    // ctx
+    j_expect(context.fail).not.toBeCalled()
+    j_expect(context.done).not.toBeCalled()
+    j_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,
+      }
+    )
+    const handlerResp = await transaction.execute(async () => {
+      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)
+    // ctx
+    j_expect(context.fail).not.toBeCalled()
+    j_expect(context.done).not.toBeCalled()
+    j_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
+    expect(handlerResp).to.be.null
+    // ctx
+    j_expect(context.fail).not.toBeCalled()
+    j_expect(context.done).not.toBeCalled()
+    j_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
+    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()
+  })
+})
+
+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
+    expect(handlerResp).to.be.null
+    // ctx
+    j_expect(context.fail).not.toBeCalled()
+    j_expect(context.done).not.toBeCalled()
+    j_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
+    expect(handlerResp?.getBody()).to.be.deep.equals(b)
+    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()
+  })
+
+  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
+    expect(handlerResp).to.be.null
+    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()
+  })
+})
+
+export {}