@creator.co/wapi 1.7.1-alpha4 → 1.7.2-alpha1

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 {}

package/tests/API/Utils.test.ts

@@ -0,0 +1,167 @@
+import { expect } from 'chai'
+
+import Utils from '../../src/Util/Utils.js'
+
+describe('isHybridlessContainer', () => {
+  test('Simple isHybridlessContainer test', () => {
+    const v = Utils.isHybridlessContainer()
+    expect(v).to.be.a('boolean')
+    // this is done, so tests are reliable based on the testing .env
+    expect(v).to.be[process.env.HYBRIDLESS_RUNTIME ? 'true' : 'false']
+  })
+})
+
+describe('isValidString', () => {
+  test('Empty string is not valid', () => {
+    const v = Utils.isValidString('')
+    expect(v).to.be.a('boolean')
+    expect(v).to.be.false
+  })
+
+  test('Number is not a valid string', () => {
+    // @ts-ignore
+    const v = Utils.isValidString(12)
+    expect(v).to.be.a('boolean')
+    expect(v).to.be.false
+  })
+
+  test('Simple string is valid', () => {
+    const v = Utils.isValidString('abc')
+    expect(v).to.be.a('boolean')
+    expect(v).to.be.true
+  })
+})
+
+describe('parseIntNullIfNaN', () => {
+  test('Null if only chars', () => {
+    const v = Utils.parseIntNullIfNaN('abc')
+    expect(v).to.be.null
+  })
+
+  test('Null if chars with numbers', () => {
+    const v = Utils.parseIntNullIfNaN('abc123')
+    expect(v).to.be.null
+  })
+
+  test('Null if null', () => {
+    // @ts-ignore
+    const v = Utils.parseIntNullIfNaN(null)
+    expect(v).to.be.null
+  })
+
+  test('Not null if starts with numbers (js behavior)', () => {
+    const v = Utils.parseIntNullIfNaN('123abc')
+    expect(v).to.be.a('number')
+    expect(v).to.be.equals(123)
+  })
+
+  test('Not null if numbers', () => {
+    const v = Utils.parseIntNullIfNaN('123')
+    expect(v).to.be.a('number')
+    expect(v).to.be.equals(123)
+  })
+
+  test('Not null if number type', () => {
+    // @ts-ignore
+    const v = Utils.parseIntNullIfNaN(123)
+    expect(v).to.be.a('number')
+    expect(v).to.be.equals(123)
+  })
+})
+
+describe('parseObjectNullIfEmpty', () => {
+  test('Null if only chars', () => {
+    const v = Utils.parseObjectNullIfEmpty('abc')
+    expect(v).to.be.null
+  })
+
+  test('Null if chars with numbers', () => {
+    const v = Utils.parseObjectNullIfEmpty('abc123')
+    expect(v).to.be.null
+  })
+
+  test('Null if null', () => {
+    // @ts-ignore
+    const v = Utils.parseObjectNullIfEmpty(null)
+    expect(v).to.be.null
+  })
+
+  test('Null if malformed object', () => {
+    const v = Utils.parseObjectNullIfEmpty('{d: 123}')
+    expect(v).to.be.null
+  })
+
+  test('Null if empty object', () => {
+    const v = Utils.parseObjectNullIfEmpty('{}')
+    expect(v).to.be.null
+  })
+
+  test('Not null if object with a key', () => {
+    const v = Utils.parseObjectNullIfEmpty('{"d": 123}')
+    expect(v).to.be.a('object')
+    expect(v?.['d']).to.be.equals(123)
+  })
+})
+
+describe('isValidNumber', () => {
+  test('Not a valid number if only chars', () => {
+    const v = Utils.isValidNumber('abc')
+    expect(v).to.be.false
+  })
+
+  test('Not a valid number if only chars and numbers', () => {
+    const v = Utils.isValidNumber('abc123')
+    expect(v).to.be.false
+  })
+
+  test('Not a valid number if causes a crash on conversion', () => {
+    // @ts-ignore
+    const v = Utils.isValidNumber({
+      toString: () => {
+        throw new Error('Evil object')
+      },
+    })
+    expect(v).to.be.false
+  })
+
+  test('Valid number if numbers and chars after', () => {
+    const v = Utils.isValidNumber('123abc')
+    expect(v).to.be.true
+  })
+
+  test('Valid number if numbers', () => {
+    const v = Utils.isValidNumber('123')
+    expect(v).to.be.true
+  })
+})
+
+describe('caseInsensitiveObjectForKey', () => {
+  test('Get a key that is lowercase, asking uppercase', () => {
+    const v = Utils.caseInsensitiveObjectForKey({ abc: 123 }, 'ABC')
+    expect(v).to.be.a('number')
+    expect(v).to.be.equals(123)
+  })
+
+  test('Get a key that is uppercase, asking lowercase', () => {
+    const v = Utils.caseInsensitiveObjectForKey({ ABC: 123 }, 'abc')
+    expect(v).to.be.a('number')
+    expect(v).to.be.equals(123)
+  })
+
+  test('Fails gracefully if key is not found', () => {
+    const v = Utils.caseInsensitiveObjectForKey({ ABC: 123 }, 'asd')
+    expect(v).to.be.null
+  })
+
+  test('Fails gracefully for null object', () => {
+    const v = Utils.caseInsensitiveObjectForKey(null, 'abc')
+    expect(v).to.be.null
+  })
+
+  test('Fails gracefully for invalid object', () => {
+    const v = Utils.caseInsensitiveObjectForKey('', 'abc')
+    expect(v).to.be.null
+  })
+})
+
+export {}