@itentialopensource/adapter-jira 1.7.4 → 1.7.6

package/test/integration/adapterTestIntegration.js

@@ -1,8 +1,10 @@
 /* @copyright Itential, LLC 2019 (pre-modifications) */
 
 // Set globals
-/* global describe it log pronghornProps before after */
+/* global after before 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');
@@ -13,25 +15,39 @@ 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 stub = true;
 const isRapidFail = false;
 const isSaveMockData = false;
-const attemptTimeout = 5000;
+
+// read in the properties from the sampleProperties files
+let adaptdir = __dirname;
+if (adaptdir.endsWith('/test/integration')) {
+  adaptdir = adaptdir.substring(0, adaptdir.length - 17);
+} else if (adaptdir.endsWith('/test/unit')) {
+  adaptdir = adaptdir.substring(0, adaptdir.length - 10);
+}
+const samProps = require(`${adaptdir}/sampleProperties.json`).properties;
 
 // these variables can be changed to run in integrated mode so easier to set them here
 // always check these in with bogus data!!!
-const host = 'replace.hostorip.here';
-const username = 'username';
-const password = 'password';
-const protocol = 'http';
-const port = 80;
-const sslenable = false;
-const sslinvalid = false;
+samProps.stub = true;
+samProps.host = 'replace.hostorip.here';
+samProps.authentication.username = 'username';
+samProps.authentication.password = 'password';
+samProps.protocol = 'http';
+samProps.port = 80;
+samProps.ssl.enabled = false;
+samProps.ssl.accept_invalid_cert = false;
+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
@@ -43,99 +59,7 @@ global.pronghornProps = {
     adapters: [{
       id: 'Test-jira',
       type: 'Jira',
-      properties: {
-        host,
-        port,
-        version: '',
-        base_path: '',
-        cache_location: 'none',
-        encode_pathvars: true,
-        save_metric: false,
-        stub,
-        protocol,
-        authentication: {
-          auth_method: 'basic user_password',
-          username,
-          password,
-          token: 'YOUR PERSONAL ACCESS TOKEN',
-          token_timeout: -1,
-          token_cache: 'local',
-          invalid_token_error: 401,
-          auth_field: 'header.headers.Authorization',
-          auth_field_format: 'Basic {b64}{username}:{password}{/b64}',
-          auth_logging: false
-        },
-        healthcheck: {
-          type: 'startup',
-          frequency: 300000,
-          query_object: {}
-        },
-        throttle: {
-          throttle_enabled: false,
-          number_pronghorns: 1,
-          sync_async: 'sync',
-          max_in_queue: 1000,
-          concurrent_max: 1,
-          expire_timeout: 0,
-          avg_runtime: 200,
-          priorities: [
-            {
-              value: 0,
-              percent: 100
-            }
-          ]
-        },
-        request: {
-          number_redirects: 0,
-          number_retries: 3,
-          limit_retry_error: 0,
-          failover_codes: [],
-          attempt_timeout: attemptTimeout,
-          global_request: {
-            payload: {},
-            uriOptions: {},
-            addlHeaders: {},
-            authData: {}
-          },
-          healthcheck_on_timeout: true,
-          return_raw: true,
-          archiving: false,
-          return_request: false
-        },
-        proxy: {
-          enabled: false,
-          host: '',
-          port: 1,
-          protocol: 'http',
-          username: '',
-          password: ''
-        },
-        ssl: {
-          ecdhCurve: '',
-          enabled: sslenable,
-          accept_invalid_cert: sslinvalid,
-          ca_file: '',
-          key_file: '',
-          cert_file: '',
-          secure_protocol: '',
-          ciphers: ''
-        },
-        mongo: {
-          host: '',
-          port: 0,
-          database: '',
-          username,
-          password: '',
-          replSet: '',
-          db_ssl: {
-            enabled: false,
-            accept_invalid_cert: false,
-            ca_file: '',
-            key_file: '',
-            cert_file: ''
-          }
-        }
-      }
+      properties: samProps
     }]
   }
 };
@@ -310,12 +234,12 @@ function saveMockData(entityName, actionName, descriptor, responseData) {
 }
 
 // require the adapter that we are going to be using
-const Jira2 = require('../../adapter.js');
+const Jira = require('../../adapter');
 
 // begin the testing - these should be pretty well defined between the describe and the it!
 describe('[integration] Jira Adapter Test', () => {
-  describe('Jira2 Class Tests', () => {
-    const a = new Jira2(
+  describe('Jira Class Tests', () => {
+    const a = new Jira(
       pronghornProps.adapterProps.adapters[0].id,
       pronghornProps.adapterProps.adapters[0].properties
     );
@@ -341,6 +265,8 @@ describe('[integration] Jira Adapter Test', () => {
         try {
           assert.notEqual(null, a);
           assert.notEqual(undefined, a);
+          const checkId = global.pronghornProps.adapterProps.adapters[0].id;
+          assert.equal(checkId, a.id);
           assert.notEqual(null, a.allProps);
           const check = global.pronghornProps.adapterProps.adapters[0].properties.healthcheck.type;
           assert.equal(check, a.healthcheckType);
@@ -12150,5 +12076,3606 @@ describe('[integration] Jira Adapter Test', () => {
         }
       }).timeout(attemptTimeout);
     });
+
+    const issueCustomFieldValuesAppsUpdateMultipleCustomFieldValuesBodyParam = {
+      updates: [
+        {
+          customField: 'string',
+          issueIds: [
+            4
+          ],
+          value: null
+        }
+      ]
+    };
+    describe('#updateMultipleCustomFieldValues - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateMultipleCustomFieldValues(null, issueCustomFieldValuesAppsUpdateMultipleCustomFieldValuesBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueCustomFieldValuesApps', 'updateMultipleCustomFieldValues', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueCustomFieldValuesAppsUpdateCustomFieldValueBodyParam = {
+      updates: [
+        {
+          issueIds: [
+            9
+          ],
+          value: null
+        }
+      ]
+    };
+    describe('#updateCustomFieldValue - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateCustomFieldValue('fakedata', null, issueCustomFieldValuesAppsUpdateCustomFieldValueBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueCustomFieldValuesApps', 'updateCustomFieldValue', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getCustomFieldConfiguration - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getCustomFieldConfiguration('fakedata', null, null, null, null, null, null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(1000, data.response.maxResults);
+                assert.equal(0, data.response.startAt);
+                assert.equal(2, data.response.total);
+                assert.equal(true, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueCustomFieldConfigurationApps', 'getCustomFieldConfiguration', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueCustomFieldConfigurationAppsUpdateCustomFieldConfigurationBodyParam = {
+      configurations: [
+        {}
+      ]
+    };
+    describe('#updateCustomFieldConfiguration - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateCustomFieldConfiguration('fakedata', issueCustomFieldConfigurationAppsUpdateCustomFieldConfigurationBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueCustomFieldConfigurationApps', 'updateCustomFieldConfiguration', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAttachmentContent - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getAttachmentContent('fakedata', null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueAttachments', 'getAttachmentContent', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAttachmentThumbnail - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getAttachmentThumbnail('fakedata', null, null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueAttachments', 'getAttachmentThumbnail', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const dashboardsCreateDashboardBodyParam = {
+      name: 'string',
+      sharePermissions: [
+        {}
+      ],
+      editPermissions: [
+        {}
+      ]
+    };
+    describe('#createDashboard - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.createDashboard(dashboardsCreateDashboardBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('10000', data.response.id);
+                assert.equal(false, data.response.isFavourite);
+                assert.equal('System Dashboard', data.response.name);
+                assert.equal(1, data.response.popularity);
+                assert.equal('https://your-domain.atlassian.net/rest/api/3/dashboard/10000', data.response.self);
+                assert.equal(true, Array.isArray(data.response.sharePermissions));
+                assert.equal('https://your-domain.atlassian.net/secure/Dashboard.jspa?selectPageId=10000', data.response.view);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Dashboards', 'createDashboard', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const dashboardsUpdateDashboardBodyParam = {
+      name: 'string',
+      sharePermissions: [
+        {}
+      ],
+      editPermissions: [
+        {}
+      ]
+    };
+    describe('#updateDashboard - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.updateDashboard('fakedata', dashboardsUpdateDashboardBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('success', data.response);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Dashboards', 'updateDashboard', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteDashboard - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteDashboard('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Dashboards', 'deleteDashboard', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const dashboardsCopyDashboardBodyParam = {
+      name: 'string',
+      sharePermissions: [
+        {}
+      ],
+      editPermissions: [
+        {}
+      ]
+    };
+    describe('#copyDashboard - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.copyDashboard('fakedata', dashboardsCopyDashboardBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('10000', data.response.id);
+                assert.equal(false, data.response.isFavourite);
+                assert.equal('System Dashboard', data.response.name);
+                assert.equal(1, data.response.popularity);
+                assert.equal('https://your-domain.atlassian.net/rest/api/3/dashboard/10000', data.response.self);
+                assert.equal(true, Array.isArray(data.response.sharePermissions));
+                assert.equal('https://your-domain.atlassian.net/secure/Dashboard.jspa?selectPageId=10000', data.response.view);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Dashboards', 'copyDashboard', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getEvents - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getEvents((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Issues', 'getEvents', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issuesGetChangeLogsByIdsBodyParam = {
+      changelogIds: [
+        7
+      ]
+    };
+    describe('#getChangeLogsByIds - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getChangeLogsByIds('fakedata', issuesGetChangeLogsByIdsBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(0, data.response.startAt);
+                assert.equal(2, data.response.maxResults);
+                assert.equal(2, data.response.total);
+                assert.equal(true, Array.isArray(data.response.histories));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Issues', 'getChangeLogsByIds', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const jiraExpressionsAnalyseExpressionBodyParam = {
+      expressions: 'issues.map(issue => issue.properties[\'property_key\'])'
+    };
+    describe('#analyseExpression - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.analyseExpression(null, jiraExpressionsAnalyseExpressionBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(true, Array.isArray(data.response.results));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('JiraExpressions', 'analyseExpression', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getFieldsPaginated - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getFieldsPaginated(null, null, null, null, null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(50, data.response.maxResults);
+                assert.equal(0, data.response.startAt);
+                assert.equal(2, data.response.total);
+                assert.equal(false, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueFields', 'getFieldsPaginated', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueFieldsUpdateCustomFieldBodyParam = {
+      name: 'string',
+      description: 'string',
+      searcherKey: 'com.atlassian.jira.plugin.system.customfieldtypes:multiselectsearcher'
+    };
+    describe('#updateCustomField - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateCustomField('fakedata', issueFieldsUpdateCustomFieldBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueFields', 'updateCustomField', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getContextsForFieldDeprecated - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getContextsForFieldDeprecated('fakedata', null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(1, data.response.maxResults);
+                assert.equal(0, data.response.startAt);
+                assert.equal(5, data.response.total);
+                assert.equal(false, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueFields', 'getContextsForFieldDeprecated', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteCustomField - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteCustomField('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueFields', 'deleteCustomField', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#restoreCustomField - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.restoreCustomField('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueFields', 'restoreCustomField', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#trashCustomField - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.trashCustomField('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueFields', 'trashCustomField', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getContextsForField - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getContextsForField('fakedata', null, null, null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(100, data.response.maxResults);
+                assert.equal(0, data.response.startAt);
+                assert.equal(2, data.response.total);
+                assert.equal(true, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueCustomFieldContexts', 'getContextsForField', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueCustomFieldContextsCreateCustomFieldContextBodyParam = {
+      name: 'string'
+    };
+    describe('#createCustomFieldContext - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.createCustomFieldContext('fakedata', issueCustomFieldContextsCreateCustomFieldContextBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('10025', data.response.id);
+                assert.equal('Bug fields context', data.response.name);
+                assert.equal('A context used to define the custom field options for bugs.', data.response.description);
+                assert.equal(true, Array.isArray(data.response.projectIds));
+                assert.equal(true, Array.isArray(data.response.issueTypeIds));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueCustomFieldContexts', 'createCustomFieldContext', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDefaultValues - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getDefaultValues('fakedata', null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(50, data.response.maxResults);
+                assert.equal(0, data.response.startAt);
+                assert.equal(3, data.response.total);
+                assert.equal(true, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueCustomFieldContexts', 'getDefaultValues', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueCustomFieldContextsSetDefaultValuesBodyParam = {
+      defaultValues: [
+        {}
+      ]
+    };
+    describe('#setDefaultValues - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.setDefaultValues('fakedata', issueCustomFieldContextsSetDefaultValuesBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueCustomFieldContexts', 'setDefaultValues', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getIssueTypeMappingsForContexts - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getIssueTypeMappingsForContexts('fakedata', null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(100, data.response.maxResults);
+                assert.equal(0, data.response.startAt);
+                assert.equal(3, data.response.total);
+                assert.equal(true, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueCustomFieldContexts', 'getIssueTypeMappingsForContexts', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueCustomFieldContextsGetCustomFieldContextsForProjectsAndIssueTypesBodyParam = {
+      mappings: [
+        {}
+      ]
+    };
+    describe('#getCustomFieldContextsForProjectsAndIssueTypes - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getCustomFieldContextsForProjectsAndIssueTypes('fakedata', null, null, issueCustomFieldContextsGetCustomFieldContextsForProjectsAndIssueTypesBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(50, data.response.maxResults);
+                assert.equal(0, data.response.startAt);
+                assert.equal(3, data.response.total);
+                assert.equal(true, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueCustomFieldContexts', 'getCustomFieldContextsForProjectsAndIssueTypes', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getProjectContextMapping - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getProjectContextMapping('fakedata', null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(100, data.response.maxResults);
+                assert.equal(0, data.response.startAt);
+                assert.equal(2, data.response.total);
+                assert.equal(true, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueCustomFieldContexts', 'getProjectContextMapping', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueCustomFieldContextsUpdateCustomFieldContextBodyParam = {
+      name: 'string',
+      description: 'string'
+    };
+    describe('#updateCustomFieldContext - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateCustomFieldContext('fakedata', 555, issueCustomFieldContextsUpdateCustomFieldContextBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueCustomFieldContexts', 'updateCustomFieldContext', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteCustomFieldContext - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteCustomFieldContext('fakedata', 555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueCustomFieldContexts', 'deleteCustomFieldContext', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueCustomFieldContextsAddIssueTypesToContextBodyParam = {
+      issueTypeIds: [
+        'string'
+      ]
+    };
+    describe('#addIssueTypesToContext - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addIssueTypesToContext('fakedata', 555, issueCustomFieldContextsAddIssueTypesToContextBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueCustomFieldContexts', 'addIssueTypesToContext', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueCustomFieldContextsRemoveIssueTypesFromContextBodyParam = {
+      issueTypeIds: [
+        'string'
+      ]
+    };
+    describe('#removeIssueTypesFromContext - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.removeIssueTypesFromContext('fakedata', 555, issueCustomFieldContextsRemoveIssueTypesFromContextBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueCustomFieldContexts', 'removeIssueTypesFromContext', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueCustomFieldContextsAssignProjectsToCustomFieldContextBodyParam = {
+      projectIds: [
+        'string'
+      ]
+    };
+    describe('#assignProjectsToCustomFieldContext - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.assignProjectsToCustomFieldContext('fakedata', 555, issueCustomFieldContextsAssignProjectsToCustomFieldContextBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueCustomFieldContexts', 'assignProjectsToCustomFieldContext', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueCustomFieldContextsRemoveCustomFieldContextFromProjectsBodyParam = {
+      projectIds: [
+        'string'
+      ]
+    };
+    describe('#removeCustomFieldContextFromProjects - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.removeCustomFieldContextFromProjects('fakedata', 555, issueCustomFieldContextsRemoveCustomFieldContextFromProjectsBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueCustomFieldContexts', 'removeCustomFieldContextFromProjects', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getOptionsForContext - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getOptionsForContext('fakedata', 555, null, null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(100, data.response.maxResults);
+                assert.equal(0, data.response.startAt);
+                assert.equal(4, data.response.total);
+                assert.equal(true, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueCustomFieldOptions', 'getOptionsForContext', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueCustomFieldOptionsUpdateCustomFieldOptionBodyParam = {
+      options: [
+        {
+          id: 'string',
+          value: 'string',
+          disabled: false
+        }
+      ]
+    };
+    describe('#updateCustomFieldOption - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.updateCustomFieldOption('fakedata', 555, issueCustomFieldOptionsUpdateCustomFieldOptionBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('success', data.response);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueCustomFieldOptions', 'updateCustomFieldOption', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueCustomFieldOptionsCreateCustomFieldOptionBodyParam = {
+      options: [
+        {
+          value: 'string',
+          optionId: 'string',
+          disabled: false
+        }
+      ]
+    };
+    describe('#createCustomFieldOption - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.createCustomFieldOption('fakedata', 555, issueCustomFieldOptionsCreateCustomFieldOptionBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(true, Array.isArray(data.response.options));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueCustomFieldOptions', 'createCustomFieldOption', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueCustomFieldOptionsReorderCustomFieldOptionsBodyParam = {
+      customFieldOptionIds: [
+        'string'
+      ]
+    };
+    describe('#reorderCustomFieldOptions - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.reorderCustomFieldOptions('fakedata', 555, issueCustomFieldOptionsReorderCustomFieldOptionsBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueCustomFieldOptions', 'reorderCustomFieldOptions', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteCustomFieldOption - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteCustomFieldOption('fakedata', 555, 555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueCustomFieldOptions', 'deleteCustomFieldOption', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getScreensForField - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getScreensForField('fakedata', null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(1, data.response.maxResults);
+                assert.equal(0, data.response.startAt);
+                assert.equal(5, data.response.total);
+                assert.equal(false, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Screens', 'getScreensForField', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const screensCreateScreenBodyParam = {
+      name: 'string'
+    };
+    describe('#createScreen - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.createScreen(screensCreateScreenBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(10005, data.response.id);
+                assert.equal('Resolve Security Issue Screen', data.response.name);
+                assert.equal('Enables changes to resolution and linked issues.', data.response.description);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Screens', 'createScreen', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const screensUpdateScreenBodyParam = {
+      name: 'string',
+      description: 'string'
+    };
+    describe('#updateScreen - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.updateScreen(555, screensUpdateScreenBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('success', data.response);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Screens', 'updateScreen', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteScreen - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteScreen(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Screens', 'deleteScreen', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAllFieldConfigurations - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getAllFieldConfigurations(null, null, null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(50, data.response.maxResults);
+                assert.equal(0, data.response.startAt);
+                assert.equal(2, data.response.total);
+                assert.equal(true, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueFieldConfigurations', 'getAllFieldConfigurations', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueFieldConfigurationsCreateFieldConfigurationBodyParam = {
+      name: 'string'
+    };
+    describe('#createFieldConfiguration - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.createFieldConfiguration(issueFieldConfigurationsCreateFieldConfigurationBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(10001, data.response.id);
+                assert.equal('My Field Configuration', data.response.name);
+                assert.equal('My field configuration description', data.response.description);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueFieldConfigurations', 'createFieldConfiguration', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueFieldConfigurationsUpdateFieldConfigurationBodyParam = {
+      name: 'string'
+    };
+    describe('#updateFieldConfiguration - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateFieldConfiguration(555, issueFieldConfigurationsUpdateFieldConfigurationBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueFieldConfigurations', 'updateFieldConfiguration', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteFieldConfiguration - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteFieldConfiguration(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueFieldConfigurations', 'deleteFieldConfiguration', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getFieldConfigurationItems - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getFieldConfigurationItems(555, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(50, data.response.maxResults);
+                assert.equal(0, data.response.startAt);
+                assert.equal(2, data.response.total);
+                assert.equal(true, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueFieldConfigurations', 'getFieldConfigurationItems', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueFieldConfigurationsUpdateFieldConfigurationItemsBodyParam = {
+      fieldConfigurationItems: [
+        {}
+      ]
+    };
+    describe('#updateFieldConfigurationItems - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateFieldConfigurationItems(555, issueFieldConfigurationsUpdateFieldConfigurationItemsBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueFieldConfigurations', 'updateFieldConfigurationItems', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAllFieldConfigurationSchemes - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getAllFieldConfigurationSchemes(null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(10, data.response.maxResults);
+                assert.equal(0, data.response.startAt);
+                assert.equal(3, data.response.total);
+                assert.equal(true, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueFieldConfigurations', 'getAllFieldConfigurationSchemes', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueFieldConfigurationsCreateFieldConfigurationSchemeBodyParam = {
+      name: 'string'
+    };
+    describe('#createFieldConfigurationScheme - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.createFieldConfigurationScheme(issueFieldConfigurationsCreateFieldConfigurationSchemeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('10002', data.response.id);
+                assert.equal('Field Configuration Scheme for software related projects', data.response.name);
+                assert.equal('We can use this one for software projects.', data.response.description);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueFieldConfigurations', 'createFieldConfigurationScheme', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getFieldConfigurationSchemeMappings - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getFieldConfigurationSchemeMappings(null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(100, data.response.maxResults);
+                assert.equal(0, data.response.startAt);
+                assert.equal(5, data.response.total);
+                assert.equal(true, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueFieldConfigurations', 'getFieldConfigurationSchemeMappings', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getFieldConfigurationSchemeProjectMapping - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getFieldConfigurationSchemeProjectMapping(null, null, [], (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(50, data.response.maxResults);
+                assert.equal(0, data.response.startAt);
+                assert.equal(5, data.response.total);
+                assert.equal(true, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueFieldConfigurations', 'getFieldConfigurationSchemeProjectMapping', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueFieldConfigurationsAssignFieldConfigurationSchemeToProjectBodyParam = {
+      projectId: 'string'
+    };
+    describe('#assignFieldConfigurationSchemeToProject - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.assignFieldConfigurationSchemeToProject(issueFieldConfigurationsAssignFieldConfigurationSchemeToProjectBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueFieldConfigurations', 'assignFieldConfigurationSchemeToProject', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueFieldConfigurationsUpdateFieldConfigurationSchemeBodyParam = {
+      name: 'string'
+    };
+    describe('#updateFieldConfigurationScheme - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateFieldConfigurationScheme(555, issueFieldConfigurationsUpdateFieldConfigurationSchemeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueFieldConfigurations', 'updateFieldConfigurationScheme', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteFieldConfigurationScheme - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteFieldConfigurationScheme(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueFieldConfigurations', 'deleteFieldConfigurationScheme', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueFieldConfigurationsSetFieldConfigurationSchemeMappingBodyParam = {
+      mappings: [
+        {}
+      ]
+    };
+    describe('#setFieldConfigurationSchemeMapping - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.setFieldConfigurationSchemeMapping(555, issueFieldConfigurationsSetFieldConfigurationSchemeMappingBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueFieldConfigurations', 'setFieldConfigurationSchemeMapping', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueFieldConfigurationsRemoveIssueTypesFromGlobalFieldConfigurationSchemeBodyParam = {
+      issueTypeIds: [
+        'string'
+      ]
+    };
+    describe('#removeIssueTypesFromGlobalFieldConfigurationScheme - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.removeIssueTypesFromGlobalFieldConfigurationScheme(555, issueFieldConfigurationsRemoveIssueTypesFromGlobalFieldConfigurationSchemeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueFieldConfigurations', 'removeIssueTypesFromGlobalFieldConfigurationScheme', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#bulkGetGroups - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.bulkGetGroups(null, null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(10, data.response.maxResults);
+                assert.equal(0, data.response.startAt);
+                assert.equal(2, data.response.total);
+                assert.equal(true, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Groups', 'bulkGetGroups', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getLicense - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getLicense((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(true, Array.isArray(data.response.applications));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('InstanceInformation', 'getLicense', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issuePropertiesBulkSetIssuesPropertiesListBodyParam = {
+      entitiesIds: [
+        3
+      ],
+      properties: {}
+    };
+    describe('#bulkSetIssuesPropertiesList - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.bulkSetIssuesPropertiesList(issuePropertiesBulkSetIssuesPropertiesListBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueProperties', 'bulkSetIssuesPropertiesList', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issuePropertiesBulkSetIssuePropertiesByIssueBodyParam = {
+      issues: [
+        {
+          issueID: 4,
+          properties: {}
+        }
+      ]
+    };
+    describe('#bulkSetIssuePropertiesByIssue - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.bulkSetIssuePropertiesByIssue(issuePropertiesBulkSetIssuePropertiesByIssueBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueProperties', 'bulkSetIssuePropertiesByIssue', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueWatchersGetIsWatchingIssueBulkBodyParam = {
+      issueIds: [
+        'string'
+      ]
+    };
+    describe('#getIsWatchingIssueBulk - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getIsWatchingIssueBulk(issueWatchersGetIsWatchingIssueBulkBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response.issuesIsWatching);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueWatchers', 'getIsWatchingIssueBulk', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getIssueSecurityLevelMembers - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getIssueSecurityLevelMembers(555, null, null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(100, data.response.maxResults);
+                assert.equal(0, data.response.startAt);
+                assert.equal(3, data.response.total);
+                assert.equal(true, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueSecurityLevel', 'getIssueSecurityLevelMembers', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getIssueTypesForProject - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getIssueTypesForProject(555, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueTypes', 'getIssueTypesForProject', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAllIssueTypeSchemes - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getAllIssueTypeSchemes(null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(100, data.response.maxResults);
+                assert.equal(0, data.response.startAt);
+                assert.equal(3, data.response.total);
+                assert.equal(true, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueTypeSchemes', 'getAllIssueTypeSchemes', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueTypeSchemesCreateIssueTypeSchemeBodyParam = {
+      name: 'string',
+      issueTypeIds: [
+        'string'
+      ]
+    };
+    describe('#createIssueTypeScheme - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.createIssueTypeScheme(issueTypeSchemesCreateIssueTypeSchemeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('10010', data.response.issueTypeSchemeId);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueTypeSchemes', 'createIssueTypeScheme', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getIssueTypeSchemesMapping - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getIssueTypeSchemesMapping(null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(100, data.response.maxResults);
+                assert.equal(0, data.response.startAt);
+                assert.equal(4, data.response.total);
+                assert.equal(true, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueTypeSchemes', 'getIssueTypeSchemesMapping', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getIssueTypeSchemeForProjects - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getIssueTypeSchemeForProjects(null, null, [], (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(100, data.response.maxResults);
+                assert.equal(0, data.response.startAt);
+                assert.equal(3, data.response.total);
+                assert.equal(true, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueTypeSchemes', 'getIssueTypeSchemeForProjects', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueTypeSchemesAssignIssueTypeSchemeToProjectBodyParam = {
+      issueTypeSchemeId: 'string',
+      projectId: 'string'
+    };
+    describe('#assignIssueTypeSchemeToProject - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.assignIssueTypeSchemeToProject(issueTypeSchemesAssignIssueTypeSchemeToProjectBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueTypeSchemes', 'assignIssueTypeSchemeToProject', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueTypeSchemesUpdateIssueTypeSchemeBodyParam = {
+      name: 'string',
+      description: 'string',
+      defaultIssueTypeId: 'string'
+    };
+    describe('#updateIssueTypeScheme - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateIssueTypeScheme(555, issueTypeSchemesUpdateIssueTypeSchemeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueTypeSchemes', 'updateIssueTypeScheme', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteIssueTypeScheme - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteIssueTypeScheme(555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueTypeSchemes', 'deleteIssueTypeScheme', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueTypeSchemesAddIssueTypesToIssueTypeSchemeBodyParam = {
+      issueTypeIds: [
+        'string'
+      ]
+    };
+    describe('#addIssueTypesToIssueTypeScheme - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addIssueTypesToIssueTypeScheme(555, issueTypeSchemesAddIssueTypesToIssueTypeSchemeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueTypeSchemes', 'addIssueTypesToIssueTypeScheme', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueTypeSchemesReorderIssueTypesInIssueTypeSchemeBodyParam = {
+      issueTypeIds: [
+        'string'
+      ]
+    };
+    describe('#reorderIssueTypesInIssueTypeScheme - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.reorderIssueTypesInIssueTypeScheme(555, issueTypeSchemesReorderIssueTypesInIssueTypeSchemeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueTypeSchemes', 'reorderIssueTypesInIssueTypeScheme', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#removeIssueTypeFromIssueTypeScheme - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.removeIssueTypeFromIssueTypeScheme(555, 555, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueTypeSchemes', 'removeIssueTypeFromIssueTypeScheme', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getIssueTypeScreenSchemes - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getIssueTypeScreenSchemes(null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(100, data.response.maxResults);
+                assert.equal(0, data.response.startAt);
+                assert.equal(2, data.response.total);
+                assert.equal(true, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueTypeScreenSchemes', 'getIssueTypeScreenSchemes', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueTypeScreenSchemesCreateIssueTypeScreenSchemeBodyParam = {
+      name: 'string',
+      issueTypeMappings: [
+        {}
+      ]
+    };
+    describe('#createIssueTypeScreenScheme - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.createIssueTypeScreenScheme(issueTypeScreenSchemesCreateIssueTypeScreenSchemeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('10001', data.response.id);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueTypeScreenSchemes', 'createIssueTypeScreenScheme', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getIssueTypeScreenSchemeMappings - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getIssueTypeScreenSchemeMappings(null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(100, data.response.maxResults);
+                assert.equal(0, data.response.startAt);
+                assert.equal(4, data.response.total);
+                assert.equal(true, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueTypeScreenSchemes', 'getIssueTypeScreenSchemeMappings', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getIssueTypeScreenSchemeProjectAssociations - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getIssueTypeScreenSchemeProjectAssociations(null, null, [], (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(100, data.response.maxResults);
+                assert.equal(0, data.response.startAt);
+                assert.equal(1, data.response.total);
+                assert.equal(true, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueTypeScreenSchemes', 'getIssueTypeScreenSchemeProjectAssociations', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueTypeScreenSchemesAssignIssueTypeScreenSchemeToProjectBodyParam = {
+      issueTypeScreenSchemeId: 'string',
+      projectId: 'string'
+    };
+    describe('#assignIssueTypeScreenSchemeToProject - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.assignIssueTypeScreenSchemeToProject(issueTypeScreenSchemesAssignIssueTypeScreenSchemeToProjectBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueTypeScreenSchemes', 'assignIssueTypeScreenSchemeToProject', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueTypeScreenSchemesUpdateIssueTypeScreenSchemeBodyParam = {
+      name: 'string',
+      description: 'string'
+    };
+    describe('#updateIssueTypeScreenScheme - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateIssueTypeScreenScheme('fakedata', issueTypeScreenSchemesUpdateIssueTypeScreenSchemeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueTypeScreenSchemes', 'updateIssueTypeScreenScheme', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteIssueTypeScreenScheme - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteIssueTypeScreenScheme('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueTypeScreenSchemes', 'deleteIssueTypeScreenScheme', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueTypeScreenSchemesAppendMappingsForIssueTypeScreenSchemeBodyParam = {
+      issueTypeMappings: [
+        {}
+      ]
+    };
+    describe('#appendMappingsForIssueTypeScreenScheme - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.appendMappingsForIssueTypeScreenScheme('fakedata', issueTypeScreenSchemesAppendMappingsForIssueTypeScreenSchemeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueTypeScreenSchemes', 'appendMappingsForIssueTypeScreenScheme', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueTypeScreenSchemesUpdateDefaultScreenSchemeBodyParam = {
+      screenSchemeId: 'string'
+    };
+    describe('#updateDefaultScreenScheme - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateDefaultScreenScheme('fakedata', issueTypeScreenSchemesUpdateDefaultScreenSchemeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueTypeScreenSchemes', 'updateDefaultScreenScheme', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueTypeScreenSchemesRemoveMappingsFromIssueTypeScreenSchemeBodyParam = {
+      issueTypeIds: [
+        'string'
+      ]
+    };
+    describe('#removeMappingsFromIssueTypeScreenScheme - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.removeMappingsFromIssueTypeScreenScheme('fakedata', issueTypeScreenSchemesRemoveMappingsFromIssueTypeScreenSchemeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueTypeScreenSchemes', 'removeMappingsFromIssueTypeScreenScheme', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getProjectsForIssueTypeScreenScheme - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getProjectsForIssueTypeScreenScheme(555, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(100, data.response.maxResults);
+                assert.equal(0, data.response.startAt);
+                assert.equal(1, data.response.total);
+                assert.equal(true, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueTypeScreenSchemes', 'getProjectsForIssueTypeScreenScheme', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const jQLGetAutoCompletePostBodyParam = {
+      projectIds: [
+        9
+      ],
+      includeCollapsedFields: false
+    };
+    describe('#getAutoCompletePost - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getAutoCompletePost(jQLGetAutoCompletePostBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(true, Array.isArray(data.response.visibleFieldNames));
+                assert.equal(true, Array.isArray(data.response.visibleFunctionNames));
+                assert.equal(true, Array.isArray(data.response.jqlReservedWords));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('JQL', 'getAutoCompletePost', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const jQLParseJqlQueriesBodyParam = {
+      queries: [
+        'string'
+      ]
+    };
+    describe('#parseJqlQueries - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.parseJqlQueries(null, jQLParseJqlQueriesBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(true, Array.isArray(data.response.queries));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('JQL', 'parseJqlQueries', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueSearchMatchIssuesBodyParam = {
+      jqls: [
+        'string'
+      ],
+      issueIds: [
+        1
+      ]
+    };
+    describe('#matchIssues - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.matchIssues(issueSearchMatchIssuesBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(true, Array.isArray(data.response.matches));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('IssueSearch', 'matchIssues', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAllLabels - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getAllLabels(null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(2, data.response.maxResults);
+                assert.equal(0, data.response.startAt);
+                assert.equal(100, data.response.total);
+                assert.equal(false, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Labels', 'getAllLabels', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getRecent - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getRecent(null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Projects', 'getRecent', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#archiveProject - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.archiveProject('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Projects', 'archiveProject', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteProjectAsynchronously - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteProjectAsynchronously('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Projects', 'deleteProjectAsynchronously', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#restore - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.restore('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('https://your-domain.atlassian.net/rest/api/3/project/EX', data.response.self);
+                assert.equal('10000', data.response.id);
+                assert.equal('EX', data.response.key);
+                assert.equal('This project was created as an example for REST.', data.response.description);
+                assert.equal('object', typeof data.response.lead);
+                assert.equal(true, Array.isArray(data.response.components));
+                assert.equal(true, Array.isArray(data.response.issueTypes));
+                assert.equal('https://www.example.com', data.response.url);
+                assert.equal('from-jira@example.com', data.response.email);
+                assert.equal('PROJECT_LEAD', data.response.assigneeType);
+                assert.equal(true, Array.isArray(data.response.versions));
+                assert.equal('Example', data.response.name);
+                assert.equal('object', typeof data.response.roles);
+                assert.equal('object', typeof data.response.avatarUrls);
+                assert.equal('object', typeof data.response.projectCategory);
+                assert.equal(false, data.response.simplified);
+                assert.equal('classic', data.response.style);
+                assert.equal('object', typeof data.response.properties);
+                assert.equal('object', typeof data.response.insight);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Projects', 'restore', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getHierarchy - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getHierarchy(555, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(10030, data.response.projectId);
+                assert.equal(true, Array.isArray(data.response.hierarchy));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Projects', 'getHierarchy', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAllAccessibleProjectTypes - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getAllAccessibleProjectTypes((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ProjectTypes', 'getAllAccessibleProjectTypes', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getFeaturesForProject - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getFeaturesForProject('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(true, Array.isArray(data.response.features));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ProjectFeatures', 'getFeaturesForProject', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const projectFeaturesToggleFeatureForProjectBodyParam = {
+      state: 'COMING_SOON'
+    };
+    describe('#toggleFeatureForProject - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.toggleFeatureForProject('fakedata', 'fakedata', projectFeaturesToggleFeatureForProjectBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('success', data.response);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ProjectFeatures', 'toggleFeatureForProject', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getProjectEmail - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getProjectEmail(555, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('jira@example.customdomain.com', data.response.emailAddress);
+                assert.equal(true, Array.isArray(data.response.emailAddressStatus));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ProjectEmail', 'getProjectEmail', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const projectEmailUpdateProjectEmailBodyParam = {
+      emailAddress: 'string',
+      emailAddressStatus: [
+        'string'
+      ]
+    };
+    describe('#updateProjectEmail - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateProjectEmail(555, projectEmailUpdateProjectEmailBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ProjectEmail', 'updateProjectEmail', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getScreenSchemes - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getScreenSchemes(null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('https://your-domain.atlassian.net/rest/api/3/screenscheme?maxResults=25&startAt=0', data.response.self);
+                assert.equal(100, data.response.maxResults);
+                assert.equal(0, data.response.startAt);
+                assert.equal(2, data.response.total);
+                assert.equal(true, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ScreenSchemes', 'getScreenSchemes', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const screenSchemesCreateScreenSchemeBodyParam = {
+      name: 'string',
+      screens: {}
+    };
+    describe('#createScreenScheme - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.createScreenScheme(screenSchemesCreateScreenSchemeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(10001, data.response.id);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ScreenSchemes', 'createScreenScheme', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const screenSchemesUpdateScreenSchemeBodyParam = {
+      name: 'string',
+      description: 'string',
+      screens: {
+        edit: 'string',
+        create: 'string',
+        view: 'string',
+        default: 'string'
+      }
+    };
+    describe('#updateScreenScheme - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateScreenScheme('fakedata', screenSchemesUpdateScreenSchemeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ScreenSchemes', 'updateScreenScheme', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteScreenScheme - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteScreenScheme('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('ScreenSchemes', 'deleteScreenScheme', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAvatarImageByType - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getAvatarImageByType('fakedata', null, null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Avatars', 'getAvatarImageByType', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAvatarImageByID - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getAvatarImageByID('fakedata', 555, null, null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Avatars', 'getAvatarImageByID', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAvatarImageByOwner - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getAvatarImageByOwner('fakedata', 'fakedata', null, null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Avatars', 'getAvatarImageByOwner', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getUserEmail - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getUserEmail('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Users', 'getUserEmail', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getUserEmailBulk - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getUserEmailBulk([], (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Users', 'getUserEmailBulk', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAllUsersDefault - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getAllUsersDefault(null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Users', 'getAllUsersDefault', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAllUsers - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getAllUsers(null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+                assert.equal('object', typeof data.response[1]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Users', 'getAllUsers', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDynamicWebhooksForApp - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getDynamicWebhooksForApp(null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(3, data.response.maxResults);
+                assert.equal(0, data.response.startAt);
+                assert.equal(3, data.response.total);
+                assert.equal(true, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Webhooks', 'getDynamicWebhooksForApp', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const webhooksRegisterDynamicWebhooksBodyParam = {
+      webhooks: [
+        {}
+      ],
+      url: 'string'
+    };
+    describe('#registerDynamicWebhooks - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.registerDynamicWebhooks(webhooksRegisterDynamicWebhooksBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(true, Array.isArray(data.response.webhookRegistrationResult));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Webhooks', 'registerDynamicWebhooks', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const webhooksDeleteWebhookByIdBodyParam = {
+      webhookIds: [
+        4
+      ]
+    };
+    describe('#deleteWebhookById - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteWebhookById(webhooksDeleteWebhookByIdBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Webhooks', 'deleteWebhookById', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getFailedWebhooks - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getFailedWebhooks(null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(true, Array.isArray(data.response.values));
+                assert.equal(100, data.response.maxResults);
+                assert.equal('https://your-domain.atlassian.net/rest/api/3/webhook/failed?failedAfter=1573540473480&maxResults=100', data.response.next);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Webhooks', 'getFailedWebhooks', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const webhooksRefreshWebhooksBodyParam = {
+      webhookIds: [
+        8
+      ]
+    };
+    describe('#refreshWebhooks - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.refreshWebhooks(webhooksRefreshWebhooksBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('success', data.response);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Webhooks', 'refreshWebhooks', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const workflowsCreateWorkflowBodyParam = {
+      name: 'string',
+      transitions: [
+        {
+          name: 'string'
+        }
+      ],
+      statuses: [
+        {}
+      ]
+    };
+    describe('#createWorkflow - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.createWorkflow(workflowsCreateWorkflowBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('Workflow 1', data.response.name);
+                assert.equal('fb8731c5-aa05-4453-bf79-b583a1c87736', data.response.entityId);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Workflows', 'createWorkflow', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getWorkflowsPaginated - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getWorkflowsPaginated(null, null, null, null, null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(1, data.response.maxResults);
+                assert.equal(0, data.response.startAt);
+                assert.equal(5, data.response.total);
+                assert.equal(false, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Workflows', 'getWorkflowsPaginated', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteInactiveWorkflow - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteInactiveWorkflow('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Workflows', 'deleteInactiveWorkflow', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getWorkflowTransitionRuleConfigurations - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getWorkflowTransitionRuleConfigurations(null, null, [], null, null, null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(10, data.response.maxResults);
+                assert.equal(0, data.response.startAt);
+                assert.equal(1, data.response.total);
+                assert.equal(true, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('WorkflowTransitionRules', 'getWorkflowTransitionRuleConfigurations', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const workflowTransitionRulesUpdateWorkflowTransitionRuleConfigurationsBodyParam = {
+      workflows: [
+        {}
+      ]
+    };
+    describe('#updateWorkflowTransitionRuleConfigurations - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.updateWorkflowTransitionRuleConfigurations(workflowTransitionRulesUpdateWorkflowTransitionRuleConfigurationsBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('success', data.response);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('WorkflowTransitionRules', 'updateWorkflowTransitionRuleConfigurations', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const workflowTransitionRulesDeleteWorkflowTransitionRuleConfigurationsBodyParam = {
+      workflows: [
+        {}
+      ]
+    };
+    describe('#deleteWorkflowTransitionRuleConfigurations - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.deleteWorkflowTransitionRuleConfigurations(workflowTransitionRulesDeleteWorkflowTransitionRuleConfigurationsBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('success', data.response);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('WorkflowTransitionRules', 'deleteWorkflowTransitionRuleConfigurations', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAllWorkflowSchemes - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getAllWorkflowSchemes(null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(50, data.response.maxResults);
+                assert.equal(0, data.response.startAt);
+                assert.equal(2, data.response.total);
+                assert.equal(true, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('WorkflowSchemes', 'getAllWorkflowSchemes', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getWorkflowSchemeProjectAssociations - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getWorkflowSchemeProjectAssociations([], (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('WorkflowSchemeProjectAssociations', 'getWorkflowSchemeProjectAssociations', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const workflowSchemeProjectAssociationsAssignSchemeToProjectBodyParam = {
+      projectId: 'string'
+    };
+    describe('#assignSchemeToProject - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.assignSchemeToProject(workflowSchemeProjectAssociationsAssignSchemeToProjectBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('WorkflowSchemeProjectAssociations', 'assignSchemeToProject', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const workflowSchemeDraftsPublishDraftWorkflowSchemeBodyParam = {
+      statusMappings: [
+        {
+          issueTypeId: 'string',
+          statusId: 'string',
+          newStatusId: 'string'
+        }
+      ]
+    };
+    describe('#publishDraftWorkflowScheme - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.publishDraftWorkflowScheme(555, null, workflowSchemeDraftsPublishDraftWorkflowSchemeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-jira-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('WorkflowSchemeDrafts', 'publishDraftWorkflowScheme', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
   });
 });