@itentialopensource/adapter-paragon_pathfinder 0.1.1 → 1.0.0

package/test/unit/adapterTestUnit.js

@@ -14612,5 +14612,4693 @@ describe('[unit] Paragon_pathfinder Adapter Test', () => {
         }
       }).timeout(attemptTimeout);
     });
+
+    describe('#getTopologyV2 - errors', () => {
+      it('should have a getTopologyV2 function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2 === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyId - errors', () => {
+      it('should have a getTopologyV2TopologyId function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyId(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteTopologyV2TopologyId - errors', () => {
+      it('should have a deleteTopologyV2TopologyId function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteTopologyV2TopologyId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.deleteTopologyV2TopologyId(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteTopologyV2TopologyId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdStream - errors', () => {
+      it('should have a getTopologyV2TopologyIdStream function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdStream === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdStream(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdStream', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdStatus - errors', () => {
+      it('should have a getTopologyV2TopologyIdStatus function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdStatus === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdStatus(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdStatus', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdStatusAnalyticsCollection - errors', () => {
+      it('should have a getTopologyV2TopologyIdStatusAnalyticsCollection function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdStatusAnalyticsCollection === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdStatusAnalyticsCollection(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdStatusAnalyticsCollection', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdStatusAnalyticsDatabase - errors', () => {
+      it('should have a getTopologyV2TopologyIdStatusAnalyticsDatabase function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdStatusAnalyticsDatabase === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdStatusAnalyticsDatabase(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdStatusAnalyticsDatabase', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdStatusPce - errors', () => {
+      it('should have a getTopologyV2TopologyIdStatusPce function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdStatusPce === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdStatusPce(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdStatusPce', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdStatusTopologyAcquisition - errors', () => {
+      it('should have a getTopologyV2TopologyIdStatusTopologyAcquisition function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdStatusTopologyAcquisition === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdStatusTopologyAcquisition(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdStatusTopologyAcquisition', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdStatusPathComputationServer - errors', () => {
+      it('should have a getTopologyV2TopologyIdStatusPathComputationServer function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdStatusPathComputationServer === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdStatusPathComputationServer(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdStatusPathComputationServer', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdStatusTransportTopologyAcquisition - errors', () => {
+      it('should have a getTopologyV2TopologyIdStatusTransportTopologyAcquisition function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdStatusTransportTopologyAcquisition === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdStatusTransportTopologyAcquisition(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdStatusTransportTopologyAcquisition', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdNodes - errors', () => {
+      it('should have a getTopologyV2TopologyIdNodes function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdNodes === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdNodes(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdNodes', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postTopologyV2TopologyIdNodes - errors', () => {
+      it('should have a postTopologyV2TopologyIdNodes function', (done) => {
+        try {
+          assert.equal(true, typeof a.postTopologyV2TopologyIdNodes === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.postTopologyV2TopologyIdNodes(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-postTopologyV2TopologyIdNodes', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdNodesSearch - errors', () => {
+      it('should have a getTopologyV2TopologyIdNodesSearch function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdNodesSearch === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdNodesSearch(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdNodesSearch', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdNodesStream - errors', () => {
+      it('should have a getTopologyV2TopologyIdNodesStream function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdNodesStream === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdNodesStream(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdNodesStream', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postTopologyV2TopologyIdNodesBulk - errors', () => {
+      it('should have a postTopologyV2TopologyIdNodesBulk function', (done) => {
+        try {
+          assert.equal(true, typeof a.postTopologyV2TopologyIdNodesBulk === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.postTopologyV2TopologyIdNodesBulk(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-postTopologyV2TopologyIdNodesBulk', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#putTopologyV2TopologyIdNodesBulk - errors', () => {
+      it('should have a putTopologyV2TopologyIdNodesBulk function', (done) => {
+        try {
+          assert.equal(true, typeof a.putTopologyV2TopologyIdNodesBulk === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.putTopologyV2TopologyIdNodesBulk(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-putTopologyV2TopologyIdNodesBulk', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchTopologyV2TopologyIdNodesBulk - errors', () => {
+      it('should have a patchTopologyV2TopologyIdNodesBulk function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchTopologyV2TopologyIdNodesBulk === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.patchTopologyV2TopologyIdNodesBulk(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-patchTopologyV2TopologyIdNodesBulk', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteTopologyV2TopologyIdNodesBulk - errors', () => {
+      it('should have a deleteTopologyV2TopologyIdNodesBulk function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteTopologyV2TopologyIdNodesBulk === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.deleteTopologyV2TopologyIdNodesBulk(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteTopologyV2TopologyIdNodesBulk', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdNodesNodeIndex - errors', () => {
+      it('should have a getTopologyV2TopologyIdNodesNodeIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdNodesNodeIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdNodesNodeIndex(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdNodesNodeIndex', 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 nodeIndex', (done) => {
+        try {
+          a.getTopologyV2TopologyIdNodesNodeIndex('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'nodeIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdNodesNodeIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#putTopologyV2TopologyIdNodesNodeIndex - errors', () => {
+      it('should have a putTopologyV2TopologyIdNodesNodeIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.putTopologyV2TopologyIdNodesNodeIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.putTopologyV2TopologyIdNodesNodeIndex(null, null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-putTopologyV2TopologyIdNodesNodeIndex', 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 nodeIndex', (done) => {
+        try {
+          a.putTopologyV2TopologyIdNodesNodeIndex('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'nodeIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-putTopologyV2TopologyIdNodesNodeIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchTopologyV2TopologyIdNodesNodeIndex - errors', () => {
+      it('should have a patchTopologyV2TopologyIdNodesNodeIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchTopologyV2TopologyIdNodesNodeIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.patchTopologyV2TopologyIdNodesNodeIndex(null, null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-patchTopologyV2TopologyIdNodesNodeIndex', 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 nodeIndex', (done) => {
+        try {
+          a.patchTopologyV2TopologyIdNodesNodeIndex('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'nodeIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-patchTopologyV2TopologyIdNodesNodeIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteTopologyV2TopologyIdNodesNodeIndex - errors', () => {
+      it('should have a deleteTopologyV2TopologyIdNodesNodeIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteTopologyV2TopologyIdNodesNodeIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.deleteTopologyV2TopologyIdNodesNodeIndex(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteTopologyV2TopologyIdNodesNodeIndex', 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 nodeIndex', (done) => {
+        try {
+          a.deleteTopologyV2TopologyIdNodesNodeIndex('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'nodeIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteTopologyV2TopologyIdNodesNodeIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdNodesNodeIndexHistory - errors', () => {
+      it('should have a getTopologyV2TopologyIdNodesNodeIndexHistory function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdNodesNodeIndexHistory === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdNodesNodeIndexHistory(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdNodesNodeIndexHistory', 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 nodeIndex', (done) => {
+        try {
+          a.getTopologyV2TopologyIdNodesNodeIndexHistory('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'nodeIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdNodesNodeIndexHistory', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdNodesNodeIndexUser - errors', () => {
+      it('should have a getTopologyV2TopologyIdNodesNodeIndexUser function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdNodesNodeIndexUser === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdNodesNodeIndexUser(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdNodesNodeIndexUser', 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 nodeIndex', (done) => {
+        try {
+          a.getTopologyV2TopologyIdNodesNodeIndexUser('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'nodeIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdNodesNodeIndexUser', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdNodesNodeIndexBgpLs - errors', () => {
+      it('should have a getTopologyV2TopologyIdNodesNodeIndexBgpLs function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdNodesNodeIndexBgpLs === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdNodesNodeIndexBgpLs(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdNodesNodeIndexBgpLs', 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 nodeIndex', (done) => {
+        try {
+          a.getTopologyV2TopologyIdNodesNodeIndexBgpLs('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'nodeIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdNodesNodeIndexBgpLs', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdNodesNodeIndexDevice - errors', () => {
+      it('should have a getTopologyV2TopologyIdNodesNodeIndexDevice function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdNodesNodeIndexDevice === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdNodesNodeIndexDevice(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdNodesNodeIndexDevice', 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 nodeIndex', (done) => {
+        try {
+          a.getTopologyV2TopologyIdNodesNodeIndexDevice('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'nodeIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdNodesNodeIndexDevice', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdLinks - errors', () => {
+      it('should have a getTopologyV2TopologyIdLinks function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdLinks === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdLinks(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdLinks', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postTopologyV2TopologyIdLinks - errors', () => {
+      it('should have a postTopologyV2TopologyIdLinks function', (done) => {
+        try {
+          assert.equal(true, typeof a.postTopologyV2TopologyIdLinks === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.postTopologyV2TopologyIdLinks(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-postTopologyV2TopologyIdLinks', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdLinksStream - errors', () => {
+      it('should have a getTopologyV2TopologyIdLinksStream function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdLinksStream === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdLinksStream(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdLinksStream', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdLinksUtilization - errors', () => {
+      it('should have a getTopologyV2TopologyIdLinksUtilization function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdLinksUtilization === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdLinksUtilization(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdLinksUtilization', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdLinksSearch - errors', () => {
+      it('should have a getTopologyV2TopologyIdLinksSearch function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdLinksSearch === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdLinksSearch(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdLinksSearch', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdLinksLinkIndex - errors', () => {
+      it('should have a getTopologyV2TopologyIdLinksLinkIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdLinksLinkIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdLinksLinkIndex(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdLinksLinkIndex', 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.getTopologyV2TopologyIdLinksLinkIndex('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'linkIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdLinksLinkIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#putTopologyV2TopologyIdLinksLinkIndex - errors', () => {
+      it('should have a putTopologyV2TopologyIdLinksLinkIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.putTopologyV2TopologyIdLinksLinkIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.putTopologyV2TopologyIdLinksLinkIndex(null, null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-putTopologyV2TopologyIdLinksLinkIndex', 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.putTopologyV2TopologyIdLinksLinkIndex('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'linkIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-putTopologyV2TopologyIdLinksLinkIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchTopologyV2TopologyIdLinksLinkIndex - errors', () => {
+      it('should have a patchTopologyV2TopologyIdLinksLinkIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchTopologyV2TopologyIdLinksLinkIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.patchTopologyV2TopologyIdLinksLinkIndex(null, null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-patchTopologyV2TopologyIdLinksLinkIndex', 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.patchTopologyV2TopologyIdLinksLinkIndex('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'linkIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-patchTopologyV2TopologyIdLinksLinkIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteTopologyV2TopologyIdLinksLinkIndex - errors', () => {
+      it('should have a deleteTopologyV2TopologyIdLinksLinkIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteTopologyV2TopologyIdLinksLinkIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.deleteTopologyV2TopologyIdLinksLinkIndex(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteTopologyV2TopologyIdLinksLinkIndex', 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.deleteTopologyV2TopologyIdLinksLinkIndex('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'linkIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteTopologyV2TopologyIdLinksLinkIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdLinksLinkIndexHistory - errors', () => {
+      it('should have a getTopologyV2TopologyIdLinksLinkIndexHistory function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdLinksLinkIndexHistory === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdLinksLinkIndexHistory(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdLinksLinkIndexHistory', 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.getTopologyV2TopologyIdLinksLinkIndexHistory('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'linkIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdLinksLinkIndexHistory', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdLinksLinkIndexDevice - errors', () => {
+      it('should have a getTopologyV2TopologyIdLinksLinkIndexDevice function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdLinksLinkIndexDevice === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdLinksLinkIndexDevice(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdLinksLinkIndexDevice', 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.getTopologyV2TopologyIdLinksLinkIndexDevice('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'linkIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdLinksLinkIndexDevice', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#putTopologyV2TopologyIdLinksLinkIndexDevice - errors', () => {
+      it('should have a putTopologyV2TopologyIdLinksLinkIndexDevice function', (done) => {
+        try {
+          assert.equal(true, typeof a.putTopologyV2TopologyIdLinksLinkIndexDevice === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.putTopologyV2TopologyIdLinksLinkIndexDevice(null, null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-putTopologyV2TopologyIdLinksLinkIndexDevice', 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.putTopologyV2TopologyIdLinksLinkIndexDevice('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'linkIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-putTopologyV2TopologyIdLinksLinkIndexDevice', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchTopologyV2TopologyIdLinksLinkIndexDevice - errors', () => {
+      it('should have a patchTopologyV2TopologyIdLinksLinkIndexDevice function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchTopologyV2TopologyIdLinksLinkIndexDevice === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.patchTopologyV2TopologyIdLinksLinkIndexDevice(null, null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-patchTopologyV2TopologyIdLinksLinkIndexDevice', 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.patchTopologyV2TopologyIdLinksLinkIndexDevice('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'linkIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-patchTopologyV2TopologyIdLinksLinkIndexDevice', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdLinksLinkIndexUser - errors', () => {
+      it('should have a getTopologyV2TopologyIdLinksLinkIndexUser function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdLinksLinkIndexUser === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdLinksLinkIndexUser(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdLinksLinkIndexUser', 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.getTopologyV2TopologyIdLinksLinkIndexUser('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'linkIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdLinksLinkIndexUser', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#putTopologyV2TopologyIdLinksLinkIndexUser - errors', () => {
+      it('should have a putTopologyV2TopologyIdLinksLinkIndexUser function', (done) => {
+        try {
+          assert.equal(true, typeof a.putTopologyV2TopologyIdLinksLinkIndexUser === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.putTopologyV2TopologyIdLinksLinkIndexUser(null, null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-putTopologyV2TopologyIdLinksLinkIndexUser', 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.putTopologyV2TopologyIdLinksLinkIndexUser('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'linkIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-putTopologyV2TopologyIdLinksLinkIndexUser', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchTopologyV2TopologyIdLinksLinkIndexUser - errors', () => {
+      it('should have a patchTopologyV2TopologyIdLinksLinkIndexUser function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchTopologyV2TopologyIdLinksLinkIndexUser === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.patchTopologyV2TopologyIdLinksLinkIndexUser(null, null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-patchTopologyV2TopologyIdLinksLinkIndexUser', 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.patchTopologyV2TopologyIdLinksLinkIndexUser('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'linkIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-patchTopologyV2TopologyIdLinksLinkIndexUser', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdLinksLinkIndexBgpLs - errors', () => {
+      it('should have a getTopologyV2TopologyIdLinksLinkIndexBgpLs function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdLinksLinkIndexBgpLs === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdLinksLinkIndexBgpLs(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdLinksLinkIndexBgpLs', 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.getTopologyV2TopologyIdLinksLinkIndexBgpLs('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'linkIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdLinksLinkIndexBgpLs', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdTeLsps - errors', () => {
+      it('should have a getTopologyV2TopologyIdTeLsps function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdTeLsps === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdTeLsps(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdTeLsps', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postTopologyV2TopologyIdTeLsps - errors', () => {
+      it('should have a postTopologyV2TopologyIdTeLsps function', (done) => {
+        try {
+          assert.equal(true, typeof a.postTopologyV2TopologyIdTeLsps === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.postTopologyV2TopologyIdTeLsps(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-postTopologyV2TopologyIdTeLsps', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdTeLspsSearch - errors', () => {
+      it('should have a getTopologyV2TopologyIdTeLspsSearch function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdTeLspsSearch === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdTeLspsSearch(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdTeLspsSearch', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdTeLspsStream - errors', () => {
+      it('should have a getTopologyV2TopologyIdTeLspsStream function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdTeLspsStream === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdTeLspsStream(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdTeLspsStream', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postTopologyV2TopologyIdTeLspsBulk - errors', () => {
+      it('should have a postTopologyV2TopologyIdTeLspsBulk function', (done) => {
+        try {
+          assert.equal(true, typeof a.postTopologyV2TopologyIdTeLspsBulk === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.postTopologyV2TopologyIdTeLspsBulk(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-postTopologyV2TopologyIdTeLspsBulk', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#putTopologyV2TopologyIdTeLspsBulk - errors', () => {
+      it('should have a putTopologyV2TopologyIdTeLspsBulk function', (done) => {
+        try {
+          assert.equal(true, typeof a.putTopologyV2TopologyIdTeLspsBulk === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.putTopologyV2TopologyIdTeLspsBulk(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-putTopologyV2TopologyIdTeLspsBulk', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchTopologyV2TopologyIdTeLspsBulk - errors', () => {
+      it('should have a patchTopologyV2TopologyIdTeLspsBulk function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchTopologyV2TopologyIdTeLspsBulk === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.patchTopologyV2TopologyIdTeLspsBulk(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-patchTopologyV2TopologyIdTeLspsBulk', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteTopologyV2TopologyIdTeLspsBulk - errors', () => {
+      it('should have a deleteTopologyV2TopologyIdTeLspsBulk function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteTopologyV2TopologyIdTeLspsBulk === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.deleteTopologyV2TopologyIdTeLspsBulk(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteTopologyV2TopologyIdTeLspsBulk', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdTeLspsLspIndex - errors', () => {
+      it('should have a getTopologyV2TopologyIdTeLspsLspIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdTeLspsLspIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdTeLspsLspIndex(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdTeLspsLspIndex', 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.getTopologyV2TopologyIdTeLspsLspIndex('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'lspIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdTeLspsLspIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#putTopologyV2TopologyIdTeLspsLspIndex - errors', () => {
+      it('should have a putTopologyV2TopologyIdTeLspsLspIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.putTopologyV2TopologyIdTeLspsLspIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.putTopologyV2TopologyIdTeLspsLspIndex(null, null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-putTopologyV2TopologyIdTeLspsLspIndex', 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.putTopologyV2TopologyIdTeLspsLspIndex('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'lspIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-putTopologyV2TopologyIdTeLspsLspIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchTopologyV2TopologyIdTeLspsLspIndex - errors', () => {
+      it('should have a patchTopologyV2TopologyIdTeLspsLspIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchTopologyV2TopologyIdTeLspsLspIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.patchTopologyV2TopologyIdTeLspsLspIndex(null, null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-patchTopologyV2TopologyIdTeLspsLspIndex', 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.patchTopologyV2TopologyIdTeLspsLspIndex('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'lspIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-patchTopologyV2TopologyIdTeLspsLspIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteTopologyV2TopologyIdTeLspsLspIndex - errors', () => {
+      it('should have a deleteTopologyV2TopologyIdTeLspsLspIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteTopologyV2TopologyIdTeLspsLspIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.deleteTopologyV2TopologyIdTeLspsLspIndex(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteTopologyV2TopologyIdTeLspsLspIndex', 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.deleteTopologyV2TopologyIdTeLspsLspIndex('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'lspIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteTopologyV2TopologyIdTeLspsLspIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdTeLspsLspIndexHistory - errors', () => {
+      it('should have a getTopologyV2TopologyIdTeLspsLspIndexHistory function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdTeLspsLspIndexHistory === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdTeLspsLspIndexHistory(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdTeLspsLspIndexHistory', 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.getTopologyV2TopologyIdTeLspsLspIndexHistory('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'lspIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdTeLspsLspIndexHistory', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdDemands - errors', () => {
+      it('should have a getTopologyV2TopologyIdDemands function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdDemands === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdDemands(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdDemands', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postTopologyV2TopologyIdDemands - errors', () => {
+      it('should have a postTopologyV2TopologyIdDemands function', (done) => {
+        try {
+          assert.equal(true, typeof a.postTopologyV2TopologyIdDemands === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.postTopologyV2TopologyIdDemands(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-postTopologyV2TopologyIdDemands', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdDemandsStream - errors', () => {
+      it('should have a getTopologyV2TopologyIdDemandsStream function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdDemandsStream === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdDemandsStream(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdDemandsStream', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdDemandsDemandIndex - errors', () => {
+      it('should have a getTopologyV2TopologyIdDemandsDemandIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdDemandsDemandIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdDemandsDemandIndex(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdDemandsDemandIndex', 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 demandIndex', (done) => {
+        try {
+          a.getTopologyV2TopologyIdDemandsDemandIndex('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'demandIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdDemandsDemandIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#putTopologyV2TopologyIdDemandsDemandIndex - errors', () => {
+      it('should have a putTopologyV2TopologyIdDemandsDemandIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.putTopologyV2TopologyIdDemandsDemandIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.putTopologyV2TopologyIdDemandsDemandIndex(null, null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-putTopologyV2TopologyIdDemandsDemandIndex', 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 demandIndex', (done) => {
+        try {
+          a.putTopologyV2TopologyIdDemandsDemandIndex('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'demandIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-putTopologyV2TopologyIdDemandsDemandIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchTopologyV2TopologyIdDemandsDemandIndex - errors', () => {
+      it('should have a patchTopologyV2TopologyIdDemandsDemandIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchTopologyV2TopologyIdDemandsDemandIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.patchTopologyV2TopologyIdDemandsDemandIndex(null, null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-patchTopologyV2TopologyIdDemandsDemandIndex', 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 demandIndex', (done) => {
+        try {
+          a.patchTopologyV2TopologyIdDemandsDemandIndex('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'demandIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-patchTopologyV2TopologyIdDemandsDemandIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteTopologyV2TopologyIdDemandsDemandIndex - errors', () => {
+      it('should have a deleteTopologyV2TopologyIdDemandsDemandIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteTopologyV2TopologyIdDemandsDemandIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.deleteTopologyV2TopologyIdDemandsDemandIndex(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteTopologyV2TopologyIdDemandsDemandIndex', 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 demandIndex', (done) => {
+        try {
+          a.deleteTopologyV2TopologyIdDemandsDemandIndex('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'demandIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteTopologyV2TopologyIdDemandsDemandIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postTopologyV2TopologyIdDemandsBulk - errors', () => {
+      it('should have a postTopologyV2TopologyIdDemandsBulk function', (done) => {
+        try {
+          assert.equal(true, typeof a.postTopologyV2TopologyIdDemandsBulk === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.postTopologyV2TopologyIdDemandsBulk(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-postTopologyV2TopologyIdDemandsBulk', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#putTopologyV2TopologyIdDemandsBulk - errors', () => {
+      it('should have a putTopologyV2TopologyIdDemandsBulk function', (done) => {
+        try {
+          assert.equal(true, typeof a.putTopologyV2TopologyIdDemandsBulk === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.putTopologyV2TopologyIdDemandsBulk(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-putTopologyV2TopologyIdDemandsBulk', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchTopologyV2TopologyIdDemandsBulk - errors', () => {
+      it('should have a patchTopologyV2TopologyIdDemandsBulk function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchTopologyV2TopologyIdDemandsBulk === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.patchTopologyV2TopologyIdDemandsBulk(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-patchTopologyV2TopologyIdDemandsBulk', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteTopologyV2TopologyIdDemandsBulk - errors', () => {
+      it('should have a deleteTopologyV2TopologyIdDemandsBulk function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteTopologyV2TopologyIdDemandsBulk === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.deleteTopologyV2TopologyIdDemandsBulk(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteTopologyV2TopologyIdDemandsBulk', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdP2mp - errors', () => {
+      it('should have a getTopologyV2TopologyIdP2mp function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdP2mp === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdP2mp(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdP2mp', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postTopologyV2TopologyIdP2mp - errors', () => {
+      it('should have a postTopologyV2TopologyIdP2mp function', (done) => {
+        try {
+          assert.equal(true, typeof a.postTopologyV2TopologyIdP2mp === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.postTopologyV2TopologyIdP2mp(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-postTopologyV2TopologyIdP2mp', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdP2mpStream - errors', () => {
+      it('should have a getTopologyV2TopologyIdP2mpStream function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdP2mpStream === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdP2mpStream(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdP2mpStream', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteTopologyV2TopologyIdP2mpBulk - errors', () => {
+      it('should have a deleteTopologyV2TopologyIdP2mpBulk function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteTopologyV2TopologyIdP2mpBulk === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.deleteTopologyV2TopologyIdP2mpBulk(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteTopologyV2TopologyIdP2mpBulk', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdP2mpP2mpGroupIndex - errors', () => {
+      it('should have a getTopologyV2TopologyIdP2mpP2mpGroupIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdP2mpP2mpGroupIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdP2mpP2mpGroupIndex(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdP2mpP2mpGroupIndex', 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 p2mpGroupIndex', (done) => {
+        try {
+          a.getTopologyV2TopologyIdP2mpP2mpGroupIndex('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'p2mpGroupIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdP2mpP2mpGroupIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#putTopologyV2TopologyIdP2mpP2mpGroupIndex - errors', () => {
+      it('should have a putTopologyV2TopologyIdP2mpP2mpGroupIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.putTopologyV2TopologyIdP2mpP2mpGroupIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.putTopologyV2TopologyIdP2mpP2mpGroupIndex(null, null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-putTopologyV2TopologyIdP2mpP2mpGroupIndex', 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 p2mpGroupIndex', (done) => {
+        try {
+          a.putTopologyV2TopologyIdP2mpP2mpGroupIndex('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'p2mpGroupIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-putTopologyV2TopologyIdP2mpP2mpGroupIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteTopologyV2TopologyIdP2mpP2mpGroupIndex - errors', () => {
+      it('should have a deleteTopologyV2TopologyIdP2mpP2mpGroupIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteTopologyV2TopologyIdP2mpP2mpGroupIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.deleteTopologyV2TopologyIdP2mpP2mpGroupIndex(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteTopologyV2TopologyIdP2mpP2mpGroupIndex', 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 p2mpGroupIndex', (done) => {
+        try {
+          a.deleteTopologyV2TopologyIdP2mpP2mpGroupIndex('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'p2mpGroupIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteTopologyV2TopologyIdP2mpP2mpGroupIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchTopologyV2TopologyIdP2mpP2mpGroupIndex - errors', () => {
+      it('should have a patchTopologyV2TopologyIdP2mpP2mpGroupIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchTopologyV2TopologyIdP2mpP2mpGroupIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.patchTopologyV2TopologyIdP2mpP2mpGroupIndex(null, null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-patchTopologyV2TopologyIdP2mpP2mpGroupIndex', 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 p2mpGroupIndex', (done) => {
+        try {
+          a.patchTopologyV2TopologyIdP2mpP2mpGroupIndex('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'p2mpGroupIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-patchTopologyV2TopologyIdP2mpP2mpGroupIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postTopologyV2TopologyIdP2mpP2mpGroupIndex - errors', () => {
+      it('should have a postTopologyV2TopologyIdP2mpP2mpGroupIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.postTopologyV2TopologyIdP2mpP2mpGroupIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.postTopologyV2TopologyIdP2mpP2mpGroupIndex(null, null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-postTopologyV2TopologyIdP2mpP2mpGroupIndex', 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 p2mpGroupIndex', (done) => {
+        try {
+          a.postTopologyV2TopologyIdP2mpP2mpGroupIndex('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'p2mpGroupIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-postTopologyV2TopologyIdP2mpP2mpGroupIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdP2mpP2mpGroupIndexLspIndex - errors', () => {
+      it('should have a getTopologyV2TopologyIdP2mpP2mpGroupIndexLspIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdP2mpP2mpGroupIndexLspIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdP2mpP2mpGroupIndexLspIndex(null, null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdP2mpP2mpGroupIndexLspIndex', 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 p2mpGroupIndex', (done) => {
+        try {
+          a.getTopologyV2TopologyIdP2mpP2mpGroupIndexLspIndex('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'p2mpGroupIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdP2mpP2mpGroupIndexLspIndex', 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.getTopologyV2TopologyIdP2mpP2mpGroupIndexLspIndex('fakeparam', 'fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'lspIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdP2mpP2mpGroupIndexLspIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteTopologyV2TopologyIdP2mpP2mpGroupIndexLspIndex - errors', () => {
+      it('should have a deleteTopologyV2TopologyIdP2mpP2mpGroupIndexLspIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteTopologyV2TopologyIdP2mpP2mpGroupIndexLspIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.deleteTopologyV2TopologyIdP2mpP2mpGroupIndexLspIndex(null, null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteTopologyV2TopologyIdP2mpP2mpGroupIndexLspIndex', 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 p2mpGroupIndex', (done) => {
+        try {
+          a.deleteTopologyV2TopologyIdP2mpP2mpGroupIndexLspIndex('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'p2mpGroupIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteTopologyV2TopologyIdP2mpP2mpGroupIndexLspIndex', 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.deleteTopologyV2TopologyIdP2mpP2mpGroupIndexLspIndex('fakeparam', 'fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'lspIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteTopologyV2TopologyIdP2mpP2mpGroupIndexLspIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteTopologyV2TopologyIdP2mpP2mpGroupIndexBulk - errors', () => {
+      it('should have a deleteTopologyV2TopologyIdP2mpP2mpGroupIndexBulk function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteTopologyV2TopologyIdP2mpP2mpGroupIndexBulk === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.deleteTopologyV2TopologyIdP2mpP2mpGroupIndexBulk(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteTopologyV2TopologyIdP2mpP2mpGroupIndexBulk', 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 p2mpGroupIndex', (done) => {
+        try {
+          a.deleteTopologyV2TopologyIdP2mpP2mpGroupIndexBulk('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'p2mpGroupIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteTopologyV2TopologyIdP2mpP2mpGroupIndexBulk', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdVrfs - errors', () => {
+      it('should have a getTopologyV2TopologyIdVrfs function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdVrfs === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdVrfs(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdVrfs', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdVrfsNodeIndex - errors', () => {
+      it('should have a getTopologyV2TopologyIdVrfsNodeIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdVrfsNodeIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdVrfsNodeIndex(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdVrfsNodeIndex', 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 nodeIndex', (done) => {
+        try {
+          a.getTopologyV2TopologyIdVrfsNodeIndex('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'nodeIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdVrfsNodeIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdMaintenances - errors', () => {
+      it('should have a getTopologyV2TopologyIdMaintenances function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdMaintenances === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdMaintenances(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdMaintenances', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postTopologyV2TopologyIdMaintenances - errors', () => {
+      it('should have a postTopologyV2TopologyIdMaintenances function', (done) => {
+        try {
+          assert.equal(true, typeof a.postTopologyV2TopologyIdMaintenances === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.postTopologyV2TopologyIdMaintenances(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-postTopologyV2TopologyIdMaintenances', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdMaintenancesStream - errors', () => {
+      it('should have a getTopologyV2TopologyIdMaintenancesStream function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdMaintenancesStream === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdMaintenancesStream(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdMaintenancesStream', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdMaintenancesMaintenanceIndex - errors', () => {
+      it('should have a getTopologyV2TopologyIdMaintenancesMaintenanceIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdMaintenancesMaintenanceIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdMaintenancesMaintenanceIndex(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdMaintenancesMaintenanceIndex', 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 maintenanceIndex', (done) => {
+        try {
+          a.getTopologyV2TopologyIdMaintenancesMaintenanceIndex('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'maintenanceIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdMaintenancesMaintenanceIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#putTopologyV2TopologyIdMaintenancesMaintenanceIndex - errors', () => {
+      it('should have a putTopologyV2TopologyIdMaintenancesMaintenanceIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.putTopologyV2TopologyIdMaintenancesMaintenanceIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.putTopologyV2TopologyIdMaintenancesMaintenanceIndex(null, null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-putTopologyV2TopologyIdMaintenancesMaintenanceIndex', 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 maintenanceIndex', (done) => {
+        try {
+          a.putTopologyV2TopologyIdMaintenancesMaintenanceIndex('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'maintenanceIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-putTopologyV2TopologyIdMaintenancesMaintenanceIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteTopologyV2TopologyIdMaintenancesMaintenanceIndex - errors', () => {
+      it('should have a deleteTopologyV2TopologyIdMaintenancesMaintenanceIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteTopologyV2TopologyIdMaintenancesMaintenanceIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.deleteTopologyV2TopologyIdMaintenancesMaintenanceIndex(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteTopologyV2TopologyIdMaintenancesMaintenanceIndex', 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 maintenanceIndex', (done) => {
+        try {
+          a.deleteTopologyV2TopologyIdMaintenancesMaintenanceIndex('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'maintenanceIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteTopologyV2TopologyIdMaintenancesMaintenanceIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdFacilities - errors', () => {
+      it('should have a getTopologyV2TopologyIdFacilities function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdFacilities === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdFacilities(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdFacilities', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postTopologyV2TopologyIdFacilities - errors', () => {
+      it('should have a postTopologyV2TopologyIdFacilities function', (done) => {
+        try {
+          assert.equal(true, typeof a.postTopologyV2TopologyIdFacilities === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.postTopologyV2TopologyIdFacilities(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-postTopologyV2TopologyIdFacilities', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdFacilitiesStream - errors', () => {
+      it('should have a getTopologyV2TopologyIdFacilitiesStream function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdFacilitiesStream === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdFacilitiesStream(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdFacilitiesStream', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdFacilitiesFacilityIndex - errors', () => {
+      it('should have a getTopologyV2TopologyIdFacilitiesFacilityIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdFacilitiesFacilityIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdFacilitiesFacilityIndex(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdFacilitiesFacilityIndex', 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 facilityIndex', (done) => {
+        try {
+          a.getTopologyV2TopologyIdFacilitiesFacilityIndex('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'facilityIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdFacilitiesFacilityIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#putTopologyV2TopologyIdFacilitiesFacilityIndex - errors', () => {
+      it('should have a putTopologyV2TopologyIdFacilitiesFacilityIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.putTopologyV2TopologyIdFacilitiesFacilityIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.putTopologyV2TopologyIdFacilitiesFacilityIndex(null, null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-putTopologyV2TopologyIdFacilitiesFacilityIndex', 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 facilityIndex', (done) => {
+        try {
+          a.putTopologyV2TopologyIdFacilitiesFacilityIndex('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'facilityIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-putTopologyV2TopologyIdFacilitiesFacilityIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteTopologyV2TopologyIdFacilitiesFacilityIndex - errors', () => {
+      it('should have a deleteTopologyV2TopologyIdFacilitiesFacilityIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteTopologyV2TopologyIdFacilitiesFacilityIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.deleteTopologyV2TopologyIdFacilitiesFacilityIndex(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteTopologyV2TopologyIdFacilitiesFacilityIndex', 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 facilityIndex', (done) => {
+        try {
+          a.deleteTopologyV2TopologyIdFacilitiesFacilityIndex('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'facilityIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteTopologyV2TopologyIdFacilitiesFacilityIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdTeContainers - errors', () => {
+      it('should have a getTopologyV2TopologyIdTeContainers function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdTeContainers === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdTeContainers(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdTeContainers', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postTopologyV2TopologyIdTeContainers - errors', () => {
+      it('should have a postTopologyV2TopologyIdTeContainers function', (done) => {
+        try {
+          assert.equal(true, typeof a.postTopologyV2TopologyIdTeContainers === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.postTopologyV2TopologyIdTeContainers(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-postTopologyV2TopologyIdTeContainers', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdTeContainersStream - errors', () => {
+      it('should have a getTopologyV2TopologyIdTeContainersStream function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdTeContainersStream === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdTeContainersStream(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdTeContainersStream', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdTeContainersContainerIndex - errors', () => {
+      it('should have a getTopologyV2TopologyIdTeContainersContainerIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdTeContainersContainerIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdTeContainersContainerIndex(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdTeContainersContainerIndex', 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 containerIndex', (done) => {
+        try {
+          a.getTopologyV2TopologyIdTeContainersContainerIndex('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'containerIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdTeContainersContainerIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#putTopologyV2TopologyIdTeContainersContainerIndex - errors', () => {
+      it('should have a putTopologyV2TopologyIdTeContainersContainerIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.putTopologyV2TopologyIdTeContainersContainerIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.putTopologyV2TopologyIdTeContainersContainerIndex(null, null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-putTopologyV2TopologyIdTeContainersContainerIndex', 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 containerIndex', (done) => {
+        try {
+          a.putTopologyV2TopologyIdTeContainersContainerIndex('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'containerIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-putTopologyV2TopologyIdTeContainersContainerIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchTopologyV2TopologyIdTeContainersContainerIndex - errors', () => {
+      it('should have a patchTopologyV2TopologyIdTeContainersContainerIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchTopologyV2TopologyIdTeContainersContainerIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.patchTopologyV2TopologyIdTeContainersContainerIndex(null, null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-patchTopologyV2TopologyIdTeContainersContainerIndex', 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 containerIndex', (done) => {
+        try {
+          a.patchTopologyV2TopologyIdTeContainersContainerIndex('fakeparam', null, null, (data, error) => {
+            try {
+              const displayE = 'containerIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-patchTopologyV2TopologyIdTeContainersContainerIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteTopologyV2TopologyIdTeContainersContainerIndex - errors', () => {
+      it('should have a deleteTopologyV2TopologyIdTeContainersContainerIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteTopologyV2TopologyIdTeContainersContainerIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.deleteTopologyV2TopologyIdTeContainersContainerIndex(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteTopologyV2TopologyIdTeContainersContainerIndex', 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 containerIndex', (done) => {
+        try {
+          a.deleteTopologyV2TopologyIdTeContainersContainerIndex('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'containerIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteTopologyV2TopologyIdTeContainersContainerIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postTopologyV2TopologyIdTeContainersBulk - errors', () => {
+      it('should have a postTopologyV2TopologyIdTeContainersBulk function', (done) => {
+        try {
+          assert.equal(true, typeof a.postTopologyV2TopologyIdTeContainersBulk === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.postTopologyV2TopologyIdTeContainersBulk(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-postTopologyV2TopologyIdTeContainersBulk', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#putTopologyV2TopologyIdTeContainersBulk - errors', () => {
+      it('should have a putTopologyV2TopologyIdTeContainersBulk function', (done) => {
+        try {
+          assert.equal(true, typeof a.putTopologyV2TopologyIdTeContainersBulk === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.putTopologyV2TopologyIdTeContainersBulk(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-putTopologyV2TopologyIdTeContainersBulk', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchTopologyV2TopologyIdTeContainersBulk - errors', () => {
+      it('should have a patchTopologyV2TopologyIdTeContainersBulk function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchTopologyV2TopologyIdTeContainersBulk === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.patchTopologyV2TopologyIdTeContainersBulk(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-patchTopologyV2TopologyIdTeContainersBulk', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteTopologyV2TopologyIdTeContainersBulk - errors', () => {
+      it('should have a deleteTopologyV2TopologyIdTeContainersBulk function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteTopologyV2TopologyIdTeContainersBulk === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.deleteTopologyV2TopologyIdTeContainersBulk(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteTopologyV2TopologyIdTeContainersBulk', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdRoutes - errors', () => {
+      it('should have a getTopologyV2TopologyIdRoutes function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdRoutes === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdRoutes(null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdRoutes', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2TopologyIdRoutesNodeIndex - errors', () => {
+      it('should have a getTopologyV2TopologyIdRoutesNodeIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2TopologyIdRoutesNodeIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.getTopologyV2TopologyIdRoutesNodeIndex(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdRoutesNodeIndex', 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 nodeIndex', (done) => {
+        try {
+          a.getTopologyV2TopologyIdRoutesNodeIndex('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'nodeIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2TopologyIdRoutesNodeIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postTopologyV2TopologyIdPathComputation - errors', () => {
+      it('should have a postTopologyV2TopologyIdPathComputation function', (done) => {
+        try {
+          assert.equal(true, typeof a.postTopologyV2TopologyIdPathComputation === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing topologyId', (done) => {
+        try {
+          a.postTopologyV2TopologyIdPathComputation(null, null, (data, error) => {
+            try {
+              const displayE = 'topologyId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-postTopologyV2TopologyIdPathComputation', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postTopologyV2RpcOptimize - errors', () => {
+      it('should have a postTopologyV2RpcOptimize function', (done) => {
+        try {
+          assert.equal(true, typeof a.postTopologyV2RpcOptimize === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2RpcOptimize - errors', () => {
+      it('should have a getTopologyV2RpcOptimize function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2RpcOptimize === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postTopologyV2RpcSimulation - errors', () => {
+      it('should have a postTopologyV2RpcSimulation function', (done) => {
+        try {
+          assert.equal(true, typeof a.postTopologyV2RpcSimulation === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2RpcSimulation - errors', () => {
+      it('should have a getTopologyV2RpcSimulation function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2RpcSimulation === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2RpcSimulationUuid - errors', () => {
+      it('should have a getTopologyV2RpcSimulationUuid function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2RpcSimulationUuid === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getTopologyV2RpcSimulationUuid(null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2RpcSimulationUuid', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2RpcSimulationUuidReportName - errors', () => {
+      it('should have a getTopologyV2RpcSimulationUuidReportName function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2RpcSimulationUuidReportName === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getTopologyV2RpcSimulationUuidReportName(null, null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2RpcSimulationUuidReportName', 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 reportName', (done) => {
+        try {
+          a.getTopologyV2RpcSimulationUuidReportName('fakeparam', null, (data, error) => {
+            try {
+              const displayE = 'reportName is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2RpcSimulationUuidReportName', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postTopologyV2RpcDiverseTreeDesign - errors', () => {
+      it('should have a postTopologyV2RpcDiverseTreeDesign function', (done) => {
+        try {
+          assert.equal(true, typeof a.postTopologyV2RpcDiverseTreeDesign === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2RpcDiverseTreeDesign - errors', () => {
+      it('should have a getTopologyV2RpcDiverseTreeDesign function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2RpcDiverseTreeDesign === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTopologyV2RpcDiverseTreeDesignUuid - errors', () => {
+      it('should have a getTopologyV2RpcDiverseTreeDesignUuid function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTopologyV2RpcDiverseTreeDesignUuid === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing uuid', (done) => {
+        try {
+          a.getTopologyV2RpcDiverseTreeDesignUuid(null, (data, error) => {
+            try {
+              const displayE = 'uuid is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTopologyV2RpcDiverseTreeDesignUuid', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSchedulerV2Tasklist - errors', () => {
+      it('should have a getSchedulerV2Tasklist function', (done) => {
+        try {
+          assert.equal(true, typeof a.getSchedulerV2Tasklist === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSchedulerV2Tasks - errors', () => {
+      it('should have a getSchedulerV2Tasks function', (done) => {
+        try {
+          assert.equal(true, typeof a.getSchedulerV2Tasks === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postSchedulerV2Addtask - errors', () => {
+      it('should have a postSchedulerV2Addtask function', (done) => {
+        try {
+          assert.equal(true, typeof a.postSchedulerV2Addtask === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postSchedulerV2Updatetask - errors', () => {
+      it('should have a postSchedulerV2Updatetask function', (done) => {
+        try {
+          assert.equal(true, typeof a.postSchedulerV2Updatetask === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postSchedulerV2Removeaddtask - errors', () => {
+      it('should have a postSchedulerV2Removeaddtask function', (done) => {
+        try {
+          assert.equal(true, typeof a.postSchedulerV2Removeaddtask === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postSchedulerV2Deletetask - errors', () => {
+      it('should have a postSchedulerV2Deletetask function', (done) => {
+        try {
+          assert.equal(true, typeof a.postSchedulerV2Deletetask === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSchedulerV2TaskshistoryTaskId - errors', () => {
+      it('should have a getSchedulerV2TaskshistoryTaskId function', (done) => {
+        try {
+          assert.equal(true, typeof a.getSchedulerV2TaskshistoryTaskId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing taskId', (done) => {
+        try {
+          a.getSchedulerV2TaskshistoryTaskId(null, (data, error) => {
+            try {
+              const displayE = 'taskId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getSchedulerV2TaskshistoryTaskId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSchedulerV2TaskstatusTaskId - errors', () => {
+      it('should have a getSchedulerV2TaskstatusTaskId function', (done) => {
+        try {
+          assert.equal(true, typeof a.getSchedulerV2TaskstatusTaskId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing taskId', (done) => {
+        try {
+          a.getSchedulerV2TaskstatusTaskId(null, (data, error) => {
+            try {
+              const displayE = 'taskId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getSchedulerV2TaskstatusTaskId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getComponentConfig - errors', () => {
+      it('should have a getComponentConfig function', (done) => {
+        try {
+          assert.equal(true, typeof a.getComponentConfig === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postConfig - errors', () => {
+      it('should have a postConfig function', (done) => {
+        try {
+          assert.equal(true, typeof a.postConfig === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#patchConfig - errors', () => {
+      it('should have a patchConfig function', (done) => {
+        try {
+          assert.equal(true, typeof a.patchConfig === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteConfig - errors', () => {
+      it('should have a deleteConfig function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteConfig === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTransportControllersV2 - errors', () => {
+      it('should have a getTransportControllersV2 function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTransportControllersV2 === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postTransportControllersV2 - errors', () => {
+      it('should have a postTransportControllersV2 function', (done) => {
+        try {
+          assert.equal(true, typeof a.postTransportControllersV2 === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTransportControllersV2TransportControllerIndex - errors', () => {
+      it('should have a getTransportControllersV2TransportControllerIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTransportControllersV2TransportControllerIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing transportControllerIndex', (done) => {
+        try {
+          a.getTransportControllersV2TransportControllerIndex(null, (data, error) => {
+            try {
+              const displayE = 'transportControllerIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTransportControllersV2TransportControllerIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#putTransportControllersV2TransportControllerIndex - errors', () => {
+      it('should have a putTransportControllersV2TransportControllerIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.putTransportControllersV2TransportControllerIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing transportControllerIndex', (done) => {
+        try {
+          a.putTransportControllersV2TransportControllerIndex(null, null, (data, error) => {
+            try {
+              const displayE = 'transportControllerIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-putTransportControllersV2TransportControllerIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteTransportControllersV2TransportControllerIndex - errors', () => {
+      it('should have a deleteTransportControllersV2TransportControllerIndex function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteTransportControllersV2TransportControllerIndex === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing transportControllerIndex', (done) => {
+        try {
+          a.deleteTransportControllersV2TransportControllerIndex(null, (data, error) => {
+            try {
+              const displayE = 'transportControllerIndex is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteTransportControllersV2TransportControllerIndex', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTransportControllerGroupsV2 - errors', () => {
+      it('should have a getTransportControllerGroupsV2 function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTransportControllerGroupsV2 === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postTransportControllerGroupsV2 - errors', () => {
+      it('should have a postTransportControllerGroupsV2 function', (done) => {
+        try {
+          assert.equal(true, typeof a.postTransportControllerGroupsV2 === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteTransportControllerGroupsV2 - errors', () => {
+      it('should have a deleteTransportControllerGroupsV2 function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteTransportControllerGroupsV2 === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTransportControllerGroupsV2TransportControllerGroupName - errors', () => {
+      it('should have a getTransportControllerGroupsV2TransportControllerGroupName function', (done) => {
+        try {
+          assert.equal(true, typeof a.getTransportControllerGroupsV2TransportControllerGroupName === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing transportControllerGroupName', (done) => {
+        try {
+          a.getTransportControllerGroupsV2TransportControllerGroupName(null, (data, error) => {
+            try {
+              const displayE = 'transportControllerGroupName is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getTransportControllerGroupsV2TransportControllerGroupName', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#putTransportControllerGroupsV2TransportControllerGroupName - errors', () => {
+      it('should have a putTransportControllerGroupsV2TransportControllerGroupName function', (done) => {
+        try {
+          assert.equal(true, typeof a.putTransportControllerGroupsV2TransportControllerGroupName === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing transportControllerGroupName', (done) => {
+        try {
+          a.putTransportControllerGroupsV2TransportControllerGroupName(null, null, (data, error) => {
+            try {
+              const displayE = 'transportControllerGroupName is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-putTransportControllerGroupsV2TransportControllerGroupName', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postTransportControllerGroupsV2TransportControllerGroupName - errors', () => {
+      it('should have a postTransportControllerGroupsV2TransportControllerGroupName function', (done) => {
+        try {
+          assert.equal(true, typeof a.postTransportControllerGroupsV2TransportControllerGroupName === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing transportControllerGroupName', (done) => {
+        try {
+          a.postTransportControllerGroupsV2TransportControllerGroupName(null, null, (data, error) => {
+            try {
+              const displayE = 'transportControllerGroupName is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-postTransportControllerGroupsV2TransportControllerGroupName', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteTransportControllerGroupsV2TransportControllerGroupName - errors', () => {
+      it('should have a deleteTransportControllerGroupsV2TransportControllerGroupName function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteTransportControllerGroupsV2TransportControllerGroupName === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing transportControllerGroupName', (done) => {
+        try {
+          a.deleteTransportControllerGroupsV2TransportControllerGroupName(null, (data, error) => {
+            try {
+              const displayE = 'transportControllerGroupName is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-deleteTransportControllerGroupsV2TransportControllerGroupName', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNetconfV2Profiles - errors', () => {
+      it('should have a getNetconfV2Profiles function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNetconfV2Profiles === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postNetconfV2Profiles - errors', () => {
+      it('should have a postNetconfV2Profiles function', (done) => {
+        try {
+          assert.equal(true, typeof a.postNetconfV2Profiles === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#putNetconfV2Profiles - errors', () => {
+      it('should have a putNetconfV2Profiles function', (done) => {
+        try {
+          assert.equal(true, typeof a.putNetconfV2Profiles === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteNetconfV2Profiles - errors', () => {
+      it('should have a deleteNetconfV2Profiles function', (done) => {
+        try {
+          assert.equal(true, typeof a.deleteNetconfV2Profiles === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#postNetconfV2CollectionLiveNetwork - errors', () => {
+      it('should have a postNetconfV2CollectionLiveNetwork function', (done) => {
+        try {
+          assert.equal(true, typeof a.postNetconfV2CollectionLiveNetwork === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getNetconfV2CollectionCollectionJobId - errors', () => {
+      it('should have a getNetconfV2CollectionCollectionJobId function', (done) => {
+        try {
+          assert.equal(true, typeof a.getNetconfV2CollectionCollectionJobId === 'function');
+          done();
+        } catch (error) {
+          log.error(`Test Failure: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+      it('should error if - missing collectionJobId', (done) => {
+        try {
+          a.getNetconfV2CollectionCollectionJobId(null, (data, error) => {
+            try {
+              const displayE = 'collectionJobId is required';
+              runErrorAsserts(data, error, 'AD.300', 'Test-paragon_pathfinder-adapter-getNetconfV2CollectionCollectionJobId', displayE);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
   });
 });