@itentialopensource/adapter-zscaler 0.8.2 → 0.9.0

package/test/integration/adapterTestIntegration.js

@@ -2174,5 +2174,4887 @@ describe('[integration] Zscaler Adapter Test', () => {
         }
       }).timeout(attemptTimeout);
     });
+
+    describe('#submitFile - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.submitFile('fakedata', null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SandboxSubmissionAPI', 'submitFile', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#submitFileForScan - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.submitFileForScan('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SandboxSubmissionAPI', 'submitFileForScan', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getApp - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getApp(null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Applications', 'getApp', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const applicationsPostAppBodyParam = {};
+    describe('#postApp - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.postApp(applicationsPostAppBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Applications', 'postApp', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#appsSearchGET - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.appsSearchGET('fakedata', null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+                assert.equal('object', typeof data.response[3]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Applications', 'appsSearchGET', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getViews - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getViews((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('AppViews', 'getViews', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getViewApps - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getViewApps('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('AppViews', 'getViewApps', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getRoleSummary - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getRoleSummary(null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('AdminRoleManagement', 'getRoleSummary', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAdminUsers - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getAdminUsers(null, null, null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('AdminRoleManagement', 'getAdminUsers', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const adminRoleManagementAddAdminUserBodyParam = {
+      loginName: 'string',
+      userName: 'string',
+      email: 'string'
+    };
+    describe('#addAdminUser - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addAdminUser(null, adminRoleManagementAddAdminUserBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('AdminRoleManagement', 'addAdminUser', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateAdminUser - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateAdminUser(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('AdminRoleManagement', 'updateAdminUser', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteAdminUser - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteAdminUser(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('AdminRoleManagement', 'deleteAdminUser', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const adminRoleManagementConvertAdminToEndUserBodyParam = {};
+    describe('#convertAdminToEndUser - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.convertAdminToEndUser(555, adminRoleManagementConvertAdminToEndUserBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('AdminRoleManagement', 'convertAdminToEndUser', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getCloudBrowserIsolationProfiles - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getCloudBrowserIsolationProfiles((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('BrowserIsolation', 'getCloudBrowserIsolationProfiles', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDlpDictionaries - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getDlpDictionaries(null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'getDlpDictionaries', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const dataLossPreventionAddCustomDLPDictionaryBodyParam = {};
+    describe('#addCustomDLPDictionary - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addCustomDLPDictionary(dataLossPreventionAddCustomDLPDictionaryBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'addCustomDLPDictionary', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDLPDictionarySummary - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getDLPDictionarySummary((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+                assert.equal('object', typeof data.response[3]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'getDLPDictionarySummary', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDlpDictionaryById - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getDlpDictionaryById(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'getDlpDictionaryById', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const dataLossPreventionUpdateDlpDictionaryBodyParam = {};
+    describe('#updateDlpDictionary - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateDlpDictionary(555, dataLossPreventionUpdateDlpDictionaryBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'updateDlpDictionary', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteCustomDlpDictionary - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteCustomDlpDictionary(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'deleteCustomDlpDictionary', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getPredefinedHierarchicalIdentifiersByDictionaryId - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getPredefinedHierarchicalIdentifiersByDictionaryId(555, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('string', data.response[0]);
+                assert.equal('string', data.response[1]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'getPredefinedHierarchicalIdentifiersByDictionaryId', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#validateDlpPattern - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.validateDlpPattern((data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'validateDlpPattern', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDLPEngines - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getDLPEngines((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'getDLPEngines', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const dataLossPreventionAddCustomDLPEngineBodyParam = {};
+    describe('#addCustomDLPEngine - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addCustomDLPEngine(dataLossPreventionAddCustomDLPEngineBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'addCustomDLPEngine', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDLPEnginesSummary - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getDLPEnginesSummary((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'getDLPEnginesSummary', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const dataLossPreventionPostDlpEnginesValidateDlpExprBodyParam = {};
+    describe('#postDlpEnginesValidateDlpExpr - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.postDlpEnginesValidateDlpExpr(dataLossPreventionPostDlpEnginesValidateDlpExprBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'postDlpEnginesValidateDlpExpr', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDLPEngineById - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getDLPEngineById(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'getDLPEngineById', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const dataLossPreventionUpdateDlpEngineBodyParam = {
+      id: 10,
+      name: 'string',
+      predefinedEngineName: 'string',
+      engineExpression: 'string',
+      customDlpEngine: false,
+      description: 'string'
+    };
+    describe('#updateDlpEngine - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateDlpEngine(555, dataLossPreventionUpdateDlpEngineBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'updateDlpEngine', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteCustomDlpEngine - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteCustomDlpEngine(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'deleteCustomDlpEngine', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSchemas - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getSchemas((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+                assert.equal('object', typeof data.response[3]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'getSchemas', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSchemaLite - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getSchemaLite(null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'getSchemaLite', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#gettemplates - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.gettemplates((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+                assert.equal('object', typeof data.response[3]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'gettemplates', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#addtemplate - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addtemplate((data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'addtemplate', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTemplateById - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getTemplateById(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'getTemplateById', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updatetemplate - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updatetemplate(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'updatetemplate', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deletetemplate - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deletetemplate(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'deletetemplate', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getICAPServers - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getICAPServers((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'getICAPServers', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getICAPServerSummary - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getICAPServerSummary((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'getICAPServerSummary', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getICAPServer - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getICAPServer(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'getICAPServer', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getProfiles - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getProfiles((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'getProfiles', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSummary - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getSummary(null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'getSummary', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getProfileById - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getProfileById(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'getProfileById', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getIncidentReceiverServers - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getIncidentReceiverServers((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+                assert.equal('object', typeof data.response[3]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'getIncidentReceiverServers', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getIncidentReceiverServerSummary - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getIncidentReceiverServerSummary((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+                assert.equal('object', typeof data.response[3]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'getIncidentReceiverServerSummary', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getIncidentReceiverServer - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getIncidentReceiverServer(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'getIncidentReceiverServer', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getRules - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getRules((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+                assert.equal('object', typeof data.response[3]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'getRules', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const dataLossPreventionAddRuleBodyParam = {};
+    describe('#addRule - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addRule(dataLossPreventionAddRuleBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'addRule', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getWebDlpRulesLite - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getWebDlpRulesLite((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'getWebDlpRulesLite', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getRuleById - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getRuleById(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'getRuleById', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const dataLossPreventionUpdateRuleBodyParam = {};
+    describe('#updateRule - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateRule(555, dataLossPreventionUpdateRuleBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'updateRule', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteRule - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteRule(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DataLossPrevention', 'deleteRule', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDeviceGroups - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getDeviceGroups(null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DeviceGroups', 'getDeviceGroups', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDevices - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getDevices(null, null, null, null, null, null, null, null, null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DeviceGroups', 'getDevices', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDevicesLite - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getDevicesLite(null, null, null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DeviceGroups', 'getDevicesLite', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getEventReportEntryCsvExportStatus - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getEventReportEntryCsvExportStatus((data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('EventLogs', 'getEventReportEntryCsvExportStatus', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const eventLogsStartEventReportEntryCsvExportBodyParam = {};
+    describe('#startEventReportEntryCsvExport - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.startEventReportEntryCsvExport(eventLogsStartEventReportEntryCsvExportBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('EventLogs', 'startEventReportEntryCsvExport', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#cancelEventReportEntryCsvExport - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.cancelEventReportEntryCsvExport((data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('EventLogs', 'cancelEventReportEntryCsvExport', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getEventReportEntryCsvData - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getEventReportEntryCsvData((data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('EventLogs', 'getEventReportEntryCsvData', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getFirewallFilteringRules - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getFirewallFilteringRules((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'getFirewallFilteringRules', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const firewallPoliciesCreateFirewallFilteringRuleBodyParam = {};
+    describe('#createFirewallFilteringRule - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createFirewallFilteringRule(firewallPoliciesCreateFirewallFilteringRuleBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'createFirewallFilteringRule', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getFirewallFilteringRule - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getFirewallFilteringRule(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'getFirewallFilteringRule', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const firewallPoliciesUpdateFirewallFilteringRuleBodyParam = {};
+    describe('#updateFirewallFilteringRule - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateFirewallFilteringRule(555, firewallPoliciesUpdateFirewallFilteringRuleBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'updateFirewallFilteringRule', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteFirewallFilteringRule - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteFirewallFilteringRule(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'deleteFirewallFilteringRule', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDestinationIpGroups - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getDestinationIpGroups(null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+                assert.equal('object', typeof data.response[3]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'getDestinationIpGroups', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#addDestinationIpGroup - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addDestinationIpGroup((data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'addDestinationIpGroup', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDestinationIpv6Groups - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getDestinationIpv6Groups(null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+                assert.equal('object', typeof data.response[3]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'getDestinationIpv6Groups', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDestinationIpv6GroupsLite - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getDestinationIpv6GroupsLite(null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'getDestinationIpv6GroupsLite', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDestinationIpGroupsLite - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getDestinationIpGroupsLite(null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'getDestinationIpGroupsLite', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDestinationIpGroupById - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getDestinationIpGroupById(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'getDestinationIpGroupById', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#editDestinationIpGroup - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.editDestinationIpGroup(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'editDestinationIpGroup', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteDestinationIpGroup - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteDestinationIpGroup(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'deleteDestinationIpGroup', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSourceIpGroups - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getSourceIpGroups(null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+                assert.equal('object', typeof data.response[3]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'getSourceIpGroups', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#addSourceIpGroup - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addSourceIpGroup((data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'addSourceIpGroup', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSourceIpv6Groups - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getSourceIpv6Groups((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+                assert.equal('object', typeof data.response[3]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'getSourceIpv6Groups', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSourceIpv6GroupsLite - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getSourceIpv6GroupsLite((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'getSourceIpv6GroupsLite', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSourceIpGroupsLite - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getSourceIpGroupsLite((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'getSourceIpGroupsLite', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSourceIpGroupById - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getSourceIpGroupById(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'getSourceIpGroupById', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#editSourceIpGroup - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.editSourceIpGroup(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'editSourceIpGroup', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteSourceIpGroup - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteSourceIpGroup(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'deleteSourceIpGroup', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNetowrkApplicationGroups - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getNetowrkApplicationGroups(null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'getNetowrkApplicationGroups', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createNetworkApplicationGroup - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createNetworkApplicationGroup((data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'createNetworkApplicationGroup', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNetowrkApplicationGroupsLite - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getNetowrkApplicationGroupsLite((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+                assert.equal('object', typeof data.response[3]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'getNetowrkApplicationGroupsLite', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNetworkApplicationGroupById - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getNetworkApplicationGroupById(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'getNetworkApplicationGroupById', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateNetworkApplicationGroup - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateNetworkApplicationGroup(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'updateNetworkApplicationGroup', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteNetworkApplicationGroup - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteNetworkApplicationGroup(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'deleteNetworkApplicationGroup', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNetworkApplications - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getNetworkApplications(null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'getNetworkApplications', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNetworkApplicationById - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getNetworkApplicationById('fakedata', null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'getNetworkApplicationById', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNetworkServiceGroups - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getNetworkServiceGroups(null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'getNetworkServiceGroups', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#addCustomNetworkServiceGroup - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addCustomNetworkServiceGroup((data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'addCustomNetworkServiceGroup', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNetworkServiceGroupsLite - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getNetworkServiceGroupsLite((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'getNetworkServiceGroupsLite', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNetworkServiceGroupById - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getNetworkServiceGroupById(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'getNetworkServiceGroupById', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#editNetworkServiceGroup - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.editNetworkServiceGroup(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'editNetworkServiceGroup', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteCustomNetowrkServiceGroup - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteCustomNetowrkServiceGroup(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'deleteCustomNetowrkServiceGroup', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNetworkServices - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getNetworkServices(null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'getNetworkServices', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const firewallPoliciesAddCustomNetworkServiceBodyParam = {};
+    describe('#addCustomNetworkService - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addCustomNetworkService(firewallPoliciesAddCustomNetworkServiceBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'addCustomNetworkService', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNetworkServicesLite - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getNetworkServicesLite(null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'getNetworkServicesLite', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNetworkServiceById - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getNetworkServiceById(555, null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'getNetworkServiceById', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#editNetworkService - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.editNetworkService(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'editNetworkService', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteCustomNetworkService - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteCustomNetworkService(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'deleteCustomNetworkService', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTimeWindows - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getTimeWindows((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'getTimeWindows', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTimeWindowSummary - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getTimeWindowSummary((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('FirewallPolicies', 'getTimeWindowSummary', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getUrlFilteringRules - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getUrlFilteringRules((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('URLFilteringPolicies', 'getUrlFilteringRules', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const uRLFilteringPoliciesPostUrlFilteringRulesBodyParam = {};
+    describe('#postUrlFilteringRules - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.postUrlFilteringRules(uRLFilteringPoliciesPostUrlFilteringRulesBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('URLFilteringPolicies', 'postUrlFilteringRules', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getUrlFilteringRulesRuleId - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getUrlFilteringRulesRuleId(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('URLFilteringPolicies', 'getUrlFilteringRulesRuleId', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const uRLFilteringPoliciesPutUrlFilteringRulesRuleIdBodyParam = {};
+    describe('#putUrlFilteringRulesRuleId - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.putUrlFilteringRulesRuleId(555, uRLFilteringPoliciesPutUrlFilteringRulesRuleIdBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('URLFilteringPolicies', 'putUrlFilteringRulesRuleId', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteUrlFilteringRulesRuleId - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteUrlFilteringRulesRuleId(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('URLFilteringPolicies', 'deleteUrlFilteringRulesRuleId', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getForwardingRules - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getForwardingRules((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ForwardingControlPolicy', 'getForwardingRules', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const forwardingControlPolicyCreateForwardingRuleBodyParam = {};
+    describe('#createForwardingRule - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createForwardingRule(forwardingControlPolicyCreateForwardingRuleBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ForwardingControlPolicy', 'createForwardingRule', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getForwardingRule - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getForwardingRule(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ForwardingControlPolicy', 'getForwardingRule', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const forwardingControlPolicyUpdateForwardingRuleBodyParam = {};
+    describe('#updateForwardingRule - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateForwardingRule(555, forwardingControlPolicyUpdateForwardingRuleBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ForwardingControlPolicy', 'updateForwardingRule', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteForwardingRule - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteForwardingRule(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ForwardingControlPolicy', 'deleteForwardingRule', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getZpaGateways - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getZpaGateways(null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ForwardingControlPolicy', 'getZpaGateways', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const forwardingControlPolicyAddZpaGatewayBodyParam = {
+      id: 3,
+      name: 'string',
+      zpaServerGroup: {
+        id: 2,
+        name: 'string',
+        externalId: 'string',
+        extensions: {}
+      },
+      zpaAppSegments: [
+        {
+          id: 7,
+          name: 'string',
+          externalId: 'string',
+          extensions: {}
+        }
+      ],
+      zpaTenantId: 10,
+      lastModifiedBy: {
+        id: 5,
+        name: 'string',
+        externalId: 'string',
+        extensions: {}
+      },
+      lastModifiedTime: 3,
+      type: null,
+      description: 'string'
+    };
+    describe('#addZpaGateway - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addZpaGateway(forwardingControlPolicyAddZpaGatewayBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ForwardingControlPolicy', 'addZpaGateway', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getZpaGatewayById - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getZpaGatewayById(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ForwardingControlPolicy', 'getZpaGatewayById', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const forwardingControlPolicyEditZpaGatewayBodyParam = {};
+    describe('#editZpaGateway - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.editZpaGateway(555, forwardingControlPolicyEditZpaGatewayBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ForwardingControlPolicy', 'editZpaGateway', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteZpaGateway - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteZpaGateway(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ForwardingControlPolicy', 'deleteZpaGateway', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getIntermediateCaCertificates - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getIntermediateCaCertificates(null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IntermediateCACertificates', 'getIntermediateCaCertificates', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const intermediateCACertificatesAddIntermediateCaCertificateBodyParam = {};
+    describe('#addIntermediateCaCertificate - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addIntermediateCaCertificate(intermediateCACertificatesAddIntermediateCaCertificateBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IntermediateCACertificates', 'addIntermediateCaCertificate', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#downloadAttestationStmt - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.downloadAttestationStmt(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IntermediateCACertificates', 'downloadAttestationStmt', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#downloadCSR - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.downloadCSR(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IntermediateCACertificates', 'downloadCSR', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#downloadHsmPublicKey - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.downloadHsmPublicKey(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IntermediateCACertificates', 'downloadHsmPublicKey', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#finalizeCert - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.finalizeCert(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IntermediateCACertificates', 'finalizeCert', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const intermediateCACertificatesGenerateCsrBodyParam = {};
+    describe('#generateCsr - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.generateCsr(555, intermediateCACertificatesGenerateCsrBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IntermediateCACertificates', 'generateCsr', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#generateHsmKeyPair - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.generateHsmKeyPair(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IntermediateCACertificates', 'generateHsmKeyPair', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getIntermediateCaCertificatesLite - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getIntermediateCaCertificatesLite(null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IntermediateCACertificates', 'getIntermediateCaCertificatesLite', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getIntermediateCaCertificateLite - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getIntermediateCaCertificateLite(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IntermediateCACertificates', 'getIntermediateCaCertificateLite', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#makeDefaultCertificate - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.makeDefaultCertificate(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IntermediateCACertificates', 'makeDefaultCertificate', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getCertificatesInReadyToUseState - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getCertificatesInReadyToUseState(null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+                assert.equal('object', typeof data.response[3]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IntermediateCACertificates', 'getCertificatesInReadyToUseState', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showCert - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showCert(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IntermediateCACertificates', 'showCert', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showCsr - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showCsr(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IntermediateCACertificates', 'showCsr', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const intermediateCACertificatesUploadCertBodyParam = {};
+    describe('#uploadCert - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.uploadCert(555, intermediateCACertificatesUploadCertBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IntermediateCACertificates', 'uploadCert', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const intermediateCACertificatesUploadCertChainBodyParam = {};
+    describe('#uploadCertChain - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.uploadCertChain(555, intermediateCACertificatesUploadCertChainBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IntermediateCACertificates', 'uploadCertChain', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#verifyKeyAttestation - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.verifyKeyAttestation(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IntermediateCACertificates', 'verifyKeyAttestation', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getIntermediateCaCertificate - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getIntermediateCaCertificate(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IntermediateCACertificates', 'getIntermediateCaCertificate', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const intermediateCACertificatesUpdateIntermediateCaCertificateBodyParam = {};
+    describe('#updateIntermediateCaCertificate - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateIntermediateCaCertificate(555, intermediateCACertificatesUpdateIntermediateCaCertificateBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IntermediateCACertificates', 'updateIntermediateCaCertificate', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteIntermediateCaCertificate - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteIntermediateCaCertificate(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IntermediateCACertificates', 'deleteIntermediateCaCertificate', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSslExemptedUrls - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getSslExemptedUrls((data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IntermediateCACertificates', 'getSslExemptedUrls', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateSslExemptedUrls - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateSslExemptedUrls('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IntermediateCACertificates', 'updateSslExemptedUrls', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDeviceTypes - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getDeviceTypes((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IoTReport', 'getDeviceTypes', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getCategories - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getCategories((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+                assert.equal('object', typeof data.response[3]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IoTReport', 'getCategories', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getClassifications - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getClassifications((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IoTReport', 'getClassifications', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDeviceList - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getDeviceList((data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IoTReport', 'getDeviceList', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSubLocations - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getSubLocations(555, null, null, null, null, null, null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('LocationManagement', 'getSubLocations', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getGroupsCount - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getGroupsCount(null, null, null, null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('LocationManagement', 'getGroupsCount', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getGroupsSummary - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getGroupsSummary(null, null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('LocationManagement', 'getGroupsSummary', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getGroupSummary - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getGroupSummary(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('LocationManagement', 'getGroupSummary', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getGroupById - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getGroupById(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('LocationManagement', 'getGroupById', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getRuleLabels - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getRuleLabels(null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('RuleLabels', 'getRuleLabels', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#addRuleLabel - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addRuleLabel((data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('RuleLabels', 'addRuleLabel', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getRuleLabelById - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getRuleLabelById(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('RuleLabels', 'getRuleLabelById', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateRuleLabel - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateRuleLabel(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('RuleLabels', 'updateRuleLabel', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteRuleLabel - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteRuleLabel(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('RuleLabels', 'deleteRuleLabel', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getCustomFileHash - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getCustomFileHash((data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SandboxSettings', 'getCustomFileHash', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const sandboxSettingsUpdateCustomFileHashBodyParam = {
+      fileHashesToBeBlocked: [
+        'string'
+      ]
+    };
+    describe('#updateCustomFileHash - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateCustomFileHash(sandboxSettingsUpdateCustomFileHashBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SandboxSettings', 'updateCustomFileHash', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getCustomFileHashQuota - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getCustomFileHashQuota((data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SandboxSettings', 'getCustomFileHashQuota', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const shadowITReportBulkUpdateCloudApplicationBodyParam = {
+      sanctionedState: null,
+      applicationIds: [
+        3
+      ],
+      customTags: [
+        {
+          id: 5,
+          name: 'string'
+        }
+      ]
+    };
+    describe('#bulkUpdateCloudApplication - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.bulkUpdateCloudApplication(shadowITReportBulkUpdateCloudApplicationBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ShadowITReport', 'bulkUpdateCloudApplication', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getCloudApplicationsLite - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getCloudApplicationsLite(null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ShadowITReport', 'getCloudApplicationsLite', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAllCustomTags - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getAllCustomTags((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ShadowITReport', 'getAllCustomTags', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const shadowITReportGetReportDataApplicationsExportBodyParam = {};
+    describe('#getReportDataApplicationsExport - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getReportDataApplicationsExport(shadowITReportGetReportDataApplicationsExportBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ShadowITReport', 'getReportDataApplicationsExport', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const shadowITReportGetReportTransactionsExportBodyParam = {};
+    describe('#getReportTransactionsExport - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getReportTransactionsExport('fakedata', shadowITReportGetReportTransactionsExportBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ShadowITReport', 'getReportTransactionsExport', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAllGreTunnels - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getAllGreTunnels(null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('TrafficForwarding', 'getAllGreTunnels', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const trafficForwardingAddGreTunnelBodyParam = {
+      id: 10,
+      sourceIp: 'string',
+      primaryDestVip: {
+        id: 6,
+        virtualIp: 'string',
+        privateServiceEdge: false,
+        datacenter: 'string'
+      },
+      secondaryDestVip: {
+        id: 6,
+        virtualIp: 'string',
+        privateServiceEdge: true,
+        datacenter: 'string'
+      },
+      internalIpRange: 'string',
+      managedBy: {
+        id: 4,
+        name: 'string',
+        externalId: 'string',
+        extensions: {}
+      },
+      lastModificationTime: 7,
+      lastModifiedBy: {
+        id: 4,
+        name: 'string',
+        externalId: 'string',
+        extensions: {}
+      },
+      withinCountry: false,
+      comment: 'string',
+      ipUnnumbered: true,
+      subcloud: 'string'
+    };
+    describe('#addGreTunnel - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addGreTunnel(trafficForwardingAddGreTunnelBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('TrafficForwarding', 'addGreTunnel', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#validateAndGetAvailableInternalIpRanges - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.validateAndGetAvailableInternalIpRanges(null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+                assert.equal('object', typeof data.response[3]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('TrafficForwarding', 'validateAndGetAvailableInternalIpRanges', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getGreTunelById - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getGreTunelById(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('TrafficForwarding', 'getGreTunelById', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const trafficForwardingUpdateGreTunnelBodyParam = {};
+    describe('#updateGreTunnel - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateGreTunnel(555, trafficForwardingUpdateGreTunnelBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('TrafficForwarding', 'updateGreTunnel', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteGreTunnel - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteGreTunnel(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('TrafficForwarding', 'deleteGreTunnel', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getIPv6Configuration - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getIPv6Configuration((data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('TrafficForwarding', 'getIPv6Configuration', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDns64Prefixes - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getDns64Prefixes(null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+                assert.equal('object', typeof data.response[3]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('TrafficForwarding', 'getDns64Prefixes', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNat64Prefixes - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getNat64Prefixes(null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('TrafficForwarding', 'getNat64Prefixes', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getIPGWDetails - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getIPGWDetails(null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('TrafficForwarding', 'getIPGWDetails', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getRegionByGeoCoordinates - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getRegionByGeoCoordinates(555, 555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('TrafficForwarding', 'getRegionByGeoCoordinates', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getRegionBySrcIPAddress - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getRegionBySrcIPAddress('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('TrafficForwarding', 'getRegionBySrcIPAddress', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getRegionsByPrefix - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getRegionsByPrefix(null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('TrafficForwarding', 'getRegionsByPrefix', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAllStaticIPs - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getAllStaticIPs(null, null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+                assert.equal('object', typeof data.response[3]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('TrafficForwarding', 'getAllStaticIPs', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const trafficForwardingAddStaticIPBodyParam = {};
+    describe('#addStaticIP - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addStaticIP(trafficForwardingAddStaticIPBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('TrafficForwarding', 'addStaticIP', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const trafficForwardingValidateIPAddressBodyParam = {};
+    describe('#validateIPAddress - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.validateIPAddress(trafficForwardingValidateIPAddressBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('TrafficForwarding', 'validateIPAddress', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getStaticIPById - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getStaticIPById(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('TrafficForwarding', 'getStaticIPById', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const trafficForwardingUpdateStaticIPBodyParam = {};
+    describe('#updateStaticIP - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateStaticIP(555, trafficForwardingUpdateStaticIPBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('TrafficForwarding', 'updateStaticIP', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteStaticIP - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteStaticIP(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('TrafficForwarding', 'deleteStaticIP', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getZscalerNodesDetails - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getZscalerNodesDetails(null, null, null, null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+                assert.equal('object', typeof data.response[3]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('TrafficForwarding', 'getZscalerNodesDetails', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getRecommendedVipsGroupedByDC - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getRecommendedVipsGroupedByDC(null, null, null, null, null, null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('TrafficForwarding', 'getRecommendedVipsGroupedByDC', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getRecommendedGreVips - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getRecommendedGreVips(null, null, null, null, null, null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('TrafficForwarding', 'getRecommendedGreVips', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAuthExemptedUrls - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getAuthExemptedUrls((data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('UserAuthenticationSettings', 'getAuthExemptedUrls', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateAuthExemptedUrls - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateAuthExemptedUrls('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-zscaler-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('UserAuthenticationSettings', 'updateAuthExemptedUrls', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getWorkloadGroups - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getWorkloadGroups(null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('WorkloadGroups', 'getWorkloadGroups', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getLocationGroups - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getLocationGroups(null, null, null, null, null, null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+                assert.equal('object', typeof data.response[2]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('LocationManagement', 'getLocationGroups', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
   });
 });