@creator.co/wapi 1.2.1-beta6 → 1.2.2

package/tests/API/Response.test.ts

@@ -0,0 +1,372 @@
+import { expect as j_expect } from "@jest/globals"
+import { APIGatewayEvent, Context } from "aws-lambda"
+import { expect } from "chai"
+
+import Response from "../../src/API/Response"
+import Transaction from "../../src/BaseEvent/Transaction"
+import Globals from "../../src/Globals"
+import { observableTransaction, defaultHeaders } from "../Test.utils"
+
+async function testResponse(
+  r: Response<any>,
+  body: any,
+  optCode?: number,
+  optHeaders?: any,
+) {
+  const t = observableTransaction()
+  const context = t["context"]
+  const buildR = await r.build(context, t, false)
+  expect(buildR).to.be.undefined
+  j_expect(t.responseProxy).toBeCalledTimes(1)
+  j_expect(context.fail).not.toBeCalled()
+  j_expect(context.done).not.toBeCalled()
+  j_expect(context.succeed).toHaveBeenCalledWith({
+    statusCode: optCode || 400,
+    headers: {
+      ...defaultHeaders,
+      ...(optHeaders || {}),
+    },
+    ...(body
+      ? {
+          body: JSON.stringify({
+            ...body,
+            transactionID: "unknown",
+          }),
+        }
+      : {}),
+  })
+}
+
+describe("Response basics", () => {
+  test("Null body", () => {
+    const r = new Response<null>(200, null)
+    expect(r.getCode()).to.be.equals(200)
+    expect(r.getBody()).to.be.null
+  })
+
+  test("String body", () => {
+    const r = new Response<string>(200, "abc")
+    expect(r.getCode()).to.be.equals(200)
+    expect(r.getBody()).to.be.equals("abc")
+  })
+
+  test("Generic body", () => {
+    const r = new Response<any>(200, { name: "abc" })
+    r.appendIntoBody("name2", "123")
+    expect(r.getCode()).to.be.equals(200)
+    expect(r.getBody().name).to.be.equals("abc")
+    expect(r.getBody().name2).to.be.equals("123")
+  })
+
+  test("Append/validate header", () => {
+    const r = new Response<any>(200, {})
+    r.appendHeader("name2", "123")
+    expect(r["_headers"]["name2"]).to.be.equals("123")
+  })
+})
+
+describe("Response build", () => {
+  test("Succeeds to transaction context", async () => {
+    const b = { name: "abc" }
+    const r = new Response<any>(200, b)
+    r.appendHeader("abc", "123")
+    // do not use default, so we dont use proxy response for once
+    const t = new Transaction(
+      <APIGatewayEvent>(<unknown>{}),
+      <Context>(<unknown>{
+        done: jest.fn(),
+        fail: jest.fn(),
+        succeed: jest.fn(),
+      }),
+    )
+    const context = t["context"]
+    const buildR = await r.build(context, t, false)
+    expect(buildR).to.be.undefined
+    j_expect(context.fail).not.toBeCalled()
+    j_expect(context.done).not.toBeCalled()
+    j_expect(context.succeed).toHaveBeenCalledWith({
+      statusCode: 200,
+      headers: {
+        ...defaultHeaders,
+        abc: "123",
+      },
+      body: JSON.stringify({
+        ...b,
+        transactionID: "unknown",
+      }),
+    })
+  })
+
+  test("Succeeds with no context call", async () => {
+    const b = { name: "abc" }
+    const r = new Response<any>(200, b)
+    const t = observableTransaction()
+    const context = t["context"]
+    const buildR = await r.build(context, t, true)
+    expect(buildR).to.be.undefined
+    j_expect(context.fail).not.toBeCalled()
+    j_expect(context.done).not.toBeCalled()
+    j_expect(context.succeed).not.toBeCalled()
+  })
+
+  test("Succeeds to transaction context as RAW", async () => {
+    const b = { name: "abc" }
+    const r = new Response<any>(200, b, {
+      rawBody: true,
+    })
+    const t = observableTransaction()
+    const context = t["context"]
+    const buildR = await r.build(context, t, false)
+    expect(buildR).to.be.undefined
+    j_expect(context.fail).not.toBeCalled()
+    j_expect(context.done).not.toBeCalled()
+    j_expect(context.succeed).toHaveBeenCalledWith({
+      ...b,
+      transactionID: "unknown",
+    })
+  })
+
+  test("Succeeds to transaction piping", async () => {
+    const b = { name: "abc" }
+    const r = new Response<any>(200, b, {
+      shouldStream: true,
+    })
+    const t = observableTransaction()
+    const context = t["context"]
+    const buildR = await r.build(context, t, false)
+    await r.build(context, t, false) //pipe twice, should not affect
+    expect(buildR).to.be.undefined
+    j_expect(context.fail).not.toBeCalled()
+    j_expect(context.done).not.toBeCalled()
+    j_expect(context.succeed).toHaveBeenCalledTimes(1)
+    j_expect(context.succeed).toHaveBeenCalledWith({
+      statusCode: 200,
+      headers: {
+        ...defaultHeaders,
+      },
+      body: {
+        ...b,
+      },
+    })
+  })
+
+  test("Failure to transaction context as RAW", async () => {
+    const b = { name: "abc" }
+    const r = new Response<any>(400, b, {
+      rawBody: true,
+    })
+    const t = observableTransaction()
+    const context = t["context"]
+    const buildR = await r.build(context, t, false)
+    expect(buildR).to.be.undefined
+    j_expect(context.done).not.toBeCalled()
+    j_expect(context.succeed).not.toBeCalled()
+    j_expect(context.fail).toHaveBeenCalledTimes(1)
+  })
+
+  test("Failure exception to transaction context as RAW", async () => {
+    const b = { name: "abc" }
+    const r = new Response<any>(400, b, {
+      rawBody: true,
+      throwOnErrors: true,
+    })
+    const t = observableTransaction()
+    const context = t["context"]
+    let buildR: any = null,
+      exception = null
+    try {
+      buildR = await r.build(context, t, false)
+    } catch (e) {
+      exception = e
+    }
+    expect(buildR).to.be.null
+    expect(exception).to.not.be.null
+    j_expect(context.done).not.toBeCalled()
+    j_expect(context.succeed).not.toBeCalled()
+    j_expect(context.fail).not.toBeCalled()
+  })
+
+  test("Failure exception to transaction context as RAW and null body", async () => {
+    const b = null
+    const r = new Response<any>(400, b, {
+      rawBody: true,
+      throwOnErrors: true,
+    })
+    const t = observableTransaction()
+    const context = t["context"]
+    let buildR: any = null,
+      exception = null
+    try {
+      buildR = await r.build(context, t, false)
+    } catch (e) {
+      exception = e
+    }
+    expect(buildR).to.be.null
+    expect(exception).to.not.be.null
+    j_expect(context.done).not.toBeCalled()
+    j_expect(context.succeed).not.toBeCalled()
+    j_expect(context.fail).not.toBeCalled()
+  })
+
+  test("Failure exception to transaction context as RAW and custom ero", async () => {
+    const b = { message: "abc", error: "error 123" }
+    const r = new Response<any>(400, b, {
+      rawBody: true,
+      throwOnErrors: true,
+    })
+    const t = observableTransaction()
+    const context = t["context"]
+    let buildR: any = null,
+      exception = null
+    try {
+      buildR = await r.build(context, t, false)
+    } catch (e) {
+      exception = e
+    }
+    expect(buildR).to.be.null
+    expect(exception).to.not.be.null
+    j_expect(context.done).not.toBeCalled()
+    j_expect(context.succeed).not.toBeCalled()
+    j_expect(context.fail).not.toBeCalled()
+  })
+})
+
+describe("Response shortcuts", () => {
+  test("MissingParamResponse", async () => {
+    const pName = "abc"
+    const r = Response.MissingParamResponse(pName)
+    await testResponse(r, {
+      err: `Invalid request. Path parameter ${pName} is missing.`,
+      errCode: Globals.ErrorCode_MissingParam,
+    })
+  })
+
+  test("MissingQueryResponse", async () => {
+    const pName = "abc"
+    const r = Response.MissingQueryResponse(pName)
+    await testResponse(r, {
+      err: `Invalid request. Query parameter ${pName} is missing.`,
+      errCode: Globals.ErrorCode_MissingParam,
+    })
+  })
+
+  test("BadRequestResponse", async () => {
+    const message = "abc"
+    const code = "CODE"
+    const optBody = { additional: 123 }
+    const r = Response.BadRequestResponse(message, code, optBody)
+    await testResponse(r, {
+      err: message,
+      errCode: code,
+      ...optBody,
+    })
+  })
+
+  test("BadRequestResponse no opts", async () => {
+    const message = "abc"
+    const r = Response.BadRequestResponse(message)
+    await testResponse(r, {
+      err: message,
+    })
+  })
+
+  test("BadRequestResponseWithRollback", async () => {
+    const message = "abc"
+    const code = "CODE"
+    const optBody = { additional: 123 }
+    const r = Response.BadRequestResponseWithRollback(message, code, optBody)
+    await testResponse(r, {
+      err: message,
+      rollback: true,
+      errCode: code,
+      ...optBody,
+    })
+  })
+
+  test("BadRequestResponseWithRollback no opts", async () => {
+    const message = "abc"
+    const r = Response.BadRequestResponseWithRollback(message)
+    await testResponse(r, {
+      err: message,
+      rollback: true,
+    })
+  })
+
+  test("UnauthorizedResponse", async () => {
+    const message = "abc"
+    const code = "CODE"
+    const r = Response.UnauthorizedResponse(message, code)
+    await testResponse(
+      r,
+      {
+        err: message,
+        errCode: code,
+      },
+      401,
+    )
+  })
+
+  test("UnauthorizedResponse no code", async () => {
+    const message = "abc"
+    const r = Response.UnauthorizedResponse(message)
+    await testResponse(r, { err: message }, 401)
+  })
+
+  test("SuccessResponse", async () => {
+    const body = { additional: 123 }
+    const r = Response.SuccessResponse(body)
+    await testResponse(r, body, 200)
+  })
+
+  test("SuccessResponse null body", async () => {
+    const r = Response.SuccessResponse(null)
+    await testResponse(r, {}, 200)
+  })
+
+  test("SuccessNoContentResponse", async () => {
+    const r = Response.SuccessNoContentResponse()
+    await testResponse(r, null, 204)
+  })
+
+  test("SimpleResponse", async () => {
+    const r = Response.SimpleResponse(null)
+    await testResponse(r, null, 200)
+  })
+
+  test("SimpleResponse override statuscode", async () => {
+    const r = Response.SimpleResponse(null, 203)
+    await testResponse(r, null, 203)
+  })
+
+  test("RedirectResponse", async () => {
+    const url = "https://google.com"
+    const r = Response.RedirectResponse(url)
+    await testResponse(r, null, 302, { Location: url })
+  })
+
+  test("SuccessStreamResponse", async () => {
+    const b = { name: "abc" }
+    const r = Response.SuccessStreamResponse(b, "test-stream")
+    const t = observableTransaction()
+    const context = t["context"]
+    const buildR = await r.build(context, t, false)
+    await r.build(context, t, false) //pipe twice, should not affect
+    expect(buildR).to.be.undefined
+    j_expect(context.fail).not.toBeCalled()
+    j_expect(context.done).not.toBeCalled()
+    j_expect(context.succeed).toHaveBeenCalledTimes(1)
+    j_expect(context.succeed).toHaveBeenCalledWith({
+      statusCode: 200,
+      headers: {
+        ...defaultHeaders,
+        "Content-Type": "test-stream",
+        Connection: "keep-alive",
+      },
+      body: {
+        ...b,
+      },
+    })
+  })
+})
+
+export {}

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