@itentialopensource/adapter-openstack_cinder 0.1.1

package/test/integration/adapterTestIntegration.js

@@ -0,0 +1,4799 @@
+/* @copyright Itential, LLC 2019 (pre-modifications) */
+
+// Set globals
+/* global describe it log pronghornProps */
+/* eslint no-unused-vars: warn */
+/* eslint no-underscore-dangle: warn  */
+/* eslint import/no-dynamic-require:warn */
+
+// include required items for testing & logging
+const assert = require('assert');
+const fs = require('fs');
+const mocha = require('mocha');
+const path = require('path');
+const winston = require('winston');
+const { expect } = require('chai');
+const { use } = require('chai');
+const td = require('testdouble');
+const util = require('util');
+
+const anything = td.matchers.anything();
+
+// stub and attemptTimeout are used throughout the code so set them here
+let logLevel = 'none';
+const isRapidFail = false;
+const isSaveMockData = false;
+
+// read in the properties from the sampleProperties files
+let adaptdir = __dirname;
+if (adaptdir.endsWith('/test/integration')) {
+  adaptdir = adaptdir.substring(0, adaptdir.length - 17);
+} else if (adaptdir.endsWith('/test/unit')) {
+  adaptdir = adaptdir.substring(0, adaptdir.length - 10);
+}
+const samProps = require(`${adaptdir}/sampleProperties.json`).properties;
+
+// these variables can be changed to run in integrated mode so easier to set them here
+// always check these in with bogus data!!!
+samProps.stub = true;
+samProps.host = 'replace.hostorip.here';
+samProps.authentication.username = 'username';
+samProps.authentication.password = 'password';
+samProps.protocol = 'http';
+samProps.port = 80;
+samProps.ssl.enabled = false;
+samProps.ssl.accept_invalid_cert = false;
+if (samProps.request.attempt_timeout < 30000) {
+  samProps.request.attempt_timeout = 30000;
+}
+const attemptTimeout = samProps.request.attempt_timeout;
+const { stub } = samProps;
+
+// these are the adapter properties. You generally should not need to alter
+// any of these after they are initially set up
+global.pronghornProps = {
+  pathProps: {
+    encrypted: false
+  },
+  adapterProps: {
+    adapters: [{
+      id: 'Test-openstack_cinder',
+      type: 'OpenstackCinder',
+      properties: samProps
+    }]
+  }
+};
+
+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 common asserts for test
+ */
+function runCommonAsserts(data, error) {
+  assert.equal(undefined, error);
+  assert.notEqual(undefined, data);
+  assert.notEqual(null, data);
+  assert.notEqual(undefined, data.response);
+  assert.notEqual(null, data.response);
+}
+
+/**
+ * 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);
+}
+
+/**
+ * @function saveMockData
+ * Attempts to take data from responses and place them in MockDataFiles to help create Mockdata.
+ * Note, this was built based on entity file structure for Adapter-Engine 1.6.x
+ * @param {string} entityName - Name of the entity saving mock data for
+ * @param {string} actionName -  Name of the action saving mock data for
+ * @param {string} descriptor -  Something to describe this test (used as a type)
+ * @param {string or object} responseData - The data to put in the mock file.
+ */
+function saveMockData(entityName, actionName, descriptor, responseData) {
+  // do not need to save mockdata if we are running in stub mode (already has mock data) or if told not to save
+  if (stub || !isSaveMockData) {
+    return false;
+  }
+
+  // must have a response in order to store the response
+  if (responseData && responseData.response) {
+    let data = responseData.response;
+
+    // if there was a raw response that one is better as it is untranslated
+    if (responseData.raw) {
+      data = responseData.raw;
+
+      try {
+        const temp = JSON.parse(data);
+        data = temp;
+      } catch (pex) {
+        // do not care if it did not parse as we will just use data
+      }
+    }
+
+    try {
+      const base = path.join(__dirname, `../../entities/${entityName}/`);
+      const mockdatafolder = 'mockdatafiles';
+      const filename = `mockdatafiles/${actionName}-${descriptor}.json`;
+
+      if (!fs.existsSync(base + mockdatafolder)) {
+        fs.mkdirSync(base + mockdatafolder);
+      }
+
+      // write the data we retrieved
+      fs.writeFile(base + filename, JSON.stringify(data, null, 2), 'utf8', (errWritingMock) => {
+        if (errWritingMock) throw errWritingMock;
+
+        // update the action file to reflect the changes. Note: We're replacing the default object for now!
+        fs.readFile(`${base}action.json`, (errRead, content) => {
+          if (errRead) throw errRead;
+
+          // parse the action file into JSON
+          const parsedJson = JSON.parse(content);
+
+          // The object update we'll write in.
+          const responseObj = {
+            type: descriptor,
+            key: '',
+            mockFile: filename
+          };
+
+          // get the object for method we're trying to change.
+          const currentMethodAction = parsedJson.actions.find((obj) => obj.name === actionName);
+
+          // if the method was not found - should never happen but...
+          if (!currentMethodAction) {
+            throw Error('Can\'t find an action for this method in the provided entity.');
+          }
+
+          // if there is a response object, we want to replace the Response object. Otherwise we'll create one.
+          const actionResponseObj = currentMethodAction.responseObjects.find((obj) => obj.type === descriptor);
+
+          // Add the action responseObj back into the array of response objects.
+          if (!actionResponseObj) {
+            // if there is a default response object, we want to get the key.
+            const defaultResponseObj = currentMethodAction.responseObjects.find((obj) => obj.type === 'default');
+
+            // save the default key into the new response object
+            if (defaultResponseObj) {
+              responseObj.key = defaultResponseObj.key;
+            }
+
+            // save the new response object
+            currentMethodAction.responseObjects = [responseObj];
+          } else {
+            // update the location of the mock data file
+            actionResponseObj.mockFile = responseObj.mockFile;
+          }
+
+          // Save results
+          fs.writeFile(`${base}action.json`, JSON.stringify(parsedJson, null, 2), (err) => {
+            if (err) throw err;
+          });
+        });
+      });
+    } catch (e) {
+      log.debug(`Failed to save mock data for ${actionName}. ${e.message}`);
+      return false;
+    }
+  }
+
+  // no response to save
+  log.debug(`No data passed to save into mockdata for ${actionName}`);
+  return false;
+}
+
+// require the adapter that we are going to be using
+const OpenstackCinder = require('../../adapter');
+
+// begin the testing - these should be pretty well defined between the describe and the it!
+describe('[integration] Openstack_cinder Adapter Test', () => {
+  describe('OpenstackCinder Class Tests', () => {
+    const a = new OpenstackCinder(
+      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('#connect', () => {
+      it('should get connected - no healthcheck', (done) => {
+        try {
+          a.healthcheckType = 'none';
+          a.connect();
+
+          try {
+            assert.equal(true, a.alive);
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      });
+      it('should get connected - startup healthcheck', (done) => {
+        try {
+          a.healthcheckType = 'startup';
+          a.connect();
+
+          try {
+            assert.equal(true, a.alive);
+            done();
+          } catch (error) {
+            log.error(`Test Failure: ${error}`);
+            done(error);
+          }
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      });
+    });
+
+    describe('#healthCheck', () => {
+      it('should be healthy', (done) => {
+        try {
+          a.healthCheck(null, (data) => {
+            try {
+              assert.equal(true, a.healthy);
+              saveMockData('system', 'healthcheck', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    /*
+    -----------------------------------------------------------------------
+    -----------------------------------------------------------------------
+    *** All code above this comment will be replaced during a migration ***
+    ******************* DO NOT REMOVE THIS COMMENT BLOCK ******************
+    -----------------------------------------------------------------------
+    -----------------------------------------------------------------------
+    */
+
+    describe('#listAllApiVersions - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listAllApiVersions((data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('APIVersions', 'listAllApiVersions', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showAPIV3Details - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showAPIV3Details((data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('APIVersionDetails', 'showAPIV3Details', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const aPIExtensionsExtensionsProjectId = 'fakedata';
+    describe('#listKnownAPIExtensions - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listKnownAPIExtensions(aPIExtensionsExtensionsProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('APIExtensionsExtensions', 'listKnownAPIExtensions', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const volumeTypesTypesProjectId = 'fakedata';
+    const volumeTypesTypesCreateAVolumeTypeBodyParam = {
+      volume_type: {
+        name: 'string',
+        description: 'string',
+        'os-volume-type-access:is_public': true,
+        extra_specs: {
+          capabilities: 'string'
+        }
+      }
+    };
+    describe('#createAVolumeType - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createAVolumeType(volumeTypesTypesProjectId, volumeTypesTypesCreateAVolumeTypeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeTypesTypes', 'createAVolumeType', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const volumeTypesTypesVolumeTypeId = 'fakedata';
+    const volumeTypesTypesCreateAnEncryptionTypeBodyParam = {
+      encryption: {
+        key_size: 2,
+        provider: 'string',
+        control_location: 'string',
+        cipher: 'string'
+      }
+    };
+    describe('#createAnEncryptionType - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createAnEncryptionType(volumeTypesTypesProjectId, volumeTypesTypesVolumeTypeId, volumeTypesTypesCreateAnEncryptionTypeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeTypesTypes', 'createAnEncryptionType', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const volumeTypesTypesCreateOrUpdateExtraSpecsForVolumeTypeBodyParam = {
+      extra_specs: {
+        key1: 'string',
+        key2: 'string'
+      }
+    };
+    describe('#createOrUpdateExtraSpecsForVolumeType - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createOrUpdateExtraSpecsForVolumeType(volumeTypesTypesProjectId, volumeTypesTypesVolumeTypeId, volumeTypesTypesCreateOrUpdateExtraSpecsForVolumeTypeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeTypesTypes', 'createOrUpdateExtraSpecsForVolumeType', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listAllVolumeTypes - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listAllVolumeTypes(null, null, null, null, null, volumeTypesTypesProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeTypesTypes', 'listAllVolumeTypes', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showDefaultVolumeType - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showDefaultVolumeType(volumeTypesTypesProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeTypesTypes', 'showDefaultVolumeType', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const volumeTypesTypesUpdateAVolumeTypeBodyParam = {
+      volume_type: {
+        name: 'string',
+        description: 'string',
+        is_public: true
+      }
+    };
+    describe('#updateAVolumeType - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateAVolumeType(volumeTypesTypesProjectId, volumeTypesTypesVolumeTypeId, volumeTypesTypesUpdateAVolumeTypeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeTypesTypes', 'updateAVolumeType', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showVolumeTypeDetail - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showVolumeTypeDetail(volumeTypesTypesProjectId, volumeTypesTypesVolumeTypeId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeTypesTypes', 'showVolumeTypeDetail', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showAnEncryptionType - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showAnEncryptionType(volumeTypesTypesProjectId, volumeTypesTypesVolumeTypeId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeTypesTypes', 'showAnEncryptionType', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const volumeTypesTypesEncryptionId = 'fakedata';
+    const volumeTypesTypesUpdateAnEncryptionTypeBodyParam = {
+      encryption: {
+        key_size: 10,
+        provider: 'string',
+        control_location: 'string',
+        cipher: 'string'
+      }
+    };
+    describe('#updateAnEncryptionType - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateAnEncryptionType(volumeTypesTypesProjectId, volumeTypesTypesVolumeTypeId, volumeTypesTypesEncryptionId, volumeTypesTypesUpdateAnEncryptionTypeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeTypesTypes', 'updateAnEncryptionType', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const volumeTypesTypesKey = 'fakedata';
+    describe('#showEncryptionSpecsItem - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showEncryptionSpecsItem(volumeTypesTypesProjectId, volumeTypesTypesVolumeTypeId, volumeTypesTypesKey, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeTypesTypes', 'showEncryptionSpecsItem', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showAllExtraSpecificationsForVolumeType - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showAllExtraSpecificationsForVolumeType(volumeTypesTypesProjectId, volumeTypesTypesVolumeTypeId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeTypesTypes', 'showAllExtraSpecificationsForVolumeType', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const volumeTypesTypesUpdateExtraSpecificationForVolumeTypeBodyParam = {
+      key1: 'string'
+    };
+    describe('#updateExtraSpecificationForVolumeType - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateExtraSpecificationForVolumeType(volumeTypesTypesProjectId, volumeTypesTypesVolumeTypeId, volumeTypesTypesKey, volumeTypesTypesUpdateExtraSpecificationForVolumeTypeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeTypesTypes', 'updateExtraSpecificationForVolumeType', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showExtraSpecificationForVolumeType - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showExtraSpecificationForVolumeType(volumeTypesTypesProjectId, volumeTypesTypesVolumeTypeId, volumeTypesTypesKey, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeTypesTypes', 'showExtraSpecificationForVolumeType', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const volumeTypeAccessTypesActionTypesOsVolumeTypeAccessProjectId = 'fakedata';
+    const volumeTypeAccessTypesActionTypesOsVolumeTypeAccessVolumeType = 'fakedata';
+    const volumeTypeAccessTypesActionTypesOsVolumeTypeAccessAddPrivateVolumeTypeAccessToProjectBodyParam = {
+      addProjectAccess: {
+        project: 'string'
+      }
+    };
+    describe('#addPrivateVolumeTypeAccessToProject - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addPrivateVolumeTypeAccessToProject(volumeTypeAccessTypesActionTypesOsVolumeTypeAccessProjectId, volumeTypeAccessTypesActionTypesOsVolumeTypeAccessVolumeType, volumeTypeAccessTypesActionTypesOsVolumeTypeAccessAddPrivateVolumeTypeAccessToProjectBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeTypeAccessTypesActionTypesOsVolumeTypeAccess', 'addPrivateVolumeTypeAccessToProject', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listPrivateVolumeTypeAccessDetail - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listPrivateVolumeTypeAccessDetail(volumeTypeAccessTypesActionTypesOsVolumeTypeAccessProjectId, volumeTypeAccessTypesActionTypesOsVolumeTypeAccessVolumeType, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeTypeAccessTypesActionTypesOsVolumeTypeAccess', 'listPrivateVolumeTypeAccessDetail', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listDefaultVolumeTypes - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listDefaultVolumeTypes((data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DefaultVolumeTypesDefaultTypes', 'listDefaultVolumeTypes', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const defaultVolumeTypesDefaultTypesProjectId = 'fakedata';
+    const defaultVolumeTypesDefaultTypesCreateOrUpdateADefaultVolumeTypeBodyParam = {
+      default_type: {
+        volume_type: 'string'
+      }
+    };
+    describe('#createOrUpdateADefaultVolumeType - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createOrUpdateADefaultVolumeType(defaultVolumeTypesDefaultTypesProjectId, defaultVolumeTypesDefaultTypesCreateOrUpdateADefaultVolumeTypeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DefaultVolumeTypesDefaultTypes', 'createOrUpdateADefaultVolumeType', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showADefaultVolumeType - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showADefaultVolumeType(defaultVolumeTypesDefaultTypesProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DefaultVolumeTypesDefaultTypes', 'showADefaultVolumeType', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const volumesVolumesProjectId = 'fakedata';
+    const volumesVolumesCreateAVolumeBodyParam = {
+      volume: {
+        size: 1,
+        availability_zone: 'string',
+        source_volid: 'string',
+        description: 'string',
+        multiattach: true,
+        snapshot_id: 'string',
+        backup_id: 'string',
+        name: 'string',
+        imageRef: 'string',
+        volume_type: 'string',
+        metadata: {},
+        consistencygroup_id: 'string'
+      },
+      'OS-SCH-HNT:scheduler_hints': {
+        same_host: [
+          'string'
+        ]
+      }
+    };
+    describe('#createAVolume - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createAVolume(volumesVolumesProjectId, volumesVolumesCreateAVolumeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumesVolumes', 'createAVolume', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const volumesVolumesVolumeId = 'fakedata';
+    const volumesVolumesCreateMetadataForVolumeBodyParam = {
+      metadata: {
+        name: 'string'
+      }
+    };
+    describe('#createMetadataForVolume - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createMetadataForVolume(volumesVolumesProjectId, volumesVolumesVolumeId, volumesVolumesCreateMetadataForVolumeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumesVolumes', 'createMetadataForVolume', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listAccessibleVolumes - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listAccessibleVolumes(null, null, null, null, null, null, null, null, null, volumesVolumesProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumesVolumes', 'listAccessibleVolumes', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listAccessibleVolumesWithDetails - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listAccessibleVolumesWithDetails(null, null, null, null, null, null, null, null, null, volumesVolumesProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumesVolumes', 'listAccessibleVolumesWithDetails', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getVolumesSummary - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getVolumesSummary(null, volumesVolumesProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumesVolumes', 'getVolumesSummary', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const volumesVolumesUpdateAVolumeBodyParam = {
+      volume: {
+        name: 'string',
+        description: 'string',
+        metadata: {
+          name: 'string'
+        }
+      }
+    };
+    describe('#updateAVolume - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateAVolume(volumesVolumesProjectId, volumesVolumesVolumeId, volumesVolumesUpdateAVolumeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumesVolumes', 'updateAVolume', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showAVolumeSDetails - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showAVolumeSDetails(volumesVolumesProjectId, volumesVolumesVolumeId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumesVolumes', 'showAVolumeSDetails', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const volumesVolumesUpdateAVolumeSMetadataBodyParam = {
+      metadata: {
+        name: 'string'
+      }
+    };
+    describe('#updateAVolumeSMetadata - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateAVolumeSMetadata(volumesVolumesProjectId, volumesVolumesVolumeId, volumesVolumesUpdateAVolumeSMetadataBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumesVolumes', 'updateAVolumeSMetadata', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showAVolumeSMetadata - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showAVolumeSMetadata(volumesVolumesProjectId, volumesVolumesVolumeId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumesVolumes', 'showAVolumeSMetadata', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const volumesVolumesKey = 'fakedata';
+    const volumesVolumesUpdateAVolumeSMetadataForASpecificKeyBodyParam = {
+      meta: {
+        name: 'string'
+      }
+    };
+    describe('#updateAVolumeSMetadataForASpecificKey - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateAVolumeSMetadataForASpecificKey(volumesVolumesProjectId, volumesVolumesVolumeId, volumesVolumesKey, volumesVolumesUpdateAVolumeSMetadataForASpecificKeyBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumesVolumes', 'updateAVolumeSMetadataForASpecificKey', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showAVolumeSMetadataForASpecificKey - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showAVolumeSMetadataForASpecificKey(volumesVolumesProjectId, volumesVolumesVolumeId, volumesVolumesKey, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumesVolumes', 'showAVolumeSMetadataForASpecificKey', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const volumeActionsVolumesActionProjectId = 'fakedata';
+    const volumeActionsVolumesActionVolumeId = 'fakedata';
+    const volumeActionsVolumesActionExtendAVolumeSizeBodyParam = {
+      'os-extend': {
+        new_size: 8
+      }
+    };
+    describe('#extendAVolumeSize - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.extendAVolumeSize(volumeActionsVolumesActionProjectId, volumeActionsVolumesActionVolumeId, volumeActionsVolumesActionExtendAVolumeSizeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeActionsVolumesAction', 'extendAVolumeSize', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const volumeManageExtensionManageableVolumesProjectId = 'fakedata';
+    const volumeManageExtensionManageableVolumesManageAnExistingVolumeBodyParam = {
+      volume: {
+        host: 'string',
+        ref: {
+          'source-name': 'string',
+          'source-id': 'string'
+        },
+        name: 'string',
+        availability_zone: 'string',
+        description: 'string',
+        volume_type: 'string',
+        bootable: false,
+        metadata: {
+          key1: 'string',
+          key2: 'string'
+        }
+      }
+    };
+    describe('#manageAnExistingVolume - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.manageAnExistingVolume(volumeManageExtensionManageableVolumesProjectId, volumeManageExtensionManageableVolumesManageAnExistingVolumeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeManageExtensionManageableVolumes', 'manageAnExistingVolume', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listSummaryOfVolumesAvailableToManage - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listSummaryOfVolumesAvailableToManage(null, null, null, null, volumeManageExtensionManageableVolumesProjectId, null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeManageExtensionManageableVolumes', 'listSummaryOfVolumesAvailableToManage', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listDetailOfVolumesAvailableToManage - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listDetailOfVolumesAvailableToManage(null, null, null, null, null, volumeManageExtensionManageableVolumesProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeManageExtensionManageableVolumes', 'listDetailOfVolumesAvailableToManage', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const volumeSnapshotsSnapshotsProjectId = 'fakedata';
+    const volumeSnapshotsSnapshotsCreateASnapshotBodyParam = {
+      snapshot: {
+        name: 'string',
+        description: 'string',
+        volume_id: 'string',
+        force: true,
+        metadata: {
+          key: 'string'
+        }
+      }
+    };
+    describe('#createASnapshot - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createASnapshot(volumeSnapshotsSnapshotsProjectId, volumeSnapshotsSnapshotsCreateASnapshotBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeSnapshotsSnapshots', 'createASnapshot', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const volumeSnapshotsSnapshotsSnapshotId = 'fakedata';
+    const volumeSnapshotsSnapshotsCreateASnapshotSMetadataBodyParam = {
+      metadata: {
+        key: 'string'
+      }
+    };
+    describe('#createASnapshotSMetadata - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createASnapshotSMetadata(volumeSnapshotsSnapshotsProjectId, volumeSnapshotsSnapshotsSnapshotId, volumeSnapshotsSnapshotsCreateASnapshotSMetadataBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeSnapshotsSnapshots', 'createASnapshotSMetadata', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const volumeSnapshotsSnapshotsKey = 'fakedata';
+    describe('#showASnapshotSMetadataForASpecificKey - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showASnapshotSMetadataForASpecificKey(volumeSnapshotsSnapshotsProjectId, volumeSnapshotsSnapshotsSnapshotId, volumeSnapshotsSnapshotsKey, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeSnapshotsSnapshots', 'showASnapshotSMetadataForASpecificKey', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listAccessibleSnapshots - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listAccessibleSnapshots(null, null, null, null, null, null, null, volumeSnapshotsSnapshotsProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeSnapshotsSnapshots', 'listAccessibleSnapshots', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listSnapshotsAndDetails - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listSnapshotsAndDetails(null, null, null, null, null, null, null, volumeSnapshotsSnapshotsProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeSnapshotsSnapshots', 'listSnapshotsAndDetails', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const volumeSnapshotsSnapshotsUpdateASnapshotBodyParam = {
+      snapshot: {
+        name: 'string',
+        description: 'string'
+      }
+    };
+    describe('#updateASnapshot - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateASnapshot(volumeSnapshotsSnapshotsProjectId, volumeSnapshotsSnapshotsSnapshotId, volumeSnapshotsSnapshotsUpdateASnapshotBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeSnapshotsSnapshots', 'updateASnapshot', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showASnapshotSDetails - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showASnapshotSDetails(volumeSnapshotsSnapshotsProjectId, volumeSnapshotsSnapshotsSnapshotId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeSnapshotsSnapshots', 'showASnapshotSDetails', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const volumeSnapshotsSnapshotsUpdateASnapshotSMetadataBodyParam = {
+      metadata: {
+        new_key: 'string'
+      }
+    };
+    describe('#updateASnapshotSMetadata - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateASnapshotSMetadata(volumeSnapshotsSnapshotsProjectId, volumeSnapshotsSnapshotsSnapshotId, volumeSnapshotsSnapshotsUpdateASnapshotSMetadataBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeSnapshotsSnapshots', 'updateASnapshotSMetadata', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showASnapshotSMetadata - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showASnapshotSMetadata(volumeSnapshotsSnapshotsProjectId, volumeSnapshotsSnapshotsSnapshotId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeSnapshotsSnapshots', 'showASnapshotSMetadata', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const volumeSnapshotsSnapshotsUpdateASnapshotSMetadataForASpecificKeyBodyParam = {
+      meta: {
+        key: 'string'
+      }
+    };
+    describe('#updateASnapshotSMetadataForASpecificKey - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateASnapshotSMetadataForASpecificKey(volumeSnapshotsSnapshotsProjectId, volumeSnapshotsSnapshotsSnapshotId, volumeSnapshotsSnapshotsKey, volumeSnapshotsSnapshotsUpdateASnapshotSMetadataForASpecificKeyBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeSnapshotsSnapshots', 'updateASnapshotSMetadataForASpecificKey', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const snapshotActionsSnapshotsActionProjectId = 'fakedata';
+    const snapshotActionsSnapshotsActionSnapshotId = 'fakedata';
+    const snapshotActionsSnapshotsActionResetASnapshotSStatusBodyParam = {
+      'os-reset_status': {
+        status: 'string'
+      }
+    };
+    describe('#resetASnapshotSStatus - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.resetASnapshotSStatus(snapshotActionsSnapshotsActionProjectId, snapshotActionsSnapshotsActionSnapshotId, snapshotActionsSnapshotsActionResetASnapshotSStatusBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SnapshotActionsSnapshotsAction', 'resetASnapshotSStatus', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const snapshotManageExtensionManageableSnapshotsProjectId = 'fakedata';
+    const snapshotManageExtensionManageableSnapshotsManageAnExistingSnapshotBodyParam = {
+      snapshot: {
+        description: 'string',
+        metadata: {},
+        ref: {
+          'source-name': 'string'
+        },
+        name: 'string',
+        volume_id: 'string'
+      }
+    };
+    describe('#manageAnExistingSnapshot - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.manageAnExistingSnapshot(snapshotManageExtensionManageableSnapshotsProjectId, snapshotManageExtensionManageableSnapshotsManageAnExistingSnapshotBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SnapshotManageExtensionManageableSnapshots', 'manageAnExistingSnapshot', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listSummaryOfSnapshotsAvailableToManage - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listSummaryOfSnapshotsAvailableToManage(null, null, null, null, null, snapshotManageExtensionManageableSnapshotsProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SnapshotManageExtensionManageableSnapshots', 'listSummaryOfSnapshotsAvailableToManage', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listDetailOfSnapshotsAvailableToManage - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listDetailOfSnapshotsAvailableToManage(null, null, null, null, null, snapshotManageExtensionManageableSnapshotsProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SnapshotManageExtensionManageableSnapshots', 'listDetailOfSnapshotsAvailableToManage', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const volumeTransferProjectId = 'fakedata';
+    const volumeTransferCreateAVolumeTransferNewBodyParam = {
+      transfer: {
+        volume_id: 'string',
+        name: 'string'
+      }
+    };
+    describe('#createAVolumeTransferNew - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createAVolumeTransferNew(volumeTransferProjectId, volumeTransferCreateAVolumeTransferNewBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeTransfer', 'createAVolumeTransferNew', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const volumeTransferTransferId = 'fakedata';
+    const volumeTransferAcceptAVolumeTransferNewBodyParam = {
+      accept: {
+        auth_key: 'string'
+      }
+    };
+    describe('#acceptAVolumeTransferNew - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.acceptAVolumeTransferNew(volumeTransferProjectId, volumeTransferTransferId, volumeTransferAcceptAVolumeTransferNewBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeTransfer', 'acceptAVolumeTransferNew', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listVolumeTransfersForAProjectNew - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listVolumeTransfersForAProjectNew(null, volumeTransferProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeTransfer', 'listVolumeTransfersForAProjectNew', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listVolumeTransfersAndDetailsNew - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listVolumeTransfersAndDetailsNew(null, volumeTransferProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeTransfer', 'listVolumeTransfersAndDetailsNew', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showVolumeTransferDetailNew - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showVolumeTransferDetailNew(volumeTransferProjectId, volumeTransferTransferId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeTransfer', 'showVolumeTransferDetailNew', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const volumeTransfersVolumeTransfers355OrLaterProjectId = 'fakedata';
+    const volumeTransfersVolumeTransfers355OrLaterCreateAVolumeTransferBodyParam = {
+      transfer: {
+        volume_id: 'string',
+        name: 'string'
+      }
+    };
+    describe('#createAVolumeTransfer - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createAVolumeTransfer(volumeTransfersVolumeTransfers355OrLaterProjectId, volumeTransfersVolumeTransfers355OrLaterCreateAVolumeTransferBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeTransfersVolumeTransfers355OrLater', 'createAVolumeTransfer', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const volumeTransfersVolumeTransfers355OrLaterTransferId = 'fakedata';
+    const volumeTransfersVolumeTransfers355OrLaterAcceptAVolumeTransferBodyParam = {
+      accept: {
+        auth_key: 'string'
+      }
+    };
+    describe('#acceptAVolumeTransfer - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.acceptAVolumeTransfer(volumeTransfersVolumeTransfers355OrLaterProjectId, volumeTransfersVolumeTransfers355OrLaterTransferId, volumeTransfersVolumeTransfers355OrLaterAcceptAVolumeTransferBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeTransfersVolumeTransfers355OrLater', 'acceptAVolumeTransfer', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listVolumeTransfersForAProject - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listVolumeTransfersForAProject(null, null, null, null, null, null, volumeTransfersVolumeTransfers355OrLaterProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeTransfersVolumeTransfers355OrLater', 'listVolumeTransfersForAProject', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listVolumeTransfersAndDetails - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listVolumeTransfersAndDetails(null, volumeTransfersVolumeTransfers355OrLaterProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeTransfersVolumeTransfers355OrLater', 'listVolumeTransfersAndDetails', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showVolumeTransferDetail - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showVolumeTransferDetail(volumeTransfersVolumeTransfers355OrLaterProjectId, volumeTransfersVolumeTransfers355OrLaterTransferId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeTransfersVolumeTransfers355OrLater', 'showVolumeTransferDetail', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const attachmentsAttachmentsProjectId = 'fakedata';
+    const attachmentsAttachmentsCreateAttachmentBodyParam = {
+      attachment: {
+        instance_uuid: 'string',
+        connector: {
+          initiator: 'string',
+          ip: 'string',
+          platform: 'string',
+          host: 'string',
+          os_type: 'string',
+          multipath: true,
+          mountpoint: 'string',
+          mode: 'string'
+        },
+        volume_uuid: 'string'
+      }
+    };
+    describe('#createAttachment - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createAttachment(attachmentsAttachmentsProjectId, attachmentsAttachmentsCreateAttachmentBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('AttachmentsAttachments', 'createAttachment', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const attachmentsAttachmentsAttachmentId = 'fakedata';
+    const attachmentsAttachmentsCompleteAttachmentBodyParam = {
+      'os-complete': {}
+    };
+    describe('#completeAttachment - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.completeAttachment(attachmentsAttachmentsProjectId, attachmentsAttachmentsAttachmentId, attachmentsAttachmentsCompleteAttachmentBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('AttachmentsAttachments', 'completeAttachment', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listAttachments - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listAttachments(null, null, null, null, null, attachmentsAttachmentsProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('AttachmentsAttachments', 'listAttachments', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listAttachmentsWithDetails - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listAttachmentsWithDetails(null, null, null, null, null, attachmentsAttachmentsProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('AttachmentsAttachments', 'listAttachmentsWithDetails', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const attachmentsAttachmentsUpdateAnAttachmentBodyParam = {
+      attachment: {
+        connector: {
+          initiator: 'string',
+          ip: 'string',
+          platform: 'string',
+          host: 'string',
+          os_type: 'string',
+          multipath: false,
+          mountpoint: 'string',
+          mode: 'string'
+        }
+      }
+    };
+    describe('#updateAnAttachment - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateAnAttachment(attachmentsAttachmentsProjectId, attachmentsAttachmentsAttachmentId, attachmentsAttachmentsUpdateAnAttachmentBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('AttachmentsAttachments', 'updateAnAttachment', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showAttachmentDetails - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showAttachmentDetails(attachmentsAttachmentsProjectId, attachmentsAttachmentsAttachmentId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('AttachmentsAttachments', 'showAttachmentDetails', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const backEndStoragePoolsProjectId = 'fakedata';
+    describe('#listAllBackEndStoragePools - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listAllBackEndStoragePools(null, backEndStoragePoolsProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('BackEndStoragePools', 'listAllBackEndStoragePools', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const backupsBackupsProjectId = 'fakedata';
+    const backupsBackupsCreateABackupBodyParam = {
+      backup: {
+        container: 'string',
+        description: 'string',
+        name: 'string',
+        volume_id: 'string',
+        incremental: true,
+        availability_zone: 'string',
+        metadata: {}
+      }
+    };
+    describe('#createABackup - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createABackup(backupsBackupsProjectId, backupsBackupsCreateABackupBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('BackupsBackups', 'createABackup', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const backupsBackupsImportABackupBodyParam = {
+      'backup-record': {
+        backup_service: 'string',
+        backup_url: 'string'
+      }
+    };
+    describe('#importABackup - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.importABackup(backupsBackupsProjectId, backupsBackupsImportABackupBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('BackupsBackups', 'importABackup', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const backupsBackupsBackupId = 'fakedata';
+    const backupsBackupsRestoreABackupBodyParam = {
+      restore: {
+        name: 'string',
+        volume_id: 'string'
+      }
+    };
+    describe('#restoreABackup - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.restoreABackup(backupsBackupsProjectId, backupsBackupsBackupId, backupsBackupsRestoreABackupBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('BackupsBackups', 'restoreABackup', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listBackupsForProject - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listBackupsForProject(null, null, null, null, null, backupsBackupsProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('BackupsBackups', 'listBackupsForProject', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listBackupsWithDetail - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listBackupsWithDetail(null, null, null, null, null, null, backupsBackupsProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('BackupsBackups', 'listBackupsWithDetail', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const backupsBackupsUpdateABackupBodyParam = {
+      backup: {
+        name: 'string',
+        metadata: {
+          key: 'string'
+        },
+        description: 'string'
+      }
+    };
+    describe('#updateABackup - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateABackup(backupsBackupsProjectId, backupsBackupsBackupId, backupsBackupsUpdateABackupBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('BackupsBackups', 'updateABackup', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showBackupDetail - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showBackupDetail(backupsBackupsProjectId, backupsBackupsBackupId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('BackupsBackups', 'showBackupDetail', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#exportABackup - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.exportABackup(backupsBackupsProjectId, backupsBackupsBackupId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('BackupsBackups', 'exportABackup', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const backupActionsBackupsActionProjectId = 'fakedata';
+    const backupActionsBackupsActionBackupId = 'fakedata';
+    const backupActionsBackupsActionForceDeleteABackupBodyParam = {
+      'os-force_delete': {}
+    };
+    describe('#forceDeleteABackup - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.forceDeleteABackup(backupActionsBackupsActionProjectId, backupActionsBackupsActionBackupId, backupActionsBackupsActionForceDeleteABackupBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('BackupActionsBackupsAction', 'forceDeleteABackup', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const capabilitiesForStorageBackEndsCapabilitiesProjectId = 'fakedata';
+    const capabilitiesForStorageBackEndsCapabilitiesHostname = 'fakedata';
+    describe('#showAllBackEndCapabilities - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showAllBackEndCapabilities(capabilitiesForStorageBackEndsCapabilitiesProjectId, capabilitiesForStorageBackEndsCapabilitiesHostname, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('CapabilitiesForStorageBackEndsCapabilities', 'showAllBackEndCapabilities', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const consistencyGroupsDEPRECATEDProjectId = 'fakedata';
+    const consistencyGroupsDEPRECATEDCreateAConsistencyGroupBodyParam = {
+      consistencygroup: {
+        name: 'string',
+        description: 'string',
+        volume_types: 'string',
+        availability_zone: 'string'
+      }
+    };
+    describe('#createAConsistencyGroup - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createAConsistencyGroup(consistencyGroupsDEPRECATEDProjectId, consistencyGroupsDEPRECATEDCreateAConsistencyGroupBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ConsistencyGroupsDEPRECATED', 'createAConsistencyGroup', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const consistencyGroupsDEPRECATEDCreateAConsistencyGroupFromSourceBodyParam = {
+      'consistencygroup-from-src': {
+        name: 'string',
+        description: 'string',
+        cgsnapshot_id: 'string',
+        source_cgid: 'string',
+        user_id: 'string',
+        project_id: 'string',
+        status: 'string'
+      }
+    };
+    describe('#createAConsistencyGroupFromSource - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createAConsistencyGroupFromSource(consistencyGroupsDEPRECATEDProjectId, consistencyGroupsDEPRECATEDCreateAConsistencyGroupFromSourceBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ConsistencyGroupsDEPRECATED', 'createAConsistencyGroupFromSource', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const consistencyGroupsDEPRECATEDConsistencygroupId = 'fakedata';
+    const consistencyGroupsDEPRECATEDDeleteAConsistencyGroupBodyParam = {
+      consistencygroup: {
+        force: false
+      }
+    };
+    describe('#deleteAConsistencyGroup - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteAConsistencyGroup(consistencyGroupsDEPRECATEDProjectId, consistencyGroupsDEPRECATEDConsistencygroupId, consistencyGroupsDEPRECATEDDeleteAConsistencyGroupBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ConsistencyGroupsDEPRECATED', 'deleteAConsistencyGroup', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listProjectSConsistencyGroups - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listProjectSConsistencyGroups(null, null, null, null, consistencyGroupsDEPRECATEDProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ConsistencyGroupsDEPRECATED', 'listProjectSConsistencyGroups', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listConsistencyGroupsAndDetails - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listConsistencyGroupsAndDetails(null, null, null, null, consistencyGroupsDEPRECATEDProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ConsistencyGroupsDEPRECATED', 'listConsistencyGroupsAndDetails', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showAConsistencyGroupSDetails - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showAConsistencyGroupSDetails(consistencyGroupsDEPRECATEDProjectId, consistencyGroupsDEPRECATEDConsistencygroupId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ConsistencyGroupsDEPRECATED', 'showAConsistencyGroupSDetails', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const consistencyGroupsDEPRECATEDUpdateAConsistencyGroupBodyParam = {
+      consistencygroup: {
+        name: 'string',
+        description: 'string',
+        add_volumes: 'string',
+        remove_volumes: 'string'
+      }
+    };
+    describe('#updateAConsistencyGroup - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateAConsistencyGroup(consistencyGroupsDEPRECATEDProjectId, consistencyGroupsDEPRECATEDConsistencygroupId, consistencyGroupsDEPRECATEDUpdateAConsistencyGroupBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ConsistencyGroupsDEPRECATED', 'updateAConsistencyGroup', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const consistencyGroupSnapshotsDEPRECATEDProjectId = 'fakedata';
+    const consistencyGroupSnapshotsDEPRECATEDCreateAConsistencyGroupSnapshotBodyParam = {
+      cgsnapshot: {
+        consistencygroup_id: 'string',
+        name: 'string',
+        description: 'string',
+        status: 'string'
+      }
+    };
+    describe('#createAConsistencyGroupSnapshot - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createAConsistencyGroupSnapshot(consistencyGroupSnapshotsDEPRECATEDProjectId, consistencyGroupSnapshotsDEPRECATEDCreateAConsistencyGroupSnapshotBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ConsistencyGroupSnapshotsDEPRECATED', 'createAConsistencyGroupSnapshot', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listAllConsistencyGroupSnapshots - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listAllConsistencyGroupSnapshots(null, consistencyGroupSnapshotsDEPRECATEDProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ConsistencyGroupSnapshotsDEPRECATED', 'listAllConsistencyGroupSnapshots', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listAllConsistencyGroupSnapshotsWithDetails - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listAllConsistencyGroupSnapshotsWithDetails(null, consistencyGroupSnapshotsDEPRECATEDProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ConsistencyGroupSnapshotsDEPRECATED', 'listAllConsistencyGroupSnapshotsWithDetails', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const consistencyGroupSnapshotsDEPRECATEDCgsnapshotId = 'fakedata';
+    describe('#showConsistencyGroupSnapshotDetail - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showConsistencyGroupSnapshotDetail(consistencyGroupSnapshotsDEPRECATEDProjectId, consistencyGroupSnapshotsDEPRECATEDCgsnapshotId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ConsistencyGroupSnapshotsDEPRECATED', 'showConsistencyGroupSnapshotDetail', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const servicesOsServicesProjectId = 'fakedata';
+    describe('#listAllCinderServices - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listAllCinderServices(null, null, servicesOsServicesProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ServicesOsServices', 'listAllCinderServices', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const servicesOsServicesDisableACinderServiceBodyParam = {
+      binary: 'string',
+      host: 'string'
+    };
+    describe('#disableACinderService - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.disableACinderService(servicesOsServicesProjectId, servicesOsServicesDisableACinderServiceBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ServicesOsServices', 'disableACinderService', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const servicesOsServicesLogDisabledCinderServiceInformationBodyParam = {
+      binary: 'string',
+      host: 'string',
+      disabled_reason: 'string'
+    };
+    describe('#logDisabledCinderServiceInformation - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.logDisabledCinderServiceInformation(servicesOsServicesProjectId, servicesOsServicesLogDisabledCinderServiceInformationBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ServicesOsServices', 'logDisabledCinderServiceInformation', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const servicesOsServicesEnableACinderServiceBodyParam = {
+      binary: 'string',
+      host: 'string'
+    };
+    describe('#enableACinderService - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.enableACinderService(servicesOsServicesProjectId, servicesOsServicesEnableACinderServiceBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ServicesOsServices', 'enableACinderService', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const servicesOsServicesFailoverACinderBackendHostBodyParam = {
+      host: 'string',
+      backend_id: 'string'
+    };
+    describe('#failoverACinderBackendHost - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.failoverACinderBackendHost(servicesOsServicesProjectId, servicesOsServicesFailoverACinderBackendHostBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ServicesOsServices', 'failoverACinderBackendHost', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const servicesOsServicesFreezeACinderBackendHostBodyParam = {
+      host: 'string'
+    };
+    describe('#freezeACinderBackendHost - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.freezeACinderBackendHost(servicesOsServicesProjectId, servicesOsServicesFreezeACinderBackendHostBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ServicesOsServices', 'freezeACinderBackendHost', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const servicesOsServicesGetCurrentLogLevelsForCinderServicesBodyParam = {
+      binary: 'string',
+      server: 'string',
+      prefix: 'string'
+    };
+    describe('#getCurrentLogLevelsForCinderServices - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getCurrentLogLevelsForCinderServices(servicesOsServicesProjectId, servicesOsServicesGetCurrentLogLevelsForCinderServicesBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ServicesOsServices', 'getCurrentLogLevelsForCinderServices', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const servicesOsServicesSetLogLevelsOfCinderServicesDynamicallyBodyParam = {
+      binary: 'string',
+      server: 'string',
+      prefix: 'string',
+      level: 'string'
+    };
+    describe('#setLogLevelsOfCinderServicesDynamically - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.setLogLevelsOfCinderServicesDynamically(servicesOsServicesProjectId, servicesOsServicesSetLogLevelsOfCinderServicesDynamicallyBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ServicesOsServices', 'setLogLevelsOfCinderServicesDynamically', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const servicesOsServicesThawACinderBackendHostBodyParam = {
+      host: 'string'
+    };
+    describe('#thawACinderBackendHost - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.thawACinderBackendHost(servicesOsServicesProjectId, servicesOsServicesThawACinderBackendHostBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ServicesOsServices', 'thawACinderBackendHost', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const genericVolumeGroupsGroupsProjectId = 'fakedata';
+    const genericVolumeGroupsGroupsCreateGroupBodyParam = {
+      group: {
+        name: 'string',
+        description: 'string',
+        group_type: 'string',
+        volume_types: [
+          'string'
+        ],
+        availability_zone: 'string'
+      }
+    };
+    describe('#createGroup - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createGroup(genericVolumeGroupsGroupsProjectId, genericVolumeGroupsGroupsCreateGroupBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('GenericVolumeGroupsGroups', 'createGroup', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const genericVolumeGroupsGroupsCreateGroupFromSourceBodyParam = {
+      'create-from-src': {
+        name: 'string',
+        description: 'string',
+        group_snapshot_id: 'string',
+        source_group_id: 'string'
+      }
+    };
+    describe('#createGroupFromSource - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createGroupFromSource(genericVolumeGroupsGroupsProjectId, genericVolumeGroupsGroupsCreateGroupFromSourceBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('GenericVolumeGroupsGroups', 'createGroupFromSource', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const genericVolumeGroupsGroupsGroupId = 'fakedata';
+    const genericVolumeGroupsGroupsDeleteGroupBodyParam = {
+      delete: {
+        'delete-volumes': false
+      }
+    };
+    describe('#deleteGroup - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteGroup(genericVolumeGroupsGroupsProjectId, genericVolumeGroupsGroupsGroupId, genericVolumeGroupsGroupsDeleteGroupBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('GenericVolumeGroupsGroups', 'deleteGroup', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listGroups - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listGroups(null, null, null, null, null, genericVolumeGroupsGroupsProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('GenericVolumeGroupsGroups', 'listGroups', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listGroupsWithDetails - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listGroupsWithDetails(null, null, null, null, null, genericVolumeGroupsGroupsProjectId, null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('GenericVolumeGroupsGroups', 'listGroupsWithDetails', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const genericVolumeGroupsGroupsUpdateGroupBodyParam = {
+      group: {
+        name: 'string',
+        description: 'string',
+        add_volumes: 'string',
+        remove_volumes: 'string'
+      }
+    };
+    describe('#updateGroup - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateGroup(genericVolumeGroupsGroupsProjectId, genericVolumeGroupsGroupsGroupId, genericVolumeGroupsGroupsUpdateGroupBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('GenericVolumeGroupsGroups', 'updateGroup', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showGroupDetails - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showGroupDetails(genericVolumeGroupsGroupsProjectId, genericVolumeGroupsGroupsGroupId, null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('GenericVolumeGroupsGroups', 'showGroupDetails', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const groupSnapshotsGroupSnapshotsProjectId = 'fakedata';
+    const groupSnapshotsGroupSnapshotsCreateGroupSnapshotBodyParam = {
+      group_snapshot: {
+        group_id: 'string',
+        name: 'string',
+        description: 'string'
+      }
+    };
+    describe('#createGroupSnapshot - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createGroupSnapshot(groupSnapshotsGroupSnapshotsProjectId, groupSnapshotsGroupSnapshotsCreateGroupSnapshotBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('GroupSnapshotsGroupSnapshots', 'createGroupSnapshot', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const groupSnapshotsGroupSnapshotsGroupSnapshotId = 'fakedata';
+    const groupSnapshotsGroupSnapshotsResetGroupSnapshotStatusBodyParam = {
+      reset_status: {
+        status: 'string'
+      }
+    };
+    describe('#resetGroupSnapshotStatus - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.resetGroupSnapshotStatus(groupSnapshotsGroupSnapshotsProjectId, groupSnapshotsGroupSnapshotsGroupSnapshotId, groupSnapshotsGroupSnapshotsResetGroupSnapshotStatusBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('GroupSnapshotsGroupSnapshots', 'resetGroupSnapshotStatus', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listGroupSnapshots - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listGroupSnapshots(null, null, null, null, null, null, groupSnapshotsGroupSnapshotsProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('GroupSnapshotsGroupSnapshots', 'listGroupSnapshots', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listGroupSnapshotsWithDetails - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listGroupSnapshotsWithDetails(null, null, null, null, null, null, groupSnapshotsGroupSnapshotsProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('GroupSnapshotsGroupSnapshots', 'listGroupSnapshotsWithDetails', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showGroupSnapshotDetails - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showGroupSnapshotDetails(groupSnapshotsGroupSnapshotsProjectId, groupSnapshotsGroupSnapshotsGroupSnapshotId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('GroupSnapshotsGroupSnapshots', 'showGroupSnapshotDetails', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const groupTypesGroupTypesProjectId = 'fakedata';
+    const groupTypesGroupTypesCreateGroupTypeBodyParam = {
+      group_type: {
+        name: 'string',
+        description: 'string',
+        is_public: false,
+        group_specs: {
+          consistent_group_snapshot_enabled: 'string'
+        }
+      }
+    };
+    describe('#createGroupType - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createGroupType(groupTypesGroupTypesProjectId, groupTypesGroupTypesCreateGroupTypeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('GroupTypesGroupTypes', 'createGroupType', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listGroupTypes - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listGroupTypes(null, null, null, null, groupTypesGroupTypesProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('GroupTypesGroupTypes', 'listGroupTypes', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showDefaultGroupTypeDetails - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showDefaultGroupTypeDetails(groupTypesGroupTypesProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('GroupTypesGroupTypes', 'showDefaultGroupTypeDetails', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const groupTypesGroupTypesGroupTypeId = 'fakedata';
+    const groupTypesGroupTypesUpdateGroupTypeBodyParam = {
+      group_type: {
+        name: 'string',
+        description: 'string',
+        is_public: false
+      }
+    };
+    describe('#updateGroupType - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateGroupType(groupTypesGroupTypesProjectId, groupTypesGroupTypesGroupTypeId, groupTypesGroupTypesUpdateGroupTypeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('GroupTypesGroupTypes', 'updateGroupType', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showGroupTypeDetails - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showGroupTypeDetails(groupTypesGroupTypesProjectId, groupTypesGroupTypesGroupTypeId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('GroupTypesGroupTypes', 'showGroupTypeDetails', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const groupTypeSpecsGroupTypesGroupSpecsProjectId = 'fakedata';
+    const groupTypeSpecsGroupTypesGroupSpecsGroupTypeId = 'fakedata';
+    const groupTypeSpecsGroupTypesGroupSpecsCreateOrUpdateGroupSpecsForAGroupTypeBodyParam = {
+      group_specs: {
+        key1: 'string',
+        key2: 'string'
+      }
+    };
+    describe('#createOrUpdateGroupSpecsForAGroupType - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createOrUpdateGroupSpecsForAGroupType(groupTypeSpecsGroupTypesGroupSpecsProjectId, groupTypeSpecsGroupTypesGroupSpecsGroupTypeId, groupTypeSpecsGroupTypesGroupSpecsCreateOrUpdateGroupSpecsForAGroupTypeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('GroupTypeSpecsGroupTypesGroupSpecs', 'createOrUpdateGroupSpecsForAGroupType', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listGroupSpecsForAGroupType - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listGroupSpecsForAGroupType(groupTypeSpecsGroupTypesGroupSpecsProjectId, groupTypeSpecsGroupTypesGroupSpecsGroupTypeId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('GroupTypeSpecsGroupTypesGroupSpecs', 'listGroupSpecsForAGroupType', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const groupTypeSpecsGroupTypesGroupSpecsSpecId = 'fakedata';
+    const groupTypeSpecsGroupTypesGroupSpecsUpdateOneSpecificGroupSpecForAGroupTypeBodyParam = {
+      key1: 'string'
+    };
+    describe('#updateOneSpecificGroupSpecForAGroupType - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateOneSpecificGroupSpecForAGroupType(groupTypeSpecsGroupTypesGroupSpecsProjectId, groupTypeSpecsGroupTypesGroupSpecsGroupTypeId, groupTypeSpecsGroupTypesGroupSpecsSpecId, groupTypeSpecsGroupTypesGroupSpecsUpdateOneSpecificGroupSpecForAGroupTypeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('GroupTypeSpecsGroupTypesGroupSpecs', 'updateOneSpecificGroupSpecForAGroupType', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showOneSpecificGroupSpecForAGroupType - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showOneSpecificGroupSpecForAGroupType(groupTypeSpecsGroupTypesGroupSpecsProjectId, groupTypeSpecsGroupTypesGroupSpecsGroupTypeId, groupTypeSpecsGroupTypesGroupSpecsSpecId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('GroupTypeSpecsGroupTypesGroupSpecs', 'showOneSpecificGroupSpecForAGroupType', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const hostsExtensionOsHostsAdminProjectId = 'fakedata';
+    describe('#listAllHostsForAProject - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listAllHostsForAProject(hostsExtensionOsHostsAdminProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('HostsExtensionOsHosts', 'listAllHostsForAProject', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const hostsExtensionOsHostsHostName = 'fakedata';
+    describe('#showHostDetailsForAProject - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showHostDetailsForAProject(hostsExtensionOsHostsAdminProjectId, hostsExtensionOsHostsHostName, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('HostsExtensionOsHosts', 'showHostDetailsForAProject', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const limitsLimitsProjectId = 'fakedata';
+    describe('#showAbsoluteLimitsForProject - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showAbsoluteLimitsForProject(limitsLimitsProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('LimitsLimits', 'showAbsoluteLimitsForProject', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const messagesMessagesProjectId = 'fakedata';
+    describe('#listMessages - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listMessages(null, null, null, null, messagesMessagesProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('MessagesMessages', 'listMessages', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const messagesMessagesMessageId = 'fakedata';
+    describe('#showMessageDetails - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showMessageDetails(messagesMessagesProjectId, messagesMessagesMessageId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('MessagesMessages', 'showMessageDetails', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const resourceFiltersResourceFiltersProjectId = 'fakedata';
+    describe('#listResourceFilters - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listResourceFilters(null, resourceFiltersResourceFiltersProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ResourceFiltersResourceFilters', 'listResourceFilters', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const qualityOfServiceQoSSpecificationsQosSpecsProjectId = 'fakedata';
+    const qualityOfServiceQoSSpecificationsQosSpecsCreateAQoSSpecificationBodyParam = {
+      qos_specs: {
+        name: 'string'
+      }
+    };
+    describe('#createAQoSSpecification - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.createAQoSSpecification(qualityOfServiceQoSSpecificationsQosSpecsProjectId, qualityOfServiceQoSSpecificationsQosSpecsCreateAQoSSpecificationBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('QualityOfServiceQoSSpecificationsQosSpecs', 'createAQoSSpecification', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listQoSSpecifications - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.listQoSSpecifications(null, null, null, qualityOfServiceQoSSpecificationsQosSpecsProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('QualityOfServiceQoSSpecificationsQosSpecs', 'listQoSSpecifications', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const qualityOfServiceQoSSpecificationsQosSpecsQosId = 'fakedata';
+    const qualityOfServiceQoSSpecificationsQosSpecsSetKeysInAQoSSpecificationBodyParam = {
+      qos_specs: {
+        delay: 'string'
+      }
+    };
+    describe('#setKeysInAQoSSpecification - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.setKeysInAQoSSpecification(qualityOfServiceQoSSpecificationsQosSpecsProjectId, qualityOfServiceQoSSpecificationsQosSpecsQosId, qualityOfServiceQoSSpecificationsQosSpecsSetKeysInAQoSSpecificationBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('QualityOfServiceQoSSpecificationsQosSpecs', 'setKeysInAQoSSpecification', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showAQoSSpecificationDetails - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showAQoSSpecificationDetails(qualityOfServiceQoSSpecificationsQosSpecsProjectId, qualityOfServiceQoSSpecificationsQosSpecsQosId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('QualityOfServiceQoSSpecificationsQosSpecs', 'showAQoSSpecificationDetails', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const qualityOfServiceQoSSpecificationsQosSpecsVolTypeId = 'fakedata';
+    describe('#associateQoSSpecificationWithAVolumeType - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.associateQoSSpecificationWithAVolumeType(qualityOfServiceQoSSpecificationsQosSpecsVolTypeId, qualityOfServiceQoSSpecificationsQosSpecsProjectId, qualityOfServiceQoSSpecificationsQosSpecsQosId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('QualityOfServiceQoSSpecificationsQosSpecs', 'associateQoSSpecificationWithAVolumeType', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAllAssociationsForAQoSSpecification - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getAllAssociationsForAQoSSpecification(qualityOfServiceQoSSpecificationsQosSpecsProjectId, qualityOfServiceQoSSpecificationsQosSpecsQosId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('QualityOfServiceQoSSpecificationsQosSpecs', 'getAllAssociationsForAQoSSpecification', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const qualityOfServiceQoSSpecificationsQosSpecsUnsetKeysInAQoSSpecificationBodyParam = {
+      keys: [
+        'string'
+      ]
+    };
+    describe('#unsetKeysInAQoSSpecification - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.unsetKeysInAQoSSpecification(qualityOfServiceQoSSpecificationsQosSpecsProjectId, qualityOfServiceQoSSpecificationsQosSpecsQosId, qualityOfServiceQoSSpecificationsQosSpecsUnsetKeysInAQoSSpecificationBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('QualityOfServiceQoSSpecificationsQosSpecs', 'unsetKeysInAQoSSpecification', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#disassociateQoSSpecificationFromAVolumeType - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.disassociateQoSSpecificationFromAVolumeType(qualityOfServiceQoSSpecificationsQosSpecsVolTypeId, qualityOfServiceQoSSpecificationsQosSpecsProjectId, qualityOfServiceQoSSpecificationsQosSpecsQosId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('QualityOfServiceQoSSpecificationsQosSpecs', 'disassociateQoSSpecificationFromAVolumeType', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#disassociateAQoSSpecificationFromAllAssociations - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.disassociateAQoSSpecificationFromAllAssociations(qualityOfServiceQoSSpecificationsQosSpecsProjectId, qualityOfServiceQoSSpecificationsQosSpecsQosId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('QualityOfServiceQoSSpecificationsQosSpecs', 'disassociateAQoSSpecificationFromAllAssociations', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const quotaClassSetExtensionOsQuotaClassSetsAdminProjectId = 'fakedata';
+    const quotaClassSetExtensionOsQuotaClassSetsQuotaClassName = 'fakedata';
+    const quotaClassSetExtensionOsQuotaClassSetsUpdateQuotaClassesForAProjectBodyParam = {
+      quota_class_set: {
+        volumes: 2,
+        gigabytes: 10,
+        snapshots: 1
+      }
+    };
+    describe('#updateQuotaClassesForAProject - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateQuotaClassesForAProject(quotaClassSetExtensionOsQuotaClassSetsAdminProjectId, quotaClassSetExtensionOsQuotaClassSetsQuotaClassName, quotaClassSetExtensionOsQuotaClassSetsUpdateQuotaClassesForAProjectBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('QuotaClassSetExtensionOsQuotaClassSets', 'updateQuotaClassesForAProject', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showQuotaClassesForAProject - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showQuotaClassesForAProject(quotaClassSetExtensionOsQuotaClassSetsQuotaClassName, quotaClassSetExtensionOsQuotaClassSetsAdminProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('QuotaClassSetExtensionOsQuotaClassSets', 'showQuotaClassesForAProject', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const quotaSetsExtensionOsQuotaSetsAdminProjectId = 'fakedata';
+    const quotaSetsExtensionOsQuotaSetsProjectId = 'fakedata';
+    const quotaSetsExtensionOsQuotaSetsUpdateQuotasForAProjectBodyParam = {
+      quota_set: {
+        groups: 2,
+        volumes: 4,
+        backups: 6
+      }
+    };
+    describe('#updateQuotasForAProject - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateQuotasForAProject(quotaSetsExtensionOsQuotaSetsAdminProjectId, quotaSetsExtensionOsQuotaSetsProjectId, quotaSetsExtensionOsQuotaSetsUpdateQuotasForAProjectBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('QuotaSetsExtensionOsQuotaSets', 'updateQuotasForAProject', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showQuotasForAProject - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showQuotasForAProject(null, quotaSetsExtensionOsQuotaSetsAdminProjectId, quotaSetsExtensionOsQuotaSetsProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('QuotaSetsExtensionOsQuotaSets', 'showQuotasForAProject', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDefaultQuotasForAProject - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getDefaultQuotasForAProject(quotaSetsExtensionOsQuotaSetsProjectId, quotaSetsExtensionOsQuotaSetsAdminProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('QuotaSetsExtensionOsQuotaSets', 'getDefaultQuotasForAProject', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const workersWorkersProjectId = 'fakedata';
+    const workersWorkersCleanupServicesBodyParam = {
+      cluster_name: 'string',
+      disabled: false,
+      host: 'string',
+      service_id: 2,
+      is_up: true,
+      binary: 'string',
+      resource_id: 'string',
+      resource_type: 'string'
+    };
+    describe('#cleanupServices - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.cleanupServices(workersWorkersProjectId, workersWorkersCleanupServicesBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('WorkersWorkers', 'cleanupServices', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteAVolumeType - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteAVolumeType(volumeTypesTypesProjectId, volumeTypesTypesVolumeTypeId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeTypesTypes', 'deleteAVolumeType', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteAnEncryptionType - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteAnEncryptionType(volumeTypesTypesProjectId, volumeTypesTypesVolumeTypeId, volumeTypesTypesEncryptionId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeTypesTypes', 'deleteAnEncryptionType', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteExtraSpecificationForVolumeType - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteExtraSpecificationForVolumeType(volumeTypesTypesProjectId, volumeTypesTypesVolumeTypeId, volumeTypesTypesKey, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeTypesTypes', 'deleteExtraSpecificationForVolumeType', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteADefaultVolumeType - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteADefaultVolumeType(defaultVolumeTypesDefaultTypesProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('DefaultVolumeTypesDefaultTypes', 'deleteADefaultVolumeType', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteAVolume - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteAVolume(null, null, volumesVolumesProjectId, volumesVolumesVolumeId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumesVolumes', 'deleteAVolume', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteAVolumeSMetadata - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteAVolumeSMetadata(volumesVolumesProjectId, volumesVolumesVolumeId, volumesVolumesKey, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumesVolumes', 'deleteAVolumeSMetadata', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteASnapshot - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteASnapshot(volumeSnapshotsSnapshotsProjectId, volumeSnapshotsSnapshotsSnapshotId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeSnapshotsSnapshots', 'deleteASnapshot', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteASnapshotSMetadata - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteASnapshotSMetadata(volumeSnapshotsSnapshotsProjectId, volumeSnapshotsSnapshotsSnapshotId, volumeSnapshotsSnapshotsKey, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeSnapshotsSnapshots', 'deleteASnapshotSMetadata', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteAVolumeTransferNew - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteAVolumeTransferNew(volumeTransferProjectId, volumeTransferTransferId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeTransfer', 'deleteAVolumeTransferNew', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteAVolumeTransfer - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteAVolumeTransfer(volumeTransfersVolumeTransfers355OrLaterProjectId, volumeTransfersVolumeTransfers355OrLaterTransferId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('VolumeTransfersVolumeTransfers355OrLater', 'deleteAVolumeTransfer', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteAttachment - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteAttachment(attachmentsAttachmentsProjectId, attachmentsAttachmentsAttachmentId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('AttachmentsAttachments', 'deleteAttachment', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteABackup - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteABackup(backupsBackupsProjectId, backupsBackupsBackupId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('BackupsBackups', 'deleteABackup', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteAConsistencyGroupSnapshot - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteAConsistencyGroupSnapshot(consistencyGroupSnapshotsDEPRECATEDProjectId, consistencyGroupSnapshotsDEPRECATEDCgsnapshotId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ConsistencyGroupSnapshotsDEPRECATED', 'deleteAConsistencyGroupSnapshot', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteGroupSnapshot - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteGroupSnapshot(groupSnapshotsGroupSnapshotsProjectId, groupSnapshotsGroupSnapshotsGroupSnapshotId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('GroupSnapshotsGroupSnapshots', 'deleteGroupSnapshot', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteGroupType - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteGroupType(groupTypesGroupTypesGroupTypeId, groupTypesGroupTypesProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('GroupTypesGroupTypes', 'deleteGroupType', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteOneSpecificGroupSpecForAGroupType - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteOneSpecificGroupSpecForAGroupType(groupTypeSpecsGroupTypesGroupSpecsProjectId, groupTypeSpecsGroupTypesGroupSpecsGroupTypeId, groupTypeSpecsGroupTypesGroupSpecsSpecId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('GroupTypeSpecsGroupTypesGroupSpecs', 'deleteOneSpecificGroupSpecForAGroupType', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteMessage - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteMessage(messagesMessagesProjectId, messagesMessagesMessageId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('MessagesMessages', 'deleteMessage', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteAQoSSpecification - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteAQoSSpecification(null, qualityOfServiceQoSSpecificationsQosSpecsProjectId, qualityOfServiceQoSSpecificationsQosSpecsQosId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('QualityOfServiceQoSSpecificationsQosSpecs', 'deleteAQoSSpecification', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteQuotasForAProject - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteQuotasForAProject(quotaSetsExtensionOsQuotaSetsProjectId, quotaSetsExtensionOsQuotaSetsAdminProjectId, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-openstack_cinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('QuotaSetsExtensionOsQuotaSets', 'deleteQuotasForAProject', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+  });
+});