@itentialopensource/adapter-checkpoint_management 0.10.4 → 0.10.6

package/test/integration/adapterTestIntegration.js

@@ -10318,5 +10318,239 @@ describe('[integration] Checkpoint_Management Adapter Test', () => {
         }
       }).timeout(attemptTimeout);
     });
+
+    const packageDeploymentVerifySoftwarePackageBodyParam = {};
+    describe('#verifySoftwarePackage - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.verifySoftwarePackage(packageDeploymentVerifySoftwarePackageBodyParam, null, null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-checkpoint_management-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('PackageDeployment', 'verifySoftwarePackage', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const packageDeploymentInstallSoftwarePackageBodyParam = {};
+    describe('#installSoftwarePackage - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.installSoftwarePackage(packageDeploymentInstallSoftwarePackageBodyParam, null, null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-checkpoint_management-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('PackageDeployment', 'installSoftwarePackage', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const packageDeploymentUninstallSoftwarePackageBodyParam = {};
+    describe('#uninstallSoftwarePackage - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.uninstallSoftwarePackage(packageDeploymentUninstallSoftwarePackageBodyParam, null, null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-checkpoint_management-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('PackageDeployment', 'uninstallSoftwarePackage', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const packageDeploymentAddRepositoryPackageBodyParam = {};
+    describe('#addRepositoryPackage - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addRepositoryPackage(packageDeploymentAddRepositoryPackageBodyParam, null, null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-checkpoint_management-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('PackageDeployment', 'addRepositoryPackage', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const packageDeploymentShowRepositoryPackageBodyParam = {};
+    describe('#showRepositoryPackage - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showRepositoryPackage(packageDeploymentShowRepositoryPackageBodyParam, null, null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-checkpoint_management-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('PackageDeployment', 'showRepositoryPackage', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const packageDeploymentShowSoftwarePackageDetailsBodyParam = {};
+    describe('#showSoftwarePackageDetails - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showSoftwarePackageDetails(packageDeploymentShowSoftwarePackageDetailsBodyParam, null, null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-checkpoint_management-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('PackageDeployment', 'showSoftwarePackageDetails', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const packageDeploymentShowSoftwarePackagesPerTargetsBodyParam = {};
+    describe('#showSoftwarePackagesPerTargets - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showSoftwarePackagesPerTargets(packageDeploymentShowSoftwarePackagesPerTargetsBodyParam, null, null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-checkpoint_management-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('PackageDeployment', 'showSoftwarePackagesPerTargets', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const packageDeploymentDeleteRepositoryPackageBodyParam = {};
+    describe('#deleteRepositoryPackage - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteRepositoryPackage(packageDeploymentDeleteRepositoryPackageBodyParam, null, null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-checkpoint_management-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('PackageDeployment', 'deleteRepositoryPackage', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const packageDeploymentShowRepositoryPackagesBodyParam = {};
+    describe('#showRepositoryPackages - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.showRepositoryPackages(packageDeploymentShowRepositoryPackagesBodyParam, null, null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-checkpoint_management-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('PackageDeployment', 'showRepositoryPackages', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
   });
 });

package/test/unit/adapterTestUnit.js

@@ -315,15 +315,15 @@ describe('[unit] Checkpoint_Management Adapter Test', () => {
           assert.notEqual(null, packageDotJson.dependencies);
           assert.notEqual('', packageDotJson.dependencies);
           assert.equal('^8.17.1', packageDotJson.dependencies.ajv);
-          assert.equal('^1.7.4', packageDotJson.dependencies.axios);
+          assert.equal('^1.7.9', packageDotJson.dependencies.axios);
           assert.equal('^11.0.0', packageDotJson.dependencies.commander);
           assert.equal('^11.2.0', packageDotJson.dependencies['fs-extra']);
-          assert.equal('^10.7.3', packageDotJson.dependencies.mocha);
+          assert.equal('^10.8.2', packageDotJson.dependencies.mocha);
           assert.equal('^2.0.1', packageDotJson.dependencies['mocha-param']);
           assert.equal('^0.4.4', packageDotJson.dependencies.ping);
           assert.equal('^1.4.10', packageDotJson.dependencies['readline-sync']);
           assert.equal('^7.6.3', packageDotJson.dependencies.semver);
-          assert.equal('^3.14.2', packageDotJson.dependencies.winston);
+          assert.equal('^3.17.0', packageDotJson.dependencies.winston);
           done();
         } catch (error) {
           log.error(`Test Failure: ${error}`);
@@ -10057,5 +10057,266 @@ describe('[unit] Checkpoint_Management Adapter Test', () => {
         }
       }).timeout(attemptTimeout);
     });
+
+    describe('#verifySoftwarePackage - errors', () => {
+      it('should have a verifySoftwarePackage function', (done) => {
+        try {
+          assert.equal(true, typeof a.verifySoftwarePackage === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.verifySoftwarePackage(null, null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-checkpoint_management-adapter-verifySoftwarePackage', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#installSoftwarePackage - errors', () => {
+      it('should have a installSoftwarePackage function', (done) => {
+        try {
+          assert.equal(true, typeof a.installSoftwarePackage === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.installSoftwarePackage(null, null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-checkpoint_management-adapter-installSoftwarePackage', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#uninstallSoftwarePackage - errors', () => {
+      it('should have a uninstallSoftwarePackage function', (done) => {
+        try {
+          assert.equal(true, typeof a.uninstallSoftwarePackage === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.uninstallSoftwarePackage(null, null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-checkpoint_management-adapter-uninstallSoftwarePackage', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#addRepositoryPackage - errors', () => {
+      it('should have a addRepositoryPackage function', (done) => {
+        try {
+          assert.equal(true, typeof a.addRepositoryPackage === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.addRepositoryPackage(null, null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-checkpoint_management-adapter-addRepositoryPackage', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showRepositoryPackage - errors', () => {
+      it('should have a showRepositoryPackage function', (done) => {
+        try {
+          assert.equal(true, typeof a.showRepositoryPackage === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.showRepositoryPackage(null, null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-checkpoint_management-adapter-showRepositoryPackage', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showSoftwarePackageDetails - errors', () => {
+      it('should have a showSoftwarePackageDetails function', (done) => {
+        try {
+          assert.equal(true, typeof a.showSoftwarePackageDetails === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.showSoftwarePackageDetails(null, null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-checkpoint_management-adapter-showSoftwarePackageDetails', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showSoftwarePackagesPerTargets - errors', () => {
+      it('should have a showSoftwarePackagesPerTargets function', (done) => {
+        try {
+          assert.equal(true, typeof a.showSoftwarePackagesPerTargets === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.showSoftwarePackagesPerTargets(null, null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-checkpoint_management-adapter-showSoftwarePackagesPerTargets', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteRepositoryPackage - errors', () => {
+      it('should have a deleteRepositoryPackage function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteRepositoryPackage === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.deleteRepositoryPackage(null, null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-checkpoint_management-adapter-deleteRepositoryPackage', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#showRepositoryPackages - errors', () => {
+      it('should have a showRepositoryPackages function', (done) => {
+        try {
+          assert.equal(true, typeof a.showRepositoryPackages === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing body', (done) => {
+        try {
+          a.showRepositoryPackages(null, null, null, (data, error) => {
+            try {
+              const displayE = 'body is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-checkpoint_management-adapter-showRepositoryPackages', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
   });
 });