@itentialopensource/adapter-paragon_pathfinder 1.7.1 → 1.7.3

package/test/integration/adapterTestIntegration.js

@@ -7859,5 +7859,161 @@ describe('[integration] Paragon_pathfinder Adapter Test', () => {
         }
       }).timeout(attemptTimeout);
     });
+
+    const authenticationAuthenticationTokenBodyParam = {};
+    describe('#authenticationToken - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.authenticationToken(authenticationAuthenticationTokenBodyParam, null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_pathfinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Authentication', 'authenticationToken', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const linksSearchLinksBodyParam = {};
+    describe('#searchLinks - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.searchLinks('fakedata', linksSearchLinksBodyParam, null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_pathfinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Links', 'searchLinks', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const linksPatchLinkBodyParam = {};
+    describe('#patchLink - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.patchLink('fakedata', 'fakedata', linksPatchLinkBodyParam, null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_pathfinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('Links', 'patchLink', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const tELSPsSearchLSPsBodyParam = {};
+    describe('#searchLSPs - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.searchLSPs('fakedata', tELSPsSearchLSPsBodyParam, null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_pathfinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('TELSPs', 'searchLSPs', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const tELSPsPatchATELSPBodyParam = {};
+    describe('#patchATELSP - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.patchATELSP('fakedata', 'fakedata', tELSPsPatchATELSPBodyParam, null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_pathfinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('TELSPs', 'patchATELSP', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const tELSPsDeleteATELSPBodyParam = {};
+    describe('#deleteATELSP - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteATELSP('fakedata', 'fakedata', tELSPsDeleteATELSPBodyParam, null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-paragon_pathfinder-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('TELSPs', 'deleteATELSP', '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

@@ -6323,5 +6323,213 @@ describe('[unit] Paragon_pathfinder Adapter Test', () => {
         }
       }).timeout(attemptTimeout);
     });
+
+    describe('#authenticationToken - errors', () => {
+      it('should have a authenticationToken function', (done) => {
+        try {
+          assert.equal(true, typeof a.authenticationToken === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#searchLinks - errors', () => {
+      it('should have a searchLinks function', (done) => {
+        try {
+          assert.equal(true, typeof a.searchLinks === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.searchLinks(null, null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-searchLinks', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchLink - errors', () => {
+      it('should have a patchLink function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchLink === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.patchLink(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-patchLink', 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 linkIndex', (done) => {
+        try {
+          a.patchLink('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'linkIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-patchLink', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#searchLSPs - errors', () => {
+      it('should have a searchLSPs function', (done) => {
+        try {
+          assert.equal(true, typeof a.searchLSPs === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.searchLSPs(null, null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-searchLSPs', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchATELSP - errors', () => {
+      it('should have a patchATELSP function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchATELSP === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.patchATELSP(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-patchATELSP', 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 lspIndex', (done) => {
+        try {
+          a.patchATELSP('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'lspIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-patchATELSP', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteATELSP - errors', () => {
+      it('should have a deleteATELSP function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteATELSP === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.deleteATELSP(null, null, null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteATELSP', 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 lspIndex', (done) => {
+        try {
+          a.deleteATELSP('fakeparam', null, null, null, (data, error) => {
+            try {
+              const displayE = 'lspIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteATELSP', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
   });
 });