@creator.co/wapi 1.2.1-beta6 → 1.2.2

package/tests/Mailer/Mailer.test.ts

@@ -0,0 +1,67 @@
+import { SESClient, SendRawEmailCommand } from "@aws-sdk/client-ses"
+import { mockClient } from "aws-sdk-client-mock"
+import { expect } from "chai"
+
+import Mailer from "../../src/Mailer/Mailer"
+
+const SESMock = mockClient(SESClient)
+
+describe("SendRaw", () => {
+  // reset mock
+  beforeEach(() => {
+    SESMock.reset()
+  })
+
+  const provider = new Mailer("dev+tests@creator.co", "ca-central-1")
+
+  test("Send raw with success", async () => {
+    const messageId = "id-123"
+    SESMock.on(SendRawEmailCommand).resolves({
+      MessageId: messageId,
+    })
+    const res = await provider.sendRawEmail(
+      "test@test.com",
+      "My message",
+      "My subject",
+    )
+    expect(res).is.not.null
+    console.log(res)
+  })
+
+  test("Send raw with success", async () => {
+    const messageId = "id-123"
+    const from = "test@test.com"
+    const to = "test@test2.com"
+    const msg = "My message"
+    const subject = "My subject"
+    const cc = "test@test3.com"
+    const replyTo = "test@test4.com"
+    SESMock.on(SendRawEmailCommand).resolves({
+      MessageId: messageId,
+    })
+    const res = await provider.sendRawEmail(to, msg, subject, cc, from, replyTo)
+    expect(res).is.not.null
+    console.log(res)
+  })
+
+  test("Send raw with failure", async () => {
+    SESMock.on(SendRawEmailCommand).rejects(new Error("failed!"))
+    let res: any = null,
+      err: any = null
+    try {
+      res = await provider.sendRawEmail(
+        "test@test.com",
+        "My message",
+        "My subject",
+      )
+    } catch (e) {
+      err = e
+    }
+    expect(res).is.null
+    expect(err?.message).to.be.equals("failed!")
+    expect(res).is.null
+    console.log(res)
+  })
+})
+
+export {}

package/tests/Publisher/Publisher.test.ts

@@ -0,0 +1,60 @@
+import { SNSClient, PublishCommand } from "@aws-sdk/client-sns"
+import { mockClient } from "aws-sdk-client-mock"
+import { expect } from "chai"
+
+import Publisher from "../../src/Publisher/Publisher"
+
+const SNSMock = mockClient(SNSClient)
+
+describe("Encryption", () => {
+  // reset mock
+  beforeEach(() => {
+    SNSMock.reset()
+  })
+
+  const provider = new Publisher({
+    region: "ca-central-1",
+  })
+
+  test("Publishes with success", async () => {
+    const msg = { text: "123" }
+    const topic = "123"
+    const messageId = "id-123"
+    SNSMock.on(PublishCommand, {
+      Message: JSON.stringify(msg),
+      TopicArn: topic,
+    }).resolves({
+      MessageId: messageId,
+    })
+    const res = await provider.publishOnTopic(msg, topic)
+    expect(res).is.not.null
+    expect(res.MessageId).to.be.equals(messageId)
+  })
+
+  test("Publishes with success (additional props)", async () => {
+    const msg = { text: "123" }
+    const topic = "123"
+    const messageId = "id-123"
+    SNSMock.on(PublishCommand, {
+      Message: JSON.stringify(msg),
+      TopicArn: topic,
+    }).resolves({
+      MessageId: messageId,
+    })
+    const res = await provider.publishOnTopic(msg, topic, {
+      FifoGroup: 123,
+    })
+    expect(res).is.not.null
+    expect(res.MessageId).to.be.equals(messageId)
+  })
+
+  test("Publish failure", async () => {
+    const msg = { text: "123" }
+    const topic = "123"
+    SNSMock.on(PublishCommand).rejects(new Error("failed!"))
+    const res = await provider.publishOnTopic(msg, topic)
+    expect(res).is.null
+  })
+})
+
+export {}

package/tests/Server/RouteResolver.test.ts

@@ -0,0 +1,106 @@
+import { Route } from "../../src/Server/Router"
+import RouteResolver from "../../src/Server/RouteResolver"
+
+const mockRoute = (method: Method, path: string) =>
+  ({
+    method: method,
+    path: path,
+  }) as any as Route
+
+type Method =
+  | Lowercase<"GET" | "POST" | "PUT" | "DELETE">
+  | Uppercase<"GET" | "POST" | "PUT" | "DELETE">
+
+describe("RouteResolver", () => {
+  test("no routes configured", () => {
+    parameterizedTest({}, () => [
+      ["GET", "/", undefined],
+      ["GET", "", undefined],
+      ["GET", "hjdah", undefined],
+    ])
+  })
+
+  test("one route, case insensitive", () => {
+    parameterizedTest(
+      {
+        route: mockRoute("get", "/"),
+      },
+      (routes) => [
+        ["GET", "/", routes.route],
+        ["get", "/", routes.route],
+        ["GET", "", routes.route],
+        ["GET", "hjdah", undefined],
+        ["POST", "/", undefined],
+        ["DELETE", "/", undefined],
+      ],
+    )
+  })
+
+  test("basic matching", () => {
+    parameterizedTest(
+      {
+        getBase: mockRoute("GET", "/"),
+        getA: mockRoute("GET", "/a"),
+        getB: mockRoute("GET", "/b"),
+        postBase: mockRoute("POST", "/"),
+        postA: mockRoute("POST", "/a"),
+        variable: mockRoute("GET", "/:a"),
+        getAb: mockRoute("GET", "/a/b"),
+      },
+      (routes) => [
+        ["GET", "/", routes.getBase],
+        ["GET", "/a", routes.getA],
+        ["GET", "/b", routes.getB],
+        ["POST", "/", routes.postBase],
+        ["POST", "/a", routes.postA],
+        ["GET", "/c", routes.variable],
+        ["GET", "/a/b", routes.getAb],
+      ],
+    )
+  })
+
+  test("path variables", () => {
+    parameterizedTest(
+      {
+        path_vars: mockRoute("get", "/base/:a/:b/:c"),
+        abc: mockRoute("get", "/base/a/b/c"),
+        abcd: mockRoute("get", "/base/a/b/c/d"),
+        abc_path: mockRoute("get", "/base/a/b/c/:d"),
+      },
+      (routes) => [
+        ["GET", "/base/1/2/3", routes.path_vars],
+        ["GET", "/base/a/b/c", routes.abc],
+        ["GET", "/base/a/b/c/d", routes.abcd],
+        ["GET", "/base/a/b/c/u", routes.abc_path],
+        ["GET", "/base/a/b", undefined],
+        ["GET", "/base/a/b/c/d/e", undefined],
+        ["GET", "/base/a/b/c/d/e/f", undefined],
+      ],
+    )
+  })
+
+  test("fails to construct with duplicate routes", () => {
+    expect(
+      () =>
+        new RouteResolver({
+          routes: [
+            mockRoute("GET", "/a/b/c/:d/:e/b"),
+            mockRoute("GET", "/a/b/c/:jshj/:e/b"),
+          ],
+        }),
+    ).toThrowError("Duplicate route: GET: /a/b/c/:jshj/:e/b")
+  })
+})
+
+const parameterizedTest = <T extends { [k: string]: Route }>(
+  routes: T,
+  tests: (routes: T) => [Method, string, Route?][],
+) => {
+  const underTest = new RouteResolver({
+    routes: Object.values(routes),
+  })
+
+  tests(routes).forEach(([method, path, expected]) =>
+    expect(underTest.resolveRoute(method, path)).toBe(expected),
+  )
+}

package/tests/Server/Router.test.ts

@@ -0,0 +1,38 @@
+import { expect } from "chai"
+
+import ContainerServer from "../../src/Server/lib/ContainerServer"
+import Server from "../../src/Server/lib/Server"
+import Router from "../../src/Server/Router"
+
+describe("Router basics", () => {
+  // @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("Serverless server", async () => {
+    process.env["HYBRIDLESS_RUNTIME"] = undefined
+    const router = new Router({ routes: [] })
+    expect(router.getExport()).to.not.be.undefined
+    expect(router["server"]).to.be.an.instanceof(Server)
+    expect(router["server"]).to.not.be.an.instanceof(ContainerServer)
+  })
+  test("Container server", async () => {
+    process.env["HYBRIDLESS_RUNTIME"] = "true"
+    const router = new Router({ routes: [] })
+    expect(router.getExport()).to.not.be.undefined
+    expect(router["server"]).to.be.an.instanceof(Server)
+    expect(router["server"]).to.be.an.instanceof(ContainerServer)
+    await router["server"]["stop"]()
+  })
+})
+
+export {}

package/tests/Server/lib/ContainerServer.test.ts

@@ -0,0 +1,329 @@
+import { expect as j_expect } from "@jest/globals"
+import { expect } from "chai"
+import * as request from "supertest"
+import { z } from "zod"
+
+import Response from "../../../src/API/Response"
+import Globals from "../../../src/Globals"
+import ContainerServer from "../../../src/Server/lib/ContainerServer"
+import { defaultUrl } from "../../Test.utils"
+
+export const ViewSchema = z.object({
+  id: z.string(),
+  content: z.string(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+})
+
+describe("Container server 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 & 404 handler", async () => {
+    const server = new ContainerServer({ routes: [] })
+    await server.start()
+    // 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!")
+    // Not handled
+    await request(defaultUrl)
+      .get(`/abc`)
+      .expect("Content-Type", "application/json; charset=utf-8")
+      .expect(404)
+
+    // Unload
+    await server.stop("Error")
+    j_expect(mockExit).toHaveBeenCalledTimes(1)
+    j_expect(mockExit).toBeCalledWith(1)
+  })
+
+  test("Simple route", async () => {
+    const server = new ContainerServer({
+      routes: [
+        {
+          path: "/abc",
+          method: "get",
+          handler: async () => {
+            return Response.SimpleResponse({ name: "abc" })
+          },
+        },
+      ],
+    })
+    await server.start()
+    // 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!")
+    // Found route
+    const resG = await request(defaultUrl)
+      .get(`/abc`)
+      .expect("Content-Type", "application/json; charset=utf-8")
+      .expect(200)
+    expect(resG.body["name"]).to.be.deep.equals("abc")
+    expect(resG.body["transactionID"]).to.not.be.null
+    // Found route, but not method
+    await request(defaultUrl)
+      .post(`/abc`)
+      .expect("Content-Type", "application/json; charset=utf-8")
+      .expect(404)
+    // Not found route
+    await request(defaultUrl)
+      .get(`/abc/123`)
+      .expect("Content-Type", "application/json; charset=utf-8")
+      .expect(404)
+    // Unload
+    await server.stop("Error")
+    j_expect(mockExit).toHaveBeenCalledTimes(1)
+    j_expect(mockExit).toBeCalledWith(1)
+  })
+})
+
+describe("Container server basics", () => {
+  // @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("Starts with exports", async () => {
+    const server = new ContainerServer({ routes: [] })
+    server.getExport()
+    return new Promise((resolve) => {
+      setTimeout(async () => {
+        // 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!")
+        // Unload
+        await server.stop()
+        j_expect(mockExit).toHaveBeenCalledTimes(1)
+        j_expect(mockExit).toBeCalledWith(0)
+        resolve(null)
+      }, 2000)
+    })
+  })
+
+  test("Stops if process sends message SIGINT", async () => {
+    const server = new ContainerServer({ routes: [] })
+    await server.start()
+    process.emit("SIGINT")
+    return new Promise((resolve) => {
+      setTimeout(async () => {
+        j_expect(mockExit).toHaveBeenCalledTimes(1)
+        j_expect(mockExit).toBeCalledWith(0)
+        resolve(null)
+      }, 2000)
+    })
+  }, 10000)
+
+  test("Stops if process sends message unhandledRejection", async () => {
+    const server = new ContainerServer({ routes: [] })
+    await server.start()
+    // @ts-ignore
+    process.emit("unhandledRejection")
+    return new Promise((resolve) => {
+      setTimeout(async () => {
+        j_expect(mockExit).toHaveBeenCalledTimes(1)
+        j_expect(mockExit).toBeCalledWith(0)
+        resolve(null)
+      }, 2000)
+    })
+  }, 10000)
+})
+
+describe("Container server validation", () => {
+  // @ts-ignore
+  let mockExit = jest.spyOn(process, "exit").mockImplementation(() => {})
+  beforeAll(() => {
+    // @ts-ignore
+    mockExit = jest.spyOn(process, "exit").mockImplementation(() => {})
+  })
+  afterAll(() => {
+    mockExit.mockRestore()
+  })
+  beforeEach(() => {
+    mockExit.mockReset()
+  })
+
+  function validateValidationFailure(res: any, failureCount?: number) {
+    expect(res.body["err"]).to.be.equals(Globals.ErrorResponseValidationFail)
+    expect(res.body["errCode"]).to.be.equals(Globals.ErrorCode_InvalidInput)
+    expect(res.body["transactionID"]).to.not.be.null
+    expect(res.body["transactionID"]).to.be.an("string")
+    expect(res.body["validationFailure"]?.length).to.be.equals(
+      failureCount || 4,
+    )
+  }
+
+  test("Validates empty body", async () => {
+    const server = new ContainerServer({
+      routes: [
+        {
+          path: "/abc",
+          method: "post",
+          inputSchema: ViewSchema,
+          handler: async () => {
+            return Response.SimpleResponse({ name: "abc" })
+          },
+        },
+      ],
+    })
+    await server.start()
+    // Validation fails, empty body
+    const resG = await request(defaultUrl)
+      .post(`/abc`)
+      .expect("Content-Type", "application/json; charset=utf-8")
+      .expect(400)
+    validateValidationFailure(resG)
+    await server.stop()
+  })
+
+  test("Validates empty string body", async () => {
+    const server = new ContainerServer({
+      routes: [
+        {
+          path: "/abc",
+          method: "post",
+          inputSchema: ViewSchema,
+          handler: async () => {
+            return Response.SimpleResponse({ name: "abc" })
+          },
+        },
+      ],
+    })
+    await server.start()
+    // Validation fails, empty body
+    const resG = await request(defaultUrl)
+      .post(`/abc`)
+      .send("")
+      .expect("Content-Type", "application/json; charset=utf-8")
+      .expect(400)
+    validateValidationFailure(resG)
+    await server.stop()
+  })
+
+  test("Validates empty object body", async () => {
+    const server = new ContainerServer({
+      routes: [
+        {
+          path: "/abc",
+          method: "post",
+          inputSchema: ViewSchema,
+          handler: async () => {
+            return Response.SimpleResponse({ name: "abc" })
+          },
+        },
+      ],
+    })
+    await server.start()
+    // Validation fails, empty body
+    const resG = await request(defaultUrl)
+      .post(`/abc`)
+      .send({})
+      .expect("Content-Type", "application/json; charset=utf-8")
+      .expect(400)
+    validateValidationFailure(resG)
+    await server.stop()
+  })
+
+  test("Validates missing props body", async () => {
+    const server = new ContainerServer({
+      routes: [
+        {
+          path: "/abc",
+          method: "post",
+          inputSchema: ViewSchema,
+          handler: async () => {
+            return Response.SimpleResponse({ name: "abc" })
+          },
+        },
+      ],
+    })
+    await server.start()
+    // Validation fails, empty body
+    const resG = await request(defaultUrl)
+      .post(`/abc`)
+      .send({ id: "123" })
+      .expect("Content-Type", "application/json; charset=utf-8")
+      .expect(400)
+    validateValidationFailure(resG, 3)
+    await server.stop()
+  })
+
+  test("Validates wrong type props body", async () => {
+    const server = new ContainerServer({
+      routes: [
+        {
+          path: "/abc",
+          method: "post",
+          inputSchema: ViewSchema,
+          handler: async () => {
+            return Response.SimpleResponse({ name: "abc" })
+          },
+        },
+      ],
+    })
+    await server.start()
+    // Validation fails, empty body
+    const resG = await request(defaultUrl)
+      .post(`/abc`)
+      .send({ id: 123 })
+      .expect("Content-Type", "application/json; charset=utf-8")
+      .expect(400)
+    validateValidationFailure(resG)
+    await server.stop()
+  })
+
+  test("Validates successfully", async () => {
+    const server = new ContainerServer({
+      routes: [
+        {
+          path: "/abc",
+          method: "post",
+          inputSchema: ViewSchema,
+          handler: async () => {
+            return Response.SimpleResponse({ name: "abc" })
+          },
+        },
+      ],
+    })
+    await server.start()
+    // Validation fails, empty body
+    await request(defaultUrl)
+      .post(`/abc`)
+      .send({
+        id: "123",
+        content: "123",
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      })
+      .expect("Content-Type", "application/json; charset=utf-8")
+      .expect(200)
+    await server.stop()
+  })
+})
+export {}

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

@@ -0,0 +1,12 @@
+import { expect } from "chai"
+
+import Server from "../../../src/Server/lib/Server"
+
+describe("Server basics", () => {
+  test("Works", async () => {
+    const server = new Server({ routes: [] })
+    expect(server.getExport()).to.not.be.undefined
+  })
+})
+
+export {}