@itentialopensource/adapter-f5_bigiq 0.5.7 → 0.6.0

package/test/unit/adapterTestUnit.js

@@ -18,10 +18,10 @@ const { expect } = require('chai');
 const { use } = require('chai');
 const td = require('testdouble');
 const Ajv = require('ajv');
+const log = require('../../utils/logger');
 
 const ajv = new Ajv({ strictSchema: false, allErrors: true, allowUnionTypes: true });
 const anything = td.matchers.anything();
-let logLevel = 'none';
 const isRapidFail = false;
 
 // read in the properties from the sampleProperties files
@@ -36,13 +36,17 @@ const samProps = require(`${adaptdir}/sampleProperties.json`).properties;
 // these variables can be changed to run in integrated mode so easier to set them here
 // always check these in with bogus data!!!
 samProps.stub = true;
-samProps.host = 'replace.hostorip.here';
-samProps.authentication.username = 'username';
-samProps.authentication.password = 'password';
-samProps.protocol = 'http';
-samProps.port = 80;
-samProps.ssl.enabled = false;
-samProps.ssl.accept_invalid_cert = false;
+
+// uncomment if connecting
+// samProps.host = 'replace.hostorip.here';
+// samProps.authentication.username = 'username';
+// samProps.authentication.password = 'password';
+// samProps.authentication.token = 'password';
+// samProps.protocol = 'http';
+// samProps.port = 80;
+// samProps.ssl.enabled = false;
+// samProps.ssl.accept_invalid_cert = false;
+
 samProps.request.attempt_timeout = 1200000;
 const attemptTimeout = samProps.request.attempt_timeout;
 const { stub } = samProps;
@@ -64,43 +68,6 @@ global.pronghornProps = {
 
 global.$HOME = `${__dirname}/../..`;
 
-// set the log levels that Pronghorn uses, spam and trace are not defaulted in so without
-// this you may error on log.trace calls.
-const myCustomLevels = {
-  levels: {
-    spam: 6,
-    trace: 5,
-    debug: 4,
-    info: 3,
-    warn: 2,
-    error: 1,
-    none: 0
-  }
-};
-
-// need to see if there is a log level passed in
-process.argv.forEach((val) => {
-  // is there a log level defined to be passed in?
-  if (val.indexOf('--LOG') === 0) {
-    // get the desired log level
-    const inputVal = val.split('=')[1];
-
-    // validate the log level is supported, if so set it
-    if (Object.hasOwnProperty.call(myCustomLevels.levels, inputVal)) {
-      logLevel = inputVal;
-    }
-  }
-});
-
-// need to set global logging
-global.log = winston.createLogger({
-  level: logLevel,
-  levels: myCustomLevels.levels,
-  transports: [
-    new winston.transports.Console()
-  ]
-});
-
 /**
  * Runs the error asserts for the test
  */
@@ -314,16 +281,16 @@ describe('[unit] F5BigIQ Adapter Test', () => {
           assert.notEqual(undefined, packageDotJson.dependencies);
           assert.notEqual(null, packageDotJson.dependencies);
           assert.notEqual('', packageDotJson.dependencies);
-          assert.equal('^8.17.1', packageDotJson.dependencies.ajv);
-          assert.equal('^1.8.2', packageDotJson.dependencies.axios);
-          assert.equal('^11.0.0', packageDotJson.dependencies.commander);
-          assert.equal('^11.2.0', packageDotJson.dependencies['fs-extra']);
-          assert.equal('^10.8.2', packageDotJson.dependencies.mocha);
-          assert.equal('^2.0.1', packageDotJson.dependencies['mocha-param']);
-          assert.equal('^0.4.4', packageDotJson.dependencies.ping);
-          assert.equal('^1.4.10', packageDotJson.dependencies['readline-sync']);
-          assert.equal('^7.6.3', packageDotJson.dependencies.semver);
-          assert.equal('^3.17.0', packageDotJson.dependencies.winston);
+          assert.equal('8.17.1', packageDotJson.dependencies.ajv);
+          assert.equal('1.9.0', packageDotJson.dependencies.axios);
+          assert.equal('11.1.0', packageDotJson.dependencies.commander);
+          assert.equal('11.3.0', packageDotJson.dependencies['fs-extra']);
+          assert.equal('10.8.2', packageDotJson.dependencies.mocha);
+          assert.equal('2.0.1', packageDotJson.dependencies['mocha-param']);
+          assert.equal('0.4.4', packageDotJson.dependencies.ping);
+          assert.equal('1.4.10', packageDotJson.dependencies['readline-sync']);
+          assert.equal('7.7.2', packageDotJson.dependencies.semver);
+          assert.equal('3.17.0', packageDotJson.dependencies.winston);
           done();
         } catch (error) {
           log.error(`Test Failure: ${error}`);
@@ -336,12 +303,12 @@ describe('[unit] F5BigIQ Adapter Test', () => {
           assert.notEqual(undefined, packageDotJson.devDependencies);
           assert.notEqual(null, packageDotJson.devDependencies);
           assert.notEqual('', packageDotJson.devDependencies);
-          assert.equal('^4.3.7', packageDotJson.devDependencies.chai);
-          assert.equal('^8.44.0', packageDotJson.devDependencies.eslint);
-          assert.equal('^15.0.0', packageDotJson.devDependencies['eslint-config-airbnb-base']);
-          assert.equal('^2.27.5', packageDotJson.devDependencies['eslint-plugin-import']);
-          assert.equal('^3.1.0', packageDotJson.devDependencies['eslint-plugin-json']);
-          assert.equal('^3.18.0', packageDotJson.devDependencies.testdouble);
+          assert.equal('4.5.0', packageDotJson.devDependencies.chai);
+          assert.equal('8.57.0', packageDotJson.devDependencies.eslint);
+          assert.equal('15.0.0', packageDotJson.devDependencies['eslint-config-airbnb-base']);
+          assert.equal('2.31.0', packageDotJson.devDependencies['eslint-plugin-import']);
+          assert.equal('3.1.0', packageDotJson.devDependencies['eslint-plugin-json']);
+          assert.equal('3.18.0', packageDotJson.devDependencies.testdouble);
           done();
         } catch (error) {
           log.error(`Test Failure: ${error}`);
@@ -13904,5 +13871,4799 @@ describe('[unit] F5BigIQ Adapter Test', () => {
         }
       }).timeout(attemptTimeout);
     });
+
+    describe('#getNetVlans - errors', () => {
+      it('should have a getNetVlans function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNetVlans === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getNetVlans(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getNetVlans', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createNetVlan - errors', () => {
+      it('should have a createNetVlan function', (done) => {
+        try {
+          assert.equal(true, typeof a.createNetVlan === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.createNetVlan(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createNetVlan', 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.createNetVlan('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createNetVlan', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNetVlanById - errors', () => {
+      it('should have a getNetVlanById function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNetVlanById === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getNetVlanById(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getNetVlanById', 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 resourceId', (done) => {
+        try {
+          a.getNetVlanById('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'resourceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getNetVlanById', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateNetVlan - errors', () => {
+      it('should have a updateNetVlan function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateNetVlan === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.updateNetVlan(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateNetVlan', 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 resourceId', (done) => {
+        try {
+          a.updateNetVlan('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'resourceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateNetVlan', 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.updateNetVlan('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateNetVlan', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteNetVlan - errors', () => {
+      it('should have a deleteNetVlan function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteNetVlan === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.deleteNetVlan(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteNetVlan', 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 resourceId', (done) => {
+        try {
+          a.deleteNetVlan('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'resourceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteNetVlan', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchNetVlan - errors', () => {
+      it('should have a patchNetVlan function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchNetVlan === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.patchNetVlan(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchNetVlan', 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 resourceId', (done) => {
+        try {
+          a.patchNetVlan('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'resourceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchNetVlan', 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.patchNetVlan('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchNetVlan', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAllNetSelfIPs - errors', () => {
+      it('should have a getAllNetSelfIPs function', (done) => {
+        try {
+          assert.equal(true, typeof a.getAllNetSelfIPs === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getAllNetSelfIPs(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getAllNetSelfIPs', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createNetSelfIP - errors', () => {
+      it('should have a createNetSelfIP function', (done) => {
+        try {
+          assert.equal(true, typeof a.createNetSelfIP === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.createNetSelfIP(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createNetSelfIP', 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.createNetSelfIP('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createNetSelfIP', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNetSelfIPByName - errors', () => {
+      it('should have a getNetSelfIPByName function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNetSelfIPByName === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getNetSelfIPByName(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getNetSelfIPByName', 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 name', (done) => {
+        try {
+          a.getNetSelfIPByName('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getNetSelfIPByName', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateNetSelfIP - errors', () => {
+      it('should have a updateNetSelfIP function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateNetSelfIP === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.updateNetSelfIP(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateNetSelfIP', 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 name', (done) => {
+        try {
+          a.updateNetSelfIP('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateNetSelfIP', 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.updateNetSelfIP('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateNetSelfIP', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteNetSelfIP - errors', () => {
+      it('should have a deleteNetSelfIP function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteNetSelfIP === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.deleteNetSelfIP(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteNetSelfIP', 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 name', (done) => {
+        try {
+          a.deleteNetSelfIP('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteNetSelfIP', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchNetSelfIP - errors', () => {
+      it('should have a patchNetSelfIP function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchNetSelfIP === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.patchNetSelfIP(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchNetSelfIP', 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 name', (done) => {
+        try {
+          a.patchNetSelfIP('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchNetSelfIP', 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.patchNetSelfIP('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchNetSelfIP', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNetRoutes - errors', () => {
+      it('should have a getNetRoutes function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNetRoutes === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getNetRoutes(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getNetRoutes', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createNetRoute - errors', () => {
+      it('should have a createNetRoute function', (done) => {
+        try {
+          assert.equal(true, typeof a.createNetRoute === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.createNetRoute(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createNetRoute', 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.createNetRoute('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createNetRoute', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNetRouteByName - errors', () => {
+      it('should have a getNetRouteByName function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNetRouteByName === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getNetRouteByName(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getNetRouteByName', 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 name', (done) => {
+        try {
+          a.getNetRouteByName('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getNetRouteByName', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateNetRoute - errors', () => {
+      it('should have a updateNetRoute function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateNetRoute === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.updateNetRoute(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateNetRoute', 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 name', (done) => {
+        try {
+          a.updateNetRoute('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateNetRoute', 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.updateNetRoute('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateNetRoute', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteNetRoute - errors', () => {
+      it('should have a deleteNetRoute function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteNetRoute === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.deleteNetRoute(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteNetRoute', 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 name', (done) => {
+        try {
+          a.deleteNetRoute('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteNetRoute', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchNetRoute - errors', () => {
+      it('should have a patchNetRoute function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchNetRoute === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.patchNetRoute(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchNetRoute', 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 name', (done) => {
+        try {
+          a.patchNetRoute('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchNetRoute', 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.patchNetRoute('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchNetRoute', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNetInterfaces - errors', () => {
+      it('should have a getNetInterfaces function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNetInterfaces === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getNetInterfaces(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getNetInterfaces', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNetInterfaceByName - errors', () => {
+      it('should have a getNetInterfaceByName function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNetInterfaceByName === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getNetInterfaceByName(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getNetInterfaceByName', 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 name', (done) => {
+        try {
+          a.getNetInterfaceByName('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getNetInterfaceByName', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateNetInterface - errors', () => {
+      it('should have a updateNetInterface function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateNetInterface === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.updateNetInterface(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateNetInterface', 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 name', (done) => {
+        try {
+          a.updateNetInterface('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateNetInterface', 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.updateNetInterface('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateNetInterface', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getlTMNodes - errors', () => {
+      it('should have a getlTMNodes function', (done) => {
+        try {
+          assert.equal(true, typeof a.getlTMNodes === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getlTMNodes(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getlTMNodes', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createLtmNode - errors', () => {
+      it('should have a createLtmNode function', (done) => {
+        try {
+          assert.equal(true, typeof a.createLtmNode === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.createLtmNode(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createLtmNode', 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.createLtmNode('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createLtmNode', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getLtmNodeById - errors', () => {
+      it('should have a getLtmNodeById function', (done) => {
+        try {
+          assert.equal(true, typeof a.getLtmNodeById === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getLtmNodeById(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getLtmNodeById', 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 resourceId', (done) => {
+        try {
+          a.getLtmNodeById('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'resourceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getLtmNodeById', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateLtmNode - errors', () => {
+      it('should have a updateLtmNode function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateLtmNode === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.updateLtmNode(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateLtmNode', 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 resourceId', (done) => {
+        try {
+          a.updateLtmNode('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'resourceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateLtmNode', 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.updateLtmNode('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateLtmNode', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteLtmNode - errors', () => {
+      it('should have a deleteLtmNode function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteLtmNode === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.deleteLtmNode(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteLtmNode', 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 resourceId', (done) => {
+        try {
+          a.deleteLtmNode('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'resourceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteLtmNode', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchLtmNode - errors', () => {
+      it('should have a patchLtmNode function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchLtmNode === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.patchLtmNode(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchLtmNode', 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 resourceId', (done) => {
+        try {
+          a.patchLtmNode('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'resourceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchLtmNode', 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.patchLtmNode('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchLtmNode', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getLtmVirtualServers - errors', () => {
+      it('should have a getLtmVirtualServers function', (done) => {
+        try {
+          assert.equal(true, typeof a.getLtmVirtualServers === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getLtmVirtualServers(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getLtmVirtualServers', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createLtmVirtualServer - errors', () => {
+      it('should have a createLtmVirtualServer function', (done) => {
+        try {
+          assert.equal(true, typeof a.createLtmVirtualServer === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.createLtmVirtualServer(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createLtmVirtualServer', 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.createLtmVirtualServer('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createLtmVirtualServer', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getLtmVirtualServerById - errors', () => {
+      it('should have a getLtmVirtualServerById function', (done) => {
+        try {
+          assert.equal(true, typeof a.getLtmVirtualServerById === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getLtmVirtualServerById(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getLtmVirtualServerById', 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 resourceId', (done) => {
+        try {
+          a.getLtmVirtualServerById('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'resourceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getLtmVirtualServerById', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateLtmVirtualServer - errors', () => {
+      it('should have a updateLtmVirtualServer function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateLtmVirtualServer === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.updateLtmVirtualServer(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateLtmVirtualServer', 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 resourceId', (done) => {
+        try {
+          a.updateLtmVirtualServer('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'resourceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateLtmVirtualServer', 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.updateLtmVirtualServer('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateLtmVirtualServer', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchLtmVirtualServer - errors', () => {
+      it('should have a patchLtmVirtualServer function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchLtmVirtualServer === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.patchLtmVirtualServer(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchLtmVirtualServer', 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 resourceId', (done) => {
+        try {
+          a.patchLtmVirtualServer('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'resourceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchLtmVirtualServer', 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.patchLtmVirtualServer('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchLtmVirtualServer', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteLtmVirtualServerById - errors', () => {
+      it('should have a deleteLtmVirtualServerById function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteLtmVirtualServerById === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.deleteLtmVirtualServerById(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteLtmVirtualServerById', 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 resourceId', (done) => {
+        try {
+          a.deleteLtmVirtualServerById('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'resourceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteLtmVirtualServerById', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getLtmVirtualAddresses - errors', () => {
+      it('should have a getLtmVirtualAddresses function', (done) => {
+        try {
+          assert.equal(true, typeof a.getLtmVirtualAddresses === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getLtmVirtualAddresses(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getLtmVirtualAddresses', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createLtmVirtualAddress - errors', () => {
+      it('should have a createLtmVirtualAddress function', (done) => {
+        try {
+          assert.equal(true, typeof a.createLtmVirtualAddress === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.createLtmVirtualAddress(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createLtmVirtualAddress', 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.createLtmVirtualAddress('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createLtmVirtualAddress', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getLtmVirtualAddressById - errors', () => {
+      it('should have a getLtmVirtualAddressById function', (done) => {
+        try {
+          assert.equal(true, typeof a.getLtmVirtualAddressById === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getLtmVirtualAddressById(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getLtmVirtualAddressById', 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 resourceId', (done) => {
+        try {
+          a.getLtmVirtualAddressById('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'resourceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getLtmVirtualAddressById', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateLtmVirtualAddress - errors', () => {
+      it('should have a updateLtmVirtualAddress function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateLtmVirtualAddress === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.updateLtmVirtualAddress(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateLtmVirtualAddress', 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 resourceId', (done) => {
+        try {
+          a.updateLtmVirtualAddress('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'resourceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateLtmVirtualAddress', 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.updateLtmVirtualAddress('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateLtmVirtualAddress', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteLtmVirtualAddress - errors', () => {
+      it('should have a deleteLtmVirtualAddress function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteLtmVirtualAddress === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.deleteLtmVirtualAddress(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteLtmVirtualAddress', 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 resourceId', (done) => {
+        try {
+          a.deleteLtmVirtualAddress('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'resourceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteLtmVirtualAddress', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchLtmVirtualAddress - errors', () => {
+      it('should have a patchLtmVirtualAddress function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchLtmVirtualAddress === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.patchLtmVirtualAddress(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchLtmVirtualAddress', 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 resourceId', (done) => {
+        try {
+          a.patchLtmVirtualAddress('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'resourceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchLtmVirtualAddress', 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.patchLtmVirtualAddress('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchLtmVirtualAddress', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getLtmPools - errors', () => {
+      it('should have a getLtmPools function', (done) => {
+        try {
+          assert.equal(true, typeof a.getLtmPools === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getLtmPools(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getLtmPools', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createLtmPool - errors', () => {
+      it('should have a createLtmPool function', (done) => {
+        try {
+          assert.equal(true, typeof a.createLtmPool === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.createLtmPool(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createLtmPool', 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.createLtmPool('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createLtmPool', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateLtmPool - errors', () => {
+      it('should have a updateLtmPool function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateLtmPool === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.updateLtmPool(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateLtmPool', 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 resourceId', (done) => {
+        try {
+          a.updateLtmPool('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'resourceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateLtmPool', 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.updateLtmPool('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateLtmPool', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getLtmPoolById - errors', () => {
+      it('should have a getLtmPoolById function', (done) => {
+        try {
+          assert.equal(true, typeof a.getLtmPoolById === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getLtmPoolById(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getLtmPoolById', 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 resourceId', (done) => {
+        try {
+          a.getLtmPoolById('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'resourceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getLtmPoolById', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteLtmPool - errors', () => {
+      it('should have a deleteLtmPool function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteLtmPool === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.deleteLtmPool(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteLtmPool', 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 resourceId', (done) => {
+        try {
+          a.deleteLtmPool('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'resourceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteLtmPool', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchLtmPool - errors', () => {
+      it('should have a patchLtmPool function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchLtmPool === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.patchLtmPool(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchLtmPool', 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 resourceId', (done) => {
+        try {
+          a.patchLtmPool('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'resourceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchLtmPool', 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.patchLtmPool('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchLtmPool', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getLtmIRules - errors', () => {
+      it('should have a getLtmIRules function', (done) => {
+        try {
+          assert.equal(true, typeof a.getLtmIRules === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getLtmIRules(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getLtmIRules', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createLtmIRule - errors', () => {
+      it('should have a createLtmIRule function', (done) => {
+        try {
+          assert.equal(true, typeof a.createLtmIRule === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.createLtmIRule(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createLtmIRule', 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.createLtmIRule('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createLtmIRule', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getLtmIRuleByid - errors', () => {
+      it('should have a getLtmIRuleByid function', (done) => {
+        try {
+          assert.equal(true, typeof a.getLtmIRuleByid === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getLtmIRuleByid(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getLtmIRuleByid', 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 resourceId', (done) => {
+        try {
+          a.getLtmIRuleByid('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'resourceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getLtmIRuleByid', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateLtmIRule - errors', () => {
+      it('should have a updateLtmIRule function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateLtmIRule === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.updateLtmIRule(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateLtmIRule', 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 resourceId', (done) => {
+        try {
+          a.updateLtmIRule('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'resourceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateLtmIRule', 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.updateLtmIRule('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateLtmIRule', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteLtmIRule - errors', () => {
+      it('should have a deleteLtmIRule function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteLtmIRule === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.deleteLtmIRule(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteLtmIRule', 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 resourceId', (done) => {
+        try {
+          a.deleteLtmIRule('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'resourceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteLtmIRule', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchLtmIRule - errors', () => {
+      it('should have a patchLtmIRule function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchLtmIRule === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.patchLtmIRule(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchLtmIRule', 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 resourceId', (done) => {
+        try {
+          a.patchLtmIRule('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'resourceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchLtmIRule', 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.patchLtmIRule('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchLtmIRule', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getLtmPolicies - errors', () => {
+      it('should have a getLtmPolicies function', (done) => {
+        try {
+          assert.equal(true, typeof a.getLtmPolicies === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getLtmPolicies(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getLtmPolicies', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createLtmPolicy - errors', () => {
+      it('should have a createLtmPolicy function', (done) => {
+        try {
+          assert.equal(true, typeof a.createLtmPolicy === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.createLtmPolicy(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createLtmPolicy', 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.createLtmPolicy('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createLtmPolicy', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getLtmPolicyById - errors', () => {
+      it('should have a getLtmPolicyById function', (done) => {
+        try {
+          assert.equal(true, typeof a.getLtmPolicyById === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getLtmPolicyById(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getLtmPolicyById', 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 resourceId', (done) => {
+        try {
+          a.getLtmPolicyById('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'resourceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getLtmPolicyById', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateLtmPolicy - errors', () => {
+      it('should have a updateLtmPolicy function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateLtmPolicy === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.updateLtmPolicy(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateLtmPolicy', 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 resourceId', (done) => {
+        try {
+          a.updateLtmPolicy('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'resourceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateLtmPolicy', 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.updateLtmPolicy('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateLtmPolicy', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteLtmPolicy - errors', () => {
+      it('should have a deleteLtmPolicy function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteLtmPolicy === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.deleteLtmPolicy(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteLtmPolicy', 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 resourceId', (done) => {
+        try {
+          a.deleteLtmPolicy('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'resourceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteLtmPolicy', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchLtmPolicy - errors', () => {
+      it('should have a patchLtmPolicy function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchLtmPolicy === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.patchLtmPolicy(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchLtmPolicy', 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 resourceId', (done) => {
+        try {
+          a.patchLtmPolicy('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'resourceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchLtmPolicy', 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.patchLtmPolicy('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchLtmPolicy', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getLtmSnats - errors', () => {
+      it('should have a getLtmSnats function', (done) => {
+        try {
+          assert.equal(true, typeof a.getLtmSnats === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getLtmSnats(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getLtmSnats', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createLtmSnat - errors', () => {
+      it('should have a createLtmSnat function', (done) => {
+        try {
+          assert.equal(true, typeof a.createLtmSnat === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.createLtmSnat(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createLtmSnat', 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.createLtmSnat('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createLtmSnat', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getLtmSnatByName - errors', () => {
+      it('should have a getLtmSnatByName function', (done) => {
+        try {
+          assert.equal(true, typeof a.getLtmSnatByName === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getLtmSnatByName(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getLtmSnatByName', 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 name', (done) => {
+        try {
+          a.getLtmSnatByName('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getLtmSnatByName', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateLtmSnat - errors', () => {
+      it('should have a updateLtmSnat function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateLtmSnat === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.updateLtmSnat(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateLtmSnat', 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 name', (done) => {
+        try {
+          a.updateLtmSnat('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateLtmSnat', 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.updateLtmSnat('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateLtmSnat', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteLtmSnat - errors', () => {
+      it('should have a deleteLtmSnat function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteLtmSnat === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.deleteLtmSnat(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteLtmSnat', 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 name', (done) => {
+        try {
+          a.deleteLtmSnat('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteLtmSnat', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getLtmSnatPools - errors', () => {
+      it('should have a getLtmSnatPools function', (done) => {
+        try {
+          assert.equal(true, typeof a.getLtmSnatPools === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getLtmSnatPools(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getLtmSnatPools', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createLtmSnatPool - errors', () => {
+      it('should have a createLtmSnatPool function', (done) => {
+        try {
+          assert.equal(true, typeof a.createLtmSnatPool === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.createLtmSnatPool(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createLtmSnatPool', 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.createLtmSnatPool('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createLtmSnatPool', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getLtmSnatPoolByName - errors', () => {
+      it('should have a getLtmSnatPoolByName function', (done) => {
+        try {
+          assert.equal(true, typeof a.getLtmSnatPoolByName === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getLtmSnatPoolByName(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getLtmSnatPoolByName', 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 name', (done) => {
+        try {
+          a.getLtmSnatPoolByName('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getLtmSnatPoolByName', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateLtmSnatPool - errors', () => {
+      it('should have a updateLtmSnatPool function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateLtmSnatPool === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.updateLtmSnatPool(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateLtmSnatPool', 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 name', (done) => {
+        try {
+          a.updateLtmSnatPool('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateLtmSnatPool', 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.updateLtmSnatPool('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateLtmSnatPool', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteLtmSnatPool - errors', () => {
+      it('should have a deleteLtmSnatPool function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteLtmSnatPool === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.deleteLtmSnatPool(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteLtmSnatPool', 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 name', (done) => {
+        try {
+          a.deleteLtmSnatPool('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteLtmSnatPool', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getLtmNats - errors', () => {
+      it('should have a getLtmNats function', (done) => {
+        try {
+          assert.equal(true, typeof a.getLtmNats === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getLtmNats(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getLtmNats', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createLtmNat - errors', () => {
+      it('should have a createLtmNat function', (done) => {
+        try {
+          assert.equal(true, typeof a.createLtmNat === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.createLtmNat(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createLtmNat', 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.createLtmNat('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createLtmNat', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getLtmNatByName - errors', () => {
+      it('should have a getLtmNatByName function', (done) => {
+        try {
+          assert.equal(true, typeof a.getLtmNatByName === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getLtmNatByName(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getLtmNatByName', 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 name', (done) => {
+        try {
+          a.getLtmNatByName('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getLtmNatByName', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateLtmNat - errors', () => {
+      it('should have a updateLtmNat function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateLtmNat === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.updateLtmNat(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateLtmNat', 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 name', (done) => {
+        try {
+          a.updateLtmNat('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateLtmNat', 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.updateLtmNat('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateLtmNat', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteLtmNat - errors', () => {
+      it('should have a deleteLtmNat function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteLtmNat === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.deleteLtmNat(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteLtmNat', 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 name', (done) => {
+        try {
+          a.deleteLtmNat('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteLtmNat', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSysGlobalSettings - errors', () => {
+      it('should have a getSysGlobalSettings function', (done) => {
+        try {
+          assert.equal(true, typeof a.getSysGlobalSettings === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getSysGlobalSettings(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getSysGlobalSettings', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateSysGlobalSettings - errors', () => {
+      it('should have a updateSysGlobalSettings function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateSysGlobalSettings === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.updateSysGlobalSettings(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateSysGlobalSettings', 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.updateSysGlobalSettings('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateSysGlobalSettings', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchSysGlobalSettings - errors', () => {
+      it('should have a patchSysGlobalSettings function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchSysGlobalSettings === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.patchSysGlobalSettings(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchSysGlobalSettings', 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.patchSysGlobalSettings('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchSysGlobalSettings', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSysNTPSettings - errors', () => {
+      it('should have a getSysNTPSettings function', (done) => {
+        try {
+          assert.equal(true, typeof a.getSysNTPSettings === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getSysNTPSettings(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getSysNTPSettings', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#setSysNTPSettings - errors', () => {
+      it('should have a setSysNTPSettings function', (done) => {
+        try {
+          assert.equal(true, typeof a.setSysNTPSettings === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.setSysNTPSettings(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-setSysNTPSettings', 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.setSysNTPSettings('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-setSysNTPSettings', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSysSoftwareImages - errors', () => {
+      it('should have a getSysSoftwareImages function', (done) => {
+        try {
+          assert.equal(true, typeof a.getSysSoftwareImages === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getSysSoftwareImages(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getSysSoftwareImages', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteSysSoftwareVolume - errors', () => {
+      it('should have a deleteSysSoftwareVolume function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteSysSoftwareVolume === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.deleteSysSoftwareVolume(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteSysSoftwareVolume', 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 name', (done) => {
+        try {
+          a.deleteSysSoftwareVolume('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteSysSoftwareVolume', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSysSoftwareVolumeByName - errors', () => {
+      it('should have a getSysSoftwareVolumeByName function', (done) => {
+        try {
+          assert.equal(true, typeof a.getSysSoftwareVolumeByName === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getSysSoftwareVolumeByName(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getSysSoftwareVolumeByName', 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 name', (done) => {
+        try {
+          a.getSysSoftwareVolumeByName('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getSysSoftwareVolumeByName', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSysDnsSettings - errors', () => {
+      it('should have a getSysDnsSettings function', (done) => {
+        try {
+          assert.equal(true, typeof a.getSysDnsSettings === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getSysDnsSettings(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getSysDnsSettings', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#setSysDnsSettings - errors', () => {
+      it('should have a setSysDnsSettings function', (done) => {
+        try {
+          assert.equal(true, typeof a.setSysDnsSettings === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.setSysDnsSettings(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-setSysDnsSettings', 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.setSysDnsSettings('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-setSysDnsSettings', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getCmTrafficGroups - errors', () => {
+      it('should have a getCmTrafficGroups function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCmTrafficGroups === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getCmTrafficGroups(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getCmTrafficGroups', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createCmTrafficGroup - errors', () => {
+      it('should have a createCmTrafficGroup function', (done) => {
+        try {
+          assert.equal(true, typeof a.createCmTrafficGroup === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.createCmTrafficGroup(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createCmTrafficGroup', 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.createCmTrafficGroup('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createCmTrafficGroup', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getCmTrafficGroupByName - errors', () => {
+      it('should have a getCmTrafficGroupByName function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCmTrafficGroupByName === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getCmTrafficGroupByName(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getCmTrafficGroupByName', 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 name', (done) => {
+        try {
+          a.getCmTrafficGroupByName('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getCmTrafficGroupByName', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateCmTrafficGroup - errors', () => {
+      it('should have a updateCmTrafficGroup function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateCmTrafficGroup === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.updateCmTrafficGroup(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateCmTrafficGroup', 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 name', (done) => {
+        try {
+          a.updateCmTrafficGroup('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateCmTrafficGroup', 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.updateCmTrafficGroup('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateCmTrafficGroup', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteCmTrafficGroup - errors', () => {
+      it('should have a deleteCmTrafficGroup function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteCmTrafficGroup === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.deleteCmTrafficGroup(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteCmTrafficGroup', 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 name', (done) => {
+        try {
+          a.deleteCmTrafficGroup('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteCmTrafficGroup', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchCmTrafficGroup - errors', () => {
+      it('should have a patchCmTrafficGroup function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchCmTrafficGroup === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.patchCmTrafficGroup(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchCmTrafficGroup', 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 name', (done) => {
+        try {
+          a.patchCmTrafficGroup('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchCmTrafficGroup', 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.patchCmTrafficGroup('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-patchCmTrafficGroup', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getCmDevices - errors', () => {
+      it('should have a getCmDevices function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCmDevices === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getCmDevices(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getCmDevices', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getCmDeviceByName - errors', () => {
+      it('should have a getCmDeviceByName function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCmDeviceByName === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getCmDeviceByName(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getCmDeviceByName', 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 name', (done) => {
+        try {
+          a.getCmDeviceByName('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getCmDeviceByName', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateCmDevice - errors', () => {
+      it('should have a updateCmDevice function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateCmDevice === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.updateCmDevice(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateCmDevice', 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 name', (done) => {
+        try {
+          a.updateCmDevice('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateCmDevice', 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.updateCmDevice('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateCmDevice', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteCmDevice - errors', () => {
+      it('should have a deleteCmDevice function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteCmDevice === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.deleteCmDevice(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteCmDevice', 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 name', (done) => {
+        try {
+          a.deleteCmDevice('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteCmDevice', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getCmDeviceGroups - errors', () => {
+      it('should have a getCmDeviceGroups function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCmDeviceGroups === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getCmDeviceGroups(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getCmDeviceGroups', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createCmDeviceGroup - errors', () => {
+      it('should have a createCmDeviceGroup function', (done) => {
+        try {
+          assert.equal(true, typeof a.createCmDeviceGroup === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.createCmDeviceGroup(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createCmDeviceGroup', 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.createCmDeviceGroup('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createCmDeviceGroup', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getCmDeviceGroupByName - errors', () => {
+      it('should have a getCmDeviceGroupByName function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCmDeviceGroupByName === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getCmDeviceGroupByName(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getCmDeviceGroupByName', 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 name', (done) => {
+        try {
+          a.getCmDeviceGroupByName('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getCmDeviceGroupByName', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateCmDeviceGroup - errors', () => {
+      it('should have a updateCmDeviceGroup function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateCmDeviceGroup === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.updateCmDeviceGroup(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateCmDeviceGroup', 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 name', (done) => {
+        try {
+          a.updateCmDeviceGroup('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateCmDeviceGroup', 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.updateCmDeviceGroup('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateCmDeviceGroup', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteCmDeviceGroup - errors', () => {
+      it('should have a deleteCmDeviceGroup function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteCmDeviceGroup === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.deleteCmDeviceGroup(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteCmDeviceGroup', 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 name', (done) => {
+        try {
+          a.deleteCmDeviceGroup('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteCmDeviceGroup', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAuthUsers - errors', () => {
+      it('should have a getAuthUsers function', (done) => {
+        try {
+          assert.equal(true, typeof a.getAuthUsers === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getAuthUsers(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getAuthUsers', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createAuthUser - errors', () => {
+      it('should have a createAuthUser function', (done) => {
+        try {
+          assert.equal(true, typeof a.createAuthUser === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.createAuthUser(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createAuthUser', 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.createAuthUser('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-createAuthUser', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAuthUserByName - errors', () => {
+      it('should have a getAuthUserByName function', (done) => {
+        try {
+          assert.equal(true, typeof a.getAuthUserByName === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getAuthUserByName(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getAuthUserByName', 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 name', (done) => {
+        try {
+          a.getAuthUserByName('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-getAuthUserByName', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateAuthUser - errors', () => {
+      it('should have a updateAuthUser function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateAuthUser === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.updateAuthUser(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateAuthUser', 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 name', (done) => {
+        try {
+          a.updateAuthUser('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateAuthUser', 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.updateAuthUser('fakeparam', 'fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-updateAuthUser', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteAuthUser - errors', () => {
+      it('should have a deleteAuthUser function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteAuthUser === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.deleteAuthUser(null, null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteAuthUser', 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 name', (done) => {
+        try {
+          a.deleteAuthUser('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'name is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-f5_bigiq-adapter-deleteAuthUser', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
   });
 });