@sudoplatform/sudo-common 7.0.2 → 8.0.0

package/github/test/unit/configurationManager/defaultConfigurationManager.spec.ts

@@ -1,506 +0,0 @@
-import { DefaultConfigurationManager } from '../../../src/configurationManager/defaultConfigurationManager'
-import * as t from 'io-ts'
-import { ConfigurationSetNotFoundError } from '../../../src/errors/error'
-import AWS from 'aws-sdk'
-
-describe('configuration manager', () => {
-  const config = {
-    federatedSignIn: {
-      appClientId: '120q904mra9d5l4psmvdbrgm49',
-      signInRedirectUri: 'http://localhost:3000/callback',
-      signOutRedirectUri: 'http://localhost:3000/',
-      webDomain: 'id-dev-fsso-sudoplatform.auth.us-east-1.amazoncognito.com',
-      identityProvider: 'Auth0',
-    },
-    apiService: {
-      apiUrl:
-        'https://xy7zw5ys7rahrponv7h26vjn6y.appsync-api.us-east-1.amazonaws.com/graphql',
-      region: 'us-east-1',
-    },
-    identityService: {
-      region: 'us-east-1',
-      poolId: 'us-east-1_ZiPDToF73',
-      clientId: '120q904mra9d5l4psmvdbrgm49',
-      identityPoolId: 'us-east-1:8fe6d8ed-cd77-4622-b1bb-3f0c147638ad',
-      apiUrl:
-        'https://mqn7cjrzcrd75jpsma3xw4744a.appsync-api.us-east-1.amazonaws.com/graphql',
-      apiKey: 'da2-xejsa343urfifmzkycmz3rqdom',
-      bucket: 'ids-userdata-id-dev-fsso-userdatabucket2d841c35-j9x47k5042fk',
-      transientBucket:
-        'ids-userdata-id-dev-fsso-transientuserdatabucket0-1enoeyoho1sjl',
-    },
-    secureVaultService: {
-      region: 'us-east-1',
-      poolId: 'us-east-1_6NalHLdlq',
-      clientId: 'pcg1ma18cluamqrif79viaj04',
-      apiUrl:
-        'https://u2ysyzwojzaahbsq5toulhdt4e.appsync-api.us-east-1.amazonaws.com/graphql',
-      pbkdfRounds: 100000,
-    },
-  }
-
-  const IdentityServiceConfig = t.type({
-    region: t.string,
-    poolId: t.string,
-    clientId: t.string,
-    apiUrl: t.string,
-  })
-
-  const ApiServiceConfig = t.type({
-    apiUrl: t.string,
-    region: t.string,
-  })
-
-  const SdkConfig = t.type({
-    identityService: IdentityServiceConfig,
-    apiService: ApiServiceConfig,
-  })
-
-  type IdentityServiceConfig = t.TypeOf<typeof IdentityServiceConfig>
-  type ApiServiceConfig = t.TypeOf<typeof ApiServiceConfig>
-  type SdkConfig = t.TypeOf<typeof SdkConfig>
-
-  describe('getConfigSet', () => {
-    it('should return entire config set when empty namespace supplied', () => {
-      const configSet = DefaultConfigurationManager.getInstance()
-        .setConfig(JSON.stringify(config))
-        .getConfigSet()
-
-      expect(configSet).toStrictEqual(config)
-    })
-
-    it('should return subset of configuration when matching namespace supplied', () => {
-      const expected = {
-        region: 'us-east-1',
-        poolId: 'us-east-1_ZiPDToF73',
-        clientId: '120q904mra9d5l4psmvdbrgm49',
-        identityPoolId: 'us-east-1:8fe6d8ed-cd77-4622-b1bb-3f0c147638ad',
-        apiUrl:
-          'https://mqn7cjrzcrd75jpsma3xw4744a.appsync-api.us-east-1.amazonaws.com/graphql',
-        apiKey: 'da2-xejsa343urfifmzkycmz3rqdom',
-        bucket: 'ids-userdata-id-dev-fsso-userdatabucket2d841c35-j9x47k5042fk',
-        transientBucket:
-          'ids-userdata-id-dev-fsso-transientuserdatabucket0-1enoeyoho1sjl',
-      }
-
-      const configSet = DefaultConfigurationManager.getInstance()
-        .setConfig(JSON.stringify(config))
-        .getConfigSet('identityService')
-
-      expect(configSet).toStrictEqual(expected)
-    })
-
-    it('should return nothing when no matching namespace supplied', () => {
-      const configSet = DefaultConfigurationManager.getInstance()
-        .setConfig(JSON.stringify(config))
-        .getConfigSet('randomNoMatchingNamespace')
-
-      expect(configSet).toBeFalsy()
-    })
-  })
-
-  describe('bindConfigSet<T>', () => {
-    it('should find config set then bind to given type', () => {
-      const result = DefaultConfigurationManager.getInstance()
-        .setConfig(JSON.stringify(config))
-        .bindConfigSet<IdentityServiceConfig>(
-          IdentityServiceConfig,
-          'identityService',
-        )
-
-      expect(result).toBeTruthy()
-      expect(result['apiUrl']).toBeTruthy()
-    })
-
-    it('should throw when configuration set not found', () => {
-      expect(() => {
-        DefaultConfigurationManager.getInstance()
-          .setConfig(JSON.stringify(config))
-          .bindConfigSet<IdentityServiceConfig>(
-            IdentityServiceConfig,
-            'randomNamespace',
-          )
-      }).toThrow(ConfigurationSetNotFoundError)
-    })
-
-    it('should still bind when no nampespace provided', () => {
-      const result = DefaultConfigurationManager.getInstance()
-        .setConfig(JSON.stringify(config))
-        .bindConfigSet<SdkConfig>(SdkConfig)
-
-      expect(result).toBeTruthy()
-      expect(result['identityService'].apiUrl).toBeTruthy()
-    })
-  })
-
-  describe('validateConfig', () => {
-    it('should return empty result when config not set', async () => {
-      const manager = DefaultConfigurationManager.getInstance()
-
-      await expect(manager.validateConfig()).resolves.toEqual({
-        deprecated: [],
-        incompatible: [],
-      })
-    })
-
-    it('should return empty result when config does not have identity service config', async () => {
-      const badConfig = {
-        bad: 'bad',
-      }
-
-      const manager = DefaultConfigurationManager.getInstance().setConfig(
-        JSON.stringify(badConfig),
-      )
-
-      await expect(manager.validateConfig()).resolves.toEqual({
-        deprecated: [],
-        incompatible: [],
-      })
-    })
-
-    it('should return empty result when config does not have service info bucket name', async () => {
-      const badConfig = {
-        identityService: {
-          region: 'dummy_region',
-        },
-      }
-
-      const manager = DefaultConfigurationManager.getInstance().setConfig(
-        JSON.stringify(badConfig),
-      )
-
-      await expect(manager.validateConfig()).resolves.toEqual({
-        deprecated: [],
-        incompatible: [],
-      })
-    })
-
-    it('should return empty result when service info document does not have .json extension', async () => {
-      const config = {
-        identityService: {
-          region: 'us-east-1',
-          serviceInfoBucket: 'dummy_bucket',
-        },
-      }
-
-      const manager = DefaultConfigurationManager.getInstance().setConfig(
-        JSON.stringify(config),
-      )
-
-      jest.mock('aws-sdk')
-
-      AWS.Service.prototype.makeUnauthenticatedRequest = jest
-        .fn()
-        .mockImplementation((operation) => {
-          if (operation === 'listObjects') {
-            return {
-              promise() {
-                return Promise.resolve({
-                  Contents: [{ Key: 'identityService' }],
-                })
-              },
-            }
-          }
-        })
-
-      await expect(manager.validateConfig()).resolves.toEqual({
-        deprecated: [],
-        incompatible: [],
-      })
-    })
-
-    it('should return empty result when service info document does not match the client config', async () => {
-      const config = {
-        identityService: {
-          region: 'us-east-1',
-          serviceInfoBucket: 'dummy_bucket',
-        },
-      }
-
-      const manager = DefaultConfigurationManager.getInstance().setConfig(
-        JSON.stringify(config),
-      )
-
-      jest.mock('aws-sdk')
-
-      AWS.Service.prototype.makeUnauthenticatedRequest = jest
-        .fn()
-        .mockImplementation((operation) => {
-          if (operation === 'listObjects') {
-            return {
-              promise() {
-                return Promise.resolve({
-                  Contents: [{ Key: 'sudoService' }],
-                })
-              },
-            }
-          }
-        })
-
-      await expect(manager.validateConfig()).resolves.toEqual({
-        deprecated: [],
-        incompatible: [],
-      })
-    })
-
-    it('should return empty result when there is no service info document', async () => {
-      const config = {
-        identityService: {
-          region: 'us-east-1',
-          serviceInfoBucket: 'dummy_bucket',
-        },
-      }
-
-      const manager = DefaultConfigurationManager.getInstance().setConfig(
-        JSON.stringify(config),
-      )
-
-      jest.mock('aws-sdk')
-
-      AWS.Service.prototype.makeUnauthenticatedRequest = jest
-        .fn()
-        .mockImplementation((operation) => {
-          if (operation === 'listObjects') {
-            return {
-              promise() {
-                return Promise.resolve({
-                  Contents: [],
-                })
-              },
-            }
-          }
-        })
-
-      await expect(manager.validateConfig()).resolves.toEqual({
-        deprecated: [],
-        incompatible: [],
-      })
-    })
-
-    it('should return incompatible service info if less than min version', async () => {
-      const config = {
-        identityService: {
-          version: 1,
-          region: 'us-east-1',
-          serviceInfoBucket: 'dummy_bucket',
-        },
-      }
-
-      const serviceInfo = {
-        identityService: {
-          minVersion: 2,
-        },
-      }
-
-      const manager = DefaultConfigurationManager.getInstance().setConfig(
-        JSON.stringify(config),
-      )
-
-      jest.mock('aws-sdk')
-
-      AWS.Service.prototype.makeUnauthenticatedRequest = jest
-        .fn()
-        .mockImplementation((operation, params) => {
-          if (operation === 'listObjects') {
-            return {
-              promise() {
-                return Promise.resolve({
-                  Contents: [{ Key: 'identityService.json' }],
-                })
-              },
-            }
-          } else if (
-            params.Key === 'identityService.json' &&
-            params.Bucket === 'dummy_bucket'
-          ) {
-            return {
-              promise() {
-                return Promise.resolve({ Body: JSON.stringify(serviceInfo) })
-              },
-            }
-          }
-        })
-
-      await expect(manager.validateConfig()).resolves.toEqual({
-        deprecated: [],
-        incompatible: [
-          {
-            configVersion: 1,
-            minSupportedVersion: 2,
-            name: 'identityService',
-          },
-        ],
-      })
-    })
-
-    it('should return empty result if greater than min version', async () => {
-      const config = {
-        identityService: {
-          version: 3,
-          region: 'us-east-1',
-          serviceInfoBucket: 'dummy_bucket',
-        },
-      }
-
-      const serviceInfo = {
-        identityService: {
-          minVersion: 2,
-        },
-      }
-
-      const manager = DefaultConfigurationManager.getInstance().setConfig(
-        JSON.stringify(config),
-      )
-
-      jest.mock('aws-sdk')
-
-      AWS.Service.prototype.makeUnauthenticatedRequest = jest
-        .fn()
-        .mockImplementation((operation, params) => {
-          if (operation === 'listObjects') {
-            return {
-              promise() {
-                return Promise.resolve({
-                  Contents: [{ Key: 'identityService.json' }],
-                })
-              },
-            }
-          } else if (
-            params.Key === 'identityService.json' &&
-            params.Bucket === 'dummy_bucket'
-          ) {
-            return {
-              promise() {
-                return Promise.resolve({ Body: JSON.stringify(serviceInfo) })
-              },
-            }
-          }
-        })
-
-      await expect(manager.validateConfig()).resolves.toEqual({
-        deprecated: [],
-        incompatible: [],
-      })
-    })
-
-    it('should return deprecated service info if equal to deprecated version', async () => {
-      const config = {
-        identityService: {
-          version: 2,
-          region: 'us-east-1',
-          serviceInfoBucket: 'dummy_bucket',
-        },
-      }
-
-      const serviceInfo = {
-        identityService: {
-          minVersion: 1,
-          deprecated: 2,
-          deprecationGrace: 1,
-        },
-      }
-
-      const manager = DefaultConfigurationManager.getInstance().setConfig(
-        JSON.stringify(config),
-      )
-
-      jest.mock('aws-sdk')
-
-      AWS.Service.prototype.makeUnauthenticatedRequest = jest
-        .fn()
-        .mockImplementation((operation, params) => {
-          if (operation === 'listObjects') {
-            return {
-              promise() {
-                return Promise.resolve({
-                  Contents: [{ Key: 'identityService.json' }],
-                })
-              },
-            }
-          } else if (
-            params.Key === 'identityService.json' &&
-            params.Bucket === 'dummy_bucket'
-          ) {
-            return {
-              promise() {
-                return Promise.resolve({ Body: JSON.stringify(serviceInfo) })
-              },
-            }
-          }
-        })
-
-      await expect(manager.validateConfig()).resolves.toEqual({
-        deprecated: [
-          {
-            configVersion: 2,
-            minSupportedVersion: 1,
-            deprecatedVersion: 2,
-            deprecationGrace: new Date(1),
-            name: 'identityService',
-          },
-        ],
-        incompatible: [],
-      })
-    })
-
-    it('should return deprecated service info if less than deprecated version', async () => {
-      const config = {
-        identityService: {
-          version: 2,
-          region: 'us-east-1',
-          serviceInfoBucket: 'dummy_bucket',
-        },
-      }
-
-      const serviceInfo = {
-        identityService: {
-          minVersion: 1,
-          deprecated: 3,
-          deprecationGrace: 1,
-        },
-      }
-
-      const manager = DefaultConfigurationManager.getInstance().setConfig(
-        JSON.stringify(config),
-      )
-
-      jest.mock('aws-sdk')
-
-      AWS.Service.prototype.makeUnauthenticatedRequest = jest
-        .fn()
-        .mockImplementation((operation, params) => {
-          if (operation === 'listObjects') {
-            return {
-              promise() {
-                return Promise.resolve({
-                  Contents: [{ Key: 'identityService.json' }],
-                })
-              },
-            }
-          } else if (
-            params.Key === 'identityService.json' &&
-            params.Bucket === 'dummy_bucket'
-          ) {
-            return {
-              promise() {
-                return Promise.resolve({ Body: JSON.stringify(serviceInfo) })
-              },
-            }
-          }
-        })
-
-      await expect(manager.validateConfig()).resolves.toEqual({
-        deprecated: [
-          {
-            configVersion: 2,
-            minSupportedVersion: 1,
-            deprecatedVersion: 3,
-            deprecationGrace: new Date(1),
-            name: 'identityService',
-          },
-        ],
-        incompatible: [],
-      })
-    })
-  })
-})

package/github/test/unit/errors/error.spec.ts

@@ -1,115 +0,0 @@
-import {
-  AccountLockedError,
-  AppSyncNetworkError,
-  IllegalArgumentError,
-  InsufficientEntitlementsError,
-  InvalidTokenError,
-  isAppSyncNetworkError,
-  LimitExceededError,
-  mapGraphQLToClientError,
-  mapNetworkErrorToClientError,
-  NoEntitlementsError,
-  NotAuthorizedError,
-  RequestFailedError,
-  ServiceError,
-  UnknownGraphQLError,
-} from '../../../src/errors/error'
-
-describe('error', () => {
-  const message = 'graphql-error'
-  describe('mapGraphQLToClientError', () => {
-    it.each`
-      code                                            | error
-      ${'sudoplatform.InsufficientEntitlementsError'} | ${new InsufficientEntitlementsError()}
-      ${'sudoplatform.AccountLockedError'}            | ${new AccountLockedError()}
-      ${'sudoplatform.InvalidTokenError'}             | ${new InvalidTokenError()}
-      ${'sudoplatform.InvalidArgumentError'}          | ${new IllegalArgumentError()}
-      ${'sudoplatform.NoEntitlementsError'}           | ${new NoEntitlementsError()}
-      ${'sudoplatform.ServiceError'}                  | ${new ServiceError(message)}
-      ${'sudoplatform.LimitExceededError'}            | ${new LimitExceededError()}
-    `('should map common error $code properly', ({ code, error }) => {
-      expect(
-        mapGraphQLToClientError({
-          message,
-          errorType: code,
-        }),
-      ).toEqual(error)
-    })
-
-    it('should map an unrecognized error to UnknownGraphQLError', () => {
-      const unrecognized = {
-        message,
-        errorType: 'unrecognized',
-      }
-      expect(mapGraphQLToClientError(unrecognized)).toEqual(
-        new UnknownGraphQLError(unrecognized),
-      )
-    })
-  })
-
-  describe('isAppSyncNetworkError', () => {
-    const normalNetworkError = {
-      name: 'name',
-      message: 'message',
-      networkError: {
-        name: 'name',
-        message: 'message',
-        statusCode: 401,
-      },
-    }
-
-    const noStatusCodeNetworkError = {
-      name: 'name',
-      message: 'message',
-      networkError: {
-        name: 'name',
-        message: 'message',
-      },
-    }
-
-    const nullNetworkError = {
-      name: 'name',
-      message: 'message',
-      networkError: null,
-    }
-
-    const undefinedNetworkError = {
-      name: 'name',
-      message: 'message',
-    }
-
-    it.each`
-      error                       | networkError
-      ${normalNetworkError}       | ${true}
-      ${noStatusCodeNetworkError} | ${true}
-      ${undefinedNetworkError}    | ${false}
-      ${nullNetworkError}         | ${false}
-    `('should return $networkError for $error', ({ error, networkError }) => {
-      expect(isAppSyncNetworkError(error)).toEqual(networkError)
-    })
-  })
-
-  describe('mapNetworkErrorToClientError', () => {
-    it.each`
-      statusCode   | error
-      ${401}       | ${new NotAuthorizedError()}
-      ${500}       | ${'default'}
-      ${undefined} | ${'default'}
-    `('maps network error $statusCode to $error', ({ statusCode, error }) => {
-      const networkError: AppSyncNetworkError = {
-        name: 'error ' + statusCode,
-        message: 'error ' + statusCode,
-        networkError: {
-          name: 'error ' + statusCode,
-          message: 'error ' + statusCode,
-          statusCode,
-        },
-      }
-      if (error === 'default') {
-        error = new RequestFailedError(networkError, statusCode)
-      }
-
-      expect(mapNetworkErrorToClientError(networkError)).toEqual(error)
-    })
-  })
-})

package/github/test/unit/keyType.spec.ts

@@ -1,54 +0,0 @@
-import { isLeft, isRight } from 'fp-ts/lib/Either'
-import {
-  KeyArchiveKeyType,
-  KeyArchiveKeyTypeCodec,
-} from '../../src/sudoKeyArchive/keyType'
-
-describe('KeyArchiveKeyType tests', () => {
-  describe('KeyArchiveKeyTypeCodec', () => {
-    it.each`
-      input                             | encoded
-      ${KeyArchiveKeyType.Password}     | ${'password'}
-      ${KeyArchiveKeyType.PrivateKey}   | ${'privateKey'}
-      ${KeyArchiveKeyType.PublicKey}    | ${'publicKey'}
-      ${KeyArchiveKeyType.SymmetricKey} | ${'symmetricKey'}
-    `('should encode $input to $encoded', ({ input, encoded }) => {
-      expect(KeyArchiveKeyTypeCodec.encode(input)).toEqual(encoded)
-    })
-
-    it.each`
-      input              | decoded
-      ${'password'}      | ${KeyArchiveKeyType.Password}
-      ${'privateKey'}    | ${KeyArchiveKeyType.PrivateKey}
-      ${'privatekey'}    | ${KeyArchiveKeyType.PrivateKey}
-      ${'private_key'}   | ${KeyArchiveKeyType.PrivateKey}
-      ${'publicKey'}     | ${KeyArchiveKeyType.PublicKey}
-      ${'publickey'}     | ${KeyArchiveKeyType.PublicKey}
-      ${'public_key'}    | ${KeyArchiveKeyType.PublicKey}
-      ${'symmetricKey'}  | ${KeyArchiveKeyType.SymmetricKey}
-      ${'symmetrickey'}  | ${KeyArchiveKeyType.SymmetricKey}
-      ${'symmetric_key'} | ${KeyArchiveKeyType.SymmetricKey}
-    `('should decode $input to $decoded', ({ input, decoded }) => {
-      const result = KeyArchiveKeyTypeCodec.decode(input)
-      expect(isRight(result)).toEqual(true)
-      if (!isRight(result)) {
-        fail('result unexpectedly not right')
-      }
-      expect(result.right).toEqual(decoded)
-    })
-
-    it.each`
-      invalid
-      ${'password_'}
-      ${'symmetric__key'}
-      ${'foo'}
-      ${'1'}
-      ${1}
-      ${null}
-      ${undefined}
-    `('it should detect $invalid as invalid', ({ invalid }) => {
-      const result = KeyArchiveKeyTypeCodec.decode(invalid)
-      expect(isLeft(result)).toEqual(true)
-    })
-  })
-})