@itentialopensource/adapter-infoblox 1.9.2 → 1.10.1

package/test/unit/adapterTestUnit.js

@@ -4,6 +4,7 @@
 /* global describe it log pronghornProps */
 /* eslint global-require: warn */
 /* eslint no-unused-vars: warn */
+/* eslint import/no-dynamic-require:warn */
 
 // include required items for testing & logging
 const assert = require('assert');
@@ -18,22 +19,31 @@ const { use } = require('chai');
 const td = require('testdouble');
 
 const anything = td.matchers.anything();
-
-// stub and attemptTimeout are used throughout the code so set them here
 let logLevel = 'none';
-const stub = true;
 const isRapidFail = false;
-const attemptTimeout = 120000;
+
+// read in the properties from the sampleProperties files
+let adaptdir = __dirname;
+if (adaptdir.endsWith('/test/integration')) {
+  adaptdir = adaptdir.substring(0, adaptdir.length - 17);
+} else if (adaptdir.endsWith('/test/unit')) {
+  adaptdir = adaptdir.substring(0, adaptdir.length - 10);
+}
+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!!!
-const host = 'replace.hostorip.here';
-const username = 'username';
-const password = 'password';
-const protocol = 'http';
-const port = 80;
-const sslenable = false;
-const sslinvalid = false;
+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;
+samProps.request.attempt_timeout = 60000;
+const attemptTimeout = samProps.request.attempt_timeout;
+const { stub } = samProps;
 
 // these are the adapter properties. You generally should not need to alter
 // any of these after they are initially set up
@@ -43,96 +53,9 @@ global.pronghornProps = {
   },
   adapterProps: {
     adapters: [{
-      id: 'infoblox',
+      id: 'Test-infoblox',
       type: 'Infoblox',
-      properties: {
-        host,
-        port,
-        base_path: '/wapi',
-        version: 'v1',
-        cache_location: 'none',
-        encode_pathvars: true,
-        save_metric: false,
-        stub,
-        protocol,
-        authentication: {
-          auth_method: 'basic user_password',
-          username,
-          password,
-          token: '',
-          invalid_token_error: 401,
-          token_timeout: -1,
-          token_cache: 'local',
-          auth_field: 'header.headers.Authorization',
-          auth_field_format: 'Basic {b64}{username}:{password}{/b64}'
-        },
-        healthcheck: {
-          type: 'startup',
-          frequency: 60000
-        },
-        throttle: {
-          throttle_enabled: false,
-          number_pronghorns: 1,
-          sync_async: 'sync',
-          max_in_queue: 1000,
-          concurrent_max: 1,
-          expire_timeout: 0,
-          avg_runtime: 200,
-          priorities: [
-            {
-              value: 0,
-              percent: 100
-            }
-          ]
-        },
-        request: {
-          number_redirects: 0,
-          number_retries: 3,
-          limit_retry_error: 0,
-          failover_codes: [],
-          attempt_timeout: attemptTimeout,
-          global_request: {
-            payload: {},
-            uriOptions: {},
-            addlHeaders: {},
-            authData: {}
-          },
-          healthcheck_on_timeout: false,
-          return_raw: true,
-          archiving: false
-        },
-        proxy: {
-          enabled: false,
-          host: '',
-          port: 1,
-          protocol: 'http'
-        },
-        ssl: {
-          ecdhCurve: '',
-          enabled: sslenable,
-          accept_invalid_cert: sslinvalid,
-          ca_file: '',
-          key_file: '',
-          cert_file: '',
-          secure_protocol: '',
-          ciphers: ''
-        },
-        mongo: {
-          host: '',
-          port: 0,
-          database: '',
-          username: '',
-          password: '',
-          replSet: '',
-          db_ssl: {
-            enabled: false,
-            accept_invalid_cert: false,
-            ca_file: '',
-            key_file: '',
-            cert_file: ''
-          }
-        }
-      }
+      properties: samProps
     }]
   }
 };
@@ -193,7 +116,7 @@ function runErrorAsserts(data, error, code, origin, displayStr) {
 }
 
 // require the adapter that we are going to be using
-const Infoblox = require('../../adapter.js');
+const Infoblox = require('../../adapter');
 
 // delete the .DS_Store directory in entities -- otherwise this will cause errors
 const dirPath = path.join(__dirname, '../../entities/.DS_Store');
@@ -235,6 +158,8 @@ describe('[unit] Infoblox Adapter Test', () => {
         try {
           assert.notEqual(null, a);
           assert.notEqual(undefined, a);
+          const checkId = global.pronghornProps.adapterProps.adapters[0].id;
+          assert.equal(checkId, a.id);
           assert.notEqual(null, a.allProps);
           const check = global.pronghornProps.adapterProps.adapters[0].properties.healthcheck.type;
           assert.equal(check, a.healthcheckType);
@@ -261,10 +186,10 @@ describe('[unit] Infoblox Adapter Test', () => {
     });
 
     let wffunctions = [];
-    describe('#getWorkflowFunctions', () => {
+    describe('#iapGetAdapterWorkflowFunctions', () => {
       it('should retrieve workflow functions', (done) => {
         try {
-          wffunctions = a.getWorkflowFunctions();
+          wffunctions = a.iapGetAdapterWorkflowFunctions([]);
 
           try {
             assert.notEqual(0, wffunctions.length);
@@ -316,13 +241,103 @@ describe('[unit] Infoblox Adapter Test', () => {
           done(error);
         }
       });
-      it('package.json should be customized', (done) => {
+      it('package.json standard fields should be customized', (done) => {
         try {
           const packageDotJson = require('../../package.json');
           assert.notEqual(-1, packageDotJson.name.indexOf('infoblox'));
           assert.notEqual(undefined, packageDotJson.version);
           assert.notEqual(null, packageDotJson.version);
           assert.notEqual('', packageDotJson.version);
+          assert.notEqual(undefined, packageDotJson.description);
+          assert.notEqual(null, packageDotJson.description);
+          assert.notEqual('', packageDotJson.description);
+          assert.equal('adapter.js', packageDotJson.main);
+          assert.notEqual(undefined, packageDotJson.wizardVersion);
+          assert.notEqual(null, packageDotJson.wizardVersion);
+          assert.notEqual('', packageDotJson.wizardVersion);
+          assert.notEqual(undefined, packageDotJson.engineVersion);
+          assert.notEqual(null, packageDotJson.engineVersion);
+          assert.notEqual('', packageDotJson.engineVersion);
+          assert.equal('http', packageDotJson.adapterType);
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+      it('package.json proper scripts should be provided', (done) => {
+        try {
+          const packageDotJson = require('../../package.json');
+          assert.notEqual(undefined, packageDotJson.scripts);
+          assert.notEqual(null, packageDotJson.scripts);
+          assert.notEqual('', packageDotJson.scripts);
+          assert.equal('node utils/setup.js && npm install --package-lock-only --ignore-scripts && npx npm-force-resolutions', packageDotJson.scripts.preinstall);
+          assert.equal('node --max_old_space_size=4096 ./node_modules/eslint/bin/eslint.js . --ext .json --ext .js', packageDotJson.scripts.lint);
+          assert.equal('node --max_old_space_size=4096 ./node_modules/eslint/bin/eslint.js . --ext .json --ext .js --quiet', packageDotJson.scripts['lint:errors']);
+          assert.equal('mocha test/unit/adapterBaseTestUnit.js --LOG=error', packageDotJson.scripts['test:baseunit']);
+          assert.equal('mocha test/unit/adapterTestUnit.js --LOG=error', packageDotJson.scripts['test:unit']);
+          assert.equal('mocha test/integration/adapterTestIntegration.js --LOG=error', packageDotJson.scripts['test:integration']);
+          assert.equal('nyc --reporter html --reporter text mocha --reporter dot test/*', packageDotJson.scripts['test:cover']);
+          assert.equal('npm run test:baseunit && npm run test:unit && npm run test:integration', packageDotJson.scripts.test);
+          assert.equal('npm publish --registry=https://registry.npmjs.org --access=public', packageDotJson.scripts.deploy);
+          assert.equal('npm run deploy', packageDotJson.scripts.build);
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+      it('package.json proper directories should be provided', (done) => {
+        try {
+          const packageDotJson = require('../../package.json');
+          assert.notEqual(undefined, packageDotJson.repository);
+          assert.notEqual(null, packageDotJson.repository);
+          assert.notEqual('', packageDotJson.repository);
+          assert.equal('git', packageDotJson.repository.type);
+          assert.equal('git@gitlab.com:itentialopensource/adapters/', packageDotJson.repository.url.substring(0, 43));
+          assert.equal('https://gitlab.com/itentialopensource/adapters/', packageDotJson.homepage.substring(0, 47));
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+      it('package.json proper dependencies should be provided', (done) => {
+        try {
+          const packageDotJson = require('../../package.json');
+          assert.notEqual(undefined, packageDotJson.dependencies);
+          assert.notEqual(null, packageDotJson.dependencies);
+          assert.notEqual('', packageDotJson.dependencies);
+          assert.equal('^6.12.0', packageDotJson.dependencies.ajv);
+          assert.equal('^0.21.0', packageDotJson.dependencies.axios);
+          assert.equal('^2.20.0', packageDotJson.dependencies.commander);
+          assert.equal('^8.1.0', packageDotJson.dependencies['fs-extra']);
+          assert.equal('^9.0.1', packageDotJson.dependencies.mocha);
+          assert.equal('^2.0.1', packageDotJson.dependencies['mocha-param']);
+          assert.equal('^0.5.3', packageDotJson.dependencies['network-diagnostics']);
+          assert.equal('^15.1.0', packageDotJson.dependencies.nyc);
+          assert.equal('^1.4.10', packageDotJson.dependencies['readline-sync']);
+          assert.equal('^7.3.2', packageDotJson.dependencies.semver);
+          assert.equal('^3.3.3', packageDotJson.dependencies.winston);
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+      it('package.json proper dev dependencies should be provided', (done) => {
+        try {
+          const packageDotJson = require('../../package.json');
+          assert.notEqual(undefined, packageDotJson.devDependencies);
+          assert.notEqual(null, packageDotJson.devDependencies);
+          assert.notEqual('', packageDotJson.devDependencies);
+          assert.equal('^4.3.4', packageDotJson.devDependencies.chai);
+          assert.equal('^7.29.0', packageDotJson.devDependencies.eslint);
+          assert.equal('^14.2.1', packageDotJson.devDependencies['eslint-config-airbnb-base']);
+          assert.equal('^2.23.4', packageDotJson.devDependencies['eslint-plugin-import']);
+          assert.equal('^3.0.0', packageDotJson.devDependencies['eslint-plugin-json']);
+          assert.equal('^0.6.3', packageDotJson.devDependencies['package-json-validator']);
+          assert.equal('^3.16.1', packageDotJson.devDependencies.testdouble);
           done();
         } catch (error) {
           log.error(`Test Failure: ${error}`);
@@ -347,8 +362,35 @@ describe('[unit] Infoblox Adapter Test', () => {
         try {
           const pronghornDotJson = require('../../pronghorn.json');
           assert.notEqual(-1, pronghornDotJson.id.indexOf('infoblox'));
+          assert.equal('Adapter', pronghornDotJson.type);
           assert.equal('Infoblox', pronghornDotJson.export);
           assert.equal('Infoblox', pronghornDotJson.title);
+          assert.equal('adapter.js', pronghornDotJson.src);
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+      it('pronghorn.json should contain generic adapter methods', (done) => {
+        try {
+          const pronghornDotJson = require('../../pronghorn.json');
+          assert.notEqual(undefined, pronghornDotJson.methods);
+          assert.notEqual(null, pronghornDotJson.methods);
+          assert.notEqual('', pronghornDotJson.methods);
+          assert.equal(true, Array.isArray(pronghornDotJson.methods));
+          assert.notEqual(0, pronghornDotJson.methods.length);
+          assert.notEqual(undefined, pronghornDotJson.methods.find((e) => e.name === 'iapUpdateAdapterConfiguration'));
+          assert.notEqual(undefined, pronghornDotJson.methods.find((e) => e.name === 'iapFindAdapterPath'));
+          assert.notEqual(undefined, pronghornDotJson.methods.find((e) => e.name === 'iapTroubleshootAdapter'));
+          assert.notEqual(undefined, pronghornDotJson.methods.find((e) => e.name === 'iapRunAdapterHealthcheck'));
+          assert.notEqual(undefined, pronghornDotJson.methods.find((e) => e.name === 'iapRunAdapterConnectivity'));
+          assert.notEqual(undefined, pronghornDotJson.methods.find((e) => e.name === 'iapRunAdapterBasicGet'));
+          assert.notEqual(undefined, pronghornDotJson.methods.find((e) => e.name === 'iapSuspendAdapter'));
+          assert.notEqual(undefined, pronghornDotJson.methods.find((e) => e.name === 'iapUnsuspendAdapter'));
+          assert.notEqual(undefined, pronghornDotJson.methods.find((e) => e.name === 'iapGetAdapterQueue'));
+          assert.notEqual(undefined, pronghornDotJson.methods.find((e) => e.name === 'genericAdapterRequest'));
+          assert.notEqual(undefined, pronghornDotJson.methods.find((e) => e.name === 'genericAdapterRequestNoBasePath'));
           done();
         } catch (error) {
           log.error(`Test Failure: ${error}`);
@@ -370,7 +412,7 @@ describe('[unit] Infoblox Adapter Test', () => {
                 let wfparams = [];
 
                 if (methLine && methLine.indexOf('(') >= 0 && methLine.indexOf(')') >= 0) {
-                  const temp = methLine.substring(methLine.indexOf('(') + 1, methLine.indexOf(')'));
+                  const temp = methLine.substring(methLine.indexOf('(') + 1, methLine.lastIndexOf(')'));
                   wfparams = temp.split(',');
 
                   for (let t = 0; t < wfparams.length; t += 1) {
@@ -487,6 +529,124 @@ describe('[unit] Infoblox Adapter Test', () => {
         try {
           const propertiesDotJson = require('../../propertiesSchema.json');
           assert.equal('adapter-infoblox', propertiesDotJson.$id);
+          assert.equal('object', propertiesDotJson.type);
+          assert.equal('http://json-schema.org/draft-07/schema#', propertiesDotJson.$schema);
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+      it('propertiesSchema.json should contain generic adapter properties', (done) => {
+        try {
+          const propertiesDotJson = require('../../propertiesSchema.json');
+          assert.notEqual(undefined, propertiesDotJson.properties);
+          assert.notEqual(null, propertiesDotJson.properties);
+          assert.notEqual('', propertiesDotJson.properties);
+          assert.equal('string', propertiesDotJson.properties.host.type);
+          assert.equal('integer', propertiesDotJson.properties.port.type);
+          assert.equal('boolean', propertiesDotJson.properties.stub.type);
+          assert.notEqual(undefined, propertiesDotJson.definitions.authentication);
+          assert.notEqual(null, propertiesDotJson.definitions.authentication);
+          assert.notEqual('', propertiesDotJson.definitions.authentication);
+          assert.equal('string', propertiesDotJson.definitions.authentication.properties.auth_method.type);
+          assert.equal('string', propertiesDotJson.definitions.authentication.properties.username.type);
+          assert.equal('string', propertiesDotJson.definitions.authentication.properties.password.type);
+          assert.equal('string', propertiesDotJson.definitions.authentication.properties.token.type);
+          assert.equal('integer', propertiesDotJson.definitions.authentication.properties.invalid_token_error.type);
+          assert.equal('integer', propertiesDotJson.definitions.authentication.properties.token_timeout.type);
+          assert.equal('string', propertiesDotJson.definitions.authentication.properties.token_cache.type);
+          assert.equal(true, Array.isArray(propertiesDotJson.definitions.authentication.properties.auth_field.type));
+          assert.equal(true, Array.isArray(propertiesDotJson.definitions.authentication.properties.auth_field_format.type));
+          assert.equal('boolean', propertiesDotJson.definitions.authentication.properties.auth_logging.type);
+          assert.equal('string', propertiesDotJson.definitions.authentication.properties.client_id.type);
+          assert.equal('string', propertiesDotJson.definitions.authentication.properties.client_secret.type);
+          assert.equal('string', propertiesDotJson.definitions.authentication.properties.grant_type.type);
+          assert.notEqual(undefined, propertiesDotJson.definitions.ssl);
+          assert.notEqual(null, propertiesDotJson.definitions.ssl);
+          assert.notEqual('', propertiesDotJson.definitions.ssl);
+          assert.equal('string', propertiesDotJson.definitions.ssl.properties.ecdhCurve.type);
+          assert.equal('boolean', propertiesDotJson.definitions.ssl.properties.enabled.type);
+          assert.equal('boolean', propertiesDotJson.definitions.ssl.properties.accept_invalid_cert.type);
+          assert.equal('string', propertiesDotJson.definitions.ssl.properties.ca_file.type);
+          assert.equal('string', propertiesDotJson.definitions.ssl.properties.key_file.type);
+          assert.equal('string', propertiesDotJson.definitions.ssl.properties.cert_file.type);
+          assert.equal('string', propertiesDotJson.definitions.ssl.properties.secure_protocol.type);
+          assert.equal('string', propertiesDotJson.definitions.ssl.properties.ciphers.type);
+          assert.equal('string', propertiesDotJson.properties.base_path.type);
+          assert.equal('string', propertiesDotJson.properties.version.type);
+          assert.equal('string', propertiesDotJson.properties.cache_location.type);
+          assert.equal('boolean', propertiesDotJson.properties.encode_pathvars.type);
+          assert.equal('boolean', propertiesDotJson.properties.encode_queryvars.type);
+          assert.equal(true, Array.isArray(propertiesDotJson.properties.save_metric.type));
+          assert.equal('string', propertiesDotJson.properties.protocol.type);
+          assert.notEqual(undefined, propertiesDotJson.definitions);
+          assert.notEqual(null, propertiesDotJson.definitions);
+          assert.notEqual('', propertiesDotJson.definitions);
+          assert.notEqual(undefined, propertiesDotJson.definitions.healthcheck);
+          assert.notEqual(null, propertiesDotJson.definitions.healthcheck);
+          assert.notEqual('', propertiesDotJson.definitions.healthcheck);
+          assert.equal('string', propertiesDotJson.definitions.healthcheck.properties.type.type);
+          assert.equal('integer', propertiesDotJson.definitions.healthcheck.properties.frequency.type);
+          assert.equal('object', propertiesDotJson.definitions.healthcheck.properties.query_object.type);
+          assert.notEqual(undefined, propertiesDotJson.definitions.throttle);
+          assert.notEqual(null, propertiesDotJson.definitions.throttle);
+          assert.notEqual('', propertiesDotJson.definitions.throttle);
+          assert.equal('boolean', propertiesDotJson.definitions.throttle.properties.throttle_enabled.type);
+          assert.equal('integer', propertiesDotJson.definitions.throttle.properties.number_pronghorns.type);
+          assert.equal('string', propertiesDotJson.definitions.throttle.properties.sync_async.type);
+          assert.equal('integer', propertiesDotJson.definitions.throttle.properties.max_in_queue.type);
+          assert.equal('integer', propertiesDotJson.definitions.throttle.properties.concurrent_max.type);
+          assert.equal('integer', propertiesDotJson.definitions.throttle.properties.expire_timeout.type);
+          assert.equal('integer', propertiesDotJson.definitions.throttle.properties.avg_runtime.type);
+          assert.equal('array', propertiesDotJson.definitions.throttle.properties.priorities.type);
+          assert.notEqual(undefined, propertiesDotJson.definitions.request);
+          assert.notEqual(null, propertiesDotJson.definitions.request);
+          assert.notEqual('', propertiesDotJson.definitions.request);
+          assert.equal('integer', propertiesDotJson.definitions.request.properties.number_redirects.type);
+          assert.equal('integer', propertiesDotJson.definitions.request.properties.number_retries.type);
+          assert.equal(true, Array.isArray(propertiesDotJson.definitions.request.properties.limit_retry_error.type));
+          assert.equal('array', propertiesDotJson.definitions.request.properties.failover_codes.type);
+          assert.equal('integer', propertiesDotJson.definitions.request.properties.attempt_timeout.type);
+          assert.equal('object', propertiesDotJson.definitions.request.properties.global_request.type);
+          assert.equal('object', propertiesDotJson.definitions.request.properties.global_request.properties.payload.type);
+          assert.equal('object', propertiesDotJson.definitions.request.properties.global_request.properties.uriOptions.type);
+          assert.equal('object', propertiesDotJson.definitions.request.properties.global_request.properties.addlHeaders.type);
+          assert.equal('object', propertiesDotJson.definitions.request.properties.global_request.properties.authData.type);
+          assert.equal('boolean', propertiesDotJson.definitions.request.properties.healthcheck_on_timeout.type);
+          assert.equal('boolean', propertiesDotJson.definitions.request.properties.return_raw.type);
+          assert.equal('boolean', propertiesDotJson.definitions.request.properties.archiving.type);
+          assert.equal('boolean', propertiesDotJson.definitions.request.properties.return_request.type);
+          assert.notEqual(undefined, propertiesDotJson.definitions.proxy);
+          assert.notEqual(null, propertiesDotJson.definitions.proxy);
+          assert.notEqual('', propertiesDotJson.definitions.proxy);
+          assert.equal('boolean', propertiesDotJson.definitions.proxy.properties.enabled.type);
+          assert.equal('string', propertiesDotJson.definitions.proxy.properties.host.type);
+          assert.equal('integer', propertiesDotJson.definitions.proxy.properties.port.type);
+          assert.equal('string', propertiesDotJson.definitions.proxy.properties.protocol.type);
+          assert.equal('string', propertiesDotJson.definitions.proxy.properties.username.type);
+          assert.equal('string', propertiesDotJson.definitions.proxy.properties.password.type);
+          assert.notEqual(undefined, propertiesDotJson.definitions.mongo);
+          assert.notEqual(null, propertiesDotJson.definitions.mongo);
+          assert.notEqual('', propertiesDotJson.definitions.mongo);
+          assert.equal('string', propertiesDotJson.definitions.mongo.properties.host.type);
+          assert.equal('integer', propertiesDotJson.definitions.mongo.properties.port.type);
+          assert.equal('string', propertiesDotJson.definitions.mongo.properties.database.type);
+          assert.equal('string', propertiesDotJson.definitions.mongo.properties.username.type);
+          assert.equal('string', propertiesDotJson.definitions.mongo.properties.password.type);
+          assert.equal('string', propertiesDotJson.definitions.mongo.properties.replSet.type);
+          assert.equal('object', propertiesDotJson.definitions.mongo.properties.db_ssl.type);
+          assert.equal('boolean', propertiesDotJson.definitions.mongo.properties.db_ssl.properties.enabled.type);
+          assert.equal('boolean', propertiesDotJson.definitions.mongo.properties.db_ssl.properties.accept_invalid_cert.type);
+          assert.equal('string', propertiesDotJson.definitions.mongo.properties.db_ssl.properties.ca_file.type);
+          assert.equal('string', propertiesDotJson.definitions.mongo.properties.db_ssl.properties.key_file.type);
+          assert.equal('string', propertiesDotJson.definitions.mongo.properties.db_ssl.properties.cert_file.type);
+          assert.notEqual('', propertiesDotJson.definitions.devicebroker);
+          assert.equal('array', propertiesDotJson.definitions.devicebroker.properties.getDevice.type);
+          assert.equal('array', propertiesDotJson.definitions.devicebroker.properties.getDevicesFiltered.type);
+          assert.equal('array', propertiesDotJson.definitions.devicebroker.properties.isAlive.type);
+          assert.equal('array', propertiesDotJson.definitions.devicebroker.properties.getConfig.type);
+          assert.equal('array', propertiesDotJson.definitions.devicebroker.properties.getCount.type);
           done();
         } catch (error) {
           log.error(`Test Failure: ${error}`);
@@ -507,6 +667,50 @@ describe('[unit] Infoblox Adapter Test', () => {
           done(error);
         }
       });
+      it('error.json should have standard adapter errors', (done) => {
+        try {
+          const errorDotJson = require('../../error.json');
+          assert.notEqual(undefined, errorDotJson.errors);
+          assert.notEqual(null, errorDotJson.errors);
+          assert.notEqual('', errorDotJson.errors);
+          assert.equal(true, Array.isArray(errorDotJson.errors));
+          assert.notEqual(0, errorDotJson.errors.length);
+          assert.notEqual(undefined, errorDotJson.errors.find((e) => e.icode === 'AD.100'));
+          assert.notEqual(undefined, errorDotJson.errors.find((e) => e.icode === 'AD.101'));
+          assert.notEqual(undefined, errorDotJson.errors.find((e) => e.icode === 'AD.102'));
+          assert.notEqual(undefined, errorDotJson.errors.find((e) => e.icode === 'AD.110'));
+          assert.notEqual(undefined, errorDotJson.errors.find((e) => e.icode === 'AD.111'));
+          assert.notEqual(undefined, errorDotJson.errors.find((e) => e.icode === 'AD.112'));
+          assert.notEqual(undefined, errorDotJson.errors.find((e) => e.icode === 'AD.113'));
+          assert.notEqual(undefined, errorDotJson.errors.find((e) => e.icode === 'AD.114'));
+          assert.notEqual(undefined, errorDotJson.errors.find((e) => e.icode === 'AD.115'));
+          assert.notEqual(undefined, errorDotJson.errors.find((e) => e.icode === 'AD.116'));
+          assert.notEqual(undefined, errorDotJson.errors.find((e) => e.icode === 'AD.300'));
+          assert.notEqual(undefined, errorDotJson.errors.find((e) => e.icode === 'AD.301'));
+          assert.notEqual(undefined, errorDotJson.errors.find((e) => e.icode === 'AD.302'));
+          assert.notEqual(undefined, errorDotJson.errors.find((e) => e.icode === 'AD.303'));
+          assert.notEqual(undefined, errorDotJson.errors.find((e) => e.icode === 'AD.304'));
+          assert.notEqual(undefined, errorDotJson.errors.find((e) => e.icode === 'AD.305'));
+          assert.notEqual(undefined, errorDotJson.errors.find((e) => e.icode === 'AD.310'));
+          assert.notEqual(undefined, errorDotJson.errors.find((e) => e.icode === 'AD.311'));
+          assert.notEqual(undefined, errorDotJson.errors.find((e) => e.icode === 'AD.312'));
+          assert.notEqual(undefined, errorDotJson.errors.find((e) => e.icode === 'AD.320'));
+          assert.notEqual(undefined, errorDotJson.errors.find((e) => e.icode === 'AD.321'));
+          assert.notEqual(undefined, errorDotJson.errors.find((e) => e.icode === 'AD.400'));
+          assert.notEqual(undefined, errorDotJson.errors.find((e) => e.icode === 'AD.401'));
+          assert.notEqual(undefined, errorDotJson.errors.find((e) => e.icode === 'AD.402'));
+          assert.notEqual(undefined, errorDotJson.errors.find((e) => e.icode === 'AD.500'));
+          assert.notEqual(undefined, errorDotJson.errors.find((e) => e.icode === 'AD.501'));
+          assert.notEqual(undefined, errorDotJson.errors.find((e) => e.icode === 'AD.502'));
+          assert.notEqual(undefined, errorDotJson.errors.find((e) => e.icode === 'AD.503'));
+          assert.notEqual(undefined, errorDotJson.errors.find((e) => e.icode === 'AD.600'));
+          assert.notEqual(undefined, errorDotJson.errors.find((e) => e.icode === 'AD.900'));
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
     });
 
     describe('sampleProperties.json', () => {
@@ -521,6 +725,121 @@ describe('[unit] Infoblox Adapter Test', () => {
           done(error);
         }
       });
+      it('sampleProperties.json should contain generic adapter properties', (done) => {
+        try {
+          const sampleDotJson = require('../../sampleProperties.json');
+          assert.notEqual(-1, sampleDotJson.id.indexOf('infoblox'));
+          assert.equal('Infoblox', sampleDotJson.type);
+          assert.notEqual(undefined, sampleDotJson.properties);
+          assert.notEqual(null, sampleDotJson.properties);
+          assert.notEqual('', sampleDotJson.properties);
+          assert.notEqual(undefined, sampleDotJson.properties.host);
+          assert.notEqual(undefined, sampleDotJson.properties.port);
+          assert.notEqual(undefined, sampleDotJson.properties.stub);
+          assert.notEqual(undefined, sampleDotJson.properties.authentication);
+          assert.notEqual(null, sampleDotJson.properties.authentication);
+          assert.notEqual('', sampleDotJson.properties.authentication);
+          assert.notEqual(undefined, sampleDotJson.properties.authentication.auth_method);
+          assert.notEqual(undefined, sampleDotJson.properties.authentication.username);
+          assert.notEqual(undefined, sampleDotJson.properties.authentication.password);
+          assert.notEqual(undefined, sampleDotJson.properties.authentication.token);
+          assert.notEqual(undefined, sampleDotJson.properties.authentication.invalid_token_error);
+          assert.notEqual(undefined, sampleDotJson.properties.authentication.token_timeout);
+          assert.notEqual(undefined, sampleDotJson.properties.authentication.token_cache);
+          assert.notEqual(undefined, sampleDotJson.properties.authentication.auth_field);
+          assert.notEqual(undefined, sampleDotJson.properties.authentication.auth_field_format);
+          assert.notEqual(undefined, sampleDotJson.properties.authentication.auth_logging);
+          assert.notEqual(undefined, sampleDotJson.properties.authentication.client_id);
+          assert.notEqual(undefined, sampleDotJson.properties.authentication.client_secret);
+          assert.notEqual(undefined, sampleDotJson.properties.authentication.grant_type);
+          assert.notEqual(undefined, sampleDotJson.properties.ssl);
+          assert.notEqual(null, sampleDotJson.properties.ssl);
+          assert.notEqual('', sampleDotJson.properties.ssl);
+          assert.notEqual(undefined, sampleDotJson.properties.ssl.ecdhCurve);
+          assert.notEqual(undefined, sampleDotJson.properties.ssl.enabled);
+          assert.notEqual(undefined, sampleDotJson.properties.ssl.accept_invalid_cert);
+          assert.notEqual(undefined, sampleDotJson.properties.ssl.ca_file);
+          assert.notEqual(undefined, sampleDotJson.properties.ssl.key_file);
+          assert.notEqual(undefined, sampleDotJson.properties.ssl.cert_file);
+          assert.notEqual(undefined, sampleDotJson.properties.ssl.secure_protocol);
+          assert.notEqual(undefined, sampleDotJson.properties.ssl.ciphers);
+          assert.notEqual(undefined, sampleDotJson.properties.base_path);
+          assert.notEqual(undefined, sampleDotJson.properties.version);
+          assert.notEqual(undefined, sampleDotJson.properties.cache_location);
+          assert.notEqual(undefined, sampleDotJson.properties.encode_pathvars);
+          assert.notEqual(undefined, sampleDotJson.properties.encode_queryvars);
+          assert.notEqual(undefined, sampleDotJson.properties.save_metric);
+          assert.notEqual(undefined, sampleDotJson.properties.protocol);
+          assert.notEqual(undefined, sampleDotJson.properties.healthcheck);
+          assert.notEqual(null, sampleDotJson.properties.healthcheck);
+          assert.notEqual('', sampleDotJson.properties.healthcheck);
+          assert.notEqual(undefined, sampleDotJson.properties.healthcheck.type);
+          assert.notEqual(undefined, sampleDotJson.properties.healthcheck.frequency);
+          assert.notEqual(undefined, sampleDotJson.properties.healthcheck.query_object);
+          assert.notEqual(undefined, sampleDotJson.properties.throttle);
+          assert.notEqual(null, sampleDotJson.properties.throttle);
+          assert.notEqual('', sampleDotJson.properties.throttle);
+          assert.notEqual(undefined, sampleDotJson.properties.throttle.throttle_enabled);
+          assert.notEqual(undefined, sampleDotJson.properties.throttle.number_pronghorns);
+          assert.notEqual(undefined, sampleDotJson.properties.throttle.sync_async);
+          assert.notEqual(undefined, sampleDotJson.properties.throttle.max_in_queue);
+          assert.notEqual(undefined, sampleDotJson.properties.throttle.concurrent_max);
+          assert.notEqual(undefined, sampleDotJson.properties.throttle.expire_timeout);
+          assert.notEqual(undefined, sampleDotJson.properties.throttle.avg_runtime);
+          assert.notEqual(undefined, sampleDotJson.properties.throttle.priorities);
+          assert.notEqual(undefined, sampleDotJson.properties.request);
+          assert.notEqual(null, sampleDotJson.properties.request);
+          assert.notEqual('', sampleDotJson.properties.request);
+          assert.notEqual(undefined, sampleDotJson.properties.request.number_redirects);
+          assert.notEqual(undefined, sampleDotJson.properties.request.number_retries);
+          assert.notEqual(undefined, sampleDotJson.properties.request.limit_retry_error);
+          assert.notEqual(undefined, sampleDotJson.properties.request.failover_codes);
+          assert.notEqual(undefined, sampleDotJson.properties.request.attempt_timeout);
+          assert.notEqual(undefined, sampleDotJson.properties.request.global_request);
+          assert.notEqual(undefined, sampleDotJson.properties.request.global_request.payload);
+          assert.notEqual(undefined, sampleDotJson.properties.request.global_request.uriOptions);
+          assert.notEqual(undefined, sampleDotJson.properties.request.global_request.addlHeaders);
+          assert.notEqual(undefined, sampleDotJson.properties.request.global_request.authData);
+          assert.notEqual(undefined, sampleDotJson.properties.request.healthcheck_on_timeout);
+          assert.notEqual(undefined, sampleDotJson.properties.request.return_raw);
+          assert.notEqual(undefined, sampleDotJson.properties.request.archiving);
+          assert.notEqual(undefined, sampleDotJson.properties.request.return_request);
+          assert.notEqual(undefined, sampleDotJson.properties.proxy);
+          assert.notEqual(null, sampleDotJson.properties.proxy);
+          assert.notEqual('', sampleDotJson.properties.proxy);
+          assert.notEqual(undefined, sampleDotJson.properties.proxy.enabled);
+          assert.notEqual(undefined, sampleDotJson.properties.proxy.host);
+          assert.notEqual(undefined, sampleDotJson.properties.proxy.port);
+          assert.notEqual(undefined, sampleDotJson.properties.proxy.protocol);
+          assert.notEqual(undefined, sampleDotJson.properties.proxy.username);
+          assert.notEqual(undefined, sampleDotJson.properties.proxy.password);
+          assert.notEqual(undefined, sampleDotJson.properties.mongo);
+          assert.notEqual(null, sampleDotJson.properties.mongo);
+          assert.notEqual('', sampleDotJson.properties.mongo);
+          assert.notEqual(undefined, sampleDotJson.properties.mongo.host);
+          assert.notEqual(undefined, sampleDotJson.properties.mongo.port);
+          assert.notEqual(undefined, sampleDotJson.properties.mongo.database);
+          assert.notEqual(undefined, sampleDotJson.properties.mongo.username);
+          assert.notEqual(undefined, sampleDotJson.properties.mongo.password);
+          assert.notEqual(undefined, sampleDotJson.properties.mongo.replSet);
+          assert.notEqual(undefined, sampleDotJson.properties.mongo.db_ssl);
+          assert.notEqual(undefined, sampleDotJson.properties.mongo.db_ssl.enabled);
+          assert.notEqual(undefined, sampleDotJson.properties.mongo.db_ssl.accept_invalid_cert);
+          assert.notEqual(undefined, sampleDotJson.properties.mongo.db_ssl.ca_file);
+          assert.notEqual(undefined, sampleDotJson.properties.mongo.db_ssl.key_file);
+          assert.notEqual(undefined, sampleDotJson.properties.mongo.db_ssl.cert_file);
+          assert.notEqual(undefined, sampleDotJson.properties.devicebroker);
+          assert.notEqual(undefined, sampleDotJson.properties.devicebroker.getDevice);
+          assert.notEqual(undefined, sampleDotJson.properties.devicebroker.getDevicesFiltered);
+          assert.notEqual(undefined, sampleDotJson.properties.devicebroker.isAlive);
+          assert.notEqual(undefined, sampleDotJson.properties.devicebroker.getConfig);
+          assert.notEqual(undefined, sampleDotJson.properties.devicebroker.getCount);
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
     });
 
     describe('#checkProperties', () => {
@@ -608,6 +927,148 @@ describe('[unit] Infoblox Adapter Test', () => {
       });
     });
 
+    describe('#iapUpdateAdapterConfiguration', () => {
+      it('should have a iapUpdateAdapterConfiguration function', (done) => {
+        try {
+          assert.equal(true, typeof a.iapUpdateAdapterConfiguration === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#iapFindAdapterPath', () => {
+      it('should have a iapFindAdapterPath function', (done) => {
+        try {
+          assert.equal(true, typeof a.iapFindAdapterPath === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+      it('iapFindAdapterPath should find atleast one path that matches', (done) => {
+        try {
+          a.iapFindAdapterPath('{base_path}/{version}', (data, error) => {
+            try {
+              assert.equal(undefined, error);
+              assert.notEqual(undefined, data);
+              assert.notEqual(null, data);
+              assert.equal(true, data.found);
+              assert.notEqual(undefined, data.foundIn);
+              assert.notEqual(null, data.foundIn);
+              assert.notEqual(0, data.foundIn.length);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#iapSuspendAdapter', () => {
+      it('should have a iapSuspendAdapter function', (done) => {
+        try {
+          assert.equal(true, typeof a.iapSuspendAdapter === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#iapUnsuspendAdapter', () => {
+      it('should have a iapUnsuspendAdapter function', (done) => {
+        try {
+          assert.equal(true, typeof a.iapUnsuspendAdapter === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#iapGetAdapterQueue', () => {
+      it('should have a iapGetAdapterQueue function', (done) => {
+        try {
+          assert.equal(true, typeof a.iapGetAdapterQueue === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#iapTroubleshootAdapter', () => {
+      it('should have a iapTroubleshootAdapter function', (done) => {
+        try {
+          assert.equal(true, typeof a.iapTroubleshootAdapter === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#iapRunAdapterHealthcheck', () => {
+      it('should have a iapRunAdapterHealthcheck function', (done) => {
+        try {
+          assert.equal(true, typeof a.iapRunAdapterHealthcheck === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#iapRunAdapterConnectivity', () => {
+      it('should have a iapRunAdapterConnectivity function', (done) => {
+        try {
+          assert.equal(true, typeof a.iapRunAdapterConnectivity === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#iapRunAdapterBasicGet', () => {
+      it('should have a iapRunAdapterBasicGet function', (done) => {
+        try {
+          assert.equal(true, typeof a.iapRunAdapterBasicGet === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#iapMoveAdapterEntitiesToDB', () => {
+      it('should have a iapMoveAdapterEntitiesToDB function', (done) => {
+        try {
+          assert.equal(true, typeof a.iapMoveAdapterEntitiesToDB === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
     describe('#checkActionFiles', () => {
       it('should have a checkActionFiles function', (done) => {
         try {
@@ -693,10 +1154,10 @@ describe('[unit] Infoblox Adapter Test', () => {
       }).timeout(attemptTimeout);
     });
 
-    // describe('#hasEntity', () => {
-    //   it('should have a hasEntity function', (done) => {
+    // describe('#iapHasAdapterEntity', () => {
+    //   it('should have a iapHasAdapterEntity function', (done) => {
     //     try {
-    //       assert.equal(true, typeof a.hasEntity === 'function');
+    //       assert.equal(true, typeof a.iapHasAdapterEntity === 'function');
     //       done();
     //     } catch (error) {
     //       log.error(`Test Failure: ${error}`);
@@ -705,7 +1166,7 @@ describe('[unit] Infoblox Adapter Test', () => {
     //   });
     //   it('should find entity', (done) => {
     //     try {
-    //       a.hasEntity('template_entity', // 'a9e9c33dc61122760072455df62663d2', (data) => {
+    //       a.iapHasAdapterEntity('template_entity', // 'a9e9c33dc61122760072455df62663d2', (data) => {
     //         try {
     //           assert.equal(true, data[0]);
     //           done();
@@ -721,7 +1182,7 @@ describe('[unit] Infoblox Adapter Test', () => {
     //   }).timeout(attemptTimeout);
     //   it('should not find entity', (done) => {
     //     try {
-    //       a.hasEntity('template_entity', 'blah', (data) => {
+    //       a.iapHasAdapterEntity('template_entity', 'blah', (data) => {
     //         try {
     //           assert.equal(false, data[0]);
     //           done();
@@ -737,6 +1198,78 @@ describe('[unit] Infoblox Adapter Test', () => {
     //   }).timeout(attemptTimeout);
     // });
 
+    describe('#hasEntities', () => {
+      it('should have a hasEntities function', (done) => {
+        try {
+          assert.equal(true, typeof a.hasEntities === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#getDevice', () => {
+      it('should have a getDevice function', (done) => {
+        try {
+          assert.equal(true, typeof a.getDevice === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#getDevicesFiltered', () => {
+      it('should have a getDevicesFiltered function', (done) => {
+        try {
+          assert.equal(true, typeof a.getDevicesFiltered === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#isAlive', () => {
+      it('should have a isAlive function', (done) => {
+        try {
+          assert.equal(true, typeof a.isAlive === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#getConfig', () => {
+      it('should have a getConfig function', (done) => {
+        try {
+          assert.equal(true, typeof a.getConfig === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#iapGetDeviceCount', () => {
+      it('should have a iapGetDeviceCount function', (done) => {
+        try {
+          assert.equal(true, typeof a.iapGetDeviceCount === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
     /*
     -----------------------------------------------------------------------
     -----------------------------------------------------------------------
@@ -761,7 +1294,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createNetwork(null, null, (data, error) => {
             try {
               const displayE = 'network is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createNetwork', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createNetwork', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -778,7 +1311,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createNetwork('1.1.1.1', null, (data, error) => {
             try {
               const displayE = 'comment is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createNetwork', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createNetwork', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -807,7 +1340,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.getNetworkKeyByIP(null, (data, error) => {
             try {
               const displayE = 'networkIP is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-getNetworkKeyByIP', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getNetworkKeyByIPWithQuery', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -836,7 +1369,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createAuthZone(null, (data, error) => {
             try {
               const displayE = 'fqdnName is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createAuthZone', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createAuthZone', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -865,7 +1398,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createHostRecord(null, null, null, (data, error) => {
             try {
               const displayE = 'hostName is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createHostRecord', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createHostRecord', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -882,7 +1415,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createHostRecord('itential.com', null, null, (data, error) => {
             try {
               const displayE = 'IPAddress is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createHostRecord', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createHostRecord', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -911,7 +1444,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createHostRecord2(null, null, null, (data, error) => {
             try {
               const displayE = 'hostName is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createHostRecord2', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createHostRecord2', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -928,7 +1461,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createHostRecord2('itential.com', null, null, (data, error) => {
             try {
               const displayE = 'IPAddress is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createHostRecord2', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createHostRecord2', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -957,7 +1490,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.getIpByHost(null, (data, error) => {
             try {
               const displayE = 'hostName is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-getIpByHost', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getIpByHostWithQuery', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -986,7 +1519,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.getHostKeyByHostName(null, (data, error) => {
             try {
               const displayE = 'hostName is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-getHostKeyByHostName', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getHostKeyByHostNameWithQuery', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1015,7 +1548,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.deleteHostRecordByHostName(null, (data, error) => {
             try {
               const displayE = 'hostName is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-deleteHostRecordByHostName', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-deleteHostRecordByHostName', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1044,7 +1577,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.assignNextNetwork(null, null, null, (data, error) => {
             try {
               const displayE = 'networkBlock is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-assignNextNetwork', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-assignNextNetwork', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1061,7 +1594,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.assignNextNetwork('fakedata', null, null, (data, error) => {
             try {
               const displayE = 'nextNetworkSubnetMask is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-assignNextNetwork', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-assignNextNetwork', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1090,7 +1623,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.assignNextNetworkByNetwork(null, null, null, null, null, (data, error) => {
             try {
               const displayE = 'networkBlock is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-assignNextNetworkByNetwork', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-assignNextNetworkByNetwork', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1107,7 +1640,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.assignNextNetworkByNetwork('fakedata', null, null, null, null, (data, error) => {
             try {
               const displayE = 'nextNetworkSubnetMask is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-assignNextNetworkByNetwork', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-assignNextNetworkByNetwork', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1136,7 +1669,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.assignNextNetworkByRef(null, null, null, null, null, (data, error) => {
             try {
               const displayE = 'networkReference is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-assignNextNetworkByRef', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-assignNextNetworkByRef', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1153,7 +1686,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.assignNextNetworkByRef('fakedata', null, null, null, null, (data, error) => {
             try {
               const displayE = 'nextNetworkSubnetMask is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-assignNextNetworkByRef', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-assignNextNetworkByRef', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1182,7 +1715,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.assignNextIP(null, ' ', ' ', (data, error) => {
             try {
               const displayE = 'networkIP is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-assignNextIP', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-assignNextIP', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1199,7 +1732,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.assignNextIP(' ', null, ' ', (data, error) => {
             try {
               const displayE = 'hostName is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-assignNextIP', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-assignNextIP', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1216,7 +1749,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.assignNextIP(' ', ' ', null, (data, error) => {
             try {
               const displayE = 'fqdnName is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-assignNextIP', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-assignNextIP', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1244,8 +1777,8 @@ describe('[unit] Infoblox Adapter Test', () => {
         try {
           a.getAuthZoneDetailsByfqdnName(null, (data, error) => {
             try {
-              const displayE = 'Schema validation failed on should be string';
-              runErrorAsserts(data, error, 'AD.312', 'infoblox-translatorUtil-buildJSONEntity', displayE);
+              const displayE = 'fqdnName is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getAuthZoneDetailsByfqdnNameWithQuery', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1277,16 +1810,190 @@ describe('[unit] Infoblox Adapter Test', () => {
           assert.equal(true, typeof a.createForwardZone === 'function');
           done();
         } catch (error) {
-          log.error(`Test Failure: ${error}`);
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.createForwardZone(null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createForwardZone', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteZones - errors', () => {
+      it('should have a deleteZones function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteZones === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing objectReference', (done) => {
+        try {
+          a.deleteZones(null, (data, error) => {
+            try {
+              const displayE = 'objectReference is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-deleteZones', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getZoneDelegations - errors', () => {
+      it('should have a getZoneDelegations function', (done) => {
+        try {
+          assert.equal(true, typeof a.getZoneDelegations === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createZoneDelegation - errors', () => {
+      it('should have a createZoneDelegation function', (done) => {
+        try {
+          assert.equal(true, typeof a.createZoneDelegation === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.createZoneDelegation(null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createZoneDelegation', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteAuthZoneByRef - errors', () => {
+      it('should have a deleteAuthZoneByRef function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteAuthZoneByRef === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing zoneRef', (done) => {
+        try {
+          a.deleteAuthZoneByRef(null, (data, error) => {
+            try {
+              const displayE = 'zoneRef is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-deleteAuthZoneByRef', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNetworkBlock - errors', () => {
+      it('should have a getNetworkBlock function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNetworkBlock === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing objectReference', (done) => {
+        try {
+          a.getNetworkBlock(null, (data, error) => {
+            try {
+              const displayE = 'objectReference is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getNetworkBlockWithQuery', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#modifyNetworkBlock - errors', () => {
+      it('should have a modifyNetworkBlock function', (done) => {
+        try {
+          assert.equal(true, typeof a.modifyNetworkBlock === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing objectReference', (done) => {
+        try {
+          a.modifyNetworkBlock(null, null, (data, error) => {
+            try {
+              const displayE = 'networkIP is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getNetworkKeyByIPWithQuery', 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.createForwardZone(null, (data, error) => {
+          a.modifyNetworkBlock('fakeparam', null, (data, error) => {
             try {
-              const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createForwardZone', displayE);
+              const displayE = 'Schema validation failed on should be string';
+              runErrorAsserts(data, error, 'AD.312', 'Test-infoblox-translatorUtil-buildJSONEntity', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1300,22 +2007,22 @@ describe('[unit] Infoblox Adapter Test', () => {
       }).timeout(attemptTimeout);
     });
 
-    describe('#deleteZones - errors', () => {
-      it('should have a deleteZones function', (done) => {
+    describe('#getNetworkContainerNextNetworkIps - errors', () => {
+      it('should have a getNetworkContainerNextNetworkIps function', (done) => {
         try {
-          assert.equal(true, typeof a.deleteZones === 'function');
+          assert.equal(true, typeof a.getNetworkContainerNextNetworkIps === 'function');
           done();
         } catch (error) {
           log.error(`Test Failure: ${error}`);
           done(error);
         }
       }).timeout(attemptTimeout);
-      it('should error if - missing objectReference', (done) => {
+      it('should error if - missing networkId', (done) => {
         try {
-          a.deleteZones(null, (data, error) => {
+          a.getNetworkContainerNextNetworkIps(null, null, null, null, (data, error) => {
             try {
-              const displayE = 'objectReference is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-deleteZones', displayE);
+              const displayE = 'networkId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getNetworkContainerNextNetworkIps', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1327,36 +2034,29 @@ describe('[unit] Infoblox Adapter Test', () => {
           done(error);
         }
       }).timeout(attemptTimeout);
-    });
-
-    describe('#getZoneDelegations - errors', () => {
-      it('should have a getZoneDelegations function', (done) => {
-        try {
-          assert.equal(true, typeof a.getZoneDelegations === 'function');
-          done();
-        } catch (error) {
-          log.error(`Test Failure: ${error}`);
-          done(error);
-        }
-      }).timeout(attemptTimeout);
-    });
-
-    describe('#createZoneDelegation - errors', () => {
-      it('should have a createZoneDelegation function', (done) => {
+      it('should error if - missing containerId', (done) => {
         try {
-          assert.equal(true, typeof a.createZoneDelegation === 'function');
-          done();
+          a.getNetworkContainerNextNetworkIps('fakedata', null, null, null, (data, error) => {
+            try {
+              const displayE = 'containerId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getNetworkContainerNextNetworkIps', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
         } catch (error) {
-          log.error(`Test Failure: ${error}`);
+          log.error(`Adapter Exception: ${error}`);
           done(error);
         }
       }).timeout(attemptTimeout);
       it('should error if - missing body', (done) => {
         try {
-          a.createZoneDelegation(null, (data, error) => {
+          a.getNetworkContainerNextNetworkIps('fakedata', 'fakedata', null, null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createZoneDelegation', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getNetworkContainerNextNetworkIps', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1368,24 +2068,12 @@ describe('[unit] Infoblox Adapter Test', () => {
           done(error);
         }
       }).timeout(attemptTimeout);
-    });
-
-    describe('#deleteAuthZoneByRef - errors', () => {
-      it('should have a deleteAuthZoneByRef function', (done) => {
-        try {
-          assert.equal(true, typeof a.deleteAuthZoneByRef === 'function');
-          done();
-        } catch (error) {
-          log.error(`Test Failure: ${error}`);
-          done(error);
-        }
-      }).timeout(attemptTimeout);
-      it('should error if - missing zoneRef', (done) => {
+      it('should error if - missing query', (done) => {
         try {
-          a.deleteAuthZoneByRef(null, (data, error) => {
+          a.getNetworkContainerNextNetworkIps('fakedata', 'fakedata', { key: 'fakedata' }, null, (data, error) => {
             try {
-              const displayE = 'zoneRef is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-deleteAuthZoneByRef', displayE);
+              const displayE = 'query is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getNetworkContainerNextNetworkIps', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1399,22 +2087,22 @@ describe('[unit] Infoblox Adapter Test', () => {
       }).timeout(attemptTimeout);
     });
 
-    describe('#getNetworkBlock - errors', () => {
-      it('should have a getNetworkBlock function', (done) => {
+    describe('#getIpv6NetworkContainerNextNetworkIps - errors', () => {
+      it('should have a getIpv6NetworkContainerNextNetworkIps function', (done) => {
         try {
-          assert.equal(true, typeof a.getNetworkBlock === 'function');
+          assert.equal(true, typeof a.getIpv6NetworkContainerNextNetworkIps === 'function');
           done();
         } catch (error) {
           log.error(`Test Failure: ${error}`);
           done(error);
         }
       }).timeout(attemptTimeout);
-      it('should error if - missing objectReference', (done) => {
+      it('should error if - missing networkId', (done) => {
         try {
-          a.getNetworkBlock(null, (data, error) => {
+          a.getIpv6NetworkContainerNextNetworkIps(null, null, null, null, (data, error) => {
             try {
-              const displayE = 'objectReference is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-getNetworkBlock', displayE);
+              const displayE = 'networkId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getIpv6NetworkContainerNextNetworkIps', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1426,24 +2114,29 @@ describe('[unit] Infoblox Adapter Test', () => {
           done(error);
         }
       }).timeout(attemptTimeout);
-    });
-
-    describe('#modifyNetworkBlock - errors', () => {
-      it('should have a modifyNetworkBlock function', (done) => {
+      it('should error if - missing containerId', (done) => {
         try {
-          assert.equal(true, typeof a.modifyNetworkBlock === 'function');
-          done();
+          a.getIpv6NetworkContainerNextNetworkIps('fakedata', null, null, null, (data, error) => {
+            try {
+              const displayE = 'containerId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getIpv6NetworkContainerNextNetworkIps', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
         } catch (error) {
-          log.error(`Test Failure: ${error}`);
+          log.error(`Adapter Exception: ${error}`);
           done(error);
         }
       }).timeout(attemptTimeout);
-      it('should error if - missing objectReference', (done) => {
+      it('should error if - missing body', (done) => {
         try {
-          a.modifyNetworkBlock(null, null, (data, error) => {
+          a.getIpv6NetworkContainerNextNetworkIps('fakedata', 'fakedata', null, null, (data, error) => {
             try {
-              const displayE = 'networkIP is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-getNetworkKeyByIP', displayE);
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getIpv6NetworkContainerNextNetworkIps', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1455,12 +2148,12 @@ describe('[unit] Infoblox Adapter Test', () => {
           done(error);
         }
       }).timeout(attemptTimeout);
-      it('should error if - missing body', (done) => {
+      it('should error if - missing query', (done) => {
         try {
-          a.modifyNetworkBlock('fakeparam', null, (data, error) => {
+          a.getIpv6NetworkContainerNextNetworkIps('fakedata', 'fakedata', { key: 'fakedata' }, null, (data, error) => {
             try {
-              const displayE = 'Schema validation failed on should be string';
-              runErrorAsserts(data, error, 'AD.312', 'infoblox-translatorUtil-buildJSONEntity', displayE);
+              const displayE = 'query is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getIpv6NetworkContainerNextNetworkIps', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1488,8 +2181,8 @@ describe('[unit] Infoblox Adapter Test', () => {
         try {
           a.getNetworkDetails(null, (data, error) => {
             try {
-              const displayE = 'Schema validation failed on should be string';
-              runErrorAsserts(data, error, 'AD.312', 'infoblox-translatorUtil-buildJSONEntity', displayE);
+              const displayE = 'networkIP is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getNetworkDetailsWithQuery', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1517,8 +2210,8 @@ describe('[unit] Infoblox Adapter Test', () => {
         try {
           a.getNetworkContainerDetails(null, (data, error) => {
             try {
-              const displayE = 'Schema validation failed on should be string';
-              runErrorAsserts(data, error, 'AD.312', 'infoblox-translatorUtil-buildJSONEntity', displayE);
+              const displayE = 'networkIP is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getNetworkContainerDetailsWithQuery', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1559,7 +2252,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.deleteNetworkContainer(null, (data, error) => {
             try {
               const displayE = 'networkRef is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-deleteNetworkContainer', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-deleteNetworkContainer', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1588,7 +2281,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.genericCreateNextAvailableNetwork(null, null, null, (data, error) => {
             try {
               const displayE = 'networkRef is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-genericCreateNextAvailableNetwork', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-genericCreateNextAvailableNetwork', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1605,7 +2298,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.genericCreateNextAvailableNetwork('fakeparam', null, null, (data, error) => {
             try {
               const displayE = 'options is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-genericCreateNextAvailableNetwork', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-genericCreateNextAvailableNetwork', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1622,7 +2315,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.genericCreateNextAvailableNetwork('fakeparam', 'fakeparam', null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-genericCreateNextAvailableNetwork', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-genericCreateNextAvailableNetwork', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1650,8 +2343,8 @@ describe('[unit] Infoblox Adapter Test', () => {
         try {
           a.deleteNetwork(null, (data, error) => {
             try {
-              const displayE = 'Schema validation failed on should be string';
-              runErrorAsserts(data, error, 'AD.312', 'infoblox-translatorUtil-buildJSONEntity', displayE);
+              const displayE = 'networkIP is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getNetworkContainerDetailsWithQuery', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1679,8 +2372,8 @@ describe('[unit] Infoblox Adapter Test', () => {
         try {
           a.deleteNetworkv2(null, (data, error) => {
             try {
-              const displayE = 'Schema validation failed on should be string';
-              runErrorAsserts(data, error, 'AD.312', 'infoblox-translatorUtil-buildJSONEntity', displayE);
+              const displayE = 'networkIP is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getNetworkDetailsWithQuery', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1709,7 +2402,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.getNetworkUtilizationByIP(null, (data, error) => {
             try {
               const displayE = 'networkIP is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-getNetworkUtilizationByIP', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getNetworkUtilizationByIPWithQuery', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1738,7 +2431,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createNetworkBlock(null, null, null, (data, error) => {
             try {
               const displayE = 'functionParam is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createNetworkBlock', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createNetworkBlock', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1755,7 +2448,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createNetworkBlock('fakeparam', null, null, (data, error) => {
             try {
               const displayE = 'objectReference is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createNetworkBlock', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createNetworkBlock', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1772,7 +2465,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createNetworkBlock('fakeparam', 'fakeparam', null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createNetworkBlock', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createNetworkBlock', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1813,7 +2506,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createDtcServer(null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createDtcServer', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createDtcServer', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1854,7 +2547,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createDtcPool(null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createDtcPool', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createDtcPool', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1883,7 +2576,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createDtcLbdn(null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createDtcLbdn', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createDtcLbdn', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1912,7 +2605,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.getHostRecord(null, (data, error) => {
             try {
               const displayE = 'hostName is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-getHostRecord', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getHostRecordWithQuery', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1953,7 +2646,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createARecord(null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createARecord', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createARecord', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -1994,7 +2687,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createCNAMERecord(null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createCNAMERecord', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createCNAMERecord', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2035,7 +2728,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createTxtRecord(null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createTxtRecord', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createTxtRecord', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2064,7 +2757,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.getAllRecords(null, (data, error) => {
             try {
               const displayE = 'zone is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-getAllRecords', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getAllRecordsWithQuery', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2105,7 +2798,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createAaaaRecord(null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createAaaaRecord', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createAaaaRecord', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2146,7 +2839,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createMxRecord(null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createMxRecord', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createMxRecord', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2187,7 +2880,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createNsRecord(null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createNsRecord', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createNsRecord', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2228,7 +2921,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createPtrRecord(null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createPtrRecord', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createPtrRecord', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2269,7 +2962,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createSrvRecord(null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createSrvRecord', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createSrvRecord', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2298,7 +2991,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.updateHostRecord(null, null, (data, error) => {
             try {
               const displayE = 'recordkey is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-updateHostRecord', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-updateHostRecord', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2315,7 +3008,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.updateHostRecord('fakeparam', null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-updateHostRecord', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-updateHostRecord', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2344,7 +3037,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.deleteHostRecord(null, (data, error) => {
             try {
               const displayE = 'recordkey is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-deleteHostRecord', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-deleteHostRecord', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2373,7 +3066,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.updateARecord(null, null, (data, error) => {
             try {
               const displayE = 'recordkey is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-updateARecord', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-updateARecord', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2390,7 +3083,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.updateARecord('fakeparam', null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-updateARecord', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-updateARecord', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2419,7 +3112,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.deleteARecord(null, (data, error) => {
             try {
               const displayE = 'recordkey is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-deleteARecord', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-deleteARecord', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2448,7 +3141,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.updatePTRRecord(null, null, (data, error) => {
             try {
               const displayE = 'recordkey is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-updatePTRRecord', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-updatePTRRecord', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2465,7 +3158,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.updatePTRRecord('fakeparam', null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-updatePTRRecord', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-updatePTRRecord', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2494,7 +3187,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.deletePTRRecord(null, (data, error) => {
             try {
               const displayE = 'recordkey is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-deletePTRRecord', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-deletePTRRecord', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2523,7 +3216,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.updateCNAMERecord(null, null, (data, error) => {
             try {
               const displayE = 'recordkey is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-updateCNAMERecord', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-updateCNAMERecord', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2540,7 +3233,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.updateCNAMERecord('fakeparam', null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-updateCNAMERecord', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-updateCNAMERecord', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2569,7 +3262,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.deleteCNAMERecord(null, (data, error) => {
             try {
               const displayE = 'recordkey is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-deleteCNAMERecord', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-deleteCNAMERecord', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2634,7 +3327,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createResponsePolicyZone(null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createResponsePolicyZone', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createResponsePolicyZone', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2663,7 +3356,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createSubstituitionRuleForARecords(null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createSubstituitionRuleForARecords', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createSubstituitionRuleForARecords', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2692,7 +3385,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.addSubstituitionRuleForPtrRecords(null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-addSubstituitionRuleForPtrRecords', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-addSubstituitionRuleForPtrRecords', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2721,7 +3414,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.addSubstituitionRuleForIpTriggerPolicy(null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-addSubstituitionRuleForIpTriggerPolicy', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-addSubstituitionRuleForIpTriggerPolicy', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2750,7 +3443,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.addBlockDomainNameRule(null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-addBlockDomainNameRule', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-addBlockDomainNameRule', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2779,7 +3472,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.addBlockClientIpAddressRule(null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-addBlockClientIpAddressRule', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-addBlockClientIpAddressRule', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2808,7 +3501,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.addSubstituteDomainNameClientIpAddressRule(null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-addSubstituteDomainNameClientIpAddressRule', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-addSubstituteDomainNameClientIpAddressRule', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2837,7 +3530,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.addBlockIpAddressNoSuchDomainRule(null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-addBlockIpAddressNoSuchDomainRule', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-addBlockIpAddressNoSuchDomainRule', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2866,7 +3559,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.addSubstituteDomainNameIpAddressRule(null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-addSubstituteDomainNameIpAddressRule', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-addSubstituteDomainNameIpAddressRule', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2895,7 +3588,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.getAllRpzRecords(null, (data, error) => {
             try {
               const displayE = 'zone is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-getAllRpzRecords', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getAllRpzRecordsWithQuery', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2936,7 +3629,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createNameServerGroup(null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createNameServerGroup', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createNameServerGroup', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2965,7 +3658,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.getRangeByExtensibleAttribute(null, (data, error) => {
             try {
               const displayE = 'location is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-getRangeByExtensibleAttribute', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getRangeByExtensibleAttributeWithQuery', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -2994,7 +3687,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createRange(null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createRange', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createRange', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -3023,7 +3716,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.getLeaseByIpAddress(null, (data, error) => {
             try {
               const displayE = 'address is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-getLeaseByIpAddress', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getLeaseByIpAddressWithQuery', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -3076,7 +3769,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.getIpAddressUsingSearch(null, (data, error) => {
             try {
               const displayE = 'address is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-getIpAddressUsingSearch', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getIpAddressUsingSearchWithQuery', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -3114,6 +3807,18 @@ describe('[unit] Infoblox Adapter Test', () => {
       }).timeout(attemptTimeout);
     });
 
+    describe('#getNetworkViewWithQuery - errors', () => {
+      it('should have a getNetworkViewWithQuery function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNetworkViewWithQuery === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
     describe('#createNetworkView - errors', () => {
       it('should have a createNetworkView function', (done) => {
         try {
@@ -3129,7 +3834,94 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createNetworkView(null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createNetworkView', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createNetworkView', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNetworkViewById - errors', () => {
+      it('should have a getNetworkViewById function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNetworkViewById === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing viewId', (done) => {
+        try {
+          a.getNetworkViewById(null, null, (data, error) => {
+            try {
+              const displayE = 'viewId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getNetworkViewById', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateNetworkView - errors', () => {
+      it('should have a updateNetworkView function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateNetworkView === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing viewId', (done) => {
+        try {
+          a.updateNetworkView(null, (data, error) => {
+            try {
+              const displayE = 'viewId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-updateNetworkView', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteNetworkView - errors', () => {
+      it('should have a deleteNetworkView function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteNetworkView === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing viewId', (done) => {
+        try {
+          a.deleteNetworkView(null, (data, error) => {
+            try {
+              const displayE = 'viewId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-deleteNetworkView', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -3158,7 +3950,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.getFixedAddressMac(null, (data, error) => {
             try {
               const displayE = 'mac is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-getFixedAddressMac', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getFixedAddressMacWithQuery', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -3187,7 +3979,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createFixedAddress(null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createFixedAddress', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createFixedAddress', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -3228,7 +4020,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createMember(null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createMember', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createMember', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -3254,6 +4046,18 @@ describe('[unit] Infoblox Adapter Test', () => {
       }).timeout(attemptTimeout);
     });
 
+    describe('#getGridStatus - errors', () => {
+      it('should have a getGridStatus function', (done) => {
+        try {
+          assert.equal(true, typeof a.getGridStatus === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
     describe('#getGridPendingChanges - errors', () => {
       it('should have a getGridPendingChanges function', (done) => {
         try {
@@ -3293,7 +4097,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createVdiscoveryTask(null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createVdiscoveryTask', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createVdiscoveryTask', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -3322,7 +4126,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.getPermissionsForARole(null, (data, error) => {
             try {
               const displayE = 'role is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-getPermissionsForARole', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getPermissionsForARoleWithQuery', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -3351,7 +4155,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.getWapiSchema(null, (data, error) => {
             try {
               const displayE = 'schema is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-getWapiSchema', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getWapiSchemaWithQuery', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -3380,7 +4184,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.multipleRecordTypes(null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-multipleRecordTypes', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-multipleRecordTypes', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -3406,6 +4210,18 @@ describe('[unit] Infoblox Adapter Test', () => {
       }).timeout(attemptTimeout);
     });
 
+    describe('#getExtensibleAttributeDefinitionWithQuery - errors', () => {
+      it('should have a getExtensibleAttributeDefinitionWithQuery function', (done) => {
+        try {
+          assert.equal(true, typeof a.getExtensibleAttributeDefinitionWithQuery === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
     describe('#createExtensibleAttributeDefinition - errors', () => {
       it('should have a createExtensibleAttributeDefinition function', (done) => {
         try {
@@ -3421,7 +4237,94 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createExtensibleAttributeDefinition(null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createExtensibleAttributeDefinition', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createExtensibleAttributeDefinition', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getExtensibleAttributeDefinitionById - errors', () => {
+      it('should have a getExtensibleAttributeDefinitionById function', (done) => {
+        try {
+          assert.equal(true, typeof a.getExtensibleAttributeDefinitionById === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing eaId', (done) => {
+        try {
+          a.getExtensibleAttributeDefinitionById(null, {}, (data, error) => {
+            try {
+              const displayE = 'eaId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getExtensibleAttributeDefinitionById', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateExtensibleAttributeDefinition - errors', () => {
+      it('should have a updateExtensibleAttributeDefinition function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateExtensibleAttributeDefinition === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing eaId', (done) => {
+        try {
+          a.updateExtensibleAttributeDefinition(null, (data, error) => {
+            try {
+              const displayE = 'eaId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-updateExtensibleAttributeDefinition', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteExtensibleAttributeDefinition - errors', () => {
+      it('should have a deleteExtensibleAttributeDefinition function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteExtensibleAttributeDefinition === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing eaId', (done) => {
+        try {
+          a.deleteExtensibleAttributeDefinition(null, (data, error) => {
+            try {
+              const displayE = 'eaId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-deleteExtensibleAttributeDefinition', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -3450,7 +4353,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createObject(null, {}, (data, error) => {
             try {
               const displayE = 'objectType is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createObject', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createObject', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -3467,7 +4370,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.createObject('type', null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-createObject', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-createObject', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -3496,7 +4399,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.updateObject(null, {}, (data, error) => {
             try {
               const displayE = 'objectReference is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-updateObject', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-updateObject', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -3532,7 +4435,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.updateObject('type', null, (data, error) => {
             try {
               const displayE = 'body is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-updateObject', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-updateObject', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -3561,7 +4464,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.deleteObject(null, (data, error) => {
             try {
               const displayE = 'objectReference is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-deleteObject', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-deleteObject', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -3609,7 +4512,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.getObject(null, {}, 'field', (data, error) => {
             try {
               const displayE = 'objectType is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-getObject', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getObject', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -3626,7 +4529,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.getObject('type', null, 'field', (data, error) => {
             try {
               const displayE = 'queryObject is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-getObject', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getObject', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -3643,7 +4546,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.getObject('type', {}, null, (data, error) => {
             try {
               const displayE = 'returnFields is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-getObject', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-getObject', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -3672,7 +4575,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.extractObjectTypeFromObjectReference(null, (data, error) => {
             try {
               const displayE = 'objectReference is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-extractObjectTypeFromObjectReference', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-extractObjectTypeFromObjectReference', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -3738,7 +4641,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.restartServices(null, null, (data, error) => {
             try {
               const displayE = 'objectReference is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-restartServices', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-restartServices', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);
@@ -3756,7 +4659,7 @@ describe('[unit] Infoblox Adapter Test', () => {
           a.restartServices(objectReference, null, (data, error) => {
             try {
               const displayE = 'queries is required';
-              runErrorAsserts(data, error, 'AD.300', 'infoblox-adapter-restartServices', displayE);
+              runErrorAsserts(data, error, 'AD.300', 'Test-infoblox-adapter-restartServices', displayE);
               done();
             } catch (err) {
               log.error(`Test Failure: ${err}`);