@itentialopensource/adapter-digicert_pki 0.1.1 → 1.0.0

package/test/unit/adapterTestUnit.js

@@ -2274,5 +2274,4871 @@ describe('[unit] Digicert Adapter Test', () => {
         }
       }).timeout(attemptTimeout);
     });
+
+    describe('#listCertificates - errors', () => {
+      it('should have a listCertificates function', (done) => {
+        try {
+          assert.equal(true, typeof a.listCertificates === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getExampleCertificateRequestCertificateID - errors', () => {
+      it('should have a getExampleCertificateRequestCertificateID function', (done) => {
+        try {
+          assert.equal(true, typeof a.getExampleCertificateRequestCertificateID === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateId', (done) => {
+        try {
+          a.getExampleCertificateRequestCertificateID(null, (data, error) => {
+            try {
+              const displayE = 'certificateId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-getExampleCertificateRequestCertificateID', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#renewCertificate - errors', () => {
+      it('should have a renewCertificate function', (done) => {
+        try {
+          assert.equal(true, typeof a.renewCertificate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateId', (done) => {
+        try {
+          a.renewCertificate(null, null, (data, error) => {
+            try {
+              const displayE = 'certificateId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-renewCertificate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#renewBySerial - errors', () => {
+      it('should have a renewBySerial function', (done) => {
+        try {
+          assert.equal(true, typeof a.renewBySerial === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateSerialNumber', (done) => {
+        try {
+          a.renewBySerial(null, null, (data, error) => {
+            try {
+              const displayE = 'certificateSerialNumber is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-renewBySerial', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#revokeCertificate - errors', () => {
+      it('should have a revokeCertificate function', (done) => {
+        try {
+          assert.equal(true, typeof a.revokeCertificate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateId', (done) => {
+        try {
+          a.revokeCertificate(null, null, (data, error) => {
+            try {
+              const displayE = 'certificateId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-revokeCertificate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateNote - errors', () => {
+      it('should have a updateNote function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateNote === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateId', (done) => {
+        try {
+          a.updateNote(null, null, (data, error) => {
+            try {
+              const displayE = 'certificateId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-updateNote', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#revokeCertificateBySerialNumber - errors', () => {
+      it('should have a revokeCertificateBySerialNumber function', (done) => {
+        try {
+          assert.equal(true, typeof a.revokeCertificateBySerialNumber === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateSerialNumber', (done) => {
+        try {
+          a.revokeCertificateBySerialNumber(null, null, (data, error) => {
+            try {
+              const displayE = 'certificateSerialNumber is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-revokeCertificateBySerialNumber', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#downloadCertificate - errors', () => {
+      it('should have a downloadCertificate function', (done) => {
+        try {
+          assert.equal(true, typeof a.downloadCertificate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateId', (done) => {
+        try {
+          a.downloadCertificate(null, null, (data, error) => {
+            try {
+              const displayE = 'certificateId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-downloadCertificate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing format', (done) => {
+        try {
+          a.downloadCertificate('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'format is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-downloadCertificate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#downloadCertificateBySerialNumber - errors', () => {
+      it('should have a downloadCertificateBySerialNumber function', (done) => {
+        try {
+          assert.equal(true, typeof a.downloadCertificateBySerialNumber === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateSerialNumber', (done) => {
+        try {
+          a.downloadCertificateBySerialNumber(null, null, (data, error) => {
+            try {
+              const displayE = 'certificateSerialNumber is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-downloadCertificateBySerialNumber', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing format', (done) => {
+        try {
+          a.downloadCertificateBySerialNumber('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'format is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-downloadCertificateBySerialNumber', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#importCertificate - errors', () => {
+      it('should have a importCertificate function', (done) => {
+        try {
+          assert.equal(true, typeof a.importCertificate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing enrollmentProfileId', (done) => {
+        try {
+          a.importCertificate(null, null, (data, error) => {
+            try {
+              const displayE = 'enrollmentProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-importCertificate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getImportDetails - errors', () => {
+      it('should have a getImportDetails function', (done) => {
+        try {
+          assert.equal(true, typeof a.getImportDetails === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing jobId', (done) => {
+        try {
+          a.getImportDetails(null, (data, error) => {
+            try {
+              const displayE = 'jobId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-getImportDetails', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getCertificateStatus - errors', () => {
+      it('should have a getCertificateStatus function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCertificateStatus === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateSerialNumber', (done) => {
+        try {
+          a.getCertificateStatus(null, (data, error) => {
+            try {
+              const displayE = 'certificateSerialNumber is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-getCertificateStatus', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getCertificateStatusById - errors', () => {
+      it('should have a getCertificateStatusById function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCertificateStatusById === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateId', (done) => {
+        try {
+          a.getCertificateStatusById(null, (data, error) => {
+            try {
+              const displayE = 'certificateId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-getCertificateStatusById', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listCertificatesByCertificateValue - errors', () => {
+      it('should have a listCertificatesByCertificateValue function', (done) => {
+        try {
+          assert.equal(true, typeof a.listCertificatesByCertificateValue === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateValue', (done) => {
+        try {
+          a.listCertificatesByCertificateValue(null, null, null, (data, error) => {
+            try {
+              const displayE = 'certificateValue is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-listCertificatesByCertificateValue', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#downloadApprovedCertificate - errors', () => {
+      it('should have a downloadApprovedCertificate function', (done) => {
+        try {
+          assert.equal(true, typeof a.downloadApprovedCertificate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateId', (done) => {
+        try {
+          a.downloadApprovedCertificate(null, null, (data, error) => {
+            try {
+              const displayE = 'certificateId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-downloadApprovedCertificate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.downloadApprovedCertificate('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-downloadApprovedCertificate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listAuthenticationCACertificates - errors', () => {
+      it('should have a listAuthenticationCACertificates function', (done) => {
+        try {
+          assert.equal(true, typeof a.listAuthenticationCACertificates === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listAuthenticationCACertificatesByAccount - errors', () => {
+      it('should have a listAuthenticationCACertificatesByAccount function', (done) => {
+        try {
+          assert.equal(true, typeof a.listAuthenticationCACertificatesByAccount === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing accountId', (done) => {
+        try {
+          a.listAuthenticationCACertificatesByAccount(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'accountId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-listAuthenticationCACertificatesByAccount', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#uploadAuthenticationCACertificate - errors', () => {
+      it('should have a uploadAuthenticationCACertificate function', (done) => {
+        try {
+          assert.equal(true, typeof a.uploadAuthenticationCACertificate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing accountId', (done) => {
+        try {
+          a.uploadAuthenticationCACertificate(null, null, (data, error) => {
+            try {
+              const displayE = 'accountId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-uploadAuthenticationCACertificate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAuthenticationCACertificate - errors', () => {
+      it('should have a getAuthenticationCACertificate function', (done) => {
+        try {
+          assert.equal(true, typeof a.getAuthenticationCACertificate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing accountId', (done) => {
+        try {
+          a.getAuthenticationCACertificate(null, null, (data, error) => {
+            try {
+              const displayE = 'accountId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-getAuthenticationCACertificate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing authenticationCaId', (done) => {
+        try {
+          a.getAuthenticationCACertificate('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'authenticationCaId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-getAuthenticationCACertificate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteAuthenticationCACertificate - errors', () => {
+      it('should have a deleteAuthenticationCACertificate function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteAuthenticationCACertificate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing accountId', (done) => {
+        try {
+          a.deleteAuthenticationCACertificate(null, null, (data, error) => {
+            try {
+              const displayE = 'accountId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-deleteAuthenticationCACertificate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing authenticationCaId', (done) => {
+        try {
+          a.deleteAuthenticationCACertificate('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'authenticationCaId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-deleteAuthenticationCACertificate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createAuthenticationCATemplate - errors', () => {
+      it('should have a createAuthenticationCATemplate function', (done) => {
+        try {
+          assert.equal(true, typeof a.createAuthenticationCATemplate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listAuthenticationCATemplate - errors', () => {
+      it('should have a listAuthenticationCATemplate function', (done) => {
+        try {
+          assert.equal(true, typeof a.listAuthenticationCATemplate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateAuthenticationCATemplate - errors', () => {
+      it('should have a updateAuthenticationCATemplate function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateAuthenticationCATemplate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing authenticationCaTemplateId', (done) => {
+        try {
+          a.updateAuthenticationCATemplate(null, null, (data, error) => {
+            try {
+              const displayE = 'authenticationCaTemplateId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-updateAuthenticationCATemplate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAuthenticationCATemplate - errors', () => {
+      it('should have a getAuthenticationCATemplate function', (done) => {
+        try {
+          assert.equal(true, typeof a.getAuthenticationCATemplate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing authenticationCaTemplateId', (done) => {
+        try {
+          a.getAuthenticationCATemplate(null, (data, error) => {
+            try {
+              const displayE = 'authenticationCaTemplateId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-getAuthenticationCATemplate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#disableAuthenticationCATemplate - errors', () => {
+      it('should have a disableAuthenticationCATemplate function', (done) => {
+        try {
+          assert.equal(true, typeof a.disableAuthenticationCATemplate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing authenticationCaTemplateId', (done) => {
+        try {
+          a.disableAuthenticationCATemplate(null, (data, error) => {
+            try {
+              const displayE = 'authenticationCaTemplateId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-disableAuthenticationCATemplate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteAuthenticationCATemplate - errors', () => {
+      it('should have a deleteAuthenticationCATemplate function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteAuthenticationCATemplate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing authenticationCaTemplateId', (done) => {
+        try {
+          a.deleteAuthenticationCATemplate(null, (data, error) => {
+            try {
+              const displayE = 'authenticationCaTemplateId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-deleteAuthenticationCATemplate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#restoreAuthenticationCATemplate - errors', () => {
+      it('should have a restoreAuthenticationCATemplate function', (done) => {
+        try {
+          assert.equal(true, typeof a.restoreAuthenticationCATemplate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing authenticationCaTemplateId', (done) => {
+        try {
+          a.restoreAuthenticationCATemplate(null, (data, error) => {
+            try {
+              const displayE = 'authenticationCaTemplateId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-restoreAuthenticationCATemplate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#enableAuthenticationCATemplate - errors', () => {
+      it('should have a enableAuthenticationCATemplate function', (done) => {
+        try {
+          assert.equal(true, typeof a.enableAuthenticationCATemplate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing authenticationCaTemplateId', (done) => {
+        try {
+          a.enableAuthenticationCATemplate(null, (data, error) => {
+            try {
+              const displayE = 'authenticationCaTemplateId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-enableAuthenticationCATemplate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listAssignableAuthenticationCACertificates - errors', () => {
+      it('should have a listAssignableAuthenticationCACertificates function', (done) => {
+        try {
+          assert.equal(true, typeof a.listAssignableAuthenticationCACertificates === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing enrollmentProfileId', (done) => {
+        try {
+          a.listAssignableAuthenticationCACertificates(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'enrollmentProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-listAssignableAuthenticationCACertificates', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#addAuthenticationCertificate - errors', () => {
+      it('should have a addAuthenticationCertificate function', (done) => {
+        try {
+          assert.equal(true, typeof a.addAuthenticationCertificate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listAuthenticationCertificates - errors', () => {
+      it('should have a listAuthenticationCertificates function', (done) => {
+        try {
+          assert.equal(true, typeof a.listAuthenticationCertificates === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAuthenticationCertificateDetails - errors', () => {
+      it('should have a getAuthenticationCertificateDetails function', (done) => {
+        try {
+          assert.equal(true, typeof a.getAuthenticationCertificateDetails === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing authenticationCertificateId', (done) => {
+        try {
+          a.getAuthenticationCertificateDetails(null, (data, error) => {
+            try {
+              const displayE = 'authenticationCertificateId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-getAuthenticationCertificateDetails', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateAuthenticationCertificate - errors', () => {
+      it('should have a updateAuthenticationCertificate function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateAuthenticationCertificate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing authenticationCertificateId', (done) => {
+        try {
+          a.updateAuthenticationCertificate(null, null, (data, error) => {
+            try {
+              const displayE = 'authenticationCertificateId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-updateAuthenticationCertificate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#disableAuthenticationCertificate - errors', () => {
+      it('should have a disableAuthenticationCertificate function', (done) => {
+        try {
+          assert.equal(true, typeof a.disableAuthenticationCertificate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing authenticationCertificateId', (done) => {
+        try {
+          a.disableAuthenticationCertificate(null, (data, error) => {
+            try {
+              const displayE = 'authenticationCertificateId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-disableAuthenticationCertificate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#enableAuthenticationCertificate - errors', () => {
+      it('should have a enableAuthenticationCertificate function', (done) => {
+        try {
+          assert.equal(true, typeof a.enableAuthenticationCertificate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing authenticationCertificateId', (done) => {
+        try {
+          a.enableAuthenticationCertificate(null, (data, error) => {
+            try {
+              const displayE = 'authenticationCertificateId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-enableAuthenticationCertificate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteAuthenticationCertificate - errors', () => {
+      it('should have a deleteAuthenticationCertificate function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteAuthenticationCertificate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing authenticationCertificateId', (done) => {
+        try {
+          a.deleteAuthenticationCertificate(null, (data, error) => {
+            try {
+              const displayE = 'authenticationCertificateId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-deleteAuthenticationCertificate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#restoreAuthenticationCertificate - errors', () => {
+      it('should have a restoreAuthenticationCertificate function', (done) => {
+        try {
+          assert.equal(true, typeof a.restoreAuthenticationCertificate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing authenticationCertificateId', (done) => {
+        try {
+          a.restoreAuthenticationCertificate(null, (data, error) => {
+            try {
+              const displayE = 'authenticationCertificateId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-restoreAuthenticationCertificate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listCertificateProfiles - errors', () => {
+      it('should have a listCertificateProfiles function', (done) => {
+        try {
+          assert.equal(true, typeof a.listCertificateProfiles === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createCertificateProfile - errors', () => {
+      it('should have a createCertificateProfile function', (done) => {
+        try {
+          assert.equal(true, typeof a.createCertificateProfile === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getCertificateProfile - errors', () => {
+      it('should have a getCertificateProfile function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCertificateProfile === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateProfileId', (done) => {
+        try {
+          a.getCertificateProfile(null, (data, error) => {
+            try {
+              const displayE = 'certificateProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-getCertificateProfile', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateCertificateProfile - errors', () => {
+      it('should have a updateCertificateProfile function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateCertificateProfile === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateProfileId', (done) => {
+        try {
+          a.updateCertificateProfile(null, null, (data, error) => {
+            try {
+              const displayE = 'certificateProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-updateCertificateProfile', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#disableCertificateProfile - errors', () => {
+      it('should have a disableCertificateProfile function', (done) => {
+        try {
+          assert.equal(true, typeof a.disableCertificateProfile === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateProfileId', (done) => {
+        try {
+          a.disableCertificateProfile(null, (data, error) => {
+            try {
+              const displayE = 'certificateProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-disableCertificateProfile', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#enableCertificateProfile - errors', () => {
+      it('should have a enableCertificateProfile function', (done) => {
+        try {
+          assert.equal(true, typeof a.enableCertificateProfile === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateProfileId', (done) => {
+        try {
+          a.enableCertificateProfile(null, (data, error) => {
+            try {
+              const displayE = 'certificateProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-enableCertificateProfile', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteCertificateProfile - errors', () => {
+      it('should have a deleteCertificateProfile function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteCertificateProfile === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateProfileId', (done) => {
+        try {
+          a.deleteCertificateProfile(null, (data, error) => {
+            try {
+              const displayE = 'certificateProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-deleteCertificateProfile', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#restoreCertificateProfile - errors', () => {
+      it('should have a restoreCertificateProfile function', (done) => {
+        try {
+          assert.equal(true, typeof a.restoreCertificateProfile === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateProfileId', (done) => {
+        try {
+          a.restoreCertificateProfile(null, (data, error) => {
+            try {
+              const displayE = 'certificateProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-restoreCertificateProfile', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#assignCertificateProfileDivisions - errors', () => {
+      it('should have a assignCertificateProfileDivisions function', (done) => {
+        try {
+          assert.equal(true, typeof a.assignCertificateProfileDivisions === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateProfileId', (done) => {
+        try {
+          a.assignCertificateProfileDivisions(null, null, (data, error) => {
+            try {
+              const displayE = 'certificateProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-assignCertificateProfileDivisions', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#unassignCertificateProfileDivisions - errors', () => {
+      it('should have a unassignCertificateProfileDivisions function', (done) => {
+        try {
+          assert.equal(true, typeof a.unassignCertificateProfileDivisions === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateProfileId', (done) => {
+        try {
+          a.unassignCertificateProfileDivisions(null, null, (data, error) => {
+            try {
+              const displayE = 'certificateProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-unassignCertificateProfileDivisions', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getRequestStatus - errors', () => {
+      it('should have a getRequestStatus function', (done) => {
+        try {
+          assert.equal(true, typeof a.getRequestStatus === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateRequestId', (done) => {
+        try {
+          a.getRequestStatus(null, (data, error) => {
+            try {
+              const displayE = 'certificateRequestId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-getRequestStatus', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listCertificateTemplates - errors', () => {
+      it('should have a listCertificateTemplates function', (done) => {
+        try {
+          assert.equal(true, typeof a.listCertificateTemplates === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createCertificateTemplate - errors', () => {
+      it('should have a createCertificateTemplate function', (done) => {
+        try {
+          assert.equal(true, typeof a.createCertificateTemplate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getCertificateTemplate - errors', () => {
+      it('should have a getCertificateTemplate function', (done) => {
+        try {
+          assert.equal(true, typeof a.getCertificateTemplate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateTemplateId', (done) => {
+        try {
+          a.getCertificateTemplate(null, (data, error) => {
+            try {
+              const displayE = 'certificateTemplateId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-getCertificateTemplate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateCertificateTemplate - errors', () => {
+      it('should have a updateCertificateTemplate function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateCertificateTemplate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateTemplateId', (done) => {
+        try {
+          a.updateCertificateTemplate(null, null, (data, error) => {
+            try {
+              const displayE = 'certificateTemplateId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-updateCertificateTemplate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#clonecertificatetemplate - errors', () => {
+      it('should have a clonecertificatetemplate function', (done) => {
+        try {
+          assert.equal(true, typeof a.clonecertificatetemplate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateTemplateId', (done) => {
+        try {
+          a.clonecertificatetemplate(null, null, (data, error) => {
+            try {
+              const displayE = 'certificateTemplateId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-clonecertificatetemplate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#disableCertificateTemplate - errors', () => {
+      it('should have a disableCertificateTemplate function', (done) => {
+        try {
+          assert.equal(true, typeof a.disableCertificateTemplate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateTemplateId', (done) => {
+        try {
+          a.disableCertificateTemplate(null, (data, error) => {
+            try {
+              const displayE = 'certificateTemplateId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-disableCertificateTemplate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#enableCertificateTemplate - errors', () => {
+      it('should have a enableCertificateTemplate function', (done) => {
+        try {
+          assert.equal(true, typeof a.enableCertificateTemplate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateTemplateId', (done) => {
+        try {
+          a.enableCertificateTemplate(null, (data, error) => {
+            try {
+              const displayE = 'certificateTemplateId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-enableCertificateTemplate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteCertificateTemplate - errors', () => {
+      it('should have a deleteCertificateTemplate function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteCertificateTemplate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateTemplateId', (done) => {
+        try {
+          a.deleteCertificateTemplate(null, (data, error) => {
+            try {
+              const displayE = 'certificateTemplateId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-deleteCertificateTemplate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#restoreCertificateTemplate - errors', () => {
+      it('should have a restoreCertificateTemplate function', (done) => {
+        try {
+          assert.equal(true, typeof a.restoreCertificateTemplate === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateTemplateId', (done) => {
+        try {
+          a.restoreCertificateTemplate(null, (data, error) => {
+            try {
+              const displayE = 'certificateTemplateId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-restoreCertificateTemplate', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createDevice - errors', () => {
+      it('should have a createDevice function', (done) => {
+        try {
+          assert.equal(true, typeof a.createDevice === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDeviceList - errors', () => {
+      it('should have a getDeviceList function', (done) => {
+        try {
+          assert.equal(true, typeof a.getDeviceList === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDeviceDetails - errors', () => {
+      it('should have a getDeviceDetails function', (done) => {
+        try {
+          assert.equal(true, typeof a.getDeviceDetails === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing deviceIdentifier', (done) => {
+        try {
+          a.getDeviceDetails(null, null, (data, error) => {
+            try {
+              const displayE = 'deviceIdentifier is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-getDeviceDetails', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing divisionId', (done) => {
+        try {
+          a.getDeviceDetails('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'divisionId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-getDeviceDetails', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateDevice - errors', () => {
+      it('should have a updateDevice function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateDevice === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing deviceIdentifier', (done) => {
+        try {
+          a.updateDevice(null, null, null, (data, error) => {
+            try {
+              const displayE = 'deviceIdentifier is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-updateDevice', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing divisionId', (done) => {
+        try {
+          a.updateDevice('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'divisionId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-updateDevice', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#archiveDevice - errors', () => {
+      it('should have a archiveDevice function', (done) => {
+        try {
+          assert.equal(true, typeof a.archiveDevice === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing deviceIdentifier', (done) => {
+        try {
+          a.archiveDevice(null, null, (data, error) => {
+            try {
+              const displayE = 'deviceIdentifier is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-archiveDevice', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing divisionId', (done) => {
+        try {
+          a.archiveDevice('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'divisionId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-archiveDevice', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#enableDevice - errors', () => {
+      it('should have a enableDevice function', (done) => {
+        try {
+          assert.equal(true, typeof a.enableDevice === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing deviceIdentifier', (done) => {
+        try {
+          a.enableDevice(null, null, (data, error) => {
+            try {
+              const displayE = 'deviceIdentifier is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-enableDevice', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing divisionId', (done) => {
+        try {
+          a.enableDevice('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'divisionId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-enableDevice', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#disableDevice - errors', () => {
+      it('should have a disableDevice function', (done) => {
+        try {
+          assert.equal(true, typeof a.disableDevice === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing deviceIdentifier', (done) => {
+        try {
+          a.disableDevice(null, null, (data, error) => {
+            try {
+              const displayE = 'deviceIdentifier is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-disableDevice', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing divisionId', (done) => {
+        try {
+          a.disableDevice('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'divisionId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-disableDevice', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#restoreDevice - errors', () => {
+      it('should have a restoreDevice function', (done) => {
+        try {
+          assert.equal(true, typeof a.restoreDevice === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing deviceIdentifier', (done) => {
+        try {
+          a.restoreDevice(null, null, (data, error) => {
+            try {
+              const displayE = 'deviceIdentifier is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-restoreDevice', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing divisionId', (done) => {
+        try {
+          a.restoreDevice('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'divisionId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-restoreDevice', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createDeviceV2 - errors', () => {
+      it('should have a createDeviceV2 function', (done) => {
+        try {
+          assert.equal(true, typeof a.createDeviceV2 === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDeviceListV2 - errors', () => {
+      it('should have a getDeviceListV2 function', (done) => {
+        try {
+          assert.equal(true, typeof a.getDeviceListV2 === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDeviceDetailsV2 - errors', () => {
+      it('should have a getDeviceDetailsV2 function', (done) => {
+        try {
+          assert.equal(true, typeof a.getDeviceDetailsV2 === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing deviceId', (done) => {
+        try {
+          a.getDeviceDetailsV2(null, (data, error) => {
+            try {
+              const displayE = 'deviceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-getDeviceDetailsV2', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateDeviceV2 - errors', () => {
+      it('should have a updateDeviceV2 function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateDeviceV2 === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing deviceId', (done) => {
+        try {
+          a.updateDeviceV2(null, null, (data, error) => {
+            try {
+              const displayE = 'deviceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-updateDeviceV2', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#archiveDeviceV2 - errors', () => {
+      it('should have a archiveDeviceV2 function', (done) => {
+        try {
+          assert.equal(true, typeof a.archiveDeviceV2 === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing deviceId', (done) => {
+        try {
+          a.archiveDeviceV2(null, (data, error) => {
+            try {
+              const displayE = 'deviceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-archiveDeviceV2', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#enableDeviceV2 - errors', () => {
+      it('should have a enableDeviceV2 function', (done) => {
+        try {
+          assert.equal(true, typeof a.enableDeviceV2 === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing deviceId', (done) => {
+        try {
+          a.enableDeviceV2(null, (data, error) => {
+            try {
+              const displayE = 'deviceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-enableDeviceV2', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#disableDeviceV2 - errors', () => {
+      it('should have a disableDeviceV2 function', (done) => {
+        try {
+          assert.equal(true, typeof a.disableDeviceV2 === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing deviceId', (done) => {
+        try {
+          a.disableDeviceV2(null, (data, error) => {
+            try {
+              const displayE = 'deviceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-disableDeviceV2', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#restoreDeviceV2 - errors', () => {
+      it('should have a restoreDeviceV2 function', (done) => {
+        try {
+          assert.equal(true, typeof a.restoreDeviceV2 === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing deviceId', (done) => {
+        try {
+          a.restoreDeviceV2(null, (data, error) => {
+            try {
+              const displayE = 'deviceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-restoreDeviceV2', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#renewDeviceCertificateV2 - errors', () => {
+      it('should have a renewDeviceCertificateV2 function', (done) => {
+        try {
+          assert.equal(true, typeof a.renewDeviceCertificateV2 === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing deviceId', (done) => {
+        try {
+          a.renewDeviceCertificateV2(null, null, (data, error) => {
+            try {
+              const displayE = 'deviceId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-renewDeviceCertificateV2', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listDivisions - errors', () => {
+      it('should have a listDivisions function', (done) => {
+        try {
+          assert.equal(true, typeof a.listDivisions === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createDivision - errors', () => {
+      it('should have a createDivision function', (done) => {
+        try {
+          assert.equal(true, typeof a.createDivision === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDivision - errors', () => {
+      it('should have a getDivision function', (done) => {
+        try {
+          assert.equal(true, typeof a.getDivision === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing divisionId', (done) => {
+        try {
+          a.getDivision(null, (data, error) => {
+            try {
+              const displayE = 'divisionId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-getDivision', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateDivision - errors', () => {
+      it('should have a updateDivision function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateDivision === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing divisionId', (done) => {
+        try {
+          a.updateDivision(null, null, (data, error) => {
+            try {
+              const displayE = 'divisionId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-updateDivision', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#disableDivision - errors', () => {
+      it('should have a disableDivision function', (done) => {
+        try {
+          assert.equal(true, typeof a.disableDivision === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing divisionId', (done) => {
+        try {
+          a.disableDivision(null, (data, error) => {
+            try {
+              const displayE = 'divisionId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-disableDivision', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#enableDivision - errors', () => {
+      it('should have a enableDivision function', (done) => {
+        try {
+          assert.equal(true, typeof a.enableDivision === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing divisionId', (done) => {
+        try {
+          a.enableDivision(null, (data, error) => {
+            try {
+              const displayE = 'divisionId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-enableDivision', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteDivision - errors', () => {
+      it('should have a deleteDivision function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteDivision === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing divisionId', (done) => {
+        try {
+          a.deleteDivision(null, (data, error) => {
+            try {
+              const displayE = 'divisionId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-deleteDivision', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#restoreDivision - errors', () => {
+      it('should have a restoreDivision function', (done) => {
+        try {
+          assert.equal(true, typeof a.restoreDivision === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing divisionId', (done) => {
+        try {
+          a.restoreDivision(null, (data, error) => {
+            try {
+              const displayE = 'divisionId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-restoreDivision', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#assignDivisionUsers - errors', () => {
+      it('should have a assignDivisionUsers function', (done) => {
+        try {
+          assert.equal(true, typeof a.assignDivisionUsers === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing divisionId', (done) => {
+        try {
+          a.assignDivisionUsers(null, null, (data, error) => {
+            try {
+              const displayE = 'divisionId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-assignDivisionUsers', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listDivisionUsers - errors', () => {
+      it('should have a listDivisionUsers function', (done) => {
+        try {
+          assert.equal(true, typeof a.listDivisionUsers === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing divisionId', (done) => {
+        try {
+          a.listDivisionUsers(null, null, null, (data, error) => {
+            try {
+              const displayE = 'divisionId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-listDivisionUsers', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#removeDivisionUsers - errors', () => {
+      it('should have a removeDivisionUsers function', (done) => {
+        try {
+          assert.equal(true, typeof a.removeDivisionUsers === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing divisionId', (done) => {
+        try {
+          a.removeDivisionUsers(null, null, (data, error) => {
+            try {
+              const displayE = 'divisionId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-removeDivisionUsers', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#assignICAstodivision - errors', () => {
+      it('should have a assignICAstodivision function', (done) => {
+        try {
+          assert.equal(true, typeof a.assignICAstodivision === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing divisionId', (done) => {
+        try {
+          a.assignICAstodivision(null, null, (data, error) => {
+            try {
+              const displayE = 'divisionId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-assignICAstodivision', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#removeICAsfromdivision - errors', () => {
+      it('should have a removeICAsfromdivision function', (done) => {
+        try {
+          assert.equal(true, typeof a.removeICAsfromdivision === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing divisionId', (done) => {
+        try {
+          a.removeICAsfromdivision(null, null, (data, error) => {
+            try {
+              const displayE = 'divisionId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-removeICAsfromdivision', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listdivisionICAassignments - errors', () => {
+      it('should have a listdivisionICAassignments function', (done) => {
+        try {
+          assert.equal(true, typeof a.listdivisionICAassignments === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing divisionId', (done) => {
+        try {
+          a.listdivisionICAassignments(null, null, null, null, null, null, null, null, null, null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'divisionId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-listdivisionICAassignments', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listEnrollmentProfiles - errors', () => {
+      it('should have a listEnrollmentProfiles function', (done) => {
+        try {
+          assert.equal(true, typeof a.listEnrollmentProfiles === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createEnrollmentProfile - errors', () => {
+      it('should have a createEnrollmentProfile function', (done) => {
+        try {
+          assert.equal(true, typeof a.createEnrollmentProfile === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getExampleCertificateRequestEnrollmentProfileID - errors', () => {
+      it('should have a getExampleCertificateRequestEnrollmentProfileID function', (done) => {
+        try {
+          assert.equal(true, typeof a.getExampleCertificateRequestEnrollmentProfileID === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing enrollmentProfileId', (done) => {
+        try {
+          a.getExampleCertificateRequestEnrollmentProfileID(null, (data, error) => {
+            try {
+              const displayE = 'enrollmentProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-getExampleCertificateRequestEnrollmentProfileID', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getEnrollmentProfile - errors', () => {
+      it('should have a getEnrollmentProfile function', (done) => {
+        try {
+          assert.equal(true, typeof a.getEnrollmentProfile === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing enrollmentProfileId', (done) => {
+        try {
+          a.getEnrollmentProfile(null, (data, error) => {
+            try {
+              const displayE = 'enrollmentProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-getEnrollmentProfile', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateEnrollmentProfile - errors', () => {
+      it('should have a updateEnrollmentProfile function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateEnrollmentProfile === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing enrollmentProfileId', (done) => {
+        try {
+          a.updateEnrollmentProfile(null, null, (data, error) => {
+            try {
+              const displayE = 'enrollmentProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-updateEnrollmentProfile', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listAssignableICAs - errors', () => {
+      it('should have a listAssignableICAs function', (done) => {
+        try {
+          assert.equal(true, typeof a.listAssignableICAs === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing enrollmentProfileId', (done) => {
+        try {
+          a.listAssignableICAs(null, null, null, (data, error) => {
+            try {
+              const displayE = 'enrollmentProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-listAssignableICAs', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getIssuingICA - errors', () => {
+      it('should have a getIssuingICA function', (done) => {
+        try {
+          assert.equal(true, typeof a.getIssuingICA === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing enrollmentProfileId', (done) => {
+        try {
+          a.getIssuingICA(null, null, (data, error) => {
+            try {
+              const displayE = 'enrollmentProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-getIssuingICA', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getEnrollmentProfileSpecification - errors', () => {
+      it('should have a getEnrollmentProfileSpecification function', (done) => {
+        try {
+          assert.equal(true, typeof a.getEnrollmentProfileSpecification === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing enrollmentProfileId', (done) => {
+        try {
+          a.getEnrollmentProfileSpecification(null, (data, error) => {
+            try {
+              const displayE = 'enrollmentProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-getEnrollmentProfileSpecification', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getEnrollmentProfileStatus - errors', () => {
+      it('should have a getEnrollmentProfileStatus function', (done) => {
+        try {
+          assert.equal(true, typeof a.getEnrollmentProfileStatus === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing enrollmentProfileId', (done) => {
+        try {
+          a.getEnrollmentProfileStatus(null, (data, error) => {
+            try {
+              const displayE = 'enrollmentProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-getEnrollmentProfileStatus', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listEnrollmentPasscodes - errors', () => {
+      it('should have a listEnrollmentPasscodes function', (done) => {
+        try {
+          assert.equal(true, typeof a.listEnrollmentPasscodes === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createEnrollmentPasscode - errors', () => {
+      it('should have a createEnrollmentPasscode function', (done) => {
+        try {
+          assert.equal(true, typeof a.createEnrollmentPasscode === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing enrollmentProfileId', (done) => {
+        try {
+          a.createEnrollmentPasscode(null, null, (data, error) => {
+            try {
+              const displayE = 'enrollmentProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-createEnrollmentPasscode', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getEnrollmentPasscodeDetails - errors', () => {
+      it('should have a getEnrollmentPasscodeDetails function', (done) => {
+        try {
+          assert.equal(true, typeof a.getEnrollmentPasscodeDetails === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing enrollmentProfileId', (done) => {
+        try {
+          a.getEnrollmentPasscodeDetails(null, null, (data, error) => {
+            try {
+              const displayE = 'enrollmentProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-getEnrollmentPasscodeDetails', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing passcodeId', (done) => {
+        try {
+          a.getEnrollmentPasscodeDetails('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'passcodeId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-getEnrollmentPasscodeDetails', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateEnrollmentPasscode - errors', () => {
+      it('should have a updateEnrollmentPasscode function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateEnrollmentPasscode === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing enrollmentProfileId', (done) => {
+        try {
+          a.updateEnrollmentPasscode(null, null, null, (data, error) => {
+            try {
+              const displayE = 'enrollmentProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-updateEnrollmentPasscode', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing passcodeId', (done) => {
+        try {
+          a.updateEnrollmentPasscode('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'passcodeId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-updateEnrollmentPasscode', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteEnrollmentPasscode - errors', () => {
+      it('should have a deleteEnrollmentPasscode function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteEnrollmentPasscode === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing enrollmentProfileId', (done) => {
+        try {
+          a.deleteEnrollmentPasscode(null, null, (data, error) => {
+            try {
+              const displayE = 'enrollmentProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-deleteEnrollmentPasscode', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing passcodeId', (done) => {
+        try {
+          a.deleteEnrollmentPasscode('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'passcodeId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-deleteEnrollmentPasscode', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#restoreEnrollmentPasscode - errors', () => {
+      it('should have a restoreEnrollmentPasscode function', (done) => {
+        try {
+          assert.equal(true, typeof a.restoreEnrollmentPasscode === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing enrollmentProfileId', (done) => {
+        try {
+          a.restoreEnrollmentPasscode(null, null, (data, error) => {
+            try {
+              const displayE = 'enrollmentProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-restoreEnrollmentPasscode', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing passcodeId', (done) => {
+        try {
+          a.restoreEnrollmentPasscode('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'passcodeId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-restoreEnrollmentPasscode', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#disableEnrollmentPasscode - errors', () => {
+      it('should have a disableEnrollmentPasscode function', (done) => {
+        try {
+          assert.equal(true, typeof a.disableEnrollmentPasscode === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing enrollmentProfileId', (done) => {
+        try {
+          a.disableEnrollmentPasscode(null, null, (data, error) => {
+            try {
+              const displayE = 'enrollmentProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-disableEnrollmentPasscode', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing passcodeId', (done) => {
+        try {
+          a.disableEnrollmentPasscode('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'passcodeId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-disableEnrollmentPasscode', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#enableEnrollmentPasscode - errors', () => {
+      it('should have a enableEnrollmentPasscode function', (done) => {
+        try {
+          assert.equal(true, typeof a.enableEnrollmentPasscode === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing enrollmentProfileId', (done) => {
+        try {
+          a.enableEnrollmentPasscode(null, null, (data, error) => {
+            try {
+              const displayE = 'enrollmentProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-enableEnrollmentPasscode', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing passcodeId', (done) => {
+        try {
+          a.enableEnrollmentPasscode('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'passcodeId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-enableEnrollmentPasscode', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#regenerateEnrollmentPasscode - errors', () => {
+      it('should have a regenerateEnrollmentPasscode function', (done) => {
+        try {
+          assert.equal(true, typeof a.regenerateEnrollmentPasscode === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing enrollmentProfileId', (done) => {
+        try {
+          a.regenerateEnrollmentPasscode(null, null, (data, error) => {
+            try {
+              const displayE = 'enrollmentProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-regenerateEnrollmentPasscode', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing passcodeId', (done) => {
+        try {
+          a.regenerateEnrollmentPasscode('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'passcodeId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-regenerateEnrollmentPasscode', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createAcmeAuthentication - errors', () => {
+      it('should have a createAcmeAuthentication function', (done) => {
+        try {
+          assert.equal(true, typeof a.createAcmeAuthentication === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.createAcmeAuthentication(null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-createAcmeAuthentication', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listAcmeAuthentication - errors', () => {
+      it('should have a listAcmeAuthentication function', (done) => {
+        try {
+          assert.equal(true, typeof a.listAcmeAuthentication === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getAcmeAuthentication - errors', () => {
+      it('should have a getAcmeAuthentication function', (done) => {
+        try {
+          assert.equal(true, typeof a.getAcmeAuthentication === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing acmeAuthenticationId', (done) => {
+        try {
+          a.getAcmeAuthentication(null, (data, error) => {
+            try {
+              const displayE = 'acmeAuthenticationId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-getAcmeAuthentication', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateAcmeAuthentication - errors', () => {
+      it('should have a updateAcmeAuthentication function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateAcmeAuthentication === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing acmeAuthenticationId', (done) => {
+        try {
+          a.updateAcmeAuthentication(null, null, (data, error) => {
+            try {
+              const displayE = 'acmeAuthenticationId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-updateAcmeAuthentication', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#disableAcmeAuthentication - errors', () => {
+      it('should have a disableAcmeAuthentication function', (done) => {
+        try {
+          assert.equal(true, typeof a.disableAcmeAuthentication === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing acmeAuthenticationId', (done) => {
+        try {
+          a.disableAcmeAuthentication(null, (data, error) => {
+            try {
+              const displayE = 'acmeAuthenticationId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-disableAcmeAuthentication', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#enableAcmeAuthentication - errors', () => {
+      it('should have a enableAcmeAuthentication function', (done) => {
+        try {
+          assert.equal(true, typeof a.enableAcmeAuthentication === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing acmeAuthenticationId', (done) => {
+        try {
+          a.enableAcmeAuthentication(null, (data, error) => {
+            try {
+              const displayE = 'acmeAuthenticationId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-enableAcmeAuthentication', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteAcmeAuthentication - errors', () => {
+      it('should have a deleteAcmeAuthentication function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteAcmeAuthentication === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing acmeAuthenticationId', (done) => {
+        try {
+          a.deleteAcmeAuthentication(null, (data, error) => {
+            try {
+              const displayE = 'acmeAuthenticationId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-deleteAcmeAuthentication', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#restoreAcmeAuthentication - errors', () => {
+      it('should have a restoreAcmeAuthentication function', (done) => {
+        try {
+          assert.equal(true, typeof a.restoreAcmeAuthentication === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing acmeAuthenticationId', (done) => {
+        try {
+          a.restoreAcmeAuthentication(null, (data, error) => {
+            try {
+              const displayE = 'acmeAuthenticationId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-restoreAcmeAuthentication', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#batchCSREnroll - errors', () => {
+      it('should have a batchCSREnroll function', (done) => {
+        try {
+          assert.equal(true, typeof a.batchCSREnroll === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing enrollmentProfileId', (done) => {
+        try {
+          a.batchCSREnroll(null, null, null, null, null, null, null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'enrollmentProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-batchCSREnroll', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateFormat', (done) => {
+        try {
+          a.batchCSREnroll('fakeparam', 'fakeparam', null, null, null, null, null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'certificateFormat is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-batchCSREnroll', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing data', (done) => {
+        try {
+          a.batchCSREnroll('fakeparam', 'fakeparam', 'fakeparam', null, null, null, null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'data is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-batchCSREnroll', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing emails', (done) => {
+        try {
+          a.batchCSREnroll('fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', null, null, null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'emails is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-batchCSREnroll', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#batchEnrollWithKeyGen - errors', () => {
+      it('should have a batchEnrollWithKeyGen function', (done) => {
+        try {
+          assert.equal(true, typeof a.batchEnrollWithKeyGen === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing enrollmentProfileId', (done) => {
+        try {
+          a.batchEnrollWithKeyGen(null, null, null, null, null, null, null, null, null, null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'enrollmentProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-batchEnrollWithKeyGen', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateFormat', (done) => {
+        try {
+          a.batchEnrollWithKeyGen('fakeparam', 'fakeparam', null, null, null, null, null, null, null, null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'certificateFormat is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-batchEnrollWithKeyGen', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing data', (done) => {
+        try {
+          a.batchEnrollWithKeyGen('fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', null, null, null, null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'data is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-batchEnrollWithKeyGen', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing emails', (done) => {
+        try {
+          a.batchEnrollWithKeyGen('fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', null, null, null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'emails is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-batchEnrollWithKeyGen', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing keyType', (done) => {
+        try {
+          a.batchEnrollWithKeyGen('fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', null, null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'keyType is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-batchEnrollWithKeyGen', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificate', (done) => {
+        try {
+          a.batchEnrollWithKeyGen('fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'certificate is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-batchEnrollWithKeyGen', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#batchEnrollWithKeyGenMac - errors', () => {
+      it('should have a batchEnrollWithKeyGenMac function', (done) => {
+        try {
+          assert.equal(true, typeof a.batchEnrollWithKeyGenMac === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing enrollmentProfileId', (done) => {
+        try {
+          a.batchEnrollWithKeyGenMac(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'enrollmentProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-batchEnrollWithKeyGenMac', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateFormat', (done) => {
+        try {
+          a.batchEnrollWithKeyGenMac('fakeparam', 'fakeparam', null, null, null, null, null, null, null, null, null, null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'certificateFormat is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-batchEnrollWithKeyGenMac', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing macAddressFrom', (done) => {
+        try {
+          a.batchEnrollWithKeyGenMac('fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', null, null, null, null, null, null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'macAddressFrom is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-batchEnrollWithKeyGenMac', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing macAddressNumber', (done) => {
+        try {
+          a.batchEnrollWithKeyGenMac('fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', null, null, null, null, null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'macAddressNumber is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-batchEnrollWithKeyGenMac', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing macAddressStep', (done) => {
+        try {
+          a.batchEnrollWithKeyGenMac('fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', null, null, null, null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'macAddressStep is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-batchEnrollWithKeyGenMac', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing emails', (done) => {
+        try {
+          a.batchEnrollWithKeyGenMac('fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', null, null, null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'emails is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-batchEnrollWithKeyGenMac', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing keyType', (done) => {
+        try {
+          a.batchEnrollWithKeyGenMac('fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', null, null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'keyType is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-batchEnrollWithKeyGenMac', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificate', (done) => {
+        try {
+          a.batchEnrollWithKeyGenMac('fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', 'fakeparam', null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'certificate is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-batchEnrollWithKeyGenMac', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listBatchJobs - errors', () => {
+      it('should have a listBatchJobs function', (done) => {
+        try {
+          assert.equal(true, typeof a.listBatchJobs === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getBatchJobSettings - errors', () => {
+      it('should have a getBatchJobSettings function', (done) => {
+        try {
+          assert.equal(true, typeof a.getBatchJobSettings === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing jobId', (done) => {
+        try {
+          a.getBatchJobSettings(null, (data, error) => {
+            try {
+              const displayE = 'jobId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-getBatchJobSettings', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateBatchJobSettings - errors', () => {
+      it('should have a updateBatchJobSettings function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateBatchJobSettings === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing jobId', (done) => {
+        try {
+          a.updateBatchJobSettings(null, null, (data, error) => {
+            try {
+              const displayE = 'jobId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-updateBatchJobSettings', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#regenerateBatchJobPasscode - errors', () => {
+      it('should have a regenerateBatchJobPasscode function', (done) => {
+        try {
+          assert.equal(true, typeof a.regenerateBatchJobPasscode === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing jobId', (done) => {
+        try {
+          a.regenerateBatchJobPasscode(null, (data, error) => {
+            try {
+              const displayE = 'jobId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-regenerateBatchJobPasscode', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#approveJob - errors', () => {
+      it('should have a approveJob function', (done) => {
+        try {
+          assert.equal(true, typeof a.approveJob === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing jobId', (done) => {
+        try {
+          a.approveJob(null, (data, error) => {
+            try {
+              const displayE = 'jobId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-approveJob', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#rejectJob - errors', () => {
+      it('should have a rejectJob function', (done) => {
+        try {
+          assert.equal(true, typeof a.rejectJob === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing jobId', (done) => {
+        try {
+          a.rejectJob(null, null, (data, error) => {
+            try {
+              const displayE = 'jobId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-rejectJob', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#downloadReport - errors', () => {
+      it('should have a downloadReport function', (done) => {
+        try {
+          assert.equal(true, typeof a.downloadReport === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing jobId', (done) => {
+        try {
+          a.downloadReport(null, (data, error) => {
+            try {
+              const displayE = 'jobId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-downloadReport', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#downloadCertificates - errors', () => {
+      it('should have a downloadCertificates function', (done) => {
+        try {
+          assert.equal(true, typeof a.downloadCertificates === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing jobId', (done) => {
+        try {
+          a.downloadCertificates(null, (data, error) => {
+            try {
+              const displayE = 'jobId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-downloadCertificates', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteDownloadUrls - errors', () => {
+      it('should have a deleteDownloadUrls function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteDownloadUrls === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing jobId', (done) => {
+        try {
+          a.deleteDownloadUrls(null, (data, error) => {
+            try {
+              const displayE = 'jobId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-deleteDownloadUrls', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#resendDownloadUrls - errors', () => {
+      it('should have a resendDownloadUrls function', (done) => {
+        try {
+          assert.equal(true, typeof a.resendDownloadUrls === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing jobId', (done) => {
+        try {
+          a.resendDownloadUrls(null, (data, error) => {
+            try {
+              const displayE = 'jobId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-resendDownloadUrls', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#batchEnrollExternal - errors', () => {
+      it('should have a batchEnrollExternal function', (done) => {
+        try {
+          assert.equal(true, typeof a.batchEnrollExternal === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing enrollmentProfileId', (done) => {
+        try {
+          a.batchEnrollExternal(null, null, null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'enrollmentProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-batchEnrollExternal', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing data', (done) => {
+        try {
+          a.batchEnrollExternal('fakeparam', 'fakeparam', null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'data is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-batchEnrollExternal', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing emails', (done) => {
+        try {
+          a.batchEnrollExternal('fakeparam', 'fakeparam', 'fakeparam', null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'emails is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-batchEnrollExternal', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#downloadMapping - errors', () => {
+      it('should have a downloadMapping function', (done) => {
+        try {
+          assert.equal(true, typeof a.downloadMapping === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing jobId', (done) => {
+        try {
+          a.downloadMapping(null, (data, error) => {
+            try {
+              const displayE = 'jobId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-downloadMapping', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#downloadByJobIdAndUniqueId - errors', () => {
+      it('should have a downloadByJobIdAndUniqueId function', (done) => {
+        try {
+          assert.equal(true, typeof a.downloadByJobIdAndUniqueId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing jobId', (done) => {
+        try {
+          a.downloadByJobIdAndUniqueId(null, null, null, (data, error) => {
+            try {
+              const displayE = 'jobId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-downloadByJobIdAndUniqueId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uniqueIdentifier', (done) => {
+        try {
+          a.downloadByJobIdAndUniqueId('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'uniqueIdentifier is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-downloadByJobIdAndUniqueId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing format', (done) => {
+        try {
+          a.downloadByJobIdAndUniqueId('fakeparam', 'fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'format is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-downloadByJobIdAndUniqueId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#downloadByCommonName - errors', () => {
+      it('should have a downloadByCommonName function', (done) => {
+        try {
+          assert.equal(true, typeof a.downloadByCommonName === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing commonName', (done) => {
+        try {
+          a.downloadByCommonName(null, null, (data, error) => {
+            try {
+              const displayE = 'commonName is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-downloadByCommonName', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing format', (done) => {
+        try {
+          a.downloadByCommonName('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'format is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-downloadByCommonName', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#downloadByJobIdAndCommonName - errors', () => {
+      it('should have a downloadByJobIdAndCommonName function', (done) => {
+        try {
+          assert.equal(true, typeof a.downloadByJobIdAndCommonName === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing jobId', (done) => {
+        try {
+          a.downloadByJobIdAndCommonName(null, null, null, (data, error) => {
+            try {
+              const displayE = 'jobId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-downloadByJobIdAndCommonName', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing commonName', (done) => {
+        try {
+          a.downloadByJobIdAndCommonName('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'commonName is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-downloadByJobIdAndCommonName', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing format', (done) => {
+        try {
+          a.downloadByJobIdAndCommonName('fakeparam', 'fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'format is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-downloadByJobIdAndCommonName', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#downloadByCertificateValue - errors', () => {
+      it('should have a downloadByCertificateValue function', (done) => {
+        try {
+          assert.equal(true, typeof a.downloadByCertificateValue === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateValue', (done) => {
+        try {
+          a.downloadByCertificateValue(null, null, (data, error) => {
+            try {
+              const displayE = 'certificateValue is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-downloadByCertificateValue', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing format', (done) => {
+        try {
+          a.downloadByCertificateValue('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'format is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-downloadByCertificateValue', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#downloadByJobIdAndCertificateValue - errors', () => {
+      it('should have a downloadByJobIdAndCertificateValue function', (done) => {
+        try {
+          assert.equal(true, typeof a.downloadByJobIdAndCertificateValue === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing jobId', (done) => {
+        try {
+          a.downloadByJobIdAndCertificateValue(null, null, null, (data, error) => {
+            try {
+              const displayE = 'jobId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-downloadByJobIdAndCertificateValue', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing certificateValue', (done) => {
+        try {
+          a.downloadByJobIdAndCertificateValue('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'certificateValue is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-downloadByJobIdAndCertificateValue', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing format', (done) => {
+        try {
+          a.downloadByJobIdAndCertificateValue('fakeparam', 'fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'format is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-downloadByJobIdAndCertificateValue', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createDeviceProfile - errors', () => {
+      it('should have a createDeviceProfile function', (done) => {
+        try {
+          assert.equal(true, typeof a.createDeviceProfile === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listdeviceprofiles - errors', () => {
+      it('should have a listdeviceprofiles function', (done) => {
+        try {
+          assert.equal(true, typeof a.listdeviceprofiles === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDeviceProfile - errors', () => {
+      it('should have a getDeviceProfile function', (done) => {
+        try {
+          assert.equal(true, typeof a.getDeviceProfile === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing deviceProfileId', (done) => {
+        try {
+          a.getDeviceProfile(null, (data, error) => {
+            try {
+              const displayE = 'deviceProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-getDeviceProfile', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateDeviceProfile - errors', () => {
+      it('should have a updateDeviceProfile function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateDeviceProfile === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing deviceProfileId', (done) => {
+        try {
+          a.updateDeviceProfile(null, null, (data, error) => {
+            try {
+              const displayE = 'deviceProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-updateDeviceProfile', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteDeviceProfile - errors', () => {
+      it('should have a deleteDeviceProfile function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteDeviceProfile === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing deviceProfileId', (done) => {
+        try {
+          a.deleteDeviceProfile(null, (data, error) => {
+            try {
+              const displayE = 'deviceProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-deleteDeviceProfile', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#restoreDeviceProfile - errors', () => {
+      it('should have a restoreDeviceProfile function', (done) => {
+        try {
+          assert.equal(true, typeof a.restoreDeviceProfile === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing deviceProfileId', (done) => {
+        try {
+          a.restoreDeviceProfile(null, (data, error) => {
+            try {
+              const displayE = 'deviceProfileId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-restoreDeviceProfile', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getICA - errors', () => {
+      it('should have a getICA function', (done) => {
+        try {
+          assert.equal(true, typeof a.getICA === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing icaId', (done) => {
+        try {
+          a.getICA(null, (data, error) => {
+            try {
+              const displayE = 'icaId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-getICA', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listICAs - errors', () => {
+      it('should have a listICAs function', (done) => {
+        try {
+          assert.equal(true, typeof a.listICAs === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getGatewayDetails - errors', () => {
+      it('should have a getGatewayDetails function', (done) => {
+        try {
+          assert.equal(true, typeof a.getGatewayDetails === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing gatewayId', (done) => {
+        try {
+          a.getGatewayDetails(null, (data, error) => {
+            try {
+              const displayE = 'gatewayId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-getGatewayDetails', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateGateway - errors', () => {
+      it('should have a updateGateway function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateGateway === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing gatewayId', (done) => {
+        try {
+          a.updateGateway(null, null, (data, error) => {
+            try {
+              const displayE = 'gatewayId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-updateGateway', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listGateways - errors', () => {
+      it('should have a listGateways function', (done) => {
+        try {
+          assert.equal(true, typeof a.listGateways === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createGateway - errors', () => {
+      it('should have a createGateway function', (done) => {
+        try {
+          assert.equal(true, typeof a.createGateway === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#enableGateway - errors', () => {
+      it('should have a enableGateway function', (done) => {
+        try {
+          assert.equal(true, typeof a.enableGateway === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing gatewayId', (done) => {
+        try {
+          a.enableGateway(null, (data, error) => {
+            try {
+              const displayE = 'gatewayId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-enableGateway', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#disableGateway - errors', () => {
+      it('should have a disableGateway function', (done) => {
+        try {
+          assert.equal(true, typeof a.disableGateway === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing gatewayId', (done) => {
+        try {
+          a.disableGateway(null, (data, error) => {
+            try {
+              const displayE = 'gatewayId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-disableGateway', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteGateway - errors', () => {
+      it('should have a deleteGateway function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteGateway === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing gatewayId', (done) => {
+        try {
+          a.deleteGateway(null, (data, error) => {
+            try {
+              const displayE = 'gatewayId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-deleteGateway', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#restoreGateway - errors', () => {
+      it('should have a restoreGateway function', (done) => {
+        try {
+          assert.equal(true, typeof a.restoreGateway === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing gatewayId', (done) => {
+        try {
+          a.restoreGateway(null, (data, error) => {
+            try {
+              const displayE = 'gatewayId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-restoreGateway', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#downloadGatewayConfig - errors', () => {
+      it('should have a downloadGatewayConfig function', (done) => {
+        try {
+          assert.equal(true, typeof a.downloadGatewayConfig === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing gatewayId', (done) => {
+        try {
+          a.downloadGatewayConfig(null, (data, error) => {
+            try {
+              const displayE = 'gatewayId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-downloadGatewayConfig', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listOCSPGroups - errors', () => {
+      it('should have a listOCSPGroups function', (done) => {
+        try {
+          assert.equal(true, typeof a.listOCSPGroups === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#createOCSPGroup - errors', () => {
+      it('should have a createOCSPGroup function', (done) => {
+        try {
+          assert.equal(true, typeof a.createOCSPGroup === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getOCSPGroupDetails - errors', () => {
+      it('should have a getOCSPGroupDetails function', (done) => {
+        try {
+          assert.equal(true, typeof a.getOCSPGroupDetails === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing ocspGroupId', (done) => {
+        try {
+          a.getOCSPGroupDetails(null, (data, error) => {
+            try {
+              const displayE = 'ocspGroupId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-getOCSPGroupDetails', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#updateOCSPGroup - errors', () => {
+      it('should have a updateOCSPGroup function', (done) => {
+        try {
+          assert.equal(true, typeof a.updateOCSPGroup === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing ocspGroupId', (done) => {
+        try {
+          a.updateOCSPGroup(null, null, (data, error) => {
+            try {
+              const displayE = 'ocspGroupId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-updateOCSPGroup', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteOCSPGroup - errors', () => {
+      it('should have a deleteOCSPGroup function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteOCSPGroup === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing ocspGroupId', (done) => {
+        try {
+          a.deleteOCSPGroup(null, (data, error) => {
+            try {
+              const displayE = 'ocspGroupId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-deleteOCSPGroup', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#addCertsOCSPGroup - errors', () => {
+      it('should have a addCertsOCSPGroup function', (done) => {
+        try {
+          assert.equal(true, typeof a.addCertsOCSPGroup === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing ocspGroupId', (done) => {
+        try {
+          a.addCertsOCSPGroup(null, null, (data, error) => {
+            try {
+              const displayE = 'ocspGroupId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-addCertsOCSPGroup', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#removeCertsOCSPGroup - errors', () => {
+      it('should have a removeCertsOCSPGroup function', (done) => {
+        try {
+          assert.equal(true, typeof a.removeCertsOCSPGroup === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing ocspGroupId', (done) => {
+        try {
+          a.removeCertsOCSPGroup(null, null, (data, error) => {
+            try {
+              const displayE = 'ocspGroupId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-removeCertsOCSPGroup', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#listOCSPGroupCerts - errors', () => {
+      it('should have a listOCSPGroupCerts function', (done) => {
+        try {
+          assert.equal(true, typeof a.listOCSPGroupCerts === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing ocspGroupId', (done) => {
+        try {
+          a.listOCSPGroupCerts(null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'ocspGroupId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-digicert-adapter-listOCSPGroupCerts', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
   });
 });