@rockcarver/frodo-lib 0.12.2-8 → 0.12.2

package/esm/ops/IdpOps.mjs

@@ -17,56 +17,57 @@ function getFileDataTemplate() {
  */
 
 
-export async function listProviders() {
-  getSocialIdentityProviders().then(response => {
-    response.result.sort((a, b) => a._id.localeCompare(b._id));
-    response.result.forEach(socialIdentityProvider => {
+export async function listSocialProviders() {
+  try {
+    const providers = await getSocialIdentityProviders();
+    providers.result.sort((a, b) => a._id.localeCompare(b._id));
+    providers.result.forEach(socialIdentityProvider => {
       printMessage(`${socialIdentityProvider._id}`, 'data');
     });
-  }).catch(err => {
-    printMessage(`listProviders ERROR: ${err.message}`, 'error');
+  } catch (err) {
+    printMessage(`listSocialProviders ERROR: ${err.message}`, 'error');
     printMessage(err, 'error');
-  });
+  }
 }
 /**
  * Get social identity provider by id
- * @param {String} id social identity provider id/name
+ * @param {String} providerId social identity provider id/name
  * @returns {Promise} a promise that resolves a social identity provider object
  */
 
-export async function getSocialIdentityProviderById(id) {
+export async function getSocialProvider(providerId) {
   return getSocialIdentityProviders().then(response => {
-    const foundProviders = response.result.filter(provider => provider._id === id);
+    const foundProviders = response.result.filter(provider => provider._id === providerId);
 
     switch (foundProviders.length) {
       case 1:
         return foundProviders[0];
 
       case 0:
-        throw new Error(`Provider '${id}' not found`);
+        throw new Error(`Provider '${providerId}' not found`);
 
       default:
-        throw new Error(`${foundProviders.length} providers '${id}' found`);
+        throw new Error(`${foundProviders.length} providers '${providerId}' found`);
     }
   });
 }
 /**
  * Export provider by id
- * @param {String} id provider id/name
+ * @param {String} providerId provider id/name
  * @param {String} file optional export file name
  */
 
-export async function exportProvider(id, file = '') {
+export async function exportSocialProviderToFile(providerId, file = '') {
   let fileName = file;
 
   if (!fileName) {
-    fileName = getTypedFilename(id, 'idp');
+    fileName = getTypedFilename(providerId, 'idp');
   }
 
-  createProgressIndicator(1, `Exporting ${id}`);
+  createProgressIndicator(1, `Exporting ${providerId}`);
 
   try {
-    const idpData = await getSocialIdentityProviderById(id);
+    const idpData = await getSocialProvider(providerId);
     updateProgressIndicator(`Writing file ${fileName}`);
     const fileData = getFileDataTemplate();
     fileData.idp[idpData._id] = idpData;
@@ -78,7 +79,7 @@ export async function exportProvider(id, file = '') {
     }
 
     saveJsonToFile(fileData, fileName);
-    stopProgressIndicator(`Exported ${id['brightCyan']} to ${fileName['brightCyan']}.`);
+    stopProgressIndicator(`Exported ${providerId['brightCyan']} to ${fileName['brightCyan']}.`);
   } catch (err) {
     stopProgressIndicator(`${err}`);
     printMessage(`${err}`, 'error');
@@ -89,7 +90,7 @@ export async function exportProvider(id, file = '') {
  * @param {String} file optional export file name
  */
 
-export async function exportProvidersToFile(file) {
+export async function exportSocialProvidersToFile(file) {
   let fileName = file;
 
   if (!fileName) {
@@ -119,7 +120,7 @@ export async function exportProvidersToFile(file) {
  * Export all providers to individual files
  */
 
-export async function exportProvidersToFiles() {
+export async function exportSocialProvidersToFiles() {
   const allIdpsData = await (await getSocialIdentityProviders()).result; // printMessage(allIdpsData, 'data');
 
   createProgressIndicator(allIdpsData.length, 'Exporting providers');
@@ -144,11 +145,11 @@ export async function exportProvidersToFiles() {
 }
 /**
  * Import provider by id/name
- * @param {String} id provider id/name
+ * @param {String} providerId provider id/name
  * @param {String} file import file name
  */
 
-export async function importProviderById(id, file) {
+export async function importSocialProviderFromFile(providerId, file) {
   fs.readFile(file, 'utf8', async (err, data) => {
     if (err) throw err;
     const fileData = JSON.parse(data);
@@ -159,7 +160,7 @@ export async function importProviderById(id, file) {
 
       for (const idpId in fileData.idp) {
         if ({}.hasOwnProperty.call(fileData.idp, idpId)) {
-          if (idpId === id) {
+          if (idpId === providerId) {
             found = true;
             updateProgressIndicator(`Importing ${fileData.idp[idpId]._id}`);
             const scriptId = fileData.idp[idpId].transform;
@@ -172,10 +173,10 @@ export async function importProviderById(id, file) {
             }
 
             putProviderByTypeAndId(fileData.idp[idpId]._type._id, idpId, fileData.idp[idpId]).then(() => {
-              stopProgressIndicator(`Successfully imported provider ${id}.`);
+              stopProgressIndicator(`Successfully imported provider ${providerId}.`);
             }).catch(importProviderErr => {
               stopProgressIndicator(`Error importing provider ${fileData.idp[idpId]._id}`);
-              printMessage(`\nError importing provider ${id}`, 'error');
+              printMessage(`\nError importing provider ${providerId}`, 'error');
               printMessage(importProviderErr.response.data, 'error');
             });
             break;
@@ -184,7 +185,7 @@ export async function importProviderById(id, file) {
       }
 
       if (!found) {
-        stopProgressIndicator(`Provider ${id.brightCyan} not found in ${file.brightCyan}!`);
+        stopProgressIndicator(`Provider ${providerId.brightCyan} not found in ${file.brightCyan}!`);
       }
     } else {
       printMessage('Import validation failed...', 'error');
@@ -196,7 +197,7 @@ export async function importProviderById(id, file) {
  * @param {String} file import file name
  */
 
-export async function importFirstProvider(file) {
+export async function importFirstSocialProviderFromFile(file) {
   fs.readFile(file, 'utf8', async (err, data) => {
     if (err) throw err;
     const fileData = JSON.parse(data);
@@ -237,7 +238,7 @@ export async function importFirstProvider(file) {
  * @param {String} file import file name
  */
 
-export async function importProvidersFromFile(file) {
+export async function importSocialProvidersFromFile(file) {
   fs.readFile(file, 'utf8', async (err, data) => {
     if (err) throw err;
     const fileData = JSON.parse(data);
@@ -275,7 +276,7 @@ export async function importProvidersFromFile(file) {
  * Import providers from *.idp.json files in current working directory
  */
 
-export async function importProvidersFromFiles() {
+export async function importSocialProvidersFromFiles() {
   const names = fs.readdirSync('.');
   const jsonFiles = names.filter(name => name.toLowerCase().endsWith('.idp.json'));
   createProgressIndicator(jsonFiles.length, 'Importing providers...');

package/esm/ops/IdpOps.test.mjs

@@ -0,0 +1,63 @@
+import axios from 'axios';
+import MockAdapter from 'axios-mock-adapter';
+import { Idp, state } from '../index';
+import * as global from '../storage/StaticStorage';
+import { mockGetSocialProviders } from '../test/mocks/ForgeRockApiMockEngine';
+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');
+state.default.session.setDeploymentType(global.CLOUD_DEPLOYMENT_TYPE_KEY);
+describe('IdpOps - exportSocialProviderToFile()', () => {
+  test('exportSocialProviderToFile() 0: Method is implemented', async () => {
+    expect(Idp.exportSocialProviderToFile).toBeDefined();
+  });
+});
+describe('IdpOps - exportSocialProvidersToFile()', () => {
+  test('exportSocialProvidersToFile() 0: Method is implemented', async () => {
+    expect(Idp.exportSocialProvidersToFile).toBeDefined();
+  });
+});
+describe('IdpOps - exportSocialProvidersToFiles()', () => {
+  test('exportSocialProvidersToFiles() 0: Method is implemented', async () => {
+    expect(Idp.exportSocialProvidersToFiles).toBeDefined();
+  });
+});
+describe('IdpOps - getSocialProvider()', () => {
+  test('getSocialProvider() 0: Method is implemented', async () => {
+    expect(Idp.getSocialProvider).toBeDefined();
+  });
+});
+describe('IdpOps - importFirstSocialProviderFromFile()', () => {
+  test('importFirstSocialProviderFromFile() 0: Method is implemented', async () => {
+    expect(Idp.importFirstSocialProviderFromFile).toBeDefined();
+  });
+});
+describe('IdpOps - importSocialProviderFromFile()', () => {
+  test('importSocialProviderFromFile() 0: Method is implemented', async () => {
+    expect(Idp.importSocialProviderFromFile).toBeDefined();
+  });
+});
+describe('IdpOps - importSocialProvidersFromFile()', () => {
+  test('importSocialProvidersFromFile() 0: Method is implemented', async () => {
+    expect(Idp.importSocialProvidersFromFile).toBeDefined();
+  });
+});
+describe('IdpOps - importSocialProvidersFromFiles()', () => {
+  test('importSocialProvidersFromFiles() 0: Method is implemented', async () => {
+    expect(Idp.importSocialProvidersFromFiles).toBeDefined();
+  });
+});
+describe('IdpOps - listSocialProviders()', () => {
+  test('listSocialProviders() 0: Method is implemented', async () => {
+    expect(Idp.listSocialProviders).toBeDefined();
+  });
+  test('listSocialProviders() 1: List social identity providers', async () => {
+    mockGetSocialProviders(mock);
+    expect.assertions(2);
+    await Idp.listSocialProviders();
+    expect(true).toBeTruthy();
+  });
+});
+//# sourceMappingURL=IdpOps.test.js.map

package/esm/ops/JourneyOps.mjs

@@ -416,15 +416,18 @@ export async function exportJourney(treeId, options = {
       const themePromiseResults = await Promise.resolve(themePromise);
 
       for (const themeObject of themePromiseResults) {
+        var _themeObject$linkedTr;
+
         if (themeObject && ( // has the theme been specified by id or name in a page node?
         themes.includes(themeObject._id) || themes.includes(themeObject.name) || // has this journey been linked to a theme?
-        themeObject.linkedTrees.includes(treeObject._id))) {
+        (_themeObject$linkedTr = themeObject.linkedTrees) !== null && _themeObject$linkedTr !== void 0 && _themeObject$linkedTr.includes(treeObject._id))) {
           if (verbose) printMessage(`    - ${themeObject._id} (${themeObject.name})`, 'info');
           exportData.themes.push(themeObject);
         }
       }
     } catch (error) {
-      printMessage(error.message, 'error');
+      printMessage(error, 'error');
+      printMessage('Error handling themes: ' + error.message, 'error');
     }
   }
 

package/esm/ops/{SamlOps.mjs → Saml2Ops.mjs}

@@ -30,19 +30,21 @@ function getFileDataTemplate() {
  */
 
 
-export async function listProviders(long = false) {
+export async function listSaml2Providers(long = false) {
   const providerList = (await getProviders()).result;
   providerList.sort((a, b) => a._id.localeCompare(b._id));
 
   if (!long) {
-    providerList.forEach(item => {
-      printMessage(`${item.entityId}`, 'data');
-    });
+    for (const provider of providerList) {
+      printMessage(`${provider.entityId}`, 'data');
+    }
   } else {
     const table = createTable(['Entity Id'['brightCyan'], 'Location'['brightCyan'], 'Role(s)'['brightCyan']]);
-    providerList.forEach(provider => {
+
+    for (const provider of providerList) {
       table.push([provider.entityId, provider.location, provider.roles.map(role => roleMap[role]).join(', ')]);
-    });
+    }
+
     printMessage(table.toString());
   }
 }
@@ -82,7 +84,7 @@ async function exportDependencies(providerData, fileData) {
  */
 
 
-export async function exportProvider(entityId, file = null) {
+export async function exportSaml2ProviderToFile(entityId, file = null) {
   let fileName = file;
 
   if (!fileName) {
@@ -136,7 +138,7 @@ export async function exportProvider(entityId, file = null) {
  * @param {String} file Optional filename
  */
 
-export async function exportMetadata(entityId, file = null) {
+export async function exportSaml2Metadata(entityId, file = null) {
   let fileName = file;
 
   if (!fileName) {
@@ -160,7 +162,7 @@ export async function exportMetadata(entityId, file = null) {
  * @param {String} entityId Provider entity id
  */
 
-export async function describeProvider(entityId) {
+export async function describeSaml2Provider(entityId) {
   try {
     const found = await findProviders(`entityId eq '${entityId}'`, 'location,roles');
 
@@ -209,7 +211,7 @@ export async function describeProvider(entityId) {
  * @param {String} file Optional filename
  */
 
-export async function exportProvidersToFile(file = null) {
+export async function exportSaml2ProvidersToFile(file = null) {
   let fileName = file;
 
   if (!fileName) {
@@ -221,9 +223,9 @@ export async function exportProvidersToFile(file = null) {
     const found = await getProviders();
 
     if (found.resultCount > 0) {
-      createProgressIndicator(found.data.resultCount, 'Exporting providers');
+      createProgressIndicator(found.resultCount, 'Exporting providers');
 
-      for (const stubData of found.data.result) {
+      for (const stubData of found.result) {
         updateProgressIndicator(`Exporting provider ${stubData.entityId}`); // eslint-disable-next-line no-await-in-loop
 
         const providerData = await getProviderByLocationAndId(stubData.location, stubData._id); // eslint-disable-next-line no-await-in-loop
@@ -233,7 +235,7 @@ export async function exportProvidersToFile(file = null) {
       }
 
       saveJsonToFile(fileData, fileName);
-      stopProgressIndicator(`${found.data.resultCount} providers exported to ${fileName}.`);
+      stopProgressIndicator(`${found.resultCount} providers exported to ${fileName}.`);
     } else {
       printMessage('No entity providers found.', 'info');
     }
@@ -248,13 +250,13 @@ export async function exportProvidersToFile(file = null) {
  * Export all entity providers to individual files
  */
 
-export async function exportProvidersToFiles() {
+export async function exportSaml2ProvidersToFiles() {
   const found = await getProviders();
 
   if (found.resultCount > 0) {
-    createProgressIndicator(found.data.resultCount, 'Exporting providers');
+    createProgressIndicator(found.resultCount, 'Exporting providers');
 
-    for (const stubData of found.data.result) {
+    for (const stubData of found.result) {
       updateProgressIndicator(`Exporting provider ${stubData.entityId}`);
       const fileName = getTypedFilename(stubData.entityId, 'saml');
       const fileData = getFileDataTemplate(); // eslint-disable-next-line no-await-in-loop
@@ -266,7 +268,7 @@ export async function exportProvidersToFiles() {
       saveJsonToFile(fileData, fileName);
     }
 
-    stopProgressIndicator(`${found.data.resultCount} providers exported.`);
+    stopProgressIndicator(`${found.resultCount} providers exported.`);
   } else {
     printMessage('No entity providers found.', 'info');
   }
@@ -322,7 +324,7 @@ function getLocation(entityId64, fileData) {
  */
 
 
-export async function importProvider(entityId, file) {
+export async function importSaml2ProviderFromFile(entityId, file) {
   const entityId64 = encode(entityId, false);
   fs.readFile(file, 'utf8', async (err, data) => {
     if (err) throw err;
@@ -362,7 +364,7 @@ export async function importProvider(entityId, file) {
  * @param {String} file Import file name
  */
 
-export async function importFirstProvider(file) {
+export async function importFirstSaml2ProviderFromFile(file) {
   fs.readFile(file, 'utf8', async (err, data) => {
     if (err) throw err;
     const fileData = JSON.parse(data);
@@ -417,7 +419,7 @@ export async function importFirstProvider(file) {
  * @param {String} file Import file name
  */
 
-export async function importProvidersFromFile(file) {
+export async function importSaml2ProvidersFromFile(file) {
   fs.readFile(file, 'utf8', async (err, data) => {
     if (err) throw err;
     const fileData = JSON.parse(data);
@@ -465,7 +467,7 @@ export async function importProvidersFromFile(file) {
  * Import all SAML entity providers from all *.saml.json files in the current directory
  */
 
-export async function importProvidersFromFiles() {
+export async function importSaml2ProvidersFromFiles() {
   const names = fs.readdirSync('.');
   const jsonFiles = names.filter(name => name.toLowerCase().endsWith('.saml.json'));
   createProgressIndicator(jsonFiles.length, 'Importing providers...');
@@ -518,4 +520,4 @@ export async function importProvidersFromFiles() {
 
   stopProgressIndicator(`Imported ${total - totalErrors} of ${total} provider(s) from ${jsonFiles.length} file(s).`);
 }
-//# sourceMappingURL=SamlOps.js.map
+//# sourceMappingURL=Saml2Ops.js.map

package/esm/ops/Saml2Ops.test.mjs

@@ -0,0 +1,89 @@
+import axios from 'axios';
+import MockAdapter from 'axios-mock-adapter';
+import { Saml2, state } from '../index';
+import * as global from '../storage/StaticStorage';
+import { mockGetSaml2Providers, mockFindSaml2Providers, mockGetSaml2ProviderByLocationAndId, mockGetSaml2ProviderMetadata } from '../test/mocks/ForgeRockApiMockEngine';
+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');
+state.default.session.setDeploymentType(global.CLOUD_DEPLOYMENT_TYPE_KEY);
+describe('Saml2Ops - describeSaml2Provider()', () => {
+  test('describeSaml2Provider() 0: Method is implemented', async () => {
+    expect(Saml2.describeSaml2Provider).toBeDefined();
+  });
+  test('describeSaml2Provider() 1: Describe saml2 entity provider', async () => {
+    mockFindSaml2Providers(mock);
+    mockGetSaml2ProviderByLocationAndId(mock);
+    mockGetSaml2ProviderMetadata(mock);
+    expect.assertions(2);
+    await Saml2.describeSaml2Provider('iSPAzure');
+    expect(true).toBeTruthy();
+  });
+});
+describe('Saml2Ops - exportSaml2Metadata()', () => {
+  test('exportSaml2Metadata() 0: Method is implemented', async () => {
+    expect(Saml2.exportSaml2Metadata).toBeDefined();
+  });
+  test('describeSaml2Provider() 1: Export hosted saml2 entity provider metadata', async () => {
+    mockGetSaml2ProviderMetadata(mock);
+    expect.assertions(2);
+    await Saml2.exportSaml2Metadata('iSPAzure');
+    expect(true).toBeTruthy();
+  });
+  test('describeSaml2Provider() 2: Export remote saml2 entity provider metadata', async () => {
+    mockGetSaml2ProviderMetadata(mock);
+    expect.assertions(2);
+    await Saml2.exportSaml2Metadata('urn:federation:MicrosoftOnline');
+    expect(true).toBeTruthy();
+  });
+});
+describe('Saml2Ops - exportSaml2ProviderToFile()', () => {
+  test('exportSaml2ProviderToFile() 0: Method is implemented', async () => {
+    expect(Saml2.exportSaml2ProviderToFile).toBeDefined();
+  });
+});
+describe('Saml2Ops - exportSaml2ProvidersToFile()', () => {
+  test('exportSaml2ProvidersToFile() 0: Method is implemented', async () => {
+    expect(Saml2.exportSaml2ProvidersToFile).toBeDefined();
+  });
+});
+describe('Saml2Ops - exportSaml2ProvidersToFiles()', () => {
+  test('exportSaml2ProvidersToFiles() 0: Method is implemented', async () => {
+    expect(Saml2.exportSaml2ProvidersToFiles).toBeDefined();
+  });
+});
+describe('Saml2Ops - importFirstSaml2ProviderFromFile()', () => {
+  test('importFirstSaml2ProviderFromFile() 0: Method is implemented', async () => {
+    expect(Saml2.importFirstSaml2ProviderFromFile).toBeDefined();
+  });
+});
+describe('Saml2Ops - importSaml2ProviderFromFile()', () => {
+  test('importSaml2ProviderFromFile() 0: Method is implemented', async () => {
+    expect(Saml2.importSaml2ProviderFromFile).toBeDefined();
+  });
+});
+describe('Saml2Ops - importSaml2ProvidersFromFile()', () => {
+  test('importSaml2ProvidersFromFile() 0: Method is implemented', async () => {
+    expect(Saml2.importSaml2ProvidersFromFile).toBeDefined();
+  });
+});
+describe('Saml2Ops - importSaml2ProvidersFromFiles()', () => {
+  test('importSaml2ProvidersFromFiles() 0: Method is implemented', async () => {
+    expect(Saml2.importSaml2ProvidersFromFiles).toBeDefined();
+  });
+});
+describe('Saml2Ops - listSaml2Providers()', () => {
+  mockGetSaml2Providers(mock);
+  test('listSaml2Providers() 0: Method is implemented', async () => {
+    expect(Saml2.listSaml2Providers).toBeDefined();
+  });
+  test('listSaml2Providers() 1: List saml2 entity providers', async () => {
+    mockGetSaml2Providers(mock);
+    expect.assertions(2);
+    await Saml2.listSaml2Providers();
+    expect(true).toBeTruthy();
+  });
+});
+//# sourceMappingURL=Saml2Ops.test.js.map

package/esm/test/mocks/ForgeRockApiMockEngine.mjs

@@ -251,6 +251,13 @@ export function mockPutSocialProviderByTypeAndId(mock, callback) {
  * IDM Mocks and Utils
  */
 
+export function mockListAllConfigEntities(mock) {
+  mock.onGet(/.*?\/openidm\/config$/).reply(function () {
+    const mockStatus = 200;
+    const mockResponse = JSON.parse(fs.readFileSync(path.resolve(__dirname, `./IdmConfigApi/getAllConfigEntities/entities.json`), 'utf8'));
+    return [mockStatus, mockResponse];
+  });
+}
 export function mockGetConfigEntity(mock) {
   mock.onGet(/.*?\/openidm\/config\/.+/).reply(function (config) {
     const entityId = config.url ? config.url.substring(config.url.indexOf('/config/') + 8) : '';