@itentialopensource/adapter-f5_bigiq 0.2.0 → 0.3.1

package/test/unit/adapterTestUnit.js

@@ -6507,6 +6507,52 @@ describe('[unit] F5BigIQ Adapter Test', () => {
       }).timeout(attemptTimeout);
     });
 
+    describe('#performDeviceDiscoveryTask - errors', () => {
+      it('should have a performDeviceDiscoveryTask function', (done) => {
+        try {
+          assert.equal(true, typeof a.performDeviceDiscoveryTask === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing objectId', (done) => {
+        try {
+          a.performDeviceDiscoveryTask(null, null, (data, error) => {
+            try {
+              const displayE = 'objectId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-performDeviceDiscoveryTask', 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.performDeviceDiscoveryTask('fakedata', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-performDeviceDiscoveryTask', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
     describe('#postDeviceTrustTask - errors', () => {
       it('should have a postDeviceTrustTask function', (done) => {
         try {
@@ -10962,5 +11008,1110 @@ describe('[unit] F5BigIQ Adapter Test', () => {
         }
       }).timeout(attemptTimeout);
     });
+
+    describe('#getResolveMachineId - errors', () => {
+      it('should have a getResolveMachineId function', (done) => {
+        try {
+          assert.equal(true, typeof a.getResolveMachineId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getExampleQkview - errors', () => {
+      it('should have a getExampleQkview function', (done) => {
+        try {
+          assert.equal(true, typeof a.getExampleQkview === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#retrieveQkviewTasks - errors', () => {
+      it('should have a retrieveQkviewTasks function', (done) => {
+        try {
+          assert.equal(true, typeof a.retrieveQkviewTasks === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#generateaQkview - errors', () => {
+      it('should have a generateaQkview function', (done) => {
+        try {
+          assert.equal(true, typeof a.generateaQkview === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.generateaQkview(null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-generateaQkview', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#queryBIGIQQkviewTask - errors', () => {
+      it('should have a queryBIGIQQkviewTask function', (done) => {
+        try {
+          assert.equal(true, typeof a.queryBIGIQQkviewTask === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing bIGIQQKVIEWTASKID', (done) => {
+        try {
+          a.queryBIGIQQkviewTask(null, (data, error) => {
+            try {
+              const displayE = 'bIGIQQKVIEWTASKID is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-queryBIGIQQkviewTask', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteBIGIQQkview - errors', () => {
+      it('should have a deleteBIGIQQkview function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteBIGIQQkview === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing bIGIQQKVIEWTASKID', (done) => {
+        try {
+          a.deleteBIGIQQkview(null, (data, error) => {
+            try {
+              const displayE = 'bIGIQQKVIEWTASKID is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteBIGIQQkview', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#queryBIGIPQkviewTask - errors', () => {
+      it('should have a queryBIGIPQkviewTask function', (done) => {
+        try {
+          assert.equal(true, typeof a.queryBIGIPQkviewTask === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing bIGIPQKVIEWTASKID', (done) => {
+        try {
+          a.queryBIGIPQkviewTask(null, (data, error) => {
+            try {
+              const displayE = 'bIGIPQKVIEWTASKID is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-queryBIGIPQkviewTask', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteaBIGIQQkview - errors', () => {
+      it('should have a deleteaBIGIQQkview function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteaBIGIQQkview === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing bIGIPQKVIEWTASKID', (done) => {
+        try {
+          a.deleteaBIGIQQkview(null, (data, error) => {
+            try {
+              const displayE = 'bIGIPQKVIEWTASKID is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteaBIGIQQkview', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getExampleBIGIPiHealthReport - errors', () => {
+      it('should have a getExampleBIGIPiHealthReport function', (done) => {
+        try {
+          assert.equal(true, typeof a.getExampleBIGIPiHealthReport === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getExampleBIGIPiHealthUploads - errors', () => {
+      it('should have a getExampleBIGIPiHealthUploads function', (done) => {
+        try {
+          assert.equal(true, typeof a.getExampleBIGIPiHealthUploads === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getExampleBIGIPiHealthCredentials - errors', () => {
+      it('should have a getExampleBIGIPiHealthCredentials function', (done) => {
+        try {
+          assert.equal(true, typeof a.getExampleBIGIPiHealthCredentials === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getExampleBIGIPiHealthConfig - errors', () => {
+      it('should have a getExampleBIGIPiHealthConfig function', (done) => {
+        try {
+          assert.equal(true, typeof a.getExampleBIGIPiHealthConfig === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#retrieveBIGIPiHealthReports - errors', () => {
+      it('should have a retrieveBIGIPiHealthReports function', (done) => {
+        try {
+          assert.equal(true, typeof a.retrieveBIGIPiHealthReports === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#generateBIGIPiHealthReport - errors', () => {
+      it('should have a generateBIGIPiHealthReport function', (done) => {
+        try {
+          assert.equal(true, typeof a.generateBIGIPiHealthReport === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.generateBIGIPiHealthReport(null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-generateBIGIPiHealthReport', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#retrieveBIGIPiHealthCredentials - errors', () => {
+      it('should have a retrieveBIGIPiHealthCredentials function', (done) => {
+        try {
+          assert.equal(true, typeof a.retrieveBIGIPiHealthCredentials === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createTestBIGIPiHealthCredentials - errors', () => {
+      it('should have a createTestBIGIPiHealthCredentials function', (done) => {
+        try {
+          assert.equal(true, typeof a.createTestBIGIPiHealthCredentials === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.createTestBIGIPiHealthCredentials(null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createTestBIGIPiHealthCredentials', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#retrieveBIGIPiHealthConfig - errors', () => {
+      it('should have a retrieveBIGIPiHealthConfig function', (done) => {
+        try {
+          assert.equal(true, typeof a.retrieveBIGIPiHealthConfig === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateBIGIPiHealthConfig - errors', () => {
+      it('should have a updateBIGIPiHealthConfig function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateBIGIPiHealthConfig === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.updateBIGIPiHealthConfig(null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateBIGIPiHealthConfig', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#retrieveBIGIPiHealthUploads - errors', () => {
+      it('should have a retrieveBIGIPiHealthUploads function', (done) => {
+        try {
+          assert.equal(true, typeof a.retrieveBIGIPiHealthUploads === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createBIGIPiHealthUploadTask - errors', () => {
+      it('should have a createBIGIPiHealthUploadTask function', (done) => {
+        try {
+          assert.equal(true, typeof a.createBIGIPiHealthUploadTask === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.createBIGIPiHealthUploadTask(null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createBIGIPiHealthUploadTask', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#queryUploadTaskStatus - errors', () => {
+      it('should have a queryUploadTaskStatus function', (done) => {
+        try {
+          assert.equal(true, typeof a.queryUploadTaskStatus === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing iHealthUploadTaskId', (done) => {
+        try {
+          a.queryUploadTaskStatus(null, (data, error) => {
+            try {
+              const displayE = 'iHealthUploadTaskId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-queryUploadTaskStatus', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#modifyTestBIGIPiHealthCredentials - errors', () => {
+      it('should have a modifyTestBIGIPiHealthCredentials function', (done) => {
+        try {
+          assert.equal(true, typeof a.modifyTestBIGIPiHealthCredentials === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing credentialsId', (done) => {
+        try {
+          a.modifyTestBIGIPiHealthCredentials(null, null, (data, error) => {
+            try {
+              const displayE = 'credentialsId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-modifyTestBIGIPiHealthCredentials', 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.modifyTestBIGIPiHealthCredentials('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-modifyTestBIGIPiHealthCredentials', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteTestBIGIPiHealthCredentials - errors', () => {
+      it('should have a deleteTestBIGIPiHealthCredentials function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteTestBIGIPiHealthCredentials === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing credentialsId', (done) => {
+        try {
+          a.deleteTestBIGIPiHealthCredentials(null, (data, error) => {
+            try {
+              const displayE = 'credentialsId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteTestBIGIPiHealthCredentials', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#verifyProperSystemStatus - errors', () => {
+      it('should have a verifyProperSystemStatus function', (done) => {
+        try {
+          assert.equal(true, typeof a.verifyProperSystemStatus === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#verifyProperHAStatus - errors', () => {
+      it('should have a verifyProperHAStatus function', (done) => {
+        try {
+          assert.equal(true, typeof a.verifyProperHAStatus === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getExampleBackupRestoreTask - errors', () => {
+      it('should have a getExampleBackupRestoreTask function', (done) => {
+        try {
+          assert.equal(true, typeof a.getExampleBackupRestoreTask === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#retrieveallBackupTasks - errors', () => {
+      it('should have a retrieveallBackupTasks function', (done) => {
+        try {
+          assert.equal(true, typeof a.retrieveallBackupTasks === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#generateBackupofDevice - errors', () => {
+      it('should have a generateBackupofDevice function', (done) => {
+        try {
+          assert.equal(true, typeof a.generateBackupofDevice === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.generateBackupofDevice(null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-generateBackupofDevice', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#queryBackupTaskStatus - errors', () => {
+      it('should have a queryBackupTaskStatus function', (done) => {
+        try {
+          assert.equal(true, typeof a.queryBackupTaskStatus === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing backupTaskId', (done) => {
+        try {
+          a.queryBackupTaskStatus(null, (data, error) => {
+            try {
+              const displayE = 'backupTaskId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-queryBackupTaskStatus', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteBackupFile - errors', () => {
+      it('should have a deleteBackupFile function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteBackupFile === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing backupTaskId', (done) => {
+        try {
+          a.deleteBackupFile(null, (data, error) => {
+            try {
+              const displayE = 'backupTaskId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteBackupFile', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#generateBackupFileDownloadPathHash - errors', () => {
+      it('should have a generateBackupFileDownloadPathHash function', (done) => {
+        try {
+          assert.equal(true, typeof a.generateBackupFileDownloadPathHash === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.generateBackupFileDownloadPathHash(null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-generateBackupFileDownloadPathHash', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#downloadBackupFileusingPathHash - errors', () => {
+      it('should have a downloadBackupFileusingPathHash function', (done) => {
+        try {
+          assert.equal(true, typeof a.downloadBackupFileusingPathHash === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing pathHash', (done) => {
+        try {
+          a.downloadBackupFileusingPathHash(null, (data, error) => {
+            try {
+              const displayE = 'pathHash is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-downloadBackupFileusingPathHash', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getExampleBIGIPscripts - errors', () => {
+      it('should have a getExampleBIGIPscripts function', (done) => {
+        try {
+          assert.equal(true, typeof a.getExampleBIGIPscripts === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#retrieveallBIGIPscripts - errors', () => {
+      it('should have a retrieveallBIGIPscripts function', (done) => {
+        try {
+          assert.equal(true, typeof a.retrieveallBIGIPscripts === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createaBIGIPscript - errors', () => {
+      it('should have a createaBIGIPscript function', (done) => {
+        try {
+          assert.equal(true, typeof a.createaBIGIPscript === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.createaBIGIPscript(null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createaBIGIPscript', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#executeaBIGIPscript - errors', () => {
+      it('should have a executeaBIGIPscript function', (done) => {
+        try {
+          assert.equal(true, typeof a.executeaBIGIPscript === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.executeaBIGIPscript(null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-executeaBIGIPscript', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#queryBIGIPscriptstatus - errors', () => {
+      it('should have a queryBIGIPscriptstatus function', (done) => {
+        try {
+          assert.equal(true, typeof a.queryBIGIPscriptstatus === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing scriptTaskId', (done) => {
+        try {
+          a.queryBIGIPscriptstatus(null, (data, error) => {
+            try {
+              const displayE = 'scriptTaskId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-queryBIGIPscriptstatus', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#retrieveallSoftwareImages - errors', () => {
+      it('should have a retrieveallSoftwareImages function', (done) => {
+        try {
+          assert.equal(true, typeof a.retrieveallSoftwareImages === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#retrieveallBIGIPsandimageslots - errors', () => {
+      it('should have a retrieveallBIGIPsandimageslots function', (done) => {
+        try {
+          assert.equal(true, typeof a.retrieveallBIGIPsandimageslots === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#retrievaallUpgradeTasks - errors', () => {
+      it('should have a retrievaallUpgradeTasks function', (done) => {
+        try {
+          assert.equal(true, typeof a.retrievaallUpgradeTasks === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#performSoftwareUpgrade - errors', () => {
+      it('should have a performSoftwareUpgrade function', (done) => {
+        try {
+          assert.equal(true, typeof a.performSoftwareUpgrade === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.performSoftwareUpgrade(null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-performSoftwareUpgrade', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#retrieveBIGIPdevices - errors', () => {
+      it('should have a retrieveBIGIPdevices function', (done) => {
+        try {
+          assert.equal(true, typeof a.retrieveBIGIPdevices === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#retrieveDeviceGroups - errors', () => {
+      it('should have a retrieveDeviceGroups function', (done) => {
+        try {
+          assert.equal(true, typeof a.retrieveDeviceGroups === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#retrieveBIGIPHealthSummary - errors', () => {
+      it('should have a retrieveBIGIPHealthSummary function', (done) => {
+        try {
+          assert.equal(true, typeof a.retrieveBIGIPHealthSummary === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing instanceUuid', (done) => {
+        try {
+          a.retrieveBIGIPHealthSummary(null, (data, error) => {
+            try {
+              const displayE = 'instanceUuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-retrieveBIGIPHealthSummary', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#retrieveBIGIPDeviceImportTasks - errors', () => {
+      it('should have a retrieveBIGIPDeviceImportTasks function', (done) => {
+        try {
+          assert.equal(true, typeof a.retrieveBIGIPDeviceImportTasks === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#performBIGIPDeviceImportusingmachineId - errors', () => {
+      it('should have a performBIGIPDeviceImportusingmachineId function', (done) => {
+        try {
+          assert.equal(true, typeof a.performBIGIPDeviceImportusingmachineId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.performBIGIPDeviceImportusingmachineId(null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-performBIGIPDeviceImportusingmachineId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#performBIGIPDeviceImportusingImportTask - errors', () => {
+      it('should have a performBIGIPDeviceImportusingImportTask function', (done) => {
+        try {
+          assert.equal(true, typeof a.performBIGIPDeviceImportusingImportTask === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing deviceImportId', (done) => {
+        try {
+          a.performBIGIPDeviceImportusingImportTask(null, null, (data, error) => {
+            try {
+              const displayE = 'deviceImportId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-performBIGIPDeviceImportusingImportTask', 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.performBIGIPDeviceImportusingImportTask('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-performBIGIPDeviceImportusingImportTask', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#monitorImportTask - errors', () => {
+      it('should have a monitorImportTask function', (done) => {
+        try {
+          assert.equal(true, typeof a.monitorImportTask === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing deviceImportId', (done) => {
+        try {
+          a.monitorImportTask(null, (data, error) => {
+            try {
+              const displayE = 'deviceImportId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-monitorImportTask', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#queryDevicebyDeviceReference - errors', () => {
+      it('should have a queryDevicebyDeviceReference function', (done) => {
+        try {
+          assert.equal(true, typeof a.queryDevicebyDeviceReference === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.queryDevicebyDeviceReference(null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-queryDevicebyDeviceReference', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#queryDSCGroup - errors', () => {
+      it('should have a queryDSCGroup function', (done) => {
+        try {
+          assert.equal(true, typeof a.queryDSCGroup === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#queryDSCGroupByGroupId - errors', () => {
+      it('should have a queryDSCGroupByGroupId function', (done) => {
+        try {
+          assert.equal(true, typeof a.queryDSCGroupByGroupId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing groupId', (done) => {
+        try {
+          a.queryDSCGroupByGroupId(null, (data, error) => {
+            try {
+              const displayE = 'groupId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-queryDSCGroupByGroupId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
   });
 });