@creator.co/wapi 1.2.1-beta6 → 1.2.2

package/tests/BaseEvent/EventProcessor.test.ts

@@ -0,0 +1,278 @@
+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,231 @@
+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 {}