@ikonintegration/ikapi 4.0.1 → 5.0.0

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.js'
+import Response from '../../../src/API/Response.js'
+import Globals from '../../../src/Globals.js'
+import ContainerServer from '../../../src/Server/lib/ContainerServer.js'
+import { defaultUrl } from '../../Test.utils.js'
+
+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.js'
+
+describe('Server basics', () => {
+  test('Works', async () => {
+    const server = new Server({ routes: [] })
+    expect(server.getExport()).to.not.be.undefined
+  })
+})
+
+export {}

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

@@ -0,0 +1,131 @@
+import { jest } from '@jest/globals'
+import { APIGatewayProxyEvent, Context } from 'aws-lambda'
+import { expect as c_expect } from 'chai'
+import { Request, Response } from 'express'
+
+import Globals from '../../../../src/Globals.js'
+import GenericHandler from '../../../../src/Server/lib/container/GenericHandler.js'
+
+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)
+    //
+    c_expect(handlerResp).to.be.undefined
+    expect(resp.send).not.toBeCalled()
+    expect(resp.json).toBeCalledWith(JSON.parse(v.body))
+    expect(resp.status).toBeCalledWith(v.statusCode)
+    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)
+    //
+    c_expect(handlerResp).to.be.undefined
+    expect(resp.send).not.toBeCalled()
+    expect(resp.json).toBeCalledWith(JSON.parse(v.body))
+    expect(resp.status).toBeCalledWith(v.statusCode)
+    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)
+    //
+    c_expect(handlerResp).to.be.undefined
+    expect(resp.send).not.toBeCalled()
+    expect(resp.json).toBeCalledWith({})
+    expect(resp.status).toBeCalledWith(v.statusCode)
+    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)
+    //
+    c_expect(handlerResp).to.be.undefined
+    expect(resp.send).not.toBeCalled()
+    expect(resp.header).not.toBeCalled()
+    expect(resp.json).toBeCalledWith({
+      err: Globals.Resp_MSG_INVALIDRESP,
+      errCode: Globals.Resp_CODE_INVALIDRESP,
+    })
+    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)
+    //
+    c_expect(handlerResp).to.be.undefined
+    expect(resp.send).not.toBeCalled()
+    expect(resp.header).not.toBeCalled()
+    expect(resp.json).toBeCalledWith({
+      err,
+    })
+    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)
+    //
+    c_expect(handlerResp).to.be.undefined
+    expect(resp.send).not.toBeCalled()
+    expect(resp.header).not.toBeCalled()
+    expect(resp.json).toBeCalledWith({
+      ...err,
+      err: Globals.Resp_MSG_EXCEPTION,
+      errCode: Globals.Resp_CODE_EXCEPTION,
+    })
+    expect(resp.status).toBeCalledWith(Globals.Resp_STATUSCODE_EXCEPTION)
+  })
+})
+
+export {}