@itentialopensource/adapter-etsi_sol005 0.1.1

package/test/unit/adapterTestUnit.js

@@ -0,0 +1,4287 @@
+/* @copyright Itential, LLC 2019 (pre-modifications) */
+
+// Set globals
+/* global describe it log pronghornProps */
+/* eslint global-require: warn */
+/* eslint no-unused-vars: warn */
+
+// include required items for testing & logging
+const assert = require('assert');
+const fs = require('fs-extra');
+const mocha = require('mocha');
+const path = require('path');
+const util = require('util');
+const winston = require('winston');
+const execute = require('child_process').execSync;
+const { expect } = require('chai');
+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 = 600000;
+
+// 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;
+
+// these are the adapter properties. You generally should not need to alter
+// any of these after they are initially set up
+global.pronghornProps = {
+  pathProps: {
+    encrypted: false
+  },
+  adapterProps: {
+    adapters: [{
+      id: 'Test-etsi_sol005',
+      type: 'EtsiSol005',
+      properties: {
+        host,
+        port,
+        base_path: '/',
+        version: '',
+        cache_location: 'none',
+        encode_pathvars: true,
+        save_metric: false,
+        stub,
+        protocol,
+        authentication: {
+          auth_method: 'request_token',
+          username,
+          password,
+          token: '',
+          invalid_token_error: 401,
+          token_timeout: 1800000,
+          token_cache: 'local',
+          auth_field: 'header.headers.Authorization',
+          auth_field_format: 'Bearer {token}',
+          auth_logging: false,
+          client_id: '',
+          client_secret: '',
+          grant_type: ''
+        },
+        healthcheck: {
+          type: 'none',
+          frequency: 60000,
+          query_object: {}
+        },
+        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: true,
+          return_raw: true,
+          archiving: false,
+          return_request: false
+        },
+        proxy: {
+          enabled: false,
+          host: '',
+          port: 1,
+          protocol: 'http',
+          username: '',
+          password: ''
+        },
+        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: ''
+          }
+        }
+      }
+    }]
+  }
+};
+
+global.$HOME = `${__dirname}/../..`;
+
+// set the log levels that Pronghorn uses, spam and trace are not defaulted in so without
+// this you may error on log.trace calls.
+const myCustomLevels = {
+  levels: {
+    spam: 6,
+    trace: 5,
+    debug: 4,
+    info: 3,
+    warn: 2,
+    error: 1,
+    none: 0
+  }
+};
+
+// need to see if there is a log level passed in
+process.argv.forEach((val) => {
+  // is there a log level defined to be passed in?
+  if (val.indexOf('--LOG') === 0) {
+    // get the desired log level
+    const inputVal = val.split('=')[1];
+
+    // validate the log level is supported, if so set it
+    if (Object.hasOwnProperty.call(myCustomLevels.levels, inputVal)) {
+      logLevel = inputVal;
+    }
+  }
+});
+
+// need to set global logging
+global.log = winston.createLogger({
+  level: logLevel,
+  levels: myCustomLevels.levels,
+  transports: [
+    new winston.transports.Console()
+  ]
+});
+
+/**
+ * Runs the error asserts for the test
+ */
+function runErrorAsserts(data, error, code, origin, displayStr) {
+  assert.equal(null, data);
+  assert.notEqual(undefined, error);
+  assert.notEqual(null, error);
+  assert.notEqual(undefined, error.IAPerror);
+  assert.notEqual(null, error.IAPerror);
+  assert.notEqual(undefined, error.IAPerror.displayString);
+  assert.notEqual(null, error.IAPerror.displayString);
+  assert.equal(code, error.icode);
+  assert.equal(origin, error.IAPerror.origin);
+  assert.equal(displayStr, error.IAPerror.displayString);
+}
+
+// require the adapter that we are going to be using
+const EtsiSol005 = require('../../adapter');
+
+// delete the .DS_Store directory in entities -- otherwise this will cause errors
+const dirPath = path.join(__dirname, '../../entities/.DS_Store');
+if (fs.existsSync(dirPath)) {
+  try {
+    fs.removeSync(dirPath);
+    console.log('.DS_Store deleted');
+  } catch (e) {
+    console.log('Error when deleting .DS_Store:', e);
+  }
+}
+
+// begin the testing - these should be pretty well defined between the describe and the it!
+describe('[unit] Etsi_sol005 Adapter Test', () => {
+  describe('EtsiSol005 Class Tests', () => {
+    const a = new EtsiSol005(
+      pronghornProps.adapterProps.adapters[0].id,
+      pronghornProps.adapterProps.adapters[0].properties
+    );
+
+    if (isRapidFail) {
+      const state = {};
+      state.passed = true;
+
+      mocha.afterEach(function x() {
+        state.passed = state.passed
+        && (this.currentTest.state === 'passed');
+      });
+      mocha.beforeEach(function x() {
+        if (!state.passed) {
+          return this.currentTest.skip();
+        }
+        return true;
+      });
+    }
+
+    describe('#class instance created', () => {
+      it('should be a class with properties', (done) => {
+        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);
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('adapterBase.js', () => {
+      it('should have an adapterBase.js', (done) => {
+        try {
+          fs.exists('adapterBase.js', (val) => {
+            assert.equal(true, val);
+            done();
+          });
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    let wffunctions = [];
+    describe('#getWorkflowFunctions', () => {
+      it('should retrieve workflow functions', (done) => {
+        try {
+          wffunctions = a.getWorkflowFunctions([]);
+
+          try {
+            assert.notEqual(0, wffunctions.length);
+            done();
+          } catch (err) {
+            log.error(`Test Failure: ${err}`);
+            done(err);
+          }
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('package.json', () => {
+      it('should have a package.json', (done) => {
+        try {
+          fs.exists('package.json', (val) => {
+            assert.equal(true, val);
+            done();
+          });
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+      it('package.json should be validated', (done) => {
+        try {
+          const packageDotJson = require('../../package.json');
+          const { PJV } = require('package-json-validator');
+          const options = {
+            warnings: true, // show warnings
+            recommendations: true // show recommendations
+          };
+          const results = PJV.validate(JSON.stringify(packageDotJson), 'npm', options);
+
+          if (results.valid === false) {
+            log.error('The package.json contains the following errors: ');
+            log.error(util.inspect(results));
+            assert.equal(true, results.valid);
+          } else {
+            assert.equal(true, results.valid);
+          }
+
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+      it('package.json standard fields should be customized', (done) => {
+        try {
+          const packageDotJson = require('../../package.json');
+          assert.notEqual(-1, packageDotJson.name.indexOf('etsi_sol005'));
+          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}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('pronghorn.json', () => {
+      it('should have a pronghorn.json', (done) => {
+        try {
+          fs.exists('pronghorn.json', (val) => {
+            assert.equal(true, val);
+            done();
+          });
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+      it('pronghorn.json should be customized', (done) => {
+        try {
+          const pronghornDotJson = require('../../pronghorn.json');
+          assert.notEqual(-1, pronghornDotJson.id.indexOf('etsi_sol005'));
+          assert.equal('Adapter', pronghornDotJson.type);
+          assert.equal('EtsiSol005', pronghornDotJson.export);
+          assert.equal('Etsi_sol005', 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 === 'updateAdapterConfiguration'));
+          assert.notEqual(undefined, pronghornDotJson.methods.find((e) => e.name === 'findPath'));
+          assert.notEqual(undefined, pronghornDotJson.methods.find((e) => e.name === 'troubleshoot'));
+          assert.notEqual(undefined, pronghornDotJson.methods.find((e) => e.name === 'runHealthcheck'));
+          assert.notEqual(undefined, pronghornDotJson.methods.find((e) => e.name === 'runConnectivity'));
+          assert.notEqual(undefined, pronghornDotJson.methods.find((e) => e.name === 'runBasicGet'));
+          assert.notEqual(undefined, pronghornDotJson.methods.find((e) => e.name === 'suspend'));
+          assert.notEqual(undefined, pronghornDotJson.methods.find((e) => e.name === 'unsuspend'));
+          assert.notEqual(undefined, pronghornDotJson.methods.find((e) => e.name === 'getQueue'));
+          assert.notEqual(undefined, pronghornDotJson.methods.find((e) => e.name === 'genericAdapterRequest'));
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+      it('pronghorn.json should only expose workflow functions', (done) => {
+        try {
+          const pronghornDotJson = require('../../pronghorn.json');
+
+          for (let m = 0; m < pronghornDotJson.methods.length; m += 1) {
+            let found = false;
+            let paramissue = false;
+
+            for (let w = 0; w < wffunctions.length; w += 1) {
+              if (pronghornDotJson.methods[m].name === wffunctions[w]) {
+                found = true;
+                const methLine = execute(`grep "  ${wffunctions[w]}(" adapter.js | grep "callback) {"`).toString();
+                let wfparams = [];
+
+                if (methLine && methLine.indexOf('(') >= 0 && methLine.indexOf(')') >= 0) {
+                  const temp = methLine.substring(methLine.indexOf('(') + 1, methLine.lastIndexOf(')'));
+                  wfparams = temp.split(',');
+
+                  for (let t = 0; t < wfparams.length; t += 1) {
+                    // remove default value from the parameter name
+                    wfparams[t] = wfparams[t].substring(0, wfparams[t].search(/=/) > 0 ? wfparams[t].search(/#|\?|=/) : wfparams[t].length);
+                    // remove spaces
+                    wfparams[t] = wfparams[t].trim();
+
+                    if (wfparams[t] === 'callback') {
+                      wfparams.splice(t, 1);
+                    }
+                  }
+                }
+
+                // if there are inputs defined but not on the method line
+                if (wfparams.length === 0 && (pronghornDotJson.methods[m].input
+                    && pronghornDotJson.methods[m].input.length > 0)) {
+                  paramissue = true;
+                } else if (wfparams.length > 0 && (!pronghornDotJson.methods[m].input
+                    || pronghornDotJson.methods[m].input.length === 0)) {
+                  // if there are no inputs defined but there are on the method line
+                  paramissue = true;
+                } else {
+                  for (let p = 0; p < pronghornDotJson.methods[m].input.length; p += 1) {
+                    let pfound = false;
+                    for (let wfp = 0; wfp < wfparams.length; wfp += 1) {
+                      if (pronghornDotJson.methods[m].input[p].name.toUpperCase() === wfparams[wfp].toUpperCase()) {
+                        pfound = true;
+                      }
+                    }
+
+                    if (!pfound) {
+                      paramissue = true;
+                    }
+                  }
+                  for (let wfp = 0; wfp < wfparams.length; wfp += 1) {
+                    let pfound = false;
+                    for (let p = 0; p < pronghornDotJson.methods[m].input.length; p += 1) {
+                      if (pronghornDotJson.methods[m].input[p].name.toUpperCase() === wfparams[wfp].toUpperCase()) {
+                        pfound = true;
+                      }
+                    }
+
+                    if (!pfound) {
+                      paramissue = true;
+                    }
+                  }
+                }
+
+                break;
+              }
+            }
+
+            if (!found) {
+              // this is the reason to go through both loops - log which ones are not found so
+              // they can be worked
+              log.error(`${pronghornDotJson.methods[m].name} not found in workflow functions`);
+            }
+            if (paramissue) {
+              // this is the reason to go through both loops - log which ones are not found so
+              // they can be worked
+              log.error(`${pronghornDotJson.methods[m].name} has a parameter mismatch`);
+            }
+            assert.equal(true, found);
+            assert.equal(false, paramissue);
+          }
+          done();
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('pronghorn.json should expose all workflow functions', (done) => {
+        try {
+          const pronghornDotJson = require('../../pronghorn.json');
+          for (let w = 0; w < wffunctions.length; w += 1) {
+            let found = false;
+
+            for (let m = 0; m < pronghornDotJson.methods.length; m += 1) {
+              if (pronghornDotJson.methods[m].name === wffunctions[w]) {
+                found = true;
+                break;
+              }
+            }
+
+            if (!found) {
+              // this is the reason to go through both loops - log which ones are not found so
+              // they can be worked
+              log.error(`${wffunctions[w]} not found in pronghorn.json`);
+            }
+            assert.equal(true, found);
+          }
+          done();
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('propertiesSchema.json', () => {
+      it('should have a propertiesSchema.json', (done) => {
+        try {
+          fs.exists('propertiesSchema.json', (val) => {
+            assert.equal(true, val);
+            done();
+          });
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+      it('propertiesSchema.json should be customized', (done) => {
+        try {
+          const propertiesDotJson = require('../../propertiesSchema.json');
+          assert.equal('adapter-etsi_sol005', 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('', 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(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.ssl);
+          assert.notEqual(null, propertiesDotJson.definitions.ssl);
+          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);
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('error.json', () => {
+      it('should have an error.json', (done) => {
+        try {
+          fs.exists('error.json', (val) => {
+            assert.equal(true, val);
+            done();
+          });
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          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', () => {
+      it('should have a sampleProperties.json', (done) => {
+        try {
+          fs.exists('sampleProperties.json', (val) => {
+            assert.equal(true, val);
+            done();
+          });
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+      it('sampleProperties.json should contain generic adapter properties', (done) => {
+        try {
+          const sampleDotJson = require('../../sampleProperties.json');
+          assert.notEqual(-1, sampleDotJson.id.indexOf('etsi_sol005'));
+          assert.equal('EtsiSol005', 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.save_metric);
+          assert.notEqual(undefined, sampleDotJson.properties.protocol);
+          assert.notEqual(undefined, sampleDotJson.properties.stub);
+          assert.notEqual(undefined, sampleDotJson.properties.stub);
+          assert.notEqual(undefined, sampleDotJson.properties.stub);
+          assert.notEqual(undefined, sampleDotJson.properties.stub);
+          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);
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#checkProperties', () => {
+      it('should have a checkProperties function', (done) => {
+        try {
+          assert.equal(true, typeof a.checkProperties === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+      it('the sample properties should be good - if failure change the log level', (done) => {
+        try {
+          const samplePropsJson = require('../../sampleProperties.json');
+          const clean = a.checkProperties(samplePropsJson.properties);
+
+          try {
+            assert.notEqual(0, Object.keys(clean));
+            assert.equal(undefined, clean.exception);
+            assert.notEqual(undefined, clean.host);
+            assert.notEqual(null, clean.host);
+            assert.notEqual('', clean.host);
+            done();
+          } catch (err) {
+            log.error(`Test Failure: ${err}`);
+            done(err);
+          }
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('README.md', () => {
+      it('should have a README', (done) => {
+        try {
+          fs.exists('README.md', (val) => {
+            assert.equal(true, val);
+            done();
+          });
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+      it('README.md should be customized', (done) => {
+        try {
+          fs.readFile('README.md', 'utf8', (err, data) => {
+            assert.equal(-1, data.indexOf('[System]'));
+            assert.equal(-1, data.indexOf('[system]'));
+            assert.equal(-1, data.indexOf('[version]'));
+            assert.equal(-1, data.indexOf('[namespace]'));
+            done();
+          });
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#connect', () => {
+      it('should have a connect function', (done) => {
+        try {
+          assert.equal(true, typeof a.connect === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#healthCheck', () => {
+      it('should have a healthCheck function', (done) => {
+        try {
+          assert.equal(true, typeof a.healthCheck === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#updateAdapterConfiguration', () => {
+      it('should have a updateAdapterConfiguration function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateAdapterConfiguration === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#findPath', () => {
+      it('should have a findPath function', (done) => {
+        try {
+          assert.equal(true, typeof a.findPath === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+      it('findPath should find atleast one path that matches', (done) => {
+        try {
+          a.findPath('{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('#suspend', () => {
+      it('should have a suspend function', (done) => {
+        try {
+          assert.equal(true, typeof a.suspend === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#unsuspend', () => {
+      it('should have a unsuspend function', (done) => {
+        try {
+          assert.equal(true, typeof a.unsuspend === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#getQueue', () => {
+      it('should have a getQueue function', (done) => {
+        try {
+          assert.equal(true, typeof a.getQueue === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#troubleshoot', () => {
+      it('should have a troubleshoot function', (done) => {
+        try {
+          assert.equal(true, typeof a.troubleshoot === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#runHealthcheck', () => {
+      it('should have a runHealthcheck function', (done) => {
+        try {
+          assert.equal(true, typeof a.runHealthcheck === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#runConnectivity', () => {
+      it('should have a runConnectivity function', (done) => {
+        try {
+          assert.equal(true, typeof a.runConnectivity === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#runBasicGet', () => {
+      it('should have a runBasicGet function', (done) => {
+        try {
+          assert.equal(true, typeof a.runBasicGet === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#moveEntitiesToDB', () => {
+      it('should have a moveEntitiesToDB function', (done) => {
+        try {
+          assert.equal(true, typeof a.moveEntitiesToDB === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#checkActionFiles', () => {
+      it('should have a checkActionFiles function', (done) => {
+        try {
+          assert.equal(true, typeof a.checkActionFiles === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+      it('the action files should be good - if failure change the log level as most issues are warnings', (done) => {
+        try {
+          const clean = a.checkActionFiles();
+
+          try {
+            for (let c = 0; c < clean.length; c += 1) {
+              log.error(clean[c]);
+            }
+            assert.equal(0, clean.length);
+            done();
+          } catch (err) {
+            log.error(`Test Failure: ${err}`);
+            done(err);
+          }
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#encryptProperty', () => {
+      it('should have a encryptProperty function', (done) => {
+        try {
+          assert.equal(true, typeof a.encryptProperty === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+      it('should get base64 encoded property', (done) => {
+        try {
+          a.encryptProperty('testing', 'base64', (data, error) => {
+            try {
+              assert.equal(undefined, error);
+              assert.notEqual(undefined, data);
+              assert.notEqual(null, data);
+              assert.notEqual(undefined, data.response);
+              assert.notEqual(null, data.response);
+              assert.equal(0, data.response.indexOf('{code}'));
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should get encrypted property', (done) => {
+        try {
+          a.encryptProperty('testing', 'encrypt', (data, error) => {
+            try {
+              assert.equal(undefined, error);
+              assert.notEqual(undefined, data);
+              assert.notEqual(null, data);
+              assert.notEqual(undefined, data.response);
+              assert.notEqual(null, data.response);
+              assert.equal(0, data.response.indexOf('{crypt}'));
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    // describe('#hasEntity', () => {
+    //   it('should have a hasEntity function', (done) => {
+    //     try {
+    //       assert.equal(true, typeof a.hasEntity === 'function');
+    //       done();
+    //     } catch (error) {
+    //       log.error(`Test Failure: ${error}`);
+    //       done(error);
+    //     }
+    //   });
+    //   it('should find entity', (done) => {
+    //     try {
+    //       a.hasEntity('template_entity', // 'a9e9c33dc61122760072455df62663d2', (data) => {
+    //         try {
+    //           assert.equal(true, data[0]);
+    //           done();
+    //         } catch (err) {
+    //           log.error(`Test Failure: ${err}`);
+    //           done(err);
+    //         }
+    //       });
+    //     } catch (error) {
+    //       log.error(`Adapter Exception: ${error}`);
+    //       done(error);
+    //     }
+    //   }).timeout(attemptTimeout);
+    //   it('should not find entity', (done) => {
+    //     try {
+    //       a.hasEntity('template_entity', 'blah', (data) => {
+    //         try {
+    //           assert.equal(false, data[0]);
+    //           done();
+    //         } catch (err) {
+    //           log.error(`Test Failure: ${err}`);
+    //           done(err);
+    //         }
+    //       });
+    //     } catch (error) {
+    //       log.error(`Adapter Exception: ${error}`);
+    //       done(error);
+    //     }
+    //   }).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('#hasDevices', () => {
+      it('should have a hasDevices function', (done) => {
+        try {
+          assert.equal(true, typeof a.hasDevices === '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('#getCount', () => {
+      it('should have a getCount function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCount === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    /*
+    -----------------------------------------------------------------------
+    -----------------------------------------------------------------------
+    *** All code above this comment will be replaced during a migration ***
+    ******************* DO NOT REMOVE THIS COMMENT BLOCK ******************
+    -----------------------------------------------------------------------
+    -----------------------------------------------------------------------
+    */
+
+    describe('#getApiVersions - errors', () => {
+      it('should have a getApiVersions function', (done) => {
+        try {
+          assert.equal(true, typeof a.getApiVersions === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postNsDescriptors - errors', () => {
+      it('should have a postNsDescriptors function', (done) => {
+        try {
+          assert.equal(true, typeof a.postNsDescriptors === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.postNsDescriptors(null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-postNsDescriptors', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNsDescriptors - errors', () => {
+      it('should have a getNsDescriptors function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNsDescriptors === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNsDescriptorsNsdInfoId - errors', () => {
+      it('should have a getNsDescriptorsNsdInfoId function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNsDescriptorsNsdInfoId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing nsdInfoId', (done) => {
+        try {
+          a.getNsDescriptorsNsdInfoId(null, (data, error) => {
+            try {
+              const displayE = 'nsdInfoId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getNsDescriptorsNsdInfoId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchNsDescriptorsNsdInfoId - errors', () => {
+      it('should have a patchNsDescriptorsNsdInfoId function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchNsDescriptorsNsdInfoId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing nsdInfoId', (done) => {
+        try {
+          a.patchNsDescriptorsNsdInfoId(null, null, (data, error) => {
+            try {
+              const displayE = 'nsdInfoId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-patchNsDescriptorsNsdInfoId', 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.patchNsDescriptorsNsdInfoId('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-patchNsDescriptorsNsdInfoId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteNsDescriptorsNsdInfoId - errors', () => {
+      it('should have a deleteNsDescriptorsNsdInfoId function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteNsDescriptorsNsdInfoId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing nsdInfoId', (done) => {
+        try {
+          a.deleteNsDescriptorsNsdInfoId(null, (data, error) => {
+            try {
+              const displayE = 'nsdInfoId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-deleteNsDescriptorsNsdInfoId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNsDescriptorsNsdInfoIdNsdContent - errors', () => {
+      it('should have a getNsDescriptorsNsdInfoIdNsdContent function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNsDescriptorsNsdInfoIdNsdContent === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing nsdInfoId', (done) => {
+        try {
+          a.getNsDescriptorsNsdInfoIdNsdContent(null, (data, error) => {
+            try {
+              const displayE = 'nsdInfoId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getNsDescriptorsNsdInfoIdNsdContent', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#putNsDescriptorsNsdInfoIdNsdContent - errors', () => {
+      it('should have a putNsDescriptorsNsdInfoIdNsdContent function', (done) => {
+        try {
+          assert.equal(true, typeof a.putNsDescriptorsNsdInfoIdNsdContent === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing nsdInfoId', (done) => {
+        try {
+          a.putNsDescriptorsNsdInfoIdNsdContent(null, (data, error) => {
+            try {
+              const displayE = 'nsdInfoId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-putNsDescriptorsNsdInfoIdNsdContent', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNsDescriptorsNsdInfoIdNsd - errors', () => {
+      it('should have a getNsDescriptorsNsdInfoIdNsd function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNsDescriptorsNsdInfoIdNsd === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing nsdInfoId', (done) => {
+        try {
+          a.getNsDescriptorsNsdInfoIdNsd(null, null, (data, error) => {
+            try {
+              const displayE = 'nsdInfoId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getNsDescriptorsNsdInfoIdNsd', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNsDescriptorsNsdInfoIdManifest - errors', () => {
+      it('should have a getNsDescriptorsNsdInfoIdManifest function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNsDescriptorsNsdInfoIdManifest === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing nsdInfoId', (done) => {
+        try {
+          a.getNsDescriptorsNsdInfoIdManifest(null, null, (data, error) => {
+            try {
+              const displayE = 'nsdInfoId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getNsDescriptorsNsdInfoIdManifest', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNsDescriptorsNsdInfoIdArtifactsArtifactPath - errors', () => {
+      it('should have a getNsDescriptorsNsdInfoIdArtifactsArtifactPath function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNsDescriptorsNsdInfoIdArtifactsArtifactPath === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing nsdInfoId', (done) => {
+        try {
+          a.getNsDescriptorsNsdInfoIdArtifactsArtifactPath(null, null, null, (data, error) => {
+            try {
+              const displayE = 'nsdInfoId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getNsDescriptorsNsdInfoIdArtifactsArtifactPath', 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 artifactPath', (done) => {
+        try {
+          a.getNsDescriptorsNsdInfoIdArtifactsArtifactPath('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'artifactPath is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getNsDescriptorsNsdInfoIdArtifactsArtifactPath', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postPnfDescriptors - errors', () => {
+      it('should have a postPnfDescriptors function', (done) => {
+        try {
+          assert.equal(true, typeof a.postPnfDescriptors === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.postPnfDescriptors(null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-postPnfDescriptors', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getPnfDescriptors - errors', () => {
+      it('should have a getPnfDescriptors function', (done) => {
+        try {
+          assert.equal(true, typeof a.getPnfDescriptors === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getPnfDescriptorsPnfdInfoId - errors', () => {
+      it('should have a getPnfDescriptorsPnfdInfoId function', (done) => {
+        try {
+          assert.equal(true, typeof a.getPnfDescriptorsPnfdInfoId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing pnfdInfoId', (done) => {
+        try {
+          a.getPnfDescriptorsPnfdInfoId(null, (data, error) => {
+            try {
+              const displayE = 'pnfdInfoId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getPnfDescriptorsPnfdInfoId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchPnfDescriptorsPnfdInfoId - errors', () => {
+      it('should have a patchPnfDescriptorsPnfdInfoId function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchPnfDescriptorsPnfdInfoId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing pnfdInfoId', (done) => {
+        try {
+          a.patchPnfDescriptorsPnfdInfoId(null, null, (data, error) => {
+            try {
+              const displayE = 'pnfdInfoId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-patchPnfDescriptorsPnfdInfoId', 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.patchPnfDescriptorsPnfdInfoId('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-patchPnfDescriptorsPnfdInfoId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deletePnfDescriptorsPnfdInfoId - errors', () => {
+      it('should have a deletePnfDescriptorsPnfdInfoId function', (done) => {
+        try {
+          assert.equal(true, typeof a.deletePnfDescriptorsPnfdInfoId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing pnfdInfoId', (done) => {
+        try {
+          a.deletePnfDescriptorsPnfdInfoId(null, (data, error) => {
+            try {
+              const displayE = 'pnfdInfoId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-deletePnfDescriptorsPnfdInfoId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getPnfDescriptorsPnfdInfoIdPnfdContent - errors', () => {
+      it('should have a getPnfDescriptorsPnfdInfoIdPnfdContent function', (done) => {
+        try {
+          assert.equal(true, typeof a.getPnfDescriptorsPnfdInfoIdPnfdContent === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing pnfdInfoId', (done) => {
+        try {
+          a.getPnfDescriptorsPnfdInfoIdPnfdContent(null, (data, error) => {
+            try {
+              const displayE = 'pnfdInfoId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getPnfDescriptorsPnfdInfoIdPnfdContent', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#putPnfDescriptorsPnfdInfoIdPnfdContent - errors', () => {
+      it('should have a putPnfDescriptorsPnfdInfoIdPnfdContent function', (done) => {
+        try {
+          assert.equal(true, typeof a.putPnfDescriptorsPnfdInfoIdPnfdContent === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing pnfdInfoId', (done) => {
+        try {
+          a.putPnfDescriptorsPnfdInfoIdPnfdContent(null, (data, error) => {
+            try {
+              const displayE = 'pnfdInfoId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-putPnfDescriptorsPnfdInfoIdPnfdContent', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getPnfDescriptorsPnfdInfoIdPnfd - errors', () => {
+      it('should have a getPnfDescriptorsPnfdInfoIdPnfd function', (done) => {
+        try {
+          assert.equal(true, typeof a.getPnfDescriptorsPnfdInfoIdPnfd === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing pnfdInfoId', (done) => {
+        try {
+          a.getPnfDescriptorsPnfdInfoIdPnfd(null, null, (data, error) => {
+            try {
+              const displayE = 'pnfdInfoId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getPnfDescriptorsPnfdInfoIdPnfd', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getPnfDescriptorsPnfdInfoIdManifest - errors', () => {
+      it('should have a getPnfDescriptorsPnfdInfoIdManifest function', (done) => {
+        try {
+          assert.equal(true, typeof a.getPnfDescriptorsPnfdInfoIdManifest === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing pnfdInfoId', (done) => {
+        try {
+          a.getPnfDescriptorsPnfdInfoIdManifest(null, null, (data, error) => {
+            try {
+              const displayE = 'pnfdInfoId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getPnfDescriptorsPnfdInfoIdManifest', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getPnfDescriptorsPnfdInfoIdArtifactsArtifactPath - errors', () => {
+      it('should have a getPnfDescriptorsPnfdInfoIdArtifactsArtifactPath function', (done) => {
+        try {
+          assert.equal(true, typeof a.getPnfDescriptorsPnfdInfoIdArtifactsArtifactPath === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing pnfdInfoId', (done) => {
+        try {
+          a.getPnfDescriptorsPnfdInfoIdArtifactsArtifactPath(null, null, null, (data, error) => {
+            try {
+              const displayE = 'pnfdInfoId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getPnfDescriptorsPnfdInfoIdArtifactsArtifactPath', 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 artifactPath', (done) => {
+        try {
+          a.getPnfDescriptorsPnfdInfoIdArtifactsArtifactPath('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'artifactPath is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getPnfDescriptorsPnfdInfoIdArtifactsArtifactPath', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postSubscriptions - errors', () => {
+      it('should have a postSubscriptions function', (done) => {
+        try {
+          assert.equal(true, typeof a.postSubscriptions === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.postSubscriptions(null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-postSubscriptions', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSubscriptions - errors', () => {
+      it('should have a getSubscriptions function', (done) => {
+        try {
+          assert.equal(true, typeof a.getSubscriptions === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSubscriptionsSubscriptionId - errors', () => {
+      it('should have a getSubscriptionsSubscriptionId function', (done) => {
+        try {
+          assert.equal(true, typeof a.getSubscriptionsSubscriptionId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing subscriptionId', (done) => {
+        try {
+          a.getSubscriptionsSubscriptionId(null, (data, error) => {
+            try {
+              const displayE = 'subscriptionId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getSubscriptionsSubscriptionId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteSubscriptionsSubscriptionId - errors', () => {
+      it('should have a deleteSubscriptionsSubscriptionId function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteSubscriptionsSubscriptionId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing subscriptionId', (done) => {
+        try {
+          a.deleteSubscriptionsSubscriptionId(null, (data, error) => {
+            try {
+              const displayE = 'subscriptionId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-deleteSubscriptionsSubscriptionId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAlarms - errors', () => {
+      it('should have a getAlarms function', (done) => {
+        try {
+          assert.equal(true, typeof a.getAlarms === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAlarmsAlarmId - errors', () => {
+      it('should have a getAlarmsAlarmId function', (done) => {
+        try {
+          assert.equal(true, typeof a.getAlarmsAlarmId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing alarmId', (done) => {
+        try {
+          a.getAlarmsAlarmId(null, (data, error) => {
+            try {
+              const displayE = 'alarmId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getAlarmsAlarmId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchAlarmsAlarmId - errors', () => {
+      it('should have a patchAlarmsAlarmId function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchAlarmsAlarmId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing alarmId', (done) => {
+        try {
+          a.patchAlarmsAlarmId(null, null, (data, error) => {
+            try {
+              const displayE = 'alarmId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-patchAlarmsAlarmId', 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.patchAlarmsAlarmId('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-patchAlarmsAlarmId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getVnfPackages - errors', () => {
+      it('should have a getVnfPackages function', (done) => {
+        try {
+          assert.equal(true, typeof a.getVnfPackages === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postVnfPackages - errors', () => {
+      it('should have a postVnfPackages function', (done) => {
+        try {
+          assert.equal(true, typeof a.postVnfPackages === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.postVnfPackages(null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-postVnfPackages', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getVnfPackagesVnfPkgId - errors', () => {
+      it('should have a getVnfPackagesVnfPkgId function', (done) => {
+        try {
+          assert.equal(true, typeof a.getVnfPackagesVnfPkgId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing vnfPkgId', (done) => {
+        try {
+          a.getVnfPackagesVnfPkgId(null, (data, error) => {
+            try {
+              const displayE = 'vnfPkgId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getVnfPackagesVnfPkgId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteVnfPackagesVnfPkgId - errors', () => {
+      it('should have a deleteVnfPackagesVnfPkgId function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteVnfPackagesVnfPkgId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing vnfPkgId', (done) => {
+        try {
+          a.deleteVnfPackagesVnfPkgId(null, (data, error) => {
+            try {
+              const displayE = 'vnfPkgId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-deleteVnfPackagesVnfPkgId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchVnfPackagesVnfPkgId - errors', () => {
+      it('should have a patchVnfPackagesVnfPkgId function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchVnfPackagesVnfPkgId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing vnfPkgId', (done) => {
+        try {
+          a.patchVnfPackagesVnfPkgId(null, null, (data, error) => {
+            try {
+              const displayE = 'vnfPkgId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-patchVnfPackagesVnfPkgId', 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.patchVnfPackagesVnfPkgId('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-patchVnfPackagesVnfPkgId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getVnfPackagesVnfPkgIdVnfd - errors', () => {
+      it('should have a getVnfPackagesVnfPkgIdVnfd function', (done) => {
+        try {
+          assert.equal(true, typeof a.getVnfPackagesVnfPkgIdVnfd === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing vnfPkgId', (done) => {
+        try {
+          a.getVnfPackagesVnfPkgIdVnfd(null, null, (data, error) => {
+            try {
+              const displayE = 'vnfPkgId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getVnfPackagesVnfPkgIdVnfd', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getVnfPackagesVnfPkgIdExtArtifactsAccess - errors', () => {
+      it('should have a getVnfPackagesVnfPkgIdExtArtifactsAccess function', (done) => {
+        try {
+          assert.equal(true, typeof a.getVnfPackagesVnfPkgIdExtArtifactsAccess === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing vnfPkgId', (done) => {
+        try {
+          a.getVnfPackagesVnfPkgIdExtArtifactsAccess(null, (data, error) => {
+            try {
+              const displayE = 'vnfPkgId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getVnfPackagesVnfPkgIdExtArtifactsAccess', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#putVnfPackagesVnfPkgIdExtArtifactsAccess - errors', () => {
+      it('should have a putVnfPackagesVnfPkgIdExtArtifactsAccess function', (done) => {
+        try {
+          assert.equal(true, typeof a.putVnfPackagesVnfPkgIdExtArtifactsAccess === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing vnfPkgId', (done) => {
+        try {
+          a.putVnfPackagesVnfPkgIdExtArtifactsAccess(null, null, (data, error) => {
+            try {
+              const displayE = 'vnfPkgId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-putVnfPackagesVnfPkgIdExtArtifactsAccess', 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.putVnfPackagesVnfPkgIdExtArtifactsAccess('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-putVnfPackagesVnfPkgIdExtArtifactsAccess', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getVnfPackagesVnfPkgIdManifest - errors', () => {
+      it('should have a getVnfPackagesVnfPkgIdManifest function', (done) => {
+        try {
+          assert.equal(true, typeof a.getVnfPackagesVnfPkgIdManifest === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing vnfPkgId', (done) => {
+        try {
+          a.getVnfPackagesVnfPkgIdManifest(null, null, (data, error) => {
+            try {
+              const displayE = 'vnfPkgId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getVnfPackagesVnfPkgIdManifest', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getVnfPackagesVnfPkgIdPackageContent - errors', () => {
+      it('should have a getVnfPackagesVnfPkgIdPackageContent function', (done) => {
+        try {
+          assert.equal(true, typeof a.getVnfPackagesVnfPkgIdPackageContent === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing vnfPkgId', (done) => {
+        try {
+          a.getVnfPackagesVnfPkgIdPackageContent(null, (data, error) => {
+            try {
+              const displayE = 'vnfPkgId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getVnfPackagesVnfPkgIdPackageContent', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#putVnfPackagesVnfPkgIdPackageContent - errors', () => {
+      it('should have a putVnfPackagesVnfPkgIdPackageContent function', (done) => {
+        try {
+          assert.equal(true, typeof a.putVnfPackagesVnfPkgIdPackageContent === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing vnfPkgId', (done) => {
+        try {
+          a.putVnfPackagesVnfPkgIdPackageContent(null, null, (data, error) => {
+            try {
+              const displayE = 'vnfPkgId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-putVnfPackagesVnfPkgIdPackageContent', 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.putVnfPackagesVnfPkgIdPackageContent('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-putVnfPackagesVnfPkgIdPackageContent', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getVnfPackagesVnfPkgIdArtifacts - errors', () => {
+      it('should have a getVnfPackagesVnfPkgIdArtifacts function', (done) => {
+        try {
+          assert.equal(true, typeof a.getVnfPackagesVnfPkgIdArtifacts === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing vnfPkgId', (done) => {
+        try {
+          a.getVnfPackagesVnfPkgIdArtifacts(null, null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'vnfPkgId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getVnfPackagesVnfPkgIdArtifacts', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postVnfPackagesVnfPkgIdPackageContentUploadFromUri - errors', () => {
+      it('should have a postVnfPackagesVnfPkgIdPackageContentUploadFromUri function', (done) => {
+        try {
+          assert.equal(true, typeof a.postVnfPackagesVnfPkgIdPackageContentUploadFromUri === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing vnfPkgId', (done) => {
+        try {
+          a.postVnfPackagesVnfPkgIdPackageContentUploadFromUri(null, null, (data, error) => {
+            try {
+              const displayE = 'vnfPkgId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-postVnfPackagesVnfPkgIdPackageContentUploadFromUri', 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.postVnfPackagesVnfPkgIdPackageContentUploadFromUri('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-postVnfPackagesVnfPkgIdPackageContentUploadFromUri', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getVnfPackagesVnfPkgIdArtifactsArtifactPath - errors', () => {
+      it('should have a getVnfPackagesVnfPkgIdArtifactsArtifactPath function', (done) => {
+        try {
+          assert.equal(true, typeof a.getVnfPackagesVnfPkgIdArtifactsArtifactPath === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing vnfPkgId', (done) => {
+        try {
+          a.getVnfPackagesVnfPkgIdArtifactsArtifactPath(null, null, null, (data, error) => {
+            try {
+              const displayE = 'vnfPkgId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getVnfPackagesVnfPkgIdArtifactsArtifactPath', 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 artifactPath', (done) => {
+        try {
+          a.getVnfPackagesVnfPkgIdArtifactsArtifactPath('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'artifactPath is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getVnfPackagesVnfPkgIdArtifactsArtifactPath', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postPmJobs - errors', () => {
+      it('should have a postPmJobs function', (done) => {
+        try {
+          assert.equal(true, typeof a.postPmJobs === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.postPmJobs(null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-postPmJobs', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getPmJobs - errors', () => {
+      it('should have a getPmJobs function', (done) => {
+        try {
+          assert.equal(true, typeof a.getPmJobs === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getPmJobsPmJobId - errors', () => {
+      it('should have a getPmJobsPmJobId function', (done) => {
+        try {
+          assert.equal(true, typeof a.getPmJobsPmJobId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing pmJobId', (done) => {
+        try {
+          a.getPmJobsPmJobId(null, (data, error) => {
+            try {
+              const displayE = 'pmJobId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getPmJobsPmJobId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchPmJobsPmJobId - errors', () => {
+      it('should have a patchPmJobsPmJobId function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchPmJobsPmJobId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing pmJobId', (done) => {
+        try {
+          a.patchPmJobsPmJobId(null, null, (data, error) => {
+            try {
+              const displayE = 'pmJobId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-patchPmJobsPmJobId', 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.patchPmJobsPmJobId('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-patchPmJobsPmJobId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deletePmJobsPmJobId - errors', () => {
+      it('should have a deletePmJobsPmJobId function', (done) => {
+        try {
+          assert.equal(true, typeof a.deletePmJobsPmJobId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing pmJobId', (done) => {
+        try {
+          a.deletePmJobsPmJobId(null, (data, error) => {
+            try {
+              const displayE = 'pmJobId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-deletePmJobsPmJobId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getPmJobsPmJobIdReportsReportId - errors', () => {
+      it('should have a getPmJobsPmJobIdReportsReportId function', (done) => {
+        try {
+          assert.equal(true, typeof a.getPmJobsPmJobIdReportsReportId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing pmJobId', (done) => {
+        try {
+          a.getPmJobsPmJobIdReportsReportId(null, null, (data, error) => {
+            try {
+              const displayE = 'pmJobId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getPmJobsPmJobIdReportsReportId', 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 reportId', (done) => {
+        try {
+          a.getPmJobsPmJobIdReportsReportId('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'reportId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getPmJobsPmJobIdReportsReportId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postThresholds - errors', () => {
+      it('should have a postThresholds function', (done) => {
+        try {
+          assert.equal(true, typeof a.postThresholds === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.postThresholds(null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-postThresholds', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getThresholds - errors', () => {
+      it('should have a getThresholds function', (done) => {
+        try {
+          assert.equal(true, typeof a.getThresholds === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getThresholdsThresholdId - errors', () => {
+      it('should have a getThresholdsThresholdId function', (done) => {
+        try {
+          assert.equal(true, typeof a.getThresholdsThresholdId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing thresholdId', (done) => {
+        try {
+          a.getThresholdsThresholdId(null, (data, error) => {
+            try {
+              const displayE = 'thresholdId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getThresholdsThresholdId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchThresholdsThresholdId - errors', () => {
+      it('should have a patchThresholdsThresholdId function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchThresholdsThresholdId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing thresholdId', (done) => {
+        try {
+          a.patchThresholdsThresholdId(null, null, (data, error) => {
+            try {
+              const displayE = 'thresholdId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-patchThresholdsThresholdId', 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.patchThresholdsThresholdId('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-patchThresholdsThresholdId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteThresholdsThresholdId - errors', () => {
+      it('should have a deleteThresholdsThresholdId function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteThresholdsThresholdId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing thresholdId', (done) => {
+        try {
+          a.deleteThresholdsThresholdId(null, (data, error) => {
+            try {
+              const displayE = 'thresholdId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-deleteThresholdsThresholdId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNfviCapacityInfos - errors', () => {
+      it('should have a getNfviCapacityInfos function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNfviCapacityInfos === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNfviCapacityInfosVimId - errors', () => {
+      it('should have a getNfviCapacityInfosVimId function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNfviCapacityInfosVimId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing vimId', (done) => {
+        try {
+          a.getNfviCapacityInfosVimId(null, null, (data, error) => {
+            try {
+              const displayE = 'vimId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getNfviCapacityInfosVimId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getCapacityThresholds - errors', () => {
+      it('should have a getCapacityThresholds function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCapacityThresholds === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postCapacityThresholds - errors', () => {
+      it('should have a postCapacityThresholds function', (done) => {
+        try {
+          assert.equal(true, typeof a.postCapacityThresholds === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.postCapacityThresholds(null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-postCapacityThresholds', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getCapacityThresholdsCapacityThresholdId - errors', () => {
+      it('should have a getCapacityThresholdsCapacityThresholdId function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCapacityThresholdsCapacityThresholdId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing capacityThresholdId', (done) => {
+        try {
+          a.getCapacityThresholdsCapacityThresholdId(null, (data, error) => {
+            try {
+              const displayE = 'capacityThresholdId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getCapacityThresholdsCapacityThresholdId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchCapacityThresholdsCapacityThresholdId - errors', () => {
+      it('should have a patchCapacityThresholdsCapacityThresholdId function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchCapacityThresholdsCapacityThresholdId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing capacityThresholdId', (done) => {
+        try {
+          a.patchCapacityThresholdsCapacityThresholdId(null, null, (data, error) => {
+            try {
+              const displayE = 'capacityThresholdId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-patchCapacityThresholdsCapacityThresholdId', 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.patchCapacityThresholdsCapacityThresholdId('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-patchCapacityThresholdsCapacityThresholdId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteCapacityThresholdsCapacityThresholdId - errors', () => {
+      it('should have a deleteCapacityThresholdsCapacityThresholdId function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteCapacityThresholdsCapacityThresholdId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing capacityThresholdId', (done) => {
+        try {
+          a.deleteCapacityThresholdsCapacityThresholdId(null, (data, error) => {
+            try {
+              const displayE = 'capacityThresholdId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-deleteCapacityThresholdsCapacityThresholdId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postVnfSnapshotPackages - errors', () => {
+      it('should have a postVnfSnapshotPackages function', (done) => {
+        try {
+          assert.equal(true, typeof a.postVnfSnapshotPackages === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.postVnfSnapshotPackages(null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-postVnfSnapshotPackages', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getVnfSnapshotPackages - errors', () => {
+      it('should have a getVnfSnapshotPackages function', (done) => {
+        try {
+          assert.equal(true, typeof a.getVnfSnapshotPackages === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getVnfSnapshotPackagesVnfSnapshotPkgId - errors', () => {
+      it('should have a getVnfSnapshotPackagesVnfSnapshotPkgId function', (done) => {
+        try {
+          assert.equal(true, typeof a.getVnfSnapshotPackagesVnfSnapshotPkgId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing vnfSnapshotPkgId', (done) => {
+        try {
+          a.getVnfSnapshotPackagesVnfSnapshotPkgId(null, (data, error) => {
+            try {
+              const displayE = 'vnfSnapshotPkgId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getVnfSnapshotPackagesVnfSnapshotPkgId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchVnfSnapshotPackagesVnfSnapshotPkgId - errors', () => {
+      it('should have a patchVnfSnapshotPackagesVnfSnapshotPkgId function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchVnfSnapshotPackagesVnfSnapshotPkgId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing vnfSnapshotPkgId', (done) => {
+        try {
+          a.patchVnfSnapshotPackagesVnfSnapshotPkgId(null, null, (data, error) => {
+            try {
+              const displayE = 'vnfSnapshotPkgId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-patchVnfSnapshotPackagesVnfSnapshotPkgId', 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.patchVnfSnapshotPackagesVnfSnapshotPkgId('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-patchVnfSnapshotPackagesVnfSnapshotPkgId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteVnfSnapshotPackagesVnfSnapshotPkgId - errors', () => {
+      it('should have a deleteVnfSnapshotPackagesVnfSnapshotPkgId function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteVnfSnapshotPackagesVnfSnapshotPkgId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing vnfSnapshotPkgId', (done) => {
+        try {
+          a.deleteVnfSnapshotPackagesVnfSnapshotPkgId(null, (data, error) => {
+            try {
+              const displayE = 'vnfSnapshotPkgId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-deleteVnfSnapshotPackagesVnfSnapshotPkgId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getVnfSnapshotPackagesVnfSnapshotPkgIdPackageContent - errors', () => {
+      it('should have a getVnfSnapshotPackagesVnfSnapshotPkgIdPackageContent function', (done) => {
+        try {
+          assert.equal(true, typeof a.getVnfSnapshotPackagesVnfSnapshotPkgIdPackageContent === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing vnfSnapshotPkgId', (done) => {
+        try {
+          a.getVnfSnapshotPackagesVnfSnapshotPkgIdPackageContent(null, (data, error) => {
+            try {
+              const displayE = 'vnfSnapshotPkgId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getVnfSnapshotPackagesVnfSnapshotPkgIdPackageContent', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#putVnfSnapshotPackagesVnfSnapshotPkgIdPackageContent - errors', () => {
+      it('should have a putVnfSnapshotPackagesVnfSnapshotPkgIdPackageContent function', (done) => {
+        try {
+          assert.equal(true, typeof a.putVnfSnapshotPackagesVnfSnapshotPkgIdPackageContent === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing vnfSnapshotPkgId', (done) => {
+        try {
+          a.putVnfSnapshotPackagesVnfSnapshotPkgIdPackageContent(null, (data, error) => {
+            try {
+              const displayE = 'vnfSnapshotPkgId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-putVnfSnapshotPackagesVnfSnapshotPkgIdPackageContent', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postVnfSnapshotPackagesVnfSnapshotPkgIdPackageContentUploadFromUri - errors', () => {
+      it('should have a postVnfSnapshotPackagesVnfSnapshotPkgIdPackageContentUploadFromUri function', (done) => {
+        try {
+          assert.equal(true, typeof a.postVnfSnapshotPackagesVnfSnapshotPkgIdPackageContentUploadFromUri === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing vnfSnapshotPkgId', (done) => {
+        try {
+          a.postVnfSnapshotPackagesVnfSnapshotPkgIdPackageContentUploadFromUri(null, null, (data, error) => {
+            try {
+              const displayE = 'vnfSnapshotPkgId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-postVnfSnapshotPackagesVnfSnapshotPkgIdPackageContentUploadFromUri', 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.postVnfSnapshotPackagesVnfSnapshotPkgIdPackageContentUploadFromUri('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-postVnfSnapshotPackagesVnfSnapshotPkgIdPackageContentUploadFromUri', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postVnfSnapshotPackagesVnfSnapshotPkgIdPackageContentBuild - errors', () => {
+      it('should have a postVnfSnapshotPackagesVnfSnapshotPkgIdPackageContentBuild function', (done) => {
+        try {
+          assert.equal(true, typeof a.postVnfSnapshotPackagesVnfSnapshotPkgIdPackageContentBuild === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing vnfSnapshotPkgId', (done) => {
+        try {
+          a.postVnfSnapshotPackagesVnfSnapshotPkgIdPackageContentBuild(null, null, (data, error) => {
+            try {
+              const displayE = 'vnfSnapshotPkgId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-postVnfSnapshotPackagesVnfSnapshotPkgIdPackageContentBuild', 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.postVnfSnapshotPackagesVnfSnapshotPkgIdPackageContentBuild('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-postVnfSnapshotPackagesVnfSnapshotPkgIdPackageContentBuild', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postVnfSnapshotPackagesVnfSnapshotPkgIdPackageContentExtract - errors', () => {
+      it('should have a postVnfSnapshotPackagesVnfSnapshotPkgIdPackageContentExtract function', (done) => {
+        try {
+          assert.equal(true, typeof a.postVnfSnapshotPackagesVnfSnapshotPkgIdPackageContentExtract === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing vnfSnapshotPkgId', (done) => {
+        try {
+          a.postVnfSnapshotPackagesVnfSnapshotPkgIdPackageContentExtract(null, null, (data, error) => {
+            try {
+              const displayE = 'vnfSnapshotPkgId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-postVnfSnapshotPackagesVnfSnapshotPkgIdPackageContentExtract', 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.postVnfSnapshotPackagesVnfSnapshotPkgIdPackageContentExtract('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-postVnfSnapshotPackagesVnfSnapshotPkgIdPackageContentExtract', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postVnfSnapshotPackagesVnfSnapshotPkgIdPackageContentCancel - errors', () => {
+      it('should have a postVnfSnapshotPackagesVnfSnapshotPkgIdPackageContentCancel function', (done) => {
+        try {
+          assert.equal(true, typeof a.postVnfSnapshotPackagesVnfSnapshotPkgIdPackageContentCancel === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing vnfSnapshotPkgId', (done) => {
+        try {
+          a.postVnfSnapshotPackagesVnfSnapshotPkgIdPackageContentCancel(null, null, (data, error) => {
+            try {
+              const displayE = 'vnfSnapshotPkgId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-postVnfSnapshotPackagesVnfSnapshotPkgIdPackageContentCancel', 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.postVnfSnapshotPackagesVnfSnapshotPkgIdPackageContentCancel('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-postVnfSnapshotPackagesVnfSnapshotPkgIdPackageContentCancel', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getVnfSnapshotPackagesVnfSnapshotPkgIdExtArtifactsAccess - errors', () => {
+      it('should have a getVnfSnapshotPackagesVnfSnapshotPkgIdExtArtifactsAccess function', (done) => {
+        try {
+          assert.equal(true, typeof a.getVnfSnapshotPackagesVnfSnapshotPkgIdExtArtifactsAccess === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing vnfSnapshotPkgId', (done) => {
+        try {
+          a.getVnfSnapshotPackagesVnfSnapshotPkgIdExtArtifactsAccess(null, (data, error) => {
+            try {
+              const displayE = 'vnfSnapshotPkgId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getVnfSnapshotPackagesVnfSnapshotPkgIdExtArtifactsAccess', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#putVnfSnapshotPackagesVnfSnapshotPkgIdExtArtifactsAccess - errors', () => {
+      it('should have a putVnfSnapshotPackagesVnfSnapshotPkgIdExtArtifactsAccess function', (done) => {
+        try {
+          assert.equal(true, typeof a.putVnfSnapshotPackagesVnfSnapshotPkgIdExtArtifactsAccess === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing vnfSnapshotPkgId', (done) => {
+        try {
+          a.putVnfSnapshotPackagesVnfSnapshotPkgIdExtArtifactsAccess(null, null, (data, error) => {
+            try {
+              const displayE = 'vnfSnapshotPkgId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-putVnfSnapshotPackagesVnfSnapshotPkgIdExtArtifactsAccess', 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.putVnfSnapshotPackagesVnfSnapshotPkgIdExtArtifactsAccess('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-putVnfSnapshotPackagesVnfSnapshotPkgIdExtArtifactsAccess', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getVnfSnapshotPackagesVnfSnapshotPkgIdArtifactsArtifactPath - errors', () => {
+      it('should have a getVnfSnapshotPackagesVnfSnapshotPkgIdArtifactsArtifactPath function', (done) => {
+        try {
+          assert.equal(true, typeof a.getVnfSnapshotPackagesVnfSnapshotPkgIdArtifactsArtifactPath === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing vnfSnapshotPkgId', (done) => {
+        try {
+          a.getVnfSnapshotPackagesVnfSnapshotPkgIdArtifactsArtifactPath(null, null, (data, error) => {
+            try {
+              const displayE = 'vnfSnapshotPkgId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getVnfSnapshotPackagesVnfSnapshotPkgIdArtifactsArtifactPath', 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 artifactPath', (done) => {
+        try {
+          a.getVnfSnapshotPackagesVnfSnapshotPkgIdArtifactsArtifactPath('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'artifactPath is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-getVnfSnapshotPackagesVnfSnapshotPkgIdArtifactsArtifactPath', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#querymultipleNSinstances - errors', () => {
+      it('should have a querymultipleNSinstances function', (done) => {
+        try {
+          assert.equal(true, typeof a.querymultipleNSinstances === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createaNSinstanceresource - errors', () => {
+      it('should have a createaNSinstanceresource function', (done) => {
+        try {
+          assert.equal(true, typeof a.createaNSinstanceresource === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.createaNSinstanceresource(null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-createaNSinstanceresource', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#readanindividualNSinstanceresource - errors', () => {
+      it('should have a readanindividualNSinstanceresource function', (done) => {
+        try {
+          assert.equal(true, typeof a.readanindividualNSinstanceresource === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing nsInstanceId', (done) => {
+        try {
+          a.readanindividualNSinstanceresource(null, (data, error) => {
+            try {
+              const displayE = 'nsInstanceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-readanindividualNSinstanceresource', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteNSinstanceresource - errors', () => {
+      it('should have a deleteNSinstanceresource function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteNSinstanceresource === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing nsInstanceId', (done) => {
+        try {
+          a.deleteNSinstanceresource(null, (data, error) => {
+            try {
+              const displayE = 'nsInstanceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-deleteNSinstanceresource', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#instantiateaNS - errors', () => {
+      it('should have a instantiateaNS function', (done) => {
+        try {
+          assert.equal(true, typeof a.instantiateaNS === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing nsInstanceId', (done) => {
+        try {
+          a.instantiateaNS(null, null, (data, error) => {
+            try {
+              const displayE = 'nsInstanceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-instantiateaNS', 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.instantiateaNS('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-instantiateaNS', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#scaleaNSinstance - errors', () => {
+      it('should have a scaleaNSinstance function', (done) => {
+        try {
+          assert.equal(true, typeof a.scaleaNSinstance === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing nsInstanceId', (done) => {
+        try {
+          a.scaleaNSinstance(null, null, (data, error) => {
+            try {
+              const displayE = 'nsInstanceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-scaleaNSinstance', 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.scaleaNSinstance('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-scaleaNSinstance', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updatesaNSinstance - errors', () => {
+      it('should have a updatesaNSinstance function', (done) => {
+        try {
+          assert.equal(true, typeof a.updatesaNSinstance === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing nsInstanceId', (done) => {
+        try {
+          a.updatesaNSinstance(null, null, (data, error) => {
+            try {
+              const displayE = 'nsInstanceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-updatesaNSinstance', 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.updatesaNSinstance('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-updatesaNSinstance', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#healaNSinstance - errors', () => {
+      it('should have a healaNSinstance function', (done) => {
+        try {
+          assert.equal(true, typeof a.healaNSinstance === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing nsInstanceId', (done) => {
+        try {
+          a.healaNSinstance(null, null, (data, error) => {
+            try {
+              const displayE = 'nsInstanceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-healaNSinstance', 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.healaNSinstance('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-healaNSinstance', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#terminateaNSinstance - errors', () => {
+      it('should have a terminateaNSinstance function', (done) => {
+        try {
+          assert.equal(true, typeof a.terminateaNSinstance === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing nsInstanceId', (done) => {
+        try {
+          a.terminateaNSinstance(null, null, (data, error) => {
+            try {
+              const displayE = 'nsInstanceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-terminateaNSinstance', 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.terminateaNSinstance('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-terminateaNSinstance', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#querymultipleNSLCMoperationoccurrences - errors', () => {
+      it('should have a querymultipleNSLCMoperationoccurrences function', (done) => {
+        try {
+          assert.equal(true, typeof a.querymultipleNSLCMoperationoccurrences === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#readanindividualNSLCMoperationoccurrenceresource - errors', () => {
+      it('should have a readanindividualNSLCMoperationoccurrenceresource function', (done) => {
+        try {
+          assert.equal(true, typeof a.readanindividualNSLCMoperationoccurrenceresource === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing nsLcmOpOccId', (done) => {
+        try {
+          a.readanindividualNSLCMoperationoccurrenceresource(null, (data, error) => {
+            try {
+              const displayE = 'nsLcmOpOccId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-readanindividualNSLCMoperationoccurrenceresource', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#retryaNSlifecyclemanagementoperationoccurrence - errors', () => {
+      it('should have a retryaNSlifecyclemanagementoperationoccurrence function', (done) => {
+        try {
+          assert.equal(true, typeof a.retryaNSlifecyclemanagementoperationoccurrence === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing nsLcmOpOccId', (done) => {
+        try {
+          a.retryaNSlifecyclemanagementoperationoccurrence(null, (data, error) => {
+            try {
+              const displayE = 'nsLcmOpOccId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-retryaNSlifecyclemanagementoperationoccurrence', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#rollbackaNSlifecyclemanagementoperationoccurrence - errors', () => {
+      it('should have a rollbackaNSlifecyclemanagementoperationoccurrence function', (done) => {
+        try {
+          assert.equal(true, typeof a.rollbackaNSlifecyclemanagementoperationoccurrence === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing nsLcmOpOccId', (done) => {
+        try {
+          a.rollbackaNSlifecyclemanagementoperationoccurrence(null, (data, error) => {
+            try {
+              const displayE = 'nsLcmOpOccId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-rollbackaNSlifecyclemanagementoperationoccurrence', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#continueaNSlifecyclemanagementoperationoccurrence - errors', () => {
+      it('should have a continueaNSlifecyclemanagementoperationoccurrence function', (done) => {
+        try {
+          assert.equal(true, typeof a.continueaNSlifecyclemanagementoperationoccurrence === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing nsLcmOpOccId', (done) => {
+        try {
+          a.continueaNSlifecyclemanagementoperationoccurrence(null, (data, error) => {
+            try {
+              const displayE = 'nsLcmOpOccId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-continueaNSlifecyclemanagementoperationoccurrence', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#markaNSlifecyclemanagementoperationoccurrenceasfailed - errors', () => {
+      it('should have a markaNSlifecyclemanagementoperationoccurrenceasfailed function', (done) => {
+        try {
+          assert.equal(true, typeof a.markaNSlifecyclemanagementoperationoccurrenceasfailed === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing nsLcmOpOccId', (done) => {
+        try {
+          a.markaNSlifecyclemanagementoperationoccurrenceasfailed(null, (data, error) => {
+            try {
+              const displayE = 'nsLcmOpOccId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-markaNSlifecyclemanagementoperationoccurrenceasfailed', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#cancelaNSlifecyclemanagementoperationoccurrence - errors', () => {
+      it('should have a cancelaNSlifecyclemanagementoperationoccurrence function', (done) => {
+        try {
+          assert.equal(true, typeof a.cancelaNSlifecyclemanagementoperationoccurrence === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing nsLcmOpOccId', (done) => {
+        try {
+          a.cancelaNSlifecyclemanagementoperationoccurrence(null, null, (data, error) => {
+            try {
+              const displayE = 'nsLcmOpOccId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-cancelaNSlifecyclemanagementoperationoccurrence', 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.cancelaNSlifecyclemanagementoperationoccurrence('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-cancelaNSlifecyclemanagementoperationoccurrence', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#queryVNFsnapshots - errors', () => {
+      it('should have a queryVNFsnapshots function', (done) => {
+        try {
+          assert.equal(true, typeof a.queryVNFsnapshots === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#queryanIndividualVNFsnapshot - errors', () => {
+      it('should have a queryanIndividualVNFsnapshot function', (done) => {
+        try {
+          assert.equal(true, typeof a.queryanIndividualVNFsnapshot === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing vnfSnapshotInfoId', (done) => {
+        try {
+          a.queryanIndividualVNFsnapshot(null, (data, error) => {
+            try {
+              const displayE = 'vnfSnapshotInfoId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-queryanIndividualVNFsnapshot', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteanIndividualVNFsnapshot - errors', () => {
+      it('should have a deleteanIndividualVNFsnapshot function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteanIndividualVNFsnapshot === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing vnfSnapshotInfoId', (done) => {
+        try {
+          a.deleteanIndividualVNFsnapshot(null, (data, error) => {
+            try {
+              const displayE = 'vnfSnapshotInfoId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-etsi_sol005-adapter-deleteanIndividualVNFsnapshot', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+  });
+});