@itentialopensource/adapter-jira 1.7.6 → 2.0.0

package/test/integration/adapterTestIntegration.js

@@ -15677,5 +15677,1908 @@ describe('[integration] Jira Adapter Test', () => {
         }
       }).timeout(attemptTimeout);
     });
+
+    describe('#getBanner - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getBanner((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('This is a public, enabled, non-dismissible banner, set using the API', data.response.message);
+                assert.equal(false, data.response.isDismissible);
+                assert.equal(true, data.response.isEnabled);
+                assert.equal('9HN2FJK9DM8BHRWERVW3RRTGDJ4G4D5C', data.response.hashId);
+                assert.equal('public', data.response.visibility);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('AnnouncementBanner', 'getBanner', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const announcementBannerSetBannerBodyParam = {
+      isDismissible: false,
+      isEnabled: true,
+      message: 'string',
+      visibility: 'string'
+    };
+    describe('#setBanner - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.setBanner(announcementBannerSetBannerBodyParam, (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('AnnouncementBanner', 'setBanner', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAllAvailableDashboardGadgets - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getAllAvailableDashboardGadgets((data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(true, Array.isArray(data.response.gadgets));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Dashboards', 'getAllAvailableDashboardGadgets', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAllGadgets - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getAllGadgets(555, null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(true, Array.isArray(data.response.gadgets));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Dashboards', 'getAllGadgets', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const dashboardsAddGadgetBodyParam = {
+      color: 'string',
+      ignoreUriAndModuleKeyValidation: true,
+      moduleKey: 'string',
+      position: {
+        'The column position of the gadget.': 10,
+        'The row position of the gadget.': 6
+      },
+      title: 'string',
+      uri: 'string'
+    };
+    describe('#addGadget - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.addGadget(555, dashboardsAddGadgetBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(10001, data.response.id);
+                assert.equal('com.atlassian.plugins.atlassian-connect-plugin:com.atlassian.connect.node.sample-addon__sample-dashboard-item', data.response.moduleKey);
+                assert.equal('blue', data.response.color);
+                assert.equal('object', typeof data.response.position);
+                assert.equal('Issue statistics', data.response.title);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Dashboards', 'addGadget', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const dashboardsUpdateGadgetBodyParam = {
+      color: 'string',
+      position: {
+        'The column position of the gadget.': 8,
+        'The row position of the gadget.': 3
+      },
+      title: 'string'
+    };
+    describe('#updateGadget - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateGadget(555, 555, dashboardsUpdateGadgetBodyParam, (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', 'updateGadget', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#removeGadget - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.removeGadget(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('Dashboards', 'removeGadget', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTrashedFieldsPaginated - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getTrashedFieldsPaginated(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(1, data.response.total);
+                assert.equal(false, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Issuefields', 'getTrashedFieldsPaginated', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const filtersChangeFilterOwnerBodyParam = {
+      accountId: 'string'
+    };
+    describe('#changeFilterOwner - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.changeFilterOwner(555, filtersChangeFilterOwnerBodyParam, (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('Filters', 'changeFilterOwner', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueSecuritySchemesCreateIssueSecuritySchemeBodyParam = {
+      name: 'string'
+    };
+    describe('#createIssueSecurityScheme - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.createIssueSecurityScheme(issueSecuritySchemesCreateIssueSecuritySchemeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('10001', data.response.id);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Issuesecurityschemes', 'createIssueSecurityScheme', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSecurityLevels - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getSecurityLevels(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(1, data.response.total);
+                assert.equal(true, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Issuesecurityschemes', 'getSecurityLevels', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueSecuritySchemesSetDefaultLevelsBodyParam = {
+      defaultValues: [
+        {}
+      ]
+    };
+    describe('#setDefaultLevels - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.setDefaultLevels(issueSecuritySchemesSetDefaultLevelsBodyParam, (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('Issuesecurityschemes', 'setDefaultLevels', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSecurityLevelMembers - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getSecurityLevelMembers(null, 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(3, data.response.total);
+                assert.equal(true, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Issuesecurityschemes', 'getSecurityLevelMembers', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#searchProjectsUsingSecuritySchemes - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.searchProjectsUsingSecuritySchemes(null, null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('10000', data.response.issueSecuritySchemeId);
+                assert.equal('10000', data.response.projectId);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Issuesecurityschemes', 'searchProjectsUsingSecuritySchemes', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#searchSecuritySchemes - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.searchSecuritySchemes(null, null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(10000, data.response.id);
+                assert.equal('https://your-domain.atlassian.net/rest/api/3/issuesecurityscheme/10000', data.response.self);
+                assert.equal('Default scheme', data.response.name);
+                assert.equal('Default scheme description', data.response.description);
+                assert.equal(10001, data.response.defaultLevel);
+                assert.equal(true, Array.isArray(data.response.projectIds));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Issuesecurityschemes', 'searchSecuritySchemes', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueSecuritySchemesUpdateIssueSecuritySchemeBodyParam = {
+      description: 'string',
+      name: 'string'
+    };
+    describe('#updateIssueSecurityScheme - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateIssueSecurityScheme('fakedata', issueSecuritySchemesUpdateIssueSecuritySchemeBodyParam, (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('Issuesecurityschemes', 'updateIssueSecurityScheme', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteSecurityScheme - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteSecurityScheme('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('Issuesecurityschemes', 'deleteSecurityScheme', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueSecuritySchemesAddSecurityLevelBodyParam = {
+      levels: [
+        {
+          description: 'string',
+          isDefault: false,
+          members: [
+            {
+              parameter: 'string',
+              type: 'string'
+            }
+          ],
+          name: 'string'
+        }
+      ]
+    };
+    describe('#addSecurityLevel - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addSecurityLevel('fakedata', issueSecuritySchemesAddSecurityLevelBodyParam, (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('Issuesecurityschemes', 'addSecurityLevel', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueSecuritySchemesUpdateSecurityLevelBodyParam = {
+      description: 'string',
+      name: 'string'
+    };
+    describe('#updateSecurityLevel - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateSecurityLevel('fakedata', 'fakedata', issueSecuritySchemesUpdateSecurityLevelBodyParam, (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('Issuesecurityschemes', 'updateSecurityLevel', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#removeLevel - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.removeLevel('fakedata', '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('Issuesecurityschemes', 'removeLevel', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueSecuritySchemesAddSecurityLevelMembersBodyParam = {};
+    describe('#addSecurityLevelMembers - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addSecurityLevelMembers('fakedata', 'fakedata', issueSecuritySchemesAddSecurityLevelMembersBodyParam, (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('Issuesecurityschemes', 'addSecurityLevelMembers', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#removeMemberFromSecurityLevel - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.removeMemberFromSecurityLevel('fakedata', 'fakedata', '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('Issuesecurityschemes', 'removeMemberFromSecurityLevel', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const jQLSanitiseJqlQueriesBodyParam = {
+      queries: [
+        {}
+      ]
+    };
+    describe('#sanitiseJqlQueries - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.sanitiseJqlQueries(jQLSanitiseJqlQueriesBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(true, Array.isArray(data.response.queries));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('JQL', 'sanitiseJqlQueries', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getPrecomputations - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getPrecomputations(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(1, data.response.total);
+                assert.equal(true, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('JQLFunctionsApps', 'getPrecomputations', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const jQLFunctionsAppsUpdatePrecomputationsBodyParam = {
+      values: [
+        {
+          id: 1,
+          value: 'string'
+        }
+      ]
+    };
+    describe('#updatePrecomputations - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updatePrecomputations(jQLFunctionsAppsUpdatePrecomputationsBodyParam, (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('JQLFunctionsApps', 'updatePrecomputations', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getApproximateLicenseCount - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getApproximateLicenseCount((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('LicenseMetrics', 'getApproximateLicenseCount', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getApproximateApplicationLicenseCount - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getApproximateApplicationLicenseCount('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('LicenseMetrics', 'getApproximateApplicationLicenseCount', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueNotificationSchemesCreateNotificationSchemeBodyParam = {
+      name: 'string'
+    };
+    describe('#createNotificationScheme - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.createNotificationScheme(issueNotificationSchemesCreateNotificationSchemeBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('10001', data.response.id);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Issuenotificationschemes', 'createNotificationScheme', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNotificationSchemeToProjectMappings - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getNotificationSchemeToProjectMappings(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(4, data.response.total);
+                assert.equal(true, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Issuenotificationschemes', 'getNotificationSchemeToProjectMappings', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueNotificationSchemesUpdateNotificationSchemeBodyParam = {
+      description: 'string',
+      name: 'string'
+    };
+    describe('#updateNotificationScheme - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateNotificationScheme('fakedata', issueNotificationSchemesUpdateNotificationSchemeBodyParam, (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('Issuenotificationschemes', 'updateNotificationScheme', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueNotificationSchemesAddNotificationsBodyParam = {
+      notificationSchemeEvents: [
+        {}
+      ]
+    };
+    describe('#addNotifications - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addNotifications('fakedata', issueNotificationSchemesAddNotificationsBodyParam, (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('Issuenotificationschemes', 'addNotifications', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteNotificationScheme - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteNotificationScheme('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('Issuenotificationschemes', 'deleteNotificationScheme', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#removeNotificationFromNotificationScheme - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.removeNotificationFromNotificationScheme('fakedata', '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('Issuenotificationschemes', 'removeNotificationFromNotificationScheme', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issuePrioritiesCreatePriorityBodyParam = {
+      name: 'string',
+      statusColor: 'string'
+    };
+    describe('#createPriority - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.createPriority(issuePrioritiesCreatePriorityBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('10001', data.response.id);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Issuepriorities', 'createPriority', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issuePrioritiesSetDefaultPriorityBodyParam = {
+      id: 'string'
+    };
+    describe('#setDefaultPriority - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.setDefaultPriority(issuePrioritiesSetDefaultPriorityBodyParam, (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('Issuepriorities', 'setDefaultPriority', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issuePrioritiesMovePrioritiesBodyParam = {
+      ids: [
+        'string'
+      ]
+    };
+    describe('#movePriorities - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.movePriorities(issuePrioritiesMovePrioritiesBodyParam, (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('Issuepriorities', 'movePriorities', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#searchPriorities - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.searchPriorities(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('Issuepriorities', 'searchPriorities', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issuePrioritiesUpdatePriorityBodyParam = {
+      description: 'string',
+      iconUrl: '/images/icons/priorities/medium.png',
+      name: 'string',
+      statusColor: 'string'
+    };
+    describe('#updatePriority - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updatePriority('fakedata', issuePrioritiesUpdatePriorityBodyParam, (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('Issuepriorities', 'updatePriority', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deletePriority - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deletePriority('fakedata', '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('Issuepriorities', 'deletePriority', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueResolutionsCreateResolutionBodyParam = {
+      name: 'string'
+    };
+    describe('#createResolution - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.createResolution(issueResolutionsCreateResolutionBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('10001', data.response.id);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Issueresolutions', 'createResolution', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueResolutionsSetDefaultResolutionBodyParam = {
+      id: 'string'
+    };
+    describe('#setDefaultResolution - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.setDefaultResolution(issueResolutionsSetDefaultResolutionBodyParam, (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('Issueresolutions', 'setDefaultResolution', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueResolutionsMoveResolutionsBodyParam = {
+      ids: [
+        'string'
+      ]
+    };
+    describe('#moveResolutions - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.moveResolutions(issueResolutionsMoveResolutionsBodyParam, (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('Issueresolutions', 'moveResolutions', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#searchResolutions - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.searchResolutions(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(1, data.response.total);
+                assert.equal(true, data.response.isLast);
+                assert.equal(true, Array.isArray(data.response.values));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Issueresolutions', 'searchResolutions', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const issueResolutionsUpdateResolutionBodyParam = {
+      name: 'string'
+    };
+    describe('#updateResolution - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateResolution('fakedata', issueResolutionsUpdateResolutionBodyParam, (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('Issueresolutions', 'updateResolution', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteResolution - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteResolution('fakedata', '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('Issueresolutions', 'deleteResolution', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getStatusesById - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getStatusesById(null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Status', 'getStatusesById', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const statusUpdateStatusesBodyParam = {
+      statuses: [
+        {
+          description: 'string',
+          id: 'string',
+          name: 'string',
+          statusCategory: 'DONE'
+        }
+      ]
+    };
+    describe('#updateStatuses - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateStatuses(statusUpdateStatusesBodyParam, (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('Status', 'updateStatuses', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const statusCreateStatusesBodyParam = {
+      scope: {},
+      statuses: [
+        {}
+      ]
+    };
+    describe('#createStatuses - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.createStatuses(statusCreateStatusesBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('object', typeof data.response[0]);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Status', 'createStatuses', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteStatusesById - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteStatusesById(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('Status', 'deleteStatusesById', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#search - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.search(null, null, null, null, null, null, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('https://your-domain.atlassian.net/rest/api/3/statuses/search?startAt=0&maxResults=2', data.response.self);
+                assert.equal('https://your-domain.atlassian.net/rest/api/3/statuses/search?startAt=2&maxResults=2', data.response.nextPage);
+                assert.equal(2, 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('Status', 'search', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getUiModifications - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.getUiModifications(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('UIModificationsApps', 'getUiModifications', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const uIModificationsAppsCreateUiModificationBodyParam = {
+      name: 'string'
+    };
+    describe('#createUiModification - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.createUiModification(uIModificationsAppsCreateUiModificationBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('d7dbda8a-6239-4b63-8e13-a5ef975c8e61', data.response.id);
+                assert.equal('https://api.atlassian.com/ex/jira/{cloudid}/rest/api/2/uiModifications/d7dbda8a-6239-4b63-8e13-a5ef975c8e61', data.response.self);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('UIModificationsApps', 'createUiModification', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const uIModificationsAppsUpdateUiModificationBodyParam = {
+      contexts: [
+        {
+          id: 'string',
+          isAvailable: true,
+          issueTypeId: 'string',
+          projectId: 'string',
+          viewType: 'string'
+        }
+      ],
+      data: 'string',
+      description: 'string',
+      name: 'string'
+    };
+    describe('#updateUiModification - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateUiModification('fakedata', uIModificationsAppsUpdateUiModificationBodyParam, (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('UIModificationsApps', 'updateUiModification', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteUiModification - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteUiModification('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('UIModificationsApps', 'deleteUiModification', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#addonPropertiesResourceGetAddonPropertiesGet - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.addonPropertiesResourceGetAddonPropertiesGet('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal(true, Array.isArray(data.response.keys));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('AppProperties', 'addonPropertiesResourceGetAddonPropertiesGet', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#addonPropertiesResourceGetAddonPropertyGet - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.addonPropertiesResourceGetAddonPropertyGet('fakedata', 'fakedata', (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('https://your-domain.atlassian.net/jira/rest/atlassian-connect/1/addon/example.app.key/properties/propertyKey', data.response.self);
+                assert.equal('propertyKey', data.response.key);
+                assert.equal('propertyValue', data.response.value);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('AppProperties', 'addonPropertiesResourceGetAddonPropertyGet', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const appPropertiesAddonPropertiesResourcePutAddonPropertyPutBodyParam = {};
+    describe('#addonPropertiesResourcePutAddonPropertyPut - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.addonPropertiesResourcePutAddonPropertyPut('fakedata', 'fakedata', appPropertiesAddonPropertiesResourcePutAddonPropertyPutBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('success', data.response);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('AppProperties', 'addonPropertiesResourcePutAddonPropertyPut', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#addonPropertiesResourceDeleteAddonPropertyDelete - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addonPropertiesResourceDeleteAddonPropertyDelete('fakedata', '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('AppProperties', 'addonPropertiesResourceDeleteAddonPropertyDelete', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const appPropertiesAddonPropertiesResourcePutAppPropertyPutBodyParam = {};
+    describe('#addonPropertiesResourcePutAppPropertyPut - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.addonPropertiesResourcePutAppPropertyPut('fakedata', appPropertiesAddonPropertiesResourcePutAppPropertyPutBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('success', data.response);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('AppProperties', 'addonPropertiesResourcePutAppPropertyPut', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#addonPropertiesResourceDeleteAppPropertyDelete - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addonPropertiesResourceDeleteAppPropertyDelete('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('AppProperties', 'addonPropertiesResourceDeleteAppPropertyDelete', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#dynamicModulesResourceGetModulesGet - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.dynamicModulesResourceGetModulesGet((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('DynamicModules', 'dynamicModulesResourceGetModulesGet', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const dynamicModulesDynamicModulesResourceRegisterModulesPostBodyParam = {
+      modules: [
+        {
+          description: {
+            value: 'field with team'
+          },
+          type: 'single_select',
+          extractions: [
+            {
+              path: 'category',
+              type: 'text',
+              name: 'categoryName'
+            }
+          ],
+          name: {
+            value: 'Team'
+          },
+          key: 'team-field'
+        }
+      ]
+    };
+    describe('#dynamicModulesResourceRegisterModulesPost - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.dynamicModulesResourceRegisterModulesPost(dynamicModulesDynamicModulesResourceRegisterModulesPostBodyParam, (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('DynamicModules', 'dynamicModulesResourceRegisterModulesPost', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#dynamicModulesResourceRemoveModulesDelete - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.dynamicModulesResourceRemoveModulesDelete(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('DynamicModules', 'dynamicModulesResourceRemoveModulesDelete', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const appMigrationAppIssueFieldValueUpdateResourceUpdateIssueFieldsPutBodyParam = {
+      updateValueList: [
+        {
+          _type: 'StringIssueField',
+          fieldID: 1,
+          issueID: 9,
+          number: 1,
+          optionID: 'string',
+          richText: 'string',
+          string: 'string',
+          text: 'string'
+        }
+      ]
+    };
+    describe('#appIssueFieldValueUpdateResourceUpdateIssueFieldsPut - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.appIssueFieldValueUpdateResourceUpdateIssueFieldsPut(appMigrationAppIssueFieldValueUpdateResourceUpdateIssueFieldsPutBodyParam, (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('AppMigration', 'appIssueFieldValueUpdateResourceUpdateIssueFieldsPut', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const appMigrationMigrationResourceUpdateEntityPropertiesValuePutBodyParam = [
+      {}
+    ];
+    describe('#migrationResourceUpdateEntityPropertiesValuePut - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.migrationResourceUpdateEntityPropertiesValuePut('fakedata', appMigrationMigrationResourceUpdateEntityPropertiesValuePutBodyParam, (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('AppMigration', 'migrationResourceUpdateEntityPropertiesValuePut', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const appMigrationMigrationResourceWorkflowRuleSearchPostBodyParam = {
+      ruleIds: [
+        '55d44f1d-c859-42e5-9c27-2c5ec3f340b1'
+      ],
+      workflowEntityId: 'a498d711-685d-428d-8c3e-bc03bb450ea7'
+    };
+    describe('#migrationResourceWorkflowRuleSearchPost - errors', () => {
+      it('should work if integrated or standalone with mockdata', (done) => {
+        try {
+          a.migrationResourceWorkflowRuleSearchPost(appMigrationMigrationResourceWorkflowRuleSearchPostBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                runCommonAsserts(data, error);
+                assert.equal('a498d711-685d-428d-8c3e-bc03bb450ea7', data.response.workflowEntityId);
+                assert.equal(true, Array.isArray(data.response.invalidRules));
+                assert.equal(true, Array.isArray(data.response.validRules));
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('AppMigration', 'migrationResourceWorkflowRuleSearchPost', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
   });
 });