@ikonintegration/ikapi 4.0.1 → 5.0.0

package/tests/BaseEvent/DynamoTransaction.test.ts

@@ -0,0 +1,272 @@
+import { expect as c_expect } from 'chai'
+
+import Response from '../../src/API/Response.js'
+import DynamoTransaction from '../../src/BaseEvent/DynamoTransaction.js'
+import Globals from '../../src/Globals.js'
+import Utils from '../../src/Util/Utils.js'
+import { emptyDynamoDBEvent, observableContext } from '../Test.utils.js'
+
+const skipCleanTmp = {
+  skipCleanTmp: true,
+}
+
+describe('DynamoTransaction success invocation path', () => {
+  test('Simple success', async () => {
+    const record = { id: '123' }
+    const context = observableContext()
+    const transaction = new DynamoTransaction(
+      emptyDynamoDBEvent({
+        Records: [
+          { dynamodb: { NewImage: Utils.ddbMarshall(record) } },
+          { dynamodb: { NewImage: Utils.ddbMarshall(record) } },
+        ],
+      }),
+      context
+    )
+    let count = 0
+    const handlerResp = await transaction.processEvent(async (transaction, eventRecord) => {
+      c_expect(eventRecord.marshalled.NewImage).to.be.deep.equal(record)
+      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 record = { id: '123' }
+    const context = observableContext()
+    const transaction = new DynamoTransaction(
+      emptyDynamoDBEvent({
+        Records: [
+          { dynamodb: { NewImage: Utils.ddbMarshall(record) } },
+          { dynamodb: { NewImage: Utils.ddbMarshall(record) } },
+        ],
+      }),
+      context,
+      { ...skipCleanTmp }
+    )
+    let count = 0
+    const handlerResp = await transaction.processEvent(async (transaction, eventRecord) => {
+      c_expect(eventRecord.dynamodb?.NewImage).to.be.deep.equal(Utils.ddbMarshall(record))
+      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()
+  })
+})
+
+describe('DynamoTransaction failure invocation path', () => {
+  test('Simple failure', async () => {
+    const record = { id: '123' }
+    const context = observableContext()
+    const transaction = new DynamoTransaction(
+      emptyDynamoDBEvent({
+        Records: [
+          { dynamodb: { NewImage: Utils.ddbMarshall(record) } },
+          { eventID: '123', dynamodb: { NewImage: Utils.ddbMarshall(record) } },
+          { dynamodb: { NewImage: Utils.ddbMarshall(record) } },
+        ],
+      }),
+      context,
+      { ...skipCleanTmp }
+    )
+    let count = 0
+    let handlerResp: any = null,
+      err: any = null
+    try {
+      handlerResp = await transaction.processEvent(async (transaction, eventRecord) => {
+        c_expect(eventRecord.marshalled.NewImage).to.be.deep.equal(record)
+        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 record = { id: '123' }
+    const context = observableContext()
+    const transaction = new DynamoTransaction(
+      emptyDynamoDBEvent({
+        Records: [
+          { dynamodb: { NewImage: Utils.ddbMarshall(record) } },
+          { eventID: '123', dynamodb: { NewImage: Utils.ddbMarshall(record) } },
+          { dynamodb: { NewImage: Utils.ddbMarshall(record) } },
+        ],
+      }),
+      context,
+      { ...skipCleanTmp }
+    )
+    let count = 0
+    let handlerResp: any = null,
+      err: any = null
+    try {
+      handlerResp = await transaction.processEvent(
+        // @ts-ignore
+        async (transaction, eventRecord) => {
+          c_expect(eventRecord.marshalled.NewImage).to.be.deep.equal(record)
+          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 record = { id: '123' }
+    const context = observableContext()
+    const transaction = new DynamoTransaction(
+      emptyDynamoDBEvent({
+        Records: [
+          { dynamodb: { NewImage: Utils.ddbMarshall(record) } },
+          { eventID: '123', dynamodb: { NewImage: Utils.ddbMarshall(record) } },
+        ],
+      }),
+      context,
+      { ...skipCleanTmp },
+      true
+    )
+    let count = 0
+    const handlerResp = await transaction.processEvent(async (transaction, eventRecord) => {
+      c_expect(eventRecord.marshalled.NewImage).to.be.deep.equal(record)
+      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 record = { id: '123' }
+    const context = observableContext()
+    const transaction = new DynamoTransaction(
+      emptyDynamoDBEvent({
+        Records: [
+          { eventID: '456', dynamodb: { NewImage: Utils.ddbMarshall(record) } },
+          { eventID: '123', dynamodb: { NewImage: Utils.ddbMarshall(record) } },
+        ],
+      }),
+      context,
+      { ...skipCleanTmp },
+      true
+    )
+    let count = 0
+    const handlerResp = await transaction.processEvent(
+      // @ts-ignore
+      async (transaction, eventRecord) => {
+        c_expect(eventRecord.marshalled.NewImage).to.be.deep.equal(record)
+        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 DynamoTransaction(emptyDynamoDBEvent(), 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()
+  })
+})

package/tests/BaseEvent/EventProcessor.test.ts

@@ -0,0 +1,263 @@
+import { expect as c_expect } from 'chai'
+
+import Response from '../../src/API/Response.js'
+import EventProcessor from '../../src/BaseEvent/EventProcessor.js'
+import Globals from '../../src/Globals.js'
+import { emptyQueueEvent, observableContext } from '../Test.utils.js'
+
+const skipCleanTmp = {
+  skipCleanTmp: true,
+}
+
+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,
+      { ...skipCleanTmp }
+    )
+    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,
+      { ...skipCleanTmp }
+    )
+    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,
+      { ...skipCleanTmp }
+    )
+    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,
+      { ...skipCleanTmp }
+    )
+    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,
+      { ...skipCleanTmp },
+      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,
+      { ...skipCleanTmp },
+      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()
+  })
+})

package/tests/BaseEvent/Process.test.ts

@@ -0,0 +1,47 @@
+import { expect } from 'chai'
+
+import Response from '../../src/API/Response.js'
+import Process from '../../src/BaseEvent/Process.js'
+
+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)
+    })
+  })
+})

package/tests/BaseEvent/StepTransaction.test.ts

@@ -0,0 +1,44 @@
+import { Context } from 'aws-lambda' // Import Context from aws-lambda
+
+import Response from '../../src/API/Response.js'
+import StepTransaction from '../../src/BaseEvent/StepTransaction.js'
+import Transaction from '../../src/BaseEvent/Transaction.js'
+
+describe('StepTransaction', () => {
+  let mockEvent
+  let mockContext
+
+  beforeEach(() => {
+    mockEvent = { key: 'value' }
+    mockContext = {} as Context // Mock AWS Lambda context object
+  })
+
+  describe('constructor', () => {
+    test('should create an instance of StepTransaction with default config', () => {
+      const stepTransaction = new StepTransaction(mockEvent, mockContext)
+
+      expect(stepTransaction).toBeInstanceOf(StepTransaction)
+      expect(stepTransaction).toBeInstanceOf(Transaction)
+      expect((stepTransaction as any).syncReturn).toBe(true)
+      expect((stepTransaction as any).retrowErrors).toBe(true)
+    })
+  })
+
+  describe('getErrorResponse', () => {
+    test('should return an error response with provided error and code', () => {
+      const stepTransaction = new StepTransaction(mockEvent, mockContext)
+      const error = 'Test error message'
+      const code = 'TestErrorCode'
+
+      const response = (stepTransaction as any).getErrorResponse(error, code)
+
+      expect(response).toBeInstanceOf(Response)
+      expect(response).toEqual(
+        expect.objectContaining({
+          statusCode: 400,
+          body: { err: error, errCode: code },
+        })
+      )
+    })
+  })
+})