@itentialopensource/adapter-dna_center 0.9.0 → 0.9.2

package/test/integration/adapterTestIntegration.js

@@ -5510,5 +5510,1644 @@ describe('[integration] Dna_center Adapter Test', () => {
         }
       }).timeout(attemptTimeout);
     });
+
+    describe('#deletePortAssignmentForAccessPointInSDAFabric - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deletePortAssignmentForAccessPointInSDAFabric('fakedata', 'fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'deletePortAssignmentForAccessPointInSDAFabric', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getPortAssignmentForAccessPointInSDAFabric - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getPortAssignmentForAccessPointInSDAFabric('fakedata', 'fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'getPortAssignmentForAccessPointInSDAFabric', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const sDAAddPortAssignmentForAccessPointInSDAFabricBodyParam = {
+      siteNameHierarchy: 'string',
+      deviceManagementIpAddress: 'string',
+      interfaceName: 'string',
+      dataIpAddressPoolName: 'string',
+      authenticateTemplateName: 'Closed Authentication ',
+      interfaceDescription: 'string'
+    };
+    describe('#addPortAssignmentForAccessPointInSDAFabric - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addPortAssignmentForAccessPointInSDAFabric(sDAAddPortAssignmentForAccessPointInSDAFabricBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'addPortAssignmentForAccessPointInSDAFabric', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDeviceInfoFromSDAFabric - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getDeviceInfoFromSDAFabric('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'getDeviceInfoFromSDAFabric', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getTransitPeerNetworkInfo - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getTransitPeerNetworkInfo('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'getTransitPeerNetworkInfo', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const sDAAddTransitPeerNetworkBodyParam = {
+      transitPeerNetworkName: 'string',
+      transitPeerNetworkType: 'ip_transit',
+      ipTransitSettings: {
+        routingProtocolName: 'BGP',
+        autonomousSystemNumber: 'string'
+      },
+      sdaTransitSettings: {
+        transitControlPlaneSettings: [
+          {
+            siteNameHierarchy: 'string',
+            deviceManagementIpAddress: 'string'
+          }
+        ]
+      }
+    };
+    describe('#addTransitPeerNetwork - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addTransitPeerNetwork(sDAAddTransitPeerNetworkBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'addTransitPeerNetwork', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteTransitPeerNetwork - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteTransitPeerNetwork('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'deleteTransitPeerNetwork', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteEdgeDeviceFromSDAFabric - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteEdgeDeviceFromSDAFabric('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'deleteEdgeDeviceFromSDAFabric', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getEdgeDeviceFromSDAFabric - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getEdgeDeviceFromSDAFabric('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'getEdgeDeviceFromSDAFabric', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const sDAAddEdgeDeviceInSDAFabricBodyParam = {
+      deviceManagementIpAddress: 'string',
+      siteNameHierarchy: 'string'
+    };
+    describe('#addEdgeDeviceInSDAFabric - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addEdgeDeviceInSDAFabric(sDAAddEdgeDeviceInSDAFabricBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'addEdgeDeviceInSDAFabric', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const sDAAddIPPoolInSDAVirtualNetworkBodyParam = {
+      siteNameHierarchy: 'string',
+      virtualNetworkName: 'string',
+      isLayer2Only: true,
+      ipPoolName: 'string',
+      vlanId: 'string',
+      vlanName: 'string',
+      autoGenerateVlanName: true,
+      trafficType: 'Data',
+      scalableGroupName: 'string',
+      isL2FloodingEnabled: false,
+      isThisCriticalPool: true,
+      isWirelessPool: true,
+      isIpDirectedBroadcast: false,
+      isCommonPool: false,
+      isBridgeModeVm: false,
+      poolType: 'AP'
+    };
+    describe('#addIPPoolInSDAVirtualNetwork - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addIPPoolInSDAVirtualNetwork(sDAAddIPPoolInSDAVirtualNetworkBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'addIPPoolInSDAVirtualNetwork', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteIPPoolFromSDAVirtualNetwork - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteIPPoolFromSDAVirtualNetwork('fakedata', 'fakedata', 'fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'deleteIPPoolFromSDAVirtualNetwork', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getIPPoolFromSDAVirtualNetwork - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getIPPoolFromSDAVirtualNetwork('fakedata', 'fakedata', 'fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'getIPPoolFromSDAVirtualNetwork', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteMulticastFromSDAFabric - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteMulticastFromSDAFabric('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'deleteMulticastFromSDAFabric', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getMulticastDetailsFromSDAFabric - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getMulticastDetailsFromSDAFabric('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'getMulticastDetailsFromSDAFabric', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const sDAAddMulticastInSDAFabricBodyParam = {
+      siteNameHierarchy: 'string',
+      multicastMethod: 'native_multicast',
+      multicastType: 'ssm',
+      multicastVnInfo: [
+        {
+          virtualNetworkName: 'string',
+          ipPoolName: 'string',
+          internalRpIpAddress: [
+            'string'
+          ],
+          externalRpIpAddress: 'string',
+          ssmInfo: [
+            {
+              ssmGroupRange: 'string',
+              ssmWildcardMask: 'string'
+            }
+          ]
+        }
+      ]
+    };
+    describe('#addMulticastInSDAFabric - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addMulticastInSDAFabric(sDAAddMulticastInSDAFabricBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'addMulticastInSDAFabric', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getVirtualNetworkFromSDAFabric - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getVirtualNetworkFromSDAFabric('fakedata', 'fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'getVirtualNetworkFromSDAFabric', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const sDAAddVNInFabricBodyParam = {
+      virtualNetworkName: 'string',
+      siteNameHierarchy: 'string'
+    };
+    describe('#addVNInFabric - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addVNInFabric(sDAAddVNInFabricBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'addVNInFabric', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteVNFromSDAFabric - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteVNFromSDAFabric('fakedata', 'fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'deleteVNFromSDAFabric', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteDefaultAuthenticationProfileFromSDAFabric - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteDefaultAuthenticationProfileFromSDAFabric('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'deleteDefaultAuthenticationProfileFromSDAFabric', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const sDAUpdateDefaultAuthenticationProfileInSDAFabricBodyParam = [
+      {
+        siteNameHierarchy: 'string',
+        authenticateTemplateName: 'Closed Authentication',
+        authenticationOrder: 'mab',
+        dot1xToMabFallbackTimeout: 'string',
+        wakeOnLan: true,
+        numberOfHosts: 'Single'
+      }
+    ];
+    describe('#updateDefaultAuthenticationProfileInSDAFabric - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateDefaultAuthenticationProfileInSDAFabric(sDAUpdateDefaultAuthenticationProfileInSDAFabricBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'updateDefaultAuthenticationProfileInSDAFabric', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDefaultAuthenticationProfileFromSDAFabric - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getDefaultAuthenticationProfileFromSDAFabric('fakedata', null, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'getDefaultAuthenticationProfileFromSDAFabric', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const sDAAddDefaultAuthenticationTemplateInSDAFabricBodyParam = [
+      {
+        siteNameHierarchy: 'string',
+        authenticateTemplateName: 'Open Authentication'
+      }
+    ];
+    describe('#addDefaultAuthenticationTemplateInSDAFabric - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addDefaultAuthenticationTemplateInSDAFabric(sDAAddDefaultAuthenticationTemplateInSDAFabricBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'addDefaultAuthenticationTemplateInSDAFabric', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteSiteFromSDAFabric - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteSiteFromSDAFabric('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'deleteSiteFromSDAFabric', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getSiteFromSDAFabric - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getSiteFromSDAFabric('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'getSiteFromSDAFabric', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const sDAAddSiteInSDAFabricBodyParam = {
+      fabricName: 'string',
+      siteNameHierarchy: 'string',
+      fabricType: 'string'
+    };
+    describe('#addSiteInSDAFabric - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addSiteInSDAFabric(sDAAddSiteInSDAFabricBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'addSiteInSDAFabric', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const sDAReProvisionWiredDeviceBodyParam = {
+      deviceManagementIpAddress: 'string',
+      siteNameHierarchy: 'string'
+    };
+    describe('#reProvisionWiredDevice - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.reProvisionWiredDevice(sDAReProvisionWiredDeviceBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'reProvisionWiredDevice', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const sDAProvisionWiredDeviceBodyParam = {
+      deviceManagementIpAddress: 'string',
+      siteNameHierarchy: 'string'
+    };
+    describe('#provisionWiredDevice - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.provisionWiredDevice(sDAProvisionWiredDeviceBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'provisionWiredDevice', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getProvisionedWiredDevice - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getProvisionedWiredDevice('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'getProvisionedWiredDevice', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteProvisionedWiredDevice - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteProvisionedWiredDevice('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'deleteProvisionedWiredDevice', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getVirtualNetworkSummary - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getVirtualNetworkSummary('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'getVirtualNetworkSummary', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getDeviceRoleInSDAFabric - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getDeviceRoleInSDAFabric('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'getDeviceRoleInSDAFabric', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const sDAAddPortAssignmentForUserDeviceInSDAFabricBodyParam = {
+      siteNameHierarchy: 'string',
+      deviceManagementIpAddress: 'string',
+      interfaceName: 'string',
+      interfaceNames: [
+        'string'
+      ],
+      dataIpAddressPoolName: 'string',
+      voiceIpAddressPoolName: 'string',
+      authenticateTemplateName: 'Low Impact',
+      scalableGroupName: 'string',
+      interfaceDescription: 'string'
+    };
+    describe('#addPortAssignmentForUserDeviceInSDAFabric - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addPortAssignmentForUserDeviceInSDAFabric(sDAAddPortAssignmentForUserDeviceInSDAFabricBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'addPortAssignmentForUserDeviceInSDAFabric', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getPortAssignmentForUserDeviceInSDAFabric - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getPortAssignmentForUserDeviceInSDAFabric('fakedata', 'fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'getPortAssignmentForUserDeviceInSDAFabric', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deletePortAssignmentForUserDeviceInSDAFabric - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deletePortAssignmentForUserDeviceInSDAFabric('fakedata', 'fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'deletePortAssignmentForUserDeviceInSDAFabric', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getBorderDeviceDetailFromSDAFabric - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getBorderDeviceDetailFromSDAFabric('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'getBorderDeviceDetailFromSDAFabric', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const sDAAddBorderDeviceInSDAFabricBodyParam = [
+      {
+        deviceManagementIpAddress: 'string',
+        siteNameHierarchy: 'string',
+        deviceRole: [
+          'string'
+        ],
+        routeDistributionProtocol: 'string',
+        externalDomainRoutingProtocolName: 'BGP',
+        externalConnectivityIpPoolName: 'string',
+        internalAutonomouSystemNumber: 'string',
+        borderPriority: 'string',
+        borderSessionType: 'ANYWHERE',
+        connectedToInternet: true,
+        sdaTransitNetworkName: 'string',
+        borderWithExternalConnectivity: false,
+        externalConnectivitySettings: [
+          {
+            interfaceName: 'string',
+            interfaceDescription: 'string',
+            externalAutonomouSystemNumber: 'string',
+            l3Handoff: [
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              }
+            ],
+            l2Handoff: [
+              {
+                virtualNetworkName: 'string',
+                vlanName: 'string'
+              },
+              {
+                virtualNetworkName: 'string',
+                vlanName: 'string'
+              }
+            ]
+          },
+          {
+            interfaceName: 'string',
+            interfaceDescription: 'string',
+            externalAutonomouSystemNumber: 'string',
+            l3Handoff: [
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              }
+            ],
+            l2Handoff: [
+              {
+                virtualNetworkName: 'string',
+                vlanName: 'string'
+              },
+              {
+                virtualNetworkName: 'string',
+                vlanName: 'string'
+              },
+              {
+                virtualNetworkName: 'string',
+                vlanName: 'string'
+              },
+              {
+                virtualNetworkName: 'string',
+                vlanName: 'string'
+              },
+              {
+                virtualNetworkName: 'string',
+                vlanName: 'string'
+              },
+              {
+                virtualNetworkName: 'string',
+                vlanName: 'string'
+              },
+              {
+                virtualNetworkName: 'string',
+                vlanName: 'string'
+              },
+              {
+                virtualNetworkName: 'string',
+                vlanName: 'string'
+              }
+            ]
+          },
+          {
+            interfaceName: 'string',
+            interfaceDescription: 'string',
+            externalAutonomouSystemNumber: 'string',
+            l3Handoff: [
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              }
+            ],
+            l2Handoff: [
+              {
+                virtualNetworkName: 'string',
+                vlanName: 'string'
+              },
+              {
+                virtualNetworkName: 'string',
+                vlanName: 'string'
+              },
+              {
+                virtualNetworkName: 'string',
+                vlanName: 'string'
+              },
+              {
+                virtualNetworkName: 'string',
+                vlanName: 'string'
+              },
+              {
+                virtualNetworkName: 'string',
+                vlanName: 'string'
+              }
+            ]
+          },
+          {
+            interfaceName: 'string',
+            interfaceDescription: 'string',
+            externalAutonomouSystemNumber: 'string',
+            l3Handoff: [
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              }
+            ],
+            l2Handoff: [
+              {
+                virtualNetworkName: 'string',
+                vlanName: 'string'
+              }
+            ]
+          },
+          {
+            interfaceName: 'string',
+            interfaceDescription: 'string',
+            externalAutonomouSystemNumber: 'string',
+            l3Handoff: [
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              },
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              }
+            ],
+            l2Handoff: [
+              {
+                virtualNetworkName: 'string',
+                vlanName: 'string'
+              }
+            ]
+          },
+          {
+            interfaceName: 'string',
+            interfaceDescription: 'string',
+            externalAutonomouSystemNumber: 'string',
+            l3Handoff: [
+              {
+                virtualNetwork: {
+                  virtualNetworkName: 'string',
+                  vlanId: 'string'
+                }
+              }
+            ],
+            l2Handoff: [
+              {
+                virtualNetworkName: 'string',
+                vlanName: 'string'
+              }
+            ]
+          }
+        ]
+      }
+    ];
+    describe('#addBorderDeviceInSDAFabric - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addBorderDeviceInSDAFabric(sDAAddBorderDeviceInSDAFabricBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'addBorderDeviceInSDAFabric', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteBorderDeviceFromSDAFabric - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteBorderDeviceFromSDAFabric('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'deleteBorderDeviceFromSDAFabric', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getControlPlaneDeviceFromSDAFabric - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getControlPlaneDeviceFromSDAFabric('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'getControlPlaneDeviceFromSDAFabric', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const sDAAddControlPlaneDeviceInSDAFabricBodyParam = {
+      deviceManagementIpAddress: 'string',
+      siteNameHierarchy: 'string',
+      routeDistributionProtocol: 'string'
+    };
+    describe('#addControlPlaneDeviceInSDAFabric - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addControlPlaneDeviceInSDAFabric(sDAAddControlPlaneDeviceInSDAFabricBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'addControlPlaneDeviceInSDAFabric', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteControlPlaneDeviceInSDAFabric - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteControlPlaneDeviceInSDAFabric('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'deleteControlPlaneDeviceInSDAFabric', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const sDAUpdateVirtualNetworkWithScalableGroupsBodyParam = {
+      virtualNetworkName: 'string',
+      isGuestVirtualNetwork: false,
+      scalableGroupNames: [
+        'string'
+      ],
+      vManageVpnId: 'string'
+    };
+    describe('#updateVirtualNetworkWithScalableGroups - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.updateVirtualNetworkWithScalableGroups(sDAUpdateVirtualNetworkWithScalableGroupsBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'updateVirtualNetworkWithScalableGroups', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#deleteVirtualNetworkWithScalableGroups - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.deleteVirtualNetworkWithScalableGroups('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'deleteVirtualNetworkWithScalableGroups', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    describe('#getVirtualNetworkWithScalableGroups - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.getVirtualNetworkWithScalableGroups('fakedata', (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'getVirtualNetworkWithScalableGroups', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
+
+    const sDAAddVirtualNetworkWithScalableGroupsBodyParam = {
+      virtualNetworkName: 'string',
+      isGuestVirtualNetwork: false,
+      scalableGroupNames: [
+        'string'
+      ],
+      vManageVpnId: 'string'
+    };
+    describe('#addVirtualNetworkWithScalableGroups - errors', () => {
+      it('should work if integrated but since no mockdata should error when run standalone', (done) => {
+        try {
+          a.addVirtualNetworkWithScalableGroups(sDAAddVirtualNetworkWithScalableGroupsBodyParam, (data, error) => {
+            try {
+              if (stub) {
+                const displayE = 'Error 400 received on request';
+                runErrorAsserts(data, error, 'AD.500', 'Test-dna_center-connectorRest-handleEndResponse', displayE);
+              } else {
+                runCommonAsserts(data, error);
+              }
+              saveMockData('SDA', 'addVirtualNetworkWithScalableGroups', 'default', data);
+              done();
+            } catch (err) {
+              log.error(`Test Failure: ${err}`);
+              done(err);
+            }
+          });
+        } catch (error) {
+          log.error(`Adapter Exception: ${error}`);
+          done(error);
+        }
+      }).timeout(attemptTimeout);
+    });
   });
 });