@rockcarver/frodo-lib 0.17.2-0 → 0.17.3

package/esm/ops/AuthenticateOps.mjs

@@ -398,17 +398,10 @@ export async function getTokens() {
       const token = await authenticate(state.getUsername(), state.getPassword());
       if (token) state.setCookieValue(token);
       await determineDeploymentTypeAndDefaultRealmAndVersion();
-      debugMessage(`AuthenticateOps.getTokens: before bearer`);
-      debugMessage(`AuthenticateOps.getTokens: cookie=${state.getCookieValue()}`);
-      debugMessage(`AuthenticateOps.getTokens: bearer=${state.getBearerToken()}`);
-      debugMessage(`AuthenticateOps.getTokens: type=${state.getDeploymentType()}`);
-      debugMessage(`AuthenticateOps.getTokens: condition=${state.getCookieValue() && !state.getBearerToken() && (state.getDeploymentType() === globalConfig.CLOUD_DEPLOYMENT_TYPE_KEY || state.getDeploymentType() === globalConfig.FORGEOPS_DEPLOYMENT_TYPE_KEY)}`);
       if (state.getCookieValue() && !state.getBearerToken() && (state.getDeploymentType() === globalConfig.CLOUD_DEPLOYMENT_TYPE_KEY || state.getDeploymentType() === globalConfig.FORGEOPS_DEPLOYMENT_TYPE_KEY)) {
-        debugMessage(`AuthenticateOps.getTokens: in bearer`);
         const accessToken = await getAccessTokenForUser();
         if (accessToken) state.setBearerToken(accessToken);
       }
-      debugMessage(`AuthenticateOps.getTokens: after bearer`);
     }
     // incomplete or no credentials
     else {

package/esm/ops/ConnectionProfileOps.test.mjs

@@ -3,62 +3,102 @@ import { homedir } from 'os';
 import { ConnectionProfile, state } from '../index';
 import { FRODO_CONNECTION_PROFILES_PATH_KEY, FRODO_MASTER_KEY_PATH_KEY, FRODO_MASTER_KEY_KEY } from '../storage/StaticStorage';
 describe('ConnectionProfileOps', () => {
-  test('saveConnectionProfile() 1: Create connection profiles in location from state field', async () => {
-    const host = 'https://openam-tenant-name.forgeblocks.com/am';
-    const user = 'frodo.baggins@shire.me';
-    const password = 'G@nd@lfTheW153';
-    const connectionProfilePath = `${homedir()}/connections1.json`;
-    state.setHost(host);
-    state.setUsername(user);
-    state.setPassword(password);
-    state.setConnectionProfilesPath(connectionProfilePath);
-    await ConnectionProfile.saveConnectionProfile(host);
-    expect(fs.existsSync(connectionProfilePath)).toBeTruthy();
-    const connections = JSON.parse(fs.readFileSync(connectionProfilePath, 'utf8'));
-    expect(connections).toBeTruthy();
-    expect(connections[host]).toBeTruthy();
-    expect(connections[host].username).toEqual(user);
-    expect(connections[host].encodedPassword).toBeTruthy();
+  const connectionProfilePath1 = `${homedir()}/connections1.json`;
+  const connectionProfilePath2 = `${homedir()}/connections2.json`;
+  const connectionProfilePath3 = `${homedir()}/connections3.json`;
+
+  // delete all connection profile files before running the tests
+  beforeAll(() => {
+    try {
+      fs.unlinkSync(connectionProfilePath1);
+    } catch (error) {
+      // ignore
+    }
+    try {
+      fs.unlinkSync(connectionProfilePath2);
+    } catch (error) {
+      // ignore
+    }
+    try {
+      fs.unlinkSync(connectionProfilePath3);
+    } catch (error) {
+      // ignore
+    }
   });
-  test(`saveConnectionProfile() 2: Create connection profiles in location from env ${FRODO_MASTER_KEY_PATH_KEY}`, async () => {
-    const host = 'https://openam-tenant-name.forgeblocks.com/am';
-    const user = 'frodo.baggins@shire.me';
-    const password = 'G@nd@lfTheW153';
-    const connectionProfilePath = `${homedir()}/connections2.json`;
-    // set the hard-coded master key
-    process.env[FRODO_CONNECTION_PROFILES_PATH_KEY] = connectionProfilePath;
-    state.setHost(host);
-    state.setUsername(user);
-    state.setPassword(password);
-    state.setConnectionProfilesPath('');
-    await ConnectionProfile.saveConnectionProfile(host);
-    expect(ConnectionProfile.getConnectionProfilesPath()).toEqual(connectionProfilePath);
-    expect(fs.existsSync(connectionProfilePath)).toBeTruthy();
-    const connections = JSON.parse(fs.readFileSync(connectionProfilePath, 'utf8'));
-    expect(connections).toBeTruthy();
-    expect(connections[host]).toBeTruthy();
-    expect(connections[host].username).toEqual(user);
-    expect(connections[host].encodedPassword).toBeTruthy();
+
+  // clean up all connection profile files after running the tests
+  afterAll(() => {
+    try {
+      fs.unlinkSync(connectionProfilePath1);
+    } catch (error) {
+      // ignore
+    }
+    try {
+      fs.unlinkSync(connectionProfilePath2);
+    } catch (error) {
+      // ignore
+    }
+    try {
+      fs.unlinkSync(connectionProfilePath3);
+    } catch (error) {
+      // ignore
+    }
   });
-  test(`saveConnectionProfile() 3: Use Master Key from env ${FRODO_MASTER_KEY_KEY}`, async () => {
-    const host = 'https://openam-tenant-name.forgeblocks.com/am';
-    const user = 'frodo.baggins@shire.me';
-    const password = 'G@nd@lfTheW153';
-    const connectionProfilePath = `${homedir()}/connections3.json`;
-    const masterKey = 'bxnQlhcU5VfyDs+BBPhRhK09yHaNtdIIk85HUMKBnqg=';
-    // set the hard-coded master key
-    process.env[FRODO_MASTER_KEY_KEY] = masterKey;
-    state.setHost(host);
-    state.setUsername(user);
-    state.setPassword(password);
-    state.setConnectionProfilesPath(connectionProfilePath);
-    await ConnectionProfile.saveConnectionProfile(host);
-    expect(fs.existsSync(connectionProfilePath)).toBeTruthy();
-    const connections = JSON.parse(fs.readFileSync(connectionProfilePath, 'utf8'));
-    expect(connections).toBeTruthy();
-    expect(connections[host]).toBeTruthy();
-    expect(connections[host].username).toEqual(user);
-    expect(connections[host].encodedPassword).toBeTruthy();
+  describe('saveConnectionProfile()', () => {
+    test('1: Create connection profiles in location from state field', async () => {
+      const host = 'https://openam-tenant-name.forgeblocks.com/am';
+      const user = 'frodo.baggins@shire.me';
+      const password = 'G@nd@lfTheW153';
+      state.setHost(host);
+      state.setUsername(user);
+      state.setPassword(password);
+      state.setConnectionProfilesPath(connectionProfilePath1);
+      await ConnectionProfile.saveConnectionProfile(host);
+      expect(fs.existsSync(connectionProfilePath1)).toBeTruthy();
+      const connections = JSON.parse(fs.readFileSync(connectionProfilePath1, 'utf8'));
+      expect(connections).toBeTruthy();
+      expect(connections[host]).toBeTruthy();
+      expect(connections[host].username).toEqual(user);
+      expect(connections[host].encodedPassword).toBeTruthy();
+    });
+    test(`2: Create connection profiles in location from env ${FRODO_MASTER_KEY_PATH_KEY}`, async () => {
+      const host = 'https://openam-tenant-name.forgeblocks.com/am';
+      const user = 'frodo.baggins@shire.me';
+      const password = 'G@nd@lfTheW153';
+      // set the hard-coded master key
+      process.env[FRODO_CONNECTION_PROFILES_PATH_KEY] = connectionProfilePath2;
+      state.setHost(host);
+      state.setUsername(user);
+      state.setPassword(password);
+      state.setConnectionProfilesPath('');
+      await ConnectionProfile.saveConnectionProfile(host);
+      expect(ConnectionProfile.getConnectionProfilesPath()).toEqual(connectionProfilePath2);
+      expect(fs.existsSync(connectionProfilePath2)).toBeTruthy();
+      const connections = JSON.parse(fs.readFileSync(connectionProfilePath2, 'utf8'));
+      expect(connections).toBeTruthy();
+      expect(connections[host]).toBeTruthy();
+      expect(connections[host].username).toEqual(user);
+      expect(connections[host].encodedPassword).toBeTruthy();
+    });
+    test(`3: Use Master Key from env ${FRODO_MASTER_KEY_KEY}`, async () => {
+      const host = 'https://openam-tenant-name.forgeblocks.com/am';
+      const user = 'frodo.baggins@shire.me';
+      const password = 'G@nd@lfTheW153';
+      const masterKey = 'bxnQlhcU5VfyDs+BBPhRhK09yHaNtdIIk85HUMKBnqg=';
+      // set the hard-coded master key
+      process.env[FRODO_MASTER_KEY_KEY] = masterKey;
+      state.setHost(host);
+      state.setUsername(user);
+      state.setPassword(password);
+      state.setConnectionProfilesPath(connectionProfilePath3);
+      await ConnectionProfile.saveConnectionProfile(host);
+      expect(fs.existsSync(connectionProfilePath3)).toBeTruthy();
+      const connections = JSON.parse(fs.readFileSync(connectionProfilePath3, 'utf8'));
+      expect(connections).toBeTruthy();
+      expect(connections[host]).toBeTruthy();
+      expect(connections[host].username).toEqual(user);
+      expect(connections[host].encodedPassword).toBeTruthy();
+    });
   });
 });
 //# sourceMappingURL=ConnectionProfileOps.test.js.map

package/esm/ops/EmailTemplateOps.test.mjs

@@ -1,34 +1,146 @@
-import axios from 'axios';
-import MockAdapter from 'axios-mock-adapter';
-import { EmailTemplate, state } from '../index';
-import * as global from '../storage/StaticStorage';
-import { mockGetConfigEntitiesByType } from '../test/mocks/ForgeRockApiMockEngine';
-const mock = new MockAdapter(axios);
-state.setHost('https://openam-frodo-dev.forgeblocks.com/am');
-state.setRealm('alpha');
-state.setCookieName('cookieName');
-state.setCookieValue('cookieValue');
-state.setDeploymentType(global.CLOUD_DEPLOYMENT_TYPE_KEY);
-describe('EmailTemplateOps - getEmailTemplate()', () => {
-  test('getEmailTemplate() 0: Method is implemented', async () => {
-    expect(EmailTemplate.getEmailTemplate).toBeDefined();
+/**
+ * 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=frodo-dev npm run test:record EmailTemplateOps
+ *
+ *    The above command assumes that you have a connection profile for
+ *    'frodo-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 EmailTemplateOps
+ *
+ * 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:only EmailTemplateOps
+ *
+ * Note: FRODO_DEBUG=1 is optional and enables debug logging for some output
+ * in case things don't function as expected
+ */
+import { EmailTemplate, IdmConfigRaw } from '../index';
+import { autoSetupPolly } from '../utils/AutoSetupPolly';
+autoSetupPolly();
+const {
+  EMAIL_TEMPLATE_TYPE
+} = EmailTemplate;
+async function stageTemplate(template, create = true) {
+  // delete if exists, then create
+  try {
+    await IdmConfigRaw.getConfigEntity(`${EMAIL_TEMPLATE_TYPE}/${template.id}`);
+    await IdmConfigRaw.deleteConfigEntity(`${EMAIL_TEMPLATE_TYPE}/${template.id}`);
+  } catch (error) {
+    // ignore
+  } finally {
+    if (create) {
+      await IdmConfigRaw.putConfigEntity(`${EMAIL_TEMPLATE_TYPE}/${template.id}`, template.data);
+    }
+  }
+}
+describe('EmailTemplateOps', () => {
+  const template1 = {
+    id: 'FrodoTestEmailTemplate1',
+    data: {
+      defaultLocale: 'en',
+      displayName: 'Frodo Test Email Template One',
+      enabled: true,
+      from: '',
+      message: {
+        en: '<h3>Click to reset your password</h3><h4><a href="{{object.resumeURI}}">Password reset link</a></h4>',
+        fr: '<h3>Cliquez pour réinitialiser votre mot de passe</h3><h4><a href="{{object.resumeURI}}">Mot de passe lien de réinitialisation</a></h4>'
+      },
+      mimeType: 'text/html',
+      subject: {
+        en: 'Reset your password',
+        fr: 'Réinitialisez votre mot de passe'
+      }
+    }
+  };
+  const template2 = {
+    id: 'FrodoTestEmailTemplate2',
+    data: {
+      defaultLocale: 'en',
+      displayName: 'Frodo Test Email Template Two',
+      enabled: true,
+      from: '',
+      message: {
+        en: '<h3>This is your one-time password:</h3><h4>{{object.description}}</a></h4>'
+      },
+      mimeType: 'text/html',
+      subject: {
+        en: 'One-Time Password for login'
+      }
+    }
+  };
+  const template3 = {
+    id: 'FrodoTestEmailTemplate3',
+    data: {
+      defaultLocale: 'en',
+      displayName: 'Frodo Test Email Template Three',
+      enabled: true,
+      from: '',
+      message: {
+        en: '<html><body><h3>You started a login or profile update that requires MFA. </h3><h4><a href="{{object.resumeURI}}">Click to Proceed</a></h4></body></html>'
+      },
+      mimeType: 'text/html',
+      subject: {
+        en: 'Multi-Factor Email for Identity Cloud login'
+      }
+    }
+  };
+  // in recording mode, setup test data before recording
+  beforeAll(async () => {
+    if (process.env.FRODO_POLLY_MODE === 'record') {
+      await stageTemplate(template1);
+      await stageTemplate(template2);
+      await stageTemplate(template3, false);
+    }
   });
-});
-describe('EmailTemplateOps - getEmailTemplates()', () => {
-  test('getEmailTemplates() 0: Method is implemented', async () => {
-    expect(EmailTemplate.getEmailTemplates).toBeDefined();
+  // in recording mode, remove test data after recording
+  afterAll(async () => {
+    if (process.env.FRODO_POLLY_MODE === 'record') {
+      await stageTemplate(template1, false);
+      await stageTemplate(template2, false);
+      await stageTemplate(template3, false);
+    }
   });
-  test('getEmailTemplates() 1: Get email templates', async () => {
-    mockGetConfigEntitiesByType(mock);
-    expect.assertions(2);
-    const emailTemplates = await EmailTemplate.getEmailTemplates();
-    expect(emailTemplates).toBeTruthy();
-    expect(emailTemplates.result.length).toBe(17);
+  describe('getEmailTemplate()', () => {
+    test('0: Method is implemented', async () => {
+      expect(EmailTemplate.getEmailTemplate).toBeDefined();
+    });
+    test(`1: Get email template '${template1.id}'`, async () => {
+      const response = await EmailTemplate.getEmailTemplate(template1.id);
+      expect(response).toMatchSnapshot();
+    });
   });
-});
-describe('EmailTemplateOps - putEmailTemplate()', () => {
-  test('putEmailTemplate() 0: Method is implemented', async () => {
-    expect(EmailTemplate.putEmailTemplate).toBeDefined();
+  describe('getEmailTemplates()', () => {
+    test('0: Method is implemented', async () => {
+      expect(EmailTemplate.getEmailTemplates).toBeDefined();
+    });
+    test('1: Get all email templates', async () => {
+      const response = await EmailTemplate.getEmailTemplates();
+      expect(response).toMatchSnapshot();
+    });
+  });
+  describe('putEmailTemplate()', () => {
+    test('0: Method is implemented', async () => {
+      expect(EmailTemplate.putEmailTemplate).toBeDefined();
+    });
+    test(`1: Create email template '${template3.id}'`, async () => {
+      const response = await EmailTemplate.putEmailTemplate(template3.id, template3.data);
+      expect(response).toMatchSnapshot();
+    });
   });
 });
 //# sourceMappingURL=EmailTemplateOps.test.js.map

package/esm/ops/IdmOps.test.mjs

@@ -1,72 +1,169 @@
-import fs from 'fs';
-import axios from 'axios';
-import MockAdapter from 'axios-mock-adapter';
-import { fileURLToPath } from 'url';
-import { Idm, state } from '../index';
-import * as global from '../storage/StaticStorage';
-import { mockGetAllConfigEntities, mockPutConfigEntity, mockGetConfigEntity, mockGetConfigEntitiesByType } from '../test/mocks/ForgeRockApiMockEngine';
-import path from 'path';
-const mock = new MockAdapter(axios);
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-state.setHost('https://openam-frodo-dev.forgeblocks.com/am');
-state.setRealm('alpha');
-state.setCookieName('cookieName');
-state.setCookieValue('cookieValue');
-state.setDeploymentType(global.CLOUD_DEPLOYMENT_TYPE_KEY);
-describe('IdmOps - getAllConfigEntities()', () => {
-  test('getAllConfigEntities() 0: Method is implemented', async () => {
-    expect(Idm.getAllConfigEntities).toBeDefined();
+/**
+ * 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=frodo-dev npm run test:record IdmOps
+ *
+ *    The above command assumes that you have a connection profile for
+ *    'frodo-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 IdmOps
+ *
+ * 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:only IdmOps
+ *
+ * Note: FRODO_DEBUG=1 is optional and enables debug logging for some output
+ * in case things don't function as expected
+ */
+import { Idm, IdmConfigRaw } from '../index';
+import { autoSetupPolly } from '../utils/AutoSetupPolly';
+autoSetupPolly();
+async function stageConfigEntity(configEntity, create = true) {
+  // delete if exists, then create
+  try {
+    await IdmConfigRaw.getConfigEntity(configEntity.id);
+    await IdmConfigRaw.deleteConfigEntity(configEntity.id);
+  } catch (error) {
+    // ignore
+  } finally {
+    if (create) {
+      await IdmConfigRaw.putConfigEntity(configEntity.id, configEntity.data);
+    }
+  }
+}
+describe('IdmOps', () => {
+  const configEntity1 = {
+    id: 'emailTemplate/FrodoTestConfigEntity1',
+    data: {
+      defaultLocale: 'en',
+      displayName: 'Frodo Test Email Template One',
+      enabled: true,
+      from: '',
+      message: {
+        en: '<h3>Click to reset your password</h3><h4><a href="{{object.resumeURI}}">Password reset link</a></h4>',
+        fr: '<h3>Cliquez pour réinitialiser votre mot de passe</h3><h4><a href="{{object.resumeURI}}">Mot de passe lien de réinitialisation</a></h4>'
+      },
+      mimeType: 'text/html',
+      subject: {
+        en: 'Reset your password',
+        fr: 'Réinitialisez votre mot de passe'
+      }
+    }
+  };
+  const configEntity2 = {
+    id: 'emailTemplate/FrodoTestConfigEntity2',
+    data: {
+      defaultLocale: 'en',
+      displayName: 'Frodo Test Email Template Two',
+      enabled: true,
+      from: '',
+      message: {
+        en: '<h3>This is your one-time password:</h3><h4>{{object.description}}</a></h4>'
+      },
+      mimeType: 'text/html',
+      subject: {
+        en: 'One-Time Password for login'
+      }
+    }
+  };
+  const configEntity3 = {
+    id: 'emailTemplate/FrodoTestConfigEntity3',
+    data: {
+      defaultLocale: 'en',
+      displayName: 'Frodo Test Email Template Three',
+      enabled: true,
+      from: '',
+      message: {
+        en: '<html><body><h3>You started a login or profile update that requires MFA. </h3><h4><a href="{{object.resumeURI}}">Click to Proceed</a></h4></body></html>'
+      },
+      mimeType: 'text/html',
+      subject: {
+        en: 'Multi-Factor Email for Identity Cloud login'
+      }
+    }
+  };
+  // in recording mode, setup test data before recording
+  beforeAll(async () => {
+    if (process.env.FRODO_POLLY_MODE === 'record') {
+      await stageConfigEntity(configEntity1);
+      await stageConfigEntity(configEntity2);
+      await stageConfigEntity(configEntity3, false);
+    }
   });
-  test('getAllConfigEntities() 1: get all config entities', async () => {
-    mockGetAllConfigEntities(mock);
-    expect.assertions(2);
-    const configEntities = await Idm.getAllConfigEntities();
-    expect(configEntities).toBeTruthy();
-    expect(configEntities.configurations.length).toBeGreaterThan(0);
+  // in recording mode, remove test data after recording
+  afterAll(async () => {
+    if (process.env.FRODO_POLLY_MODE === 'record') {
+      await stageConfigEntity(configEntity1, false);
+      await stageConfigEntity(configEntity2, false);
+      await stageConfigEntity(configEntity3, false);
+    }
   });
-});
-describe('IdmOps - getConfigEntitiesByType()', () => {
-  test('getConfigEntitiesByType() 0: Method is implemented', async () => {
-    expect(Idm.getConfigEntitiesByType).toBeDefined();
-  });
-  test('getConfigEntitiesByType() 1: Get config entity by type', async () => {
-    mockGetConfigEntitiesByType(mock);
-    expect.assertions(2);
-    const configEntity = await Idm.getConfigEntitiesByType('emailTemplate');
-    expect(configEntity).toBeTruthy();
-    expect(configEntity).toMatchSnapshot();
-  });
-});
-describe('IdmOps - getConfigEntity()', () => {
-  test('getConfigEntity() 0: Method is implemented', async () => {
-    expect(Idm.getConfigEntity).toBeDefined();
+  describe('getAllConfigEntities()', () => {
+    test('0: Method is implemented', async () => {
+      expect(Idm.getAllConfigEntities).toBeDefined();
+    });
+    test('1: get all config entities', async () => {
+      const response = await Idm.getAllConfigEntities();
+      expect(response).toMatchSnapshot();
+    });
   });
-  test('getConfigEntity() 1: Get config entity by Id', async () => {
-    mockGetConfigEntity(mock);
-    // expect.assertions(2);
-    const configEntity = await Idm.getConfigEntity('managed');
-    expect(configEntity).toBeTruthy();
-    expect(configEntity).toMatchSnapshot();
+  describe('getConfigEntitiesByType()', () => {
+    test('0: Method is implemented', async () => {
+      expect(Idm.getConfigEntitiesByType).toBeDefined();
+    });
+    test('1: Get config entity by type (emailTemplate)', async () => {
+      const response = await Idm.getConfigEntitiesByType('emailTemplate');
+      expect(response).toMatchSnapshot();
+    });
+    test('2: Get config entity by type (managed)', async () => {
+      const response = await Idm.getConfigEntitiesByType('managed');
+      expect(response).toMatchSnapshot();
+    });
   });
-});
-describe('IdmOps - putConfigEntity()', () => {
-  test('putConfigEntity() 0: Method is implemented', async () => {
-    expect(Idm.putConfigEntity).toBeDefined();
+  describe('getConfigEntity()', () => {
+    test('0: Method is implemented', async () => {
+      expect(Idm.getConfigEntity).toBeDefined();
+    });
+    test(`1: Get config entity '${configEntity1.id}'`, async () => {
+      const response = await Idm.getConfigEntity(configEntity1.id);
+      expect(response).toMatchSnapshot();
+    });
+    test("2: Get config entity 'managed'", async () => {
+      const response = await Idm.getConfigEntity('managed');
+      expect(response).toMatchSnapshot();
+    });
   });
-  test('putConfigEntity() 1: Put a config entity', async () => {
-    const templateData = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../test/mocks/IdmConfigApi/getConfigEntity/emailTemplate/welcome.json'), 'utf8'));
-    let uploaded = null;
-    mockPutConfigEntity(mock, (id, data) => {
-      uploaded = data;
+  describe('putConfigEntity()', () => {
+    test('0: Method is implemented', async () => {
+      expect(Idm.putConfigEntity).toBeDefined();
+    });
+    test(`1: Put a config entity '${configEntity3.id}'`, async () => {
+      const response = await Idm.putConfigEntity(configEntity3.id, configEntity3.data);
+      expect(response).toMatchSnapshot();
     });
-    await Idm.putConfigEntity('emailTemplate/welcome', templateData);
-    expect(uploaded).toBeDefined();
-    expect(uploaded).toMatchSnapshot();
   });
-});
-describe('IdmOps - queryAllManagedObjectsByType()', () => {
-  test('queryAllManagedObjectsByType() 0: Method is implemented', async () => {
-    expect(Idm.queryAllManagedObjectsByType).toBeDefined();
+  describe('queryAllManagedObjectsByType()', () => {
+    test('0: Method is implemented', async () => {
+      expect(Idm.queryAllManagedObjectsByType).toBeDefined();
+    });
+    test(`1: Query managed objects of type 'alpha_user'`, async () => {
+      const response = await Idm.queryAllManagedObjectsByType('alpha_user', ['*'], null);
+      expect(response).toMatchSnapshot();
+    });
   });
 });
 //# sourceMappingURL=IdmOps.test.js.map