@creator.co/wapi 1.7.1-alpha4 → 1.7.1

package/tests/Server/RouteResolver.test.ts

@@ -0,0 +1,102 @@
+import { HttpMethod } from '../../src/API/Request'
+import { Route } from '../../src/Server/Router'
+import RouteResolver from '../../src/Server/RouteResolver'
+
+const mockRoute = (method: HttpMethod, path: string) =>
+  ({
+    method: method,
+    path: path,
+  }) as any as Route
+
+describe('RouteResolver', () => {
+  test('no routes configured', () => {
+    parameterizedTest({}, () => [
+      [HttpMethod.GET, '/', undefined],
+      [HttpMethod.GET, '', undefined],
+      [HttpMethod.GET, 'hjdah', undefined],
+    ])
+  })
+
+  test('one route', () => {
+    parameterizedTest(
+      {
+        route: mockRoute(HttpMethod.GET, '/'),
+      },
+      routes => [
+        [HttpMethod.GET, '/', routes.route],
+        [HttpMethod.GET, '', routes.route],
+        [HttpMethod.GET, 'hjdah', undefined],
+        [HttpMethod.POST, '/', undefined],
+        [HttpMethod.DELETE, '/', undefined],
+      ]
+    )
+  })
+
+  test('basic matching', () => {
+    parameterizedTest(
+      {
+        getBase: mockRoute(HttpMethod.GET, '/'),
+        getA: mockRoute(HttpMethod.GET, '/a'),
+        getB: mockRoute(HttpMethod.GET, '/b'),
+        postBase: mockRoute(HttpMethod.POST, '/'),
+        postA: mockRoute(HttpMethod.POST, '/a'),
+        variable: mockRoute(HttpMethod.GET, '/:a'),
+        getAb: mockRoute(HttpMethod.GET, '/a/b'),
+      },
+      routes => [
+        [HttpMethod.GET, '/', routes.getBase],
+        [HttpMethod.GET, '/a', routes.getA],
+        [HttpMethod.GET, '/b', routes.getB],
+        [HttpMethod.POST, '/', routes.postBase],
+        [HttpMethod.POST, '/a', routes.postA],
+        [HttpMethod.GET, '/c', routes.variable],
+        [HttpMethod.GET, '/a/b', routes.getAb],
+      ]
+    )
+  })
+
+  test('path variables', () => {
+    parameterizedTest(
+      {
+        path_vars: mockRoute(HttpMethod.GET, '/base/:a/:b/:c'),
+        abc: mockRoute(HttpMethod.GET, '/base/a/b/c'),
+        abcd: mockRoute(HttpMethod.GET, '/base/a/b/c/d'),
+        abc_path: mockRoute(HttpMethod.GET, '/base/a/b/c/:d'),
+      },
+      routes => [
+        [HttpMethod.GET, '/base/1/2/3', routes.path_vars],
+        [HttpMethod.GET, '/base/a/b/c', routes.abc],
+        [HttpMethod.GET, '/base/a/b/c/d', routes.abcd],
+        [HttpMethod.GET, '/base/a/b/c/u', routes.abc_path],
+        [HttpMethod.GET, '/base/a/b', undefined],
+        [HttpMethod.GET, '/base/a/b/c/d/e', undefined],
+        [HttpMethod.GET, '/base/a/b/c/d/e/f', undefined],
+      ]
+    )
+  })
+
+  test('fails to construct with duplicate routes', () => {
+    expect(
+      () =>
+        new RouteResolver({
+          routes: [
+            mockRoute(HttpMethod.GET, '/a/b/c/:d/:e/b'),
+            mockRoute(HttpMethod.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) => [HttpMethod, 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,39 @@
+import { jest } from '@jest/globals'
+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,531 @@
+import { jest } from '@jest/globals'
+import { expect as c_expect } from 'chai'
+import request from 'supertest'
+import { z } from 'zod'
+
+import { HttpMethod } from '../../../src/API/Request'
+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(),
+})
+
+export const QuerySchema = z.object({
+  id: z.string(),
+  order: z.string().refine(
+    v => {
+      const n = Number(v)
+      return !isNaN(n) && v?.length > 0
+    },
+    { message: 'Invalid number' }
+  ),
+})
+
+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)
+    c_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')
+    expect(mockExit).toHaveBeenCalledTimes(1)
+    expect(mockExit).toBeCalledWith(1)
+  })
+
+  test('Simple route', async () => {
+    const server = new ContainerServer({
+      routes: [
+        {
+          path: '/abc',
+          method: HttpMethod.GET,
+          handler: async () => {
+            return Response.SimpleResponse({ name: 'abc' })
+          },
+        } as any,
+      ],
+    })
+    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)
+    c_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)
+    c_expect(resG.body['name']).to.be.deep.equals('abc')
+    c_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')
+    expect(mockExit).toHaveBeenCalledTimes(1)
+    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)
+        c_expect(res.text).to.be.equals('Healthy!')
+        // Unload
+        await server.stop()
+        expect(mockExit).toHaveBeenCalledTimes(1)
+        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 () => {
+        expect(mockExit).toHaveBeenCalledTimes(1)
+        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 () => {
+        expect(mockExit).toHaveBeenCalledTimes(1)
+        expect(mockExit).toBeCalledWith(0)
+        resolve(null)
+      }, 2000)
+    })
+  }, 10000)
+})
+
+describe('Container server validation (body)', () => {
+  // @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) {
+    c_expect(res.body['err']).to.be.equals(Globals.ErrorResponseValidationFail)
+    c_expect(res.body['errCode']).to.be.equals(Globals.ErrorCode_InvalidInput)
+    c_expect(res.body['transactionID']).to.not.be.null
+    c_expect(res.body['transactionID']).to.be.an('string')
+    c_expect(res.body['validationFailure']?.length).to.be.equals(failureCount || 4)
+  }
+
+  test('Validates empty body', async () => {
+    const server = new ContainerServer({
+      routes: [
+        {
+          path: '/abc',
+          method: HttpMethod.POST,
+          inputSchema: ViewSchema,
+          handler: async () => {
+            return Response.SimpleResponse({ name: 'abc' })
+          },
+        } as any,
+      ],
+    })
+    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: HttpMethod.POST,
+          inputSchema: ViewSchema,
+          handler: async () => {
+            return Response.SimpleResponse({ name: 'abc' })
+          },
+        } as any,
+      ],
+    })
+    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: HttpMethod.POST,
+          inputSchema: ViewSchema,
+          handler: async () => {
+            return Response.SimpleResponse({ name: 'abc' })
+          },
+        } as any,
+      ],
+    })
+    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: HttpMethod.POST,
+          inputSchema: ViewSchema,
+          handler: async () => {
+            return Response.SimpleResponse({ name: 'abc' })
+          },
+        } as any,
+      ],
+    })
+    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: HttpMethod.POST,
+          inputSchema: ViewSchema,
+          handler: async () => {
+            return Response.SimpleResponse({ name: 'abc' })
+          },
+        } as any,
+      ],
+    })
+    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: HttpMethod.POST,
+          inputSchema: ViewSchema,
+          handler: async () => {
+            return Response.SimpleResponse({ name: 'abc' })
+          },
+        } as any,
+      ],
+    })
+    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()
+  })
+})
+
+describe('Container server validation (query)', () => {
+  let server: ContainerServer
+  // @ts-ignore
+  let mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {})
+  beforeAll(() => {
+    // @ts-ignore
+    mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {})
+  })
+  afterAll(() => {
+    mockExit.mockRestore()
+  })
+  beforeEach(async () => {
+    mockExit.mockReset()
+    server = new ContainerServer({
+      routes: [
+        {
+          path: '/abc',
+          method: HttpMethod.POST,
+          querySchema: QuerySchema,
+          handler: async () => {
+            return Response.SimpleResponse({ name: 'abc' })
+          },
+        } as any,
+      ],
+    })
+    await server.start()
+  })
+
+  afterEach(async () => {
+    await server.stop()
+  })
+
+  function validateValidationFailure(res: any, failureCount?: number) {
+    c_expect(res.body['err']).to.be.equals(Globals.ErrorResponseValidationFail)
+    c_expect(res.body['errCode']).to.be.equals(Globals.ErrorCode_InvalidInput)
+    c_expect(res.body['transactionID']).to.not.be.null
+    c_expect(res.body['transactionID']).to.be.an('string')
+    c_expect(res.body['validationFailure']?.length).to.be.equals(failureCount || 2)
+  }
+
+  test('Validates empty query', async () => {
+    // Validation fails, empty body
+    const resG = await request(defaultUrl)
+      .post(`/abc`)
+      .expect('Content-Type', 'application/json; charset=utf-8')
+      .expect(400)
+    validateValidationFailure(resG, 2)
+  })
+
+  test('Validates empty query differently', async () => {
+    // Validation fails, empty body
+    const resG = await request(defaultUrl)
+      .post(`/abc?`)
+      .expect('Content-Type', 'application/json; charset=utf-8')
+      .expect(400)
+    validateValidationFailure(resG, 2)
+  })
+
+  test('Validates missing props body', async () => {
+    // Validation fails, empty body
+    const resG = await request(defaultUrl)
+      .post(`/abc?id=myname`)
+      .expect('Content-Type', 'application/json; charset=utf-8')
+      .expect(400)
+    validateValidationFailure(resG, 1)
+  })
+
+  test('Validates wrong type props body', async () => {
+    // Validation fails, empty body
+    const resG = await request(defaultUrl)
+      .post(`/abc?id=name&order=myname`)
+      .expect('Content-Type', 'application/json; charset=utf-8')
+      .expect(400)
+    validateValidationFailure(resG, 1)
+  })
+
+  test('Validates successfully2', async () => {
+    // Validation fails, empty body
+    await request(defaultUrl)
+      .post(`/abc`)
+      .query({ id: 'name', order: 123 })
+      .expect('Content-Type', 'application/json; charset=utf-8')
+      .expect(200)
+  })
+})
+
+describe('Container server validation (path)', () => {
+  let server: ContainerServer
+  // @ts-ignore
+  let mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {})
+  beforeAll(() => {
+    // @ts-ignore
+    mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {})
+  })
+  afterAll(() => {
+    mockExit.mockRestore()
+  })
+  beforeEach(async () => {
+    mockExit.mockReset()
+    server = new ContainerServer({
+      routes: [
+        {
+          path: '/abc/:id/:order',
+          method: HttpMethod.POST,
+          pathSchema: QuerySchema,
+          handler: async () => {
+            return Response.SimpleResponse({ name: 'abc' })
+          },
+        } as any,
+      ],
+    })
+    await server.start()
+  })
+
+  afterEach(async () => {
+    await server.stop()
+  })
+
+  function validateValidationFailure(res: any, failureCount?: number) {
+    c_expect(res.body['err']).to.be.equals(Globals.ErrorResponseValidationFail)
+    c_expect(res.body['errCode']).to.be.equals(Globals.ErrorCode_InvalidInput)
+    c_expect(res.body['transactionID']).to.not.be.null
+    c_expect(res.body['transactionID']).to.be.an('string')
+    c_expect(res.body['validationFailure']?.length).to.be.equals(failureCount || 2)
+  }
+
+  test('Validates wrong type props body', async () => {
+    // Validation fails, empty body
+    const resG = await request(defaultUrl)
+      .post(`/abc/name/myname`)
+      .expect('Content-Type', 'application/json; charset=utf-8')
+      .expect(400)
+    validateValidationFailure(resG, 1)
+  })
+
+  test('Validates successfully4', async () => {
+    // Validation fails, empty body
+    await request(defaultUrl)
+      .post(`/abc/name/123`)
+      .expect('Content-Type', 'application/json; charset=utf-8')
+      .expect(200)
+  })
+})
+
+describe('Container server raw body', () => {
+  // @ts-ignore
+  let mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {})
+  beforeAll(() => {
+    // @ts-ignore
+    mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {})
+    process.env['HYBRIDLESS_RUNTIME'] = 'true'
+  })
+  afterAll(() => {
+    mockExit.mockRestore()
+    process.env['HYBRIDLESS_RUNTIME'] = undefined
+  })
+  beforeEach(() => {
+    mockExit.mockReset()
+  })
+
+  test('Raw body is available', async () => {
+    let raw = null
+    const server = new ContainerServer({
+      routes: [
+        {
+          path: '/abc',
+          method: HttpMethod.POST,
+          handler: async t => {
+            raw = t.request.getBody(true)
+            return Response.SimpleResponse(null)
+          },
+        } as any,
+      ],
+    })
+    await server.start()
+
+    // it's formatted funky, because we're testing for exact match
+    const data = '  {   "name"  :   "abc"   }'
+    await request(defaultUrl)
+      .post(`/abc`)
+      .send(data)
+      .set('Content-Type', 'application/json')
+      .expect(200)
+
+    const s = new TextDecoder('utf-8').decode(raw!)
+    c_expect(s).to.be.equals(data)
+
+    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 {}