@ikonintegration/ikapi 4.0.1 → 5.0.0

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 { HttpMethod } from '../../../../src/API/Request.js'
+import GenericHandlerEvent from '../../../../src/Server/lib/container/GenericHandlerEvent.js'
+
+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.undefined
+    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: HttpMethod.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.undefined
+    expect(resp.data).to.be.equals('Success')
+  })
+})
+
+export {}

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

@@ -0,0 +1,30 @@
+import { jest } from '@jest/globals'
+import { expect as c_expect } from 'chai'
+import { Request, Response } from 'express'
+
+import HealthHandler from '../../../../src/Server/lib/container/HealthHandler.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('HealthHandler invocation path', () => {
+  test('Simple', async () => {
+    const resp = observableResponse()
+    const handlerResp = await HealthHandler(<Request>(<unknown>{}), resp)
+    //
+    c_expect(handlerResp).to.be.undefined
+    expect(resp.send).toBeCalledWith('Healthy!')
+    expect(resp.json).not.toBeCalled()
+    expect(resp.status).not.toBeCalled()
+    expect(resp.header).not.toBeCalled()
+  })
+})
+
+export {}

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

@@ -0,0 +1,268 @@
+import { jest } from '@jest/globals'
+import { APIGatewayProxyEvent, Context } from 'aws-lambda'
+import { expect as c_expect } from 'chai'
+import request from 'supertest'
+
+import Globals from '../../../../src/Globals.js'
+import Proxy from '../../../../src/Server/lib/container/Proxy.js'
+import { defaultUrl } from '../../../Test.utils.js'
+
+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')
+    expect(mockExit).toBeCalledWith(1)
+  })
+
+  test('Simple port config', async () => {
+    const proxy = new Proxy({ routes: [], port: 56562 }, async () => {})
+    await proxy.load()
+    await proxy.unload()
+    expect(mockExit).toBeCalledWith(0)
+  })
+
+  test('Simple timeout config', async () => {
+    const proxy = new Proxy({ routes: [], timeout: 1000 }, async () => {})
+    await proxy.load()
+    await proxy.unload()
+    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()
+    expect(mockExit).toBeCalledWith(0)
+  })
+
+  test('Empty cors config', async () => {
+    const proxy = new Proxy(
+      {
+        routes: [],
+        cors: {},
+      },
+      async () => {}
+    )
+    await proxy.load()
+    await proxy.unload()
+    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')])
+    expect(mockExit).toHaveBeenCalledTimes(1)
+    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)
+    c_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)
+    c_expect(resG.body).to.be.deep.equals({ name: '123' })
+    // Expected count
+    c_expect(count).to.be.equals(1)
+    // Unload
+    await proxy.unload('Error')
+    expect(mockExit).toHaveBeenCalledTimes(1)
+    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)
+    c_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)
+    c_expect(resG.body).to.be.deep.equals({ name: '123' })
+    // Expected count
+    c_expect(count).to.be.equals(1)
+    // Unload
+    await proxy.unload()
+    expect(mockExit).toHaveBeenCalledTimes(1)
+    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)
+    c_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
+    }
+    c_expect(err?.message).to.be.equals('socket hang up')
+    // Expected count
+    c_expect(count).to.be.equals(1)
+    // Unload
+    await proxy.unload('Error')
+    expect(mockExit).toHaveBeenCalledTimes(1)
+    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)
+    c_expect(resWH.header['access-control-allow-origin']).to.equal('*')
+    c_expect(resWH.header['access-control-allow-credentials']).to.equal('true')
+    c_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)
+    c_expect(resNWH.header['access-control-allow-origin']).to.equal('*')
+    c_expect(resNWH.header['access-control-allow-credentials']).to.equal('true')
+    c_expect(resNWH.header['access-control-allow-headers']).to.equal('Authorization')
+    // Expected count
+    c_expect(count).to.be.equals(0)
+    // Unload
+    await proxy.unload()
+    expect(mockExit).toHaveBeenCalledTimes(1)
+    expect(mockExit).toBeCalledWith(0)
+  })
+})
+
+export {}

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

@@ -0,0 +1,47 @@
+import { expect } from 'chai'
+
+import * as Utils from '../../../../src/Server/lib/container/Utils.js'
+
+describe('parseQueryStringParameters', () => {
+  test('Null url', () => {
+    // @ts-ignore
+    const validationResult = Utils.parseQueryStringParameters(null)
+    expect(validationResult).to.be.deep.equals({})
+  })
+
+  test('Empty url', () => {
+    const validationResult = Utils.parseQueryStringParameters('')
+    expect(validationResult).to.be.deep.equals({})
+  })
+
+  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,78 @@
+import { jest } from '@jest/globals'
+import { APIGatewayEvent, Context, DynamoDBStreamEvent, SQSEvent } from 'aws-lambda'
+import { z } from 'zod'
+
+import Transaction from '../src/BaseEvent/Transaction.js'
+import Globals from '../src/Globals.js'
+
+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 const SampleConfig = {
+  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,
+  },
+} as const
+
+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 emptyDynamoDBEvent(data?: any) {
+  return <DynamoDBStreamEvent>(<unknown>data || {})
+}
+
+export function observableTransaction() {
+  const t = new Transaction(emptyEvent(), observableContext())
+  t.responseProxy = jest.fn() as any
+  return t
+}