@itentialopensource/adapter-paragon_pathfinder 1.2.7 → 1.3.0

package/test/integration/adapterTestIntegration.js

@@ -9,13 +9,13 @@
 // include required items for testing & logging
 const assert = require('assert');
 const fs = require('fs');
-const mocha = require('mocha');
 const path = require('path');
+const util = require('util');
+const mocha = require('mocha');
 const winston = require('winston');
 const { expect } = require('chai');
 const { use } = require('chai');
 const td = require('testdouble');
-const util = require('util');
 
 const anything = td.matchers.anything();
 
@@ -335,6 +335,134 @@ describe('[integration] Paragon_pathfinder Adapter Test', () => {
       }).timeout(attemptTimeout);
     });
 
+    // broker tests
+    describe('#getDevicesFiltered - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          const opts = {
+            filter: {
+              name: 'deviceName'
+            }
+          };
+          a.getDevicesFiltered(opts, (data, error) => {
+            try {
+              if (stub) {
+                if (samProps.devicebroker.getDevicesFiltered[0].handleFailure === 'ignore') {
+                  assert.equal(null, error);
+                  assert.notEqual(undefined, data);
+                  assert.notEqual(null, data);
+                  assert.equal(0, data.total);
+                  assert.equal(0, data.list.length);
+                } else {
+                  const displayE = 'Error 400 received on request';
+                  runErrorAsserts(data, error, 'AD.500', 'Test-paragon_pathfinder-connectorRest-handleEndResponse', displayE);
+                }
+              } else {
+                runCommonAsserts(data, error);
+              }
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#iapGetDeviceCount - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          const opts = {
+            filter: {
+              name: 'deviceName'
+            }
+          };
+          a.iapGetDeviceCount((data, error) => {
+            try {
+              if (stub) {
+                if (samProps.devicebroker.getDevicesFiltered[0].handleFailure === 'ignore') {
+                  assert.equal(null, error);
+                  assert.notEqual(undefined, data);
+                  assert.notEqual(null, data);
+                  assert.equal(0, data.count);
+                } else {
+                  const displayE = 'Error 400 received on request';
+                  runErrorAsserts(data, error, 'AD.500', 'Test-paragon_pathfinder-connectorRest-handleEndResponse', displayE);
+                }
+              } else {
+                runCommonAsserts(data, error);
+              }
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    // exposed cache tests
+    describe('#iapPopulateEntityCache - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.iapPopulateEntityCache('Device', (data, error) => {
+            try {
+              if (stub) {
+                assert.equal(null, data);
+                assert.notEqual(undefined, error);
+                assert.notEqual(null, error);
+                done();
+              } else {
+                assert.equal(undefined, error);
+                assert.equal('success', data[0]);
+                done();
+              }
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#iapRetrieveEntitiesCache - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.iapRetrieveEntitiesCache('Device', {}, (data, error) => {
+            try {
+              if (stub) {
+                assert.equal(null, data);
+                assert.notEqual(null, error);
+                assert.notEqual(undefined, error);
+              } else {
+                assert.equal(undefined, error);
+                assert.notEqual(null, data);
+                assert.notEqual(undefined, data);
+              }
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
     /*
     -----------------------------------------------------------------------
     -----------------------------------------------------------------------
@@ -7310,5 +7438,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);
+    });
   });
 });