cisco-perfmon 1.3.3 → 1.4.0

package/main.js

@@ -85,6 +85,17 @@ var XML_REMOVE_COUNTER_ENVELOPE = `<soapenv:Envelope xmlns:soapenv="http://schem
 </soapenv:Body>
 </soapenv:Envelope>`;
 
+// Set up our promise results
+var promiseResults = {
+  cookie: "",
+  results: "",
+};
+
+// Set up our error results
+var errorResults = {
+  message: "",
+};
+
 /**
  * Cisco Perfmon Service
  * This is a service class that uses fetch and promises to pull Perfmon data from Cisco CUCM
@@ -130,7 +141,7 @@ class perfMonService {
    * @memberof perfMonService
    * @param {string} host - The host to collect data from
    * @param {string} object - The object to collect data about. Example: Cisco CallManager
-   * @returns {object} returns JSON via a Promise. JSON contains Session Cookie (If availible) and Results.
+   * @returns {object} returns JSON via a Promise. JSON contains cookie and results if successful, otherwise it returns an error object.
    */
   collectCounterData(host, object) {
     var XML;
@@ -144,17 +155,12 @@ class perfMonService {
     options.body = soapBody;
 
     return new Promise((resolve, reject) => {
-      // Set up our promise results
-      var promiseResults = {
-        Cookie: "",
-        Results: "",
-      };
       // We fetch the API endpoint
       fetch(`https://${server}:8443/perfmonservice2/services/PerfmonService/`, options)
         .then(async (response) => {
           try {
             var data = []; // create an array to save chunked data from server
-            promiseResults.Cookie = response.headers.get("set-cookie") ? response.headers.get("set-cookie") : "";
+            promiseResults.cookie = response.headers.get("set-cookie") ? response.headers.get("set-cookie") : "";
             // response.body is a ReadableStream
             const reader = response.body.getReader();
             for await (const chunk of readChunks(reader)) {
@@ -205,40 +211,43 @@ class perfMonService {
                       cstatus: returnResults.CStatus,
                     };
                   }
-                  promiseResults.Results = clean(newOutput);
+                  promiseResults.results = clean(newOutput);
                   resolve(promiseResults);
                 } else {
-                  promiseResults.Results = { response: "empty" };
-                  resolve(promiseResults);
+                  // We expected results but got none. This is an error.
+                  errorResults.message = "No results found";
+                  reject(errorResults);
                 }
               } else {
-                promiseResults.Results = { response: "empty" };
-                resolve(promiseResults);
+                // We expected results but got none. This is an error.
+                errorResults.message = "No results found";
+                reject(errorResults);
               }
             } else {
               // Error checking. If the response contains a fault, we return the fault.
               if (keyExists(output, "Fault")) {
                 if (output.Body.Fault.faultcode.includes("RateControl")) {
-                  promiseResults.Results = { faultcode: "RateControl", faultstring: output.Body.Fault.faultstring };
+                  errorResults.message = { faultcode: "RateControl", faultstring: output.Body.Fault.faultstring };
                 } else if (output.Body.Fault.faultcode.includes("generalException")) {
-                  promiseResults.Results = { faultcode: "generalException", faultstring: output.Body.Fault.faultstring };
+                  errorResults.message = { faultcode: "generalException", faultstring: output.Body.Fault.faultstring };
                 } else {
-                  promiseResults.Results = { faultcode: output.Body.Fault.faultcode, faultstring: output.Body.Fault.faultstring };
+                  errorResults.message = { faultcode: output.Body.Fault.faultcode, faultstring: output.Body.Fault.faultstring };
                 }
-                resolve(promiseResults);
+                reject(errorResults);
               } else {
                 // Error unknown. Reject with the response status instead. Most likely a 500 error from the server.
-                reject(response.status);
+                errorResults.message = response.status;
+                reject(errorResults);
               }
             }
           } catch (e) {
-            promiseResults.Results = e;
-            reject(promiseResults);
+            errorResults.message = e;
+            reject(errorResults);
           }
         })
         .catch((error) => {
-          promiseResults.Results = error;
-          reject(promiseResults);
+          errorResults.message = error;
+          reject(errorResults);
         }); // catches the error and logs it
     });
   }
@@ -267,17 +276,12 @@ class perfMonService {
     options.body = soapBody;
 
     return new Promise((resolve, reject) => {
-      // Set up our promise results
-      var promiseResults = {
-        Cookie: "",
-        Results: "",
-      };
       // We fetch the API endpoint
       fetch(`https://${server}:8443/perfmonservice2/services/PerfmonService/`, options)
         .then(async (response) => {
           try {
             var data = []; // create an array to save chunked data from server
-            promiseResults.Cookie = response.headers.get("set-cookie") ? response.headers.get("set-cookie") : "";
+            promiseResults.cookie = response.headers.get("set-cookie") ? response.headers.get("set-cookie") : "";
             // response.body is a ReadableStream
             const reader = response.body.getReader();
             for await (const chunk of readChunks(reader)) {
@@ -327,40 +331,43 @@ class perfMonService {
                       cstatus: returnResults.CStatus,
                     };
                   }
-                  promiseResults.Results = clean(newOutput);
+                  promiseResults.results = clean(newOutput);
                   resolve(promiseResults);
                 } else {
-                  promiseResults.Results = { response: "empty" };
-                  resolve(promiseResults);
+                  // We expected results but got none. This is an error.
+                  errorResults.message = "No results found";
+                  reject(errorResults);
                 }
               } else {
-                promiseResults.Results = { response: "empty" };
-                resolve(promiseResults);
+                // We expected results but got none. This is an error.
+                errorResults.message = "No results found";
+                reject(errorResults);
               }
             } else {
               // Error checking. If the response contains a fault, we return the fault.
               if (keyExists(output, "Fault")) {
                 if (output.Body.Fault.faultcode.includes("RateControl")) {
-                  promiseResults.Results = { faultcode: "RateControl", faultstring: output.Body.Fault.faultstring };
+                  errorResults.message = { faultcode: "RateControl", faultstring: output.Body.Fault.faultstring };
                 } else if (output.Body.Fault.faultcode.includes("generalException")) {
-                  promiseResults.Results = { faultcode: "generalException", faultstring: output.Body.Fault.faultstring };
+                  errorResults.message = { faultcode: "generalException", faultstring: output.Body.Fault.faultstring };
                 } else {
-                  promiseResults.Results = { faultcode: output.Body.Fault.faultcode, faultstring: output.Body.Fault.faultstring };
+                  errorResults.message = { faultcode: output.Body.Fault.faultcode, faultstring: output.Body.Fault.faultstring };
                 }
-                resolve(promiseResults);
+                reject(errorResults);
               } else {
                 // Error unknown. Reject with the response status instead. Most likely a 500 error from the server.
-                reject(response.status);
+                errorResults.message = response.status;
+                reject(errorResults);
               }
             }
           } catch (e) {
-            promiseResults.Results = e;
-            reject(promiseResults);
+            errorResults.message = e;
+            reject(errorResults);
           }
         })
         .catch((error) => {
-          promiseResults.Results = error;
-          reject(promiseResults);
+          errorResults.message = error;
+          reject(errorResults);
         }); // catches the error and logs it
     });
   }
@@ -389,17 +396,12 @@ class perfMonService {
     options.body = soapBody;
 
     return new Promise((resolve, reject) => {
-      // Set up our promise results
-      var promiseResults = {
-        Cookie: "",
-        Results: "",
-      };
       // We fetch the API endpoint
       fetch(`https://${server}:8443/perfmonservice2/services/PerfmonService/`, options)
         .then(async (response) => {
           try {
             var data = []; // create an array to save chunked data from server
-            promiseResults.Cookie = response.headers.get("set-cookie") ? response.headers.get("set-cookie") : "";
+            promiseResults.cookie = response.headers.get("set-cookie") ? response.headers.get("set-cookie") : "";
             // response.body is a ReadableStream
             const reader = response.body.getReader();
             for await (const chunk of readChunks(reader)) {
@@ -415,40 +417,43 @@ class perfMonService {
               if (keyExists(output, "perfmonListCounterReturn")) {
                 var returnResults = output.Body.perfmonListCounterResponse.perfmonListCounterReturn;
                 if (returnResults) {
-                  promiseResults.Results = clean(returnResults);
+                  promiseResults.results = clean(returnResults);
                   resolve(promiseResults);
                 } else {
-                  promiseResults.Results = { response: "empty" };
-                  resolve(promiseResults);
+                  // We expected results but got none. This is an error.
+                  errorResults.message = "No results found";
+                  reject(errorResults);
                 }
               } else {
-                promiseResults.Results = { response: "empty" };
-                resolve(promiseResults);
+                // We expected results but got none. This is an error.
+                errorResults.message = "No results found";
+                reject(errorResults);
               }
             } else {
               // Error checking. If the response contains a fault, we return the fault.
               if (keyExists(output, "Fault")) {
                 if (output.Body.Fault.faultcode.includes("RateControl")) {
-                  promiseResults.Results = { faultcode: "RateControl", faultstring: output.Body.Fault.faultstring };
+                  errorResults.message = { faultcode: "RateControl", faultstring: output.Body.Fault.faultstring };
                 } else if (output.Body.Fault.faultcode.includes("generalException")) {
-                  promiseResults.Results = { faultcode: "generalException", faultstring: output.Body.Fault.faultstring };
+                  errorResults.message = { faultcode: "generalException", faultstring: output.Body.Fault.faultstring };
                 } else {
-                  promiseResults.Results = { faultcode: output.Body.Fault.faultcode, faultstring: output.Body.Fault.faultstring };
+                  errorResults.message = { faultcode: output.Body.Fault.faultcode, faultstring: output.Body.Fault.faultstring };
                 }
-                resolve(promiseResults);
+                reject(errorResults);
               } else {
                 // Error unknown. Reject with the response status instead. Most likely a 500 error from the server.
-                reject(response.status);
+                errorResults.message = response.status;
+                reject(errorResults);
               }
             }
           } catch (e) {
-            promiseResults.Results = e;
-            reject(promiseResults);
+            errorResults.message = e;
+            reject(errorResults);
           }
         })
         .catch((error) => {
-          promiseResults.Results = error;
-          reject(promiseResults);
+          errorResults.message = error;
+          reject(errorResults);
         }); // catches the error and logs it
     });
   }
@@ -478,17 +483,12 @@ class perfMonService {
     options.body = soapBody;
 
     return new Promise((resolve, reject) => {
-      // Set up our promise results
-      var promiseResults = {
-        Cookie: "",
-        Results: "",
-      };
       // We fetch the API endpoint
       fetch(`https://${server}:8443/perfmonservice2/services/PerfmonService/`, options)
         .then(async (response) => {
           try {
             var data = []; // create an array to save chunked data from server
-            promiseResults.Cookie = response.headers.get("set-cookie") ? response.headers.get("set-cookie") : "";
+            promiseResults.cookie = response.headers.get("set-cookie") ? response.headers.get("set-cookie") : "";
             // response.body is a ReadableStream
             const reader = response.body.getReader();
             for await (const chunk of readChunks(reader)) {
@@ -504,40 +504,43 @@ class perfMonService {
               if (keyExists(output, "perfmonListInstanceReturn")) {
                 var returnResults = output.Body.perfmonListInstanceResponse.perfmonListInstanceReturn;
                 if (returnResults) {
-                  promiseResults.Results = clean(returnResults);
+                  promiseResults.results = clean(returnResults);
                   resolve(promiseResults);
                 } else {
-                  promiseResults.Results = { response: "empty" };
-                  resolve(promiseResults);
+                  // We expected results but got none. This is an error.
+                  errorResults.message = "No results found";
+                  reject(errorResults);
                 }
               } else {
-                promiseResults.Results = { response: "empty" };
-                resolve(promiseResults);
+                  // We expected results but got none. This is an error.
+                  errorResults.message = "No results found";
+                  reject(errorResults);
               }
             } else {
               // Error checking. If the response contains a fault, we return the fault.
               if (keyExists(output, "Fault")) {
                 if (output.Body.Fault.faultcode.includes("RateControl")) {
-                  promiseResults.Results = { faultcode: "RateControl", faultstring: output.Body.Fault.faultstring };
+                  errorResults.message = { faultcode: "RateControl", faultstring: output.Body.Fault.faultstring };
                 } else if (output.Body.Fault.faultcode.includes("generalException")) {
-                  promiseResults.Results = { faultcode: "generalException", faultstring: output.Body.Fault.faultstring };
+                  errorResults.message = { faultcode: "generalException", faultstring: output.Body.Fault.faultstring };
                 } else {
-                  promiseResults.Results = { faultcode: output.Body.Fault.faultcode, faultstring: output.Body.Fault.faultstring };
+                  errorResults.message = { faultcode: output.Body.Fault.faultcode, faultstring: output.Body.Fault.faultstring };
                 }
-                resolve(promiseResults);
+                reject(errorResults);
               } else {
                 // Error unknown. Reject with the response status instead. Most likely a 500 error from the server.
-                reject(response.status);
+                errorResults.message = response.status;
+                reject(errorResults);
               }
             }
           } catch (e) {
-            promiseResults.Results = e;
-            reject(promiseResults);
+            errorResults.message = e;
+            reject(errorResults);
           }
         })
         .catch((error) => {
-          promiseResults.Results = error;
-          reject(promiseResults);
+          errorResults.message = error;
+          reject(errorResults);
         }); // catches the error and logs it
     });
   }
@@ -564,17 +567,12 @@ class perfMonService {
     options.body = soapBody;
 
     return new Promise((resolve, reject) => {
-      // Set up our promise results
-      var promiseResults = {
-        Cookie: "",
-        Results: "",
-      };
       // We fetch the API endpoint
       fetch(`https://${server}:8443/perfmonservice2/services/PerfmonService/`, options)
         .then(async (response) => {
           try {
             var data = []; // create an array to save chunked data from server
-            promiseResults.Cookie = response.headers.get("set-cookie") ? response.headers.get("set-cookie") : "";
+            promiseResults.cookie = response.headers.get("set-cookie") ? response.headers.get("set-cookie") : "";
             // response.body is a ReadableStream
             const reader = response.body.getReader();
             for await (const chunk of readChunks(reader)) {
@@ -590,40 +588,43 @@ class perfMonService {
               if (keyExists(output, "perfmonOpenSessionReturn")) {
                 var returnResults = output.Body.perfmonOpenSessionResponse.perfmonOpenSessionReturn;
                 if (returnResults) {
-                  promiseResults.Results = clean(returnResults);
+                  promiseResults.results = clean(returnResults);
                   resolve(promiseResults);
                 } else {
-                  promiseResults.Results = { response: "empty" };
-                  resolve(promiseResults);
+                  // We expected results but got none. This is an error.
+                  errorResults.message = "No results found";
+                  reject(errorResults);
                 }
               } else {
-                promiseResults.Results = { response: "empty" };
-                resolve(promiseResults);
+                  // We expected results but got none. This is an error.
+                  errorResults.message = "No results found";
+                  reject(errorResults);
               }
             } else {
               // Error checking. If the response contains a fault, we return the fault.
               if (keyExists(output, "Fault")) {
                 if (output.Body.Fault.faultcode.includes("RateControl")) {
-                  promiseResults.Results = { faultcode: "RateControl", faultstring: output.Body.Fault.faultstring };
+                  errorResults.message = { faultcode: "RateControl", faultstring: output.Body.Fault.faultstring };
                 } else if (output.Body.Fault.faultcode.includes("generalException")) {
-                  promiseResults.Results = { faultcode: "generalException", faultstring: output.Body.Fault.faultstring };
+                  errorResults.message = { faultcode: "generalException", faultstring: output.Body.Fault.faultstring };
                 } else {
-                  promiseResults.Results = { faultcode: output.Body.Fault.faultcode, faultstring: output.Body.Fault.faultstring };
+                  errorResults.message = { faultcode: output.Body.Fault.faultcode, faultstring: output.Body.Fault.faultstring };
                 }
-                resolve(promiseResults);
+                reject(errorResults);
               } else {
                 // Error unknown. Reject with the response status instead. Most likely a 500 error from the server.
-                reject(response.status);
+                errorResults.message = response.status;
+                reject(errorResults);
               }
             }
           } catch (e) {
-            promiseResults.Results = e;
-            reject(promiseResults);
+            errorResults.message = e;
+            reject(errorResults);
           }
         })
         .catch((error) => {
-          promiseResults.Results = error;
-          reject(promiseResults);
+          errorResults.message = error;
+          reject(errorResults);
         }); // catches the error and logs it
     });
   }
@@ -651,17 +652,12 @@ class perfMonService {
     options.body = soapBody;
 
     return new Promise((resolve, reject) => {
-      // Set up our promise results
-      var promiseResults = {
-        Cookie: "",
-        Results: "",
-      };
       // We fetch the API endpoint
       fetch(`https://${server}:8443/perfmonservice2/services/PerfmonService/`, options)
         .then(async (response) => {
           try {
             var data = []; // create an array to save chunked data from server
-            promiseResults.Cookie = response.headers.get("set-cookie") ? response.headers.get("set-cookie") : "";
+            promiseResults.cookie = response.headers.get("set-cookie") ? response.headers.get("set-cookie") : "";
             // response.body is a ReadableStream
             const reader = response.body.getReader();
             for await (const chunk of readChunks(reader)) {
@@ -676,36 +672,37 @@ class perfMonService {
             if (keyExists(output, "perfmonCloseSessionResponse")) {
               var returnResults = output.Body.perfmonCloseSessionResponse;
               if (returnResults) {
-                promiseResults.Results = { response: "success" };
+                promiseResults.results = "success";
                 resolve(promiseResults);
               } else {
-                promiseResults.Results = { response: "unknow" };
-                reject(promiseResults);
+                errorResults.message = "unknown";
+                reject(errorResults);
               }
             } else {
               // Error checking. If the response contains a fault, we return the fault.
               if (keyExists(output, "Fault")) {
                 if (output.Body.Fault.faultcode.includes("RateControl")) {
-                  promiseResults.Results = { faultcode: "RateControl", faultstring: output.Body.Fault.faultstring };
+                  errorResults.message = { faultcode: "RateControl", faultstring: output.Body.Fault.faultstring };
                 } else if (output.Body.Fault.faultcode.includes("generalException")) {
-                  promiseResults.Results = { faultcode: "generalException", faultstring: output.Body.Fault.faultstring };
+                  errorResults.message = { faultcode: "generalException", faultstring: output.Body.Fault.faultstring };
                 } else {
-                  promiseResults.Results = { faultcode: output.Body.Fault.faultcode, faultstring: output.Body.Fault.faultstring };
+                  errorResults.message = { faultcode: output.Body.Fault.faultcode, faultstring: output.Body.Fault.faultstring };
                 }
-                resolve(promiseResults);
+                reject(errorResults);
               } else {
                 // Error unknown. Reject with the response status instead. Most likely a 500 error from the server.
-                reject(response.status);
+                errorResults.message = response.status;
+                reject(errorResults);
               }
             }
           } catch (e) {
-            promiseResults.Results = e;
-            reject(promiseResults);
+            errorResults.message = e;
+            reject(errorResults);
           }
         })
         .catch((error) => {
-          promiseResults.Results = error;
-          reject(promiseResults);
+          errorResults.message = error;
+          reject(errorResults);
         }); // catches the error and logs it
     });
   }
@@ -742,11 +739,6 @@ class perfMonService {
     options.body = soapBody;
 
     return new Promise((resolve, reject) => {
-      // Set up our promise results
-      var promiseResults = {
-        Cookie: "",
-        Results: "",
-      };
       // We fetch the API endpoint
       fetch(`https://${server}:8443/perfmonservice2/services/PerfmonService/`, options)
         .then(async (response) => {
@@ -764,32 +756,39 @@ class perfMonService {
             removeKeys(output, "$");
 
             if (keyExists(output, "perfmonAddCounterResponse")) {
-              promiseResults.Results = { response: "success" };
-              resolve(promiseResults);
+              var returnResults = output.Body.perfmonAddCounterResponse;
+              if (returnResults) {
+                promiseResults.results = "success";
+                resolve(promiseResults);
+              } else {
+                errorResults.message = "unknown";
+                reject(errorResults);
+              }
             } else {
               // Error checking. If the response contains a fault, we return the fault.
               if (keyExists(output, "Fault")) {
                 if (output.Body.Fault.faultcode.includes("RateControl")) {
-                  promiseResults.Results = { faultcode: "RateControl", faultstring: output.Body.Fault.faultstring };
+                  errorResults.message = { faultcode: "RateControl", faultstring: output.Body.Fault.faultstring };
                 } else if (output.Body.Fault.faultcode.includes("generalException")) {
-                  promiseResults.Results = { faultcode: "generalException", faultstring: output.Body.Fault.faultstring };
+                  errorResults.message = { faultcode: "generalException", faultstring: output.Body.Fault.faultstring };
                 } else {
-                  promiseResults.Results = { faultcode: output.Body.Fault.faultcode, faultstring: output.Body.Fault.faultstring };
+                  errorResults.message = { faultcode: output.Body.Fault.faultcode, faultstring: output.Body.Fault.faultstring };
                 }
-                resolve(promiseResults);
+                reject(errorResults);
               } else {
                 // Error unknown. Reject with the response status instead. Most likely a 500 error from the server.
-                reject(response.status);
+                errorResults.message = response.status;
+                reject(errorResults);
               }
             }
           } catch (e) {
-            promiseResults.Results = e;
-            reject(promiseResults);
+            errorResults.message = e;
+            reject(errorResults);
           }
         })
         .catch((error) => {
-          promiseResults.Results = error;
-          reject(promiseResults);
+          errorResults.message = error;
+          reject(errorResults);
         }); // catches the error and logs it
     });
   }
@@ -826,11 +825,6 @@ class perfMonService {
     options.body = soapBody;
 
     return new Promise((resolve, reject) => {
-      // Set up our promise results
-      var promiseResults = {
-        Cookie: "",
-        Results: "",
-      };
       // We fetch the API endpoint
       fetch(`https://${server}:8443/perfmonservice2/services/PerfmonService/`, options)
         .then(async (response) => {
@@ -850,36 +844,37 @@ class perfMonService {
             if (keyExists(output, "perfmonRemoveCounterResponse")) {
               var returnResults = output.Body.perfmonRemoveCounterResponse;
               if (returnResults) {
-                promiseResults.Results = { response: "success" };
+                promiseResults.results = "success";
                 resolve(promiseResults);
               } else {
-                promiseResults.Results = { response: "unknown" };
-                resolve(promiseResults);
+                errorResults.message = "unknown";
+                reject(errorResults);
               }
             } else {
               // Error checking. If the response contains a fault, we return the fault.
               if (keyExists(output, "Fault")) {
                 if (output.Body.Fault.faultcode.includes("RateControl")) {
-                  promiseResults.Results = { faultcode: "RateControl", faultstring: output.Body.Fault.faultstring };
+                  errorResults.message = { faultcode: "RateControl", faultstring: output.Body.Fault.faultstring };
                 } else if (output.Body.Fault.faultcode.includes("generalException")) {
-                  promiseResults.Results = { faultcode: "generalException", faultstring: output.Body.Fault.faultstring };
+                  errorResults.message = { faultcode: "generalException", faultstring: output.Body.Fault.faultstring };
                 } else {
-                  promiseResults.Results = { faultcode: output.Body.Fault.faultcode, faultstring: output.Body.Fault.faultstring };
+                  errorResults.message = { faultcode: output.Body.Fault.faultcode, faultstring: output.Body.Fault.faultstring };
                 }
-                resolve(promiseResults);
+                reject(errorResults);
               } else {
                 // Error unknown. Reject with the response status instead. Most likely a 500 error from the server.
-                reject(response.status);
+                errorResults.message = response.status;
+                reject(errorResults);
               }
             }
           } catch (e) {
-            promiseResults.Results = e;
-            reject(promiseResults);
+            errorResults.message = e;
+            reject(errorResults);
           }
         })
         .catch((error) => {
-          promiseResults.Results = error;
-          reject(promiseResults);
+          errorResults.message = error;
+          reject(errorResults);
         }); // catches the error and logs it
     });
   }
@@ -910,17 +905,12 @@ class perfMonService {
     options.body = soapBody;
 
     return new Promise((resolve, reject) => {
-      // Set up our promise results
-      var promiseResults = {
-        Cookie: "",
-        Results: "",
-      };
       // We fetch the API endpoint
       fetch(`https://${server}:8443/perfmonservice2/services/PerfmonService/`, options)
         .then(async (response) => {
           try {
             var data = []; // create an array to save chunked data from server
-            promiseResults.Cookie = response.headers.get("set-cookie") ? response.headers.get("set-cookie") : "";
+            promiseResults.cookie = response.headers.get("set-cookie") ? response.headers.get("set-cookie") : "";
             // response.body is a ReadableStream
             const reader = response.body.getReader();
             for await (const chunk of readChunks(reader)) {
@@ -937,40 +927,43 @@ class perfMonService {
               if (keyExists(output, "perfmonQueryCounterDescriptionReturn")) {
                 var returnResults = output.Body.perfmonQueryCounterDescriptionResponse.perfmonQueryCounterDescriptionReturn;
                 if (returnResults) {
-                  promiseResults.Results = clean(returnResults);
+                  promiseResults.results = clean(returnResults);
                   resolve(promiseResults);
                 } else {
-                  promiseResults.Results = { response: "empty" };
-                  resolve(promiseResults);
+                  // We expected results but got none. This is an error.
+                  errorResults.message = "No results found";
+                  reject(errorResults);
                 }
               } else {
-                promiseResults.Results = { response: "empty" };
-                resolve(promiseResults);
+                // We expected results but got none. This is an error.
+                errorResults.message = "No results found";
+                reject(errorResults);
               }
             } else {
               // Error checking. If the response contains a fault, we return the fault.
               if (keyExists(output, "Fault")) {
                 if (output.Body.Fault.faultcode.includes("RateControl")) {
-                  promiseResults.Results = { faultcode: "RateControl", faultstring: output.Body.Fault.faultstring };
+                  errorResults.message = { faultcode: "RateControl", faultstring: output.Body.Fault.faultstring };
                 } else if (output.Body.Fault.faultcode.includes("generalException")) {
-                  promiseResults.Results = { faultcode: "generalException", faultstring: output.Body.Fault.faultstring };
+                  errorResults.message = { faultcode: "generalException", faultstring: output.Body.Fault.faultstring };
                 } else {
-                  promiseResults.Results = { faultcode: output.Body.Fault.faultcode, faultstring: output.Body.Fault.faultstring };
+                  errorResults.message = { faultcode: output.Body.Fault.faultcode, faultstring: output.Body.Fault.faultstring };
                 }
-                resolve(promiseResults);
+                reject(errorResults);
               } else {
                 // Error unknown. Reject with the response status instead. Most likely a 500 error from the server.
-                reject(response.status);
+                errorResults.message = response.status;
+                reject(errorResults);
               }
             }
           } catch (e) {
-            promiseResults.Results = e;
-            reject(promiseResults);
+            errorResults.message = e;
+            reject(errorResults);
           }
         })
         .catch((error) => {
-          promiseResults.Results = error;
-          reject(promiseResults);
+          errorResults.message = error;
+          reject(errorResults);
         }); // catches the error and logs it
     });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cisco-perfmon",
-  "version": "1.3.3",
+  "version": "1.4.0",
   "description": "A library to pull Perfmon data from Cisco VOS applications via SOAP",
   "main": "main.js",
   "scripts": {

package/test/tests.js

@@ -40,89 +40,89 @@ var serviceSSO = "";
   console.log("Let's get a description of our counter. We will also retrieve a cookie to use for the rest of the session.");
   await service
     .queryCounterDescription(counterObj)
-    .then((results) => {
-      console.log("queryCounterDescription: ", results.Results);
-      if (results.Cookie) {
-        serviceSSO = new perfMonService(env.CUCM_HOSTNAME, "", "", { Cookie: results.Cookie });
+    .then((response) => {
+      console.log("queryCounterDescription: ", response.results);
+      if (response.cookie) {
+        serviceSSO = new perfMonService(env.CUCM_HOSTNAME, "", "", { Cookie: response.cookie });
       }
     })
     .catch((error) => {
-      console.log(error);
+      console.log(error.message);
     });
 
   console.log("Let's collect some non session counter data.");
   await serviceSSO
     .collectCounterData(cucmServerName, "Cisco CallManager")
-    .then((results) => {
-      console.log("collectCounterData", results.Results);
+    .then((response) => {
+      console.log("collectCounterData", response.results);
     })
     .catch((error) => {
-      console.log(error);
+      console.log(error.message);
     });
 
   console.log("Let's open a session, add a counter, wait 30 seconds, collect the session data, remove the counter and finally close the session");
   await serviceSSO
     .openSession()
-    .then(async (results) => {
-      console.log("SessionID", results.Results);
-      SessionID = results.Results;
+    .then(async (response) => {
+      console.log("SessionID", response.results);
+      SessionID = response.results;
       await serviceSSO
         .addCounter(SessionID, counterObj)
-        .then(async (results) => {
-          console.log("addCounter", results.Results);
+        .then(async (response) => {
+          console.log("addCounter", response.results);
           const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
           console.log("Wait 30 seconds");
           await delay(30000); /// waiting 30 second.
           await serviceSSO
             .collectSessionData(SessionID)
-            .then(async (results) => {
-              console.log("collectSessionData", results.Results);
+            .then(async (response) => {
+              console.log("collectSessionData", response.results);
               await serviceSSO
-                .removeCounter(SessionID, results.Results)
-                .then(async (results) => {
-                  console.log("removeCounter", results.Results);
+                .removeCounter(SessionID, response.results)
+                .then(async (response) => {
+                  console.log("removeCounter", response.results);
                   await serviceSSO
                     .closeSession(SessionID)
-                    .then((results) => {
-                      console.log("closeSession", results.Results);
+                    .then((response) => {
+                      console.log("closeSession", response.results);
                     })
                     .catch((error) => {
-                      console.log(error);
+                      console.log(error.message);
                     });
                 })
                 .catch((error) => {
-                  console.log(error);
+                  console.log(error.message);
                 });
             })
             .catch((error) => {
-              console.log(error);
+              console.log(error.message);
             });
         })
         .catch((error) => {
-          console.log(error);
+          console.log(error.message);
         });
     })
     .catch((error) => {
-      console.log(error);
+      console.log(error.message);
     });
 
   console.log("Let's returns the list of available PerfMon objects and counters on a particular host");
   await serviceSSO
     .listCounter(cucmServerName)
-    .then((results) => {
-      console.log("listCounter", results.Results);
+    .then((response) => {
+      console.log("listCounter", response.results);
     })
     .catch((error) => {
-      console.log(error);
+      console.log(error.message);
     });
 
   console.log("Let's return a list of instances of a PerfMon object on a particular host. Instances of an object can dynamically change. This operation returns the most recent list.");
   await serviceSSO
     .listInstance(cucmServerName, "Processor")
     .then((results) => {
-      console.log("listInstance", results.Results);
+      console.log("listInstance", results.results);
     })
     .catch((error) => {
-      console.log(error);
+      console.log(error.message);
     });
 })();