@creator.co/wapi 1.2.1-beta6 → 1.2.3

package/tests/Config/Config.test.ts

@@ -0,0 +1,193 @@
+import { SSMClient, GetParameterCommand } from '@aws-sdk/client-ssm'
+import { mockClient } from 'aws-sdk-client-mock'
+import { expect } from 'chai'
+
+import Configuration from '../../src/Config/Configuration'
+import { SampleConfig, SampleConfigSchema } from '../Test.utils'
+
+const SSMMock = mockClient(SSMClient)
+const config = new Configuration<SampleConfigSchema>(SampleConfig, 'my-prefix')
+describe(`Optional remote environment`, () => {
+  // reset mock
+  beforeEach(() => {
+    SSMMock.reset()
+    config['resetCache']()
+  })
+
+  test('Does not accept sync get', async () => {
+    let err = null
+    try {
+      // @ts-ignore
+      config.get('TOKEN_SECRET')
+    } catch (e) {
+      err = e
+    }
+    expect(err).is.not.null
+    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')
+    expect(token).is.undefined
+  })
+
+  test('Optional value with empty response', async () => {
+    SSMMock.on(GetParameterCommand).resolves({})
+    const token = await config.asyncGet('TOKEN_SECRET_FALSY')
+    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')
+    expect(token).is.not.undefined
+    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')
+    expect(token).is.undefined
+  })
+})
+
+describe(`Required remote environment`, () => {
+  // reset mock
+  beforeEach(() => {
+    SSMMock.reset()
+    config['resetCache']()
+  })
+
+  test('Does not accept sync get', async () => {
+    let err = null
+    try {
+      // @ts-ignore
+      config.get('TOKEN_SECRET')
+    } catch (e) {
+      err = e
+    }
+    expect(err).is.not.null
+    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
+    }
+    expect(err).is.not.null
+    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
+    }
+    expect(err).is.not.null
+    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')
+    expect(token).is.not.undefined
+    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
+    }
+    expect(err).is.not.null
+    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')
+    expect(token).is.undefined
+  })
+})
+
+describe(`Required local environment`, () => {
+  beforeEach(() => {
+    config['resetCache']()
+  })
+
+  test('Required value with null value', async () => {
+    let err = null
+    try {
+      config.get('PATH_FALSY')
+    } catch (e) {
+      err = e
+    }
+    expect(err).is.not.null
+    expect(err?.['message']).is.not.null
+  })
+
+  test('Required value with valid response', async () => {
+    const key = 'PATH'
+    const v = config.get(key)
+    expect(v).is.not.null
+    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)
+    expect(v).is.not.null
+    expect(v).to.be.equals(value)
+    // subsequent fetch
+    SSMMock.reset()
+    SSMMock.on(GetParameterCommand).rejects(new Error('failed!'))
+    const v2 = await config.asyncGet(key)
+    expect(v2).is.not.null
+    expect(v2).to.be.equals(value)
+  })
+})
+
+export {}

package/tests/Config/EnvironmentVar.test.ts

@@ -0,0 +1,214 @@
+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'
+
+const SSMMock = mockClient(SSMClient)
+const SecretsManagerMock = mockClient(SecretsManagerClient)
+
+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({
+        Parameter: {
+          Value: undefined,
+        },
+      })
+      let err = null
+      try {
+        const env = new EnvironmentVar('abc', type, true)
+        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({
+        Parameter: {
+          Value: undefined,
+        },
+      })
+      const env = new EnvironmentVar('abc', type, true)
+      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)
+      const token = await env.resolve()
+      expect(token).is.undefined
+    })
+
+    test('Optional value with valid response', async () => {
+      const value = 'abc'
+      mock.on(command).resolves({
+        Parameter: {
+          Value: value,
+        },
+      })
+      const env = new EnvironmentVar(value, type, true)
+      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)
+      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({
+        Parameter: {
+          Value: undefined,
+        },
+      })
+      let err = null
+      try {
+        const env = new EnvironmentVar('abc', type)
+        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({
+        Parameter: {
+          Value: undefined,
+        },
+      })
+      let err = null
+      try {
+        const env = new EnvironmentVar('abc', type)
+        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)
+        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({
+        Parameter: {
+          Value: value,
+        },
+      })
+      const env = new EnvironmentVar(value, type)
+      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)
+        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)
+    const v = await env.resolve()
+    expect(v).is.undefined
+  })
+
+  test('Optional value with null value', async () => {
+    const env = new EnvironmentVar('PATH123', EnvironmentType.Local, true)
+    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)
+    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)
+    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)
+      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)
+    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'
+
+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/Crypto/JWT.test.ts

@@ -0,0 +1,92 @@
+import { expect } from 'chai'
+
+import JWT from '../../src/Crypto/JWT'
+import { foreignToken, privateKey } from '../Test.utils'
+
+describe('Creates token', () => {
+  const provider = new JWT(privateKey, '7d')
+  test('Creates token without explicity expiration', () => {
+    const token = provider.createToken({ userID: 123 })
+    expect(token).to.be.a('string')
+    expect(token).is.not.null
+  })
+
+  test('Creates token with explicity expiration', () => {
+    const token = provider.createToken({ userID: 123 }, '7d')
+    expect(token).to.be.a('string')
+    expect(token).is.not.null
+  })
+
+  test('Creates token with explicity token override', () => {
+    const token = provider.createToken({ userID: 123 }, '7d', privateKey)
+    expect(token).to.be.a('string')
+    expect(token).is.not.null
+  })
+
+  test('Creates token with explicity token options', () => {
+    const token = provider.createToken({ userID: 123 }, undefined, undefined, {
+      expiresIn: '7d',
+    })
+    expect(token).to.be.a('string')
+    expect(token).is.not.null
+  })
+
+  test('Creates token with no expiration', () => {
+    const localProvider = new JWT(privateKey)
+    const token = localProvider.createToken({ userID: 123 })
+    expect(token).to.be.a('string')
+    expect(token).is.not.null
+  })
+})
+
+describe('Validates token', () => {
+  const provider = new JWT(privateKey, '7d')
+  test('Succeed to validate just created token', () => {
+    // Creates token
+    const token = provider.createToken({ userID: 123 }, '7d', privateKey)
+    expect(token).to.be.a('string')
+    expect(token).is.not.null
+    // Validates token
+    const validationResp = provider.validateToken(token)
+    expect(validationResp).is.not.null
+    expect(validationResp.isValid).is.true
+    expect(validationResp['isExpired']).is.undefined
+    expect(validationResp['decodedToken']).is.not.null
+    expect(validationResp['decodedToken'].userID).to.be.equals(123)
+    expect(validationResp['decodedToken'].exp).to.be.a('number')
+    expect(validationResp['decodedToken'].exp).to.be.above(Date.now() / 1000)
+  })
+
+  test('Fails to validate invalid token', () => {
+    // Creates token
+    const token = provider.createToken({ userID: 123 }, '7d', privateKey)
+    // Validates token
+    const validationResp = provider.validateToken(token + '123')
+    expect(validationResp).is.not.null
+    expect(validationResp.isValid).is.false
+    expect(validationResp['isExpired']).is.undefined
+    expect(validationResp['decodedToken']).to.undefined
+  })
+
+  test('Fails to validate expired token', () => {
+    // Creates token
+    const token = provider.createToken({ userID: 123 }, '-7d', privateKey)
+    // Validates token
+    const validationResp = provider.validateToken(token)
+    expect(validationResp).is.not.null
+    expect(validationResp.isValid).is.false
+    expect(validationResp['isExpired']).is.true
+    expect(validationResp['decodedToken']).to.undefined
+  })
+
+  test('Fails to validate foreign token', () => {
+    // Validates token
+    const validationResp = provider.validateToken(foreignToken)
+    expect(validationResp).is.not.null
+    expect(validationResp.isValid).is.false
+    expect(validationResp['isExpired']).is.undefined
+    expect(validationResp['decodedToken']).to.undefined
+  })
+})
+
+export {}

package/tests/Logger/Logger.test.ts

@@ -0,0 +1,96 @@
+// get console ref and mock before logger import
+const consoleProxy = console
+const mock = jest.spyOn(consoleProxy, 'log')
+// import logger after first ref
+import Logger from '../../src/Logger/Logger'
+// get console reference after logger import
+const transactionID = '123-456'
+
+function setContainerFlag(isContainer: boolean) {
+  if (isContainer) {
+    process.env['HYBRIDLESS_RUNTIME'] = 'true'
+  } else {
+    process.env['HYBRIDLESS_RUNTIME'] = undefined
+  }
+}
+
+function fixLogTypePrefix(logType: string) {
+  if (logType == 'exception') return 'error'
+  if (logType == 'warning') return 'warn'
+  if (logType == 'log') return 'info'
+  return logType
+}
+
+function testLogs(isContainer: boolean, provider?: Logger) {
+  const type = isContainer ? 'container' : 'serverless'
+  const loggerType = !provider ? 'Console' : 'Logger'
+  const localProvider = provider || console
+
+  test(`${type} - ${loggerType} Log - Suppress sensitive info`, async () => {
+    setContainerFlag(isContainer)
+    localProvider.log('TEST', { password: '123' })
+    expect(consoleProxy.log).toHaveBeenNthCalledWith(
+      1,
+      expect.stringContaining((isContainer ? `${transactionID} ` : '') + '[INFO] [Logger.test.ts:')
+    )
+    expect(consoleProxy.log).toHaveBeenNthCalledWith(
+      1,
+      expect.stringContaining('] TEST **SUPPRESSED_SENSITIVE_DATA**')
+    )
+  })
+
+  test(`${type} - ${loggerType} Log - Suppress sensitive info (array)`, async () => {
+    setContainerFlag(isContainer)
+    localProvider.log('TEST2', [{ password: '123' }])
+    expect(consoleProxy.log).toHaveBeenNthCalledWith(
+      1,
+      expect.stringContaining((isContainer ? `${transactionID} ` : '') + '[INFO] [Logger.test.ts:')
+    )
+    expect(consoleProxy.log).toHaveBeenNthCalledWith(
+      1,
+      expect.stringContaining('] TEST2 **SUPPRESSED_SENSITIVE_DATA**')
+    )
+  })
+
+  for (const logType of ['log', 'debug', 'info', 'warn', 'warning', 'error', 'exception']) {
+    test(`${type} - ${loggerType} ${logType}`, async () => {
+      setContainerFlag(isContainer)
+      localProvider[logType](logType.toUpperCase())
+      // alias
+      const logTypePrefix = fixLogTypePrefix(logType)
+      expect(consoleProxy.log).toHaveBeenNthCalledWith(
+        1,
+        expect.stringContaining(
+          (isContainer ? `${transactionID} ` : '') +
+            `[${logTypePrefix.toUpperCase()}] [Logger.test.ts:`
+        )
+      )
+      expect(consoleProxy.log).toHaveBeenNthCalledWith(
+        1,
+        expect.stringContaining(`] ${logType.toUpperCase()}`)
+      )
+    })
+  }
+}
+
+describe('Logger', () => {
+  beforeEach(() => {
+    mock.mockClear()
+  })
+  const provider = new Logger(
+    {
+      logLevel: 'DEBUG',
+      sensitiveFilteringKeywords: true,
+    },
+    transactionID
+  )
+  provider.notGlobalLogger()
+  // Test serverless logs
+  testLogs(false, provider)
+  testLogs(false)
+  // Test container logs
+  testLogs(true, provider)
+  testLogs(true)
+})
+
+export {}