@creator.co/wapi 1.2.1-beta6 → 1.2.2

package/tests/Server/lib/container/GenericHandler.test.ts

@@ -0,0 +1,141 @@
+import { expect as j_expect } from "@jest/globals"
+import { APIGatewayProxyEvent, Context } from "aws-lambda"
+import { expect } from "chai"
+import { Request, Response } from "express"
+
+import Globals from "../../../../src/Globals"
+import GenericHandler from "../../../../src/Server/lib/container/GenericHandler"
+
+function observableResponse(): Response {
+  const resp = <Response>(<unknown>{
+    send: jest.fn(() => resp),
+    json: jest.fn(() => resp),
+    status: jest.fn(() => resp),
+    header: jest.fn(() => resp),
+  })
+  return resp
+}
+
+describe("GenericHandler success invocation path", () => {
+  test("Simple success", async () => {
+    const v = {
+      statusCode: 200,
+      body: JSON.stringify({ id: 123 }),
+    }
+    const handler = GenericHandler(
+      async (event: APIGatewayProxyEvent, context: Context) => {
+        context.succeed(v)
+      },
+    )
+    const resp = observableResponse()
+    const handlerResp = await handler(<Request>(<unknown>{}), resp)
+    //
+    expect(handlerResp).to.be.undefined
+    j_expect(resp.send).not.toBeCalled()
+    j_expect(resp.json).toBeCalledWith(JSON.parse(v.body))
+    j_expect(resp.status).toBeCalledWith(v.statusCode)
+    j_expect(resp.header).not.toBeCalled()
+  })
+
+  test("Simple success w/ headers", async () => {
+    const v = {
+      statusCode: 200,
+      body: JSON.stringify({ id: 123 }),
+      headers: { Authorization: 123 },
+    }
+    const handler = GenericHandler(
+      async (event: APIGatewayProxyEvent, context: Context) => {
+        context.succeed(v)
+      },
+    )
+    const resp = observableResponse()
+    const handlerResp = await handler(<Request>(<unknown>{}), resp)
+    //
+    expect(handlerResp).to.be.undefined
+    j_expect(resp.send).not.toBeCalled()
+    j_expect(resp.json).toBeCalledWith(JSON.parse(v.body))
+    j_expect(resp.status).toBeCalledWith(v.statusCode)
+    j_expect(resp.header).toBeCalledTimes(Object.keys(v.headers).length)
+  })
+
+  test("Simple success w/ null body", async () => {
+    const v = {
+      statusCode: 200,
+      headers: { Authorization: 123 },
+    }
+    const handler = GenericHandler(
+      async (event: APIGatewayProxyEvent, context: Context) => {
+        context.succeed(v)
+      },
+    )
+    const resp = observableResponse()
+    const handlerResp = await handler(<Request>(<unknown>{}), resp)
+    //
+    expect(handlerResp).to.be.undefined
+    j_expect(resp.send).not.toBeCalled()
+    j_expect(resp.json).toBeCalledWith({})
+    j_expect(resp.status).toBeCalledWith(v.statusCode)
+    j_expect(resp.header).toBeCalledTimes(Object.keys(v.headers).length)
+  })
+})
+
+describe("GenericHandler failure invocation path", () => {
+  test("Invalid response", async () => {
+    const handler = GenericHandler(
+      async (event: APIGatewayProxyEvent, context: Context) => {
+        context.succeed(null)
+      },
+    )
+    const resp = observableResponse()
+    const handlerResp = await handler(<Request>(<unknown>{}), resp)
+    //
+    expect(handlerResp).to.be.undefined
+    j_expect(resp.send).not.toBeCalled()
+    j_expect(resp.header).not.toBeCalled()
+    j_expect(resp.json).toBeCalledWith({
+      err: Globals.Resp_MSG_INVALIDRESP,
+      errCode: Globals.Resp_CODE_INVALIDRESP,
+    })
+    j_expect(resp.status).toBeCalledWith(Globals.Resp_STATUSCODE_INVALIDRESP)
+  })
+
+  test("Error response", async () => {
+    const err = new Error("Failed!")
+    const handler = GenericHandler(
+      async (event: APIGatewayProxyEvent, context: Context) => {
+        context.fail(err)
+      },
+    )
+    const resp = observableResponse()
+    const handlerResp = await handler(<Request>(<unknown>{}), resp)
+    //
+    expect(handlerResp).to.be.undefined
+    j_expect(resp.send).not.toBeCalled()
+    j_expect(resp.header).not.toBeCalled()
+    j_expect(resp.json).toBeCalledWith({
+      err,
+    })
+    j_expect(resp.status).toBeCalledWith(400)
+  })
+
+  test("Exception response", async () => {
+    const err = new Error("Failed!")
+    const handler = GenericHandler(async () => {
+      throw err
+    })
+    const resp = observableResponse()
+    const handlerResp = await handler(<Request>(<unknown>{}), resp)
+    //
+    expect(handlerResp).to.be.undefined
+    j_expect(resp.send).not.toBeCalled()
+    j_expect(resp.header).not.toBeCalled()
+    j_expect(resp.json).toBeCalledWith({
+      ...err,
+      err: Globals.Resp_MSG_EXCEPTION,
+      errCode: Globals.Resp_CODE_EXCEPTION,
+    })
+    j_expect(resp.status).toBeCalledWith(Globals.Resp_STATUSCODE_EXCEPTION)
+  })
+})
+
+export {}

package/tests/Server/lib/container/GenericHandlerEvent.test.ts

@@ -0,0 +1,103 @@
+import { APIGatewayProxyEvent, Context } from "aws-lambda"
+import { expect } from "chai"
+import { Request } from "express"
+
+import GenericHandlerEvent from "../../../../src/Server/lib/container/GenericHandlerEvent"
+
+describe("GenericHandlerEvent invocation paths", () => {
+  test("Simple success", async () => {
+    const event = new GenericHandlerEvent(
+      <Request>(<unknown>{
+        socket: { remoteAddress: "127.0.0.1" },
+      }),
+      async (event: APIGatewayProxyEvent, context: Context) => {
+        expect(context.getRemainingTimeInMillis()).to.not.be.null
+        context.succeed("Success")
+      },
+    )
+    const resp = await event.invoke()
+    expect(resp).to.not.be.null
+    expect(resp.err).to.be.null
+    expect(resp.data).to.be.equals("Success")
+  })
+
+  test("Simple failure", async () => {
+    const event = new GenericHandlerEvent(
+      <Request>(<unknown>{}),
+      async (event: APIGatewayProxyEvent, context: Context) => {
+        context.fail("Error!")
+      },
+    )
+    const resp = await event.invoke()
+    expect(resp).to.not.be.null
+    expect(resp.data).to.be.undefined
+    expect(resp.err).to.be.equals("Error!")
+  })
+
+  test("Simple done (errored)", async () => {
+    const event = new GenericHandlerEvent(
+      <Request>(<unknown>{}),
+      async (event: APIGatewayProxyEvent, context: Context) => {
+        context.done(new Error("Error!"))
+      },
+    )
+    const resp = await event.invoke()
+    expect(resp).to.not.be.null
+    expect(resp.data).to.be.undefined
+    expect(resp.err).to.be.an("Error")
+    if (resp.err instanceof Error)
+      expect(resp.err?.message).to.be.equals("Error!")
+  })
+
+  test("Simple done (success)", async () => {
+    const event = new GenericHandlerEvent(
+      <Request>(<unknown>{}),
+      async (event: APIGatewayProxyEvent, context: Context) => {
+        context.done(undefined, "Success!")
+      },
+    )
+    const resp = await event.invoke()
+    expect(resp).to.not.be.null
+    expect(resp.err).to.be.undefined
+    expect(resp.data).to.be.equals("Success!")
+  })
+
+  test("Exception on execution", async () => {
+    const event = new GenericHandlerEvent(<Request>(<unknown>{}), async () => {
+      throw new Error("Failed!")
+    })
+    let err: any = null,
+      resp: any = null
+    try {
+      resp = await event.invoke()
+    } catch (e) {
+      err = e
+    }
+    expect(resp).to.be.null
+    expect(err).to.not.be.null
+    expect(err).to.be.an("Error")
+    expect(err.message).to.be.equals("Failed!")
+  })
+})
+
+describe("GenericHandlerEvent event test", () => {
+  test("Simple event test", async () => {
+    const event = new GenericHandlerEvent(
+      <Request>(<unknown>{
+        headers: { Authorization: "123", "x-forwarded-for": "127.0.0.1" },
+        method: "get",
+        query: "/status?name=ryan",
+      }),
+      async (event: APIGatewayProxyEvent, context: Context) => {
+        expect(context.getRemainingTimeInMillis()).to.not.be.null
+        context.succeed("Success")
+      },
+    )
+    const resp = await event.invoke()
+    expect(resp).to.not.be.null
+    expect(resp.err).to.be.null
+    expect(resp.data).to.be.equals("Success")
+  })
+})
+
+export {}

package/tests/Server/lib/container/HealthHandler.test.ts

@@ -0,0 +1,30 @@
+import { expect as j_expect } from "@jest/globals"
+import { expect } from "chai"
+import { Request, Response } from "express"
+
+import HealthHandler from "../../../../src/Server/lib/container/HealthHandler"
+
+function observableResponse(): Response {
+  const resp = <Response>(<unknown>{
+    send: jest.fn(() => resp),
+    json: jest.fn(() => resp),
+    status: jest.fn(() => resp),
+    header: jest.fn(() => resp),
+  })
+  return resp
+}
+
+describe("HealthHandler invocation path", () => {
+  test("Simple", async () => {
+    const resp = observableResponse()
+    const handlerResp = await HealthHandler(<Request>(<unknown>{}), resp)
+    //
+    expect(handlerResp).to.be.undefined
+    j_expect(resp.send).toBeCalledWith("Healthy!")
+    j_expect(resp.json).not.toBeCalled()
+    j_expect(resp.status).not.toBeCalled()
+    j_expect(resp.header).not.toBeCalled()
+  })
+})
+
+export {}

package/tests/Server/lib/container/Proxy.test.ts

@@ -0,0 +1,278 @@
+import { expect as j_expect } from "@jest/globals"
+import { APIGatewayProxyEvent, Context } from "aws-lambda"
+import { expect } from "chai"
+import * as request from "supertest"
+
+import Globals from "../../../../src/Globals"
+import Proxy from "../../../../src/Server/lib/container/Proxy"
+import { defaultUrl } from "../../../Test.utils"
+
+describe("Proxy configs", () => {
+  // @ts-ignore
+  let mockExit = jest.spyOn(process, "exit").mockImplementation(() => {})
+  beforeAll(() => {
+    // @ts-ignore
+    mockExit = jest.spyOn(process, "exit").mockImplementation(() => {})
+  })
+  afterAll(() => {
+    mockExit.mockRestore()
+  })
+  beforeEach(() => {
+    mockExit.mockReset()
+  })
+
+  test("Empty config url & unload with error", async () => {
+    const proxy = new Proxy({ routes: [] }, async () => {})
+    await proxy.load()
+    await proxy.unload("Error")
+    j_expect(mockExit).toBeCalledWith(1)
+  })
+
+  test("Simple port config", async () => {
+    const proxy = new Proxy({ routes: [], port: 56562 }, async () => {})
+    await proxy.load()
+    await proxy.unload()
+    j_expect(mockExit).toBeCalledWith(0)
+  })
+
+  test("Simple timeout config", async () => {
+    const proxy = new Proxy({ routes: [], timeout: 1000 }, async () => {})
+    await proxy.load()
+    await proxy.unload()
+    j_expect(mockExit).toBeCalledWith(0)
+  })
+
+  test("Simple cors config", async () => {
+    const proxy = new Proxy(
+      {
+        routes: [],
+        cors: {
+          origin: "*",
+          headers: ["Authorization"],
+          allowCredentials: true,
+        },
+      },
+      async () => {},
+    )
+    await proxy.load()
+    await proxy.unload()
+    j_expect(mockExit).toBeCalledWith(0)
+  })
+
+  test("Empty cors config", async () => {
+    const proxy = new Proxy(
+      {
+        routes: [],
+        cors: {},
+      },
+      async () => {},
+    )
+    await proxy.load()
+    await proxy.unload()
+    j_expect(mockExit).toBeCalledWith(0)
+  })
+})
+
+describe("Proxy behaviour", () => {
+  // @ts-ignore
+  let mockExit = jest.spyOn(process, "exit").mockImplementation(() => {})
+  beforeAll(() => {
+    // @ts-ignore
+    mockExit = jest.spyOn(process, "exit").mockImplementation(() => {})
+  })
+  afterAll(() => {
+    mockExit.mockRestore()
+  })
+  beforeEach(() => {
+    mockExit.mockReset()
+  })
+
+  test("Stop twice", async () => {
+    const proxy = new Proxy({ routes: [] }, async () => {})
+    await proxy.load()
+    await Promise.all([proxy.unload("Error"), proxy.unload("Error")])
+    j_expect(mockExit).toHaveBeenCalledTimes(1)
+    j_expect(mockExit).toBeCalledWith(1)
+  })
+})
+
+describe("Proxy routing", () => {
+  // @ts-ignore
+  let mockExit = jest.spyOn(process, "exit").mockImplementation(() => {})
+  beforeAll(() => {
+    // @ts-ignore
+    mockExit = jest.spyOn(process, "exit").mockImplementation(() => {})
+  })
+  afterAll(() => {
+    mockExit.mockRestore()
+  })
+  beforeEach(() => {
+    mockExit.mockReset()
+  })
+
+  test("Health & Default handler", async () => {
+    let count = 0
+    const proxy = new Proxy(
+      { routes: [] },
+      async (event: APIGatewayProxyEvent, context: Context) => {
+        count++
+        context.succeed({
+          body: JSON.stringify({ name: "123" }),
+          statusCode: 200,
+        })
+      },
+    )
+    await proxy.load()
+    // Health check
+    const res = await request(defaultUrl)
+      .get(Globals.Listener_HTTP_DefaultHealthCheckRoute)
+      .expect("Content-Type", "text/html; charset=utf-8")
+      .expect(200)
+    expect(res.text).to.be.equals("Healthy!")
+    // Generic handler
+    const resG = await request(defaultUrl)
+      .get(`/abc`)
+      .expect("Content-Type", "application/json; charset=utf-8")
+      .expect(200)
+    expect(resG.body).to.be.deep.equals({ name: "123" })
+    // Expected count
+    expect(count).to.be.equals(1)
+    // Unload
+    await proxy.unload("Error")
+    j_expect(mockExit).toHaveBeenCalledTimes(1)
+    j_expect(mockExit).toBeCalledWith(1)
+  })
+
+  test("Proxy on custom port", async () => {
+    let count = 0
+    const port = 56542
+    const url = defaultUrl.replace(
+      String(Globals.Listener_HTTP_DefaultPort),
+      String(port),
+    )
+    const proxy = new Proxy(
+      { routes: [], port },
+      async (event: APIGatewayProxyEvent, context: Context) => {
+        count++
+        context.succeed({
+          body: JSON.stringify({ name: "123" }),
+          statusCode: 200,
+        })
+      },
+    )
+    await proxy.load()
+    // Health check
+    const res = await request(url)
+      .get(Globals.Listener_HTTP_DefaultHealthCheckRoute)
+      .expect("Content-Type", "text/html; charset=utf-8")
+      .expect(200)
+    expect(res.text).to.be.equals("Healthy!")
+    // Generic handler
+    const resG = await request(url)
+      .get(`/abc`)
+      .expect("Content-Type", "application/json; charset=utf-8")
+      .expect(200)
+    expect(resG.body).to.be.deep.equals({ name: "123" })
+    // Expected count
+    expect(count).to.be.equals(1)
+    // Unload
+    await proxy.unload()
+    j_expect(mockExit).toHaveBeenCalledTimes(1)
+    j_expect(mockExit).toBeCalledWith(0)
+  })
+
+  test("Proxy does timeout", async () => {
+    let count = 0
+    const timeout = 1000
+    const proxy = new Proxy(
+      { routes: [], timeout },
+      async (event: APIGatewayProxyEvent, context: Context) => {
+        count++
+        setTimeout(() => {
+          context.succeed({
+            body: JSON.stringify({ name: "123" }),
+            statusCode: 200,
+          })
+        }, timeout * 2)
+      },
+    )
+    await proxy.load()
+    // Health check
+    const res = await request(defaultUrl)
+      .get(Globals.Listener_HTTP_DefaultHealthCheckRoute)
+      .expect("Content-Type", "text/html; charset=utf-8")
+      .expect(200)
+    expect(res.text).to.be.equals("Healthy!")
+    // Generic handler
+    let err: any = null
+    try {
+      await request(defaultUrl)
+        .get(`/abc`)
+        .expect("Content-Type", "application/json; charset=utf-8")
+        .expect(200)
+    } catch (e) {
+      err = e
+    }
+    expect(err?.message).to.be.equals("socket hang up")
+    // Expected count
+    expect(count).to.be.equals(1)
+    // Unload
+    await proxy.unload("Error")
+    j_expect(mockExit).toHaveBeenCalledTimes(1)
+    j_expect(mockExit).toBeCalledWith(1)
+    //
+    return new Promise((resolve) => {
+      setTimeout(resolve, timeout * 2)
+    })
+  })
+
+  test("Proxy respects cors", async () => {
+    let count = 0
+    const proxy = new Proxy(
+      {
+        routes: [],
+        cors: {
+          origin: "*",
+          headers: ["Authorization"],
+          allowCredentials: true,
+        },
+      },
+      async (event: APIGatewayProxyEvent, context: Context) => {
+        count++
+        context.succeed({
+          body: JSON.stringify({ name: "123" }),
+          statusCode: 200,
+        })
+      },
+    )
+    await proxy.load()
+    // White-listed header is allowed
+    const resWH = await request(defaultUrl)
+      .options(`/abc`)
+      .set("Authorization", 123)
+      .expect(204)
+    expect(resWH.header["access-control-allow-origin"]).to.equal("*")
+    expect(resWH.header["access-control-allow-credentials"]).to.equal("true")
+    expect(resWH.header["access-control-allow-headers"]).to.equal(
+      "Authorization",
+    )
+    // Non white-listed header is allowed
+    const resNWH = await request(defaultUrl)
+      .options(`/abc`)
+      .set("2Authorization2", 123)
+      .expect(204)
+    expect(resNWH.header["access-control-allow-origin"]).to.equal("*")
+    expect(resNWH.header["access-control-allow-credentials"]).to.equal("true")
+    expect(resNWH.header["access-control-allow-headers"]).to.equal(
+      "Authorization",
+    )
+    // Expected count
+    expect(count).to.be.equals(0)
+    // Unload
+    await proxy.unload()
+    j_expect(mockExit).toHaveBeenCalledTimes(1)
+    j_expect(mockExit).toBeCalledWith(0)
+  })
+})
+
+export {}

package/tests/Server/lib/container/Utils.test.ts

@@ -0,0 +1,48 @@
+import { expect } from "chai"
+
+import * as Utils from "../../../../src/Server/lib/container/Utils"
+
+describe("parseQueryStringParameters", () => {
+  test("Null url", () => {
+    // @ts-ignore
+    const validationResult = Utils.parseQueryStringParameters(null)
+    expect(validationResult).to.be.deep.equals(null)
+  })
+
+  test("Empty url", () => {
+    const validationResult = Utils.parseQueryStringParameters("")
+    expect(validationResult).to.be.deep.equals(null)
+  })
+
+  test("Simple param", () => {
+    const validationResult =
+      Utils.parseQueryStringParameters("/status?name=ryan")
+    expect(validationResult).to.be.deep.equals({
+      name: "ryan",
+    })
+  })
+})
+
+describe("parseMultiValueQueryStringParameters", () => {
+  test("Null url", () => {
+    // @ts-ignore
+    const validationResult = Utils.parseMultiValueQueryStringParameters()
+    expect(validationResult).to.be.deep.equals({})
+  })
+
+  test("Empty url", () => {
+    const validationResult = Utils.parseMultiValueQueryStringParameters("")
+    expect(validationResult).to.be.deep.equals({})
+  })
+
+  test("Simple multivalue param", () => {
+    const validationResult = Utils.parseMultiValueQueryStringParameters(
+      "/status?name=ryan&name=ryan2",
+    )
+    expect(validationResult).to.be.deep.equals({
+      name: ["ryan", "ryan2"],
+    })
+  })
+})
+
+export {}

package/tests/Test.utils.ts

@@ -0,0 +1,95 @@
+import { APIGatewayEvent, Context, SQSEvent } from "aws-lambda"
+import { z } from "zod"
+
+import Transaction from "../src/BaseEvent/Transaction"
+import Globals from "../src/Globals"
+
+export const defaultHeaders = {
+  "Access-Control-Allow-Credentials": true,
+  "Access-Control-Allow-Origin": "*",
+  "Content-Type": "application/json",
+}
+
+export const defaultUrl = `localhost:${Globals.Listener_HTTP_DefaultPort}`
+
+export type SampleConfigSchema = {
+  PATH: {
+    isLocal: true
+    required: true
+  }
+  PATH_FALSY: {
+    isLocal: true
+    required: true
+  }
+  PATH123: {
+    isLocal: true
+    required: false
+  }
+  TOKEN_SECRET: {
+    isRemote: true
+    required: true
+  }
+  TOKEN_SECRET_FALSY: {
+    isRemote: true
+    required: false
+  }
+}
+
+export const SampleConfig: SampleConfigSchema = {
+  PATH: {
+    isLocal: true,
+    required: true,
+  },
+  PATH_FALSY: {
+    isLocal: true,
+    required: true,
+  },
+  PATH123: {
+    isLocal: true,
+    required: false,
+  },
+  TOKEN_SECRET: {
+    isRemote: true,
+    required: true,
+  },
+  TOKEN_SECRET_FALSY: {
+    isRemote: true,
+    required: false,
+  },
+}
+export function observableContext(data?: any) {
+  return <Context>(<unknown>{
+    done: jest.fn(),
+    fail: jest.fn(),
+    succeed: jest.fn(),
+    ...(data || {}),
+  })
+}
+
+export const privateKey = "tMHOuszBQmF6XtwgrUpvqpk07rh3RATX"
+
+export const foreignToken =
+  "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c"
+
+export const ViewSchema = z.object({
+  id: z.string(),
+  content: z.string(),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+})
+
+export type View = z.infer<typeof ViewSchema>
+
+export function emptyEvent(data?: any) {
+  return <APIGatewayEvent>(<unknown>data || {})
+}
+
+export function emptyQueueEvent(data?: any) {
+  return <SQSEvent>(<unknown>data || {})
+}
+
+export function observableTransaction() {
+  const t = new Transaction(emptyEvent(), observableContext())
+  t.responseProxy = jest.fn()
+  return t
+}