@creator.co/wapi 1.7.1-alpha1 → 1.7.1-alpha3

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

@@ -1,90 +0,0 @@
-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

@@ -1,100 +0,0 @@
-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

@@ -1,205 +0,0 @@
-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

@@ -1,250 +0,0 @@
-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 {}