@ikonintegration/ikapi 4.0.1 → 5.0.0

package/tests/BaseEvent/Transaction.test.ts

@@ -0,0 +1,402 @@
+import { jest } from '@jest/globals'
+import { expect as c_expect } from 'chai'
+
+import Response from '../../src/API/Response.js'
+import Transaction from '../../src/BaseEvent/Transaction.js'
+import type { DbConfig } from '../../src/Database/types.js'
+import Globals from '../../src/Globals.js'
+import { defaultHeaders, emptyEvent, observableContext } from '../Test.utils.js'
+
+describe('Transaction success invocation path', () => {
+  test('Simple success', async () => {
+    const b = { name: '123' }
+    const context = observableContext()
+    const transaction = new Transaction<null, typeof b>(emptyEvent(), context)
+    const handlerResp = await transaction.execute(async () => {
+      return Response.SuccessResponse(b)
+    })
+    // check resp
+    c_expect(handlerResp).to.be.null
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).toBeCalledWith({
+      statusCode: 200,
+      body: JSON.stringify(b),
+      headers: defaultHeaders,
+    })
+  })
+
+  test('Simple success - sync return', async () => {
+    const b = { name: '123' }
+    const context = observableContext()
+    const transaction = new Transaction<null, typeof b>(emptyEvent(), context, {
+      syncReturn: true,
+    })
+    const handlerResp = await transaction.execute(async () => {
+      return Response.SuccessResponse(b)
+    })
+    // check resp
+    c_expect(handlerResp).to.be.an.instanceof(Response)
+    c_expect(handlerResp?.getBody()).to.be.deep.equals(b)
+    c_expect(handlerResp?.getCode()).to.be.equals(200)
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
+  })
+})
+
+describe('Transaction error invocation path without response', () => {
+  test('Not valid response returned success', async () => {
+    const b = {
+      err: Globals.ErrorResponseInvalidServerResponse,
+      rollback: true,
+      errCode: Globals.ErrorCode_APIError,
+      transactionID: '123',
+    }
+    const context = observableContext({ awsRequestId: '123' })
+    const transaction = new Transaction<null, typeof b>(emptyEvent(), context)
+    // @ts-expect-error
+    const handlerResp = await transaction.execute(async () => {
+      return null
+    })
+    // check resp
+    c_expect(handlerResp).to.be.null
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).toBeCalledWith({
+      statusCode: 400,
+      body: JSON.stringify(b),
+      headers: defaultHeaders,
+    })
+  })
+
+  test('Not valid response returned success - sync return', async () => {
+    const b = {
+      err: Globals.ErrorResponseInvalidServerResponse,
+      rollback: true,
+      errCode: Globals.ErrorCode_APIError,
+      transactionID: '123',
+    }
+    const context = observableContext()
+    const transaction = new Transaction<null, typeof b>(
+      emptyEvent({
+        requestContext: { requestId: '123' },
+      }),
+      context,
+      {
+        syncReturn: true,
+      }
+    )
+    // @ts-expect-error
+    const handlerResp = await transaction.execute(async () => {
+      return null
+    })
+    // check resp
+    c_expect(handlerResp).to.be.an.instanceof(Response)
+    c_expect(handlerResp?.getBody()).to.be.deep.equals(b)
+    c_expect(handlerResp?.getCode()).to.be.equals(400)
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
+  })
+})
+
+describe('Transaction error invocation path with non-Response class response', () => {
+  test('Not a response-class response returned success', async () => {
+    const b = {
+      err: Globals.ErrorResponseInvalidServerResponse,
+      rollback: true,
+      errCode: Globals.ErrorCode_APIError,
+      transactionID: 'unknown',
+    }
+    const b2 = { name: 'abc' }
+    const context = observableContext()
+    const transaction = new Transaction<null, null, typeof b2>(emptyEvent(), context)
+    const handlerResp = await transaction.execute(async () => {
+      return b2
+    })
+    // check resp
+    c_expect(handlerResp).to.be.null
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).toBeCalledWith({
+      statusCode: 400,
+      body: JSON.stringify(b),
+      headers: defaultHeaders,
+    })
+  })
+
+  test('Not a response-class response returned success - sync return', async () => {
+    const b2 = { name: 'abc' }
+    const context = observableContext()
+    const transaction = new Transaction<null, null, typeof b2>(emptyEvent(), context, {
+      syncReturn: true,
+    })
+    const handlerResp = await transaction.execute(async () => {
+      return b2
+    })
+    // check resp
+    c_expect(handlerResp).to.be.deep.equals(b2)
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
+  })
+})
+
+describe('Transaction error invocation path with exception', () => {
+  test('Transaction exception', async () => {
+    const b = {
+      err: Globals.ErrorResponseUnhandledError,
+      rollback: true,
+      errCode: Globals.ErrorCode_APIError,
+      transactionID: 'unknown',
+    }
+    const context = observableContext()
+    const transaction = new Transaction<null, null, null>(emptyEvent(), context)
+    const handlerResp = await transaction.execute(async () => {
+      throw new Error('Failed!')
+    })
+    // check resp
+    c_expect(handlerResp).to.be.null
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).toBeCalledWith({
+      statusCode: 400,
+      body: JSON.stringify(b),
+      headers: defaultHeaders,
+    })
+  })
+
+  test('Transaction exception - sync return', async () => {
+    const b = {
+      err: Globals.ErrorResponseUnhandledError,
+      rollback: true,
+      errCode: Globals.ErrorCode_APIError,
+      transactionID: 'unknown',
+    }
+    const context = observableContext()
+    const transaction = new Transaction<null, null, null>(emptyEvent(), context, {
+      syncReturn: true,
+    })
+    const handlerResp = await transaction.execute(async () => {
+      throw new Error('Failed!')
+    })
+    // check resp
+    c_expect(handlerResp?.getBody()).to.be.deep.equals(b)
+    c_expect(handlerResp?.getCode()).to.be.equals(400)
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
+  })
+
+  test('Transaction exception - sync return', async () => {
+    const context = observableContext()
+    const transaction = new Transaction<null, null, null>(emptyEvent(), context, {
+      throwOnErrors: true,
+    })
+    const error = new Error('Failed!')
+    let handlerResp: any = null,
+      err: any = null
+    try {
+      handlerResp = await transaction.execute(async () => {
+        throw error
+      })
+    } catch (e) {
+      err = e
+    }
+    // check resp
+    c_expect(handlerResp).to.be.null
+    c_expect(err).to.be.deep.equals(error)
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).not.toBeCalled()
+  })
+})
+
+describe('Transaction - db integration', () => {
+  const testResources = () => {
+    const mockTrans = {
+      query: jest.fn(),
+      closeSuccess: jest.fn(),
+      closeFailure: jest.fn(),
+    }
+    const mockCreate = jest.fn(
+      () => ({ transaction: () => new Promise(resolve => resolve(mockTrans)) }) as any
+    )
+
+    const transaction = new Transaction(emptyEvent(), observableContext())
+    transaction['databaseManager'] = {
+      create: mockCreate,
+    } as any
+
+    return {
+      transaction,
+      mockCreate,
+      mockTrans,
+    }
+  }
+
+  const config = { username: 'test' } as DbConfig<'pg'>
+
+  test('Transaction provides dbTransaction and calls closeSuccess', async () => {
+    const { mockCreate, mockTrans, transaction } = testResources()
+
+    await transaction.execute(async () => {
+      const pgTransaction = await transaction.getDbTransaction(config)
+
+      pgTransaction.query('name')
+
+      return Response.SuccessResponse(null)
+    })
+    expect(mockCreate).toBeCalledWith(config)
+    expect(mockTrans.query).toBeCalledWith('name')
+    expect(mockTrans.closeSuccess).toBeCalled()
+  })
+
+  test('Errored transaction calls closeFailure', async () => {
+    const { mockCreate, transaction, mockTrans } = testResources()
+
+    await transaction.execute(async () => {
+      await transaction.getDbTransaction(config)
+      throw new Error('Something went wrong!')
+      return Response.SuccessResponse(null)
+    })
+
+    expect(mockCreate).toBeCalledWith(config)
+    expect(mockTrans.closeFailure).toBeCalled()
+  })
+})
+
+describe('Transaction response types', () => {
+  test('Non-response return', async () => {
+    const b = { name: '123' }
+    const b2 = {
+      err: Globals.ErrorResponseInvalidServerResponse,
+      rollback: true,
+      errCode: Globals.ErrorCode_APIError,
+      transactionID: 'unknown',
+    }
+    const context = observableContext()
+    const transaction = new Transaction<null, typeof b>(emptyEvent(), context)
+    // @ts-expect-error
+    const handlerResp = await transaction.execute(async () => {
+      return { d: 1 }
+    })
+    // check resp
+    c_expect(handlerResp).to.be.null
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).toBeCalledWith({
+      statusCode: 400,
+      body: JSON.stringify(b2),
+      headers: defaultHeaders,
+    })
+  })
+
+  test('Null return', async () => {
+    const b = { name: '123' }
+    const b2 = {
+      err: Globals.ErrorResponseInvalidServerResponse,
+      rollback: true,
+      errCode: Globals.ErrorCode_APIError,
+      transactionID: 'unknown',
+    }
+    const context = observableContext()
+    const transaction = new Transaction<null, typeof b>(emptyEvent(), context)
+    // @ts-expect-error
+    const handlerResp = await transaction.execute(async () => {
+      return null
+    })
+    // check resp
+    c_expect(handlerResp).to.be.null
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).toBeCalledWith({
+      statusCode: 400,
+      body: JSON.stringify(b2),
+      headers: defaultHeaders,
+    })
+  })
+
+  test('Undefined return', async () => {
+    const b = { name: '123' }
+    const b2 = {
+      err: Globals.ErrorResponseInvalidServerResponse,
+      rollback: true,
+      errCode: Globals.ErrorCode_APIError,
+      transactionID: 'unknown',
+    }
+    const context = observableContext()
+    const transaction = new Transaction<null, typeof b>(emptyEvent(), context)
+    // @ts-expect-error
+    const handlerResp = await transaction.execute(async () => {
+      return
+    })
+    // check resp
+    c_expect(handlerResp).to.be.null
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).toBeCalledWith({
+      statusCode: 400,
+      body: JSON.stringify(b2),
+      headers: defaultHeaders,
+    })
+  })
+
+  test('Null inner-response return', async () => {
+    const b = { name: '123' }
+    const b2 = { transactionID: 'unknown' }
+    const context = observableContext()
+    const transaction = new Transaction<null, typeof b>(emptyEvent(), context)
+    // @ts-expect-error
+    const handlerResp = await transaction.execute(async () => {
+      return Response.SuccessResponse(null)
+    })
+    // check resp
+    c_expect(handlerResp).to.be.null
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).toBeCalledWith({
+      statusCode: 200,
+      body: JSON.stringify(b2),
+      headers: defaultHeaders,
+    })
+  })
+
+  test('Wrong keys inner-response return', async () => {
+    const b = { name: '123' }
+    const b2 = {
+      notName: '123',
+      transactionID: 'unknown',
+    }
+    const context = observableContext()
+    const transaction = new Transaction<null, typeof b>(emptyEvent(), context)
+    // @ts-expect-error
+    const handlerResp = await transaction.execute(async () => {
+      return Response.SuccessResponse({ notName: '123' })
+    })
+    // check resp
+    c_expect(handlerResp).to.be.null
+    // ctx
+    expect(context.fail).not.toBeCalled()
+    expect(context.done).not.toBeCalled()
+    expect(context.succeed).toBeCalledWith({
+      statusCode: 200,
+      body: JSON.stringify(b2),
+      headers: defaultHeaders,
+    })
+  })
+})

package/tests/Cache/Redis-client.test.ts

@@ -0,0 +1,90 @@
+import { jest } from '@jest/globals'
+
+import Redis from '../../src/Cache/Redis.js'
+
+let _connectionId = 1
+
+async function simpleRedisTest(config: any, concurrent?: boolean) {
+  const RedisMock = jest.fn(() => {
+    let opened = false
+    const connectionId = _connectionId++
+    return {
+      connectionId,
+      isOpen: () => opened,
+      close: () => (opened = false),
+      connect: jest.fn(() => {
+        opened = true
+        return {
+          mget: jest.fn(() => {
+            return true
+          }),
+        }
+      }),
+    } as any
+  })
+  Redis['ClientFactory'] = RedisMock
+  // Double call is intentional
+  const [provider, provider2] = concurrent
+    ? await Promise.all([Redis.connection(config), Redis.connection(config)])
+    : [await Redis.connection(config), await Redis.connection(config)]
+
+  // client checks
+  expect(RedisMock).toHaveBeenNthCalledWith(1, {
+    username: config.username,
+    ...(config.password ? { password: config.password } : {}),
+    disableOfflineQueue: true,
+    socket: {
+      host: config.hostname,
+      tls: config.enableTLS,
+      connectTimeout: 10000,
+    },
+  })
+  // Does not have double connection
+  expect(provider['connectionId']).toEqual(provider2['connectionId'])
+  expect(provider.connect).toHaveBeenCalledTimes(1)
+  expect(provider2.connect).toHaveBeenCalledTimes(1)
+}
+
+describe('Redis (client)', () => {
+  beforeEach(async () => {
+    // hack to close singleton connection
+    if (Redis['singleton'].getValue()) Redis['singleton'].clear()
+  })
+  test('Simple redis - do not connect twice', async () => {
+    await simpleRedisTest({
+      hostname: 'redis://localhost',
+      username: 'gabe',
+      password: 'mypassword',
+      enableTLS: true,
+      type: 'redis',
+    })
+  })
+  test('Simple redis (no SSL) - do not connect twice', async () => {
+    await simpleRedisTest({
+      hostname: 'redis://localhost',
+      username: 'gabe',
+      password: 'mypassword',
+      enableTLS: false,
+      type: 'redis',
+    })
+  })
+  test('Simple redis (passwordless) - do not connect twice', async () => {
+    await simpleRedisTest({
+      hostname: 'redis://localhost',
+      username: 'gabe',
+      enableTLS: false,
+      type: 'redis',
+    })
+  })
+  test('Concurrent redis - do not connect twice', async () => {
+    await simpleRedisTest(
+      {
+        hostname: 'redis://localhost',
+        username: 'gabe',
+        enableTLS: false,
+        type: 'redis',
+      },
+      true
+    )
+  })
+})

package/tests/Cache/Redis-cluster.test.ts

@@ -0,0 +1,100 @@
+import { jest } from '@jest/globals'
+
+import Redis from '../../src/Cache/Redis.js'
+
+let _connectionId = 1
+
+async function simpleRedisTest(config: any, concurrent?: boolean) {
+  const RedisMock = jest.fn(() => {
+    let opened = false
+    const connectionId = _connectionId++
+    return {
+      connectionId,
+      isOpen: () => opened,
+      close: () => (opened = false),
+      connect: jest.fn(() => {
+        opened = true
+        return {
+          mget: jest.fn(() => {
+            return true
+          }),
+        }
+      }),
+    } as any
+  })
+  Redis['ClusterFactory'] = RedisMock
+  // Double call is intentional
+  const [provider, provider2] = concurrent
+    ? await Promise.all([Redis.connection(config), Redis.connection(config)])
+    : [await Redis.connection(config), await Redis.connection(config)]
+
+  // client checks
+  expect(RedisMock).toHaveBeenNthCalledWith(1, {
+    defaults: {
+      username: config.username,
+      ...(config.password ? { password: config.password } : {}),
+      socket: {
+        tls: config.enableTLS,
+        connectTimeout: 10000,
+      },
+    },
+    rootNodes: [
+      {
+        url: `redis://${config.username}:${config.username}@${config.hostname}:6379`,
+        disableOfflineQueue: true,
+      },
+    ],
+  })
+  // Does not have double connection
+  expect(provider['connectionId']).toEqual(provider2['connectionId'])
+  expect(provider.connect).toHaveBeenCalledTimes(1)
+  expect(provider2.connect).toHaveBeenCalledTimes(1)
+}
+
+describe('Redis (cluster)', () => {
+  beforeEach(async () => {
+    // hack to close singleton connection
+    if (Redis['singleton'].getValue()) Redis['singleton'].clear()
+  })
+  test('Simple redis - do not connect twice', async () => {
+    await simpleRedisTest({
+      hostname: 'redis://localhost',
+      username: 'gabe',
+      password: 'mypassword',
+      enableTLS: true,
+      clusterMode: true,
+      type: 'redis',
+    })
+  })
+  test('Simple redis (no SSL) - do not connect twice', async () => {
+    await simpleRedisTest({
+      hostname: 'redis://localhost',
+      username: 'gabe',
+      password: 'mypassword',
+      enableTLS: false,
+      clusterMode: true,
+      type: 'redis',
+    })
+  })
+  test('Simple redis (passwordless) - do not connect twice', async () => {
+    await simpleRedisTest({
+      hostname: 'redis://localhost',
+      username: 'gabe',
+      enableTLS: false,
+      clusterMode: true,
+      type: 'redis',
+    })
+  })
+  test('Concurrent redis - do not connect twice', async () => {
+    await simpleRedisTest(
+      {
+        hostname: 'redis://localhost',
+        username: 'gabe',
+        enableTLS: false,
+        clusterMode: true,
+        type: 'redis',
+      },
+      true
+    )
+  })
+})