@sudoplatform/sudo-common 5.9.0 → 6.0.1

package/src/sudoKeyManager/sudoKeyManager.ts

@@ -63,6 +63,13 @@ export interface SudoKeyManager {
    */
   getSymmetricKey(name: string): Promise<ArrayBuffer | undefined>
 
+  /**
+   * Checks to see if the specified symmetric key exists.
+   *
+   * @param name The name of the symmetric key.
+   */
+  doesSymmetricKeyExists(name: string): Promise<boolean>
+
   /**
    * Deletes a symmetric key from the secure store.
    *
@@ -87,6 +94,13 @@ export interface SudoKeyManager {
    */
   getPrivateKey(name: string): Promise<ArrayBuffer | undefined>
 
+  /**
+   * Checks to see if the specified private key exists.
+   *
+   * @param name The name of the private key.
+   */
+  doesPrivateKeyExists(name: string): Promise<boolean>
+
   /**
    * Adds a public key to the secure store.
    *
@@ -379,6 +393,10 @@ export class DefaultSudoKeyManager implements SudoKeyManager {
     return this.sudoCryptoProvider.getSymmetricKey(name)
   }
 
+  public doesSymmetricKeyExists(name: string): Promise<boolean> {
+    return this.sudoCryptoProvider.doesSymmetricKeyExists(name)
+  }
+
   public deleteSymmetricKey(name: string): Promise<void> {
     return this.sudoCryptoProvider.deleteSymmetricKey(name)
   }
@@ -395,6 +413,10 @@ export class DefaultSudoKeyManager implements SudoKeyManager {
     return this.sudoCryptoProvider.getPrivateKey(name)
   }
 
+  public doesPrivateKeyExists(name: string): Promise<boolean> {
+    return this.sudoCryptoProvider.doesPrivateKeyExists(name)
+  }
+
   public addPublicKey(key: ArrayBuffer, name: string): Promise<void> {
     return this.sudoCryptoProvider.addPublicKey(key, name)
   }

package/test/logging/logger.spec.ts

@@ -57,4 +57,126 @@ describe('Logging utility test suite', () => {
       ),
     )
   })
+
+  it('should log with logger name at level set by environment variables', () => {
+    process.env.PROJECT_NAME = 'DummyProject'
+    process.env.LOG_LEVEL = 'debug'
+    const logger = new DefaultLogger()
+    console.log = jest.fn()
+    logger.debug('logger name at level set by environment variables')
+    expect(console.log).toBeCalledTimes(1)
+    expect(console.log).toBeCalledWith(
+      expect.stringContaining(
+        'DEBUG: DummyProject: logger name at level set by environment variables',
+      ),
+    )
+  })
+
+  it.each`
+    level      | traceEnabled
+    ${'trace'} | ${true}
+    ${'debug'} | ${false}
+    ${'info'}  | ${false}
+    ${'warn'}  | ${false}
+    ${'error'} | ${false}
+    ${'fatal'} | ${false}
+  `(
+    'should return trace enabled $traceEnabled when level is $level',
+    ({ level, traceEnabled }) => {
+      process.env.PROJECT_NAME = 'DummyProject'
+      process.env.LOG_LEVEL = level
+      const logger = new DefaultLogger()
+      expect(logger.trace()).toEqual(traceEnabled)
+    },
+  )
+
+  it.each`
+    level      | debugEnabled
+    ${'trace'} | ${true}
+    ${'debug'} | ${true}
+    ${'info'}  | ${false}
+    ${'warn'}  | ${false}
+    ${'error'} | ${false}
+    ${'fatal'} | ${false}
+  `(
+    'should return debug enabled $debugEnabled when level is $level',
+    ({ level, debugEnabled }) => {
+      process.env.PROJECT_NAME = 'DummyProject'
+      process.env.LOG_LEVEL = level
+      const logger = new DefaultLogger()
+      expect(logger.debug()).toEqual(debugEnabled)
+    },
+  )
+
+  it.each`
+    level      | infoEnabled
+    ${'trace'} | ${true}
+    ${'debug'} | ${true}
+    ${'info'}  | ${true}
+    ${'warn'}  | ${false}
+    ${'error'} | ${false}
+    ${'fatal'} | ${false}
+  `(
+    'should return info enabled $infoEnabled when level is $level',
+    ({ level, infoEnabled }) => {
+      process.env.PROJECT_NAME = 'DummyProject'
+      process.env.LOG_LEVEL = level
+      const logger = new DefaultLogger()
+      expect(logger.info()).toEqual(infoEnabled)
+    },
+  )
+
+  it.each`
+    level      | warnEnabled
+    ${'trace'} | ${true}
+    ${'debug'} | ${true}
+    ${'info'}  | ${true}
+    ${'warn'}  | ${true}
+    ${'error'} | ${false}
+    ${'fatal'} | ${false}
+  `(
+    'should return warn enabled $warnEnabled when level is $level',
+    ({ level, warnEnabled }) => {
+      process.env.PROJECT_NAME = 'DummyProject'
+      process.env.LOG_LEVEL = level
+      const logger = new DefaultLogger()
+      expect(logger.warn()).toEqual(warnEnabled)
+    },
+  )
+
+  it.each`
+    level      | errorEnabled
+    ${'trace'} | ${true}
+    ${'debug'} | ${true}
+    ${'info'}  | ${true}
+    ${'warn'}  | ${true}
+    ${'error'} | ${true}
+    ${'fatal'} | ${false}
+  `(
+    'should return error enabled $errorEnabled when level is $level',
+    ({ level, errorEnabled }) => {
+      process.env.PROJECT_NAME = 'DummyProject'
+      process.env.LOG_LEVEL = level
+      const logger = new DefaultLogger()
+      expect(logger.error()).toEqual(errorEnabled)
+    },
+  )
+
+  it.each`
+    level      | fatalEnabled
+    ${'trace'} | ${true}
+    ${'debug'} | ${true}
+    ${'info'}  | ${true}
+    ${'warn'}  | ${true}
+    ${'error'} | ${true}
+    ${'fatal'} | ${true}
+  `(
+    'should return fatal enabled $fatalEnabled when level is $level',
+    ({ level, fatalEnabled }) => {
+      process.env.PROJECT_NAME = 'DummyProject'
+      process.env.LOG_LEVEL = level
+      const logger = new DefaultLogger()
+      expect(logger.fatal()).toEqual(fatalEnabled)
+    },
+  )
 })

package/test/sudoKeyManager/sudoKeyManager.spec.ts

@@ -177,6 +177,24 @@ describe('DefaultSudoKeyManager', () => {
     })
   })
 
+  describe('doesSymmetricKeyExists', () => {
+    it('should call crypto provider doesSymmetricKeyExists', async () => {
+      when(
+        sudoCryptoProviderMock.doesSymmetricKeyExists(anything()),
+      ).thenResolve(true)
+
+      await expect(
+        sudoKeyManager.doesSymmetricKeyExists('VpnKey'),
+      ).resolves.toEqual(true)
+      const [actualKey] = capture(
+        sudoCryptoProviderMock.doesSymmetricKeyExists,
+      ).first()
+      expect(actualKey).toStrictEqual('VpnKey')
+
+      verify(sudoCryptoProviderMock.doesSymmetricKeyExists(anything())).once()
+    })
+  })
+
   describe('deleteSymmetricKey', () => {
     it('should call crypto provider deleteSymmetricKey', async () => {
       when(sudoCryptoProviderMock.deleteSymmetricKey(anything())).thenResolve()
@@ -263,6 +281,25 @@ describe('DefaultSudoKeyManager', () => {
     })
   })
 
+  describe('doesPrivateKeyExists', () => {
+    it('should call crypto provider doesPrivateKeyExists', async () => {
+      when(sudoCryptoProviderMock.doesPrivateKeyExists(anything())).thenResolve(
+        true,
+      )
+
+      await expect(
+        sudoKeyManager.doesPrivateKeyExists('VpnKeyPair'),
+      ).resolves.toBeTruthy()
+
+      const [actualKeyName] = capture(
+        sudoCryptoProviderMock.doesPrivateKeyExists,
+      ).first()
+      expect(actualKeyName).toStrictEqual('VpnKeyPair')
+
+      verify(sudoCryptoProviderMock.doesPrivateKeyExists(anything())).once()
+    })
+  })
+
   describe('addPublicKey', () => {
     it('should call crypto provider addPublicKey', async () => {
       when(