@rockcarver/frodo-lib 0.17.2-0 → 0.17.3

package/esm/api/SecretsApi.test.mjs

@@ -1,261 +1,268 @@
-import axios from 'axios';
-import MockAdapter from 'axios-mock-adapter';
-import { SecretsRaw, state } from '../index';
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const mock = new MockAdapter(axios);
-state.setHost('https://openam-frodo-dev.forgeblocks.com/am');
-state.setRealm('alpha');
-state.setCookieName('cookieName');
-state.setCookieValue('cookieValue');
-describe('SecretsApi - getSecrets()', () => {
-  test('getSecrets() 1: Get all secrets - success', async () => {
-    const mockResponse = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../test/mocks/SecretsApi/getSecrets/secrets.json'), 'utf8'));
-    mock.onGet('https://openam-frodo-dev.forgeblocks.com/environment/secrets').reply(200, mockResponse);
-    const response = await SecretsRaw.getSecrets();
-    expect(response).toBeTruthy();
-    expect(response).toMatchObject(mockResponse);
-  });
-  test('getSecrets() 2: Get all secrets - error', async () => {
-    const mockResponse = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../test/mocks/SecretsApi/getSecrets/error.json'), 'utf8'));
-    mock.onGet('https://openam-frodo-dev.forgeblocks.com/environment/secrets').reply(500, mockResponse);
-    expect.assertions(2);
-    try {
-      await SecretsRaw.getSecrets();
-    } catch (error) {
-      // console.dir(error);
-      expect(error).toBeTruthy();
-      expect(error).toMatchSnapshot();
+/**
+ * To record and update snapshots, you must perform 3 steps in order:
+ *
+ * 1. Record API responses & update ESM snapshots
+ *
+ *    To record and update ESM snapshots, you must call the test:record
+ *    script and override all the connection state variables required
+ *    to connect to the env to record from:
+ *
+ *        FRODO_DEBUG=1 FRODO_HOST=volker-dev npm run test:record SecretsApi
+ *
+ *    The above command assumes that you have a connection profile for
+ *    'volker-dev' on your development machine.
+ *
+ * 2. Update CJS snapshots
+ *
+ *    After recording, the ESM snapshots will already be updated as that happens
+ *    in one go, but you musty manually update the CJS snapshots by running:
+ *
+ *        FRODO_DEBUG=1 npm run test:update SecretsApi
+ *
+ * 3. Test your changes
+ *
+ *    If 1 and 2 didn't produce any errors, you are ready to run the tests in
+ *    replay mode and make sure they all succeed as well:
+ *
+ *        npm run test SecretsApi
+ *
+ * Note: FRODO_DEBUG=1 is optional and enables debug logging for some output
+ * in case things don't function as expected
+ */
+import { jest } from '@jest/globals';
+import { SecretsRaw } from '../index';
+import { autoSetupPolly } from '../utils/AutoSetupPolly';
+
+// Increase timeout for this test as pipeline keeps failing with error:
+// Timeout - Async callback was not invoked within the 5000 ms timeout specified by jest.setTimeout.
+jest.setTimeout(30000);
+autoSetupPolly();
+describe('SecretsApi', () => {
+  const secret1 = {
+    name: 'esv-frodo-test-secret1',
+    value: 'Frodo Test Secret One Value',
+    description: 'Frodo Test Secret One Description'
+  };
+  const secret2 = {
+    name: 'esv-frodo-test-secret2',
+    value: 'Frodo Test Secret Two Value',
+    description: 'Frodo Test Secret Two Description'
+  };
+  const secret3 = {
+    name: 'esv-frodo-test-secret3',
+    value: 'Frodo Test Secret Three Value',
+    description: 'Frodo Test Secret Three Description'
+  };
+  const secret4 = {
+    name: 'esv-frodo-test-secret4',
+    value: 'Frodo Test Secret Four Value',
+    description: 'Frodo Test Secret Four Description',
+    encoding: 'generic',
+    placeholders: true
+  };
+  // in recording mode, setup test data before recording
+  beforeAll(async () => {
+    if (process.env.FRODO_POLLY_MODE === 'record') {
+      // setup secret1 - delete if exists, then create
+      try {
+        await SecretsRaw.getSecret(secret1.name);
+        await SecretsRaw.deleteSecret(secret1.name);
+      } catch (error) {
+        // ignore
+      } finally {
+        await SecretsRaw.putSecret(secret1.name, secret1.value, secret1.description);
+        await SecretsRaw.createNewVersionOfSecret(secret1.name, secret1.value + ' Version 2');
+        await SecretsRaw.createNewVersionOfSecret(secret1.name, secret1.value + ' Version 3');
+        await SecretsRaw.setStatusOfVersionOfSecret(secret1.name, '2', SecretsRaw.VersionOfSecretStatus.DISABLED);
+      }
+      // setup secret2 - delete if exists, then create
+      try {
+        await SecretsRaw.getSecret(secret2.name);
+        await SecretsRaw.deleteSecret(secret2.name);
+      } catch (error) {
+        // ignore
+      } finally {
+        await SecretsRaw.putSecret(secret2.name, secret2.value, secret2.description);
+        await SecretsRaw.createNewVersionOfSecret(secret2.name, secret2.value + ' Version 2');
+        await SecretsRaw.createNewVersionOfSecret(secret2.name, secret2.value + ' Version 3');
+      }
+      // setup secret3 - delete if exists, then create
+      try {
+        await SecretsRaw.getSecret(secret3.name);
+        await SecretsRaw.deleteSecret(secret3.name);
+      } catch (error) {
+        // ignore
+      } finally {
+        await SecretsRaw.putSecret(secret3.name, secret3.value, secret3.description);
+      }
+      // setup secret4 - delete if exists
+      try {
+        await SecretsRaw.getSecret(secret4.name);
+        await SecretsRaw.deleteSecret(secret4.name);
+      } catch (error) {
+        // ignore
+      }
     }
   });
-});
-describe('SecretsApi - getSecret()', () => {
-  test('getSecret() 1: Get existing secret: esv-volkerstestsecret1', async () => {
-    const mockResponse = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../test/mocks/SecretsApi/getSecret/esv-volkerstestsecret1.json'), 'utf8'));
-    mock.onGet('https://openam-frodo-dev.forgeblocks.com/environment/secrets/esv-volkerstestsecret1').reply(200, mockResponse);
-    const response = await SecretsRaw.getSecret('esv-volkerstestsecret1');
-    expect(response).toBeTruthy();
-    expect(response).toMatchObject(mockResponse);
-  });
-  test('getSecret() 2: Get non-existing secret: esv-does-not-exist', async () => {
-    const mockResponse = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../test/mocks/SecretsApi/getSecret/esv-does-not-exist.json'), 'utf8'));
-    mock.onGet('https://openam-frodo-dev.forgeblocks.com/environment/secrets/esv-does-not-exist').reply(404, mockResponse);
-    expect.assertions(2);
-    try {
-      await SecretsRaw.getSecret('esv-does-not-exist');
-    } catch (error) {
-      // console.dir(error);
-      expect(error).toBeTruthy();
-      expect(error).toMatchSnapshot();
+  // in recording mode, remove test data after recording
+  afterAll(async () => {
+    if (process.env.FRODO_POLLY_MODE === 'record') {
+      try {
+        await SecretsRaw.getSecret(secret1.name);
+        await SecretsRaw.deleteSecret(secret1.name);
+      } catch (error) {
+        // ignore
+      }
+      try {
+        await SecretsRaw.getSecret(secret2.name);
+        await SecretsRaw.deleteSecret(secret2.name);
+      } catch (error) {
+        // ignore
+      }
+      try {
+        await SecretsRaw.getSecret(secret3.name);
+        await SecretsRaw.deleteSecret(secret3.name);
+      } catch (error) {
+        // ignore
+      }
+      try {
+        await SecretsRaw.getSecret(secret4.name);
+        await SecretsRaw.deleteSecret(secret4.name);
+      } catch (error) {
+        // ignore
+      }
     }
   });
-});
-describe('SecretsApi - putSecret()', () => {
-  test('putSecret() 1: Create secret: esv-volkerstestsecret1 - success', async () => {
-    const mockResponse = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../test/mocks/SecretsApi/putSecret/esv-volkerstestsecret1.json'), 'utf8'));
-    mock.onPut('https://openam-frodo-dev.forgeblocks.com/environment/secrets/esv-volkerstestsecret1').reply(200, mockResponse);
-    const response = await SecretsRaw.putSecret('esv-volkerstestsecret1', "Volker's Test Secret Value", "Volker's Test Secret Description", 'generic', true);
-    expect(response).toBeTruthy();
-    expect(response).toMatchObject(mockResponse);
+  describe('getSecrets()', () => {
+    test('0: Method is implemented', async () => {
+      expect(SecretsRaw.getSecrets).toBeDefined();
+    });
+    test('1: Get all secrets - success', async () => {
+      const response = await SecretsRaw.getSecrets();
+      expect(response).toMatchSnapshot();
+    });
   });
-  test('putSecret() 2: Create secret: esv-volkerstestsecret1 - error', async () => {
-    const mockResponse = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../test/mocks/SecretsApi/putSecret/error.json'), 'utf8'));
-    mock.onPut('https://openam-frodo-dev.forgeblocks.com/environment/secrets/esv-volkerstestsecret1').reply(500, mockResponse);
-    try {
-      await SecretsRaw.putSecret('esv-volkerstestsecret1', "Volker's Test Secret Value", "Volker's Test Secret Description", 'generic', true);
-    } catch (error) {
-      // console.dir(error);
-      expect(error).toMatchSnapshot();
-    }
+  describe('getSecret()', () => {
+    test('0: Method is implemented', async () => {
+      expect(SecretsRaw.getSecret).toBeDefined();
+    });
+    test(`1: Get existing secret: ${secret1.name}`, async () => {
+      const response = await SecretsRaw.getSecret(secret1.name);
+      expect(response).toMatchSnapshot();
+    });
+    test('2: Get non-existing secret: esv-does-not-exist', async () => {
+      expect.assertions(1);
+      try {
+        await SecretsRaw.getSecret('esv-does-not-exist');
+      } catch (error) {
+        expect(error).toMatchSnapshot();
+      }
+    });
   });
-});
-describe('SecretsApi - setSecretDescription()', () => {
-  test('setSecretDescription() 1: Set secret description: esv-volkerstestsecret1 - success', async () => {
-    const mockResponse = '';
-    mock.onPost('https://openam-frodo-dev.forgeblocks.com/environment/secrets/esv-volkerstestsecret1?_action=setDescription').reply(200, mockResponse);
-    const response = await SecretsRaw.setSecretDescription('esv-volkerstestsecret1', "Volker's Updated Test Secret Description");
-    expect(response).toBe('');
+  describe('putSecret()', () => {
+    test('0: Method is implemented', async () => {
+      expect(SecretsRaw.putSecret).toBeDefined();
+    });
+    test(`1: Create secret: ${secret4.name} - success`, async () => {
+      const response = await SecretsRaw.putSecret(secret4.name, secret4.value, secret4.description, secret4.encoding, secret4.placeholders);
+      expect(response).toMatchSnapshot();
+    });
   });
-  test('setSecretDescription() 2: Set secret description: esv-volkerstestsecret1 - error', async () => {
-    const mockResponse = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../test/mocks/SecretsApi/setSecretDescription/error.json'), 'utf8'));
-    mock.onPost('https://openam-frodo-dev.forgeblocks.com/environment/secrets/esv-volkerstestsecret1?_action=setDescription').reply(500, mockResponse);
-    expect.assertions(4);
-    try {
-      await SecretsRaw.setSecretDescription('esv-volkerstestsecret1', "Volker's Updated Test Secret Description");
-    } catch (error) {
-      // console.dir(error);
-      expect(error).toBeTruthy();
-      expect(error.response.status).toBe(500);
-      expect(error.response.data.code).toBe(500);
-      expect(error.response.data.message).toBe('Server Error');
-    }
+  describe('setSecretDescription()', () => {
+    test('0: Method is implemented', async () => {
+      expect(SecretsRaw.setSecretDescription).toBeDefined();
+    });
+    test(`1: Set existing secret's description: ${secret2.name} - success`, async () => {
+      const response = await SecretsRaw.setSecretDescription(secret2.name, 'Updated Frodo Test Secret Two Description');
+      expect(response).toMatchSnapshot();
+    });
   });
-});
-describe('SecretsApi - deleteSecret()', () => {
-  test('deleteSecret() 1: Delete secret: esv-volkerstestsecret1 - success', async () => {
-    const mockResponse = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../test/mocks/SecretsApi/deleteSecret/esv-volkerstestsecret1.json'), 'utf8'));
-    mock.onDelete('https://openam-frodo-dev.forgeblocks.com/environment/secrets/esv-volkerstestsecret1').reply(200, mockResponse);
-    const response = await SecretsRaw.deleteSecret('esv-volkerstestsecret1');
-    expect(response).toBeTruthy();
-    expect(response).toMatchObject(mockResponse);
+  describe('deleteSecret()', () => {
+    test('0: Method is implemented', async () => {
+      expect(SecretsRaw.deleteSecret).toBeDefined();
+    });
+    test(`1: Delete existing secret: ${secret3.name} - success`, async () => {
+      const response = await SecretsRaw.deleteSecret(secret3.name);
+      expect(response).toMatchSnapshot();
+    });
   });
-  test('deleteSecret() 2: Delete secret: esv-volkerstestsecret1 - error', async () => {
-    const mockResponse = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../test/mocks/SecretsApi/deleteSecret/error.json'), 'utf8'));
-    mock.onDelete('https://openam-frodo-dev.forgeblocks.com/environment/secrets/esv-volkerstestsecret1').reply(500, mockResponse);
-    expect.assertions(4);
-    try {
-      await SecretsRaw.deleteSecret('esv-volkerstestsecret1');
-    } catch (error) {
-      // console.dir(error);
-      expect(error).toBeTruthy();
-      expect(error.response.status).toBe(500);
-      expect(error.response.data.code).toBe(500);
-      expect(error.response.data.message).toBe('Server Error');
-    }
+  describe('getSecretVersions()', () => {
+    test('0: Method is implemented', async () => {
+      expect(SecretsRaw.getSecretVersions).toBeDefined();
+    });
+    test(`1: Get versions of existing secret: ${secret1.name}`, async () => {
+      const response = await SecretsRaw.getSecretVersions(secret1.name);
+      expect(response).toMatchSnapshot();
+    });
+    test('2: Get versions of non-existing secret: esv-does-not-exist', async () => {
+      expect.assertions(1);
+      try {
+        await SecretsRaw.getSecretVersions('esv-does-not-exist');
+      } catch (error) {
+        expect(error).toMatchSnapshot();
+      }
+    });
   });
-});
-describe('SecretsApi - getSecretVersions()', () => {
-  test('getSecretVersions() 1: Get versions of existing secret: esv-volkerstestsecret1', async () => {
-    const mockResponse = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../test/mocks/SecretsApi/getSecretVersions/esv-volkerstestsecret1.json'), 'utf8'));
-    mock.onGet('https://openam-frodo-dev.forgeblocks.com/environment/secrets/esv-volkerstestsecret1/versions').reply(200, mockResponse);
-    const response = await SecretsRaw.getSecretVersions('esv-volkerstestsecret1');
-    expect(response).toBeTruthy();
-    expect(response).toMatchObject(mockResponse);
+  describe('getVersionOfSecret()', () => {
+    test('0: Method is implemented', async () => {
+      expect(SecretsRaw.getVersionOfSecret).toBeDefined();
+    });
+    test(`1: Get version 2 of existing secret: ${secret1.name}`, async () => {
+      const response = await SecretsRaw.getVersionOfSecret(secret1.name, '2');
+      expect(response).toMatchSnapshot();
+    });
+    test('2: Get version 2 of non-existing secret: esv-does-not-exist', async () => {
+      expect.assertions(1);
+      try {
+        await SecretsRaw.getVersionOfSecret('esv-does-not-exist', '2');
+      } catch (error) {
+        expect(error).toMatchSnapshot();
+      }
+    });
   });
-  test('getSecretVersions() 2: Get versions of non-existing secret: esv-does-not-exist', async () => {
-    const mockResponse = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../test/mocks/SecretsApi/getSecretVersions/esv-does-not-exist.json'), 'utf8'));
-    mock.onGet('https://openam-frodo-dev.forgeblocks.com/environment/secrets/esv-does-not-exist/versions').reply(404, mockResponse);
-    expect.assertions(4);
-    try {
-      await SecretsRaw.getSecretVersions('esv-does-not-exist');
-    } catch (error) {
-      // console.dir(error);
-      expect(error).toBeTruthy();
-      expect(error.response.status).toBe(404);
-      expect(error.response.data.code).toBe(404);
-      expect(error.response.data.message).toBe('The secret does not exist or does not have a version');
-    }
+  describe('createNewVersionOfSecret()', () => {
+    test('0: Method is implemented', async () => {
+      expect(SecretsRaw.createNewVersionOfSecret).toBeDefined();
+    });
+    test(`1: Create new version of existing secret: ${secret2.name} - success`, async () => {
+      const response = await SecretsRaw.createNewVersionOfSecret(secret2.name, secret2.value + ' Version 4');
+      expect(response).toMatchSnapshot();
+    });
+    test('2: Create new version of non-existing secret: esv-does-not-exist - error', async () => {
+      expect.assertions(1);
+      try {
+        await SecretsRaw.createNewVersionOfSecret('esv-does-not-exist', 'Frodo Non-Existing Test Secret Value Version 2');
+      } catch (error) {
+        expect(error).toMatchSnapshot();
+      }
+    });
   });
-});
-describe('SecretsApi - createNewVersionOfSecret()', () => {
-  test('createNewVersionOfSecret() 1: Create new version of existing secret: esv-volkerstestsecret1 - success', async () => {
-    const mockResponse = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../test/mocks/SecretsApi/createNewVersionOfSecret/esv-volkerstestsecret1.json'), 'utf8'));
-    mock.onPost('https://openam-frodo-dev.forgeblocks.com/environment/secrets/esv-volkerstestsecret1/versions?_action=create').reply(200, mockResponse);
-    const response = await SecretsRaw.createNewVersionOfSecret('esv-volkerstestsecret1', "Volker's Test Secret Value");
-    expect(response).toBeTruthy();
-    expect(response).toMatchObject(mockResponse);
+  describe('setStatusOfVersionOfSecret()', () => {
+    test('0: Method is implemented', async () => {
+      expect(SecretsRaw.setStatusOfVersionOfSecret).toBeDefined();
+    });
+    test(`1: Disable version 2 of existing secret: ${secret2.name} - success`, async () => {
+      expect.assertions(1);
+      const response = await SecretsRaw.setStatusOfVersionOfSecret(secret2.name, '2', SecretsRaw.VersionOfSecretStatus.DISABLED);
+      expect(response).toMatchSnapshot();
+    });
+    test('2: Disable version 2 of non-existing secret: esv-does-not-exist - error', async () => {
+      expect.assertions(1);
+      try {
+        await SecretsRaw.setStatusOfVersionOfSecret('esv-does-not-exist', '2', SecretsRaw.VersionOfSecretStatus.DISABLED);
+      } catch (error) {
+        expect(error).toMatchSnapshot();
+      }
+    });
   });
-  test('createNewVersionOfSecret() 2: Create new version of existing secret: esv-volkerstestsecret1 - error', async () => {
-    const mockResponse = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../test/mocks/SecretsApi/createNewVersionOfSecret/error.json'), 'utf8'));
-    mock.onPost('https://openam-frodo-dev.forgeblocks.com/environment/secrets/esv-volkerstestsecret1/versions?_action=create').reply(500, mockResponse);
-    expect.assertions(4);
-    try {
-      await SecretsRaw.createNewVersionOfSecret('esv-volkerstestsecret1', "Volker's Test Secret Value");
-    } catch (error) {
-      // console.dir(error);
-      expect(error).toBeTruthy();
-      expect(error.response.status).toBe(500);
-      expect(error.response.data.code).toBe(500);
-      expect(error.response.data.message).toBe('Server Error');
-    }
-  });
-  test('createNewVersionOfSecret() 3: Create new version of non-existing secret: esv-does-not-exist - error', async () => {
-    const mockResponse = fs.readFileSync(path.resolve(__dirname, '../test/mocks/SecretsApi/createNewVersionOfSecret/esv-does-not-exist.txt'), 'utf8');
-    mock.onPost('https://openam-frodo-dev.forgeblocks.com/environment/secrets/esv-volkerstestsecret1/versions?_action=create').reply(500, mockResponse);
-    expect.assertions(3);
-    try {
-      await SecretsRaw.createNewVersionOfSecret('esv-volkerstestsecret1', "Volker's Test Secret Value");
-    } catch (error) {
-      // console.dir(error);
-      expect(error).toBeTruthy();
-      expect(error.response.status).toBe(500);
-      expect(error.response.data).toBe(mockResponse);
-    }
-  });
-});
-describe('SecretsApi - getVersionOfSecret()', () => {
-  test('getVersionOfSecret() 1: Get version 2 of existing secret: esv-volkerstestsecret1', async () => {
-    const mockResponse = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../test/mocks/SecretsApi/getVersionOfSecret/esv-volkerstestsecret1_v2.json'), 'utf8'));
-    mock.onGet('https://openam-frodo-dev.forgeblocks.com/environment/secrets/esv-volkerstestsecret1/versions/2').reply(200, mockResponse);
-    const response = await SecretsRaw.getVersionOfSecret('esv-volkerstestsecret1', '2');
-    expect(response).toBeTruthy();
-    expect(response).toMatchObject(mockResponse);
-  });
-  test('getVersionOfSecret() 2: Get version 2 of non-existing secret: esv-does-not-exist', async () => {
-    const mockResponse = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../test/mocks/SecretsApi/getVersionOfSecret/esv-does-not-exist_v2.json'), 'utf8'));
-    mock.onGet('https://openam-frodo-dev.forgeblocks.com/environment/secrets/esv-does-not-exist/versions/2').reply(500, mockResponse);
-    expect.assertions(4);
-    try {
-      await SecretsRaw.getVersionOfSecret('esv-does-not-exist', '2');
-    } catch (error) {
-      // console.dir(error);
-      expect(error).toBeTruthy();
-      expect(error.response.status).toBe(500);
-      expect(error.response.data.code).toBe(500);
-      expect(error.response.data.message).toBe('Failed to update secret version');
-    }
-  });
-});
-describe('SecretsApi - setStatusOfVersionOfSecret()', () => {
-  test('setStatusOfVersionOfSecret() 1: Disable version 2 of existing secret: esv-volkerstestsecret1 - success', async () => {
-    const mockResponse = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../test/mocks/SecretsApi/setStatusOfVersionOfSecret/esv-volkerstestsecret1_v2_DISABLED.json'), 'utf8'));
-    mock.onPost('https://openam-frodo-dev.forgeblocks.com/environment/secrets/esv-volkerstestsecret1/versions/2?_action=changestatus').reply(200, mockResponse);
-    const response = await SecretsRaw.setStatusOfVersionOfSecret('esv-volkerstestsecret1', '2', SecretsRaw.VersionOfSecretStatus.DISABLED);
-    expect(response).toBeTruthy();
-    expect(response).toMatchObject(mockResponse);
-  });
-  test('setStatusOfVersionOfSecret() 2: Disable version 2 of existing secret: esv-volkerstestsecret1 - error', async () => {
-    const mockResponse = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../test/mocks/SecretsApi/setStatusOfVersionOfSecret/error.json'), 'utf8'));
-    mock.onPost('https://openam-frodo-dev.forgeblocks.com/environment/secrets/esv-volkerstestsecret1/versions/2?_action=changestatus').reply(500, mockResponse);
-    expect.assertions(4);
-    try {
-      await SecretsRaw.setStatusOfVersionOfSecret('esv-volkerstestsecret1', '2', SecretsRaw.VersionOfSecretStatus.DISABLED);
-    } catch (error) {
-      // console.dir(error);
-      expect(error).toBeTruthy();
-      expect(error.response.status).toBe(500);
-      expect(error.response.data.code).toBe(500);
-      expect(error.response.data.message).toBe('Server Error');
-    }
-  });
-  test('setStatusOfVersionOfSecret() 3: Disable version 2 of non-existing secret: esv-does-not-exist - error', async () => {
-    const mockResponse = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../test/mocks/SecretsApi/setStatusOfVersionOfSecret/esv-does-not-exist_v2_DISABLED.json'), 'utf8'));
-    mock.onPost('https://openam-frodo-dev.forgeblocks.com/environment/secrets/esv-does-not-exist/versions/2?_action=changestatus').reply(404, mockResponse);
-    expect.assertions(4);
-    try {
-      await SecretsRaw.setStatusOfVersionOfSecret('esv-does-not-exist', '2', SecretsRaw.VersionOfSecretStatus.DISABLED);
-    } catch (error) {
-      // console.dir(error);
-      expect(error).toBeTruthy();
-      expect(error.response.status).toBe(404);
-      expect(error.response.data.code).toBe(404);
-      expect(error.response.data.message).toBe('The secret does not exist or does not have a version');
-    }
-  });
-});
-describe('SecretsApi - deleteVersionOfSecret()', () => {
-  test('deleteVersionOfSecret() 1: Delete version 2 of secret: esv-volkerstestsecret1 - success', async () => {
-    const mockResponse = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../test/mocks/SecretsApi/deleteVersionOfSecret/esv-volkerstestsecret1_v2.json'), 'utf8'));
-    mock.onDelete('https://openam-frodo-dev.forgeblocks.com/environment/secrets/esv-volkerstestsecret1/versions/2').reply(200, mockResponse);
-    const response = await SecretsRaw.deleteVersionOfSecret('esv-volkerstestsecret1', '2');
-    expect(response).toBeTruthy();
-    expect(response).toMatchObject(mockResponse);
-  });
-  test('deleteVersionOfSecret() 2: Delete version 2 of secret: esv-volkerstestsecret1 - error', async () => {
-    const mockResponse = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../test/mocks/SecretsApi/deleteVersionOfSecret/error.json'), 'utf8'));
-    mock.onDelete('https://openam-frodo-dev.forgeblocks.com/environment/secrets/esv-volkerstestsecret1/versions/2').reply(500, mockResponse);
-    expect.assertions(4);
-    try {
-      await SecretsRaw.deleteVersionOfSecret('esv-volkerstestsecret1', '2');
-    } catch (error) {
-      // console.dir(error);
-      expect(error).toBeTruthy();
-      expect(error.response.status).toBe(500);
-      expect(error.response.data.code).toBe(500);
-      expect(error.response.data.message).toBe('Server Error');
-    }
+  describe('deleteVersionOfSecret()', () => {
+    test('0: Method is implemented', async () => {
+      expect(SecretsRaw.deleteVersionOfSecret).toBeDefined();
+    });
+    test(`1: Delete version 1 of secret: ${secret2.name} - success`, async () => {
+      const response = await SecretsRaw.deleteVersionOfSecret(secret2.name, '1');
+      expect(response).toMatchSnapshot();
+    });
   });
 });
 //# sourceMappingURL=SecretsApi.test.js.map

package/esm/api/SocialIdentityProvidersApi.mjs

@@ -93,4 +93,20 @@ export async function putProviderByTypeAndId(type, id, providerData) {
   });
   return data;
 }
+
+/**
+ * Delete social identity provider by type and id
+ * @param {string} providerId provider type
+ * @param {string} providerId provider id
+ * @returns {Promise<unknown>} a promise that resolves to a social identity provider
+ */
+export async function deleteProviderByTypeAndId(type, providerId) {
+  const urlString = util.format(providerByTypeAndIdURLTemplate, state.getHost(), getCurrentRealmPath(), type, providerId);
+  const {
+    data
+  } = await generateAmApi(getApiConfig()).delete(urlString, {
+    withCredentials: true
+  });
+  return data;
+}
 //# sourceMappingURL=SocialIdentityProvidersApi.js.map