@rockcarver/frodo-lib 0.16.2-9 → 0.17.1

package/esm/ops/Saml2Ops.test.mjs

@@ -9,19 +9,17 @@ import { isEqualJson } from './utils/OpsUtils';
 import { mockCreateSaml2Provider } from '../test/mocks/ForgeRockApiMockEngine';
 import { convertTextArrayToBase64Url } from './utils/ExportImportUtils';
 const mock = new MockAdapter(axios);
-
 const outputHandler = message => {
   console.log(message);
 };
-
-state.default.session.setTenant('https://openam-volker-dev.forgeblocks.com/am');
-state.default.session.setRealm('alpha');
-state.default.session.setCookieName('cookieName');
-state.default.session.setCookieValue('cookieValue');
-state.default.session.setDeploymentType(globalConfig.CLOUD_DEPLOYMENT_TYPE_KEY);
-state.default.session.setDebug(true);
-state.default.session.setDebugHandler(outputHandler);
-state.default.session.setPrintHandler(outputHandler);
+state.setHost('https://openam-volker-dev.forgeblocks.com/am');
+state.setRealm('alpha');
+state.setCookieName('cookieName');
+state.setCookieValue('cookieValue');
+state.setDeploymentType(globalConfig.CLOUD_DEPLOYMENT_TYPE_KEY);
+state.setDebug(true);
+state.setDebugHandler(outputHandler);
+state.setPrintHandler(outputHandler);
 describe('Saml2Ops - createSaml2ExportTemplate()', () => {
   test('createSaml2ExportTemplate() 0: Method is implemented', async () => {
     expect(Saml2.createSaml2ExportTemplate).toBeDefined();
@@ -244,8 +242,8 @@ describe('Saml2Ops - importSaml2Provider()', () => {
       expect(mockSaml2ProviderId64).toEqual(entityId64);
       expect(mockSaml2ProviderLocation).toEqual(entityLocation);
       expect(isEqualJson(importData.saml[entityLocation][entityId64], mockSaml2ProviderObj, ['_rev'])).toBeTruthy();
-    }); // expect 5 assertions because import contains 1 script
-
+    });
+    // expect 5 assertions because import contains 1 script
     expect.assertions(5);
     await Saml2.importSaml2Provider(entityId, importData);
   });
@@ -262,8 +260,8 @@ describe('Saml2Ops - importSaml2Provider()', () => {
       expect(mockSaml2ProviderId64).toEqual(entityId64);
       expect(mockSaml2ProviderLocation).toEqual(entityLocation);
       expect(isEqualJson(importData.saml[entityLocation][entityId64], mockSaml2ProviderObj, ['_rev'])).toBeTruthy();
-    }); // expect 7 assertions because import contains 2 scripts
-
+    });
+    // expect 7 assertions because import contains 2 scripts
     expect.assertions(7);
     await Saml2.importSaml2Provider(entityId, importData);
   });
@@ -278,11 +276,11 @@ describe('Saml2Ops - importSaml2Provider()', () => {
     });
     mockCreateSaml2Provider(mock, (mockSaml2ProviderId64, mockSaml2ProviderLocation, mockSaml2ProviderObj) => {
       expect(mockSaml2ProviderId64).toEqual(entityId64);
-      expect(mockSaml2ProviderLocation).toEqual(entityLocation); // this is an import of a remote identity provider, which can only be done using SAML2 metadata
-
+      expect(mockSaml2ProviderLocation).toEqual(entityLocation);
+      // this is an import of a remote identity provider, which can only be done using SAML2 metadata
       expect(mockSaml2ProviderObj.standardMetadata).toEqual(convertTextArrayToBase64Url(importData.saml.metadata[entityId64]));
-    }); // expect only 3 assertions because import contains no scripts
-
+    });
+    // expect only 3 assertions because import contains no scripts
     expect.assertions(3);
     await Saml2.importSaml2Provider(entityId, importData);
   });
@@ -305,12 +303,11 @@ describe('Saml2Ops - importSaml2Providers()', () => {
     });
     mockCreateSaml2Provider(mock, (mockSaml2ProviderId64, mockSaml2ProviderLocation, mockSaml2ProviderObj) => {
       expect(allEntityIds64).toContain(mockSaml2ProviderId64);
-      expect(mockSaml2ProviderLocation).toEqual(hostedEntityIds64.includes(mockSaml2ProviderId64) ? Saml2ProiderLocation.HOSTED : Saml2ProiderLocation.REMOTE); // for hosted providers compare the provider config, for remote providers compare the metadata
-
+      expect(mockSaml2ProviderLocation).toEqual(hostedEntityIds64.includes(mockSaml2ProviderId64) ? Saml2ProiderLocation.HOSTED : Saml2ProiderLocation.REMOTE);
+      // for hosted providers compare the provider config, for remote providers compare the metadata
       expect(isEqualJson(importData.saml[mockSaml2ProviderLocation][mockSaml2ProviderId64], mockSaml2ProviderObj, ['_rev']) || mockSaml2ProviderObj.standardMetadata === convertTextArrayToBase64Url(importData.saml.metadata[mockSaml2ProviderId64])).toBeTruthy();
       hostedEntityIds64 = hostedEntityIds64.filter(saml2ProviderId64 => saml2ProviderId64 !== mockSaml2ProviderId64);
       remoteEntityIds64 = remoteEntityIds64.filter(saml2ProviderId64 => saml2ProviderId64 !== mockSaml2ProviderId64);
-
       if (mockSaml2ProviderObj.standardMetadata) {
         metaDataIds64 = metaDataIds64.filter(saml2ProviderId64 => saml2ProviderId64 !== mockSaml2ProviderId64);
       }
@@ -319,8 +316,8 @@ describe('Saml2Ops - importSaml2Providers()', () => {
     await Saml2.importSaml2Providers(importData);
     expect(scriptIds.length).toBe(0);
     expect(hostedEntityIds64.length).toBe(0);
-    expect(remoteEntityIds64.length).toBe(0); // frodo exports metadata for both hosted and remote providers but on import it is only required for remote providers
-
+    expect(remoteEntityIds64.length).toBe(0);
+    // frodo exports metadata for both hosted and remote providers but on import it is only required for remote providers
     expect(metaDataIds64.length).toBe(6);
   });
 });

package/esm/ops/ScriptOps.mjs

@@ -5,16 +5,15 @@ import { createProgressIndicator, createTable, printMessage, stopProgressIndicat
 import { getScriptByName, getScripts, putScript } from '../api/ScriptApi';
 import wordwrap from './utils/Wordwrap';
 import { convertBase64TextToArray, convertTextArrayToBase64, getTypedFilename, saveToFile, titleCase, validateImport } from './utils/ExportImportUtils';
-import storage from '../storage/SessionStorage';
+import * as state from '../shared/State';
+
 /**
  * List scripts
  */
-
 export async function listScripts(long = false) {
   try {
     const scripts = (await getScripts()).result;
     scripts.sort((a, b) => a.name.localeCompare(b.name));
-
     if (long) {
       const table = createTable(['Name', 'UUID', 'Language', 'Context', 'Description']);
       const langMap = {
@@ -34,93 +33,83 @@ export async function listScripts(long = false) {
     printMessage(`Error listing scripts - ${error}`, 'error');
   }
 }
+
 /**
  * Export script to file
  * @param {String} name script name
  * @param {String} file file name
  */
-
 export async function exportScriptByName(name, file) {
   let fileName = getTypedFilename(name, 'script');
-
   if (file) {
     fileName = file;
   }
-
   const scriptData = (await getScriptByName(name)).result;
-
   if (scriptData.length > 1) {
     printMessage(`Multiple scripts with name ${name} found...`, 'error');
   }
-
   scriptData.forEach(element => {
-    const scriptTextArray = convertBase64TextToArray(element.script); // eslint-disable-next-line no-param-reassign
-
+    const scriptTextArray = convertBase64TextToArray(element.script);
+    // eslint-disable-next-line no-param-reassign
     element.script = scriptTextArray;
   });
   saveToFile('script', scriptData, '_id', fileName);
 }
+
 /**
  * Export all scripts to single file
  * @param {String} file file name
  */
-
 export async function exportScriptsToFile(file) {
-  let fileName = getTypedFilename(`all${storage.session.getRealm()}Scripts`, 'script');
-
+  let fileName = getTypedFilename(`all${state.getRealm()}Scripts`, 'script');
   if (file) {
     fileName = file;
   }
-
   const scriptList = (await getScripts()).result;
   const allScriptsData = [];
   createProgressIndicator(scriptList.length, 'Exporting script');
-
   for (const item of scriptList) {
-    updateProgressIndicator(`Reading script ${item.name}`); // eslint-disable-next-line no-await-in-loop
-
+    updateProgressIndicator(`Reading script ${item.name}`);
+    // eslint-disable-next-line no-await-in-loop
     const scriptData = (await getScriptByName(item.name)).result;
     scriptData.forEach(element => {
-      const scriptTextArray = convertBase64TextToArray(element.script); // eslint-disable-next-line no-param-reassign
-
+      const scriptTextArray = convertBase64TextToArray(element.script);
+      // eslint-disable-next-line no-param-reassign
       element.script = scriptTextArray;
       allScriptsData.push(element);
     });
   }
-
   stopProgressIndicator('Done');
   saveToFile('script', allScriptsData, '_id', fileName);
 }
+
 /**
  * Export all scripts to individual files
  */
-
 export async function exportScriptsToFiles() {
   const scriptList = (await getScripts()).result;
   createProgressIndicator(scriptList.length, 'Exporting script');
-
   for (const item of scriptList) {
-    updateProgressIndicator(`Reading script ${item.name}`); // eslint-disable-next-line no-await-in-loop
-
+    updateProgressIndicator(`Reading script ${item.name}`);
+    // eslint-disable-next-line no-await-in-loop
     const scriptData = (await getScriptByName(item.name)).result;
     scriptData.forEach(element => {
-      const scriptTextArray = convertBase64TextToArray(element.script); // eslint-disable-next-line no-param-reassign
-
+      const scriptTextArray = convertBase64TextToArray(element.script);
+      // eslint-disable-next-line no-param-reassign
       element.script = scriptTextArray;
     });
     const fileName = getTypedFilename(item.name, 'script');
     saveToFile('script', scriptData, '_id', fileName);
   }
-
   stopProgressIndicator('Done');
 }
+
 /**
  * Import script
  * @param {String} id script uuid
  * @param {Object} data script object
  * @returns {Object} a status object
  */
-
 export async function createOrUpdateScript(id, data) {
   try {
     await putScript(id, data);
@@ -130,13 +119,12 @@ export async function createOrUpdateScript(id, data) {
     };
   } catch (e) {
     var _e$response;
-
     if (((_e$response = e.response) === null || _e$response === void 0 ? void 0 : _e$response.status) === 409) {
       printMessage(`createOrUpdateScript WARNING: script with name ${data.name} already exists, using renaming policy... <name> => <name - imported (n)>`, 'warn');
-      const newName = applyNameCollisionPolicy(data.name); // console.log(newName);
-
-      printMessage(`Trying to save script as ${newName}`, 'warn'); // eslint-disable-next-line no-param-reassign
-
+      const newName = applyNameCollisionPolicy(data.name);
+      // console.log(newName);
+      printMessage(`Trying to save script as ${newName}`, 'warn');
+      // eslint-disable-next-line no-param-reassign
       data.name = newName;
       await createOrUpdateScript(id, data);
       return {
@@ -144,7 +132,6 @@ export async function createOrUpdateScript(id, data) {
         name: data.name
       };
     }
-
     printMessage(`createOrUpdateScript ERROR: put script error, script ${id} - ${e.message}`, 'error');
     return {
       error: true,
@@ -156,42 +143,37 @@ export async function importScriptsFromFile(name, file, reUuid = false) {
   fs.readFile(file, 'utf8', (err, data) => {
     if (err) throw err;
     const scriptData = JSON.parse(data);
-
     if (validateImport(scriptData.meta)) {
       createProgressIndicator(Object.keys(scriptData.script).length, '');
-
       for (const existingId in scriptData.script) {
         if ({}.hasOwnProperty.call(scriptData.script, existingId)) {
-          let newId = existingId; // console.log(id);
-
+          let newId = existingId;
+          // console.log(id);
           const encodedScript = convertTextArrayToBase64(scriptData.script[existingId].script);
           scriptData.script[existingId].script = encodedScript;
-
           if (reUuid) {
-            newId = uuidv4(); // printMessage(
+            newId = uuidv4();
+            // printMessage(
             //   `Re-uuid-ing script ${scriptData.script[existingId].name} ${existingId} => ${newId}...`
             // );
-
             scriptData.script[existingId]._id = newId;
           }
-
           if (name) {
             // printMessage(
             //   `Renaming script ${scriptData.script[existingId].name} => ${options.script}...`
             // );
             scriptData.script[existingId].name = name;
           }
-
-          updateProgressIndicator(`Importing ${scriptData.script[existingId].name}`); // console.log(scriptData.script[id]);
-
+          updateProgressIndicator(`Importing ${scriptData.script[existingId].name}`);
+          // console.log(scriptData.script[id]);
           createOrUpdateScript(newId, scriptData.script[existingId]).then(result => {
             if (result == null) printMessage(`Error importing ${scriptData.script[existingId].name}`, 'error');
           });
           if (name) break;
         }
       }
-
-      stopProgressIndicator('Done'); // printMessage('Done');
+      stopProgressIndicator('Done');
+      // printMessage('Done');
     } else {
       printMessage('Import validation failed...', 'error');
     }

package/esm/ops/SecretsOps.mjs

@@ -2,21 +2,19 @@ import { createKeyValueTable, createProgressIndicator, createTable, printMessage
 import { createNewVersionOfSecret, deleteSecret, deleteVersionOfSecret, getSecret, getSecrets, getSecretVersions, putSecret, setSecretDescription, setStatusOfVersionOfSecret, VersionOfSecretStatus } from '../api/SecretsApi';
 import wordwrap from './utils/Wordwrap';
 import { resolveUserName } from './ManagedObjectOps';
+
 /**
  * List secrets
  * @param {boolean} long Long version, all the fields
  */
-
 export async function listSecrets(long) {
   let secrets = [];
-
   try {
     secrets = (await getSecrets()).result;
   } catch (error) {
     printMessage(`${error.message}`, 'error');
     printMessage(error.response.data, 'error');
   }
-
   if (long) {
     const table = createTable(['Id'['brightCyan'], {
       hAlign: 'right',
@@ -26,7 +24,6 @@ export async function listSecrets(long) {
       content: 'Loaded\nVersion'['brightCyan']
     }, 'Status'['brightCyan'], 'Description'['brightCyan'], 'Modifier'['brightCyan'], 'Modified'['brightCyan']]);
     secrets.sort((a, b) => a._id.localeCompare(b._id));
-
     for (const secret of secrets) {
       table.push([secret._id, {
         hAlign: 'right',
@@ -34,10 +31,10 @@ export async function listSecrets(long) {
       }, {
         hAlign: 'right',
         content: secret.loadedVersion
-      }, secret.loaded ? 'loaded'['brightGreen'] : 'unloaded'['brightRed'], wordwrap(secret.description, 40), // eslint-disable-next-line no-await-in-loop
+      }, secret.loaded ? 'loaded'['brightGreen'] : 'unloaded'['brightRed'], wordwrap(secret.description, 40),
+      // eslint-disable-next-line no-await-in-loop
       await resolveUserName('teammember', secret.lastChangedBy), new Date(secret.lastChangeDate).toLocaleString()]);
     }
-
     printMessage(table.toString());
   } else {
     secrets.forEach(secret => {
@@ -45,6 +42,7 @@ export async function listSecrets(long) {
     });
   }
 }
+
 /**
  * Create secret
  * @param {String} id secret id
@@ -53,10 +51,8 @@ export async function listSecrets(long) {
  * @param {String} encoding secret encoding
  * @param {boolean} useInPlaceholders use secret in placeholders
  */
-
 export async function createSecret(id, value, description, encoding, useInPlaceholders) {
   createProgressIndicator(undefined, `Creating secret ${id}...`, 'indeterminate');
-
   try {
     await putSecret(id, value, description, encoding, useInPlaceholders);
     stopProgressIndicator(`Created secret ${id}`, 'success');
@@ -64,15 +60,14 @@ export async function createSecret(id, value, description, encoding, useInPlaceh
     stopProgressIndicator(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'fail');
   }
 }
+
 /**
  * Set description of secret
  * @param {String} secretId secret id
  * @param {String} description secret description
  */
-
 export async function setDescriptionOfSecret(secretId, description) {
   createProgressIndicator(undefined, `Setting description of secret ${secretId}...`, 'indeterminate');
-
   try {
     await setSecretDescription(secretId, description);
     stopProgressIndicator(`Set description of secret ${secretId}`, 'success');
@@ -80,14 +75,13 @@ export async function setDescriptionOfSecret(secretId, description) {
     stopProgressIndicator(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'fail');
   }
 }
+
 /**
  * Delete a secret
  * @param {String} secretId secret id
  */
-
 export async function deleteSecretCmd(secretId) {
   createProgressIndicator(undefined, `Deleting secret ${secretId}...`, 'indeterminate');
-
   try {
     await deleteSecret(secretId);
     stopProgressIndicator(`Deleted secret ${secretId}`, 'success');
@@ -95,15 +89,14 @@ export async function deleteSecretCmd(secretId) {
     stopProgressIndicator(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'fail');
   }
 }
+
 /**
  * Delete all secrets
  */
-
 export async function deleteSecretsCmd() {
   try {
     const secrets = (await getSecrets()).result;
     createProgressIndicator(secrets.length, `Deleting secrets...`);
-
     for (const secret of secrets) {
       try {
         // eslint-disable-next-line no-await-in-loop
@@ -113,52 +106,47 @@ export async function deleteSecretsCmd() {
         printMessage(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'error');
       }
     }
-
     stopProgressIndicator(`Secrets deleted.`);
   } catch (error) {
     printMessage(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'error');
   }
 }
+
 /**
  * List all the versions of the secret
  * @param {String} secretId secret id
  */
-
 export async function listSecretVersionsCmd(secretId) {
   let versions = [];
-
   try {
     versions = await getSecretVersions(secretId);
   } catch (error) {
     printMessage(`${error.message}`, 'error');
     printMessage(error.response.data, 'error');
   }
-
   const table = createTable([{
     hAlign: 'right',
     content: 'Version'['brightCyan']
-  }, 'Status'['brightCyan'], 'Loaded'['brightCyan'], 'Created'['brightCyan']]); // versions.sort((a, b) => a._id.localeCompare(b._id));
-
+  }, 'Status'['brightCyan'], 'Loaded'['brightCyan'], 'Created'['brightCyan']]);
+  // versions.sort((a, b) => a._id.localeCompare(b._id));
   const statusMap = {
     ENABLED: 'active'['brightGreen'],
     DISABLED: 'inactive'['brightRed'],
     DESTROYED: 'deleted'['brightRed']
   };
-
   for (const version of versions) {
     table.push([{
       hAlign: 'right',
       content: version.version
     }, statusMap[version.status], version.loaded ? 'loaded'['brightGreen'] : 'unloaded'['brightRed'], new Date(version.createDate).toLocaleString()]);
   }
-
   printMessage(table.toString());
 }
+
 /**
  * Describe a secret
  * @param {String} secretId Secret id
  */
-
 export async function describeSecret(secretId) {
   const secret = await getSecret(secretId);
   const table = createKeyValueTable();
@@ -176,15 +164,14 @@ export async function describeSecret(secretId) {
   printMessage('\nSecret Versions:');
   await listSecretVersionsCmd(secretId);
 }
+
 /**
  * Create new version of secret
  * @param {String} secretId secret id
  * @param {String} value secret value
  */
-
 export async function createNewVersionOfSecretCmd(secretId, value) {
   createProgressIndicator(undefined, `Creating new version of secret ${secretId}...`, 'indeterminate');
-
   try {
     const version = await createNewVersionOfSecret(secretId, value);
     stopProgressIndicator(`Created version ${version.version} of secret ${secretId}`, 'success');
@@ -192,15 +179,14 @@ export async function createNewVersionOfSecretCmd(secretId, value) {
     stopProgressIndicator(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'fail');
   }
 }
+
 /**
  * Activate a version of a secret
  * @param {String} secretId secret id
  * @param {Number} version version of secret
  */
-
 export async function activateVersionOfSecret(secretId, version) {
   createProgressIndicator(undefined, `Activating version ${version} of secret ${secretId}...`, 'indeterminate');
-
   try {
     await setStatusOfVersionOfSecret(secretId, version, VersionOfSecretStatus.ENABLED);
     stopProgressIndicator(`Activated version ${version} of secret ${secretId}`, 'success');
@@ -208,15 +194,14 @@ export async function activateVersionOfSecret(secretId, version) {
     stopProgressIndicator(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'fail');
   }
 }
+
 /**
  * Deactivate a version of a secret
  * @param {String} secretId secret id
  * @param {Number} version version of secret
  */
-
 export async function deactivateVersionOfSecret(secretId, version) {
   createProgressIndicator(undefined, `Deactivating version ${version} of secret ${secretId}...`, 'indeterminate');
-
   try {
     await setStatusOfVersionOfSecret(secretId, version, VersionOfSecretStatus.DISABLED);
     stopProgressIndicator(`Deactivated version ${version} of secret ${secretId}`, 'success');
@@ -224,15 +209,14 @@ export async function deactivateVersionOfSecret(secretId, version) {
     stopProgressIndicator(`Error: ${error.response.data.code} - ${error.response.data.message}`, 'fail');
   }
 }
+
 /**
  * Delete version of secret
  * @param {String} secretId secret id
  * @param {Number} version version of secret
  */
-
 export async function deleteVersionOfSecretCmd(secretId, version) {
   createProgressIndicator(undefined, `Deleting version ${version} of secret ${secretId}...`, 'indeterminate');
-
   try {
     await deleteVersionOfSecret(secretId, version);
     stopProgressIndicator(`Deleted version ${version} of secret ${secretId}`, 'success');

package/esm/ops/ServiceAccountOps.mjs

@@ -0,0 +1,41 @@
+import { createManagedObject } from '../api/ManagedObjectApi';
+import { debugMessage } from './utils/Console';
+import { getConfigEntity } from './IdmOps';
+const moType = 'svcacct';
+let serviceAccountsFeatureAvailable = undefined;
+export async function isServiceAccountsFeatureAvailable() {
+  debugMessage(`ServiceAccountOps.isServiceAccountsFeatureAvailable: start`);
+  // only look up the schema once
+  if (typeof serviceAccountsFeatureAvailable !== 'undefined') return serviceAccountsFeatureAvailable;
+  serviceAccountsFeatureAvailable = false;
+  const schema = await getConfigEntity('managed');
+  for (const object of schema['objects']) {
+    if (object['name'] === 'svcacct') serviceAccountsFeatureAvailable = true;
+  }
+  debugMessage(`ServiceAccountOps.isServiceAccountsFeatureAvailable: end, available=${serviceAccountsFeatureAvailable}`);
+  return serviceAccountsFeatureAvailable;
+}
+
+/**
+ * Create service account
+ * @param {string} name Human-readable name of service account
+ * @param {string} description Description of service account
+ * @param {'Active' | 'Inactive'} accountStatus Service account status
+ * @param {string[]} scopes Scopes.
+ * @param {JwksInterface} jwks Java Web Key Set
+ * @returns {Promise<ObjectSkeletonInterface>} A promise resolving to a service account object
+ */
+export async function createServiceAccount(name, description, accountStatus, scopes, jwks) {
+  const payload = {
+    name,
+    description,
+    accountStatus,
+    scopes,
+    jwks: JSON.stringify(jwks)
+  };
+  debugMessage(`SvcacctOps: createSvcacct: payload:`);
+  debugMessage(payload);
+  const result = await createManagedObject(moType, payload);
+  return result;
+}
+//# sourceMappingURL=ServiceAccountOps.js.map

package/esm/ops/ServiceAccountOps.test.mjs

@@ -0,0 +1,51 @@
+import axios from 'axios';
+import MockAdapter from 'axios-mock-adapter';
+import { state } from '../index';
+import * as globalConfig from '../storage/StaticStorage';
+import { createJwkRsa, createJwks, getJwkRsaPublic } from './JoseOps';
+import * as ServiceAccount from './ServiceAccountOps';
+import { mockCreateManagedObject } from '../test/mocks/ForgeRockApiMockEngine';
+import { isEqualJson } from './utils/OpsUtils';
+const mock = new MockAdapter(axios);
+const outputHandler = message => {
+  console.log(message);
+};
+state.setHost('https://openam-frodo-dev.forgeblocks.com/am');
+state.setRealm('alpha');
+state.setCookieName('cookieName');
+state.setCookieValue('cookieValue');
+state.setDeploymentType(globalConfig.CLOUD_DEPLOYMENT_TYPE_KEY);
+state.setDebug(true);
+state.setDebugHandler(outputHandler);
+state.setPrintHandler(outputHandler);
+state.setCurlirize(true);
+state.setCurlirizeHandler(outputHandler);
+describe('SvcacctOps - createSvcacct()', () => {
+  test('createSvcacct() 0: Method is implemented', async () => {
+    expect(ServiceAccount.createServiceAccount).toBeDefined();
+  });
+  test('createSvcacct() 1: Create service account', async () => {
+    let moId = null;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let moData = null;
+    const name = 'sa';
+    const description = 'service account';
+    const accountStatus = 'Active';
+    const scopes = ['fr:am:*', 'fr:idm:*', 'fr:idc:esv:*'];
+    const jwk = await createJwkRsa();
+    const publicJwk = await getJwkRsaPublic(jwk);
+    const jwks = await createJwks(publicJwk);
+    mockCreateManagedObject(mock, (mockManagedObjId, mockManagedObj) => {
+      moId = mockManagedObjId;
+      moData = mockManagedObj;
+    });
+    const payload = await ServiceAccount.createServiceAccount(name, description, accountStatus, scopes, jwks);
+    expect(isEqualJson(payload, moData)).toBeTruthy();
+    expect(payload).toBeTruthy();
+    expect(payload._id).toBe(moId);
+    expect(payload.name).toBe(name);
+    expect(payload.description).toBe(description);
+    expect(payload.scopes).toStrictEqual(scopes);
+  });
+});
+//# sourceMappingURL=ServiceAccountOps.test.js.map