@itentialopensource/adapter-paragon_pathfinder 1.2.6 → 1.2.8

package/test/integration/adapterTestIntegration.js

@@ -7310,5 +7310,458 @@ describe('[integration] Paragon_pathfinder Adapter Test', () => {
         }
       }).timeout(attemptTimeout);
     });
+
+    describe('#getTopologyV2TopologyIdIpePolicy - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getTopologyV2TopologyIdIpePolicy(555, (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('Topology', 'getTopologyV2TopologyIdIpePolicy', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const topologyPostTopologyV2TopologyIdIpePolicyBodyParam = [
+      {}
+    ];
+    describe('#postTopologyV2TopologyIdIpePolicy - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.postTopologyV2TopologyIdIpePolicy(555, topologyPostTopologyV2TopologyIdIpePolicyBodyParam, (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('Topology', 'postTopologyV2TopologyIdIpePolicy', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const topologyPutTopologyV2TopologyIdIpePolicyBodyParam = [
+      {
+        asPath: {
+          regex: 'string'
+        },
+        id: 9,
+        med: 6,
+        neighbor: null,
+        node: {
+          AutonomousSystem: {
+            asNumber: null
+          },
+          activeAssurance: {
+            agentPath: 'string'
+          },
+          comment: 'string',
+          configurationDataSource: {
+            latest: {
+              href: 'string',
+              rel: 'string',
+              schema: null,
+              type: 'string'
+            }
+          },
+          design: {
+            delay: 7,
+            simulation: {
+              canFail: true
+            },
+            trafficRerouteThreshold: 4,
+            userCost: 1
+          },
+          deviceUuid: 'string',
+          epeProperties: {
+            bandwidth: 4,
+            externalRates: [
+              null,
+              null,
+              null,
+              null
+            ],
+            internalRate: 6,
+            peeringRatePlan: [
+              {
+                bound: 9,
+                rate: 8
+              }
+            ]
+          },
+          extraIpAddresses: [
+            null
+          ],
+          hostName: 'string',
+          id: 'string',
+          layer: 'string',
+          live: false,
+          logicalSystemParent: 'string',
+          name: 'string',
+          nodeIndex: 5,
+          nodeType: 'string',
+          prefixes: [
+            {
+              SR: {
+                algo: 3,
+                flags: 4,
+                index: 1
+              },
+              SRv6: {
+                algo: 1,
+                flags: 2,
+                metric: 3
+              },
+              role: 'string'
+            },
+            {
+              SR: {
+                algo: 2,
+                flags: 10,
+                index: 9
+              },
+              SRv6: {
+                algo: 3,
+                flags: 2,
+                metric: 5
+              },
+              role: 'string'
+            },
+            {
+              SR: {
+                algo: 10,
+                flags: 6,
+                index: 3
+              },
+              SRv6: {
+                algo: 7,
+                flags: 10,
+                metric: 9
+              },
+              role: 'string'
+            },
+            {
+              SR: {
+                algo: 6,
+                flags: 1,
+                index: 8
+              },
+              SRv6: {
+                algo: 3,
+                flags: 3,
+                metric: 6
+              },
+              role: 'string'
+            },
+            {
+              SR: {
+                algo: 5,
+                flags: 1,
+                index: 7
+              },
+              SRv6: {
+                algo: 5,
+                flags: 4,
+                metric: 9
+              },
+              role: 'string'
+            },
+            {
+              SR: {
+                algo: 6,
+                flags: 10,
+                index: 9
+              },
+              SRv6: {
+                algo: 9,
+                flags: 3,
+                metric: 3
+              },
+              role: 'string'
+            }
+          ],
+          protocols: {
+            BGP: {
+              AutonomousSystem: {
+                asNumber: null
+              },
+              id: 'string'
+            },
+            ISIS: {
+              TERouterId: 'string',
+              TERouterIdIPv6: 'string',
+              area: 'string',
+              isoAddress: 'string',
+              overloadBit: true,
+              routerId: 'string',
+              routerIdIPv6: 'string'
+            },
+            NETCONF: {
+              clientAddress: null,
+              clientCapabilities: [
+                'string',
+                'string',
+                'string',
+                'string',
+                'string',
+                'string',
+                'string',
+                'string'
+              ],
+              operationalState: 'Invalid_credentials',
+              operationalStatus: 'Up',
+              sessionParameters: {
+                keepalive: 10
+              }
+            },
+            OSPF: {
+              TERouterId: 'string',
+              TERouterIdIPv6: 'string',
+              overloadBit: true,
+              referenceBw: 1,
+              routerId: 'string',
+              routerIdIPv6: 'string'
+            },
+            PCEP: {
+              extensions: {
+                'lsp-association-protection': true
+              },
+              operationalStatus: 'Empty',
+              pccAddress: null,
+              peerStatefullCapabilities: {
+                SRCapability: false,
+                SRv6Capability: true,
+                lspInstantiation: false,
+                lspUpdate: true,
+                p2mp: true,
+                p2mpInstantiation: false,
+                p2mpUpdate: false
+              },
+              sessionParameters: {
+                deadtimer: 7,
+                keepalive: 8,
+                maximumStackDepth: 5
+              }
+            },
+            SR: {
+              SRGBs: [
+                {
+                  range: 10,
+                  start: 6
+                },
+                {
+                  range: 2,
+                  start: 8
+                },
+                {
+                  range: 8,
+                  start: 1
+                }
+              ],
+              capabilities: {
+                unrestrictedFirstHop: true
+              },
+              enabled: false,
+              nodeCapabilities: 10
+            },
+            SRv6: {
+              enabled: false,
+              msdType: {
+                baseMplsImposition: 4,
+                erld: 10,
+                srhMaxEndD: 9,
+                srhMaxEndPop: 6,
+                srhMaxHEncaps: 9,
+                srhMaxLs: 2
+              },
+              nodeCapabilities: 3
+            },
+            management: {
+              address: null,
+              operatingSystem: 'string',
+              operatingSystemVersion: 'string',
+              vendor: 'string'
+            }
+          },
+          pseudoNode: true,
+          routerId: 'string',
+          routerIdIPv6: 'string',
+          site: 'string',
+          slices: [
+            {
+              sliceId: 7
+            },
+            {
+              sliceId: 5
+            },
+            {
+              sliceId: 5
+            },
+            {
+              sliceId: 4
+            },
+            {
+              sliceId: 8
+            },
+            {
+              sliceId: 4
+            },
+            {
+              sliceId: 7
+            },
+            {
+              sliceId: 1
+            },
+            {
+              sliceId: 4
+            }
+          ],
+          switchingCapabilities: [
+            {
+              encoding: 'lsp-encoding-oduk',
+              switchingCapability: 'switching-l2sc'
+            },
+            {
+              encoding: 'lsp-encoding-lambda',
+              switchingCapability: 'switching-tdm'
+            },
+            {
+              encoding: 'lsp-encoding-line',
+              switchingCapability: 'switching-psc1'
+            },
+            {
+              encoding: 'lsp-encoding-digital-wrapper',
+              switchingCapability: 'switching-packet'
+            },
+            {
+              encoding: 'lsp-encoding-pdh',
+              switchingCapability: 'switching-evpl'
+            },
+            {
+              encoding: 'lsp-encoding-pdh',
+              switchingCapability: 'switching-evpl'
+            }
+          ],
+          topoObjectType: 'node',
+          topology: {
+            coordinates: {
+              bbox: [
+                5,
+                9,
+                6,
+                6,
+                1
+              ],
+              crs: {
+                properties: {},
+                type: 'string'
+              }
+            }
+          },
+          topologyIndex: 1,
+          userProperties: {}
+        },
+        prefix: null,
+        priority: 7
+      }
+    ];
+    describe('#putTopologyV2TopologyIdIpePolicy - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.putTopologyV2TopologyIdIpePolicy(555, topologyPutTopologyV2TopologyIdIpePolicyBodyParam, (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('Topology', 'putTopologyV2TopologyIdIpePolicy', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteTopologyV2TopologyIdIpePolicy - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteTopologyV2TopologyIdIpePolicy(555, (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('Topology', 'deleteTopologyV2TopologyIdIpePolicy', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdIpePolicyIpePolicyId - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getTopologyV2TopologyIdIpePolicyIpePolicyId(555, 555, (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('Topology', 'getTopologyV2TopologyIdIpePolicyIpePolicyId', '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

@@ -5995,5 +5995,167 @@ describe('[unit] Paragon_pathfinder Adapter Test', () => {
         }
       }).timeout(attemptTimeout);
     });
+
+    describe('#getTopologyV2TopologyIdIpePolicy - errors', () => {
+      it('should have a getTopologyV2TopologyIdIpePolicy function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdIpePolicy === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdIpePolicy(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdIpePolicy', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postTopologyV2TopologyIdIpePolicy - errors', () => {
+      it('should have a postTopologyV2TopologyIdIpePolicy function', (done) => {
+        try {
+          assert.equal(true, typeof a.postTopologyV2TopologyIdIpePolicy === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.postTopologyV2TopologyIdIpePolicy(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-postTopologyV2TopologyIdIpePolicy', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#putTopologyV2TopologyIdIpePolicy - errors', () => {
+      it('should have a putTopologyV2TopologyIdIpePolicy function', (done) => {
+        try {
+          assert.equal(true, typeof a.putTopologyV2TopologyIdIpePolicy === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.putTopologyV2TopologyIdIpePolicy(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-putTopologyV2TopologyIdIpePolicy', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteTopologyV2TopologyIdIpePolicy - errors', () => {
+      it('should have a deleteTopologyV2TopologyIdIpePolicy function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteTopologyV2TopologyIdIpePolicy === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.deleteTopologyV2TopologyIdIpePolicy(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteTopologyV2TopologyIdIpePolicy', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdIpePolicyIpePolicyId - errors', () => {
+      it('should have a getTopologyV2TopologyIdIpePolicyIpePolicyId function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdIpePolicyIpePolicyId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdIpePolicyIpePolicyId(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdIpePolicyIpePolicyId', 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 ipePolicyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdIpePolicyIpePolicyId('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'ipePolicyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdIpePolicyIpePolicyId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
   });
 });