@rockcarver/frodo-lib 0.12.1 → 0.12.2-0

package/esm/api/NodeApi.test.mjs

@@ -0,0 +1,105 @@
+import axios from 'axios';
+import MockAdapter from 'axios-mock-adapter';
+import { NodeRaw, 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('');
+state.default.session.setRealm('alpha');
+state.default.session.setCookieName('cookieName');
+state.default.session.setCookieValue('cookieValue');
+describe('NodeApi - getNodeTypes()', () => {
+  test('getNodeTypes() 1: Get all node types', async () => {
+    const response = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../test/mocks/NodeApi/getNodeTypes/types.json'), 'utf8'));
+    mock.onPost('/json/realms/root/realms/alpha/realm-config/authentication/authenticationtrees/nodes?_action=getAllTypes').reply(200, response);
+    const types = await NodeRaw.getNodeTypes();
+    expect(types).toBeTruthy();
+    expect(types.length).toBe(99);
+  });
+});
+describe('NodeApi - getNodesByType()', () => {
+  test('getNodesByType() 1: Get all page nodes', async () => {
+    const response = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../test/mocks/NodeApi/getNodesByType/PageNode.json'), 'utf8'));
+    mock.onGet('/json/realms/root/realms/alpha/realm-config/authentication/authenticationtrees/nodes/PageNode?_queryFilter=true').reply(200, response);
+    const nodes = await NodeRaw.getNodesByType('PageNode');
+    expect(nodes).toBeTruthy();
+    expect(nodes.length).toBe(161);
+  });
+});
+describe('NodeApi - getNode()', () => {
+  test('getNode() 1: Get existing page node [1aea363f-d8d2-4711-b88d-d58fff92dbae]', async () => {
+    const response = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../test/mocks/NodeApi/getNode/PageNode_1aea363f-d8d2-4711-b88d-d58fff92dbae.json'), 'utf8'));
+    mock.onGet('/json/realms/root/realms/alpha/realm-config/authentication/authenticationtrees/nodes/PageNode/1aea363f-d8d2-4711-b88d-d58fff92dbae').reply(200, response);
+    const node = await NodeRaw.getNode('1aea363f-d8d2-4711-b88d-d58fff92dbae', 'PageNode');
+    expect(node).toBeTruthy();
+    expect(node).toMatchObject(response);
+  });
+  test('getNode() 2: Get non-existing page node [00000000-0000-0000-0000-000000000000]', async () => {
+    mock.onGet('/json/realms/root/realms/alpha/realm-config/authentication/authenticationtrees/nodes/PageNode/00000000-0000-0000-0000-000000000000').reply(404, {
+      code: 404,
+      reason: 'Not Found',
+      message: 'Not Found'
+    });
+    expect.assertions(2);
+
+    try {
+      await NodeRaw.getNode('00000000-0000-0000-0000-000000000000', 'PageNode');
+    } catch (error) {
+      expect(error.response).toBeTruthy();
+      expect(error.response.data).toMatchObject({
+        code: 404,
+        reason: 'Not Found',
+        message: 'Not Found'
+      });
+    }
+  });
+});
+describe('NodeApi - putNode()', () => {
+  test('putNode() 1: Create page node [0ad90971-d08a-4af3-86f3-01729572dc8f]', async () => {
+    const nodeData = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../test/mocks/NodeApi/putNode/PageNode_0ad90971-d08a-4af3-86f3-01729572dc8f.json'), 'utf8'));
+    mock.onPut('/json/realms/root/realms/alpha/realm-config/authentication/authenticationtrees/nodes/PageNode/0ad90971-d08a-4af3-86f3-01729572dc8f').reply(201, nodeData);
+    const node = await NodeRaw.putNode('0ad90971-d08a-4af3-86f3-01729572dc8f', 'PageNode', nodeData);
+    expect(node).toBeTruthy();
+    expect(node).toMatchObject(nodeData);
+  });
+  test('putNode() 1: Update existing page node [1aea363f-d8d2-4711-b88d-d58fff92dbae]', async () => {
+    const nodeData = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../test/mocks/NodeApi/putNode/PageNode_1aea363f-d8d2-4711-b88d-d58fff92dbae.json'), 'utf8'));
+    mock.onPut('/json/realms/root/realms/alpha/realm-config/authentication/authenticationtrees/nodes/PageNode/1aea363f-d8d2-4711-b88d-d58fff92dbae').reply(200, nodeData);
+    const node = await NodeRaw.putNode('1aea363f-d8d2-4711-b88d-d58fff92dbae', 'PageNode', nodeData);
+    expect(node).toBeTruthy();
+    expect(node).toMatchObject(nodeData);
+  });
+});
+describe('NodeApi - deleteNode()', () => {
+  test('deleteNode() 1: Delete existing node [1aea363f-d8d2-4711-b88d-d58fff92dbae]', async () => {
+    const response = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../test/mocks/NodeApi/deleteNode/PageNode_1aea363f-d8d2-4711-b88d-d58fff92dbae.json'), 'utf8'));
+    mock.onDelete('/json/realms/root/realms/alpha/realm-config/authentication/authenticationtrees/nodes/PageNode/1aea363f-d8d2-4711-b88d-d58fff92dbae').reply(200, response);
+    const node = await NodeRaw.deleteNode('1aea363f-d8d2-4711-b88d-d58fff92dbae', 'PageNode');
+    expect(node).toBeTruthy();
+    expect(node._id).toEqual('1aea363f-d8d2-4711-b88d-d58fff92dbae');
+  });
+  test('deleteNode() 2: Delete non-existing node [00000000-0000-0000-0000-000000000000]', async () => {
+    mock.onDelete('/json/realms/root/realms/alpha/realm-config/authentication/authenticationtrees/nodes/PageNode/00000000-0000-0000-0000-000000000000').reply(404, {
+      code: 404,
+      reason: 'Not Found',
+      message: 'Not Found'
+    });
+    expect.assertions(2);
+
+    try {
+      await NodeRaw.deleteNode('00000000-0000-0000-0000-000000000000', 'PageNode');
+    } catch (error) {
+      expect(error.response).toBeTruthy();
+      expect(error.response.data).toMatchObject({
+        code: 404,
+        reason: 'Not Found',
+        message: 'Not Found'
+      });
+    }
+  });
+});
+//# sourceMappingURL=NodeApi.test.js.map

package/esm/api/StartupApi.mjs

@@ -10,33 +10,43 @@ const getApiConfig = () => ({
   path: `/environment/startup`,
   apiVersion
 });
+
+export let RestartStatus;
 /**
  * Get status
- * @returns {Promise} a promise that resolves to a status object
+ * @returns {Promise<RestartStatus>} a promise that resolves to a string indicating status
  */
 
+(function (RestartStatus) {
+  RestartStatus["restarting"] = "restarting";
+  RestartStatus["ready"] = "ready";
+})(RestartStatus || (RestartStatus = {}));
 
 export async function getStatus() {
   const urlString = util.format(startupURLTemplate, getTenantURL(storage.session.getTenant()));
-  return generateESVApi(getApiConfig()).get(urlString, {
+  const {
+    data
+  } = await generateESVApi(getApiConfig()).get(urlString, {
     withCredentials: true
   });
+  return data.restartStatus;
 }
 /**
  * Initiate restart
- * @returns {Promise} a promise that resolves to a status object
+ * @returns {Promise<string>} a promise that resolves to a string indicating status
  */
 
 export async function initiateRestart() {
-  const {
-    restartStatus
-  } = (await getStatus()).data;
+  const restartStatus = await getStatus();
 
-  if (restartStatus === 'ready') {
+  if (restartStatus === RestartStatus.ready) {
     const urlString = util.format(startupInitiateRestartURLTemplate, getTenantURL(storage.session.getTenant()));
-    return generateESVApi(getApiConfig()).post(urlString, null, {
+    const {
+      data
+    } = await generateESVApi(getApiConfig()).post(urlString, null, {
       withCredentials: true
     });
+    return data.restartStatus;
   }
 
   throw new Error(`Not ready! Current status: ${restartStatus}`);

package/esm/api/StartupApi.test.mjs

@@ -0,0 +1,56 @@
+import axios from 'axios';
+import MockAdapter from 'axios-mock-adapter';
+import { StartupRaw, 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('StartupApi - getStatus()', () => {
+  test('getStatus() 1: Get restart status - expect "ready"', async () => {
+    const response = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../test/mocks/StartupApi/getStatus/ready.json'), 'utf8'));
+    mock.onGet('https://openam-frodo-dev.forgeblocks.com/environment/startup').reply(200, response);
+    const status = await StartupRaw.getStatus();
+    expect(status in StartupRaw.RestartStatus).toBeTruthy();
+    expect(status).toBe(StartupRaw.RestartStatus.ready);
+  });
+  test('getStatus() 2: Get restart status - expect "restarting"', async () => {
+    const response = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../test/mocks/StartupApi/getStatus/restarting.json'), 'utf8'));
+    mock.onGet('https://openam-frodo-dev.forgeblocks.com/environment/startup').reply(200, response);
+    const status = await StartupRaw.getStatus();
+    expect(status in StartupRaw.RestartStatus).toBeTruthy();
+    expect(status).toBe(StartupRaw.RestartStatus.restarting);
+  });
+});
+describe('StartupApi - initiateRestart()', () => {
+  test('initiateRestart() 1: Initiate restart - expect "ready" -> "restarting"', async () => {
+    const response1 = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../test/mocks/StartupApi/getStatus/ready.json'), 'utf8'));
+    mock.onGet('https://openam-frodo-dev.forgeblocks.com/environment/startup').reply(200, response1);
+    const response2 = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../test/mocks/StartupApi/initiateRestart/restarting.json'), 'utf8'));
+    mock.onPost('https://openam-frodo-dev.forgeblocks.com/environment/startup?_action=restart').reply(200, response2);
+    const status = await StartupRaw.initiateRestart();
+    expect(status in StartupRaw.RestartStatus).toBeTruthy();
+    expect(status).toBe(StartupRaw.RestartStatus.restarting);
+  });
+  test('initiateRestart() 2: Initiate restart - expect "restarting" -> exception', async () => {
+    const response1 = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../test/mocks/StartupApi/getStatus/restarting.json'), 'utf8'));
+    mock.onGet('https://openam-frodo-dev.forgeblocks.com/environment/startup').reply(200, response1);
+    const response2 = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../test/mocks/StartupApi/initiateRestart/restarting.json'), 'utf8'));
+    mock.onPost('https://openam-frodo-dev.forgeblocks.com/environment/startup?_action=restart').reply(200, response2);
+    expect.assertions(2);
+
+    try {
+      await StartupRaw.initiateRestart();
+    } catch (error) {
+      expect(error).toBeTruthy();
+      expect(error.message).toBe('Not ready! Current status: restarting');
+    }
+  });
+});
+//# sourceMappingURL=StartupApi.test.js.map

package/esm/api/TreeApi.mjs

@@ -1,11 +1,7 @@
 import util from 'util';
-import { deleteDeepByKey, getCurrentRealmPath } from './utils/ApiUtils';
+import { getCurrentRealmPath } from './utils/ApiUtils';
 import { generateAmApi } from './BaseApi';
 import storage from '../storage/SessionStorage';
-const nodeURLTemplate = '%s/json%s/realm-config/authentication/authenticationtrees/nodes/%s/%s';
-const queryAllNodesByTypeURLTemplate = '%s/json%s/realm-config/authentication/authenticationtrees/nodes/%s?_queryFilter=true';
-const queryAllNodesURLTemplate = '%s/json%s/realm-config/authentication/authenticationtrees/nodes?_action=nextdescendents';
-const queryAllNodeTypesURLTemplate = '%s/json%s/realm-config/authentication/authenticationtrees/nodes?_action=getAllTypes';
 const treeByIdURLTemplate = '%s/json%s/realm-config/authentication/authenticationtrees/trees/%s';
 const queryAllTreesURLTemplate = '%s/json%s/realm-config/authentication/authenticationtrees/trees?_queryFilter=true';
 const apiVersion = 'protocol=2.1,resource=1.0';
@@ -17,131 +13,63 @@ const getTreeApiConfig = () => {
     apiVersion
   };
 };
-
-export async function getNodeTypes() {
-  const urlString = util.format(queryAllNodeTypesURLTemplate, storage.session.getTenant(), getCurrentRealmPath());
-  return generateAmApi(getTreeApiConfig()).post(urlString, {}, {
-    withCredentials: true,
-    headers: {
-      'Accept-Encoding': 'gzip, deflate, br'
-    }
-  });
-}
-/**
- * Get all nodes
- * @returns {Promise} a promise that resolves to an object containing an array of all node objects
- */
-
-export async function getNodes() {
-  const urlString = util.format(queryAllNodesURLTemplate, storage.session.getTenant(), getCurrentRealmPath());
-  return generateAmApi(getTreeApiConfig()).post(urlString, {}, {
-    withCredentials: true,
-    headers: {
-      'Accept-Encoding': 'gzip, deflate, br'
-    }
-  });
-}
-/**
- * Get all nodes by type
- * @param {*} type node type
- * @returns {Promise} a promise that resolves to an object containing an array of node objects of the requested type
- */
-
-export async function getNodesByType(type) {
-  const urlString = util.format(queryAllNodesByTypeURLTemplate, storage.session.getTenant(), getCurrentRealmPath(), type);
-  return generateAmApi(getTreeApiConfig()).get(urlString, {
-    withCredentials: true
-  });
-}
-/**
- * Get node by uuid and type
- * @param {String} id node uuid
- * @param {String} nodeType node type
- * @returns {Promise} a promise that resolves to an object containing a node object
- */
-
-export async function getNode(id, nodeType) {
-  const urlString = util.format(nodeURLTemplate, storage.session.getTenant(), getCurrentRealmPath(), nodeType, id);
-  return generateAmApi(getTreeApiConfig()).get(urlString, {
-    withCredentials: true
-  });
-}
-/**
- * Put node by uuid and type
- * @param {String} id node uuid
- * @param {String} nodeType node type
- * @param {Object} data node object
- * @returns {Promise} a promise that resolves to an object containing a node object
- */
-
-export async function putNode(id, nodeType, nodeData) {
-  // until we figure out a way to use transport keys in Frodo,
-  // we'll have to drop those encrypted attributes.
-  const data = deleteDeepByKey(nodeData, '-encrypted');
-  const urlString = util.format(nodeURLTemplate, storage.session.getTenant(), getCurrentRealmPath(), nodeType, id);
-  return generateAmApi(getTreeApiConfig()).put(urlString, data, {
-    withCredentials: true
-  });
-}
-/**
- * Delete node by uuid and type
- * @param {String} id node uuid
- * @param {String} nodeType node type
- * @returns {Promise} a promise that resolves to an object containing a node object
- */
-
-export async function deleteNode(id, nodeType) {
-  const urlString = util.format(nodeURLTemplate, storage.session.getTenant(), getCurrentRealmPath(), nodeType, id);
-  return generateAmApi(getTreeApiConfig()).delete(urlString, {
-    withCredentials: true
-  });
-}
 /**
  * Get all trees
- * @returns {Promise} a promise that resolves to an object containing an array of tree objects
+ * @returns {Promise} a promise that resolves to an array of tree objects
  */
 
+
 export async function getTrees() {
   const urlString = util.format(queryAllTreesURLTemplate, storage.session.getTenant(), getCurrentRealmPath());
-  return generateAmApi(getTreeApiConfig()).get(urlString, {
+  const response = await generateAmApi(getTreeApiConfig()).get(urlString, {
     withCredentials: true
   });
+  return response.data.result;
 }
 /**
  * Get tree by id/name
  * @param {String} id tree id/name
- * @returns {Promise} a promise that resolves to an object containing a tree object
+ * @returns {Promise} a promise that resolves to a tree object
  */
 
 export async function getTree(id) {
   const urlString = util.format(treeByIdURLTemplate, storage.session.getTenant(), getCurrentRealmPath(), id);
-  return generateAmApi(getTreeApiConfig()).get(urlString, {
+  const {
+    data
+  } = await generateAmApi(getTreeApiConfig()).get(urlString, {
     withCredentials: true
   });
+  return data;
 }
 /**
  * Put tree by id/name
- * @param {String} id tree id/name
- * @param {Object} data tree object
- * @returns {Promise} a promise that resolves to an object containing a tree object
+ * @param {String} treeId tree id/name
+ * @param {Object} treeData tree object
+ * @returns {Promise} a promise that resolves to a tree object
  */
 
-export async function putTree(id, data) {
-  const urlString = util.format(treeByIdURLTemplate, storage.session.getTenant(), getCurrentRealmPath(), id);
-  return generateAmApi(getTreeApiConfig()).put(urlString, data, {
+export async function putTree(treeId, treeData) {
+  const urlString = util.format(treeByIdURLTemplate, storage.session.getTenant(), getCurrentRealmPath(), treeId);
+  const {
+    data
+  } = await generateAmApi(getTreeApiConfig()).put(urlString, treeData, {
     withCredentials: true
   });
+  return data;
 }
 /**
  * Delete tree by id/name
- * @param {String} id tree id/name
- * @returns {Promise} a promise that resolves to an object containing a tree object
+ * @param {String} treeId tree id/name
+ * @returns {Promise} a promise that resolves to a tree object
  */
 
-export async function deleteTree(id) {
-  const urlString = util.format(treeByIdURLTemplate, storage.session.getTenant(), getCurrentRealmPath(), id);
-  return generateAmApi(getTreeApiConfig()).delete(urlString, {
+export async function deleteTree(treeId) {
+  const urlString = util.format(treeByIdURLTemplate, storage.session.getTenant(), getCurrentRealmPath(), treeId);
+  const {
+    data
+  } = await generateAmApi(getTreeApiConfig()).delete(urlString, {
     withCredentials: true
   });
+  return data;
 }
 //# sourceMappingURL=TreeApi.js.map

package/esm/api/TreeApi.test.mjs

@@ -0,0 +1,175 @@
+import axios from 'axios';
+import MockAdapter from 'axios-mock-adapter';
+import { TreeRaw, 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('');
+state.default.session.setRealm('alpha');
+state.default.session.setCookieName('cookieName');
+state.default.session.setCookieValue('cookieValue');
+describe('TreeApi - getTrees()', () => {
+  test('getTrees() 1: Get all trees', async () => {
+    const response = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../test/mocks/TreeApi/getTrees/trees.json'), 'utf8'));
+    mock.onGet('/json/realms/root/realms/alpha/realm-config/authentication/authenticationtrees/trees?_queryFilter=true').reply(200, response);
+    const trees = await TreeRaw.getTrees();
+    expect(trees).toBeTruthy();
+    expect(trees.length).toBe(92);
+  });
+});
+describe('TreeApi - getTree()', () => {
+  test('getTree() 1: Get existing tree', async () => {
+    const response = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../test/mocks/TreeApi/getTree/FrodoTest.json'), 'utf8'));
+    mock.onGet('/json/realms/root/realms/alpha/realm-config/authentication/authenticationtrees/trees/FrodoTest').reply(200, response);
+    const tree = await TreeRaw.getTree('FrodoTest');
+    expect(tree).toBeTruthy();
+    expect(tree._id).toEqual('FrodoTest');
+  });
+  test('getTree() 2: Get non-existing tree', async () => {
+    mock.onGet('/json/realms/root/realms/alpha/realm-config/authentication/authenticationtrees/trees/DoesNotExist').reply(404, {
+      code: 404,
+      reason: 'Not Found',
+      message: 'Not Found'
+    });
+    expect.assertions(2);
+
+    try {
+      await TreeRaw.getTree('DoesNotExist');
+    } catch (error) {
+      expect(error.response).toBeTruthy();
+      expect(error.response.data).toMatchObject({
+        code: 404,
+        reason: 'Not Found',
+        message: 'Not Found'
+      });
+    }
+  });
+});
+describe('TreeApi - putTree()', () => {
+  test('putTree() 1: Put valid tree', async () => {
+    const response = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../test/mocks/TreeApi/putTree/FrodoTest.json'), 'utf8'));
+    mock.onPut('/json/realms/root/realms/alpha/realm-config/authentication/authenticationtrees/trees/FrodoTest').reply(201, response);
+    const tree = await TreeRaw.putTree('FrodoTest', response);
+    expect(tree).toBeTruthy();
+    expect(tree._id).toEqual('FrodoTest');
+  });
+  test('putTree() 2: Put invalid tree [trailing data]', async () => {
+    const request = fs.readFileSync(path.resolve(__dirname, '../../test/mocks/TreeApi/putTree/Invalid_trailing-data.txt'), 'utf8');
+    mock.onPut('/json/realms/root/realms/alpha/realm-config/authentication/authenticationtrees/trees/Invalid').reply(400, {
+      code: 400,
+      reason: 'Bad Request',
+      message: 'The request could not be processed because there is trailing data after the JSON content'
+    });
+    expect.assertions(2);
+
+    try {
+      await TreeRaw.putTree('Invalid', request);
+    } catch (error) {
+      expect(error.response).toBeTruthy();
+      expect(error.response.data).toMatchObject({
+        code: 400,
+        reason: 'Bad Request',
+        message: 'The request could not be processed because there is trailing data after the JSON content'
+      });
+    }
+  });
+  test('putTree() 3: Put invalid tree [invalid attribute]', async () => {
+    const request = fs.readFileSync(path.resolve(__dirname, '../../test/mocks/TreeApi/putTree/Invalid_invalid-attribute.json'), 'utf8');
+    mock.onPut('/json/realms/root/realms/alpha/realm-config/authentication/authenticationtrees/trees/Invalid').reply(400, {
+      code: 400,
+      reason: 'Bad Request',
+      message: 'Invalid attribute specified.',
+      detail: {
+        validAttributes: ['description', 'enabled', 'entryNodeId', 'identityResource', 'nodes', 'staticNodes', 'uiConfig']
+      }
+    });
+    expect.assertions(2);
+
+    try {
+      await TreeRaw.putTree('Invalid', request);
+    } catch (error) {
+      expect(error.response).toBeTruthy();
+      expect(error.response.data).toMatchObject({
+        code: 400,
+        reason: 'Bad Request',
+        message: 'Invalid attribute specified.',
+        detail: {
+          validAttributes: ['description', 'enabled', 'entryNodeId', 'identityResource', 'nodes', 'staticNodes', 'uiConfig']
+        }
+      });
+    }
+  });
+  test('putTree() 4: Put invalid tree [no entry node]', async () => {
+    const request = fs.readFileSync(path.resolve(__dirname, '../../test/mocks/TreeApi/putTree/Invalid_no-entry-node.json'), 'utf8');
+    mock.onPut('/json/realms/root/realms/alpha/realm-config/authentication/authenticationtrees/trees/Invalid').reply(400, {
+      code: 400,
+      reason: 'Bad Request',
+      message: 'Node with ID entryNodeId must exist in the tree.'
+    });
+    expect.assertions(2);
+
+    try {
+      await TreeRaw.putTree('Invalid', request);
+    } catch (error) {
+      expect(error.response).toBeTruthy();
+      expect(error.response.data).toMatchObject({
+        code: 400,
+        reason: 'Bad Request',
+        message: 'Node with ID entryNodeId must exist in the tree.'
+      });
+    }
+  });
+  test('putTree() 5: Put invalid tree [invalid nodes]', async () => {
+    const request = fs.readFileSync(path.resolve(__dirname, '../../test/mocks/TreeApi/putTree/Invalid_invalid-nodes.json'), 'utf8');
+    mock.onPut('/json/realms/root/realms/alpha/realm-config/authentication/authenticationtrees/trees/Invalid').reply(400, {
+      code: 400,
+      reason: 'Bad Request',
+      message: 'Node with ID entryNodeId must exist in the tree.'
+    });
+    expect.assertions(2);
+
+    try {
+      await TreeRaw.putTree('Invalid', request);
+    } catch (error) {
+      expect(error.response).toBeTruthy();
+      expect(error.response.data).toMatchObject({
+        code: 400,
+        reason: 'Bad Request',
+        message: 'Node with ID entryNodeId must exist in the tree.'
+      });
+    }
+  });
+});
+describe('TreeApi - deleteTree()', () => {
+  test('deleteTree() 1: Delete existing tree', async () => {
+    const response = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../../test/mocks/TreeApi/deleteTree/FrodoTest.json'), 'utf8'));
+    mock.onDelete('/json/realms/root/realms/alpha/realm-config/authentication/authenticationtrees/trees/FrodoTest').reply(200, response);
+    const tree = await TreeRaw.deleteTree('FrodoTest');
+    expect(tree).toBeTruthy();
+    expect(tree._id).toEqual('FrodoTest');
+  });
+  test('deleteTree() 2: Delete non-existing tree', async () => {
+    mock.onDelete('/json/realms/root/realms/alpha/realm-config/authentication/authenticationtrees/trees/DoesNotExist').reply(404, {
+      code: 404,
+      reason: 'Not Found',
+      message: 'Not Found'
+    });
+    expect.assertions(2);
+
+    try {
+      await TreeRaw.deleteTree('DoesNotExist');
+    } catch (error) {
+      expect(error.response).toBeTruthy();
+      expect(error.response.data).toMatchObject({
+        code: 404,
+        reason: 'Not Found',
+        message: 'Not Found'
+      });
+    }
+  });
+});
+//# sourceMappingURL=TreeApi.test.js.map

package/esm/index.mjs

@@ -4,13 +4,15 @@ import { fileURLToPath } from 'url';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
-const pkg = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../package.json'), 'utf8')); // const pkg = JSON.parse(
-//   fs.readFileSync(new URL('../package.json', import.meta.url), 'utf-8')
-// );
-
+const pkg = JSON.parse(fs.readFileSync(path.resolve(__dirname, '../package.json'), 'utf8'));
 export function getVersion() {
   return `v${pkg.version}`;
-}
+} // Api Layer
+
+export * as NodeRaw from './api/NodeApi';
+export * as TreeRaw from './api/TreeApi';
+export * as StartupRaw from './api/StartupApi'; // Ops Layer
+
 export * as Admin from './ops/AdminOps';
 export * as Authenticate from './ops/AuthenticateOps';
 export * as CirclesOfTrust from './ops/CirclesOfTrustOps';

package/esm/ops/IdpOps.mjs

@@ -78,7 +78,7 @@ export async function exportProvider(id, file = '') {
     }
 
     saveJsonToFile(fileData, fileName);
-    stopProgressIndicator(`Exported ${id.brightCyan} to ${fileName.brightCyan}.`);
+    stopProgressIndicator(`Exported ${id['brightCyan']} to ${fileName['brightCyan']}.`);
   } catch (err) {
     stopProgressIndicator(`${err}`);
     printMessage(`${err}`, 'error');