@creator.co/wapi 1.7.1-alpha4 → 1.7.1

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

@@ -0,0 +1,90 @@
+import { jest } from '@jest/globals'
+
+import Redis from '../../src/Cache/Redis'
+
+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'
+
+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
+    )
+  })
+})

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'
+import { SampleConfig } from '../Test.utils'
+
+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,250 @@
+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({
+        ...(type == EnvironmentType.PlainRemote
+          ? {
+              Parameter: {
+                Value: undefined,
+              },
+            }
+          : {
+              SecretString: 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({
+        ...(type == EnvironmentType.PlainRemote
+          ? {
+              Parameter: {
+                Value: undefined,
+              },
+            }
+          : {
+              SecretString: 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({
+        ...(type == EnvironmentType.PlainRemote
+          ? {
+              Parameter: {
+                Value: value,
+              },
+            }
+          : {
+              SecretString: 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({
+        ...(type == EnvironmentType.PlainRemote
+          ? {
+              Parameter: {
+                Value: undefined,
+              },
+            }
+          : {
+              SecretString: 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({
+        ...(type == EnvironmentType.PlainRemote
+          ? {
+              Parameter: {
+                Value: undefined,
+              },
+            }
+          : {
+              SecretString: 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({
+        ...(type == EnvironmentType.PlainRemote
+          ? {
+              Parameter: {
+                Value: value,
+              },
+            }
+          : {
+              SecretString: 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 {}