@itentialopensource/adapter-paragon_pathfinder 1.7.1 → 1.8.0

package/report/updateReport1766083427477.json

@@ -0,0 +1,120 @@
+{
+  "errors": [],
+  "statistics": [
+    {
+      "owner": "errorJson",
+      "description": "New adapter errors available for use",
+      "value": 0
+    },
+    {
+      "owner": "errorJson",
+      "description": "Adapter errors no longer available for use",
+      "value": 0
+    },
+    {
+      "owner": "errorJson",
+      "description": "Adapter errors that have been updated (e.g. recommendation changes)",
+      "value": 31
+    },
+    {
+      "owner": "packageJson",
+      "description": "Number of production dependencies",
+      "value": 15
+    },
+    {
+      "owner": "packageJson",
+      "description": "Number of development dependencies",
+      "value": 6
+    },
+    {
+      "owner": "packageJson",
+      "description": "Number of npm scripts",
+      "value": 17
+    },
+    {
+      "owner": "packageJson",
+      "description": "Runtime Library dependency",
+      "value": "6.1.7"
+    },
+    {
+      "owner": "propertiesSchemaJson",
+      "description": "Adapter properties defined in the propertiesSchema file",
+      "value": 83
+    },
+    {
+      "owner": "markdown",
+      "description": "Number of lines in the README.md",
+      "value": 345
+    },
+    {
+      "owner": "markdown",
+      "description": "Number of lines in the SUMMARY.md",
+      "value": 9
+    },
+    {
+      "owner": "markdown",
+      "description": "Number of lines in the PROPERTIES.md",
+      "value": 682
+    },
+    {
+      "owner": "markdown",
+      "description": "Number of lines in the TROUBLESHOOT.md",
+      "value": 57
+    },
+    {
+      "owner": "markdown",
+      "description": "Number of lines in the ENHANCE.md",
+      "value": 70
+    },
+    {
+      "owner": "markdown",
+      "description": "Number of lines in the BROKER.md",
+      "value": 70
+    },
+    {
+      "owner": "unitTestJS",
+      "description": "Number of lines of code in unit tests",
+      "value": 6536
+    },
+    {
+      "owner": "unitTestJS",
+      "description": "Number of unit tests",
+      "value": 412
+    },
+    {
+      "owner": "integrationTestJS",
+      "description": "Number of lines of code in integration tests",
+      "value": 8020
+    },
+    {
+      "owner": "integrationTestJS",
+      "description": "Number of integration tests",
+      "value": 167
+    },
+    {
+      "owner": "staticFile",
+      "description": "Number of lines of code in adapterBase.js",
+      "value": 1527
+    },
+    {
+      "owner": "staticFile",
+      "description": "Number of static files added",
+      "value": 37
+    },
+    {
+      "owner": "Overall",
+      "description": "Total lines of Code",
+      "value": 16083
+    },
+    {
+      "owner": "Overall",
+      "description": "Total Tests",
+      "value": 579
+    },
+    {
+      "owner": "Overall",
+      "description": "Total Files",
+      "value": 6
+    }
+  ]
+}

package/sampleProperties.json

@@ -280,4 +280,4 @@
   "brokers": [],
   "logLevel": "none",
   "timeout": 120000
-}
+}

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);
+    });
   });
 });