@ikonintegration/ikapi 4.0.1 → 5.0.0

package/tests/Config/Config.test.ts

@@ -0,0 +1,205 @@
+import { SSMClient, GetParameterCommand } from '@aws-sdk/client-ssm'
+import { mockClient } from 'aws-sdk-client-mock'
+import { expect as c_expect } from 'chai'
+
+import Configuration from '../../src/Config/Configuration.js'
+import { SampleConfig } from '../Test.utils.js'
+
+const SSMMock = mockClient(SSMClient)
+const config = new Configuration<typeof SampleConfig>(SampleConfig, 'my-prefix')
+describe(`Optional remote environment`, () => {
+  // reset mock
+  beforeEach(() => {
+    SSMMock.reset()
+    config['resetCache']()
+  })
+
+  test('Does not accept sync get (+ compiler error)', async () => {
+    let err = null
+    try {
+      // @ts-expect-error
+      config.get('TOKEN_SECRET')
+    } catch (e) {
+      err = e
+    }
+    c_expect(err).is.not.null
+    c_expect(err?.['message']).is.not.null
+  })
+
+  test('Optional value with null value', async () => {
+    SSMMock.on(GetParameterCommand).resolves({
+      Parameter: {
+        Value: undefined,
+      },
+    })
+    const token = await config.asyncGet('TOKEN_SECRET_FALSY')
+    c_expect(token).is.undefined
+  })
+
+  test('Optional value with empty response', async () => {
+    SSMMock.on(GetParameterCommand).resolves({})
+    const token = await config.asyncGet('TOKEN_SECRET_FALSY')
+    c_expect(token).is.undefined
+  })
+
+  test('Optional value with valid response', async () => {
+    const value = 'abc'
+    SSMMock.on(GetParameterCommand).resolves({
+      Parameter: {
+        Value: value,
+      },
+    })
+    const token = await config.asyncGet('TOKEN_SECRET_FALSY')
+    c_expect(token).is.not.undefined
+    c_expect(token).to.be.equals(value)
+  })
+
+  test('Optional value rejection', async () => {
+    SSMMock.on(GetParameterCommand).rejects(new Error('failed!'))
+    const token = await config.asyncGet('TOKEN_SECRET_FALSY')
+    c_expect(token).is.undefined
+  })
+})
+
+describe(`Required remote environment`, () => {
+  // reset mock
+  beforeEach(() => {
+    SSMMock.reset()
+    config['resetCache']()
+  })
+
+  test('Does not accept sync get (+ compiler error)', async () => {
+    let err = null
+    try {
+      // @ts-expect-error
+      config.get('TOKEN_SECRET')
+    } catch (e) {
+      err = e
+    }
+    c_expect(err).is.not.null
+    c_expect(err?.['message']).is.not.null
+  })
+
+  test('Required value with null value', async () => {
+    SSMMock.on(GetParameterCommand).resolves({
+      Parameter: {
+        Value: undefined,
+      },
+    })
+    let err = null
+    try {
+      await config.asyncGet('TOKEN_SECRET')
+    } catch (e) {
+      err = e
+    }
+    c_expect(err).is.not.null
+    c_expect(err?.['message']).is.not.null
+  })
+
+  test('Required value with empty response', async () => {
+    SSMMock.on(GetParameterCommand).resolves({})
+    let err = null
+    try {
+      await config.asyncGet('TOKEN_SECRET')
+    } catch (e) {
+      err = e
+    }
+    c_expect(err).is.not.null
+    c_expect(err?.['message']).is.not.null
+  })
+
+  test('Required value with valid response', async () => {
+    const value = 'abc'
+    SSMMock.on(GetParameterCommand).resolves({
+      Parameter: {
+        Value: value,
+      },
+    })
+    const token = await config.asyncGet('TOKEN_SECRET')
+    c_expect(token).is.not.undefined
+    c_expect(token).to.be.equals(value)
+  })
+
+  test('Required value rejection', async () => {
+    SSMMock.on(GetParameterCommand).rejects(new Error('failed!'))
+    let err = null
+    try {
+      await config.asyncGet('TOKEN_SECRET')
+    } catch (e) {
+      err = e
+    }
+    c_expect(err).is.not.null
+    c_expect(err?.['message']).is.not.null
+  })
+})
+
+describe(`Optional local environment`, () => {
+  beforeEach(() => {
+    config['resetCache']()
+  })
+
+  test('Optional value with null value', async () => {
+    const token = config.get('PATH123')
+    c_expect(token).is.undefined
+  })
+})
+
+describe(`Required local environment`, () => {
+  beforeEach(() => {
+    config['resetCache']()
+  })
+
+  test('Test compiler error', async () => {
+    let err = null
+    try {
+      // @ts-expect-error
+      await config.asyncGet('PATH')
+    } catch (e) {
+      err = e
+    }
+    c_expect(err).is.not.null
+    c_expect(err?.['message']).is.not.null
+  })
+
+  test('Required value with null value', async () => {
+    let err = null
+    try {
+      config.get('PATH_FALSY')
+    } catch (e) {
+      err = e
+    }
+    c_expect(err).is.not.null
+    c_expect(err?.['message']).is.not.null
+  })
+
+  test('Required value with valid response', async () => {
+    const key = 'PATH'
+    const v = config.get(key)
+    c_expect(v).is.not.null
+    c_expect(v).to.be.equals(process.env[key])
+  })
+})
+
+describe(`Caching test`, () => {
+  test('Does cache previous fetched value', async () => {
+    const value = '123'
+    const key = 'TOKEN_SECRET'
+    // initial fetch
+    SSMMock.on(GetParameterCommand).resolves({
+      Parameter: {
+        Value: value,
+      },
+    })
+    const v = await config.asyncGet(key)
+    c_expect(v).is.not.null
+    c_expect(v).to.be.equals(value)
+    // subsequent fetch
+    SSMMock.reset()
+    SSMMock.on(GetParameterCommand).rejects(new Error('failed!'))
+    const v2 = await config.asyncGet(key)
+    c_expect(v2).is.not.null
+    c_expect(v2).to.be.equals(value)
+  })
+})
+
+export {}

package/tests/Config/EnvironmentVar.test.ts

@@ -0,0 +1,251 @@
+import { SecretsManagerClient, GetSecretValueCommand } from '@aws-sdk/client-secrets-manager'
+import { SSMClient, GetParameterCommand } from '@aws-sdk/client-ssm'
+import { mockClient } from 'aws-sdk-client-mock'
+import { expect } from 'chai'
+
+import EnvironmentVar, { EnvironmentType } from '../../src/Config/EnvironmentVar.js'
+
+const SSMMock = mockClient(SSMClient)
+const SecretsManagerMock = mockClient(SecretsManagerClient)
+const prefix = '/abc/test-01/'
+
+function testRemoteEnv(mock, type, command) {
+  describe(`Optional ${type} environment`, () => {
+    // reset mock
+    beforeEach(() => {
+      mock.reset()
+    })
+
+    test('Does not accept sync resolve', async () => {
+      mock.on(command).resolves({
+        ...(type == EnvironmentType.PlainRemote
+          ? {
+              Parameter: {
+                Value: undefined,
+              },
+            }
+          : {
+              SecretString: undefined,
+            }),
+      })
+      let err = null
+      try {
+        const env = new EnvironmentVar('abc', type, true, prefix)
+        env.syncResolve()
+      } catch (e) {
+        err = e
+      }
+      expect(err).is.not.null
+      expect(err?.['message']).is.not.null
+    })
+
+    test('Optional value with null value', async () => {
+      mock.on(command).resolves({
+        ...(type == EnvironmentType.PlainRemote
+          ? {
+              Parameter: {
+                Value: undefined,
+              },
+            }
+          : {
+              SecretString: undefined,
+            }),
+      })
+      const env = new EnvironmentVar('abc', type, true, prefix)
+      const token = await env.resolve()
+      expect(token).is.undefined
+    })
+
+    test('Optional value with empty response', async () => {
+      mock.on(command).resolves({})
+      const env = new EnvironmentVar('abc', type, true, prefix)
+      const token = await env.resolve()
+      expect(token).is.undefined
+    })
+
+    test('Optional value with valid response', async () => {
+      const value = 'abc'
+      mock.on(command).resolves({
+        ...(type == EnvironmentType.PlainRemote
+          ? {
+              Parameter: {
+                Value: value,
+              },
+            }
+          : {
+              SecretString: value,
+            }),
+      })
+      const env = new EnvironmentVar(value, type, true, prefix)
+      const token = await env.resolve()
+      expect(token).is.not.undefined
+      expect(token).to.be.equals(value)
+    })
+
+    test('Optional value rejection', async () => {
+      const value = 'abc'
+      mock.on(command).rejects(new Error('failed!'))
+      const env = new EnvironmentVar(value, type, true, prefix)
+      const token = await env.resolve()
+      expect(token).is.undefined
+    })
+  })
+
+  describe(`Required ${type} environment`, () => {
+    // reset mock
+    beforeEach(() => {
+      mock.reset()
+    })
+
+    test('Does not accept sync resolve', async () => {
+      mock.on(command).resolves({
+        ...(type == EnvironmentType.PlainRemote
+          ? {
+              Parameter: {
+                Value: undefined,
+              },
+            }
+          : {
+              SecretString: undefined,
+            }),
+      })
+      let err = null
+      try {
+        const env = new EnvironmentVar('abc', type, undefined, prefix)
+        env.syncResolve()
+      } catch (e) {
+        err = e
+      }
+      expect(err).is.not.null
+      expect(err?.['message']).is.not.null
+    })
+
+    test('Required fails when null', async () => {
+      mock.on(command).resolves({
+        ...(type == EnvironmentType.PlainRemote
+          ? {
+              Parameter: {
+                Value: undefined,
+              },
+            }
+          : {
+              SecretString: undefined,
+            }),
+      })
+      let err = null
+      try {
+        const env = new EnvironmentVar('abc', type, false, prefix)
+        await env.resolve()
+      } catch (e) {
+        err = e
+      }
+      console.log(err)
+      expect(err).is.not.null
+      expect(err?.['message']).is.not.null
+    })
+
+    test('Required fails when empty response', async () => {
+      mock.on(command).resolves({})
+      let err = null
+      try {
+        const env = new EnvironmentVar('abc', type, false, prefix)
+        await env.resolve()
+      } catch (e) {
+        err = e
+      }
+      expect(err).is.not.null
+      expect(err?.['message']).is.not.null
+    })
+
+    test('Required value with valid response', async () => {
+      const value = 'abc'
+      mock.on(command).resolves({
+        ...(type == EnvironmentType.PlainRemote
+          ? {
+              Parameter: {
+                Value: value,
+              },
+            }
+          : {
+              SecretString: value,
+            }),
+      })
+      const env = new EnvironmentVar(value, type, false, prefix)
+      const token = await env.resolve()
+      expect(token).is.not.undefined
+      expect(token).to.be.equals(value)
+    })
+
+    test('Required value rejection', async () => {
+      mock.on(command).rejects(new Error('failed!'))
+      let err = null
+      try {
+        const env = new EnvironmentVar('abc', type, false, prefix)
+        await env.resolve()
+      } catch (e) {
+        err = e
+      }
+      expect(err).is.not.null
+      expect(err?.['message']).is.not.null
+    })
+  })
+}
+
+/* Remote envs test */
+testRemoteEnv(SSMMock, EnvironmentType.PlainRemote, GetParameterCommand)
+testRemoteEnv(SecretsManagerMock, EnvironmentType.SecureRemote, GetSecretValueCommand)
+
+describe('Optional Local environment', () => {
+  test('Does accept async resolve', async () => {
+    const env = new EnvironmentVar('PATH123', EnvironmentType.Local, true, prefix)
+    const v = await env.resolve()
+    expect(v).is.undefined
+  })
+
+  test('Optional value with null value', async () => {
+    const env = new EnvironmentVar('PATH123', EnvironmentType.Local, true, prefix)
+    const token = env.syncResolve()
+    expect(token).is.undefined
+  })
+
+  test('Optional value with valid value', async () => {
+    const key = 'PATH'
+    const env = new EnvironmentVar(key, EnvironmentType.Local, true, prefix)
+    const token = env.syncResolve()
+    expect(token).is.not.undefined
+    expect(token).to.be.equals(process.env[key])
+  })
+})
+
+describe('Required local environment', () => {
+  test('Does accept async resolve', async () => {
+    const key = 'PATH'
+    const env = new EnvironmentVar(key, EnvironmentType.Local, false, prefix)
+    const v = await env.resolve()
+    expect(v).is.not.null
+    expect(v).to.be.equals(process.env[key])
+  })
+
+  test('Required fails when null', async () => {
+    let err = null
+    try {
+      const env = new EnvironmentVar('PATH123', EnvironmentType.Local, false, prefix)
+      env.syncResolve()
+    } catch (e) {
+      err = e
+    }
+    console.log(err)
+    expect(err).is.not.null
+    expect(err?.['message']).is.not.null
+  })
+
+  test('Required value with valid value', async () => {
+    const key = 'PATH'
+    const env = new EnvironmentVar(key, EnvironmentType.Local, false, prefix)
+    const v = env.syncResolve()
+    expect(v).is.not.null
+    expect(v).to.be.equals(process.env[key])
+  })
+})
+
+export {}

package/tests/Crypto/Crypto.test.ts

@@ -0,0 +1,88 @@
+import { DecryptCommand, EncryptCommand, KMSClient } from '@aws-sdk/client-kms'
+import { mockClient } from 'aws-sdk-client-mock'
+import { expect } from 'chai'
+
+import Crypto from '../../src/Crypto/Crypto.js'
+
+const KMSMock = mockClient(KMSClient)
+
+function fakeEncryption(v) {
+  const f = new TextEncoder().encode(v)
+  return Buffer.from(f as any, 'utf8').toString('hex')
+}
+function fakeDecryption(v) {
+  return new TextEncoder().encode(v)
+}
+
+describe('Encryption', () => {
+  // reset mock
+  beforeEach(() => {
+    KMSMock.reset()
+  })
+
+  const provider = new Crypto('ca-central-1', 'abc123')
+  test('Encrypts json object', async () => {
+    const encryptionObj = { userID: 123 }
+    KMSMock.on(EncryptCommand).resolves({
+      CiphertextBlob: new TextEncoder().encode(JSON.stringify(encryptionObj)),
+    })
+    const token = await provider.encryptData(encryptionObj)
+    expect(token).is.not.null
+    expect(token).to.be.equals(fakeEncryption(JSON.stringify(encryptionObj)))
+  })
+
+  test('Encrypts string', async () => {
+    const encryptionText = 'Hello encryption!'
+    KMSMock.on(EncryptCommand).resolves({
+      CiphertextBlob: new TextEncoder().encode(encryptionText),
+    })
+    const token = await provider.encryptData(encryptionText)
+    expect(token).is.not.null
+    expect(token).to.be.equals(fakeEncryption(encryptionText))
+  })
+
+  test('Fails to encrypt a number', async () => {
+    const encryptionText = 123
+    KMSMock.on(EncryptCommand).rejects(new Error('failed'))
+    const token = await provider.encryptData(encryptionText)
+    expect(token).is.null
+  })
+})
+
+describe('Decryption', () => {
+  // reset mock
+  beforeEach(() => {
+    KMSMock.reset()
+  })
+
+  const provider = new Crypto('ca-central-1', 'abc123')
+  test('Decrypts json object', async () => {
+    const encryptionObj = { userID: 123 }
+    KMSMock.on(DecryptCommand).resolves({
+      Plaintext: fakeDecryption(JSON.stringify(encryptionObj)),
+    })
+    const token = await provider.decryptData(fakeEncryption(JSON.stringify(encryptionObj)))
+    expect(token).is.not.null
+    expect(token).to.be.equals(JSON.stringify(encryptionObj))
+  })
+
+  test('Decrypts string', async () => {
+    const encryptionText = 'abc123'
+    KMSMock.on(DecryptCommand).resolves({
+      Plaintext: fakeDecryption(encryptionText),
+    })
+    const token = await provider.decryptData(fakeEncryption(encryptionText))
+    expect(token).is.not.null
+    expect(token).to.be.equals(encryptionText)
+  })
+
+  test('Fails to decrypt a number', async () => {
+    const encryptionText = 123
+    KMSMock.on(DecryptCommand).rejects(new Error('failed'))
+    // @ts-ignore
+    const token = await provider.decryptData(encryptionText)
+    expect(token).is.null
+  })
+})
+
+export {}

package/tests/Database/DatabaseManager.test.ts

@@ -0,0 +1,79 @@
+import { jest } from '@jest/globals'
+import { expect } from 'chai'
+
+import { DatabaseManager } from '../../src/Database/index.js'
+import type { DatabaseType, DbConfig } from '../../src/Database/types.js'
+
+type FakeDatabase = { host: string; tableName: string; type: 'pg' | 'kysely' | 'dynamo' }
+
+const fakeConfig = (host: string, type: DatabaseType) => {
+  return {
+    type,
+    host,
+  } as DbConfig<typeof type>
+}
+
+const fakeNoSQLConfig = (tableName: string, type: DatabaseType) => {
+  return {
+    type,
+    tableName,
+  } as DbConfig<typeof type>
+}
+
+describe('Database Manager', () => {
+  test('should correctly create and cache database instances', () => {
+    const underTest = new DatabaseManager()
+
+    underTest['databases'] = {
+      pg: jest.fn((config: any) => {
+        return { host: config.host, type: 'pg' } as any
+      }) as any,
+      kysely: jest.fn((config: any) => {
+        return { host: config.host, type: 'kysely' } as any
+      }) as any,
+      dynamo: jest.fn((config: any) => {
+        return { tableName: config.tableName, type: 'dynamo' } as any
+      }) as any,
+    }
+
+    const create = config => underTest.create({ ...config }) as unknown as FakeDatabase
+
+    const pgConfig1 = fakeConfig('localhost', 'pg')
+    const pgConfig2 = fakeConfig('other', 'pg')
+    const kyselyConfig1 = fakeConfig('localhost', 'pg')
+    const kyselyConfig2 = fakeConfig('other', 'pg')
+    const dynamoConfig1 = fakeNoSQLConfig('localhost', 'dynamo')
+    const dynamoConfig2 = fakeNoSQLConfig('other', 'dynamo')
+
+    const pg1 = create(pgConfig1)
+    const pg2 = create(pgConfig1)
+    const pg3 = create(pgConfig2)
+
+    const kysely1 = create(kyselyConfig1)
+    const kysely2 = create(kyselyConfig1)
+    const kysely3 = create(kyselyConfig2)
+
+    const dynamo1 = create(dynamoConfig1)
+    const dynamo2 = create(dynamoConfig1)
+    const dynamo3 = create(dynamoConfig2)
+
+    expect(pg1).to.equal(pg2).to.not.equal(pg3)
+
+    expect(pgConfig1).to.be.deep.equal(pg1).to.be.deep.equal(pg2)
+
+    expect(pg3).to.be.deep.equal(pgConfig2)
+
+    expect(kysely1).to.equal(kysely2).to.not.equal(kysely3)
+
+    expect(kyselyConfig1).to.be.deep.equal(kysely1).to.be.deep.equal(kysely2)
+
+    expect(kysely3).to.be.deep.equal(kyselyConfig2)
+
+    expect(dynamo1).to.equal(dynamo2).to.not.equal(dynamo3).to.not.equal(pg1)
+    console.log(dynamoConfig1)
+    console.log(dynamo1)
+    expect(dynamoConfig1).to.be.deep.equal(dynamo1).to.be.deep.equal(dynamo2)
+
+    expect(dynamo3).to.be.deep.equal(dynamoConfig2)
+  })
+})

package/tests/Database/integrations/dynamo/DynamoDatabase.test.ts

@@ -0,0 +1,44 @@
+import { Agent } from 'https'
+
+import { DynamoDB } from '@aws-sdk/client-dynamodb'
+import { jest } from '@jest/globals'
+import { NodeHttpHandler } from '@smithy/node-http-handler'
+
+import type { DbConfig } from '../../../../src/Database/index.js'
+import { DynamoDatabase } from '../../../../src/Database/integrations/dynamo/DynamoDatabase.js'
+
+const config: DbConfig<'dynamo'> = {
+  type: 'dynamo',
+  region: 'ca-central-1',
+  tableName: 'myTable',
+}
+
+const expectedImplConfig = {
+  region: config.region,
+  maxAttempts: 3,
+  requestHandler: new NodeHttpHandler({
+    connectionTimeout: 60000,
+    socketTimeout: 60000,
+    httpsAgent: new Agent({ keepAlive: false, maxSockets: 50, rejectUnauthorized: true }),
+  }),
+}
+
+describe('DynamoDatabase', () => {
+  test('DynamoDatabase', async () => {
+    const mockTrans = { a: 'b' } as any
+    const mockClient = jest.fn(
+      () =>
+        ({
+          test: async () => mockTrans,
+        }) as any as DynamoDB
+    )
+    DynamoDatabase['dynamoProvider'] = mockClient
+
+    const underTest = new DynamoDatabase(config)
+    expect(mockClient).toBeCalledWith(expectedImplConfig)
+
+    // no transaction
+    const trans = await underTest.transaction()
+    expect(trans).toBe(null)
+  })
+})