@itentialopensource/adapter-zscaler 0.8.2 → 0.9.0

package/test/unit/adapterTestUnit.js

@@ -316,7 +316,7 @@ describe('[unit] Zscaler Adapter Test', () => {
           assert.notEqual(null, packageDotJson.dependencies);
           assert.notEqual('', packageDotJson.dependencies);
           assert.equal('^8.12.0', packageDotJson.dependencies.ajv);
-          assert.equal('^1.6.7', packageDotJson.dependencies.axios);
+          assert.equal('^1.6.8', packageDotJson.dependencies.axios);
           assert.equal('^11.0.0', packageDotJson.dependencies.commander);
           assert.equal('^11.1.1', packageDotJson.dependencies['fs-extra']);
           assert.equal('^10.3.0', packageDotJson.dependencies.mocha);
@@ -2494,5 +2494,3852 @@ describe('[unit] Zscaler Adapter Test', () => {
         }
       }).timeout(attemptTimeout);
     });
+
+    describe('#submitFile - errors', () => {
+      it('should have a submitFile function', (done) => {
+        try {
+          assert.equal(true, typeof a.submitFile === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing apiToken', (done) => {
+        try {
+          a.submitFile(null, null, (data, error) => {
+            try {
+              const displayE = 'apiToken is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-submitFile', displayE);
+              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 have a submitFileForScan function', (done) => {
+        try {
+          assert.equal(true, typeof a.submitFileForScan === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing apiToken', (done) => {
+        try {
+          a.submitFileForScan(null, (data, error) => {
+            try {
+              const displayE = 'apiToken is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-submitFileForScan', displayE);
+              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 have a getApp function', (done) => {
+        try {
+          assert.equal(true, typeof a.getApp === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postApp - errors', () => {
+      it('should have a postApp function', (done) => {
+        try {
+          assert.equal(true, typeof a.postApp === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.postApp(null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-postApp', displayE);
+              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 have a appsSearchGET function', (done) => {
+        try {
+          assert.equal(true, typeof a.appsSearchGET === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing appName', (done) => {
+        try {
+          a.appsSearchGET(null, null, null, (data, error) => {
+            try {
+              const displayE = 'appName is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-appsSearchGET', displayE);
+              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 have a getViews function', (done) => {
+        try {
+          assert.equal(true, typeof a.getViews === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getViewApps - errors', () => {
+      it('should have a getViewApps function', (done) => {
+        try {
+          assert.equal(true, typeof a.getViewApps === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing appViewId', (done) => {
+        try {
+          a.getViewApps(null, (data, error) => {
+            try {
+              const displayE = 'appViewId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getViewApps', displayE);
+              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 have a getRoleSummary function', (done) => {
+        try {
+          assert.equal(true, typeof a.getRoleSummary === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAdminUsers - errors', () => {
+      it('should have a getAdminUsers function', (done) => {
+        try {
+          assert.equal(true, typeof a.getAdminUsers === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#addAdminUser - errors', () => {
+      it('should have a addAdminUser function', (done) => {
+        try {
+          assert.equal(true, typeof a.addAdminUser === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateAdminUser - errors', () => {
+      it('should have a updateAdminUser function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateAdminUser === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing userId', (done) => {
+        try {
+          a.updateAdminUser(null, (data, error) => {
+            try {
+              const displayE = 'userId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-updateAdminUser', displayE);
+              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 have a deleteAdminUser function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteAdminUser === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing userId', (done) => {
+        try {
+          a.deleteAdminUser(null, (data, error) => {
+            try {
+              const displayE = 'userId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-deleteAdminUser', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#convertAdminToEndUser - errors', () => {
+      it('should have a convertAdminToEndUser function', (done) => {
+        try {
+          assert.equal(true, typeof a.convertAdminToEndUser === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing userId', (done) => {
+        try {
+          a.convertAdminToEndUser(null, null, (data, error) => {
+            try {
+              const displayE = 'userId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-convertAdminToEndUser', displayE);
+              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 have a getCloudBrowserIsolationProfiles function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCloudBrowserIsolationProfiles === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDlpDictionaries - errors', () => {
+      it('should have a getDlpDictionaries function', (done) => {
+        try {
+          assert.equal(true, typeof a.getDlpDictionaries === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#addCustomDLPDictionary - errors', () => {
+      it('should have a addCustomDLPDictionary function', (done) => {
+        try {
+          assert.equal(true, typeof a.addCustomDLPDictionary === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDLPDictionarySummary - errors', () => {
+      it('should have a getDLPDictionarySummary function', (done) => {
+        try {
+          assert.equal(true, typeof a.getDLPDictionarySummary === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDlpDictionaryById - errors', () => {
+      it('should have a getDlpDictionaryById function', (done) => {
+        try {
+          assert.equal(true, typeof a.getDlpDictionaryById === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing dlpDictId', (done) => {
+        try {
+          a.getDlpDictionaryById(null, (data, error) => {
+            try {
+              const displayE = 'dlpDictId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getDlpDictionaryById', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateDlpDictionary - errors', () => {
+      it('should have a updateDlpDictionary function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateDlpDictionary === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing dlpDictId', (done) => {
+        try {
+          a.updateDlpDictionary(null, null, (data, error) => {
+            try {
+              const displayE = 'dlpDictId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-updateDlpDictionary', displayE);
+              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 have a deleteCustomDlpDictionary function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteCustomDlpDictionary === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing dlpDictId', (done) => {
+        try {
+          a.deleteCustomDlpDictionary(null, (data, error) => {
+            try {
+              const displayE = 'dlpDictId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-deleteCustomDlpDictionary', displayE);
+              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 have a getPredefinedHierarchicalIdentifiersByDictionaryId function', (done) => {
+        try {
+          assert.equal(true, typeof a.getPredefinedHierarchicalIdentifiersByDictionaryId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing dictId', (done) => {
+        try {
+          a.getPredefinedHierarchicalIdentifiersByDictionaryId(null, (data, error) => {
+            try {
+              const displayE = 'dictId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getPredefinedHierarchicalIdentifiersByDictionaryId', displayE);
+              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 have a validateDlpPattern function', (done) => {
+        try {
+          assert.equal(true, typeof a.validateDlpPattern === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDLPEngines - errors', () => {
+      it('should have a getDLPEngines function', (done) => {
+        try {
+          assert.equal(true, typeof a.getDLPEngines === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#addCustomDLPEngine - errors', () => {
+      it('should have a addCustomDLPEngine function', (done) => {
+        try {
+          assert.equal(true, typeof a.addCustomDLPEngine === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDLPEnginesSummary - errors', () => {
+      it('should have a getDLPEnginesSummary function', (done) => {
+        try {
+          assert.equal(true, typeof a.getDLPEnginesSummary === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postDlpEnginesValidateDlpExpr - errors', () => {
+      it('should have a postDlpEnginesValidateDlpExpr function', (done) => {
+        try {
+          assert.equal(true, typeof a.postDlpEnginesValidateDlpExpr === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDLPEngineById - errors', () => {
+      it('should have a getDLPEngineById function', (done) => {
+        try {
+          assert.equal(true, typeof a.getDLPEngineById === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing dlpEngineId', (done) => {
+        try {
+          a.getDLPEngineById(null, (data, error) => {
+            try {
+              const displayE = 'dlpEngineId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getDLPEngineById', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateDlpEngine - errors', () => {
+      it('should have a updateDlpEngine function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateDlpEngine === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing dlpEngineId', (done) => {
+        try {
+          a.updateDlpEngine(null, null, (data, error) => {
+            try {
+              const displayE = 'dlpEngineId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-updateDlpEngine', displayE);
+              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 have a deleteCustomDlpEngine function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteCustomDlpEngine === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing dlpEngineId', (done) => {
+        try {
+          a.deleteCustomDlpEngine(null, (data, error) => {
+            try {
+              const displayE = 'dlpEngineId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-deleteCustomDlpEngine', displayE);
+              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 have a getSchemas function', (done) => {
+        try {
+          assert.equal(true, typeof a.getSchemas === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSchemaLite - errors', () => {
+      it('should have a getSchemaLite function', (done) => {
+        try {
+          assert.equal(true, typeof a.getSchemaLite === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#gettemplates - errors', () => {
+      it('should have a gettemplates function', (done) => {
+        try {
+          assert.equal(true, typeof a.gettemplates === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#addtemplate - errors', () => {
+      it('should have a addtemplate function', (done) => {
+        try {
+          assert.equal(true, typeof a.addtemplate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTemplateById - errors', () => {
+      it('should have a getTemplateById function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTemplateById === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing templateId', (done) => {
+        try {
+          a.getTemplateById(null, (data, error) => {
+            try {
+              const displayE = 'templateId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getTemplateById', displayE);
+              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 have a updatetemplate function', (done) => {
+        try {
+          assert.equal(true, typeof a.updatetemplate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing templateId', (done) => {
+        try {
+          a.updatetemplate(null, (data, error) => {
+            try {
+              const displayE = 'templateId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-updatetemplate', displayE);
+              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 have a deletetemplate function', (done) => {
+        try {
+          assert.equal(true, typeof a.deletetemplate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing templateId', (done) => {
+        try {
+          a.deletetemplate(null, (data, error) => {
+            try {
+              const displayE = 'templateId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-deletetemplate', displayE);
+              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 have a getICAPServers function', (done) => {
+        try {
+          assert.equal(true, typeof a.getICAPServers === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getICAPServerSummary - errors', () => {
+      it('should have a getICAPServerSummary function', (done) => {
+        try {
+          assert.equal(true, typeof a.getICAPServerSummary === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getICAPServer - errors', () => {
+      it('should have a getICAPServer function', (done) => {
+        try {
+          assert.equal(true, typeof a.getICAPServer === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing icapServerId', (done) => {
+        try {
+          a.getICAPServer(null, (data, error) => {
+            try {
+              const displayE = 'icapServerId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getICAPServer', displayE);
+              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 have a getProfiles function', (done) => {
+        try {
+          assert.equal(true, typeof a.getProfiles === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSummary - errors', () => {
+      it('should have a getSummary function', (done) => {
+        try {
+          assert.equal(true, typeof a.getSummary === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getProfileById - errors', () => {
+      it('should have a getProfileById function', (done) => {
+        try {
+          assert.equal(true, typeof a.getProfileById === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing profileId', (done) => {
+        try {
+          a.getProfileById(null, (data, error) => {
+            try {
+              const displayE = 'profileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getProfileById', displayE);
+              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 have a getIncidentReceiverServers function', (done) => {
+        try {
+          assert.equal(true, typeof a.getIncidentReceiverServers === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getIncidentReceiverServerSummary - errors', () => {
+      it('should have a getIncidentReceiverServerSummary function', (done) => {
+        try {
+          assert.equal(true, typeof a.getIncidentReceiverServerSummary === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getIncidentReceiverServer - errors', () => {
+      it('should have a getIncidentReceiverServer function', (done) => {
+        try {
+          assert.equal(true, typeof a.getIncidentReceiverServer === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing incidentReceiverServerId', (done) => {
+        try {
+          a.getIncidentReceiverServer(null, (data, error) => {
+            try {
+              const displayE = 'incidentReceiverServerId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getIncidentReceiverServer', displayE);
+              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 have a getRules function', (done) => {
+        try {
+          assert.equal(true, typeof a.getRules === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#addRule - errors', () => {
+      it('should have a addRule function', (done) => {
+        try {
+          assert.equal(true, typeof a.addRule === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getWebDlpRulesLite - errors', () => {
+      it('should have a getWebDlpRulesLite function', (done) => {
+        try {
+          assert.equal(true, typeof a.getWebDlpRulesLite === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getRuleById - errors', () => {
+      it('should have a getRuleById function', (done) => {
+        try {
+          assert.equal(true, typeof a.getRuleById === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing ruleId', (done) => {
+        try {
+          a.getRuleById(null, (data, error) => {
+            try {
+              const displayE = 'ruleId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getRuleById', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateRule - errors', () => {
+      it('should have a updateRule function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateRule === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing ruleId', (done) => {
+        try {
+          a.updateRule(null, null, (data, error) => {
+            try {
+              const displayE = 'ruleId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-updateRule', displayE);
+              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 have a deleteRule function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteRule === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing ruleId', (done) => {
+        try {
+          a.deleteRule(null, (data, error) => {
+            try {
+              const displayE = 'ruleId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-deleteRule', displayE);
+              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 have a getDeviceGroups function', (done) => {
+        try {
+          assert.equal(true, typeof a.getDeviceGroups === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDevices - errors', () => {
+      it('should have a getDevices function', (done) => {
+        try {
+          assert.equal(true, typeof a.getDevices === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDevicesLite - errors', () => {
+      it('should have a getDevicesLite function', (done) => {
+        try {
+          assert.equal(true, typeof a.getDevicesLite === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getEventReportEntryCsvExportStatus - errors', () => {
+      it('should have a getEventReportEntryCsvExportStatus function', (done) => {
+        try {
+          assert.equal(true, typeof a.getEventReportEntryCsvExportStatus === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#startEventReportEntryCsvExport - errors', () => {
+      it('should have a startEventReportEntryCsvExport function', (done) => {
+        try {
+          assert.equal(true, typeof a.startEventReportEntryCsvExport === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#cancelEventReportEntryCsvExport - errors', () => {
+      it('should have a cancelEventReportEntryCsvExport function', (done) => {
+        try {
+          assert.equal(true, typeof a.cancelEventReportEntryCsvExport === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getEventReportEntryCsvData - errors', () => {
+      it('should have a getEventReportEntryCsvData function', (done) => {
+        try {
+          assert.equal(true, typeof a.getEventReportEntryCsvData === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getFirewallFilteringRules - errors', () => {
+      it('should have a getFirewallFilteringRules function', (done) => {
+        try {
+          assert.equal(true, typeof a.getFirewallFilteringRules === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createFirewallFilteringRule - errors', () => {
+      it('should have a createFirewallFilteringRule function', (done) => {
+        try {
+          assert.equal(true, typeof a.createFirewallFilteringRule === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getFirewallFilteringRule - errors', () => {
+      it('should have a getFirewallFilteringRule function', (done) => {
+        try {
+          assert.equal(true, typeof a.getFirewallFilteringRule === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing ruleId', (done) => {
+        try {
+          a.getFirewallFilteringRule(null, (data, error) => {
+            try {
+              const displayE = 'ruleId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getFirewallFilteringRule', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateFirewallFilteringRule - errors', () => {
+      it('should have a updateFirewallFilteringRule function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateFirewallFilteringRule === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing ruleId', (done) => {
+        try {
+          a.updateFirewallFilteringRule(null, null, (data, error) => {
+            try {
+              const displayE = 'ruleId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-updateFirewallFilteringRule', displayE);
+              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 have a deleteFirewallFilteringRule function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteFirewallFilteringRule === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing ruleId', (done) => {
+        try {
+          a.deleteFirewallFilteringRule(null, (data, error) => {
+            try {
+              const displayE = 'ruleId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-deleteFirewallFilteringRule', displayE);
+              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 have a getDestinationIpGroups function', (done) => {
+        try {
+          assert.equal(true, typeof a.getDestinationIpGroups === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#addDestinationIpGroup - errors', () => {
+      it('should have a addDestinationIpGroup function', (done) => {
+        try {
+          assert.equal(true, typeof a.addDestinationIpGroup === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDestinationIpv6Groups - errors', () => {
+      it('should have a getDestinationIpv6Groups function', (done) => {
+        try {
+          assert.equal(true, typeof a.getDestinationIpv6Groups === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDestinationIpv6GroupsLite - errors', () => {
+      it('should have a getDestinationIpv6GroupsLite function', (done) => {
+        try {
+          assert.equal(true, typeof a.getDestinationIpv6GroupsLite === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDestinationIpGroupsLite - errors', () => {
+      it('should have a getDestinationIpGroupsLite function', (done) => {
+        try {
+          assert.equal(true, typeof a.getDestinationIpGroupsLite === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDestinationIpGroupById - errors', () => {
+      it('should have a getDestinationIpGroupById function', (done) => {
+        try {
+          assert.equal(true, typeof a.getDestinationIpGroupById === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing ipGroupId', (done) => {
+        try {
+          a.getDestinationIpGroupById(null, (data, error) => {
+            try {
+              const displayE = 'ipGroupId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getDestinationIpGroupById', displayE);
+              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 have a editDestinationIpGroup function', (done) => {
+        try {
+          assert.equal(true, typeof a.editDestinationIpGroup === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing ipGroupId', (done) => {
+        try {
+          a.editDestinationIpGroup(null, (data, error) => {
+            try {
+              const displayE = 'ipGroupId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-editDestinationIpGroup', displayE);
+              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 have a deleteDestinationIpGroup function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteDestinationIpGroup === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing ipGroupId', (done) => {
+        try {
+          a.deleteDestinationIpGroup(null, (data, error) => {
+            try {
+              const displayE = 'ipGroupId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-deleteDestinationIpGroup', displayE);
+              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 have a getSourceIpGroups function', (done) => {
+        try {
+          assert.equal(true, typeof a.getSourceIpGroups === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#addSourceIpGroup - errors', () => {
+      it('should have a addSourceIpGroup function', (done) => {
+        try {
+          assert.equal(true, typeof a.addSourceIpGroup === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSourceIpv6Groups - errors', () => {
+      it('should have a getSourceIpv6Groups function', (done) => {
+        try {
+          assert.equal(true, typeof a.getSourceIpv6Groups === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSourceIpv6GroupsLite - errors', () => {
+      it('should have a getSourceIpv6GroupsLite function', (done) => {
+        try {
+          assert.equal(true, typeof a.getSourceIpv6GroupsLite === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSourceIpGroupsLite - errors', () => {
+      it('should have a getSourceIpGroupsLite function', (done) => {
+        try {
+          assert.equal(true, typeof a.getSourceIpGroupsLite === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSourceIpGroupById - errors', () => {
+      it('should have a getSourceIpGroupById function', (done) => {
+        try {
+          assert.equal(true, typeof a.getSourceIpGroupById === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing ipGroupId', (done) => {
+        try {
+          a.getSourceIpGroupById(null, (data, error) => {
+            try {
+              const displayE = 'ipGroupId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getSourceIpGroupById', displayE);
+              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 have a editSourceIpGroup function', (done) => {
+        try {
+          assert.equal(true, typeof a.editSourceIpGroup === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing ipGroupId', (done) => {
+        try {
+          a.editSourceIpGroup(null, (data, error) => {
+            try {
+              const displayE = 'ipGroupId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-editSourceIpGroup', displayE);
+              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 have a deleteSourceIpGroup function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteSourceIpGroup === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing ipGroupId', (done) => {
+        try {
+          a.deleteSourceIpGroup(null, (data, error) => {
+            try {
+              const displayE = 'ipGroupId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-deleteSourceIpGroup', displayE);
+              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 have a getNetowrkApplicationGroups function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNetowrkApplicationGroups === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createNetworkApplicationGroup - errors', () => {
+      it('should have a createNetworkApplicationGroup function', (done) => {
+        try {
+          assert.equal(true, typeof a.createNetworkApplicationGroup === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNetowrkApplicationGroupsLite - errors', () => {
+      it('should have a getNetowrkApplicationGroupsLite function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNetowrkApplicationGroupsLite === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNetworkApplicationGroupById - errors', () => {
+      it('should have a getNetworkApplicationGroupById function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNetworkApplicationGroupById === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing groupId', (done) => {
+        try {
+          a.getNetworkApplicationGroupById(null, (data, error) => {
+            try {
+              const displayE = 'groupId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getNetworkApplicationGroupById', displayE);
+              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 have a updateNetworkApplicationGroup function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateNetworkApplicationGroup === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing groupId', (done) => {
+        try {
+          a.updateNetworkApplicationGroup(null, (data, error) => {
+            try {
+              const displayE = 'groupId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-updateNetworkApplicationGroup', displayE);
+              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 have a deleteNetworkApplicationGroup function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteNetworkApplicationGroup === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing groupId', (done) => {
+        try {
+          a.deleteNetworkApplicationGroup(null, (data, error) => {
+            try {
+              const displayE = 'groupId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-deleteNetworkApplicationGroup', displayE);
+              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 have a getNetworkApplications function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNetworkApplications === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNetworkApplicationById - errors', () => {
+      it('should have a getNetworkApplicationById function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNetworkApplicationById === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing appId', (done) => {
+        try {
+          a.getNetworkApplicationById(null, null, (data, error) => {
+            try {
+              const displayE = 'appId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getNetworkApplicationById', displayE);
+              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 have a getNetworkServiceGroups function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNetworkServiceGroups === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#addCustomNetworkServiceGroup - errors', () => {
+      it('should have a addCustomNetworkServiceGroup function', (done) => {
+        try {
+          assert.equal(true, typeof a.addCustomNetworkServiceGroup === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNetworkServiceGroupsLite - errors', () => {
+      it('should have a getNetworkServiceGroupsLite function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNetworkServiceGroupsLite === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNetworkServiceGroupById - errors', () => {
+      it('should have a getNetworkServiceGroupById function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNetworkServiceGroupById === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing serviceGroupId', (done) => {
+        try {
+          a.getNetworkServiceGroupById(null, (data, error) => {
+            try {
+              const displayE = 'serviceGroupId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getNetworkServiceGroupById', displayE);
+              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 have a editNetworkServiceGroup function', (done) => {
+        try {
+          assert.equal(true, typeof a.editNetworkServiceGroup === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing serviceGroupId', (done) => {
+        try {
+          a.editNetworkServiceGroup(null, (data, error) => {
+            try {
+              const displayE = 'serviceGroupId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-editNetworkServiceGroup', displayE);
+              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 have a deleteCustomNetowrkServiceGroup function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteCustomNetowrkServiceGroup === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing serviceGroupId', (done) => {
+        try {
+          a.deleteCustomNetowrkServiceGroup(null, (data, error) => {
+            try {
+              const displayE = 'serviceGroupId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-deleteCustomNetowrkServiceGroup', displayE);
+              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 have a getNetworkServices function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNetworkServices === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#addCustomNetworkService - errors', () => {
+      it('should have a addCustomNetworkService function', (done) => {
+        try {
+          assert.equal(true, typeof a.addCustomNetworkService === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNetworkServicesLite - errors', () => {
+      it('should have a getNetworkServicesLite function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNetworkServicesLite === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNetworkServiceById - errors', () => {
+      it('should have a getNetworkServiceById function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNetworkServiceById === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing serviceId', (done) => {
+        try {
+          a.getNetworkServiceById(null, null, (data, error) => {
+            try {
+              const displayE = 'serviceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getNetworkServiceById', displayE);
+              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 have a editNetworkService function', (done) => {
+        try {
+          assert.equal(true, typeof a.editNetworkService === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing serviceId', (done) => {
+        try {
+          a.editNetworkService(null, (data, error) => {
+            try {
+              const displayE = 'serviceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-editNetworkService', displayE);
+              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 have a deleteCustomNetworkService function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteCustomNetworkService === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing serviceId', (done) => {
+        try {
+          a.deleteCustomNetworkService(null, (data, error) => {
+            try {
+              const displayE = 'serviceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-deleteCustomNetworkService', displayE);
+              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 have a getTimeWindows function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTimeWindows === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTimeWindowSummary - errors', () => {
+      it('should have a getTimeWindowSummary function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTimeWindowSummary === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getUrlFilteringRules - errors', () => {
+      it('should have a getUrlFilteringRules function', (done) => {
+        try {
+          assert.equal(true, typeof a.getUrlFilteringRules === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postUrlFilteringRules - errors', () => {
+      it('should have a postUrlFilteringRules function', (done) => {
+        try {
+          assert.equal(true, typeof a.postUrlFilteringRules === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getUrlFilteringRulesRuleId - errors', () => {
+      it('should have a getUrlFilteringRulesRuleId function', (done) => {
+        try {
+          assert.equal(true, typeof a.getUrlFilteringRulesRuleId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing ruleId', (done) => {
+        try {
+          a.getUrlFilteringRulesRuleId(null, (data, error) => {
+            try {
+              const displayE = 'ruleId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getUrlFilteringRulesRuleId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#putUrlFilteringRulesRuleId - errors', () => {
+      it('should have a putUrlFilteringRulesRuleId function', (done) => {
+        try {
+          assert.equal(true, typeof a.putUrlFilteringRulesRuleId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing ruleId', (done) => {
+        try {
+          a.putUrlFilteringRulesRuleId(null, null, (data, error) => {
+            try {
+              const displayE = 'ruleId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-putUrlFilteringRulesRuleId', displayE);
+              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 have a deleteUrlFilteringRulesRuleId function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteUrlFilteringRulesRuleId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing ruleId', (done) => {
+        try {
+          a.deleteUrlFilteringRulesRuleId(null, (data, error) => {
+            try {
+              const displayE = 'ruleId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-deleteUrlFilteringRulesRuleId', displayE);
+              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 have a getForwardingRules function', (done) => {
+        try {
+          assert.equal(true, typeof a.getForwardingRules === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createForwardingRule - errors', () => {
+      it('should have a createForwardingRule function', (done) => {
+        try {
+          assert.equal(true, typeof a.createForwardingRule === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getForwardingRule - errors', () => {
+      it('should have a getForwardingRule function', (done) => {
+        try {
+          assert.equal(true, typeof a.getForwardingRule === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing ruleId', (done) => {
+        try {
+          a.getForwardingRule(null, (data, error) => {
+            try {
+              const displayE = 'ruleId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getForwardingRule', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateForwardingRule - errors', () => {
+      it('should have a updateForwardingRule function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateForwardingRule === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing ruleId', (done) => {
+        try {
+          a.updateForwardingRule(null, null, (data, error) => {
+            try {
+              const displayE = 'ruleId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-updateForwardingRule', displayE);
+              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 have a deleteForwardingRule function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteForwardingRule === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing ruleId', (done) => {
+        try {
+          a.deleteForwardingRule(null, (data, error) => {
+            try {
+              const displayE = 'ruleId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-deleteForwardingRule', displayE);
+              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 have a getZpaGateways function', (done) => {
+        try {
+          assert.equal(true, typeof a.getZpaGateways === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#addZpaGateway - errors', () => {
+      it('should have a addZpaGateway function', (done) => {
+        try {
+          assert.equal(true, typeof a.addZpaGateway === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getZpaGatewayById - errors', () => {
+      it('should have a getZpaGatewayById function', (done) => {
+        try {
+          assert.equal(true, typeof a.getZpaGatewayById === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing gatewayId', (done) => {
+        try {
+          a.getZpaGatewayById(null, (data, error) => {
+            try {
+              const displayE = 'gatewayId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getZpaGatewayById', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#editZpaGateway - errors', () => {
+      it('should have a editZpaGateway function', (done) => {
+        try {
+          assert.equal(true, typeof a.editZpaGateway === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing gatewayId', (done) => {
+        try {
+          a.editZpaGateway(null, null, (data, error) => {
+            try {
+              const displayE = 'gatewayId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-editZpaGateway', displayE);
+              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 have a deleteZpaGateway function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteZpaGateway === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing gatewayId', (done) => {
+        try {
+          a.deleteZpaGateway(null, (data, error) => {
+            try {
+              const displayE = 'gatewayId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-deleteZpaGateway', displayE);
+              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 have a getIntermediateCaCertificates function', (done) => {
+        try {
+          assert.equal(true, typeof a.getIntermediateCaCertificates === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#addIntermediateCaCertificate - errors', () => {
+      it('should have a addIntermediateCaCertificate function', (done) => {
+        try {
+          assert.equal(true, typeof a.addIntermediateCaCertificate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#downloadAttestationStmt - errors', () => {
+      it('should have a downloadAttestationStmt function', (done) => {
+        try {
+          assert.equal(true, typeof a.downloadAttestationStmt === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certId', (done) => {
+        try {
+          a.downloadAttestationStmt(null, (data, error) => {
+            try {
+              const displayE = 'certId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-downloadAttestationStmt', displayE);
+              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 have a downloadCSR function', (done) => {
+        try {
+          assert.equal(true, typeof a.downloadCSR === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certId', (done) => {
+        try {
+          a.downloadCSR(null, (data, error) => {
+            try {
+              const displayE = 'certId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-downloadCSR', displayE);
+              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 have a downloadHsmPublicKey function', (done) => {
+        try {
+          assert.equal(true, typeof a.downloadHsmPublicKey === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certId', (done) => {
+        try {
+          a.downloadHsmPublicKey(null, (data, error) => {
+            try {
+              const displayE = 'certId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-downloadHsmPublicKey', displayE);
+              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 have a finalizeCert function', (done) => {
+        try {
+          assert.equal(true, typeof a.finalizeCert === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certId', (done) => {
+        try {
+          a.finalizeCert(null, (data, error) => {
+            try {
+              const displayE = 'certId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-finalizeCert', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#generateCsr - errors', () => {
+      it('should have a generateCsr function', (done) => {
+        try {
+          assert.equal(true, typeof a.generateCsr === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certId', (done) => {
+        try {
+          a.generateCsr(null, null, (data, error) => {
+            try {
+              const displayE = 'certId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-generateCsr', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.generateCsr('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-generateCsr', displayE);
+              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 have a generateHsmKeyPair function', (done) => {
+        try {
+          assert.equal(true, typeof a.generateHsmKeyPair === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certId', (done) => {
+        try {
+          a.generateHsmKeyPair(null, (data, error) => {
+            try {
+              const displayE = 'certId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-generateHsmKeyPair', displayE);
+              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 have a getIntermediateCaCertificatesLite function', (done) => {
+        try {
+          assert.equal(true, typeof a.getIntermediateCaCertificatesLite === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getIntermediateCaCertificateLite - errors', () => {
+      it('should have a getIntermediateCaCertificateLite function', (done) => {
+        try {
+          assert.equal(true, typeof a.getIntermediateCaCertificateLite === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certId', (done) => {
+        try {
+          a.getIntermediateCaCertificateLite(null, (data, error) => {
+            try {
+              const displayE = 'certId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getIntermediateCaCertificateLite', displayE);
+              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 have a makeDefaultCertificate function', (done) => {
+        try {
+          assert.equal(true, typeof a.makeDefaultCertificate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certId', (done) => {
+        try {
+          a.makeDefaultCertificate(null, (data, error) => {
+            try {
+              const displayE = 'certId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-makeDefaultCertificate', displayE);
+              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 have a getCertificatesInReadyToUseState function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCertificatesInReadyToUseState === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showCert - errors', () => {
+      it('should have a showCert function', (done) => {
+        try {
+          assert.equal(true, typeof a.showCert === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certId', (done) => {
+        try {
+          a.showCert(null, (data, error) => {
+            try {
+              const displayE = 'certId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-showCert', displayE);
+              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 have a showCsr function', (done) => {
+        try {
+          assert.equal(true, typeof a.showCsr === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certId', (done) => {
+        try {
+          a.showCsr(null, (data, error) => {
+            try {
+              const displayE = 'certId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-showCsr', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#uploadCert - errors', () => {
+      it('should have a uploadCert function', (done) => {
+        try {
+          assert.equal(true, typeof a.uploadCert === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certId', (done) => {
+        try {
+          a.uploadCert(null, null, (data, error) => {
+            try {
+              const displayE = 'certId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-uploadCert', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#uploadCertChain - errors', () => {
+      it('should have a uploadCertChain function', (done) => {
+        try {
+          assert.equal(true, typeof a.uploadCertChain === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certId', (done) => {
+        try {
+          a.uploadCertChain(null, null, (data, error) => {
+            try {
+              const displayE = 'certId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-uploadCertChain', displayE);
+              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 have a verifyKeyAttestation function', (done) => {
+        try {
+          assert.equal(true, typeof a.verifyKeyAttestation === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certId', (done) => {
+        try {
+          a.verifyKeyAttestation(null, (data, error) => {
+            try {
+              const displayE = 'certId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-verifyKeyAttestation', displayE);
+              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 have a getIntermediateCaCertificate function', (done) => {
+        try {
+          assert.equal(true, typeof a.getIntermediateCaCertificate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certId', (done) => {
+        try {
+          a.getIntermediateCaCertificate(null, (data, error) => {
+            try {
+              const displayE = 'certId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getIntermediateCaCertificate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateIntermediateCaCertificate - errors', () => {
+      it('should have a updateIntermediateCaCertificate function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateIntermediateCaCertificate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certId', (done) => {
+        try {
+          a.updateIntermediateCaCertificate(null, null, (data, error) => {
+            try {
+              const displayE = 'certId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-updateIntermediateCaCertificate', displayE);
+              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 have a deleteIntermediateCaCertificate function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteIntermediateCaCertificate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certId', (done) => {
+        try {
+          a.deleteIntermediateCaCertificate(null, (data, error) => {
+            try {
+              const displayE = 'certId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-deleteIntermediateCaCertificate', displayE);
+              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 have a getSslExemptedUrls function', (done) => {
+        try {
+          assert.equal(true, typeof a.getSslExemptedUrls === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateSslExemptedUrls - errors', () => {
+      it('should have a updateSslExemptedUrls function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateSslExemptedUrls === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing action', (done) => {
+        try {
+          a.updateSslExemptedUrls(null, (data, error) => {
+            try {
+              const displayE = 'action is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-updateSslExemptedUrls', displayE);
+              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 have a getDeviceTypes function', (done) => {
+        try {
+          assert.equal(true, typeof a.getDeviceTypes === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getCategories - errors', () => {
+      it('should have a getCategories function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCategories === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getClassifications - errors', () => {
+      it('should have a getClassifications function', (done) => {
+        try {
+          assert.equal(true, typeof a.getClassifications === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDeviceList - errors', () => {
+      it('should have a getDeviceList function', (done) => {
+        try {
+          assert.equal(true, typeof a.getDeviceList === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSubLocations - errors', () => {
+      it('should have a getSubLocations function', (done) => {
+        try {
+          assert.equal(true, typeof a.getSubLocations === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing locationId', (done) => {
+        try {
+          a.getSubLocations(null, null, null, null, null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'locationId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getSubLocations', displayE);
+              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 have a getGroupsCount function', (done) => {
+        try {
+          assert.equal(true, typeof a.getGroupsCount === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getGroupsSummary - errors', () => {
+      it('should have a getGroupsSummary function', (done) => {
+        try {
+          assert.equal(true, typeof a.getGroupsSummary === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getGroupSummary - errors', () => {
+      it('should have a getGroupSummary function', (done) => {
+        try {
+          assert.equal(true, typeof a.getGroupSummary === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.getGroupSummary(null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getGroupSummary', displayE);
+              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 have a getGroupById function', (done) => {
+        try {
+          assert.equal(true, typeof a.getGroupById === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.getGroupById(null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getGroupById', displayE);
+              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 have a getRuleLabels function', (done) => {
+        try {
+          assert.equal(true, typeof a.getRuleLabels === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#addRuleLabel - errors', () => {
+      it('should have a addRuleLabel function', (done) => {
+        try {
+          assert.equal(true, typeof a.addRuleLabel === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getRuleLabelById - errors', () => {
+      it('should have a getRuleLabelById function', (done) => {
+        try {
+          assert.equal(true, typeof a.getRuleLabelById === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing ruleLabelId', (done) => {
+        try {
+          a.getRuleLabelById(null, (data, error) => {
+            try {
+              const displayE = 'ruleLabelId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getRuleLabelById', displayE);
+              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 have a updateRuleLabel function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateRuleLabel === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing ruleLabelId', (done) => {
+        try {
+          a.updateRuleLabel(null, (data, error) => {
+            try {
+              const displayE = 'ruleLabelId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-updateRuleLabel', displayE);
+              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 have a deleteRuleLabel function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteRuleLabel === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing ruleLabelId', (done) => {
+        try {
+          a.deleteRuleLabel(null, (data, error) => {
+            try {
+              const displayE = 'ruleLabelId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-deleteRuleLabel', displayE);
+              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 have a getCustomFileHash function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCustomFileHash === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateCustomFileHash - errors', () => {
+      it('should have a updateCustomFileHash function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateCustomFileHash === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getCustomFileHashQuota - errors', () => {
+      it('should have a getCustomFileHashQuota function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCustomFileHashQuota === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#bulkUpdateCloudApplication - errors', () => {
+      it('should have a bulkUpdateCloudApplication function', (done) => {
+        try {
+          assert.equal(true, typeof a.bulkUpdateCloudApplication === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.bulkUpdateCloudApplication(null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-bulkUpdateCloudApplication', displayE);
+              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 have a getCloudApplicationsLite function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCloudApplicationsLite === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAllCustomTags - errors', () => {
+      it('should have a getAllCustomTags function', (done) => {
+        try {
+          assert.equal(true, typeof a.getAllCustomTags === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getReportDataApplicationsExport - errors', () => {
+      it('should have a getReportDataApplicationsExport function', (done) => {
+        try {
+          assert.equal(true, typeof a.getReportDataApplicationsExport === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.getReportDataApplicationsExport(null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getReportDataApplicationsExport', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getReportTransactionsExport - errors', () => {
+      it('should have a getReportTransactionsExport function', (done) => {
+        try {
+          assert.equal(true, typeof a.getReportTransactionsExport === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing entity', (done) => {
+        try {
+          a.getReportTransactionsExport(null, null, (data, error) => {
+            try {
+              const displayE = 'entity is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getReportTransactionsExport', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.getReportTransactionsExport('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getReportTransactionsExport', displayE);
+              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 have a getAllGreTunnels function', (done) => {
+        try {
+          assert.equal(true, typeof a.getAllGreTunnels === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#addGreTunnel - errors', () => {
+      it('should have a addGreTunnel function', (done) => {
+        try {
+          assert.equal(true, typeof a.addGreTunnel === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.addGreTunnel(null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-addGreTunnel', displayE);
+              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 have a validateAndGetAvailableInternalIpRanges function', (done) => {
+        try {
+          assert.equal(true, typeof a.validateAndGetAvailableInternalIpRanges === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getGreTunelById - errors', () => {
+      it('should have a getGreTunelById function', (done) => {
+        try {
+          assert.equal(true, typeof a.getGreTunelById === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.getGreTunelById(null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getGreTunelById', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateGreTunnel - errors', () => {
+      it('should have a updateGreTunnel function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateGreTunnel === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.updateGreTunnel(null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-updateGreTunnel', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.updateGreTunnel('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-updateGreTunnel', displayE);
+              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 have a deleteGreTunnel function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteGreTunnel === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.deleteGreTunnel(null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-deleteGreTunnel', displayE);
+              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 have a getIPv6Configuration function', (done) => {
+        try {
+          assert.equal(true, typeof a.getIPv6Configuration === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDns64Prefixes - errors', () => {
+      it('should have a getDns64Prefixes function', (done) => {
+        try {
+          assert.equal(true, typeof a.getDns64Prefixes === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNat64Prefixes - errors', () => {
+      it('should have a getNat64Prefixes function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNat64Prefixes === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getIPGWDetails - errors', () => {
+      it('should have a getIPGWDetails function', (done) => {
+        try {
+          assert.equal(true, typeof a.getIPGWDetails === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getRegionByGeoCoordinates - errors', () => {
+      it('should have a getRegionByGeoCoordinates function', (done) => {
+        try {
+          assert.equal(true, typeof a.getRegionByGeoCoordinates === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing latitude', (done) => {
+        try {
+          a.getRegionByGeoCoordinates(null, null, (data, error) => {
+            try {
+              const displayE = 'latitude is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getRegionByGeoCoordinates', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing longitude', (done) => {
+        try {
+          a.getRegionByGeoCoordinates('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'longitude is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getRegionByGeoCoordinates', displayE);
+              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 have a getRegionBySrcIPAddress function', (done) => {
+        try {
+          assert.equal(true, typeof a.getRegionBySrcIPAddress === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing ip', (done) => {
+        try {
+          a.getRegionBySrcIPAddress(null, (data, error) => {
+            try {
+              const displayE = 'ip is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getRegionBySrcIPAddress', displayE);
+              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 have a getRegionsByPrefix function', (done) => {
+        try {
+          assert.equal(true, typeof a.getRegionsByPrefix === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAllStaticIPs - errors', () => {
+      it('should have a getAllStaticIPs function', (done) => {
+        try {
+          assert.equal(true, typeof a.getAllStaticIPs === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#addStaticIP - errors', () => {
+      it('should have a addStaticIP function', (done) => {
+        try {
+          assert.equal(true, typeof a.addStaticIP === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.addStaticIP(null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-addStaticIP', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#validateIPAddress - errors', () => {
+      it('should have a validateIPAddress function', (done) => {
+        try {
+          assert.equal(true, typeof a.validateIPAddress === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.validateIPAddress(null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-validateIPAddress', displayE);
+              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 have a getStaticIPById function', (done) => {
+        try {
+          assert.equal(true, typeof a.getStaticIPById === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.getStaticIPById(null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-getStaticIPById', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateStaticIP - errors', () => {
+      it('should have a updateStaticIP function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateStaticIP === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.updateStaticIP(null, null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-updateStaticIP', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.updateStaticIP('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-updateStaticIP', displayE);
+              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 have a deleteStaticIP function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteStaticIP === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing id', (done) => {
+        try {
+          a.deleteStaticIP(null, (data, error) => {
+            try {
+              const displayE = 'id is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-deleteStaticIP', displayE);
+              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 have a getZscalerNodesDetails function', (done) => {
+        try {
+          assert.equal(true, typeof a.getZscalerNodesDetails === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getRecommendedVipsGroupedByDC - errors', () => {
+      it('should have a getRecommendedVipsGroupedByDC function', (done) => {
+        try {
+          assert.equal(true, typeof a.getRecommendedVipsGroupedByDC === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getRecommendedGreVips - errors', () => {
+      it('should have a getRecommendedGreVips function', (done) => {
+        try {
+          assert.equal(true, typeof a.getRecommendedGreVips === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAuthExemptedUrls - errors', () => {
+      it('should have a getAuthExemptedUrls function', (done) => {
+        try {
+          assert.equal(true, typeof a.getAuthExemptedUrls === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateAuthExemptedUrls - errors', () => {
+      it('should have a updateAuthExemptedUrls function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateAuthExemptedUrls === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing action', (done) => {
+        try {
+          a.updateAuthExemptedUrls(null, (data, error) => {
+            try {
+              const displayE = 'action is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-zscaler-adapter-updateAuthExemptedUrls', displayE);
+              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 have a getWorkloadGroups function', (done) => {
+        try {
+          assert.equal(true, typeof a.getWorkloadGroups === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getLocationGroups - errors', () => {
+      it('should have a getLocationGroups function', (done) => {
+        try {
+          assert.equal(true, typeof a.getLocationGroups === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
   });
 });