@rockcarver/frodo-lib 0.12.2-2 → 0.12.2-5

package/esm/api/SecretsApi.test.mjs

@@ -0,0 +1,283 @@
+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.default.session.setTenant('https://openam-frodo-dev.forgeblocks.com/am');
+state.default.session.setRealm('alpha');
+state.default.session.setCookieName('cookieName');
+state.default.session.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(4);
+
+    try {
+      await SecretsRaw.getSecrets();
+    } 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('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(4);
+
+    try {
+      await SecretsRaw.getSecret('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('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);
+  });
+  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);
+    expect.assertions(4);
+
+    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).toBeTruthy();
+      expect(error.response.status).toBe(500);
+      expect(error.response.data.code).toBe(500);
+      expect(error.response.data.message).toBe('Server Error');
+    }
+  });
+});
+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('');
+  });
+  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('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);
+  });
+  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('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);
+  });
+  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('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);
+  });
+  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');
+    }
+  });
+});
+//# sourceMappingURL=SecretsApi.test.js.map

package/esm/api/VariablesApi.mjs

@@ -17,7 +17,7 @@ const getApiConfig = () => {
 };
 /**
  * Get all variables
- * @returns {Promise} a promise that resolves to an object containing an array of variable objects
+ * @returns {Promise<unknown[]>} a promise that resolves to an array of variable objects
  */
 
 
@@ -28,12 +28,12 @@ export async function getVariables() {
   } = await generateESVApi(getApiConfig()).get(urlString, {
     withCredentials: true
   });
-  return data.result;
+  return data;
 }
 /**
  * Get variable by id/name
- * @param {String} variableId variable id/name
- * @returns {Promise} a promise that resolves to an object containing a variable object
+ * @param {string} variableId variable id/name
+ * @returns {Promise<unknown>} a promise that resolves to a variable object
  */
 
 export async function getVariable(variableId) {
@@ -47,10 +47,10 @@ export async function getVariable(variableId) {
 }
 /**
  * Put variable by id/name
- * @param {String} variableId variable id/name
- * @param {String} value variable value
- * @param {String} description variable description
- * @returns {Promise} a promise that resolves to an object containing a variable object
+ * @param {string} variableId variable id/name
+ * @param {string} value variable value
+ * @param {string} description variable description
+ * @returns {Promise<unknown>} a promise that resolves to a variable object
  */
 
 export async function putVariable(variableId, value, description) {
@@ -67,9 +67,9 @@ export async function putVariable(variableId, value, description) {
 }
 /**
  * Set variable description
- * @param {*} variableId variable id/name
- * @param {*} description variable description
- * @returns {Promise} a promise that resolves to an object containing a status object
+ * @param {string} variableId variable id/name
+ * @param {string} description variable description
+ * @returns {Promise<unknown>} a promise that resolves to a status object
  */
 
 export async function setVariableDescription(variableId, description) {
@@ -85,8 +85,8 @@ export async function setVariableDescription(variableId, description) {
 }
 /**
  * Delete variable by id/name
- * @param {String} variableId variable id/name
- * @returns {Promise} a promise that resolves to an object containing a variable object
+ * @param {string} variableId variable id/name
+ * @returns {Promise<unknown>} a promise that resolves to a variable object
  */
 
 export async function deleteVariable(variableId) {

package/esm/api/VariablesApi.test.mjs

@@ -0,0 +1,229 @@
+import axios from 'axios';
+import MockAdapter from 'axios-mock-adapter';
+import { VariablesRaw, state } from '../index';
+const mock = new MockAdapter(axios);
+state.default.session.setTenant('https://openam-frodo-dev.forgeblocks.com/am');
+state.default.session.setRealm('alpha');
+state.default.session.setCookieName('cookieName');
+state.default.session.setCookieValue('cookieValue');
+describe('VariablesApi - getVariables()', () => {
+  test('getVariables() 0: Method is implemented', async () => {
+    expect(VariablesRaw.getVariables).toBeDefined();
+  });
+  test('getVariables() 1: Get all variables - success', async () => {
+    const mockResponse = {
+      pagedResultsCookie: null,
+      remainingPagedResults: -1,
+      result: [{
+        _id: 'esv-twilio-phone-number',
+        description: 'Twilio phone number. Get your own at: https://twilio.com',
+        expressionType: '',
+        lastChangeDate: '2022-08-12T21:27:18.560Z',
+        lastChangedBy: 'c5f3cf35-4cc1-42f9-80b3-59e1ca842510',
+        loaded: true,
+        valueBase64: 'KzEzMTc2NDQzMTA3'
+      }, {
+        _id: 'esv-461016d8d2-configurationpropertiescredentials',
+        description: 'Configuration parameter /configurationProperties/credentials in file idm/conf/provisioner.openicf-OUD.json',
+        expressionType: '',
+        lastChangeDate: '2021-12-09T16:48:18.482Z',
+        lastChangedBy: 'forgerock-automation',
+        loaded: true,
+        valueBase64: 'RnJkcC0yMDEw'
+      }, {
+        _id: 'esv-twilio-account-sid',
+        description: 'Twilio account SID. Get your own at: https://twilio.com',
+        expressionType: '',
+        lastChangeDate: '2022-08-12T21:26:32.688Z',
+        lastChangedBy: 'c5f3cf35-4cc1-42f9-80b3-59e1ca842510',
+        loaded: true,
+        valueBase64: 'QUM3NTA0MTVlMzE2M2EyZTU3YjdhZWVhN2VlZDgyZDk0NA=='
+      }, {
+        _id: 'esv-ipv4-cidr-access-rules',
+        description: 'IPv4 CIDR access rules: { "allow": [ "address/mask" ] }',
+        expressionType: '',
+        lastChangeDate: '2022-08-25T20:16:54.243Z',
+        lastChangedBy: 'c5f3cf35-4cc1-42f9-80b3-59e1ca842510',
+        loaded: true,
+        valueBase64: 'eyAiYWxsb3ciOiBbICIxNDUuMTE4LjAuMC8xNiIsICIxMzIuMzUuMC4wLzE2IiwgIjEwMS4yMjYuMC4wLzE2IiwgIjk5LjcyLjI4LjE4Mi8zMiIgXSB9'
+      }, {
+        _id: 'esv-volkerstestvariable1',
+        description: "Volker's Updated Test Variable Description",
+        expressionType: '',
+        lastChangeDate: '2022-04-10T20:55:39.746Z',
+        lastChangedBy: 'c5f3cf35-4cc1-42f9-80b3-59e1ca842510',
+        loaded: true,
+        valueBase64: 'Vm9sa2VyJ3MgVGVzdCBWYXJpYWJsZSBWYWx1ZQo='
+      }],
+      resultCount: 5,
+      totalPagedResults: -1,
+      totalPagedResultsPolicy: 'NONE'
+    };
+    mock.onGet('https://openam-frodo-dev.forgeblocks.com/environment/variables').reply(200, mockResponse);
+    const response = await VariablesRaw.getVariables();
+    expect(response).toBeTruthy();
+    expect(response).toMatchObject(mockResponse);
+  });
+  test('getVariables() 2: Get all variables - error', async () => {
+    const mockResponse = {
+      message: 'Server Error',
+      code: 500
+    };
+    mock.onGet('https://openam-frodo-dev.forgeblocks.com/environment/variables').reply(500, mockResponse);
+    expect.assertions(4);
+
+    try {
+      await VariablesRaw.getVariables();
+    } 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('VariablesApi - getVariable()', () => {
+  test('getVariable() 0: Method is implemented', async () => {
+    expect(VariablesRaw.getVariable).toBeDefined();
+  });
+  test('getVariable() 1: Get existing variable: esv-volkerstestvariable1', async () => {
+    const mockResponse = {
+      _id: 'esv-volkerstestvariable1',
+      description: "Volker's Updated Test Variable Description",
+      expressionType: '',
+      lastChangeDate: '2022-04-10T20:55:39.746Z',
+      lastChangedBy: 'c5f3cf35-4cc1-42f9-80b3-59e1ca842510',
+      loaded: true,
+      valueBase64: 'Vm9sa2VyJ3MgVGVzdCBWYXJpYWJsZSBWYWx1ZQo='
+    };
+    mock.onGet('https://openam-frodo-dev.forgeblocks.com/environment/variables/esv-volkerstestvariable1').reply(200, mockResponse);
+    const response = await VariablesRaw.getVariable('esv-volkerstestvariable1');
+    expect(response).toBeTruthy();
+    expect(response).toMatchObject(mockResponse);
+  });
+  test('getVariable() 2: Get non-existing variable: esv-does-not-exist', async () => {
+    const mockResponse = {
+      code: 404,
+      message: 'The variable does not exist'
+    };
+    mock.onGet('https://openam-frodo-dev.forgeblocks.com/environment/variables/esv-does-not-exist').reply(404, mockResponse);
+    expect.assertions(4);
+
+    try {
+      await VariablesRaw.getVariable('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 variable does not exist');
+    }
+  });
+});
+describe('VariablesApi - putVariable()', () => {
+  test('putVariable() 0: Method is implemented', async () => {
+    expect(VariablesRaw.putVariable).toBeDefined();
+  });
+  test('putVariable() 1: Create variable: esv-volkerstestvariable1 - success', async () => {
+    const mockResponse = {
+      _id: 'esv-volkerstestvariable1',
+      description: "Volker's Updated Test Variable Description",
+      expressionType: '',
+      lastChangeDate: '2022-04-10T20:55:39.746Z',
+      lastChangedBy: 'c5f3cf35-4cc1-42f9-80b3-59e1ca842510',
+      loaded: true,
+      valueBase64: 'Vm9sa2VyJ3MgVGVzdCBWYXJpYWJsZSBWYWx1ZQo='
+    };
+    mock.onPut('https://openam-frodo-dev.forgeblocks.com/environment/variables/esv-volkerstestvariable1').reply(200, mockResponse);
+    const response = await VariablesRaw.putVariable('esv-volkerstestvariable1', "Volker's Test Variable Value", "Volker's Test Variable Description");
+    expect(response).toBeTruthy();
+    expect(response).toMatchObject(mockResponse);
+  });
+  test('putVariable() 2: Create variable: esv-volkerstestvariable1 - error', async () => {
+    const mockResponse = {
+      code: 500,
+      message: 'Server Error'
+    };
+    mock.onPut('https://openam-frodo-dev.forgeblocks.com/environment/variables/esv-volkerstestvariable1').reply(500, mockResponse);
+    expect.assertions(4);
+
+    try {
+      await VariablesRaw.putVariable('esv-volkerstestvariable1', "Volker's Test Variable Value", "Volker's Test Variable 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('VariablesApi - setVariableDescription()', () => {
+  test('setVariableDescription() 0: Method is implemented', async () => {
+    expect(VariablesRaw.setVariableDescription).toBeDefined();
+  });
+  test('setVariableDescription() 1: Set variable description: esv-volkerstestvariable1 - success', async () => {
+    const mockResponse = '';
+    mock.onPost('https://openam-frodo-dev.forgeblocks.com/environment/variables/esv-volkerstestvariable1?_action=setDescription').reply(200, mockResponse);
+    const response = await VariablesRaw.setVariableDescription('esv-volkerstestvariable1', "Volker's Updated Test Secret Description");
+    expect(response).toBe('');
+  });
+  test('setVariableDescription() 2: Set variable description: esv-volkerstestvariable1 - error', async () => {
+    const mockResponse = {
+      code: 500,
+      message: 'Server Error'
+    };
+    mock.onPost('https://openam-frodo-dev.forgeblocks.com/environment/variables/esv-volkerstestvariable1?_action=setDescription').reply(500, mockResponse);
+    expect.assertions(4);
+
+    try {
+      await VariablesRaw.setVariableDescription('esv-volkerstestvariable1', "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('VariablesApi - deleteVariable()', () => {
+  test('deleteVariable() 0: Method is implemented', async () => {
+    expect(VariablesRaw.deleteVariable).toBeDefined();
+  });
+  test('deleteVariable() 1: Delete variable: esv-volkerstestvariable1 - success', async () => {
+    const mockResponse = {
+      _id: 'esv-volkerstestvariable1',
+      description: "Volker's Updated Test Variable Description",
+      expressionType: '',
+      lastChangeDate: '2022-04-10T20:55:39.746Z',
+      lastChangedBy: 'c5f3cf35-4cc1-42f9-80b3-59e1ca842510',
+      loaded: true,
+      valueBase64: 'Vm9sa2VyJ3MgVGVzdCBWYXJpYWJsZSBWYWx1ZQo='
+    };
+    mock.onDelete('https://openam-frodo-dev.forgeblocks.com/environment/variables/esv-volkerstestvariable1').reply(200, mockResponse);
+    const response = await VariablesRaw.deleteVariable('esv-volkerstestvariable1');
+    expect(response).toBeTruthy();
+    expect(response).toMatchObject(mockResponse);
+  });
+  test('deleteVariable() 2: Delete variable: esv-volkerstestvariable1 - error', async () => {
+    const mockResponse = {
+      code: 500,
+      message: 'Cannot delete a variable that has an existing config placeholder'
+    };
+    mock.onDelete('https://openam-frodo-dev.forgeblocks.com/environment/variables/esv-volkerstestvariable1').reply(500, mockResponse);
+    expect.assertions(4);
+
+    try {
+      await VariablesRaw.deleteVariable('esv-volkerstestvariable1');
+    } 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('Cannot delete a variable that has an existing config placeholder');
+    }
+  });
+});
+//# sourceMappingURL=VariablesApi.test.js.map

package/esm/index.mjs

@@ -11,7 +11,9 @@ export function getVersion() {
 
 export * as NodeRaw from './api/NodeApi';
 export * as TreeRaw from './api/TreeApi';
-export * as StartupRaw from './api/StartupApi'; // Ops Layer
+export * as StartupRaw from './api/StartupApi';
+export * as SecretsRaw from './api/SecretsApi';
+export * as VariablesRaw from './api/VariablesApi'; // Ops Layer
 
 export * as Admin from './ops/AdminOps';
 export * as Authenticate from './ops/AuthenticateOps';

package/esm/ops/SecretsOps.mjs

@@ -1,5 +1,5 @@
 import { createKeyValueTable, createProgressIndicator, createTable, printMessage, stopProgressIndicator, updateProgressIndicator } from './utils/Console';
-import { createNewVersionOfSecret, deleteSecret, deleteVersionOfSecret, getSecret, getSecrets, getSecretVersions, putSecret, setSecretDescription, setStatusOfVersionOfSecret } from '../api/SecretsApi';
+import { createNewVersionOfSecret, deleteSecret, deleteVersionOfSecret, getSecret, getSecrets, getSecretVersions, putSecret, setSecretDescription, setStatusOfVersionOfSecret, VersionOfSecretStatus } from '../api/SecretsApi';
 import wordwrap from './utils/Wordwrap';
 import { resolveUserName } from './ManagedObjectOps';
 /**
@@ -11,7 +11,7 @@ export async function listSecrets(long) {
   let secrets = [];
 
   try {
-    secrets = await getSecrets();
+    secrets = (await getSecrets()).result;
   } catch (error) {
     printMessage(`${error.message}`, 'error');
     printMessage(error.response.data, 'error');
@@ -101,7 +101,7 @@ export async function deleteSecretCmd(secretId) {
 
 export async function deleteSecretsCmd() {
   try {
-    const secrets = await getSecrets();
+    const secrets = (await getSecrets()).result;
     createProgressIndicator(secrets.length, `Deleting secrets...`);
 
     for (const secret of secrets) {
@@ -202,7 +202,7 @@ export async function activateVersionOfSecret(secretId, version) {
   createProgressIndicator(undefined, `Activating version ${version} of secret ${secretId}...`, 'indeterminate');
 
   try {
-    await setStatusOfVersionOfSecret(secretId, version, 'ENABLED');
+    await setStatusOfVersionOfSecret(secretId, version, VersionOfSecretStatus.ENABLED);
     stopProgressIndicator(`Activated version ${version} of secret ${secretId}`, 'success');
   } catch (error) {
     stopProgressIndicator(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'fail');
@@ -218,7 +218,7 @@ export async function deactivateVersionOfSecret(secretId, version) {
   createProgressIndicator(undefined, `Deactivating version ${version} of secret ${secretId}...`, 'indeterminate');
 
   try {
-    await setStatusOfVersionOfSecret(secretId, version, 'DISABLED');
+    await setStatusOfVersionOfSecret(secretId, version, VersionOfSecretStatus.DISABLED);
     stopProgressIndicator(`Deactivated version ${version} of secret ${secretId}`, 'success');
   } catch (error) {
     stopProgressIndicator(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'fail');

package/esm/ops/StartupOps.mjs

@@ -20,8 +20,8 @@ export async function checkForUpdates() {
   createProgressIndicator(undefined, `Checking for updates to apply...`, 'indeterminate');
 
   try {
-    updates.secrets = (await getSecrets()).filter(secret => !secret.loaded);
-    updates.variables = (await getVariables()).filter(variable => !variable.loaded);
+    updates.secrets = (await getSecrets()).result.filter(secret => !secret.loaded);
+    updates.variables = (await getVariables()).result.filter(variable => !variable.loaded);
   } catch (error) {
     stopProgressIndicator(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'fail');
   }

package/esm/ops/VariablesOps.mjs

@@ -12,7 +12,7 @@ export async function listVariables(long) {
   let variables = [];
 
   try {
-    variables = await getVariables();
+    variables = (await getVariables()).result;
   } catch (error) {
     printMessage(`${error.message}`, 'error');
     printMessage(error.response.data, 'error');
@@ -105,7 +105,7 @@ export async function deleteVariableCmd(variableId) {
 
 export async function deleteVariablesCmd() {
   try {
-    const variables = await getVariables();
+    const variables = (await getVariables()).result;
     createProgressIndicator(variables.length, `Deleting variable...`);
 
     for (const variable of variables) {