@ikonintegration/ikapi 4.0.1 → 5.0.0

package/tests/API/Request.test.ts

@@ -0,0 +1,273 @@
+import { APIGatewayEvent, Context } from 'aws-lambda'
+import { expect } from 'chai'
+
+import Request, { HttpMethod } from '../../src/API/Request.js'
+import Logger from '../../src/Logger/Logger.js'
+
+function newReq(event: any, context?: any) {
+  const logger = new Logger(
+    {
+      logLevel: 'DEBUG',
+    },
+    '123-456'
+  )
+  return new Request<any, any, any>(
+    <APIGatewayEvent>(<unknown>event),
+    <Context>context ? context : {},
+    logger
+  )
+}
+
+describe('Request querystring', () => {
+  test('Null query string', () => {
+    const r = newReq({
+      queryStringParameters: null,
+    })
+    expect(r.containsQueryParam('123')).to.be.false
+    expect(r.getQueryParam('123')).to.be.null
+  })
+
+  test('Empty query string', () => {
+    const r = newReq({
+      queryStringParameters: {},
+    })
+    expect(r.containsQueryParam('123')).to.be.false
+    expect(r.getQueryParam('123')).to.be.null
+  })
+
+  test('Valid query string', () => {
+    const v = { '123': 'abc' }
+    const r = newReq({
+      queryStringParameters: v,
+    })
+    expect(r.containsQueryParam('123')).to.be.true
+    expect(r.getQueryParam('123')).to.be.equals('abc')
+    expect(r.getQueryParams()).to.be.deep.equal(v)
+  })
+
+  test('Valid query string number', () => {
+    const r = newReq({
+      queryStringParameters: { '123': 456 },
+    })
+    expect(r.containsQueryParam('123')).to.be.true
+    expect(r.getQueryParam('123')).to.be.equals(456)
+  })
+})
+
+describe('Request headers', () => {
+  test('Null headers', () => {
+    const r = newReq({ headers: null })
+    expect(r.getHeader('123')).to.be.null
+  })
+
+  test('Empty headers', () => {
+    const r = newReq({ headers: {} })
+    expect(r.getHeader('123')).to.be.null
+  })
+
+  test('Valid headers', () => {
+    const r = newReq({ headers: { '123': 'abc' } })
+    expect(r.getHeader('123')).to.be.equals('abc')
+  })
+
+  test('Auth headers', () => {
+    const r = newReq({ headers: { Authorization: 'abc' } })
+    expect(r.getAuthorizationHeader()).to.be.equals('abc')
+  })
+})
+
+describe('Request context', () => {
+  test('Null context', () => {
+    const r = newReq({ requestContext: null })
+    expect(r.getContextParam('123')).to.be.null
+  })
+
+  test('Empty context', () => {
+    const r = newReq({ requestContext: {} })
+    expect(r.getContextParam('123')).to.be.null
+  })
+
+  test('Valid context', () => {
+    const r = newReq({
+      requestContext: { '123': 'abc' },
+    })
+    expect(r.getContextParam('123')).to.be.equals('abc')
+  })
+})
+
+describe('Request path params', () => {
+  test('Null path params', () => {
+    const r = newReq({ pathParameters: null })
+    expect(r.containsPathParam('123')).to.be.false
+    expect(r.getPathParam('123')).to.be.null
+    expect(r.getPathParams()).to.be.null
+  })
+
+  test('Empty path params', () => {
+    const r = newReq({ pathParameters: {} })
+    expect(r.containsPathParam('123')).to.be.false
+    expect(r.getPathParam('123')).to.be.null
+    expect(r.getPathParams()).to.be.deep.equal({})
+  })
+
+  test('Valid path params', () => {
+    const v = { '123': 'abc' }
+    const r = newReq({
+      pathParameters: v,
+    })
+    expect(r.containsPathParam('123')).to.be.true
+    expect(r.getPathParam('123')).to.be.equals('abc')
+    expect(r.getPathParams()).to.be.deep.equal(v)
+  })
+
+  test('Valid path param number', () => {
+    const v = { '123': 456 }
+    const r = newReq({
+      pathParameters: v,
+    })
+    expect(r.containsPathParam('123')).to.be.true
+    expect(r.getPathParam('123')).to.be.equals(456)
+    expect(r.getPathParams()).to.be.deep.equal(v)
+  })
+
+  test('Fix path params', () => {
+    const v = { '123': 'abc' }
+    const r = newReq({ pathParameters: null })
+    r.setFixedPathParams(
+      Object.keys(v).map(k => ({ name: k })),
+      ['/'].concat(Object.values(v))
+    )
+    expect(r.containsPathParam('123')).to.be.true
+    expect(r.getPathParam('123')).to.be.equals('abc')
+    expect(r.getPathParams()).to.be.deep.equal(v)
+  })
+})
+
+describe('Request body', () => {
+  test('Null body', () => {
+    const r = newReq({ body: null })
+    expect(r.getBody()).to.be.null
+  })
+
+  test('Empty body', () => {
+    const r = newReq({ body: {} })
+    expect(r.getBody()).to.be.deep.equals({})
+  })
+
+  test('Empty string body', () => {
+    const r = newReq({ body: '{}' })
+    expect(r.getBody()).to.be.deep.equals({})
+  })
+
+  test('Broken json string body', () => {
+    const r = newReq({ body: '{name": "Joe"}' })
+    expect(r.getBody()).to.be.equals('{name": "Joe"}')
+  })
+
+  test('Valid string body', () => {
+    const r = newReq({ body: '{"name": "Joe"}' })
+    expect(r.getBody()).to.be.deep.equals({
+      name: 'Joe',
+    })
+  })
+
+  test('Valid json body', () => {
+    const r = newReq({ body: { name: 'Joe' } })
+    expect(r.getBody()).to.be.deep.equals({
+      name: 'Joe',
+    })
+  })
+})
+
+describe('Request path/method', () => {
+  test('Null path/method', () => {
+    const r = newReq({
+      path: null,
+      httpMethod: null,
+    })
+    expect(r.getPath()).to.be.null
+    expect(r.getMethod.bind(r)).to.throw('Invalid HTTP method: null')
+  })
+
+  test('Empty path/method', () => {
+    const r = newReq({
+      path: '',
+      httpMethod: '',
+    })
+    expect(r.getPath()).to.be.a('string')
+    expect(r.getPath()).to.be.equals('')
+    expect(r.getMethod.bind(r)).to.throw('Invalid HTTP method: ')
+  })
+
+  test('Valid method/path', () => {
+    const r = newReq({
+      path: '/root',
+      httpMethod: HttpMethod.GET,
+    })
+    expect(r.getPath()).to.be.a('string')
+    expect(r.getPath()).to.be.equals('/root')
+    expect(r.getMethod()).to.be.a('string')
+    expect(r.getMethod()).to.be.equals(HttpMethod.GET)
+  })
+
+  test('Case insensitive method', () => {
+    const r = newReq({
+      path: '/root',
+      httpMethod: 'poST',
+    })
+
+    expect(r.getMethod()).to.be.equals(HttpMethod.POST)
+  })
+})
+
+describe('Request ID', () => {
+  test('From context', () => {
+    const r = newReq({}, { awsRequestId: '123' })
+    expect(r.getRequestID()).to.not.be.null
+    expect(r.getRequestID()).to.be.equals('123')
+  })
+
+  test('From event', () => {
+    const r = newReq({
+      requestContext: { requestId: '123' },
+    })
+    expect(r.getRequestID()).to.not.be.null
+    expect(r.getRequestID()).to.be.equals('123')
+  })
+
+  test('unknown', () => {
+    const r = newReq({})
+    expect(r.getRequestID()).to.not.be.null
+    expect(r.getRequestID()).to.be.equals('unknown')
+  })
+})
+
+describe('Request origin IP', () => {
+  test('From context', () => {
+    const r = newReq({
+      requestContext: {
+        identity: { sourceIp: '127.0.0.1' },
+      },
+    })
+    expect(r.getOriginIP()).to.not.be.null
+    expect(r.getOriginIP()).to.be.equals('127.0.0.1')
+  })
+
+  test('From header', () => {
+    const r = newReq({
+      headers: {
+        'X-Forwarded-For': '127.0.0.1',
+      },
+    })
+    expect(r.getOriginIP()).to.not.be.null
+    expect(r.getOriginIP()).to.be.equals('127.0.0.1')
+  })
+
+  test('unknown', () => {
+    const r = newReq({})
+    expect(r.getOriginIP()).to.not.be.null
+    expect(r.getOriginIP()).to.be.equals('unknown')
+  })
+})
+
+export {}

package/tests/API/Response.test.ts

@@ -0,0 +1,367 @@
+import { jest } from '@jest/globals'
+import { APIGatewayEvent, Context } from 'aws-lambda'
+import { expect as c_expect } from 'chai'
+
+import Response from '../../src/API/Response.js'
+import Transaction from '../../src/BaseEvent/Transaction.js'
+import Globals from '../../src/Globals.js'
+import { observableTransaction, defaultHeaders } from '../Test.utils.js'
+
+async function testResponse(r: Response<any>, body: any, optCode?: number, optHeaders?: any) {
+  const t = observableTransaction()
+  const context = t['context']
+  const buildR = await r.build(context, t, false)
+  c_expect(buildR).to.be.undefined
+  expect(t.responseProxy).toBeCalledTimes(1)
+  expect(context.fail).not.toBeCalled()
+  expect(context.done).not.toBeCalled()
+  expect(context.succeed).toHaveBeenCalledWith({
+    statusCode: optCode || 400,
+    headers: {
+      ...defaultHeaders,
+      ...(optHeaders || {}),
+    },
+    ...(body
+      ? {
+          body: JSON.stringify({
+            ...body,
+            transactionID: 'unknown',
+          }),
+        }
+      : {}),
+  })
+}
+
+describe('Response basics', () => {
+  test('Null body', () => {
+    const r = new Response<null>(200, null)
+    c_expect(r.getCode()).to.be.equals(200)
+    c_expect(r.getBody()).to.be.null
+  })
+
+  test('String body', () => {
+    const r = new Response<string>(200, 'abc')
+    c_expect(r.getCode()).to.be.equals(200)
+    c_expect(r.getBody()).to.be.equals('abc')
+  })
+
+  test('Generic body', () => {
+    const r = new Response<any>(200, { name: 'abc' })
+    r.appendIntoBody('name2', '123')
+    c_expect(r.getCode()).to.be.equals(200)
+    c_expect(r.getBody().name).to.be.equals('abc')
+    c_expect(r.getBody().name2).to.be.equals('123')
+  })
+
+  test('Append/validate header', () => {
+    const r = new Response<any>(200, {})
+    r.appendHeader('name2', '123')
+    c_expect(r['headers']['name2']).to.be.equals('123')
+  })
+})
+
+describe('Response build', () => {
+  test('Succeeds to transaction context', async () => {
+    const b = { name: 'abc' }
+    const r = new Response<any>(200, b)
+    r.appendHeader('abc', '123')
+    // do not use default, so we dont use proxy response for once
+    const t = new Transaction(
+      <APIGatewayEvent>(<unknown>{}),
+      <Context>(<unknown>{
+        done: jest.fn(),
+        fail: jest.fn(),
+        succeed: jest.fn(),
+      })
+    )
+    const context = t['context']
+    const buildR = await r.build(context, t, false)
+    c_expect(buildR).to.be.undefined
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).toHaveBeenCalledWith({
+      statusCode: 200,
+      headers: {
+        ...defaultHeaders,
+        abc: '123',
+      },
+      body: JSON.stringify({
+        ...b,
+        transactionID: 'unknown',
+      }),
+    })
+  })
+
+  test('Succeeds with no context call', async () => {
+    const b = { name: 'abc' }
+    const r = new Response<any>(200, b)
+    const t = observableTransaction()
+    const context = t['context']
+    const buildR = await r.build(context, t, true)
+    c_expect(buildR).to.be.undefined
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
+  })
+
+  test('Succeeds to transaction context as RAW', async () => {
+    const b = { name: 'abc' }
+    const r = new Response<any>(200, b, {
+      rawBody: true,
+    })
+    const t = observableTransaction()
+    const context = t['context']
+    const buildR = await r.build(context, t, false)
+    c_expect(buildR).to.be.undefined
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).toHaveBeenCalledWith({
+      ...b,
+      transactionID: 'unknown',
+    })
+  })
+
+  test('Succeeds to transaction piping', async () => {
+    const b = { name: 'abc' }
+    const r = new Response<any>(200, b, {
+      shouldStream: true,
+    })
+    const t = observableTransaction()
+    const context = t['context']
+    const buildR = await r.build(context, t, false)
+    await r.build(context, t, false) //pipe twice, should not affect
+    c_expect(buildR).to.be.undefined
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).toHaveBeenCalledTimes(1)
+    expect(context.succeed).toHaveBeenCalledWith({
+      statusCode: 200,
+      headers: {
+        ...defaultHeaders,
+      },
+      body: {
+        ...b,
+      },
+    })
+  })
+
+  test('Failure to transaction context as RAW', async () => {
+    const b = { name: 'abc' }
+    const r = new Response<any>(400, b, {
+      rawBody: true,
+    })
+    const t = observableTransaction()
+    const context = t['context']
+    const buildR = await r.build(context, t, false)
+    c_expect(buildR).to.be.undefined
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
+    expect(context.fail).toHaveBeenCalledTimes(1)
+  })
+
+  test('Failure exception to transaction context as RAW', async () => {
+    const b = { name: 'abc' }
+    const r = new Response<any>(400, b, {
+      rawBody: true,
+      throwOnErrors: true,
+    })
+    const t = observableTransaction()
+    const context = t['context']
+    let buildR: any = null,
+      exception = null
+    try {
+      buildR = await r.build(context, t, false)
+    } catch (e) {
+      exception = e
+    }
+    c_expect(buildR).to.be.null
+    c_expect(exception).to.not.be.null
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
+    expect(context.fail).not.toBeCalled()
+  })
+
+  test('Failure exception to transaction context as RAW and null body', async () => {
+    const b = null
+    const r = new Response<any>(400, b, {
+      rawBody: true,
+      throwOnErrors: true,
+    })
+    const t = observableTransaction()
+    const context = t['context']
+    let buildR: any = null,
+      exception = null
+    try {
+      buildR = await r.build(context, t, false)
+    } catch (e) {
+      exception = e
+    }
+    c_expect(buildR).to.be.null
+    c_expect(exception).to.not.be.null
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
+    expect(context.fail).not.toBeCalled()
+  })
+
+  test('Failure exception to transaction context as RAW and custom ero', async () => {
+    const b = { message: 'abc', error: 'error 123' }
+    const r = new Response<any>(400, b, {
+      rawBody: true,
+      throwOnErrors: true,
+    })
+    const t = observableTransaction()
+    const context = t['context']
+    let buildR: any = null,
+      exception = null
+    try {
+      buildR = await r.build(context, t, false)
+    } catch (e) {
+      exception = e
+    }
+    c_expect(buildR).to.be.null
+    c_expect(exception).to.not.be.null
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
+    expect(context.fail).not.toBeCalled()
+  })
+})
+
+describe('Response shortcuts', () => {
+  test('MissingParamResponse', async () => {
+    const pName = 'abc'
+    const r = Response.MissingParamResponse(pName)
+    await testResponse(r, {
+      err: `Invalid request. Path parameter ${pName} is missing.`,
+      errCode: Globals.ErrorCode_MissingParam,
+    })
+  })
+
+  test('MissingQueryResponse', async () => {
+    const pName = 'abc'
+    const r = Response.MissingQueryResponse(pName)
+    await testResponse(r, {
+      err: `Invalid request. Query parameter ${pName} is missing.`,
+      errCode: Globals.ErrorCode_MissingParam,
+    })
+  })
+
+  test('BadRequestResponse', async () => {
+    const message = 'abc'
+    const code = 'CODE'
+    const optBody = { additional: 123 }
+    const r = Response.BadRequestResponse(message, code, optBody)
+    await testResponse(r, {
+      err: message,
+      errCode: code,
+      ...optBody,
+    })
+  })
+
+  test('BadRequestResponse no opts', async () => {
+    const message = 'abc'
+    const r = Response.BadRequestResponse(message)
+    await testResponse(r, {
+      err: message,
+    })
+  })
+
+  test('BadRequestResponseWithRollback', async () => {
+    const message = 'abc'
+    const code = 'CODE'
+    const optBody = { additional: 123 }
+    const r = Response.BadRequestResponseWithRollback(message, code, optBody)
+    await testResponse(r, {
+      err: message,
+      rollback: true,
+      errCode: code,
+      ...optBody,
+    })
+  })
+
+  test('BadRequestResponseWithRollback no opts', async () => {
+    const message = 'abc'
+    const r = Response.BadRequestResponseWithRollback(message)
+    await testResponse(r, {
+      err: message,
+      rollback: true,
+    })
+  })
+
+  test('UnauthorizedResponse', async () => {
+    const message = 'abc'
+    const code = 'CODE'
+    const r = Response.UnauthorizedResponse(message, code)
+    await testResponse(
+      r,
+      {
+        err: message,
+        errCode: code,
+      },
+      401
+    )
+  })
+
+  test('UnauthorizedResponse no code', async () => {
+    const message = 'abc'
+    const r = Response.UnauthorizedResponse(message)
+    await testResponse(r, { err: message }, 401)
+  })
+
+  test('SuccessResponse', async () => {
+    const body = { additional: 123 }
+    const r = Response.SuccessResponse(body)
+    await testResponse(r, body, 200)
+  })
+
+  test('SuccessResponse null body', async () => {
+    const r = Response.SuccessResponse(null)
+    await testResponse(r, {}, 200)
+  })
+
+  test('SuccessNoContentResponse', async () => {
+    const r = Response.SuccessNoContentResponse()
+    await testResponse(r, null, 204)
+  })
+
+  test('SimpleResponse', async () => {
+    const r = Response.SimpleResponse(null)
+    await testResponse(r, null, 200)
+  })
+
+  test('SimpleResponse override statuscode', async () => {
+    const r = Response.SimpleResponse(null, 203)
+    await testResponse(r, null, 203)
+  })
+
+  test('RedirectResponse', async () => {
+    const url = 'https://google.com'
+    const r = Response.RedirectResponse(url)
+    await testResponse(r, null, 302, { Location: url })
+  })
+
+  test('SuccessStreamResponse', async () => {
+    const b = { name: 'abc' }
+    const r = Response.SuccessStreamResponse(b, 'test-stream')
+    const t = observableTransaction()
+    const context = t['context']
+    const buildR = await r.build(context, t, false)
+    await r.build(context, t, false) //pipe twice, should not affect
+    c_expect(buildR).to.be.undefined
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).toHaveBeenCalledTimes(1)
+    expect(context.succeed).toHaveBeenCalledWith({
+      statusCode: 200,
+      headers: {
+        ...defaultHeaders,
+        'Content-Type': 'test-stream',
+        Connection: 'keep-alive',
+      },
+      body: {
+        ...b,
+      },
+    })
+  })
+})
+
+export {}