cloudstack-issues mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "ASF GitHub Bot (JIRA)" <j...@apache.org>
Subject [jira] [Commented] (CLOUDSTACK-10303) refactor plugins/nuagevsp tests to run from its own test_data.py file
Date Wed, 14 Mar 2018 11:48:04 GMT

    [ https://issues.apache.org/jira/browse/CLOUDSTACK-10303?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=16398432#comment-16398432 ] 

ASF GitHub Bot commented on CLOUDSTACK-10303:
---------------------------------------------

rhtyd closed pull request #2483: CLOUDSTACK-10303 : test data to nuage_test_data.py + run all tests against simulator
URL: https://github.com/apache/cloudstack/pull/2483
 
 
   

This is a PR merged from a forked repository.
As GitHub hides the original diff on merge, it is displayed below for
the sake of provenance:

As this is a foreign pull request (from a fork), the diff is supplied
below (as it won't show otherwise due to GitHub magic):

diff --git a/engine/storage/src/org/apache/cloudstack/storage/endpoint/DefaultEndPointSelector.java b/engine/storage/src/org/apache/cloudstack/storage/endpoint/DefaultEndPointSelector.java
index 64d74d74d20..292ef432ff9 100644
--- a/engine/storage/src/org/apache/cloudstack/storage/endpoint/DefaultEndPointSelector.java
+++ b/engine/storage/src/org/apache/cloudstack/storage/endpoint/DefaultEndPointSelector.java
@@ -128,14 +128,14 @@ protected EndPoint findEndPointInScope(Scope scope, String sqlBase, Long poolId)
         String sql = sbuilder.toString();
         HostVO host = null;
         TransactionLegacy txn = TransactionLegacy.currentTxn();
-        try(PreparedStatement pstmt = txn.prepareStatement(sql);) {
+        try (PreparedStatement pstmt = txn.prepareStatement(sql)) {
             pstmt.setLong(1, poolId);
             try(ResultSet rs = pstmt.executeQuery();) {
                 while (rs.next()) {
                     long id = rs.getLong(1);
                     host = hostDao.findById(id);
                 }
-            }catch (SQLException e) {
+            } catch (SQLException e) {
                 s_logger.warn("can't find endpoint", e);
             }
         } catch (SQLException e) {
diff --git a/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockStorageManager.java b/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockStorageManager.java
index f60e13321ae..70066dcf7dd 100644
--- a/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockStorageManager.java
+++ b/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockStorageManager.java
@@ -33,6 +33,9 @@
 import com.cloud.agent.api.DeleteStoragePoolCommand;
 import com.cloud.agent.api.GetStorageStatsAnswer;
 import com.cloud.agent.api.GetStorageStatsCommand;
+import com.cloud.agent.api.GetVolumeStatsAnswer;
+import com.cloud.agent.api.GetVolumeStatsCommand;
+import com.cloud.agent.api.HandleConfigDriveIsoCommand;
 import com.cloud.agent.api.ManageSnapshotCommand;
 import com.cloud.agent.api.ModifyStoragePoolCommand;
 import com.cloud.agent.api.SecStorageSetupCommand;
@@ -77,6 +80,8 @@
 
     public Answer DownloadProcess(DownloadProgressCommand cmd);
 
+    GetVolumeStatsAnswer getVolumeStats(GetVolumeStatsCommand cmd);
+
     public GetStorageStatsAnswer GetStorageStats(GetStorageStatsCommand cmd);
 
     public Answer ManageSnapshot(ManageSnapshotCommand cmd);
@@ -107,4 +112,5 @@
 
     public UploadStatusAnswer getUploadStatus(UploadStatusCommand cmd);
 
+    Answer handleConfigDriveIso(HandleConfigDriveIsoCommand cmd);
 }
diff --git a/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockStorageManagerImpl.java b/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockStorageManagerImpl.java
index dba9059c213..de12f3b433f 100644
--- a/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockStorageManagerImpl.java
+++ b/plugins/hypervisors/simulator/src/com/cloud/agent/manager/MockStorageManagerImpl.java
@@ -26,6 +26,8 @@
 import java.util.List;
 import java.util.Map;
 import java.util.UUID;
+import java.util.function.Function;
+import java.util.stream.Collectors;
 
 import javax.inject.Inject;
 import javax.naming.ConfigurationException;
@@ -38,6 +40,7 @@
 import org.apache.cloudstack.storage.command.UploadStatusAnswer;
 import org.apache.cloudstack.storage.command.UploadStatusAnswer.UploadStatus;
 import org.apache.cloudstack.storage.command.UploadStatusCommand;
+import org.apache.cloudstack.storage.to.VolumeObjectTO;
 
 import com.cloud.agent.api.Answer;
 import com.cloud.agent.api.AttachIsoCommand;
@@ -52,6 +55,9 @@
 import com.cloud.agent.api.DeleteStoragePoolCommand;
 import com.cloud.agent.api.GetStorageStatsAnswer;
 import com.cloud.agent.api.GetStorageStatsCommand;
+import com.cloud.agent.api.GetVolumeStatsAnswer;
+import com.cloud.agent.api.GetVolumeStatsCommand;
+import com.cloud.agent.api.HandleConfigDriveIsoCommand;
 import com.cloud.agent.api.ManageSnapshotAnswer;
 import com.cloud.agent.api.ManageSnapshotCommand;
 import com.cloud.agent.api.ModifyStoragePoolAnswer;
@@ -60,6 +66,7 @@
 import com.cloud.agent.api.SecStorageSetupCommand;
 import com.cloud.agent.api.SecStorageVMSetupCommand;
 import com.cloud.agent.api.StoragePoolInfo;
+import com.cloud.agent.api.VolumeStatsEntry;
 import com.cloud.agent.api.storage.CopyVolumeAnswer;
 import com.cloud.agent.api.storage.CopyVolumeCommand;
 import com.cloud.agent.api.storage.CreateAnswer;
@@ -578,6 +585,37 @@ public DownloadAnswer DownloadProcess(DownloadProgressCommand cmd) {
         }
     }
 
+    @Override
+    public GetVolumeStatsAnswer getVolumeStats(final GetVolumeStatsCommand cmd) {
+        HashMap<String, VolumeStatsEntry> volumeStats =
+                cmd.getVolumeUuids()
+                .stream()
+                .collect(Collectors.toMap(Function.identity(),
+                                          this::getVolumeStat,
+                                          (v1, v2) -> v1, HashMap::new));
+
+        return new GetVolumeStatsAnswer(cmd, "", volumeStats);
+    }
+
+    private VolumeStatsEntry getVolumeStat(final String volumeUuid)  {
+        TransactionLegacy txn = TransactionLegacy.open(TransactionLegacy.SIMULATOR_DB);
+
+        try {
+            txn.start();
+            MockVolumeVO volume  = _mockVolumeDao.findByUuid(volumeUuid);
+            txn.commit();
+            return new VolumeStatsEntry(volumeUuid, volume.getSize(), volume.getSize());
+        } catch (Exception ex) {
+            txn.rollback();
+            throw new CloudRuntimeException("Error when finding volume " + volumeUuid, ex);
+        } finally {
+            txn.close();
+            txn = TransactionLegacy.open(TransactionLegacy.CLOUD_DB);
+            txn.close();
+        }
+
+    }
+
     @Override
     public GetStorageStatsAnswer GetStorageStats(GetStorageStatsCommand cmd) {
         String uuid = cmd.getStorageId();
@@ -786,9 +824,13 @@ public Answer Delete(DeleteCommand cmd) {
             txn.start();
             MockVolumeVO template = _mockVolumeDao.findByStoragePathAndType(cmd.getData().getPath());
             if (template == null) {
-                return new Answer(cmd, false, "can't find object to delete:" + cmd.getData().getPath());
+                if(!((VolumeObjectTO)cmd.getData()).getName().startsWith("ROOT-")) {
+                    return new Answer(cmd, false, "can't find object to delete:" + cmd.getData()
+                                                                                      .getPath());
+                }
+            } else {
+                _mockVolumeDao.remove(template.getId());
             }
-            _mockVolumeDao.remove(template.getId());
             txn.commit();
         } catch (Exception ex) {
             txn.rollback();
@@ -1228,4 +1270,49 @@ public CopyVolumeAnswer CopyVolume(CopyVolumeCommand cmd) {
     public UploadStatusAnswer getUploadStatus(UploadStatusCommand cmd) {
         return new UploadStatusAnswer(cmd, UploadStatus.COMPLETED);
     }
+
+    @Override public Answer handleConfigDriveIso(HandleConfigDriveIsoCommand cmd) {
+        TransactionLegacy txn = TransactionLegacy.open(TransactionLegacy.SIMULATOR_DB);
+        MockSecStorageVO sec;
+        try {
+            txn.start();
+            sec = _mockSecStorageDao.findByUrl(cmd.getDestStore().getUrl());
+            if (sec == null) {
+                return new Answer(cmd, false, "can't find secondary storage");
+            }
+
+            txn.commit();
+        } catch (Exception ex) {
+            txn.rollback();
+            throw new CloudRuntimeException("Error when creating config drive.");
+        } finally {
+            txn.close();
+            txn = TransactionLegacy.open(TransactionLegacy.CLOUD_DB);
+            txn.close();
+        }
+
+        MockVolumeVO template = new MockVolumeVO();
+        String uuid = UUID.randomUUID().toString();
+        template.setName(uuid);
+        template.setPath(sec.getMountPoint() + cmd.getIsoFile());
+        template.setPoolId(sec.getId());
+        template.setSize((long)(Math.random() * 200L) + 200L);
+        template.setStatus(Status.DOWNLOADED);
+        template.setType(MockVolumeType.ISO);
+        txn = TransactionLegacy.open(TransactionLegacy.SIMULATOR_DB);
+        try {
+            txn.start();
+            template = _mockVolumeDao.persist(template);
+            txn.commit();
+        } catch (Exception ex) {
+            txn.rollback();
+            throw new CloudRuntimeException("Encountered " + ex.getMessage() + " when persisting config drive " + template.getName(), ex);
+        } finally {
+            txn.close();
+            txn = TransactionLegacy.open(TransactionLegacy.CLOUD_DB);
+            txn.close();
+        }
+
+        return new Answer(cmd);
+    }
 }
diff --git a/plugins/hypervisors/simulator/src/com/cloud/agent/manager/SimulatorManagerImpl.java b/plugins/hypervisors/simulator/src/com/cloud/agent/manager/SimulatorManagerImpl.java
index 38c2a8e004b..729777312fb 100644
--- a/plugins/hypervisors/simulator/src/com/cloud/agent/manager/SimulatorManagerImpl.java
+++ b/plugins/hypervisors/simulator/src/com/cloud/agent/manager/SimulatorManagerImpl.java
@@ -64,6 +64,8 @@
 import com.cloud.agent.api.GetStorageStatsCommand;
 import com.cloud.agent.api.GetVmStatsCommand;
 import com.cloud.agent.api.GetVncPortCommand;
+import com.cloud.agent.api.GetVolumeStatsCommand;
+import com.cloud.agent.api.HandleConfigDriveIsoCommand;
 import com.cloud.agent.api.MaintainCommand;
 import com.cloud.agent.api.ManageSnapshotCommand;
 import com.cloud.agent.api.MigrateCommand;
@@ -206,6 +208,7 @@ public MockAgentManager getAgentMgr() {
     @DB
     @Override
     public Answer simulate(final Command cmd, final String hostGuid) {
+        s_logger.debug("Simulate command " + cmd);
         Answer answer = null;
         Exception exception = null;
         TransactionLegacy txn = TransactionLegacy.open(TransactionLegacy.SIMULATOR_DB);
@@ -363,6 +366,8 @@ public Answer simulate(final Command cmd, final String hostGuid) {
                     answer = _mockStorageMgr.Download((DownloadCommand)cmd);
                 } else if (cmd instanceof GetStorageStatsCommand) {
                     answer = _mockStorageMgr.GetStorageStats((GetStorageStatsCommand)cmd);
+                } else if (cmd instanceof GetVolumeStatsCommand) {
+                    answer = _mockStorageMgr.getVolumeStats((GetVolumeStatsCommand)cmd);
                 } else if (cmd instanceof ManageSnapshotCommand) {
                     answer = _mockStorageMgr.ManageSnapshot((ManageSnapshotCommand)cmd);
                 } else if (cmd instanceof BackupSnapshotCommand) {
@@ -431,8 +436,14 @@ public Answer simulate(final Command cmd, final String hostGuid) {
                     answer = storageHandler.handleStorageCommands((StorageSubSystemCommand)cmd);
                 } else if (cmd instanceof FenceCommand) {
                     answer = _mockVmMgr.fence((FenceCommand)cmd);
-                } else if (cmd instanceof GetRouterAlertsCommand || cmd instanceof VpnUsersCfgCommand || cmd instanceof RemoteAccessVpnCfgCommand || cmd instanceof SetMonitorServiceCommand || cmd instanceof AggregationControlCommand ||
-                        cmd instanceof SecStorageFirewallCfgCommand) {
+                } else if (cmd instanceof HandleConfigDriveIsoCommand) {
+                    answer = _mockStorageMgr.handleConfigDriveIso((HandleConfigDriveIsoCommand)cmd);
+                } else if (cmd instanceof GetRouterAlertsCommand
+                        || cmd instanceof VpnUsersCfgCommand
+                        || cmd instanceof RemoteAccessVpnCfgCommand
+                        || cmd instanceof SetMonitorServiceCommand
+                        || cmd instanceof AggregationControlCommand
+                        || cmd instanceof SecStorageFirewallCfgCommand) {
                     answer = new Answer(cmd);
                 } else {
                     s_logger.error("Simulator does not implement command of type " + cmd.toString());
@@ -447,6 +458,8 @@ public Answer simulate(final Command cmd, final String hostGuid) {
                 }
             }
 
+            s_logger.debug("Finished simulate command " + cmd);
+
             return answer;
         } catch (final Exception e) {
             s_logger.error("Failed execute cmd: ", e);
diff --git a/plugins/hypervisors/simulator/src/com/cloud/resource/SimulatorStorageProcessor.java b/plugins/hypervisors/simulator/src/com/cloud/resource/SimulatorStorageProcessor.java
old mode 100755
new mode 100644
index 30cad8f0a66..c2dfdbd4e56
--- a/plugins/hypervisors/simulator/src/com/cloud/resource/SimulatorStorageProcessor.java
+++ b/plugins/hypervisors/simulator/src/com/cloud/resource/SimulatorStorageProcessor.java
@@ -85,7 +85,7 @@ public Answer handleDownloadTemplateToPrimaryStorage(DirectDownloadCommand cmd)
     public Answer copyTemplateToPrimaryStorage(CopyCommand cmd) {
         TemplateObjectTO template = new TemplateObjectTO();
         template.setPath(UUID.randomUUID().toString());
-        template.setSize(new Long(100));
+        template.setSize(100L);
         template.setFormat(Storage.ImageFormat.RAW);
         return new CopyCmdAnswer(template);
     }
diff --git a/server/src/com/cloud/network/element/ConfigDriveNetworkElement.java b/server/src/com/cloud/network/element/ConfigDriveNetworkElement.java
index 8c0f5009874..37a30ef6010 100644
--- a/server/src/com/cloud/network/element/ConfigDriveNetworkElement.java
+++ b/server/src/com/cloud/network/element/ConfigDriveNetworkElement.java
@@ -118,9 +118,9 @@
     @Inject
     VolumeOrchestrationService _volumeMgr;
 
-    public final static String CONFIGDRIVEFILENAME = "configdrive.iso";
-    public final static String CONFIGDRIVEDIR= "ConfigDrive";
-    public final static Integer CONFIGDRIVEDISKSEQ= new Integer(4);
+    private final static String CONFIGDRIVEFILENAME = "configdrive.iso";
+    private final static String CONFIGDRIVEDIR = "ConfigDrive";
+    private final static Integer CONFIGDRIVEDISKSEQ = 4;
 
     private boolean canHandle(TrafficType trafficType) {
         return trafficType.equals(TrafficType.Guest);
@@ -320,9 +320,10 @@ private boolean updateConfigDriveIso(Network network, VirtualMachineProfile prof
         s_logger.debug(String.format("%s config drive ISO for  vm %s in host %s",
                 (update?"update":"create"), profile.getInstanceName(), _hostDao.findById(hostId).getName()));
         EndPoint endpoint = _ep.select(secondaryStore);
-        if (endpoint == null )
-            throw new ResourceUnavailableException(String.format("%s failed, secondary store not available",
-                    (update?"Update":"Create")),secondaryStore.getClass(),secondaryStore.getId());
+        if (endpoint == null) {
+            throw new ResourceUnavailableException(String.format("%s failed, secondary store not available", (update ? "Update" : "Create")), secondaryStore.getClass(),
+                                                   secondaryStore.getId());
+        }
         String isoPath = CONFIGDRIVEDIR + "/" + profile.getInstanceName() + "/"  + CONFIGDRIVEFILENAME;
         HandleConfigDriveIsoCommand configDriveIsoCommand = new HandleConfigDriveIsoCommand(profile.getVmData(),
                 profile.getConfigDriveLabel(), secondaryStore.getTO(), isoPath, true, update);
diff --git a/test/integration/plugins/nuagevsp/libVSD/__init__.py b/test/integration/plugins/nuagevsp/libVSD/__init__.py
new file mode 100644
index 00000000000..3377d9cc4ce
--- /dev/null
+++ b/test/integration/plugins/nuagevsp/libVSD/__init__.py
@@ -0,0 +1,22 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+from .client import ApiClient
+from .helpers import VSDHelpers
+
+__version__ = "1.0"
+__all__ = ['ApiClient', 'VSDHelpers']
diff --git a/test/integration/plugins/nuagevsp/libVSD/client.py b/test/integration/plugins/nuagevsp/libVSD/client.py
new file mode 100644
index 00000000000..38ab6f0802b
--- /dev/null
+++ b/test/integration/plugins/nuagevsp/libVSD/client.py
@@ -0,0 +1,135 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+import bambou
+import importlib
+
+
+class ApiClient(object):
+    """
+    This class provides utilities to instantiate an API client using vspk.
+    Args:
+        address (str): ip address or hostname where the VSD API is exposed.
+        user (str): username to authenticate on the API.
+        password (str): password to authenticate on the API.
+        enterprise (str): VSD organization to use to authenticate on the API.
+        version (str): version of the API to use.
+    """
+
+    def __init__(self, address, port='8443', user='csproot',
+                 password='csproot', enterprise='csp', version=None):
+        if not version:
+            version = '5.0'
+        self.url = 'https://{}:{}'.format(address, port)
+        self.version = version
+        self.user = user
+        self.password = password
+        self.enterprise = enterprise
+        self.last_pushes = []
+        self.session = None
+
+    @staticmethod
+    def import_vspk(version):
+        """
+        Return the vspk module corresponding to a given version of the API.
+        Args:
+            version (str): version of the API
+        """
+        version = 'v{}'.format(str(version).replace('.', '_'))
+        try:
+            vsdk = importlib.import_module('vspk.%s' % version)
+        except:
+            vsdk = importlib.import_module('vspk.vsdk.%s' % version)
+        return vsdk
+
+    def import_vsdenvs(self):
+        """
+        Return the root class a `vsdenvs`.
+        """
+        if not self.session:
+            raise Exception('You must have an active session to use vsdenvs')
+        self.vsdenvs = __import__('vsdenvs', globals(), locals(), [], -1)
+        self.vsdenvs.NUCsprootEnvironment.instance = self.session.user
+
+    def new_session(self):
+        """
+        Start a new API session via vspk an return the corresponding
+        `vspk.NUVSDSession` object. Note that this object is also exposed as
+        `self.session`
+        """
+        vspk = self.import_vspk(self.version)
+        self.session = vspk.NUVSDSession(
+            username=self.user,
+            password=self.password,
+            enterprise=self.enterprise,
+            api_url=self.url)
+        self.session.start()
+        return self.session
+
+    def start_push_center(self, callback=None):
+        """
+        Add a vspk push center to the current session.
+        """
+        if not callback:
+            callback = self.default_callback
+        self.session.push_center.add_delegate(callback)
+        self.session.push_center.start()
+
+    def stop_push_center(self, callback=None):
+        """
+        Stop the vpsk push center for the current session.
+        """
+        self.session.push_center.stop()
+
+    def default_callback(self, data):
+        """
+        Default callback for the push center. It just stores the new event in
+        a LILO queue exposed as `self.last_pushe`
+        """
+        self.last_pushes.append(data)
+        # keep only the last 10 events
+        if len(self.last_pushes) == 100:
+            del self.last_pushes[-1]
+
+    def __call__(self):
+        if not self.session:
+            return self.new_session()
+        return self.session
+
+    def add_license(self):
+        """
+        Add a license to the VSD
+        """
+        vspk = self.import_vspk(self.version)
+        self.session.license = vspk.NULicense(license=self.license)
+        try:
+            self.session.user.create_child(self.session.license)
+        except bambou.exceptions.BambouHTTPError:
+            pass
+        else:
+            self.session.user.add_child(self.session.license)
+
+    def delete_license(self):
+        """
+        Delete license on the VSD
+        """
+        self.session.user.licenses.fetch()
+        for license in self.session.user.licenses:
+            try:
+                license.delete()
+            except bambou.exceptions.BambouHTTPError:
+                pass
diff --git a/test/integration/plugins/nuagevsp/libVSD/helpers.py b/test/integration/plugins/nuagevsp/libVSD/helpers.py
new file mode 100644
index 00000000000..cdc0e639d66
--- /dev/null
+++ b/test/integration/plugins/nuagevsp/libVSD/helpers.py
@@ -0,0 +1,602 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+import logging
+import functools
+import bambou
+
+LOG = logging.getLogger()
+
+
+class recreate_session_on_timeout(object):
+    def __init__(self, method):
+        self.method = method
+
+    def __get__(self, obj=None, objtype=None):
+        @functools.wraps(self.method)
+        def _wrapper(*args, **kwargs):
+            try:
+                return self.method(obj, *args, **kwargs)
+            except bambou.exceptions.BambouHTTPError as e:
+                if e.connection.response.status_code == 401:
+                    obj.session = obj.api_client.new_session()
+                    return self.method(obj, *args, **kwargs)
+                else:
+                    raise e
+
+        return _wrapper
+
+
+class VSDHelpers(object):
+
+    def __init__(self, api_client):
+        """
+        Create a wrapper
+        provide a cspsession and a vpsk object, all from the VSD object
+        """
+        self.api_client = api_client
+        self.session = api_client.session
+        self.vspk = api_client.import_vspk(api_client.version)
+
+    def update_vsd_session(self, api_client=None):
+        """
+        This method is used when Helper is
+        initialized before we create a new_session.
+        """
+        if api_client:
+            self.session = api_client.session
+            self.vspk = api_client.import_vspk(api_client.version)
+        else:
+            self.session = self.api_client.session
+
+    @recreate_session_on_timeout
+    def add_user_to_group(self, enterprise, user=None, group=None,
+                          usr_filter=None, grp_filter=None):
+        """
+        Add user to a group on VSD.
+        For example: Add csproot to cms group
+        Here you can couple of things:
+        1. enterprise can be id or NURest Object
+        2. And User group both need to be NURest object
+           or both can be filters.
+        """
+        if not isinstance(enterprise, self.vspk.NUEnterprise):
+            enterprise = self.vspk.NUEnterprise(id=enterprise)
+        if isinstance(group, self.vspk.NUGroup):
+            if isinstance(user, self.vspk.NUUser):
+                all_users = group.users.get()
+                all_users.append(user)
+                group.assign(all_users, self.vspk.NUUser)
+        elif usr_filter and grp_filter:
+            group = enterprise.groups.get_first(filter=grp_filter)
+            all_users = group.users.get()
+            user = enterprise.users.get_first(filter=usr_filter)
+            if not group:
+                LOG.error('could not fetch the group matching the filter "{}"'
+                          .format(grp_filter))
+                return
+            if not user:
+                LOG.error('could not fetch the user matching the filter "{}"'
+                          .format(usr_filter))
+                return
+            all_users.append(user)
+            group.assign(all_users, self.vspk.NUUser)
+
+    def set_name_filter(self, name):
+        """ set name filter for vsd query
+            @param: name:  string name
+            @return:  filter string
+        """
+        return 'name is "{}"'.format(name)
+
+    def set_externalID_filter(self, id):
+        """ set externalID filter for vsd query
+            @param: id:  string externalID
+            @return:  filter string
+        """
+        return 'externalID is "{}"'.format(id)
+
+    @recreate_session_on_timeout
+    def get_enterprise(self, filter):
+        """ get_enterprise
+            @params: enterprise filter following vspk filter structure
+            @return: enterprise object
+            @Example:
+            self.vsd.get_enterprise(
+                filter='externalID == "{}"'.format(ext_id))
+        """
+        if not filter:
+            LOG.error('a filter is required')
+            return None
+        enterprise = self.session.user.enterprises.get_first(filter=filter)
+        if not enterprise:
+            LOG.error('could not fetch the enterprise matching the filter "{}"'
+                      .format(filter))
+        return enterprise
+
+    @recreate_session_on_timeout
+    def get_l2domain(self, enterprise=None, filter=None):
+        """ get_l2domain
+            @params: enterprise object or enterprise id
+                     filter following vspk filter structure
+            @return  l2 domain object
+            @Example:
+            self.vsd.get_l2domain(enterprise=enterprise,
+                                filter='name == "{}"'.format(name))
+            self.vsd.get_l2domain(enterprise=enterprise_id,
+                               filter='name == "{}"'.format(name))
+            self.vsd.get_l2domain(filter='externalID == "{}"'.format(ext_id))
+        """
+        l2_domain = None
+        if enterprise:
+            if not isinstance(enterprise, self.vspk.NUEnterprise):
+                enterprise = self.vspk.NUEnterprise(id=enterprise)
+            l2_domain = enterprise.l2_domains.get_first(filter=filter)
+        elif filter:
+            l2_domain = self.session.user.l2_domains.get_first(filter=filter)
+        if not l2_domain:
+            LOG.error('could not fetch the l2 domain matching the filter "{}"'
+                      .format(filter))
+        return l2_domain
+
+    @recreate_session_on_timeout
+    def get_domain(self, enterprise=None, filter=None):
+        """ get_domain
+            @params: enterprise object or enterprise id
+                     filter following vspk filter structure
+            @return: domain object
+            @Example:
+            self.vsd.get_domain(enterprise=enterprise,
+                                filter='name == "{}"'.format(name))
+            self.vsd.get_domain(enterprise=enterprise_id,
+                               filter='name == "{}"'.format(name))
+            self.vsd.get_domain(filter='externalID == "{}"'.format(ext_id))
+        """
+        domain = None
+        if enterprise:
+            if not isinstance(enterprise, self.vspk.NUEnterprise):
+                enterprise = self.vspk.NUEnterprise(id=enterprise)
+            domain = enterprise.domains.get_first(filter=filter)
+        elif filter:
+            domain = self.session.user.domains.get_first(filter=filter)
+        if not domain:
+            LOG.error('could not fetch the domain matching the filter "{}"'
+                      .format(filter))
+        return domain
+
+    @recreate_session_on_timeout
+    def get_domain_template(self, enterprise=None, filter=None):
+        """ get_domain
+            @params: enterprise object or enterprise id
+                     filter following vspk filter structure
+            @return: domain object
+            @Example:
+            self.vsd.get_domain(enterprise=enterprise,
+                                filter='name == "{}"'.format(name))
+            self.vsd.get_domain(enterprise=enterprise_id,
+                               filter='name == "{}"'.format(name))
+            self.vsd.get_domain(filter='externalID == "{}"'.format(ext_id))
+        """
+        domain = None
+        if enterprise:
+            if not isinstance(enterprise, self.vspk.NUEnterprise):
+                enterprise = self.vspk.NUEnterprise(id=enterprise)
+            domain = enterprise.domain_templates.get_first(filter=filter)
+        elif filter:
+            domain = \
+                self.session.user.domain_templates.get_first(filter=filter)
+        if not domain:
+            LOG.error('could not fetch the domain template '
+                      'matching the filter "{}"'
+                      .format(filter))
+        return domain
+
+    @recreate_session_on_timeout
+    def get_zone(self, domain=None, filter=None):
+        """ get_zone
+            @params: domain object or domain id
+                     filter following vspk filter structure
+            @return: zone object
+            @Example:
+            self.vsd.get_zone(domain=domain,
+                                filter='name == "{}"'.format(name))
+            self.vsd.get_zone(domain=domain_id,
+                               filter='name == "{}"'.format(name))
+            self.vsd.get_zone(filter='externalID == "{}"'.format(ext_id))
+        """
+        zone = None
+        if domain:
+            if not isinstance(domain, self.vspk.NUDomain):
+                domain = self.vspk.NUDomain(id=domain)
+            zone = domain.zones.get_first(filter=filter)
+        elif filter:
+            zone = self.session.user.zones.get_first(filter=filter)
+        if not zone:
+            LOG.error('could not fetch the zone matching the filter "{}"'
+                      .format(filter))
+        return zone
+
+    @recreate_session_on_timeout
+    def get_subnet(self, zone=None, filter=None):
+        """ get_subnet
+            @params: zone object or zone id
+                     filter following vspk filter structure
+            @return: subnet object
+            @Example:
+            self.vsd.get_subnet(zone=zone,
+                                filter='name == "{}"'.format(name))
+            self.vsd.get_subnet(zone=zone_id,
+                               filter='name == "{}"'.format(name))
+            self.vsd.get_subnet(filter='externalID == "{}"'.format(ext_id))
+        """
+        subnet = None
+        if zone:
+            if not isinstance(zone, self.vspk.NUZone):
+                zone = self.vspk.NUZone(id=zone)
+            subnet = zone.subnets.get_first(filter=filter)
+        elif filter:
+            subnet = self.session.user.subnets.get_first(filter=filter)
+        if not subnet:
+            LOG.error('could not fetch the subnet matching the filter "{}"'
+                      .format(filter))
+        return subnet
+
+    @recreate_session_on_timeout
+    def get_subnet_from_domain(self, domain=None, filter=None):
+        """ get_subnet
+            @params: domain object or domain id
+                     filter following vspk filter structure
+            @return: subnet object
+            @Example:
+            self.vsd.get_subnet(domain=domain,
+                                filter='name == "{}"'.format(name))
+            self.vsd.get_subnet(domain=domain_id,
+                               filter='name == "{}"'.format(name))
+            self.vsd.get_subnet(filter='externalID == "{}"'.format(ext_id))
+        """
+        subnet = None
+        if domain:
+            if not isinstance(domain, self.vspk.NUDomain):
+                domain = self.vspk.NUDomain(id=domain)
+            subnet = domain.subnets.get_first(filter=filter)
+        elif filter:
+            subnet = self.session.user.subnets.get_first(filter=filter)
+        if not subnet:
+            LOG.error('could not fetch the subnet matching the filter "{}"'
+                      .format(filter))
+        return subnet
+
+    @recreate_session_on_timeout
+    def get_vm(self, subnet=None, filter=None):
+        """ get_vm
+            @params: subnet object or subnet id
+                     filter following vspk filter structure
+            @return: vm object
+            @Example:
+            self.vsd.get_vm(subnet=subnet,
+                                filter='name == "{}"'.format(name))
+            self.vsd.get_vm(subnet=subnet_id,
+                               filter='name == "{}"'.format(name))
+            self.vsd.get_vm(filter='externalID == "{}"'.format(ext_id))
+        """
+        vm = None
+        if subnet:
+            if not isinstance(subnet, self.vspk.NUSubnet):
+                subnet = self.vspk.NUSubnet(id=subnet)
+            vm = subnet.vms.get_first(filter=filter)
+        elif filter:
+            vm = self.session.user.vms.get_first(filter=filter)
+        if not vm:
+            LOG.error('could not fetch the vm matching the filter "{}"'
+                      .format(filter))
+        return vm
+
+    @recreate_session_on_timeout
+    def get_subnet_dhcpoptions(self, subnet=None, filter=None):
+        """ get_subnet_dhcpoptions
+            @params: subnet object or
+                     subnet filter following vspk filter structure
+            @return: subnet dhcpoptions object
+            @Example:
+            self.vsd.get_subnet_dhcpoptions(subnet=subnet)
+            self.vsd.get_subnet_dhcpoptions(
+                filter='externalID == "{}"'.format(subnet_externalID))
+        """
+        if not isinstance(subnet, self.vspk.NUSubnet):
+            if not filter:
+                LOG.error('a filter is required')
+                return None
+            subnet = self.session.user.subnets.get_first(filter=filter)
+        dhcp_options = subnet.dhcp_options.get()
+        if not dhcp_options:
+            if filter:
+                LOG.error('could not fetch the dhcp options on the subnet '
+                          'matching the filter "{}"'
+                          .format(filter))
+            else:
+                LOG.error('could not fetch the dhcp options on the subnet')
+        return dhcp_options
+
+    @recreate_session_on_timeout
+    def get_vport(self, subnet, filter):
+        """ get_vport
+            @params: subnet object
+                     vport filter following vspk filter structure
+            @return: vport object
+            @Example:
+            self.vsd.get_vport(subnet=subnet,
+                filter='externalID == "{}"'.format(ext_id))
+        """
+        if not isinstance(subnet, self.vspk.NUSubnet):
+            LOG.error('a subnet is required')
+            return None
+        if not filter:
+            LOG.error('a filter is required')
+            return None
+        vport = subnet.vports.get_first(filter=filter)
+        if not vport:
+            LOG.error('could not fetch the vport from the subnet '
+                      'matching the filter "{}"'
+                      .format(filter))
+        return vport
+
+    @recreate_session_on_timeout
+    def get_vm_interface(self, filter):
+        """ get_vm_interface
+            @params: vm interface filter following vspk filter structure
+            @return: vm interface object
+            @Example:
+            self.vsd.get_vm_interface(
+                filter='externalID == "{}"'.format(ext_id))
+        """
+        if not filter:
+            LOG.error('a filter is required')
+            return None
+        vm_interface = self.session.user.vm_interfaces.get_first(filter=filter)
+        if not vm_interface:
+            LOG.error('could not fetch the vm interface '
+                      'matching the filter "{}"'
+                      .format(filter))
+        return vm_interface
+
+    @recreate_session_on_timeout
+    def get_vm_interface_policydecisions(self, vm_interface=None, filter=None):
+        """ get_vm_interface_policydecisions
+            @params: vm interface object or
+                     vm interface filter following vspk filter structure
+            @return: vm interface policydecisions object
+            @Example:
+            self.vsd.get_vm_interface_policydecisions(vm_interface=interface)
+            self.vsd.get_vm_interface_policydecisions(
+                filter='externalID == "{}"'.format(vm_interface_externalID))
+        """
+        if not isinstance(vm_interface, self.vspk.NUVMInterface):
+            if not filter:
+                LOG.error('a filter is required')
+                return None
+            vm_interface = \
+                self.session.user.vm_interfaces.get_first(filter=filter)
+        policy_decisions = self.vspk.NUPolicyDecision(
+            id=vm_interface.policy_decision_id).fetch()
+        if not policy_decisions:
+            if filter:
+                LOG.error('could not fetch the policy decisions on the '
+                          'vm interface matching the filter "{}"'
+                          .format(filter))
+            else:
+                LOG.error('could not fetch the policy decisions '
+                          'on the vm interface')
+        return policy_decisions
+
+    @recreate_session_on_timeout
+    def get_vm_interface_dhcpoptions(self, vm_interface=None, filter=None):
+        """ get_vm_interface_dhcpoptions
+            @params: vm interface object or
+                     vm interface filter following vspk filter structure
+            @return: vm interface dhcpoptions object
+            @Example:
+            self.vsd.get_vm_interface_dhcpoptions(vm_interface=vm_interface)
+            self.vsd.get_vm_interface_dhcpoptions(
+                filter='externalID == "{}"'.format(vm_interface_externalID))
+        """
+        if not isinstance(vm_interface, self.vspk.NUVMInterface):
+            if not filter:
+                LOG.error('a filter is required')
+                return None
+            vm_interface = self.session.user.vm_interfaces.get_first(
+                    filter=filter)
+        dhcp_options = vm_interface.dhcp_options.get()
+        if not dhcp_options:
+            if filter:
+                LOG.error('could not fetch the dhcp options on the '
+                          'vm interface matching the filter "{}"'
+                          .format(filter))
+            else:
+                LOG.error('could not fetch the dhcp options on the '
+                          'vm interface')
+        return dhcp_options
+
+    @recreate_session_on_timeout
+    def get_ingress_acl_entry(self, filter):
+        """ get_ingress_acl_entry
+            @params: ingress acl entry filter following vspk filter structure
+            @return: ingress acl entry object
+            @Example:
+            self.vsd.get_ingress_acl_entry(
+                filter='externalID == "{}"'.format(ext_id))
+        """
+        if not filter:
+            LOG.error('a filter is required')
+            return None
+        acl = self.session.user.ingress_acl_entry_templates.get_first(
+                filter=filter)
+        if not acl:
+            LOG.error('could not fetch the ingress acl entry '
+                      'matching the filter "{}"'
+                      .format(filter))
+        return acl
+
+    @recreate_session_on_timeout
+    def get_egress_acl_entry(self, filter):
+        """ get_egress_acl_entry
+            @params: egress acl entry filter following vspk filter structure
+            @return: egress acl entry object
+            @Example:
+            self.vsd.get_egress_acl_entry(
+                filter='externalID == "{}"'.format(ext_id))
+        """
+        if not filter:
+            LOG.error('a filter is required')
+            return None
+        acl = self.session.user.egress_acl_entry_templates.get_first(
+                filter=filter)
+        if not acl:
+            LOG.error('could not fetch the egress acl entry '
+                      'matching the filter "{}"'
+                      .format(filter))
+        return acl
+
+    @recreate_session_on_timeout
+    def get_qoss(self, vport):
+        """ get_qoss
+            @params: vport object
+            @return: qoss object
+            @Example:
+            self.vsd.get_qoss(vport=vport)
+        """
+        if not isinstance(vport, self.vspk.NUVPort):
+            LOG.error('a vport is required')
+            return None
+        qoss = vport.qoss.get()
+        if not qoss:
+            LOG.error('could not fetch the qoss from the vport')
+        return qoss
+
+    @recreate_session_on_timeout
+    def get_floating_ip(self, filter):
+        """ get_floating_ip
+            @params: floating ip filter following vspk filter structure
+            @return: floating ip object
+            @Example:
+            self.vsd.get_floating_ip(
+                filter='externalID == "{}"'.format(ext_id))
+        """
+        if not filter:
+            LOG.error('a filter is required')
+            return None
+        floating_ip = self.session.user.floating_ips.get_first(filter=filter)
+        if not floating_ip:
+            LOG.error('could not fetch the floating ip '
+                      'matching the filter "{}"'
+                      .format(filter))
+        return floating_ip
+
+    @recreate_session_on_timeout
+    def get_ingress_acl_entries(self, filter):
+        """ get_ingress_acl_entries
+            @params: ingress acl entries (templates) filter following vspk
+                     filter structure
+            @return: ingress acl entries (objects) list
+            @Example:
+            self.vsd.get_ingress_acl_entries(
+                filter='externalID == "{}"'.format(ext_id))
+        """
+        if not filter:
+            LOG.error('a filter is required')
+            return None
+        templates = self.session.user.ingress_acl_templates.get(filter=filter)
+        if not templates:
+            LOG.error('could not fetch the ingress acl entries (templates) '
+                      'matching the filter "{}"'
+                      .format(filter))
+            return None
+        acls = []
+        for template in templates:
+            tmp = self.vspk.NUIngressACLTemplate(id=template.id)
+            acl = tmp.ingress_acl_entry_templates.get()
+            acls.append(acl)
+        return acls
+
+    @recreate_session_on_timeout
+    def get_egress_acl_entries(self, filter):
+        """ get_egress_acl_entries
+            @params: egress acl entries (templates) filter
+                     following vspk filter structure
+            @return: egress acl entries (objects) list
+            @Example:
+            self.vsd.get_egress_acl_entries(
+                filter='externalID == "{}"'.format(ext_id))
+        """
+        if not filter:
+            LOG.error('a filter is required')
+            return None
+        templates = self.session.user.egress_acl_templates.get(filter=filter)
+        if not templates:
+            LOG.error('could not fetch the egress acl entries (templates) '
+                      'matching the filter "{}"'
+                      .format(filter))
+            return None
+        acls = []
+        for template in templates:
+            tmp = self.vspk.NUEgressACLTemplate(id=template.id)
+            acl = tmp.egress_acl_entry_templates.get()
+            acls.append(acl)
+        return acls
+
+    @recreate_session_on_timeout
+    def get_shared_network_resource(self, filter):
+        """ get_shared_network_resource
+            @params: shared network resource filter
+                    following vspk filter structure
+            @return: shared network resource object
+            @Example:
+            self.vsd.get_shared_network_resource(
+                filter='externalID == "{}"'.format(ext_id))
+        """
+        if not filter:
+            LOG.error('a filter is required')
+            return None
+        shared_network_resource = \
+            self.session.user.shared_network_resources.get_first(filter=filter)
+        if not shared_network_resource:
+            LOG.error('could not fetch the shared network resource '
+                      'matching the filter "{}"'
+                      .format(filter))
+        return shared_network_resource
+
+    @recreate_session_on_timeout
+    def get_virtualip(self, vport, filter):
+        """ get_virtualip
+            @params: vport object
+                     virtualip filter following vspk filter structure
+            @return: virtualip object
+            @Example:
+            self.vsd.get_virtualip(vport=vport,
+                filter='externalID == "{}"'.format(ext_id))
+        """
+        if not isinstance(vport, self.vspk.NUVPort):
+            LOG.error('a vport is required')
+            return None
+        if not filter:
+            LOG.error('a filter is required')
+            return None
+        virtualip = vport.virtual_ips.get_first(filter=filter)
+
+        if not virtualip:
+            LOG.error('could not fetch the virtualip matching the filter "{}"'
+                      .format(filter))
+        return virtualip
diff --git a/test/integration/plugins/nuagevsp/nuageTestCase.py b/test/integration/plugins/nuagevsp/nuageTestCase.py
index 5300e6efa29..7e6468b77dd 100644
--- a/test/integration/plugins/nuagevsp/nuageTestCase.py
+++ b/test/integration/plugins/nuagevsp/nuageTestCase.py
@@ -48,6 +48,10 @@
                                   enableNuageUnderlayVlanIpRange,
                                   disableNuageUnderlayVlanIpRange,
                                   listNuageUnderlayVlanIpRanges)
+
+from nuage_test_data import nuage_test_data
+from nuage_vsp_statistics import VsdDataCollector
+
 # Import System Modules
 from retry import retry
 import importlib
@@ -56,10 +60,12 @@
 import socket
 import time
 import sys
-from nuage_vsp_statistics import VsdDataCollector
 
 
 class needscleanup(object):
+    """
+    Decorator to add the returned object automatically to the cleanup list.
+    """
     def __init__(self, method):
         self.method = method
 
@@ -84,6 +90,9 @@ def _wrapper(*args, **kwargs):
 
 
 class gherkin(object):
+    """Decorator to mark a method as Gherkin style.
+       Add extra colored logging
+    """
     BLACK = "\033[0;30m"
     BLUE = "\033[0;34m"
     GREEN = "\033[0;32m"
@@ -127,6 +136,7 @@ def setUpClass(cls):
         cls.api_client = cls.test_client.getApiClient()
         cls.db_client = cls.test_client.getDbConnection()
         cls.test_data = cls.test_client.getParsedTestDataConfig()
+        cls.test_data.update(nuage_test_data)
 
         # Get Zones and Domains
         cls.zones = Zone.list(cls.api_client)
@@ -150,7 +160,7 @@ def setUpClass(cls):
 
     @classmethod
     def getZoneDetails(cls, zone=None):
-        # Get Zone details
+        """Get Zone details"""
         cls.zone = zone if zone else get_zone(
             cls.api_client,
             zone_name=cls.test_client.getZoneForTests()
@@ -275,12 +285,13 @@ def configureVSDSessions(cls):
         log_handler.setFormatter(formatter)
         root.addHandler(log_handler)
         vsd_info = cls.nuage_vsp_device.__dict__
+
         cls.debug("Nuage VSP device (VSD) details - %s" % vsd_info)
         vsd_api_client = ApiClient(
-            address=vsd_info["hostname"],
-            user=vsd_info["username"],
-            password=vsd_info["password"],
-            version=vsd_info["apiversion"][1] + "." + vsd_info["apiversion"][3]
+            address=cls.nuage_vsp_device.hostname,
+            user=cls.nuage_vsp_device.username,
+            password=cls.nuage_vsp_device.password,
+            version=cls.nuage_vsp_device.apiversion[1] + "." + cls.nuage_vsp_device.apiversion[3]
         )
         vsd_api_client.new_session()
         cls.vsd = VSDHelpers(vsd_api_client)
@@ -293,7 +304,7 @@ def setUp(self):
     @classmethod
     def tearDownClass(cls):
         # Cleanup resources used
-        cls.debug("Cleaning up the resources")
+        cls.debug("Cleaning up the class resources")
         for obj in reversed(cls._cleanup):
             try:
                 if isinstance(obj, VirtualMachine):
@@ -304,12 +315,12 @@ def tearDownClass(cls):
                 cls.error("Failed to cleanup %s, got %s" % (obj, e))
         # cleanup_resources(cls.api_client, cls._cleanup)
         cls._cleanup = []
-        cls.debug("Cleanup complete!")
+        cls.debug("Cleanup class complete!")
         return
 
     def tearDown(self):
         # Cleanup resources used
-        self.debug("Cleaning up the resources")
+        self.debug("Cleaning up the test resources")
         for obj in reversed(self.cleanup):
             try:
                 if isinstance(obj, VirtualMachine):
@@ -322,20 +333,28 @@ def tearDown(self):
                 self.error("Failed to cleanup %s, got %s" % (obj, e))
         # cleanup_resources(self.api_client, self.cleanup)
         self.cleanup = []
-        self.debug("Cleanup complete!")
+        self.debug("Cleanup test complete!")
         return
 
-    # enable_NuageUnderlayPublicIpRange - Enables/configures underlay
-    # networking for the given public IP range in Nuage VSP
     def enable_NuageUnderlayPublicIpRange(self, vlanid):
+        """Enables/configures underlay networking
+           for the given public IP range in Nuage VSP
+
+        :param vlanid: Vlan ID
+        :type vlanid: marvin.lib.base.PublicIpRange.vlan
+        """
         cmd = enableNuageUnderlayVlanIpRange. \
             enableNuageUnderlayVlanIpRangeCmd()
         cmd.id = vlanid
         self.api_client.enableNuageUnderlayVlanIpRange(cmd)
 
-    # disable_NuageUnderlayPublicIpRange - Disables/de-configures underlay
-    # networking for the given public IP range in Nuage VSP
     def disable_NuageUnderlayPublicIpRange(self, public_ip_range):
+        """Disables underlay networking
+           for the given public IP range in Nuage VSP
+
+        :param public_ip_range: Public IP range
+        :type public_ip_range: marvin.lib.base.PublicIpRange
+        """
         cmd = disableNuageUnderlayVlanIpRange. \
             disableNuageUnderlayVlanIpRangeCmd()
         cmd.id = public_ip_range.vlan.id
@@ -344,6 +363,11 @@ def disable_NuageUnderlayPublicIpRange(self, public_ip_range):
     # list_NuageUnderlayPublicIpRanges - Lists underlay networking
     # enabled/configured public IP ranges in Nuage VSP
     def list_NuageUnderlayPublicIpRanges(self, public_ip_range=None):
+        """Lists Vlan IP ranges that have the nuage underlay flag set to True
+
+        :param public_ip_range: Optionally filter by Public IP range
+        :type public_ip_range: marvin.lib.base.PublicIpRange
+        """
         cmd = listNuageUnderlayVlanIpRanges.listNuageUnderlayVlanIpRangesCmd()
         if public_ip_range:
             cmd.id = public_ip_range.vlan.id
@@ -353,6 +377,7 @@ def list_NuageUnderlayPublicIpRanges(self, public_ip_range=None):
     # create_VpcOffering - Creates VPC offering
     @needscleanup
     def create_VpcOffering(cls, vpc_offering, suffix=None):
+        """Creates VPC offering"""
         cls.debug("Creating VPC offering")
         if suffix:
             vpc_offering["name"] = "VPC_OFF-" + str(suffix)
@@ -368,6 +393,16 @@ def create_VpcOffering(cls, vpc_offering, suffix=None):
     @needscleanup
     def create_Vpc(cls, vpc_offering, cidr='10.1.0.0/16', testdata=None,
                    account=None, networkDomain=None):
+        """Creates VPC with the given VPC offering
+        :param vpc_offering: vpc offering
+        :type vpc_offering: VpcOffering
+        :param cidr: CIDR
+        :param testdata: vpc details
+        :param account: Account which will be the owner.
+        :param networkDomain:
+        :return: created VPC
+        :rtype: VPC
+        """
         if not account:
             account = cls.account
         cls.debug("Creating a VPC in the account - %s" % account.name)
@@ -389,6 +424,12 @@ def create_Vpc(cls, vpc_offering, cidr='10.1.0.0/16', testdata=None,
 
     # restart_Vpc - Restarts the given VPC with/without cleanup
     def restart_Vpc(self, vpc, cleanup=False):
+        """Restarts the given VPC with/without cleanup
+        :param vpc: vpc to restart
+        :type vpc: VPC
+        :param cleanup: whether to restart with cleanup
+        :type cleanup: bool
+        """
         self.debug("Restarting VPC with ID - %s" % vpc.id)
         cmd = restartVPC.restartVPCCmd()
         cmd.id = vpc.id
@@ -401,6 +442,14 @@ def restart_Vpc(self, vpc, cleanup=False):
     @needscleanup
     def create_NetworkOffering(cls, net_offering, suffix=None,
                                conserve_mode=False):
+        """Creates a Network Offering
+        :param net_offering: offering details
+        :type net_offering: object
+        :param suffix: string to append to the offering name
+        :param conserve_mode:
+        :return: created Network Offering
+        :rtype: NetworkOffering
+        """
         cls.debug("Creating Network offering")
         if suffix:
             net_offering["name"] = "NET_OFF-" + str(suffix)
@@ -418,6 +467,23 @@ def create_NetworkOffering(cls, net_offering, suffix=None,
     def create_Network(cls, nw_off, gateway="10.1.1.1",
                        netmask="255.255.255.0", vpc=None, acl_list=None,
                        testdata=None, account=None, vlan=None, externalid=None):
+        """Creates Network with the given Network offering
+        :param nw_off: Network offering
+        :type nw_off: NetworkOffering
+        :param gateway: gateway
+        :param netmask: netmask
+        :param vpc: in case of a VPC tier, the parent VPC
+        :type vpc: VPC
+        :param acl_list: in case of a VPC tier, the acl list
+        :type acl_list: NetworkACLList
+        :param testdata: Network details
+        :param account: Account which will be the owner.
+        :param vlan: vlan id
+        :param externalid: external id, in case of VSD managed networks
+
+        :return: created Network
+        :rtype: Network
+        """
         if not account:
             account = cls.account
         cls.debug("Creating a network in the account - %s" % account.name)
@@ -669,6 +735,10 @@ def create_NetworkAclRule(self, rule, traffic_type="Ingress", network=None,
 
     # ssh_into_VM - Gets into the shell of the given VM using its public IP
     def ssh_into_VM(self, vm, public_ip, reconnect=True, negative_test=False):
+        if self.isSimulator:
+            self.debug("Simulator Environment: Skipping ssh into VM")
+            return
+
         self.debug("SSH into VM with ID - %s on public IP address - %s" %
                    (vm.id, public_ip.ipaddress.ipaddress))
         tries = 1 if negative_test else 3
@@ -687,8 +757,15 @@ def retry_ssh():
 
         return retry_ssh()
 
-    # execute_cmd - Executes the given command on the given ssh client
     def execute_cmd(self, ssh_client, cmd):
+        """Executes the given command on the given ssh client
+
+        :param ssh_client: SSH session to the remote machine
+        :type ssh_client: marvin.SshClient
+        :param cmd: Command to run on the remote machine
+        :type cmd: str
+        :return: command output
+        """
         self.debug("SSH client executing command - %s" % cmd)
         ret_data = ""
         out_list = ssh_client.execute(cmd)
@@ -699,10 +776,18 @@ def execute_cmd(self, ssh_client, cmd):
             self.debug("SSH client executed command result is None")
         return ret_data
 
-    # wget_from_server - Fetches file with the given file name from a web
-    # server listening on the given public IP address and port
+
     def wget_from_server(self, public_ip, port=80, file_name="index.html",
                          disable_system_proxies=True):
+        """Fetches file with the given file name from a web server
+
+        :param public_ip: HTTP server IP
+        :type public_ip: PublicIPAddress
+        :param port: HTTP server port
+        :param file_name: URL path
+        :param disable_system_proxies: whether to bypass system proxy
+        :return: filename, headers
+        """
         import urllib
         if disable_system_proxies:
             urllib.getproxies = lambda: {}
@@ -719,12 +804,15 @@ def wget_from_server(self, public_ip, port=80, file_name="index.html",
                    (file_name, public_ip.ipaddress.ipaddress, port))
         return filename, headers
 
-    # validate_NetworkServiceProvider - Validates the given Network Service
-    # Provider in the Nuage VSP Physical Network, matches the given provider
-    # name and state against the list of providers fetched
     def validate_NetworkServiceProvider(self, provider_name, state=None):
         """Validates the Network Service Provider in the Nuage VSP Physical
-        Network"""
+        Network.
+
+        :param provider_name Provider name
+        :param state Expected state
+        :raises AssertionError when provider isn't found,
+            or has an incorrect state.
+        """
         self.debug("Validating the creation and state of Network Service "
                    "Provider - %s" % provider_name)
         providers = NetworkServiceProvider.list(
@@ -748,11 +836,19 @@ def validate_NetworkServiceProvider(self, provider_name, state=None):
         self.debug("Successfully validated the creation and state of Network "
                    "Service Provider - %s" % provider_name)
 
-    # validate_VpcOffering - Validates the given VPC offering, matches the
-    # given VPC offering name and state against the list of VPC offerings
-    # fetched
     def validate_VpcOffering(self, vpc_offering, state=None):
-        """Validates the VPC offering"""
+        """Validates the VPC offering
+
+        Fetches the Vpc offering by id,
+        verifies that the name is correct,
+        and if en expected state is given, verifies that it is correct.
+
+        :param vpc_offering: cs object
+        :type vpc_offering: VpcOffering
+        :param state: optional state
+        :raise AssertionError when VPC offering isn't found,
+            or has an incorrect state.
+        """
         self.debug("Validating the creation and state of VPC offering - %s" %
                    vpc_offering.name)
         vpc_offs = VpcOffering.list(self.api_client,
@@ -772,10 +868,18 @@ def validate_VpcOffering(self, vpc_offering, state=None):
         self.debug("Successfully validated the creation and state of VPC "
                    "offering - %s" % vpc_offering.name)
 
-    # validate_Vpc - Validates the given VPC, matches the given VPC name and
-    # state against the list of VPCs fetched
     def validate_Vpc(self, vpc, state=None):
-        """Validates the VPC"""
+        """Validates the VPC
+
+        Fetches the vpc by id,
+        verifies that the name is correct,
+        and if en expected state is given, verifies that it is correct.
+
+        :param vpc: cs object
+        :type vpc: Vpc
+        :param state: optional state
+        :raise AssertionError when vpc isn't found,
+            or has an incorrect state."""
         self.debug("Validating the creation and state of VPC - %s" % vpc.name)
         vpcs = VPC.list(self.api_client,
                         id=vpc.id
@@ -794,11 +898,19 @@ def validate_Vpc(self, vpc, state=None):
         self.debug("Successfully validated the creation and state of VPC - %s"
                    % vpc.name)
 
-    # validate_NetworkOffering - Validates the given Network offering, matches
-    # the given network offering name and state against the list of network
-    # offerings fetched
     def validate_NetworkOffering(self, net_offering, state=None):
-        """Validates the Network offering"""
+        """Validates the Network offering
+
+        Fetches the Network offering by id,
+        verifies that the name is correct,
+        and if en expected state is given, verifies that it is correct.
+
+        :param net_offering: cs object
+        :type net_offering: NetworkOffering
+        :param state: optional state
+        :raise AssertionError when network offering isn't found,
+            or has an incorrect state."""
+
         self.debug("Validating the creation and state of Network offering - %s"
                    % net_offering.name)
         net_offs = NetworkOffering.list(self.api_client,
@@ -818,10 +930,18 @@ def validate_NetworkOffering(self, net_offering, state=None):
         self.debug("Successfully validated the creation and state of Network "
                    "offering - %s" % net_offering.name)
 
-    # validate_Network - Validates the given network, matches the given network
-    # name and state against the list of networks fetched
     def validate_Network(self, network, state=None):
-        """Validates the network"""
+        """Validates the network
+
+        Fetches the Network by id,
+        verifies that the name is correct,
+        and if en expected state is given, verifies that it is correct.
+
+        :param network: cs object
+        :type network: Network
+        :param state: optional state
+        :raise AssertionError when network isn't found,
+            or has an incorrect state."""
         self.debug("Validating the creation and state of Network - %s" %
                    network.name)
         networks = Network.list(self.api_client,
@@ -841,10 +961,14 @@ def validate_Network(self, network, state=None):
         self.debug("Successfully validated the creation and state of Network "
                    "- %s" % network.name)
 
-    # check_VM_state - Checks if the given VM is in the expected state form the
-    # list of fetched VMs
     def check_VM_state(self, vm, state=None):
-        """Validates the VM state"""
+        """Validates the VM state
+            :param vm: cs object
+            :type vm: VirtualMachine
+            :param state: optional state
+            :raise AssertionError when vm isn't found,
+                or has an incorrect state."""
+
         self.debug("Validating the deployment and state of VM - %s" % vm.name)
         vms = VirtualMachine.list(self.api_client,
                                   id=vm.id,
@@ -860,10 +984,14 @@ def check_VM_state(self, vm, state=None):
         self.debug("Successfully validated the deployment and state of VM - %s"
                    % vm.name)
 
-    # check_Router_state - Checks if the given router is in the expected state
-    # form the list of fetched routers
     def check_Router_state(self, router, state=None):
-        """Validates the Router state"""
+        """Validates the Router state
+            :param router: cs object
+            :type router: Router
+            :param state: optional state
+            :raise AssertionError when router isn't found,
+                or has an incorrect state."""
+
         self.debug("Validating the deployment and state of Router - %s" %
                    router.name)
         routers = Router.list(self.api_client,
@@ -880,11 +1008,20 @@ def check_Router_state(self, router, state=None):
         self.debug("Successfully validated the deployment and state of Router "
                    "- %s" % router.name)
 
-    # validate_PublicIPAddress - Validates if the given public IP address is in
-    # the expected state form the list of fetched public IP addresses
     def validate_PublicIPAddress(self, public_ip, network, static_nat=False,
                                  vm=None):
-        """Validates the Public IP Address"""
+        """Validates the Public IP Address
+            :param public_ip: cs object
+            :type public_ip: PublicIPAddress
+            :param network: cs object
+            :type network: Network
+            :param static_nat: optional state
+            :type static_nat: bool
+            :param vm: Virtual machine the public ip should be forwarding to.
+            :type vm: VirtualMachine
+            :raise AssertionError when Public IP isn't found, isn't Allocated
+                or has an incorrect ip address."""
+
         self.debug("Validating the assignment and state of public IP address "
                    "- %s" % public_ip.ipaddress.ipaddress)
         public_ips = PublicIPAddress.list(self.api_client,
@@ -913,10 +1050,14 @@ def validate_PublicIPAddress(self, public_ip, network, static_nat=False,
         self.debug("Successfully validated the assignment and state of public "
                    "IP address - %s" % public_ip.ipaddress.ipaddress)
 
-    # verify_VRWithoutPublicIPNIC - Verifies that the given Virtual Router has
-    # no public IP and NIC
     def verify_VRWithoutPublicIPNIC(self, vr):
-        """Verifies VR without Public IP and NIC"""
+        """Verifies that the given Virtual Router has no public IP nor NIC
+            :param vr: cs object
+            :type vr: Router
+            :raise AssertionError when router isn't found,
+                has an incorrect name, has a public ip for source nat
+                or has a nic in the public network."""
+
         self.debug("Verifies that there is no public IP and NIC in Virtual "
                    "Router - %s" % vr.name)
         self.assertEqual(vr.publicip, None,
@@ -930,6 +1071,11 @@ def verify_VRWithoutPublicIPNIC(self, vr):
                    "in Virtual Router - %s" % vr.name)
 
     def verify_vpc_has_no_src_nat(self, vpc, account=None):
+        """Verifies that the given Vpc has no public IP nor NIC
+            :param vpc: cs object
+            :type vpc: VPC
+            :raise AssertionError when the VPC has a public ip for source nat.
+        """
         if not account:
             account = self.account
         self.debug("Verify that there is no src NAT ip address "
@@ -944,9 +1090,14 @@ def verify_vpc_has_no_src_nat(self, vpc, account=None):
     # VSD verifications; VSD is a programmable policy and analytics engine of
     # Nuage VSP SDN platform
 
-    # get_externalID_filter - Returns corresponding external ID filter of the
-    # given object in VSD
     def get_externalID_filter(self, object_id):
+        """Builds a VSD filter to search by external ID
+
+        :param object_id: Cloudstack UUID
+        :type object_id: str
+        :rtype: str
+        :return: filter
+        """
         ext_id = object_id + "@" + self.cms_id
         return self.vsd.set_externalID_filter(ext_id)
 
@@ -963,24 +1114,45 @@ def fetch_by_externalID(self, fetcher, *cs_objects):
         :param cs_objects: Cloudstack objects to take the UUID from.
         :return: the VSPK object having the correct externalID
         """
-        return fetcher.get_first(filter="externalID BEGINSWITH '%s'" %
-                                        ":".join([o.id for o in cs_objects]))
+        object_id = ":".join([o.id for o in cs_objects])
+        ext_id = object_id + "@" + self.cms_id
+        return fetcher.get_first(filter="externalID is '%s'" % ext_id)
 
-    # verify_vsd_network - Verifies the given CloudStack domain and network/VPC
-    # against the corresponding installed enterprise, domain, zone, and subnet
-    # in VSD
-    def verify_vsd_network(self, domain_id, network, vpc=None,
-                           domain_template_name=None):
-        self.debug("Verifying the creation and state of Network - %s in VSD" %
-                   network.name)
+    def fetch_vsd_objects(self, domain_id, network, vpc=None):
         vsd_enterprise = self.vsd.get_enterprise(
             filter=self.get_externalID_filter(domain_id))
+
         ext_network_filter = self.get_externalID_filter(vpc.id) if vpc \
             else self.get_externalID_filter(network.id)
         vsd_domain = self.vsd.get_domain(filter=ext_network_filter)
         vsd_zone = self.vsd.get_zone(filter=ext_network_filter)
         vsd_subnet = self.vsd.get_subnet(
             filter=self.get_externalID_filter(network.id))
+
+        return [
+            ext_network_filter,
+            vsd_enterprise,
+            vsd_domain,
+            vsd_zone,
+            vsd_subnet
+        ]
+
+    # verify_vsd_network - Verifies the given CloudStack domain and network/VPC
+    # against the corresponding installed enterprise, domain, zone, and subnet
+    # in VSD
+    def verify_vsd_network(self, domain_id, network, vpc=None,
+                           domain_template_name=None):
+        self.debug("Verifying the creation and state of Network - %s in VSD" %
+                   network.name)
+
+        [
+            ext_network_filter,
+            vsd_enterprise,
+            vsd_domain,
+            vsd_zone,
+            vsd_subnet
+        ] = self.fetch_vsd_objects(domain_id, network, vpc)
+
         self.assertEqual(vsd_enterprise.name, domain_id,
                          "VSD enterprise name should match CloudStack domain "
                          "uuid"
@@ -1039,14 +1211,23 @@ def verify_vsd_network_not_present(self, network, vpc=None):
             filter=self.get_externalID_filter(network.id))
         self.assertEqual(vsd_subnet, None, "Network is present on the vsd.")
 
-    # get_subnet_id - Calculates and returns the subnet ID in VSD with the
-    # given CloudStack network ID and subnet gateway
     def get_subnet_id(self, network_id, gateway):
+        """ Calculates the subnet ID in VSD with
+            the given CloudStack network ID and subnet gateway
+
+            :param gateway: Gateway
+            :type gateway: str
+            :type network_id: str
+            :rtype: str
+            :return: Expected Subnet UUID
+
+        """
         try:
             import uuid
 
             class NULL_NAMESPACE:
                 bytes = b''
+
             # The UUID of the shared network in ACS
             # The gateway IP of the address range
             network_id = str(network_id)
@@ -1059,11 +1240,12 @@ class NULL_NAMESPACE:
             self.debug("Failed to get the subnet id due to %s" % e)
             self.fail("Unable to get the subnet id, failing the test case")
 
-    # verify_vsd_shared_network - Verifies the given CloudStack domain and
-    # shared network against the corresponding installed enterprise, domain,
-    # zone, subnet, and shared network resource in VSD
+
     def verify_vsd_shared_network(self, domain_id, network,
                                   gateway="10.1.1.1"):
+        """Verifies the given CloudStack domain and
+            shared network against the corresponding installed enterprise,
+            domain, zone, subnet, and shared network resource in VSD"""
         self.debug("Verifying the creation and state of Shared Network - %s "
                    "in VSD" % network.name)
         vsd_enterprise = self.vsd.get_enterprise(
@@ -1074,6 +1256,7 @@ def verify_vsd_shared_network(self, domain_id, network,
         subnet_id = self.get_subnet_id(network.id, gateway)
         vsd_subnet = self.vsd.get_subnet(
             filter=self.get_externalID_filter(subnet_id))
+
         self.assertNotEqual(vsd_enterprise, None,
                             "VSD enterprise (CloudStack domain) data format "
                             "should not be of type None"
@@ -1099,9 +1282,13 @@ def verify_vsd_shared_network(self, domain_id, network,
         self.debug("Successfully verified the creation and state of Shared "
                    "Network - %s in VSD" % network.name)
 
-    # verify_vsd_object_status - Verifies the given CloudStack object status in
-    # VSD
     def verify_vsd_object_status(self, cs_object, stopped):
+        """ Verifies the VM status in VSD for a given Cloudstack VM,
+        retrying every 5 seconds for 10 minutes.
+
+        :param cs_object: Cloudstack VM
+        :param stopped: boolean: specifying if the vm is stopped.
+        """
         vsd_object = self.vsd.get_vm(
             filter=self.get_externalID_filter(cs_object.id))
         expected_status = cs_object.state.upper() if not stopped \
@@ -1280,6 +1467,7 @@ def verify_vsd_floating_ip(self, network, vm, public_ipaddress, vpc=None):
             public_ipaddress.vlanid)
         vsd_fip_subnet = self.vsd.get_shared_network_resource(
             filter=ext_fip_subnet_filter)
+
         if self.isNuageInfraUnderlay:
             self.assertEqual(vsd_fip_subnet.underlay, True,
                              "Floating IP subnet in VSD should be underlay "
@@ -1290,6 +1478,7 @@ def verify_vsd_floating_ip(self, network, vm, public_ipaddress, vpc=None):
                              "Floating IP subnet in VSD should be underlay "
                              "disabled"
                              )
+
         ext_network_filter = self.get_externalID_filter(vpc.id) if vpc \
             else self.get_externalID_filter(network.id)
         vsd_domain = self.vsd.get_domain(filter=ext_network_filter)
diff --git a/test/integration/plugins/nuagevsp/nuage_test_data.py b/test/integration/plugins/nuagevsp/nuage_test_data.py
index 691e10360b6..d3b87d283fa 100644
--- a/test/integration/plugins/nuagevsp/nuage_test_data.py
+++ b/test/integration/plugins/nuagevsp/nuage_test_data.py
@@ -15,829 +15,7 @@
 # specific language governing permissions and limitations
 # under the License.
 
-test_data = {
-    "region": {
-        "regionid": "2",
-        "regionname": "Region2",
-        "regionendpoint": "http://region2:8080/client"
-    },
-    "zone": "NA",
-    "hypervisor": "XenServer",
-    "deleteDC": True,
-    "vdomain": {
-        "name": "domain"
-    },
-    "domain": {"name": "domain"},
-    "email": "test@test.com",
-    "gateway": "172.1.1.1",
-    "netmask": "255.255.255.0",
-    "startip": "172.1.1.10",
-    "endip": "172.1.1.20",
-    "regionid": "1",
-    "vlan": "10",
-    "isportable": "true",
-
-    "project": {
-        "name": "Project",
-        "displaytext": "Test project"
-    },
-    "publiciprange": {
-        "gateway": "",
-        "netmask": "",
-        "startip": "",
-        "endip": "",
-        "forvirtualnetwork": "true",
-        "vlan": "",
-        "zoneid": ""
-    },
-    "private_gateway": {
-        "ipaddress": "172.16.1.2",
-        "gateway": "172.16.1.1",
-        "netmask": "255.255.255.0",
-        "vlan": "10",
-        "name": "test_private_gateway"
-    },
-    "account": {
-        "email": "test-account@test.com",
-        "firstname": "test",
-        "lastname": "test",
-        "username": "test-account",
-        "password": "password"
-    },
-    "account2": {
-        "email": "test-account2@test.com",
-        "firstname": "test2",
-        "lastname": "test2",
-        "username": "test-account2",
-        "password": "password"
-    },
-    "small": {
-        "displayname": "testserver",
-        "username": "root",
-        "password": "password",
-        "ssh_port": 22,
-        "hypervisor": "XenServer",
-        "privateport": 22,
-        "publicport": 22,
-        "protocol": 'TCP',
-    },
-    "service_offering": {
-        "name": "Tiny Instance",
-        "displaytext": "Tiny Instance",
-        "cpunumber": 1,
-        "cpuspeed": 256,  # in MHz
-        "memory": 256,  # In MBs
-    },
-    "service_offerings": {
-        "tiny": {
-            "name": "Tiny Instance",
-            "displaytext": "Tiny Instance",
-            "cpunumber": 1,
-            "cpuspeed": 100,
-            "memory": 128,
-        },
-        "small": {
-            "name": "Small Instance",
-            "displaytext": "Small Instance",
-            "cpunumber": 1,
-            "cpuspeed": 100,
-            "memory": 256
-        },
-        "medium": {
-            "name": "Medium Instance",
-            "displaytext": "Medium Instance",
-            "cpunumber": 1,
-            "cpuspeed": 100,
-            "memory": 256,
-        },
-        "big": {
-            "name": "BigInstance",
-            "displaytext": "BigInstance",
-            "cpunumber": 1,
-            "cpuspeed": 100,
-            "memory": 512,
-        },
-        "large": {
-            "name": "LargeInstance",
-            "displaytext": "LargeInstance",
-            "cpunumber": 1,
-            "cpuspeed": 1024,
-            "memory": 2048,
-        },
-        "hasmall": {
-            "name": "HA Small Instance",
-            "displaytext": "HA Small Instance",
-            "cpunumber": 1,
-            "cpuspeed": 100,
-            "memory": 256,
-            "hosttags": "ha",
-            "offerha": True,
-        },
-        "taggedsmall": {
-            "name": "Tagged Small Instance",
-            "displaytext": "Tagged Small Instance",
-            "cpunumber": 1,
-            "cpuspeed": 100,
-            "memory": 256,
-            "hosttags": "vmsync",
-        },
-    },
-    "service_offering_h1": {
-        "name": "Tagged h1 Small Instance",
-        "displaytext": "Tagged h1 Small Instance",
-        "cpunumber": 1,
-        "cpuspeed": 100,
-        "memory": 256,
-        "hosttags": "h1"
-    },
-    "service_offering_h2": {
-        "name": "Tagged h2 Small Instance",
-        "displaytext": "Tagged h2 Small Instance",
-        "cpunumber": 1,
-        "cpuspeed": 100,
-        "memory": 256,
-        "hosttags": "h2"
-    },
-    "disk_offering": {
-        "name": "Disk offering",
-        "displaytext": "Disk offering",
-        "disksize": 1
-    },
-    'resized_disk_offering': {
-        "displaytext": "Resized",
-        "name": "Resized",
-        "disksize": 3
-    },
-    'disk_offering_shared_5GB': {
-        "displaytext": "disk_offering_shared_5GB",
-        "name": "disk_offering_shared_5GB",
-        "disksize": 5
-    },
-    'disk_offering_shared_15GB': {
-        "displaytext": "disk_offering_shared_5GB",
-        "name": "disk_offering_shared_5GB",
-        "disksize": 15
-    },
-    "network": {
-        "name": "Test Network",
-        "displaytext": "Test Network",
-        "acltype": "Account",
-    },
-    "network2": {
-        "name": "Test Network Shared",
-        "displaytext": "Test Network Shared",
-        "vlan": 1201,
-        "gateway": "172.16.15.1",
-        "netmask": "255.255.255.0",
-        "startip": "172.16.15.21",
-        "endip": "172.16.15.41",
-        "acltype": "Account",
-    },
-    "network_offering": {
-        "name": 'Test Network offering',
-        "displaytext": 'Test Network offering',
-        "guestiptype": 'Isolated',
-        "supportedservices": 'Dhcp,Dns,SourceNat,PortForwarding',
-        "traffictype": 'GUEST',
-        "availability": 'Optional',
-        "serviceProviderList": {
-            "Dhcp": 'VirtualRouter',
-            "Dns": 'VirtualRouter',
-            "SourceNat": 'VirtualRouter',
-            "PortForwarding": 'VirtualRouter',
-        },
-    },
-    "nw_off_isolated_netscaler": {
-        "name": 'Netscaler',
-        "displaytext": 'Netscaler',
-        "guestiptype": 'Isolated',
-        "supportedservices": 'Dhcp,Dns,SourceNat,PortForwarding,Vpn,Firewall,Lb,UserData,StaticNat',
-        "traffictype": 'GUEST',
-        "availability": 'Optional',
-        "serviceProviderList": {
-            "Dhcp": 'VirtualRouter',
-            "Dns": 'VirtualRouter',
-            "SourceNat": 'VirtualRouter',
-            "PortForwarding": 'VirtualRouter',
-            "Vpn": 'VirtualRouter',
-            "Firewall": 'VirtualRouter',
-            "Lb": 'Netscaler',
-            "UserData": 'VirtualRouter',
-            "StaticNat": 'VirtualRouter',
-        },
-    },
-    "nw_off_isolated_persistent": {
-        "name": 'Test Nw off isolated persistent',
-        "displaytext": 'Test Nw off isolated persistent',
-        "guestiptype": 'Isolated',
-        "supportedservices": 'Dhcp,Dns,SourceNat,PortForwarding',
-        "traffictype": 'GUEST',
-        "ispersistent": 'True',
-        "availability": 'Optional',
-        "serviceProviderList": {
-            "Dhcp": 'VirtualRouter',
-            "Dns": 'VirtualRouter',
-            "SourceNat": 'VirtualRouter',
-            "PortForwarding": 'VirtualRouter',
-        },
-    },
-    "nw_off_isolated_persistent_lb": {
-        "name": 'Test Nw off isolated persistent',
-        "displaytext": 'Test Nw off isolated persistent',
-        "guestiptype": 'Isolated',
-        "supportedservices": 'Dhcp,Dns,SourceNat,PortForwarding,Lb',
-        "traffictype": 'GUEST',
-        "ispersistent": 'True',
-        "availability": 'Optional',
-        "serviceProviderList": {
-            "Dhcp": 'VirtualRouter',
-            "Dns": 'VirtualRouter',
-            "SourceNat": 'VirtualRouter',
-            "PortForwarding": 'VirtualRouter',
-            "Lb": "VirtualRouter"
-        },
-    },
-    "isolated_network_offering": {
-        "name": "Network offering-DA services",
-        "displaytext": "Network offering-DA services",
-        "guestiptype": "Isolated",
-        "supportedservices":
-            "Dhcp,Dns,SourceNat,PortForwarding,Vpn,Firewall,Lb,UserData,StaticNat",
-        "traffictype": "GUEST",
-        "availability": "Optional'",
-        "serviceProviderList": {
-            "Dhcp": "VirtualRouter",
-            "Dns": "VirtualRouter",
-            "SourceNat": "VirtualRouter",
-            "PortForwarding": "VirtualRouter",
-            "Vpn": "VirtualRouter",
-            "Firewall": "VirtualRouter",
-            "Lb": "VirtualRouter",
-            "UserData": "VirtualRouter",
-            "StaticNat": "VirtualRouter"
-        }
-    },
-    "network_offering_vlan": {
-        "name": 'Test Network offering',
-        "displaytext": 'Test Network offering',
-        "guestiptype": 'Isolated',
-        "supportedservices": 'Dhcp,Dns,SourceNat,PortForwarding',
-        "traffictype": 'GUEST',
-        "specifyvlan": 'False',
-        "availability": 'Optional',
-        "serviceProviderList": {
-            "Dhcp": 'VirtualRouter',
-            "Dns": 'VirtualRouter',
-            "SourceNat": 'VirtualRouter',
-            "PortForwarding": 'VirtualRouter',
-        },
-    },
-    "network_offering_without_sourcenat": {
-        "name": 'Test Network offering',
-        "displaytext": 'Test Network offering',
-        "guestiptype": 'Isolated',
-        "supportedservices": 'Dhcp,Dns,UserData',
-        "traffictype": 'GUEST',
-        "availability": 'Optional',
-        "serviceProviderList": {
-            "Dhcp": 'VirtualRouter',
-            "Dns": 'VirtualRouter',
-            "UserData": 'VirtualRouter',
-        },
-    },
-    "isolated_network": {
-        "name": "Isolated Network",
-        "displaytext": "Isolated Network"
-    },
-    "netscaler_VPX": {
-        "ipaddress": "10.223.240.174",
-        "username": "nsroot",
-        "password": "nsroot",
-        "networkdevicetype": "NetscalerVPXLoadBalancer",
-        "publicinterface": "1/1",
-        "privateinterface": "1/2",
-        "numretries": 2,
-        "lbdevicededicated": "True",
-        "lbdevicecapacity": 2,
-        "port": 22
-    },
-    "netscaler_network": {
-        "name": "Netscaler",
-        "displaytext": "Netscaler",
-    },
-    "network_without_acl": {
-        "name": "TestNetwork",
-        "displaytext": "TestNetwork",
-    },
-    "virtual_machine": {
-        "displayname": "Test VM",
-        "username": "root",
-        "password": "password",
-        "ssh_port": 22,
-        "privateport": 22,
-        "publicport": 22,
-        "protocol": "TCP",
-        "affinity": {
-            "name": "webvms",
-            "type": "host anti-affinity",
-        }
-    },
-    "virtual_machine_userdata": {
-        "displayname": "Test VM",
-        "username": "root",
-        "password": "password",
-        "ssh_port": 22,
-        "privateport": 22,
-        "publicport": 22,
-        "protocol": "TCP",
-        "affinity": {
-            "name": "webvms",
-            "type": "host anti-affinity",
-        },
-        "userdata": "This is sample data"
-    },
-    "virtual_machine2": {
-        "name": "testvm2",
-        "displayname": "Test VM2",
-    },
-    "virtual_machine3": {
-        "name": "testvm3",
-        "displayname": "Test VM3",
-    },
-    "shared_network": {
-        "name": "MySharedNetwork - Test",
-        "displaytext": "MySharedNetwork",
-        "vlan": "",
-        "gateway": "",
-        "netmask": "",
-        "startip": "",
-        "endip": "",
-        "acltype": "Domain",
-        "scope": "all"
-    },
-    "shared_network_offering": {
-        "name": "MySharedOffering-shared",
-        "displaytext": "MySharedOffering",
-        "guestiptype": "Shared",
-        "supportedservices": "Dhcp,Dns,UserData",
-        "specifyVlan": "False",
-        "specifyIpRanges": "False",
-        "traffictype": "GUEST",
-        "serviceProviderList": {
-            "Dhcp": "VirtualRouter",
-            "Dns": "VirtualRouter",
-            "UserData": "VirtualRouter"
-        }
-    },
-    "shared_network_offering_all_services": {
-        "name": "shared network offering with services enabled",
-        "displaytext": "Shared network offering",
-        "guestiptype": "Shared",
-        "supportedservices": "Dhcp,Dns,SourceNat,PortForwarding,Vpn,Firewall,Lb,UserData,StaticNat",
-        "specifyVlan": "False",
-        "specifyIpRanges": "False",
-        "traffictype": "GUEST",
-        "serviceProviderList": {
-            "Dhcp": "VirtualRouter",
-            "Dns": "VirtualRouter",
-            "UserData": "VirtualRouter",
-            "SourceNat": "VirtualRouter",
-            "PortForwarding": "VirtualRouter",
-            "Vpn": "VirtualRouter",
-            "Firewall": "VirtualRouter",
-            "Lb": "VirtualRouter",
-            "UserData": "VirtualRouter",
-            "StaticNat": "VirtualRouter"
-        }
-    },
-    "shared_network_offering_sg": {
-        "name": "MySharedOffering-sg",
-        "displaytext": "MySharedOffering-sg",
-        "guestiptype": "Shared",
-        "supportedservices": "Dhcp,Dns,UserData,SecurityGroup",
-        "specifyVlan": "False",
-        "specifyIpRanges": "False",
-        "traffictype": "GUEST",
-        "serviceProviderList": {
-            "Dhcp": "VirtualRouter",
-            "Dns": "VirtualRouter",
-            "UserData": "VirtualRouter",
-            "SecurityGroup": "SecurityGroupProvider"
-        }
-    },
-    "shared_network_sg": {
-        "name": "Shared-Network-SG-Test",
-        "displaytext": "Shared-Network_SG-Test",
-        "networkofferingid": "1",
-        "vlan": "",
-        "gateway": "",
-        "netmask": "255.255.255.0",
-        "startip": "",
-        "endip": "",
-        "acltype": "Domain",
-        "scope": "all"
-    },
-    "vpc_offering": {
-        "name": "VPC off",
-        "displaytext": "VPC off",
-        "supportedservices":
-            "Dhcp,Dns,SourceNat,PortForwarding,Vpn,Lb,UserData,StaticNat,NetworkACL"
-    },
-    "vpc_offering_multi_lb": {
-        "name": "VPC offering with multiple Lb service providers",
-        "displaytext": "VPC offering with multiple Lb service providers",
-        "supportedservices": "Dhcp,Dns,SourceNat,PortForwarding,Vpn,Lb,UserData,StaticNat,NetworkACL",
-        "serviceProviderList": {
-            "Vpn": 'VpcVirtualRouter',
-            "Dhcp": 'VpcVirtualRouter',
-            "Dns": 'VpcVirtualRouter',
-            "SourceNat": 'VpcVirtualRouter',
-            "Lb": ["InternalLbVm", "VpcVirtualRouter"],
-            "PortForwarding": 'VpcVirtualRouter',
-            "UserData": 'VpcVirtualRouter',
-            "StaticNat": 'VpcVirtualRouter',
-            "NetworkACL": 'VpcVirtualRouter'
-        }
-    },
-    "vpc": {
-        "name": "TestVPC",
-        "displaytext": "TestVPC",
-        "cidr": "10.0.0.1/24"
-    },
-    "vpc_network_domain": {
-        "name": "TestVPC",
-        "displaytext": "TestVPC",
-        "cidr": '10.0.0.1/24',
-        "network_domain": "TestVPC"
-    },
-    "clusters": {
-        0: {
-            "clustername": "Xen Cluster",
-            "clustertype": "CloudManaged",
-            "hypervisor": "XenServer",
-        },
-        1: {
-            "clustername": "KVM Cluster",
-            "clustertype": "CloudManaged",
-            "hypervisor": "KVM",
-        },
-        2: {
-            "hypervisor": 'VMware',
-            "clustertype": 'ExternalManaged',
-            "username": 'administrator',
-            "password": 'fr3sca',
-            "url": 'http://192.168.100.17/CloudStack-Clogeny-Pune/Pune-1',
-            "clustername": 'VMWare Cluster',
-        },
-    },
-    "hosts": {
-        "xenserver": {
-            "hypervisor": 'XenServer',
-            "clustertype": 'CloudManaged',
-            "url": 'http://192.168.100.211',
-            "username": "root",
-            "password": "fr3sca",
-        },
-        "kvm": {
-            "hypervisor": 'KVM',
-            "clustertype": 'CloudManaged',
-            "url": 'http://192.168.100.212',
-            "username": "root",
-            "password": "fr3sca",
-        },
-        "vmware": {
-            "hypervisor": 'VMware',
-            "clustertype": 'ExternalManaged',
-            "url": 'http://192.168.100.203',
-            "username": "administrator",
-            "password": "fr3sca",
-        },
-    },
-    "network_offering_shared": {
-        "name": 'Test Network offering shared',
-        "displaytext": 'Test Network offering Shared',
-        "guestiptype": 'Shared',
-        "supportedservices": 'Dhcp,Dns,UserData',
-        "traffictype": 'GUEST',
-        "specifyVlan": "True",
-        "specifyIpRanges": "True",
-        "serviceProviderList": {
-            "Dhcp": 'VirtualRouter',
-            "Dns": 'VirtualRouter',
-            "UserData": 'VirtualRouter',
-        },
-    },
-    "nw_off_isolated_RVR": {
-        "name": "Network offering-RVR services",
-        "displaytext": "Network off-RVR services",
-        "guestiptype": "Isolated",
-        "supportedservices": "Vpn,Dhcp,Dns,SourceNat,PortForwarding,Firewall,Lb,UserData,StaticNat",
-        "traffictype": "GUEST",
-        "availability": "Optional",
-        "ispersistent": "False",
-        "serviceProviderList": {
-            "Vpn": "VirtualRouter",
-            "Dhcp": "VirtualRouter",
-            "Dns": "VirtualRouter",
-            "SourceNat": "VirtualRouter",
-            "PortForwarding": "VirtualRouter",
-            "Firewall": "VirtualRouter",
-            "Lb": "VirtualRouter",
-            "UserData": "VirtualRouter",
-            "StaticNat": "VirtualRouter"
-        },
-        "serviceCapabilityList": {
-            "SourceNat": {
-                "SupportedSourceNatTypes": "peraccount",
-                "RedundantRouter": "true"
-            },
-            "lb": {
-                "SupportedLbIsolation": "dedicated"
-            }
-        }
-    },
-    "nw_off_persistent_RVR": {
-        "name": 'Network offering-RVR services',
-        "displaytext": 'Network off-RVR services',
-        "guestiptype": 'Isolated',
-        "supportedservices":
-            'Vpn,Dhcp,Dns,SourceNat,PortForwarding,Firewall,Lb,UserData,StaticNat',
-        "traffictype": 'GUEST',
-        "ispersistent": 'True',
-        "availability": 'Optional',
-        "serviceProviderList": {
-            "Vpn": 'VirtualRouter',
-            "Dhcp": 'VirtualRouter',
-            "Dns": 'VirtualRouter',
-            "SourceNat": 'VirtualRouter',
-            "PortForwarding": 'VirtualRouter',
-            "Firewall": 'VirtualRouter',
-            "Lb": 'VirtualRouter',
-            "UserData": 'VirtualRouter',
-            "StaticNat": 'VirtualRouter',
-        },
-        "serviceCapabilityList": {
-            "SourceNat": {
-                "SupportedSourceNatTypes": "peraccount",
-                "RedundantRouter": "true",
-            },
-            "lb": {
-                "SupportedLbIsolation": "dedicated"
-            },
-        },
-    },
-    "nw_offering_isolated_vpc": {
-        "name": "Isolated Network for VPC",
-        "displaytext": "Isolated Network for VPC",
-        "guestiptype": "Isolated",
-        "supportedservices": "Dhcp,Dns,SourceNat,PortForwarding,Vpn,UserData,StaticNat,NetworkACL,Lb",
-        "traffictype": "GUEST",
-        "availability": "Optional",
-        "ispersistent": "False",
-        "useVpc": "on",
-        "serviceProviderList": {
-            "Dhcp": "VpcVirtualRouter",
-            "Dns": "VpcVirtualRouter",
-            "SourceNat": "VpcVirtualRouter",
-            "PortForwarding": "VpcVirtualRouter",
-            "Vpn": "VpcVirtualRouter",
-            "UserData": "VpcVirtualRouter",
-            "StaticNat": "VpcVirtualRouter",
-            "NetworkACL": "VpcVirtualRouter",
-            "Lb": "VpcVirtualRouter"
-        }
-    },
-    "nw_off_persistent_VPCVR_LB": {
-        "name": "Persistent Network VPC with LB",
-        "displaytext": "Persistent Network VPC No LB",
-        "guestiptype": "Isolated",
-        "supportedservices": "Dhcp,Dns,SourceNat,PortForwarding,Vpn,Lb,UserData,StaticNat,NetworkACL",
-        "traffictype": "GUEST",
-        "availability": "Optional",
-        "ispersistent": "True",
-        "useVpc": "on",
-        "serviceProviderList": {
-            "Dhcp": "VpcVirtualRouter",
-            "Dns": "VpcVirtualRouter",
-            "SourceNat": "VpcVirtualRouter",
-            "PortForwarding": "VpcVirtualRouter",
-            "Vpn": "VpcVirtualRouter",
-            "Lb": "VpcVirtualRouter",
-            "UserData": "VpcVirtualRouter",
-            "StaticNat": "VpcVirtualRouter",
-            "NetworkACL": "VpcVirtualRouter"
-        }
-    },
-    "nw_off_persistent_VPCVR_NoLB": {
-        "name": "Persistent Network VPC No LB",
-        "displaytext": "Persistent Network VPC No LB",
-        "guestiptype": "Isolated",
-        "supportedservices": "Dhcp,Dns,SourceNat,PortForwarding,Vpn,UserData,StaticNat,NetworkACL",
-        "traffictype": "GUEST",
-        "availability": "Optional",
-        "ispersistent": "True",
-        "useVpc": "on",
-        "serviceProviderList": {
-            "Dhcp": "VpcVirtualRouter",
-            "Dns": "VpcVirtualRouter",
-            "SourceNat": "VpcVirtualRouter",
-            "PortForwarding": "VpcVirtualRouter",
-            "Vpn": "VpcVirtualRouter",
-            "UserData": "VpcVirtualRouter",
-            "StaticNat": "VpcVirtualRouter",
-            "NetworkACL": "VpcVirtualRouter"
-        }
-    },
-    "nw_offering_shared_persistent": {
-        "name": "Network offering for Shared Persistent Network",
-        "displaytext": "Network offering-DA services",
-        "guestiptype": "Shared",
-        "supportedservices": "Dhcp,Dns,SourceNat,PortForwarding,Vpn,Firewall,Lb,UserData,StaticNat",
-        "traffictype": "GUEST",
-        "availability": "Optional",
-        "ispersistent": "True",
-        "serviceProviderList": {
-            "Dhcp": "VirtualRouter",
-            "Dns": "VirtualRouter",
-            "SourceNat": "VirtualRouter",
-            "PortForwarding": "VirtualRouter",
-            "Vpn": "VirtualRouter",
-            "Firewall": "VirtualRouter",
-            "Lb": "VirtualRouter",
-            "UserData": "VirtualRouter",
-            "StaticNat": "VirtualRouter"
-        }
-    },
-    "fwrule": {
-        "startport": 22,
-        "endport": 22,
-        "cidr": "0.0.0.0/0",
-        "protocol": "TCP"
-    },
-    "nw_off_ncc_SharedSP": {
-        "name": 'SharedSP',
-        "displaytext": 'SharedSP',
-        "guestiptype": 'Isolated',
-        "supportedservices":
-            'Dhcp,Dns,SourceNat,Lb,StaticNat',
-        "traffictype": 'GUEST',
-        "availability": 'Optional',
-        "serviceProviderList": {
-            "Dhcp": 'VirtualRouter',
-            "Dns": 'VirtualRouter',
-            "SourceNat": 'VirtualRouter',
-            "Lb": 'Netscaler',
-            "StaticNat": 'VirtualRouter'
-        }
-    },
-    "nw_off_ncc_DedicatedSP": {
-        "name": 'DedicatedSP',
-        "displaytext": 'DedicatedSP',
-        "guestiptype": 'Isolated',
-        "supportedservices":
-            'Dhcp,Dns,SourceNat,Lb,StaticNat',
-        "traffictype": 'GUEST',
-        "availability": 'Optional',
-        "serviceProviderList": {
-            "Dhcp": 'VirtualRouter',
-            "Dns": 'VirtualRouter',
-            "SourceNat": 'VirtualRouter',
-            "Lb": 'Netscaler',
-            "StaticNat": 'VirtualRouter'
-        }
-    },
-    "NCC": {
-        "NCCIP": '10.102.195.215',
-    },
-    "NSShared": {
-        "NSIP": '10.102.195.210',
-    },
-    "NSDedicated": {
-        "NSIP": '10.102.195.212'
-    },
-    "servicepackage_shared": {
-        "name": "SharedSP",
-    },
-    "servicepackage_dedicated": {
-        "name": "DedicatedSP",
-    },
-
-    "nw_off_isolated_persistent_netscaler": {
-        "name": 'Netscaler',
-        "displaytext": 'Netscaler',
-        "guestiptype": 'Isolated',
-        "supportedservices":
-            'Dhcp,Dns,SourceNat,PortForwarding,Vpn,Firewall,Lb,UserData,StaticNat',
-        "traffictype": 'GUEST',
-        "ispersistent": 'True',
-        "availability": 'Optional',
-        "serviceProviderList": {
-            "Dhcp": 'VirtualRouter',
-            "Dns": 'VirtualRouter',
-            "SourceNat": 'VirtualRouter',
-            "PortForwarding": 'VirtualRouter',
-            "Vpn": 'VirtualRouter',
-            "Firewall": 'VirtualRouter',
-            "Lb": 'Netscaler',
-            "UserData": 'VirtualRouter',
-            "StaticNat": 'VirtualRouter',
-        },
-
-    },
-    "network_acl_rule": {
-        "protocol": "TCP",
-        "traffictype": "ingress",
-        "cidrlist": "0.0.0.0/0",
-        "startport": "1",
-        "endport": "1"
-    },
-    "network_offering_internal_lb": {
-        "name": "Network offering for internal lb service",
-        "displaytext": "Network offering for internal lb service",
-        "guestiptype": "Isolated",
-        "traffictype": "Guest",
-        "supportedservices":
-            "Vpn,Dhcp,Dns,Lb,UserData,SourceNat,StaticNat,PortForwarding,NetworkACL",
-        "serviceProviderList": {
-            "Dhcp": "VpcVirtualRouter",
-            "Dns": "VpcVirtualRouter",
-            "Vpn": "VpcVirtualRouter",
-            "UserData": "VpcVirtualRouter",
-            "Lb": "InternalLbVM",
-            "SourceNat": "VpcVirtualRouter",
-            "StaticNat": "VpcVirtualRouter",
-            "PortForwarding": "VpcVirtualRouter",
-            "NetworkACL": "VpcVirtualRouter",
-        },
-        "serviceCapabilityList": {
-            "SourceNat": {"SupportedSourceNatTypes": "peraccount"},
-            "Lb": {"lbSchemes": "internal", "SupportedLbIsolation": "dedicated"}
-        }
-    },
-    "natrule": {
-        "privateport": 22,
-        "publicport": 22,
-        "protocol": "TCP"
-    },
-    "natrulerange": {
-        "privateport": 70,
-        "privateendport": 75,
-        "publicport": 70,
-        "publicendport": 75,
-        "protocol": "TCP"
-    },
-    "updatenatrulerange": {
-        "privateport": 50,
-        "privateendport": 55,
-    },
-    "egress_80": {
-        "startport": 80,
-        "endport": 80,
-        "protocol": "TCP",
-        "cidrlist": ["0.0.0.0/0"]
-    },
-    "lbrule": {
-        "name": "SSH",
-        "alg": "roundrobin",
-        "privateport": 22,
-        "publicport": 2222,
-        "protocol": 'TCP'
-    },
-    "vpclbrule": {
-        "name": "SSH",
-        "alg": "roundrobin",
-        "privateport": 22,
-        "publicport": 22,
-        "protocol": 'TCP'
-    },
-    "internal_lbrule": {
-        "name": "SSH",
-        "algorithm": "roundrobin",
-        # Algorithm used for load balancing
-        "sourceport": 22,
-        "instanceport": 22,
-        "scheme": "internal",
-        "protocol": "TCP",
-        "cidrlist": '0.0.0.0/0',
-    },
-    "internal_lbrule_http": {
-        "name": "HTTP",
-        "algorithm": "roundrobin",
-        # Algorithm used for load balancing
-        "sourceport": 80,
-        "instanceport": 80,
-        "scheme": "internal",
-        "protocol": "TCP",
-        "cidrlist": '0.0.0.0/0',
-    },
-    "http_rule": {
-        "privateport": 80,
-        "publicport": 80,
-        "startport": 80,
-        "endport": 80,
-        "protocol": "TCP",
-        "cidrlist": '0.0.0.0/0',
-    },
+nuage_test_data = {
     "dns_rule": {
         "privateport": 53,
         "publicport": 53,
@@ -846,1012 +24,64 @@
         "protocol": "UDP",
         "cidrlist": '0.0.0.0/0',
     },
-    "icmprule": {
-        "icmptype": -1,
-        "icmpcode": -1,
-        "cidrlist": "0.0.0.0/0",
-        "protocol": "ICMP"
-    },
-    "iso": {
-        "displaytext": "Test ISO",
-        "name": "ISO",
-        "url": "http://people.apache.org/~tsp/dummy.iso",
-        "bootable": False,
-        "ispublic": False,
-        "ostype": "Other (64-bit)",
-    },
-    "iso1": {
-        "displaytext": "Test ISO 1",
-        "name": "ISO 1",
-        "url": "http://people.apache.org/~tsp/dummy.iso",
-        "isextractable": True,
-        "isfeatured": True,
-        "ispublic": True,
-        "ostype": "CentOS 5.6 (64-bit)",
-    },
-    "iso2": {
-        "displaytext": "Test ISO 2",
-        "name": "ISO 2",
-        "url": "http://people.apache.org/~tsp/dummy.iso",
-        "isextractable": True,
-        "isfeatured": True,
-        "ispublic": True,
-        "ostype": "CentOS 5.6 (64-bit)",
-        "mode": 'HTTP_DOWNLOAD',
-    },
-    "isfeatured": True,
-    "ispublic": True,
-    "isextractable": True,
-    "bootable": True,
-    "passwordenabled": True,
-
-    "template": {
-        "displaytext": "xs",
-        "name": "xs",
-        "passwordenabled": False,
-        "ostype": "CentOS 5.6 (64-bit)"
-
-    },
-    "coreos_volume": {
-        "diskname": "Volume_core",
-        "urlvmware":"http://dl.openvm.eu/cloudstack/coreos/x86_64/coreos_production_cloudstack_image-vmware.ova",
-        "urlxen":"http://dl.openvm.eu/cloudstack/coreos/x86_64/coreos_production_cloudstack_image-xen.vhd.bz2",
-        "urlkvm": "http://dl.openvm.eu/cloudstack/coreos/x86_64/" \
-                  "coreos_production_cloudstack_image-kvm.qcow2.bz2",
-        "urlhyperv":"http://dl.openvm.eu/cloudstack/coreos/x86_64/coreos_production_cloudstack_image-hyperv.vhd.zip"
-    },
-    "CentOS6.3template": {
-        "displaytext": "Centos",
-        "name": "Centos",
-        "passwordenabled": False,
-        "ostype": "CentOS 6.3 (64-bit)",
-        "url": "http://people.apache.org/~sanjeev/centos63.ova",
-        "format": "OVA",
-        "ispublic": "true"
-    },
-    "CentOS7template": {
-        "displaytext": "Centos",
-        "name": "Centos",
-        "passwordenabled": False,
-        "isdynamicallyscalable":True,
-        "ostype": "CentOS 7",
-        "url": "http://dl.openvm.eu/cloudstack/centos/vanilla/7/x86_64/CentOS-7-x86_64-vanilla-xen.vhd.bz2",
-        "format": "VHD",
-        "ispublic": "true",
-        "hypervisor":"Xenserver"
-    },
-    "Rhel7template": {
-        "displaytext": "Rhel",
-        "name": "Rhel",
-        "passwordenabled": False,
-        "ostype": "Red Hat Enterprise Linux 7",
-        "format": "OVA",
-        "ispublic": "true"
-    },
-    "template_2": {
-        "displaytext": "Public Template",
-        "name": "Public template",
-        "ostype": "CentOS 5.6 (64-bit)",
-        "isfeatured": True,
-        "ispublic": True,
-        "isextractable": True,
-        "mode": "HTTP_DOWNLOAD",
-        "templatefilter": "self"
-    },
-    "Windows 7 (64-bit)": {
-        "displaytext": "Windows 7 (64-bit)",
-        "name": "Windows 7 (64-bit)",
-        "passwordenabled": False,
-        "url": "http://people.apache.org/~sanjeev/windows7.vhd",
-        "format": "VHD",
-        "ostype": "Windows 7 (64-bit)",
-        "ispublic": "true",
-        "hypervisor": "XenServer"
-    },
-    "Windows Server 2012": {
-        "displaytext": "Windows Server 2012",
-        "name": "Windows Server 2012",
-        "passwordenabled": False,
-        "format": "OVA",
-        "ostype": "Windows Server 2012 (64-bit)",
-        "ispublic": "true",
-        "hypervisor": "Vmware"
-    },
-    "privatetemplate": {
-        "displaytext": "Public Template",
-        "name": "Public template",
-        "ostype": "CentOS 5.6 (64-bit)",
-        "isfeatured": True,
-        "ispublic": False,
-        "isextractable": True,
-        "mode": "HTTP_DOWNLOAD",
-        "templatefilter": "self"
-    },
-    "volume_from_snapshot": {
-        "diskname": 'Volume from snapshot',
-        "size": "1",
-        "zoneid": ""
-    },
-    "templatefilter": 'self',
-    "templates": {
-        "displaytext": 'Template',
-        "name": 'Template',
-        "ostype": "CentOS 5.3 (64-bit)",
-        "templatefilter": 'self',
-    },
-    "win2012template": {
-        "displaytext": "win2012",
-        "name": "win2012",
-        "passwordenabled": False,
-        "url": "http://people.apache.org/~sanjeev/new-test-win.ova",
-        "format": "OVA",
-        "ostype": "Windows 8 (64-bit)",
-    },
-    "rhel60template": {
-        "displaytext": "Rhel60",
-        "name": "Rhel60",
-        "passwordenabled": False,
-        "url": "http://people.apache.org/~sanjeev/Rhel6-64bit.ova",
-        "format": "OVA",
-        "ostype": "Red Hat Enterprise Linux 6.0 (64-bit)"
-    },
-    "security_group": {"name": "custom_Sec_Grp"},
-    "ingress_rule": {
-        "protocol": "TCP",
-        "startport": "22",
-        "endport": "22",
-        "cidrlist": "0.0.0.0/0"
-    },
-    "ingress_rule_ICMP": {
-        "name": 'ICMP',
-        "protocol": 'ICMP',
-        "startport": -1,
-        "endport": -1,
-        "cidrlist": '0.0.0.0/0',
-    },
-    "vpncustomergateway": {
-        "ipsecpsk": "secreatKey",
-        "ikepolicy": "aes128-sha1",
-        "ikelifetime": "86400",
-        "esppolicy": "aes128-sha1",
-        "epslifetime": "3600",
-        "dpd": "false"
-    },
-    "vlan_ip_range": {
-        "startip": "",
-        "endip": "",
-        "netmask": "",
-        "gateway": "",
-        "forvirtualnetwork": "false",
-        "vlan": "untagged",
-    },
-    "ostype": "CoreOS",
-    "sleep": 90,
-    "timeout": 10,
-    "page": 1,
-    "pagesize": 2,
-    "listall": 'true',
-    "advanced_sg": {
-        "zone": {
-            "name": "",
-            "dns1": "8.8.8.8",
-            "internaldns1": "192.168.100.1",
-            "networktype": "Advanced",
-            "securitygroupenabled": "true"
-        },
-        "securitygroupenabled": "true"
-    },
-    "vlan": "10",
-    "portableiprange_vlan": {
-        "part": ["4090-4091", "4092-4095"],
-        "full": "4090-4095"
-    },
-    "nfs": {
-        "url": "nfs://nfs/export/automation/1/testprimary",
-        "name": "Primary XEN"
-    },
-    "nfs2": {
-        "url": "nfs://nfs/export/automation/1/testprimary2",
-        "name": "Primary XEN 2"
-    },
-    "iscsi": {
-        "url":
-            "iscsi://192.168.100.21/iqn.2012-01.localdomain.clo-cstack-cos6:iser/1",
-        "name": "Primary iSCSI"
-    },
-    "volume": {"diskname": "Test Volume",
-               "size": 1
-               },
-    "volume_write_path": {
-        "diskname": "APP Data Volume",
-        "size": 1,   # in GBs
-        "xenserver": {"rootdiskdevice":"/dev/xvda",
-                      "datadiskdevice_1": '/dev/xvdb',
-                      "datadiskdevice_2": '/dev/xvdc',   # Data Disk
-                      },
-        "kvm":       {"rootdiskdevice": "/dev/vda",
-                      "datadiskdevice_1": "/dev/vdb",
-                      "datadiskdevice_2": "/dev/vdc"
-                      },
-        "vmware":    {"rootdiskdevice": "/dev/hda",
-                      "datadiskdevice_1": "/dev/hdb",
-                      "datadiskdevice_2": "/dev/hdc"
-                      }
-    },
-    "data_write_paths": {
-        "mount_dir": "/mnt/tmp",
-        "sub_dir": "test",
-        "sub_lvl_dir1": "test1",
-        "sub_lvl_dir2": "test2",
-        "random_data": "random.data",
-    },
-    "custom_volume": {
-        "customdisksize": 1,
-        "diskname": "Custom disk",
-    },
-    "recurring_snapshot": {
-        "maxsnaps": 2,
-        "timezone": "US/Arizona",
-        "schedule": 1
-    },
-    "volume_offerings": {
-        0: {"diskname": "TestDiskServ"},
-    },
-    "diskdevice": ['/dev/vdc', '/dev/vdb', '/dev/hdb', '/dev/hdc',
-                   '/dev/xvdd', '/dev/cdrom', '/dev/sr0', '/dev/cdrom1'],
-
-    # test_vpc_vpn.py
-    "vpn_user": {
-        "username": "test",
-        "password": "password",
-    },
-    "vpc": {
-        "name": "vpc_vpn",
-        "displaytext": "vpc-vpn",
-        "cidr": "10.1.1.0/24"
-    },
-    "ntwk": {
-        "name": "tier1",
-        "displaytext": "vpc-tier1",
-        "gateway": "10.1.1.1",
-        "netmask": "255.255.255.192"
-    },
-    "vpc2": {
-        "name": "vpc2_vpn",
-        "displaytext": "vpc2-vpn",
-        "cidr": "10.2.1.0/24"
-    },
-    "ntwk2": {
-        "name": "tier2",
-        "displaytext": "vpc-tier2",
-        "gateway": "10.2.1.1",
-        "netmask": "255.255.255.192"
-    },
-    "privateport": 22,
-    "publicport": 22,
-    "protocol": 'TCP',
-    "forvirtualnetwork": "true",
-    "customdisksize": 1,
-    "diskname": "Test Volume",
-    "sparse": {
-        "name": "Sparse Type Disk offering",
-        "displaytext":
-            "Sparse Type Disk offering",
-        "disksize": 1,  # in GB
-        "provisioningtype": "sparse"
-    },
-    "fat": {
-        "name": "Fat Type Disk offering",
-        "displaytext":
-            "Fat Type Disk offering",
-        "disksize": 1,  # in GB
-        "provisioningtype": "fat"
-    },
-    "sparse_disk_offering": {
-        "displaytext": "Sparse",
-        "name": "Sparse",
-        "provisioningtype": "sparse",
-        "disksize": 1
-    },
-    "host_anti_affinity": {
-        "name": "hostantiaffinity",
-        "type": "host anti-affinity",
-    },
-    "vgpu": {
-        "disk_offering": {
-            "displaytext": "Small",
-            "name": "Small",
-            "disksize": 1
-        },
-        "templateregister1": {
-            "displaytext": "win8withpv",
-            "name": "win8withpv",
-            "passwordenabled": False,
-            "url": "http://pleaseupdateURL/dummy.vhd",
-            "format": "VHD",
-            "ostype": "Windows 8 (64-bit)",
-            "ispublic": "true",
-            "hypervisor": "XenServer"
-        },
-        "Windows 8 (64-bit)": {
-            "displaytext": "Windows 8 (64-bit)",
-            "name": "win8withpv",
-            "passwordenabled": False,
-            "url": "http://pleaseupdateURL/dummy.vhd",
-            "format": "VHD",
-            "ostype": "Windows 8 (64-bit)",
-            "ispublic": "true",
-            "hypervisor": "XenServer"
-        },
-        "Windows Server 2012 (64-bit)": {
-            "displaytext": "Windows Server 2012 (64-bit)",
-            "name": "Windows Server 2012 (64-bit)",
-            "passwordenabled": False,
-            "url": "http://pleaseupdateURL/dummy.vhd",
-            "format": "VHD",
-            "ostype": "Windows Server 2012 (64-bit)",
-            "ispublic": "true",
-            "hypervisor": "XenServer"
-        },
-
-        "Windows 7 (64-bit)": {
-            "displaytext": "Windows 7 (64-bit)",
-            "name": "Windows 7 (64-bit)",
-            "passwordenabled": False,
-            "url": "http://pleaseupdateURL/dummy.vhd",
-            "format": "VHD",
-            "ostype": "Windows 7 (64-bit)",
-            "ispublic": "true",
-            "hypervisor": "XenServer"
-        },
-        "RHEL 7 (64-bit)": {
-            "displaytext": "RHEL7 (64-bit)",
-            "name": "RHEL 7 Insta1",
-            "passwordenabled": False,
-            "url": "http://people.apache.org/~sanjeev/RHEL764bitwithtools.vhd",
-            "format": "VHD" ,
-            "ostype": "RHEL 7 (64-bit)",
-            "ispublic": "true",
-            "hypervisor": "XenServer"
-        },
-        "clusters": {
-            "clustername": "Xen Cluster Vgpu",
-            "clustertype": "CloudManaged",
-            "hypervisor": "XenServer"
-        },
-        "hosts": {
-            "nonvgpuxenserver": {
-                "hypervisor": 'XenServer',
-                "clustertype": 'CloudManaged',
-                "url": 'http://10.102.192.57',
-                "username": "root",
-                "password": "freebsd",
-            },
-        },
-        "account": {
-            "email": "test@test.com",
-            "firstname": "Test",
-            "lastname": "User",
-            "username": "test",
-            # Random characters are appended in create account to
-            # ensure unique username generated each time
-            "password": "password",
-        },
-        "service_offerings":
-            {
-                "GRID K260Q":
-                    {
-                        "name": "vGPU260Q",
-                        "displaytext": "vGPU260Q",
-                        "cpunumber": 2,
-                        "cpuspeed": 1600,  # in MHz
-                        "memory": 3072,  # In MBs
-                    },
-                "GRID K240Q":
-                    {
-                        "name": "vGPU240Q",
-                        "displaytext": "vGPU240Q",
-                        "cpunumber": 2,
-                        "cpuspeed": 1600,  # in MHz
-                        "memory": 3072,  # In MBs
-                    },
-                "GRID K220Q":
-                    {
-                        "name": "vGPU220Q",
-                        "displaytext": "vGPU220Q",
-                        "cpunumber": 2,
-                        "cpuspeed": 1600,  # in MHz
-                        "memory": 3072,  # In MBs
-                    },
-                "GRID K200":
-                    {
-                        "name": "vGPU200",
-                        "displaytext": "vGPU200",
-                        "cpunumber": 2,
-                        "cpuspeed": 1600,  # in MHz
-                        "memory": 3072,  # In MBs
-                    },
-                "passthrough":
-                    {
-                        "name": "vGPU passthrough",
-                        "displaytext": "vGPU passthrough",
-                        "cpunumber": 2,
-                        "cpuspeed": 1600,  # in MHz
-                        "memory": 3072,  # In MBs
-                    },
-                "GRID K140Q":
-                    {
-                        # Small service offering ID to for change VM
-                        # service offering from medium to small
-                        "name": "vGPU140Q",
-                        "displaytext": "vGPU140Q",
-                        "cpunumber": 2,
-                        "cpuspeed": 1600,
-                        "memory": 3072,
-                    },
-                "GRID K120Q":
-                    {
-                        "name": "vGPU120Q",
-                        "displaytext": "vGPU120Q",
-                        "cpunumber": 2,
-                        "cpuspeed": 1600,
-                        "memory": 3072,
-                    },
-                "GRID K100":
-                    {
-                        "name": "vGPU100",
-                        "displaytext": "vGPU100",
-                        "cpunumber": 2,
-                        "cpuspeed": 1600,
-                        "memory": 3072,
-                    },
-                "nonvgpuoffering":
-                    {
-                        "name": "nonvgpuoffering",
-                        "displaytext": "nonvgpuoffering",
-                        "cpunumber": 2,
-                        "cpuspeed": 1600,
-                        "memory": 3072,
-                    }
-
-            },
-        "diskdevice": ['/dev/vdc', '/dev/vdb', '/dev/hdb', '/dev/hdc', '/dev/xvdd', '/dev/cdrom', '/dev/sr0',
-                       '/dev/cdrom1'],
-        # Disk device where ISO is attached to instance
-        "mount_dir": "/mnt/tmp",
-        "sleep": 180,
-        "timeout": 60,
-        "ostype": 'Windows 8 (64-bit)',
-        "nongpu_host_ip": "10.102.192.57"
-    },
-    "acl": {
-        #data for domains and accounts
-        "domain1": {
-            "name": "D1",
-        },
-        "accountD1": {
-            "email": "testD1@test.com",
-            "firstname": "testD1",
-            "lastname": "Admin",
-            "username": "testD1",
-            "password": "password",
-            "accounttype": "1",
-        },
-        "accountD1A": {
-            "email": "testD1A@test.com",
-            "firstname": "testD1A",
-            "lastname": "User",
-            "username": "testD1A",
-            "password": "password",
-        },
-        "accountD1B": {
-            "email": "testD1B@test.com",
-            "firstname": "testD1B",
-            "lastname": "User",
-            "username": "testD1B",
-            "password": "password",
-        },
-        "domain11": {
-            "name": "D11",
-        },
-        "accountD11": {
-            "email": "testD11@test.com",
-            "firstname": "testD11",
-            "lastname": "Admin",
-            "username": "testD11",
-            "password": "password",
-            "accounttype": "1",
-        },
-        "accountD11A": {
-            "email": "testD11A@test.com",
-            "firstname": "testD11A",
-            "lastname": "User",
-            "username": "testD11A",
-            "password": "password",
-        },
-        "accountD11B": {
-            "email": "test11B@test.com",
-            "firstname": "testD11B",
-            "lastname": "User",
-            "username": "testD11B",
-            "password": "password",
-        },
-        "domain111": {
-            "name": "D111",
-        },
-        "accountD111": {
-            "email": "testD111@test.com",
-            "firstname": "testD111",
-            "lastname": "Admin",
-            "username": "testD111",
-            "password": "password",
-        },
-        "accountD111A": {
-            "email": "testD111A@test.com",
-            "firstname": "testD111A",
-            "lastname": "User",
-            "username": "testD111A",
-            "password": "password",
-        },
-        "accountD111B": {
-            "email": "testD111B@test.com",
-            "firstname": "testD111B",
-            "lastname": "User",
-            "username": "testD111B",
-            "password": "password",
-        },
-        "domain12": {
-            "name": "D12",
-        },
-        "accountD12A": {
-            "email": "testD12A@test.com",
-            "firstname": "testD12A",
-            "lastname": "User",
-            "username": "testD12A",
-            "password": "password",
-        },
-        "accountD12B": {
-            "email": "testD12B@test.com",
-            "firstname": "testD12B",
-            "lastname": "User",
-            "username": "testD12B",
-            "password": "password",
-        },
-        "domain2": {
-            "name": "D2",
-        },
-        "accountD2": {
-            "email": "testD2@test.com",
-            "firstname": "testD2",
-            "lastname": "User",
-            "username": "testD2",
-            "password": "password",
-            "accounttype": "1",
-        },
-        "accountD2A": {
-            "email": "testD2A@test.com",
-            "firstname": "testD2A",
-            "lastname": "User",
-            "username": "testD2A",
-            "password": "password",
-        },
-        "accountROOTA": {
-            "email": "testROOTA@test.com",
-            "firstname": "testROOTA",
-            "lastname": "User",
-            "username": "testROOTA",
-            "password": "password",
-        },
-
-        "accountROOT": {
-            "email": "testROOTA@test.com",
-            "firstname": "testROOT",
-            "lastname": "admin",
-            "username": "testROOT",
-            "password": "password",
-        },
-        #data reqd for virtual machine creation
-        "vmD1": {
-            "name": "d1",
-            "displayname": "d1",
-        },
-        "vmD1A": {
-            "name": "d1a",
-            "displayname": "d1a",
-        },
-        "vmD1B": {
-            "name": "d1b",
-            "displayname": "d1b",
-        },
-        "vmD11": {
-            "name": "d11",
-            "displayname": "d11",
-        },
-        "vmD11A": {
-            "name": "d11a",
-            "displayname": "d11a",
-        },
-        "vmD11B": {
-            "name": "d11b",
-            "displayname": "d11b",
-        },
-        "vmD111": {
-            "name": "d111",
-            "displayname": "d111",
-        },
-        "vmD111A": {
-            "name": "d111a",
-            "displayname": "d111a",
-        },
-        "vmD111B": {
-            "name": "d111b",
-            "displayname": "d111b",
-        },
-        "vmD12A": {
-            "name": "d12a",
-            "displayname": "d12a",
-        },
-        "vmD12B": {
-            "name": "d12b",
-            "displayname": "d12b",
-        },
-        "vmD2A": {
-            "name": "d2a",
-            "displayname": "d2a",
-        },
-
-        "vmROOTA": {
-            "name": "roota",
-            "displayname": "roota",
-        },
-        "vmROOT": {
-            "name": "root",
-            "displayname": "root",
-        },
-
-        #data reqd for Network creation
-        "network_all": {
-            "name": "SharedNetwork-All",
-            "displaytext": "SharedNetwork-All",
-            "vlan": "4001",
-            "gateway": "10.223.1.1",
-            "netmask": "255.255.255.0",
-            "startip": "10.223.1.2",
-            "endip": "10.223.1.100",
-            "acltype": "Domain"
-        },
-        "network_domain_with_no_subdomain_access": {
-            "name": "SharedNetwork-Domain-nosubdomain",
-            "displaytext": "SharedNetwork-Domain-nosubdomain",
-            "vlan": "4002",
-            "gateway": "10.223.1.1",
-            "netmask": "255.255.255.0",
-            "startip": "10.223.1.2",
-            "endip": "10.223.1.100",
-            "acltype": "Domain",
-            "subdomainaccess": "false"
-        },
-        "network_domain_with_subdomain_access": {
-            "name": "SharedNetwork-Domain-withsubdomain",
-            "displaytext": "SharedNetwork-Domain-withsubdomain",
-            "vlan": "4003",
-            "gateway": "10.223.1.1",
-            "netmask": "255.255.255.0",
-            "startip": "10.223.1.2",
-            "endip": "10.223.1.100",
-            "acltype": "Domain",
-            "subdomainaccess": "true"
-        },
-        "network_account": {
-            "name": "SharedNetwork-Account",
-            "displaytext": "SharedNetwork-Account",
-            "vlan": "4004",
-            "gateway": "10.223.1.1",
-            "netmask": "255.255.255.0",
-            "startip": "10.223.1.2",
-            "endip": "10.223.1.100",
-            "acltype": "Account"
-        },
-
-        "network": {
-            "name": "Network-",
-            "displaytext": "Network-",
-            "gateway": "10.223.1.1",
-            "netmask": "255.255.255.0",
-            "startip": "10.223.59.200",
-            "endip": "10.223.59.240",
-            "vlan": "1000"
-        },
-        "netscaler": {
-            "ipaddress": "",
-            "username": "",
-            "password": "",
-            "networkdevicetype": "",
-            "publicinterface": "",
-            "privateinterface": "",
-            "numretries": "",
-            "lbdevicededicated": "False",
-            "lbdevicecapacity": 2,
-            "port": 22
-        },
-        "iscsi": {
-            "url": "",
-            "name": "Primary iSCSI"
-        },
-        "host": {
-            "publicport": 22,
-            "username": "root",
-            "password": "password",
-        },
-        "ldap_account": {
-            "email": "",
-            "firstname": "",
-            "lastname": "",
-            "username": "",
-            "password": "",
-        },
-        "ldap_configuration": {
-            "basedn": "",
-            "emailAttribute": "",
-            "userObject": "",
-            "usernameAttribute": "",
-            "hostname": "",
-            "port": "",
-            "ldapUsername": "",
-            "ldapPassword": ""
-        },
-        "systemVmDelay": 120,
-        "setUsageConfigurationThroughTestCase": False,
-        "vmware_cluster" : {
-            "hypervisor": 'VMware',
-            "clustertype": 'ExternalManaged',
-            "username": '',
-            "password": '',
-            "url": '',
-            "clustername": 'VMWare Cluster with Space in DC name',
-            "startip": "10.223.1.2",
-            "endip": "10.223.1.100",
-        },
-        #small service offering
-        "service_offering": {
-            "small": {
-                "name": "Small Instance",
-                "displaytext": "Small Instance",
-                "cpunumber": 1,
-                "cpuspeed": 100,
-                "memory": 128,
-            },
-        },
-        "ostype": 'CentOS 5.6 (64-bit)',
+    "vpc_offering_reduced": {
+        "name": "VPC reduced off",
+        "displaytext": "VPC reduced off",
+        "supportedservices":
+            "Dhcp,Dns,SourceNat,UserData,StaticNat,NetworkACL"
     },
-    "test_34_DeployVM_in_SecondSGNetwork": {
-        "zone": "advsg",
-        "config": "D:\ACS-Repo\setup\dev\\advancedsg.cfg",  #Absolute path to cfg file
-        #For sample configuration please refer to <ACS repo>/setup/dev/advancedsg.cfg
-        "template": "CentOS 5.3(64-bit) no GUI (Simulator)",
-        "dbSvr": {
-            "dbSvr": "10.146.0.133",
-            "passwd": "cloud",
-            "db": "cloud",
-            "port": 3306,
-            "user": "cloud"
-        },
-        "mgtSvr": [
-            {
-                "mgtSvrIp": "10.146.0.133",
-                "passwd": "password",
-                "user": "root",
-                "port": 8096
-            }
-        ],
-        "ipranges": [
-            {
-                "startip": "10.147.32.150",
-                "endip": "10.147.32.153",
-                "netmask": "255.255.255.0",
-                "vlan": "32",
-                "gateway": "10.147.32.1"
-            }
-        ]
+    "shared_network_config_drive_offering": {
+        "name": 'shared_network_config_drive_offering',
+        "displaytext": 'shared_network_config_drive_offering',
+        "guestiptype": 'shared',
+        "supportedservices": 'Dhcp,UserData',
+        "traffictype": 'GUEST',
+        "specifyVlan": "True",
+        "specifyIpRanges": "True",
+        "availability": 'Optional',
+        "serviceProviderList": {
+            "Dhcp": "VirtualRouter",
+            "UserData": 'ConfigDrive'
+        }
     },
-
-    "interop":
-        {
-            "VHD":
-                {
-                    "displaytext": "Windows 8 (64-bit)",
-                    "name": "win8withpvxen",
-                    "passwordenabled": False,
-                    "url": "http://people.apache.org/~sanjeev/79211594-1d4a-4dee-ae6c-c5c315ded2be.vhd",
-                    "format": "VHD" ,
-                    "ostype": "Windows 8 (64-bit)",
-                    "ispublic": "true",
-                    "hypervisor": "XenServer"
-
-                },
-            "OVA":
-                {
-                    "displaytext": "Windows 8 (64-bit)",
-                    "name": "win8withpvvmware",
-                    "passwordenabled": False,
-                    "url": "http://pleaseupdateURL/",
-                    "format": "OVA" ,
-                    "ostype": "Windows 8 (64-bit)",
-                    "ispublic": "true",
-                    "hypervisor": "VMware"
-                },
-            "template": {
-                "displaytext": "windowsxdtemplate",
-                "name": "windowsxdtemplate",
-                "passwordenabled": False,
-                "ostype": "Windows 8 (64-bit)"
-            },
-        },
-
-    "browser_upload_volume":{
-        "VHD": {
-            "diskname": "XenUploadVol",
-            "url": "http://people.apache.org/~sanjeev/rajani-thin-volume.vhd",
-            "checksum": "09b08b6abb1b903fca7711d3ac8d6598",
-        },
-        "OVA": {
-            "diskname": "VMwareUploadVol",
-            "url": "http://people.apache.org/~sanjeev/CentOS5.5(64bit)-vmware-autoscale.ova",
-            "checksum": "da997b697feaa2f1f6e0d4785b0cece2",
-        },
-        "QCOW2": {
-            "diskname": "KVMUploadVol",
-            "url": "http://people.apache.org/~sanjeev/rajani-thin-volume.qcow2",
-            "checksum": "02de0576dd3a61ab59c03fd795fc86ac",
-        },
-        'browser_resized_disk_offering': {
-            "displaytext": "Resizeddisk",
-            "name": "Resizeddisk",
-            "disksize": 3,
+    "isolated_staticnat_network_offering": {
+        "name": 'isolated_staticnat_net_off_marvin',
+        "displaytext": 'isolated_staticnat_net_off_marvin',
+        "guestiptype": 'Isolated',
+        "supportedservices": 'Dhcp,SourceNat,StaticNat,UserData,Firewall,Dns',
+        "traffictype": 'GUEST',
+        "ispersistent": 'True',
+        "availability": 'Optional',
+        "tags": 'native',
+        "serviceProviderList": {
+            "Dhcp": 'VirtualRouter',
+            "StaticNat": 'VirtualRouter',
+            "SourceNat": 'VirtualRouter',
+            "Firewall": 'VirtualRouter',
+            "UserData": 'VirtualRouter',
+            "Dns": 'VirtualRouter'
         }
     },
-    "browser_upload_template": {
-        "VHD": {
-            "templatename": "XenUploadtemplate",
-            "displaytext": "XenUploadtemplate",
-            "url": "http://people.apache.org/~sanjeev/centos56-x86_64.vhd.bz2",
-            "hypervisor":"XenServer",
-            "checksum": "09b08b6abb1b903fca7711d3ac8d6598",
-            "ostypeid":"74affaea-c658-11e4-ad38-a6d1374244b4"
-        },
-        "OVA": {
-            "templatename": "VMwareUploadtemplate",
-            "displaytext": "VMwareUploadtemplate",
-            "url": "http://people.apache.org/~sanjeev/CentOS5.3-x86_64.ova",
-            "checksum": "02de0576dd3a61ab59c03fd795fc86ac",
-            "hypervisor":"VMware",
-            "ostypeid":"74affaea-c658-11e4-ad38-a6d1374244b4"
-        },
-        "QCOW2": {
-            "templatename": "KVMUploadtemplate",
-            "displaytext": "VMwareUploadtemplate",
-            "url": "http://people.apache.org/~sanjeev/eec2209b-9875-3c8d-92be-c001bd8a0faf.qcow2.bz2",
-            "checksum": "da997b697feaa2f1f6e0d4785b0cece2",
-            "hypervisor":"KVM",
-            "ostypeid":"2e02e376-cdf3-11e4-beb3-8aa6272b57ef"
-        },
+    "nw_offering_reduced_vpc": {
+        "name": 'Reduced Network for VPC',
+        "displaytext": 'Reduced Network for VPC',
+        "guestiptype": 'Isolated',
+        "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,UserData,'
+                             'Dns',
+        "traffictype": 'GUEST',
+        "availability": 'Optional',
+        "tags": "native",
+        "useVpc": 'on',
+        "ispersistent": 'True',
+        "serviceProviderList": {
+            "Dhcp": "VpcVirtualRouter",
+            "StaticNat": "VpcVirtualRouter",
+            "SourceNat": "VpcVirtualRouter",
+            "NetworkACL": "VpcVirtualRouter",
+            "UserData": "VpcVirtualRouter",
+            "Dns": "VpcVirtualRouter"
+        }
     },
-    "configurableData":
-        {
-            "portableIpRange": {
-                "gateway": "10.223.59.1",
-                "netmask": "255.255.255.0",
-                "startip": "10.223.59.200",
-                "endip": "10.223.59.240",
-                "vlan": "1000"
-            },
-            "netscaler": {
-                "ipaddress": "",
-                "username": "",
-                "password": "",
-                "networkdevicetype": "",
-                "publicinterface": "",
-                "privateinterface": "",
-                "numretries": "",
-                "lbdevicededicated": "False",
-                "lbdevicecapacity": 2,
-                "port": 22
-            },
-            "iscsi": {
-                "url": "",
-                "name": "Primary iSCSI"
-            },
-            "host": {
-                "publicport": 22,
-                "username": "root",
-                "password": "password",
-            },
-            "ldap_account": {
-                "email": "",
-                "firstname": "",
-                "lastname": "",
-                "username": "",
-                "password": "",
-            },
-            "link_ldap_details": {
-                "domain_name": "",
-                "accounttype": "",
-                "name": "",
-                "type": "",
-                "admin": "",
-                "linkLdapUsername": "",
-                "linkLdapPassword": "",
-                "linkLdapNestedUser": "",
-                "linkLdapNestedPassword": ""
-
-            },
-            "ldap_configuration": {
-                "basedn": "",
-                "emailAttribute": "",
-                "userObject": "",
-                "usernameAttribute": "",
-                "hostname": "",
-                "port": "",
-                "ldapUsername": "",
-                "ldapPassword": ""
-            },
-            "systemVmDelay": 120,
-            "setUsageConfigurationThroughTestCase": True,
-            "vmware_cluster": {
-                "hypervisor": 'VMware',
-                "clustertype": 'ExternalManaged',
-                "username": '',
-                "password": '',
-                "url": '',
-                "clustername": 'VMWare Cluster with Space in DC name',
-            },
-            "upload_volume": {
-                "diskname": "UploadVol",
-                "format": "VHD",
-                "url": "http://download.cloudstack.org/releases/2.0.0/UbuntuServer-10-04-64bit.vhd.bz2",
-                "checksum": "",
-            },
-            "bootableIso":
-                {
-                    "displaytext": "Test Bootable ISO",
-                    "name": "testISO",
-                    "bootable": True,
-                    "ispublic": False,
-                    "url": "http://people.apache.org/~sanjeev/CentOS-6.3-x86_64-bin-DVD1.iso",
-                    "ostype": 'CentOS 6.3 (64-bit)',
-                    "mode": 'HTTP_DOWNLOAD'
-                },
-            "setHostConfigurationForIngressRule": False,
-            "restartManagementServerThroughTestCase": False,
-            "vmxnet3template": {
-                "displaytext": "VMXNET3 Template",
-                "name": "VMXNET3 template",
-                "ostype": "CentOS 5.6 (64-bit)",
-                "isfeatured": True,
-                "ispublic": False,
-                "isextractable": True,
-                "mode": "HTTP_DOWNLOAD",
-                "templatefilter": "self",
-                "url": "http://people.apache.org/~sanjeev/systemvm64template-2014-09-30-4.3-vmware.ova",
-                "hypervisor": "vmware",
-                "format": "OVA",
-                "nicadapter": "vmxnet3",
-                "kvm": {
-                    "url": ""
-                },
-                "vmware": {
-                    "url": ""
-                },
-                "xenserver": {
-                    "url": ""
-                },
-                "hyperv": {
-                    "url": ""
-                },
-                "ostype": 'CentOS 5.3 (64-bit)',
-                "mode": 'HTTP_DOWNLOAD'
-            }
-        },
     # Nuage VSP SDN plugin specific test data
     "nuagevsp": {
         # Services supported by the Nuage VSP plugin for Isolated networks
@@ -1862,6 +92,53 @@
             "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,UserData,Firewall,Dns',
             "traffictype": 'GUEST',
             "availability": 'Optional',
+            "tags": "nuage",
+            "serviceProviderList": {
+                "Dhcp": 'NuageVsp',
+                "StaticNat": 'NuageVsp',
+                "SourceNat": 'NuageVsp',
+                "Firewall": 'NuageVsp',
+                "Connectivity": 'NuageVsp',
+                "UserData": 'VirtualRouter',
+                "Dns": 'VirtualRouter'
+            },
+            "serviceCapabilityList": {
+                "SourceNat": {"SupportedSourceNatTypes": "perzone"}
+            }
+        },
+        # Persistent services supported by the Nuage VSP plugin for Isolated networks
+        "isolated_network_offering_persistent": {
+            "name": 'nuage_marvin',
+            "displaytext": 'nuage_marvin',
+            "guestiptype": 'Isolated',
+            "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,UserData,Firewall,Dns',
+            "traffictype": 'GUEST',
+            "availability": 'Optional',
+            "ispersistent": 'True',
+            "tags": "nuage",
+            "serviceProviderList": {
+                "Dhcp": 'NuageVsp',
+                "StaticNat": 'NuageVsp',
+                "SourceNat": 'NuageVsp',
+                "Firewall": 'NuageVsp',
+                "Connectivity": 'NuageVsp',
+                "UserData": 'VirtualRouter',
+                "Dns": 'VirtualRouter'
+            },
+            "serviceCapabilityList": {
+                "SourceNat": {"SupportedSourceNatTypes": "perzone"}
+            }
+        },
+        # Persistent services supported by the Nuage VSP plugin for Isolated networks
+        "isolated_network_offering_persistent": {
+            "name": 'nuage_marvin',
+            "displaytext": 'nuage_marvin',
+            "guestiptype": 'Isolated',
+            "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,UserData,Firewall,Dns',
+            "traffictype": 'GUEST',
+            "availability": 'Optional',
+            "ispersistent": 'True',
+            "tags": "nuage",
             "serviceProviderList": {
                 "Dhcp": 'NuageVsp',
                 "StaticNat": 'NuageVsp',
@@ -1875,6 +152,47 @@
                 "SourceNat": {"SupportedSourceNatTypes": "perzone"}
             }
         },
+        # Purely nuage network offering
+        "isolated_network_offering_without_vr": {
+            "name": 'nuage_marvin',
+            "displaytext": 'nuage_marvin',
+            "guestiptype": 'Isolated',
+            "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,Firewall',
+            "traffictype": 'GUEST',
+            "availabiliy": 'Optional',
+            "tags": "nuage",
+            "serviceProviderList": {
+                "Dhcp": 'NuageVsp',
+                "StaticNat": 'NuageVsp',
+                "SourceNat": 'NuageVsp',
+                "Firewall": 'NuageVsp',
+                "Connectivity": 'NuageVsp'
+            },
+            "serviceCapabilityList": {
+                "SourceNat": {"SupportedSourceNatTypes": "perzone"}
+            }
+        },
+        # Purely persistent nuage network offering
+        "isolated_network_offering_without_vr_persistent": {
+            "name": 'nuage_marvin',
+            "displaytext": 'nuage_marvin',
+            "guestiptype": 'Isolated',
+            "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,Firewall',
+            "traffictype": 'GUEST',
+            "availability": 'Optional',
+            "tags": "nuage",
+            "ispersistent": 'True',
+            "serviceProviderList": {
+                "Dhcp": 'NuageVsp',
+                "StaticNat": 'NuageVsp',
+                "SourceNat": 'NuageVsp',
+                "Firewall": 'NuageVsp',
+                "Connectivity": 'NuageVsp'
+            },
+            "serviceCapabilityList": {
+                "SourceNat": {"SupportedSourceNatTypes": "perzone"}
+            }
+        },
         # Services supported by the Nuage VSP plugin for VPC networks
         "vpc_network_offering": {
             "name": 'nuage_vpc_marvin',
@@ -1885,6 +203,7 @@
             "availability": 'Optional',
             "useVpc": 'on',
             "ispersistent": 'True',
+            "tags": "nuage",
             "serviceProviderList": {
                 "Dhcp": "NuageVsp",
                 "StaticNat": "NuageVsp",
@@ -1905,6 +224,7 @@
             "supportedservices": 'Dhcp,Lb,StaticNat,SourceNat,NetworkACL,Connectivity,UserData,Dns',
             "traffictype": 'GUEST',
             "availability": 'Optional',
+            "tags": "nuage",
             "useVpc": 'on',
             "ispersistent": 'True',
             "serviceProviderList": {
@@ -1952,6 +272,180 @@
                 "Dns": "VpcVirtualRouter"
             }
         },
+        # Services supported by the Nuage VSP plugin for VPC without userdata
+        "vpc_network_offering_nuage_dhcp": {
+            "name": 'nuage_vpc_marvin',
+            "displaytext": 'nuage_vpc_marvin',
+            "guestiptype": 'Isolated',
+            "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,Dns',
+            "traffictype": 'GUEST',
+            "availability": 'Optional',
+            "useVpc": 'on',
+            "ispersistent": 'True',
+            "serviceProviderList": {
+                "Dhcp": "NuageVsp",
+                "StaticNat": "NuageVsp",
+                "SourceNat": "NuageVsp",
+                "NetworkACL": "NuageVsp",
+                "Connectivity": "NuageVsp",
+                "Dns": "VpcVirtualRouter",
+            },
+            "serviceCapabilityList": {
+                "SourceNat": {"SupportedSourceNatTypes": "perzone"}
+            }
+        },
+        "isolated_configdrive_network_offering_withoutdns" : {
+            "name": 'nuage_configdrive_withoutDns_marvin',
+            "displaytext": 'nuage_configdrive_withoutDns_marvin',
+            "guestiptype": 'Isolated',
+            "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,UserData,Firewall',
+            "traffictype": 'GUEST',
+            "availability": 'Optional',
+            "serviceProviderList": {
+                "Dhcp": 'NuageVsp',
+                "StaticNat": 'NuageVsp',
+                "SourceNat": 'NuageVsp',
+                "Firewall": 'NuageVsp',
+                "Connectivity": 'NuageVsp',
+                "UserData": 'ConfigDrive'
+            },
+            "serviceCapabilityList": {
+                "SourceNat": {"SupportedSourceNatTypes": "perzone"}
+            }
+        },
+        "isolated_configdrive_network_offering": {
+            "name": 'nuage_configdrive_marvin',
+            "displaytext": 'nuage_configdrive_marvin',
+            "guestiptype": 'Isolated',
+            "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,UserData,Firewall,Dns',
+            "traffictype": 'GUEST',
+            "availability": 'Optional',
+            "serviceProviderList": {
+                "Dhcp": 'NuageVsp',
+                "StaticNat": 'NuageVsp',
+                "SourceNat": 'NuageVsp',
+                "Firewall": 'NuageVsp',
+                "Connectivity": 'NuageVsp',
+                "UserData": 'ConfigDrive',
+                "Dns": 'VirtualRouter'
+            },
+            "serviceCapabilityList": {
+                "SourceNat": {"SupportedSourceNatTypes": "perzone"}
+            }
+        },
+        "vpc_network_offering_configdrive_withoutdns" : {
+            "name": 'nuage_vpc_marvin_configdrive_withoutdns',
+            "displaytext": 'nuage_vpc_marvin_configdrive_withoutdns',
+            "guestiptype": 'Isolated',
+            "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,UserData',
+            "traffictype": 'GUEST',
+            "availability": 'Optional',
+            "useVpc": 'on',
+            "ispersistent": 'True',
+            "serviceProviderList": {
+                "Dhcp": "NuageVsp",
+                "StaticNat": "NuageVsp",
+                "SourceNat": "NuageVsp",
+                "NetworkACL": "NuageVsp",
+                "Connectivity": "NuageVsp",
+                "UserData": "ConfigDrive"
+            },
+            "serviceCapabilityList": {
+                "SourceNat": {"SupportedSourceNatTypes": "perzone"}
+            }
+        },
+        "vpc_network_offering_configdrive_withdns" : {
+            "name": 'nuage_vpc_marvin_configdrive_withdns',
+            "displaytext": 'nuage_vpc_marvin_configdrive_withdns',
+            "guestiptype": 'Isolated',
+            "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,UserData,Dns',
+            "traffictype": 'GUEST',
+            "availability": 'Optional',
+            "useVpc": 'on',
+            "ispersistent": 'True',
+            "serviceProviderList": {
+                "Dhcp": "NuageVsp",
+                "StaticNat": "NuageVsp",
+                "SourceNat": "NuageVsp",
+                "NetworkACL": "NuageVsp",
+                "Connectivity": "NuageVsp",
+                "UserData": "ConfigDrive",
+                "Dns": "VpcVirtualRouter"
+            },
+            "serviceCapabilityList": {
+                "SourceNat": {"SupportedSourceNatTypes": "perzone"}
+            }
+        },
+        "vpc_offering_configdrive_withoutdns" : {
+            "name": 'Nuage VSP VPC offering ConfigDrive',
+            "displaytext": 'Nuage VSP VPC offering ConfigDrive',
+            "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,UserData',
+            "serviceProviderList": {
+                "Dhcp": "NuageVsp",
+                "StaticNat": "NuageVsp",
+                "SourceNat": "NuageVsp",
+                "NetworkACL": "NuageVsp",
+                "Connectivity": "NuageVsp",
+                "UserData": "ConfigDrive"
+            }
+        },
+        "vpc_offering_configdrive_withdns" :{
+            "name": 'Nuage VSP VPC offering ConfigDrive withVR',
+            "displaytext": 'Nuage VSP VPC offering ConfigDrive withVR',
+            "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,UserData,Dns',
+            "serviceProviderList": {
+                "Dhcp": "NuageVsp",
+                "StaticNat": "NuageVsp",
+                "SourceNat": "NuageVsp",
+                "NetworkACL": "NuageVsp",
+                "Connectivity": "NuageVsp",
+                "UserData": "ConfigDrive",
+                "Dns": "VpcVirtualRouter"
+            }
+        },
+        "shared_nuage_network_config_drive_offering" : {
+            "name": 'nuage_marvin',
+            "displaytext": 'nuage_marvin',
+            "guestiptype": 'shared',
+            "supportedservices": 'Dhcp,Connectivity,UserData',
+            "traffictype": 'GUEST',
+            "specifyVlan": "False",
+            "specifyIpRanges": "True",
+            "availability": 'Optional',
+            "serviceProviderList": {
+                "Dhcp": "NuageVsp",
+                "Connectivity": "NuageVsp",
+                "UserData": 'ConfigDrive'
+            },
+            "serviceCapabilityList": {
+                "Connectivity": {
+                    "PublicAccess": "true"
+                }
+            }
+        },
+        "network_all2" : {
+            "name": "SharedNetwork2-All-nuage",
+            "displaytext": "SharedNetwork2-All-nuage",
+            "gateway": "10.200.200.1",
+            "netmask": "255.255.255.0",
+            "startip": "10.200.200.21",
+            "endip": "10.200.200.100",
+            "acltype": "Domain"
+        },
+        # Services supported by the Nuage VSP plugin for VPCs
+        "vpc_offering_nuage_dhcp": {
+            "name": 'Nuage VSP VPC offering',
+            "displaytext": 'Nuage VSP VPC offering',
+            "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,Dns',
+            "serviceProviderList": {
+                "Dhcp": "NuageVsp",
+                "StaticNat": "NuageVsp",
+                "SourceNat": "NuageVsp",
+                "NetworkACL": "NuageVsp",
+                "Connectivity": "NuageVsp",
+                "Dns": "VpcVirtualRouter",
+            }
+        },
         "shared_nuage_network_offering": {
             "name": 'nuage_marvin',
             "displaytext": 'nuage_marvin',
@@ -1961,6 +455,7 @@
             "specifyVlan": "False",
             "specifyIpRanges": "True",
             "availability": 'Optional',
+            "tags": "nuage",
             "serviceProviderList": {
                 "Dhcp": "NuageVsp",
                 "Connectivity": "NuageVsp"
@@ -1975,6 +470,7 @@
             "specifyVlan": "False",
             "specifyIpRanges": "True",
             "availability": 'Optional',
+            "tags": "nuage",
             "serviceProviderList": {
                 "Dhcp": "NuageVsp",
                 "Connectivity": "NuageVsp"
@@ -1990,10 +486,10 @@
         "network_all": {
             "name": "SharedNetwork-All-nuage",
             "displaytext": "SharedNetwork-All-nuage",
-            "gateway": "10.223.1.1",
+            "gateway": "10.200.100.1",
             "netmask": "255.255.255.0",
-            "startip": "10.223.1.21",
-            "endip": "10.223.1.100",
+            "startip": "10.200.100.21",
+            "endip": "10.200.100.100",
             "acltype": "Domain"
         },
         "network_domain_with_no_subdomain_access": {
@@ -2025,11 +521,26 @@
             "endip": "10.220.1.100",
             "acltype": "Account"
         },
+        "shared_network_offering": {
+            "name": "MySharedOffering-shared",
+            "displaytext": "MySharedOffering",
+            "guestiptype": "Shared",
+            "supportedservices": "Dhcp,Dns,UserData",
+            "specifyVlan": "True",
+            "specifyIpRanges": "True",
+            "traffictype": "GUEST",
+            "tags": "native",
+            "serviceProviderList": {
+                "Dhcp": "VirtualRouter",
+                "Dns": "VirtualRouter",
+                "UserData": "VirtualRouter"
+            }
+        },
         "publiciprange1": {
-            "gateway": "10.223.1.1",
+            "gateway": "10.200.100.1",
             "netmask": "255.255.255.0",
-            "startip": "10.223.1.101",
-            "endip": "10.223.1.105",
+            "startip": "10.200.100.101",
+            "endip": "10.200.100.105",
             "forvirtualnetwork": "false"
         },
         "publiciprange2": {
@@ -2040,10 +551,10 @@
             "forvirtualnetwork": "false"
         },
         "publiciprange3": {
-            "gateway": "10.223.1.1",
+            "gateway": "10.200.100.1",
             "netmask": "255.255.255.0",
-            "startip": "10.223.1.2",
-            "endip": "10.223.1.20",
+            "startip": "10.200.100.2",
+            "endip": "10.200.100.20",
             "forvirtualnetwork": "false"
         }
     }
diff --git a/test/integration/plugins/nuagevsp/test_nuage_configdrive.py b/test/integration/plugins/nuagevsp/test_nuage_configdrive.py
index 78321224438..a7b80b14234 100644
--- a/test/integration/plugins/nuagevsp/test_nuage_configdrive.py
+++ b/test/integration/plugins/nuagevsp/test_nuage_configdrive.py
@@ -76,153 +76,6 @@ def delete(self, apiclient):
         apiclient.deleteSSHKeyPair(cmd)
 
 
-class Services:
-    """Test Add Remove Network Services
-    """
-
-    def __init__(self):
-        self.services = {
-            "isolated_configdrive_network_offering_withoutdns" : {
-                "name": 'nuage_configdrive_withoutDns_marvin',
-                "displaytext": 'nuage_configdrive_withoutDns_marvin',
-                "guestiptype": 'Isolated',
-                "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,UserData,Firewall',
-                "traffictype": 'GUEST',
-                "availability": 'Optional',
-                "serviceProviderList": {
-                    "Dhcp": 'NuageVsp',
-                    "StaticNat": 'NuageVsp',
-                    "SourceNat": 'NuageVsp',
-                    "Firewall": 'NuageVsp',
-                    "Connectivity": 'NuageVsp',
-                    "UserData": 'ConfigDrive'
-                },
-                "serviceCapabilityList": {
-                    "SourceNat": {"SupportedSourceNatTypes": "perzone"}
-                }
-            },
-            "isolated_configdrive_network_offering": {
-                "name": 'nuage_configdrive_marvin',
-                "displaytext": 'nuage_configdrive_marvin',
-                "guestiptype": 'Isolated',
-                "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,UserData,Firewall,Dns',
-                "traffictype": 'GUEST',
-                "availability": 'Optional',
-                "serviceProviderList": {
-                    "Dhcp": 'NuageVsp',
-                    "StaticNat": 'NuageVsp',
-                    "SourceNat": 'NuageVsp',
-                    "Firewall": 'NuageVsp',
-                    "Connectivity": 'NuageVsp',
-                    "UserData": 'ConfigDrive',
-                    "Dns": 'VirtualRouter'
-                },
-                "serviceCapabilityList": {
-                    "SourceNat": {"SupportedSourceNatTypes": "perzone"}
-                }
-            },
-            "vpc_network_offering_configdrive_withoutdns" : {
-                "name": 'nuage_vpc_marvin_configdrive_withoutdns',
-                "displaytext": 'nuage_vpc_marvin_configdrive_withoutdns',
-                "guestiptype": 'Isolated',
-                "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,UserData',
-                "traffictype": 'GUEST',
-                "availability": 'Optional',
-                "useVpc": 'on',
-                "ispersistent": 'True',
-                "serviceProviderList": {
-                    "Dhcp": "NuageVsp",
-                    "StaticNat": "NuageVsp",
-                    "SourceNat": "NuageVsp",
-                    "NetworkACL": "NuageVsp",
-                    "Connectivity": "NuageVsp",
-                    "UserData": "ConfigDrive"
-                },
-                "serviceCapabilityList": {
-                    "SourceNat": {"SupportedSourceNatTypes": "perzone"}
-                }
-            },
-            "vpc_network_offering_configdrive_withdns" : {
-                "name": 'nuage_vpc_marvin_configdrive_withdns',
-                "displaytext": 'nuage_vpc_marvin_configdrive_withdns',
-                "guestiptype": 'Isolated',
-                "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,UserData,Dns',
-                "traffictype": 'GUEST',
-                "availability": 'Optional',
-                "useVpc": 'on',
-                "ispersistent": 'True',
-                "serviceProviderList": {
-                    "Dhcp": "NuageVsp",
-                    "StaticNat": "NuageVsp",
-                    "SourceNat": "NuageVsp",
-                    "NetworkACL": "NuageVsp",
-                    "Connectivity": "NuageVsp",
-                    "UserData": "ConfigDrive",
-                    "Dns": "VpcVirtualRouter"
-                },
-                "serviceCapabilityList": {
-                    "SourceNat": {"SupportedSourceNatTypes": "perzone"}
-                }
-            },
-            "vpc_offering_configdrive_withoutdns" : {
-                "name": 'Nuage VSP VPC offering ConfigDrive',
-                "displaytext": 'Nuage VSP VPC offering ConfigDrive',
-                "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,UserData',
-                "serviceProviderList": {
-                    "Dhcp": "NuageVsp",
-                    "StaticNat": "NuageVsp",
-                    "SourceNat": "NuageVsp",
-                    "NetworkACL": "NuageVsp",
-                    "Connectivity": "NuageVsp",
-                    "UserData": "ConfigDrive"
-                }
-            },
-            "vpc_offering_configdrive_withdns" :{
-                "name": 'Nuage VSP VPC offering ConfigDrive withVR',
-                "displaytext": 'Nuage VSP VPC offering ConfigDrive withVR',
-                "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,UserData,Dns',
-                "serviceProviderList": {
-                    "Dhcp": "NuageVsp",
-                    "StaticNat": "NuageVsp",
-                    "SourceNat": "NuageVsp",
-                    "NetworkACL": "NuageVsp",
-                    "Connectivity": "NuageVsp",
-                    "UserData": "ConfigDrive",
-                    "Dns": "VpcVirtualRouter"
-                }
-            },
-            "shared_nuage_network_config_drive_offering" : {
-                "name": 'nuage_marvin',
-                "displaytext": 'nuage_marvin',
-                "guestiptype": 'shared',
-                "supportedservices": 'Dhcp,Connectivity,UserData',
-                "traffictype": 'GUEST',
-                "specifyVlan": "False",
-                "specifyIpRanges": "True",
-                "availability": 'Optional',
-                "serviceProviderList": {
-                    "Dhcp": "NuageVsp",
-                    "Connectivity": "NuageVsp",
-                    "UserData": 'ConfigDrive'
-                },
-                "serviceCapabilityList": {
-                    "Connectivity": {
-                        "PublicAccess": "true"
-                    }
-                }
-            },
-            "network_all2" : {
-                "name": "SharedNetwork2-All-nuage",
-                "displaytext": "SharedNetwork2-All-nuage",
-                "gateway": "10.200.200.1",
-                "netmask": "255.255.255.0",
-                "startip": "10.200.200.21",
-                "endip": "10.200.200.100",
-                "acltype": "Domain"
-            }
-        }
-
-
 class TestNuageConfigDrive(nuageTestCase):
     """Test user data and password reset functionality
     using configDrive with Nuage VSP SDN plugin
@@ -308,6 +161,7 @@ def __init__(self, nuagetestcase, vm, **kwargs):
         def run(self):
             self.expected_user_data = "hello world vm %s" % self.vm.name
             user_data = base64.b64encode(self.expected_user_data)
+            self.end = None
             self.start = datetime.now()
             self.vm.update(self.nuagetestcase.api_client, userdata=user_data)
             self.end = datetime.now()
@@ -321,6 +175,8 @@ def get_vm(self):
             return self.vm
 
         def get_timestamps(self):
+            if not self.end:
+                self.end = datetime.now()
             return [self.start, self.end]
 
         def get_userdata(self):
@@ -356,6 +212,8 @@ def get_vm(self):
             return self.vm
 
         def get_timestamps(self):
+            if not self.end:
+                self.end = datetime.now()
             return [self.start, self.end]
 
         def get_password(self):
@@ -368,7 +226,6 @@ def get_name():
     @classmethod
     def setUpClass(cls):
         super(TestNuageConfigDrive, cls).setUpClass()
-        cls.test_data["nuagevsp"].update(Services().services)
         return
 
     def setUp(self):
@@ -480,7 +337,7 @@ def verifyOpenStackUserData(self, ssh, iso_path, userdata):
                          'Userdata found: %s is not equal to expected: %s'
                          % (vmuserdata, userdata))
 
-    def verifyPassword(self, vm, ssh, iso_path, password):
+    def verifyPassword(self, ssh, iso_path, password):
         self.debug("Expected VM password is %s " % password.password)
         password_file = iso_path+"/cloudstack/password/vm_password.txt"
         cmd = "cat %s" % password_file
@@ -520,11 +377,7 @@ def verifyMetaData(self, vm, ssh, iso_path):
             res = ssh.execute(cmd)
             metadata[file] = res
 
-        metadata_files = ["availability-zone.txt",
-                          "instance-id.txt",
-                          "service-offering.txt",
-                          "vm-id.txt"]
-        for mfile in metadata_files:
+        for mfile in vm_files:
             if mfile not in metadata:
                 self.fail("{} file is not found in vm metadata".format(mfile))
         self.assertEqual(
@@ -546,7 +399,7 @@ def verifyMetaData(self, vm, ssh, iso_path):
         )
         return
 
-    def verifyOpenStackData(self, vm, ssh, iso_path):
+    def verifyOpenStackData(self, ssh, iso_path):
 
         openstackdata_dir = iso_path+"/openstack/latest/"
         openstackdata = {}
@@ -658,6 +511,10 @@ def verify_config_drive_content(self, vm,
                                     metadata=False,
                                     sshkey=None,
                                     ssh_client=None):
+        if self.isSimulator:
+            self.debug("Simulator Environment: Skipping Config Drive content verification")
+            return
+
         self.debug("SSHing into the VM %s" % vm.name)
         if ssh_client is None:
             ssh = self.ssh_into_VM(vm, public_ip)
@@ -672,7 +529,7 @@ def verify_config_drive_content(self, vm,
             self.debug("Verifying metadata for vm: %s" % vm.name)
             self.verifyMetaData(vm, ssh, config_drive_path)
             self.debug("Verifying openstackdata for vm: %s" % vm.name)
-            self.verifyOpenStackData(vm, ssh, config_drive_path)
+            self.verifyOpenStackData(ssh, config_drive_path)
 
         if userdata is not None:
             self.debug("Verifying userdata for vm: %s" % vm.name)
@@ -680,7 +537,7 @@ def verify_config_drive_content(self, vm,
             self.verifyOpenStackUserData(ssh, config_drive_path, userdata)
         if password_test.test_presence:
             self.debug("Verifying password for vm: %s" % vm.name)
-            test_result = self.verifyPassword(vm, ssh, config_drive_path,
+            test_result = self.verifyPassword(ssh, config_drive_path,
                                               password_test)
             self.assertEqual(test_result[0], password_test.presence,
                              "Expected is that password is present: %s "
@@ -769,7 +626,7 @@ def resetsshkey(self, vm, keypair, account=None, domainid=None):
         cmd.keypair = keypair
         cmd.account = account
         cmd.domainid = domainid
-        return(self.api_client.resetSSHKeyForVirtualMachine(cmd))
+        return self.api_client.resetSSHKeyForVirtualMachine(cmd)
 
     def update_sshkeypair(self, vm):
         vm.stop(self.api_client)
diff --git a/test/integration/plugins/nuagevsp/test_nuage_extra_dhcp.py b/test/integration/plugins/nuagevsp/test_nuage_extra_dhcp.py
index cabba0cf5f0..e167ddef122 100644
--- a/test/integration/plugins/nuagevsp/test_nuage_extra_dhcp.py
+++ b/test/integration/plugins/nuagevsp/test_nuage_extra_dhcp.py
@@ -98,12 +98,9 @@ def setUpClass(cls, zone=None):
         cls.expected_dhcp_options_on_vm = {}
         cls.dhcp_options_map_keys = [1, 16, 28, 41, 64, 93]
 
-        cls._cleanup = [
-            cls.shared_network_all,
-            cls.shared_network_offering,
-            cls.account
-            ]
-        return
+        cls._cleanup.append(cls.account)
+        cls._cleanup.append(cls.shared_network_offering)
+        cls._cleanup.append(cls.shared_network_all)
 
     def setUp(self):
         self.vmdata["displayname"] = "vm"
@@ -273,16 +270,6 @@ def tearDown(self):
         # Cleanup resources used
         self.debug("Cleaning up the resources")
         self.update_NuageVspGlobalDomainTemplateName(name="")
-        for obj in reversed(self.cleanup):
-            try:
-                if isinstance(obj, VirtualMachine):
-                    obj.delete(self.api_client, expunge=True)
-                else:
-                    obj.delete(self.api_client)
-            except Exception as e:
-                self.error("Failed to cleanup %s, got %s" % (obj, e))
-        # cleanup_resources(self.api_client, self.cleanup)
-        self.cleanup = []
         self.debug("Cleanup complete!")
         return
 
@@ -435,6 +422,10 @@ def verify_vsd_dhcp_type_notpresent(self, dhcp_types, vm_interface):
 
     def verify_dhcp_on_vm(
             self, dhcpleasefile, dhcp_option_map, ssh_client, cleanlease=True):
+        if self.isSimulator:
+            self.debug("Simulator Environment: Skipping VM DHCP option verification")
+            return
+
         cmd = 'cat /var/lib/dhclient/'+dhcpleasefile
         self.debug("get content of dhcp lease file " + cmd)
         outputlist = ssh_client.execute(cmd)
@@ -1071,9 +1062,6 @@ def validate_all_extra_dhcp_for_network_in_allocated(
 
         self.delete_VM(vm4)
         self.delete_VM(vm3)
-        self.delete_Network(network)
-        if vpc:
-            vpc.delete(self.api_client)
 
     def validate_all_extra_dhcp_for_vm_actions_in_network(
             self, network,
diff --git a/test/integration/plugins/nuagevsp/test_nuage_internal_dns.py b/test/integration/plugins/nuagevsp/test_nuage_internal_dns.py
index 0c2a6b611ed..09bcdc9800b 100644
--- a/test/integration/plugins/nuagevsp/test_nuage_internal_dns.py
+++ b/test/integration/plugins/nuagevsp/test_nuage_internal_dns.py
@@ -25,6 +25,12 @@
 from nose.plugins.attrib import attr
 import time
 
+UPDATED_DOMAIN_NAME = "update.com"
+
+ISOLATED_DOMAIN_NAME = "isolated.com"
+
+VPC_DOMAIN_NAME = "vpc.com"
+
 
 class TestNuageInternalDns(nuageTestCase):
     DNS = "06"
@@ -98,6 +104,33 @@ def verify_vsd_dhcp_option(self, dhcp_type, value, subnet_or_vm_interface,
         self.debug("Successfully verified the creation and value of DHCP "
                    "option type - %s in VSD" % dhcp_type)
 
+    def vm_verify_ping(self, src_vm, public_ip, dst_vm, domain_name):
+        if self.isSimulator:
+            self.debug("Simulator Environment: not verifying ping.")
+            return
+
+        src_vm.ssh_ip = public_ip
+        src_vm.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
+        src_vm.username = self.test_data["virtual_machine"]["username"]
+        src_vm.password = self.test_data["virtual_machine"]["password"]
+        self.debug("SSHing into VM: %s with %s" %
+                   (src_vm.ssh_ip, src_vm.password))
+
+        ssh = self.ssh_into_VM(src_vm, public_ip)
+
+        cmd = 'ping -c 2 ' + dst_vm.name
+        self.debug("ping vm2 by hostname with command: " + cmd)
+        outputlist = ssh.execute(cmd)
+        self.debug("command is executed properly " + cmd)
+        completeoutput = str(outputlist).strip('[]')
+        self.debug("complete output is " + completeoutput)
+        expectedlist = ['2 received', dst_vm.name + '.' + domain_name, dst_vm.ipaddress]
+        for item in expectedlist:
+            if item in completeoutput:
+                self.debug("excepted value found in vm: " + item)
+            else:
+                self.fail("excepted value not found in vm: " + item)
+
     @attr(tags=["advanced", "nuagevsp"], required_hardware="false")
     def test_01_Isolated_Network_with_zone(self):
         """ Verify InternalDns on Isolated Network
@@ -113,7 +146,7 @@ def test_01_Isolated_Network_with_zone(self):
         # update Network Domain at zone level
         cmd = updateZone.updateZoneCmd()
         cmd.id = self.zone.id
-        cmd.domain = "isolated.com"
+        cmd.domain = ISOLATED_DOMAIN_NAME
         self.apiclient.updateZone(cmd)
         self.debug("Creating and enabling Nuage Vsp Isolated Network "
                    "offering...")
@@ -130,11 +163,11 @@ def test_01_Isolated_Network_with_zone(self):
 
         # Internal DNS check point on VSD
         self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
-        self.verify_vsd_dhcp_option(self.DOMAINNAME, "isolated.com", network_1)
+        self.verify_vsd_dhcp_option(self.DOMAINNAME, ISOLATED_DOMAIN_NAME, network_1)
         for nic in vm_1.nic:
             self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
             self.verify_vsd_dhcp_option(
-                self.DOMAINNAME, "isolated.com", nic, True)
+                self.DOMAINNAME, ISOLATED_DOMAIN_NAME, nic, True)
             self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
 
     @attr(tags=["advanced", "nuagevsp"], required_hardware="true")
@@ -153,7 +186,7 @@ def test_02_Isolated_Network(self):
 
         cmd = updateZone.updateZoneCmd()
         cmd.id = self.zone.id
-        cmd.domain = "isolated.com"
+        cmd.domain = ISOLATED_DOMAIN_NAME
         self.apiclient.updateZone(cmd)
 
         self.debug("Creating and enabling Nuage Vsp Isolated Network "
@@ -171,11 +204,11 @@ def test_02_Isolated_Network(self):
 
         # Internal DNS check point on VSD
         self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
-        self.verify_vsd_dhcp_option(self.DOMAINNAME, "isolated.com", network_1)
+        self.verify_vsd_dhcp_option(self.DOMAINNAME, ISOLATED_DOMAIN_NAME, network_1)
         for nic in vm_1.nic:
             self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
             self.verify_vsd_dhcp_option(
-                self.DOMAINNAME, "isolated.com", nic, True)
+                self.DOMAINNAME, ISOLATED_DOMAIN_NAME, nic, True)
             self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
 
         self.test_data["virtual_machine"]["displayname"] = "vm2"
@@ -187,39 +220,13 @@ def test_02_Isolated_Network(self):
         for nic in vm_2.nic:
             self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
             self.verify_vsd_dhcp_option(
-                self.DOMAINNAME, "isolated.com", nic, True)
+                self.DOMAINNAME, ISOLATED_DOMAIN_NAME, nic, True)
             self.verify_vsd_dhcp_option(self.HOSTNAME, "vm2", nic, True)
 
         public_ip_1 = self.acquire_PublicIPAddress(network_1)
         self.create_and_verify_fw(vm_1, public_ip_1, network_1)
 
-        vm_public_ip = public_ip_1.ipaddress.ipaddress
-
-        try:
-            vm_1.ssh_ip = vm_public_ip
-            vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
-            vm_1.username = self.test_data["virtual_machine"]["username"]
-            vm_1.password = self.test_data["virtual_machine"]["password"]
-            self.debug("SSHing into VM: %s with %s" %
-                       (vm_1.ssh_ip, vm_1.password))
-
-            ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
-
-        except Exception as e:
-            self.fail("SSH into VM failed with exception %s" % e)
-
-        cmd = 'ping -c 2 vm2'
-        self.debug("ping vm2 by hostname with command: " + cmd)
-        outputlist = ssh.execute(cmd)
-        self.debug("command is executed properly " + cmd)
-        completeoutput = str(outputlist).strip('[]')
-        self.debug("complete output is " + completeoutput)
-        expectedlist = ['2 received', 'vm2.isolated.com', vm_2.ipaddress]
-        for item in expectedlist:
-            if item in completeoutput:
-                self.debug("excepted value found in vm: " + item)
-            else:
-                self.fail("excepted value not found in vm: " + item)
+        self.vm_verify_ping(vm_1, public_ip_1, vm_2, ISOLATED_DOMAIN_NAME)
 
     @attr(tags=["advanced", "nuagevsp"], required_hardware="true")
     def test_03_Isolated_Network_restarts(self):
@@ -239,7 +246,7 @@ def test_03_Isolated_Network_restarts(self):
 
         cmd = updateZone.updateZoneCmd()
         cmd.id = self.zone.id
-        cmd.domain = "isolated.com"
+        cmd.domain = ISOLATED_DOMAIN_NAME
         self.apiclient.updateZone(cmd)
 
         self.debug("Creating and enabling Nuage Vsp Isolated Network "
@@ -257,11 +264,11 @@ def test_03_Isolated_Network_restarts(self):
 
         # Internal DNS check point on VSD
         self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
-        self.verify_vsd_dhcp_option(self.DOMAINNAME, "isolated.com", network_1)
+        self.verify_vsd_dhcp_option(self.DOMAINNAME, ISOLATED_DOMAIN_NAME, network_1)
         for nic in vm_1.nic:
             self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
             self.verify_vsd_dhcp_option(
-                self.DOMAINNAME, "isolated.com", nic, True)
+                self.DOMAINNAME, ISOLATED_DOMAIN_NAME, nic, True)
             self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
 
         self.test_data["virtual_machine"]["displayname"] = "vm2"
@@ -273,40 +280,13 @@ def test_03_Isolated_Network_restarts(self):
         for nic in vm_2.nic:
             self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
             self.verify_vsd_dhcp_option(
-                self.DOMAINNAME, "isolated.com", nic, True)
+                self.DOMAINNAME, ISOLATED_DOMAIN_NAME, nic, True)
             self.verify_vsd_dhcp_option(self.HOSTNAME, "vm2", nic, True)
 
         public_ip_1 = self.acquire_PublicIPAddress(network_1)
         self.create_and_verify_fw(vm_1, public_ip_1, network_1)
 
-        vm_public_ip = public_ip_1.ipaddress.ipaddress
-
-        try:
-            vm_1.ssh_ip = vm_public_ip
-            vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
-            vm_1.username = self.test_data["virtual_machine"]["username"]
-            vm_1.password = self.test_data["virtual_machine"]["password"]
-            self.debug("SSHing into VM: %s with %s" %
-                       (vm_1.ssh_ip, vm_1.password))
-
-            ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
-
-        except Exception as e:
-            self.fail("SSH into VM failed with exception %s" % e)
-
-        time.sleep(30)
-        cmd = 'ping -c 2 vm2'
-        self.debug("ping vm2 by hostname with command: " + cmd)
-        outputlist = ssh.execute(cmd)
-        self.debug("command is executed properly " + cmd)
-        completeoutput = str(outputlist).strip('[]')
-        self.debug("complete output is " + completeoutput)
-        expectedlist = ['2 received', 'vm2.isolated.com', vm_2.ipaddress]
-        for item in expectedlist:
-            if item in completeoutput:
-                self.debug("excepted value found in vm: " + item)
-            else:
-                self.fail("excepted value not found in vm: " + item)
+        self.vm_verify_ping(vm_1, public_ip_1, vm_2, ISOLATED_DOMAIN_NAME)
 
         # Restarting Isolated network (cleanup = false)
         self.debug("Restarting the created Isolated network without "
@@ -324,31 +304,7 @@ def test_03_Isolated_Network_restarts(self):
         self.verify_vsd_vm(vm_1)
         self.verify_vsd_vm(vm_2)
 
-        try:
-            vm_1.ssh_ip = vm_public_ip
-            vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
-            vm_1.username = self.test_data["virtual_machine"]["username"]
-            vm_1.password = self.test_data["virtual_machine"]["password"]
-            self.debug("SSHing into VM: %s with %s" %
-                       (vm_1.ssh_ip, vm_1.password))
-
-            ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
-
-        except Exception as e:
-            self.fail("SSH into VM failed with exception %s" % e)
-
-        cmd = 'ping -c 2 vm2'
-        self.debug("ping vm2 by hostname with command: " + cmd)
-        outputlist = ssh.execute(cmd)
-        self.debug("command is executed properly " + cmd)
-        completeoutput = str(outputlist).strip('[]')
-        self.debug("complete output is " + completeoutput)
-        expectedlist = ['2 received', 'vm2.isolated.com', vm_2.ipaddress]
-        for item in expectedlist:
-            if item in completeoutput:
-                self.debug("excepted value found in vm: " + item)
-            else:
-                self.fail("excepted value not found in vm: " + item)
+        self.vm_verify_ping(vm_1, public_ip_1, vm_2, ISOLATED_DOMAIN_NAME)
 
         # Restarting Isolated network (cleanup = true)
         self.debug("Restarting the created Isolated network with cleanup...")
@@ -365,31 +321,7 @@ def test_03_Isolated_Network_restarts(self):
         self.verify_vsd_vm(vm_1)
         self.verify_vsd_vm(vm_2)
 
-        try:
-            vm_1.ssh_ip = vm_public_ip
-            vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
-            vm_1.username = self.test_data["virtual_machine"]["username"]
-            vm_1.password = self.test_data["virtual_machine"]["password"]
-            self.debug("SSHing into VM: %s with %s" %
-                       (vm_1.ssh_ip, vm_1.password))
-
-            ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
-
-        except Exception as e:
-            self.fail("SSH into VM failed with exception %s" % e)
-
-        cmd = 'ping -c 2 vm2'
-        self.debug("ping vm2 by hostname with command: " + cmd)
-        outputlist = ssh.execute(cmd)
-        self.debug("command is executed properly " + cmd)
-        completeoutput = str(outputlist).strip('[]')
-        self.debug("complete output is " + completeoutput)
-        expectedlist = ['2 received', 'vm2.isolated.com', vm_2.ipaddress]
-        for item in expectedlist:
-            if item in completeoutput:
-                self.debug("excepted value found in vm: " + item)
-            else:
-                self.fail("excepted value not found in vm: " + item)
+        self.vm_verify_ping(vm_1, public_ip_1, vm_2, ISOLATED_DOMAIN_NAME)
 
     @attr(tags=["advanced", "nuagevsp"], required_hardware="false")
     def test_04_Update_Network_with_Domain(self):
@@ -407,7 +339,7 @@ def test_04_Update_Network_with_Domain(self):
         # update Network Domain at zone level
         cmd = updateZone.updateZoneCmd()
         cmd.id = self.zone.id
-        cmd.domain = "isolated.com"
+        cmd.domain = ISOLATED_DOMAIN_NAME
         self.apiclient.updateZone(cmd)
 
         self.debug("Creating and enabling Nuage Vsp Isolated Network "
@@ -429,23 +361,23 @@ def test_04_Update_Network_with_Domain(self):
         for nic in vm_1.nic:
             self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
             self.verify_vsd_dhcp_option(
-                self.DOMAINNAME, "isolated.com", nic, True)
+                self.DOMAINNAME, ISOLATED_DOMAIN_NAME, nic, True)
             self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
 
         update_response = Network.update(
             network_1, self.apiclient, id=network_1.id,
-            networkdomain="update.com", changecidr=False)
+            networkdomain=UPDATED_DOMAIN_NAME, changecidr=False)
         completeoutput = str(update_response).strip('[]')
         self.debug("network update response is " + completeoutput)
-        self.assertEqual("update.com", update_response.networkdomain,
+        self.assertEqual(UPDATED_DOMAIN_NAME, update_response.networkdomain,
                          "Network Domain is not updated as expected"
                          )
         self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
-        self.verify_vsd_dhcp_option(self.DOMAINNAME, "update.com", network_1)
+        self.verify_vsd_dhcp_option(self.DOMAINNAME, UPDATED_DOMAIN_NAME, network_1)
         for nic in vm_1.nic:
             self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
             self.verify_vsd_dhcp_option(
-                self.DOMAINNAME, "update.com", nic, True)
+                self.DOMAINNAME, UPDATED_DOMAIN_NAME, nic, True)
             self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
 
     @attr(tags=["advanced", "nuagevsp"], required_hardware="true")
@@ -465,7 +397,7 @@ def test_05_Update_Network_with_Domain(self):
         # update Network Domain at zone level
         cmd = updateZone.updateZoneCmd()
         cmd.id = self.zone.id
-        cmd.domain = "isolated.com"
+        cmd.domain = ISOLATED_DOMAIN_NAME
         self.apiclient.updateZone(cmd)
 
         self.debug("Creating and enabling Nuage Vsp Isolated Network "
@@ -484,27 +416,27 @@ def test_05_Update_Network_with_Domain(self):
         # Internal DNS check point on VSD
         self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
         self.verify_vsd_dhcp_option(
-            self.DOMAINNAME, "isolated.com", network_1)
+            self.DOMAINNAME, ISOLATED_DOMAIN_NAME, network_1)
         for nic in vm_1.nic:
             self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
             self.verify_vsd_dhcp_option(
-                self.DOMAINNAME, "isolated.com", nic, True)
+                self.DOMAINNAME, ISOLATED_DOMAIN_NAME, nic, True)
             self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
 
         update_response = Network.update(
             network_1, self.apiclient, id=network_1.id,
-            networkdomain="update.com", changecidr=False)
+            networkdomain=UPDATED_DOMAIN_NAME, changecidr=False)
         completeoutput = str(update_response).strip('[]')
         self.debug("network update response is " + completeoutput)
-        self.assertEqual("update.com", update_response.networkdomain,
+        self.assertEqual(UPDATED_DOMAIN_NAME, update_response.networkdomain,
                          "Network Domain is not updated as expected"
                          )
         self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
-        self.verify_vsd_dhcp_option(self.DOMAINNAME, "update.com", network_1)
+        self.verify_vsd_dhcp_option(self.DOMAINNAME, UPDATED_DOMAIN_NAME, network_1)
         for nic in vm_1.nic:
             self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
             self.verify_vsd_dhcp_option(
-                self.DOMAINNAME, "update.com", nic, True)
+                self.DOMAINNAME, UPDATED_DOMAIN_NAME, nic, True)
             self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
 
         # stop and start VM to get new DHCP option
@@ -522,7 +454,7 @@ def test_05_Update_Network_with_Domain(self):
         for nic in vm_2.nic:
             self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
             self.verify_vsd_dhcp_option(
-                self.DOMAINNAME, "update.com", nic, True)
+                self.DOMAINNAME, UPDATED_DOMAIN_NAME, nic, True)
             self.verify_vsd_dhcp_option(self.HOSTNAME, "vm2", nic, True)
 
         try:
@@ -533,33 +465,7 @@ def test_05_Update_Network_with_Domain(self):
         public_ip_1 = self.acquire_PublicIPAddress(network_1)
         self.create_and_verify_fw(vm_1, public_ip_1, network_1)
 
-        vm_public_ip = public_ip_1.ipaddress.ipaddress
-
-        try:
-            vm_1.ssh_ip = vm_public_ip
-            vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
-            vm_1.username = self.test_data["virtual_machine"]["username"]
-            vm_1.password = self.test_data["virtual_machine"]["password"]
-            self.debug("SSHing into VM: %s with %s" %
-                       (vm_1.ssh_ip, vm_1.password))
-
-            ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
-
-        except Exception as e:
-            self.fail("SSH into VM failed with exception: %s " % e)
-
-        cmd = 'ping -c 2 vm2'
-        self.debug("ping vm2 by hostname with command: " + cmd)
-        outputlist = ssh.execute(cmd)
-        self.debug("command is executed properly " + cmd)
-        completeoutput = str(outputlist).strip('[]')
-        self.debug("complete output is " + completeoutput)
-        expectedlist = ['2 received', 'vm2.update.com', vm_2.ipaddress]
-        for item in expectedlist:
-            if item in completeoutput:
-                self.debug("excepted value found in vm: " + item)
-            else:
-                self.fail("excepted value not found in vm: " + item)
+        self.vm_verify_ping(vm_1,  public_ip_1, vm_2, UPDATED_DOMAIN_NAME)
 
     @attr(tags=["advanced", "nuagevsp"], required_hardware="false")
     def test_06_VPC_Network_With_InternalDns(self):
@@ -571,10 +477,9 @@ def test_06_VPC_Network_With_InternalDns(self):
         # 2. Deploy vm1 in tier network.
         # 3. Verify dhcp option 06 and 0f for subnet
         # 4. Verify dhcp option 06,15 and 0f for vm Interface.
-
         cmd = updateZone.updateZoneCmd()
         cmd.id = self.zone.id
-        cmd.domain = "vpc.com"
+        cmd.domain = VPC_DOMAIN_NAME
         self.apiclient.updateZone(cmd)
         vpc_off = self.create_VpcOffering(self.dnsdata["vpc_offering"])
         self.validate_VpcOffering(vpc_off, state="Enabled")
@@ -596,10 +501,10 @@ def test_06_VPC_Network_With_InternalDns(self):
 
         # Internal DNS check point on VSD
         self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
-        self.verify_vsd_dhcp_option(self.DOMAINNAME, "vpc.com", network_1)
+        self.verify_vsd_dhcp_option(self.DOMAINNAME, VPC_DOMAIN_NAME, network_1)
         for nic in vm_1.nic:
             self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
-            self.verify_vsd_dhcp_option(self.DOMAINNAME, "vpc.com", nic, True)
+            self.verify_vsd_dhcp_option(self.DOMAINNAME, VPC_DOMAIN_NAME, nic, True)
             self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
 
     @attr(tags=["advanced", "nuagevsp"], required_hardware="true")
@@ -617,7 +522,7 @@ def test_07_VPC_Network_With_InternalDns(self):
 
         cmd = updateZone.updateZoneCmd()
         cmd.id = self.zone.id
-        cmd.domain = "vpc.com"
+        cmd.domain = VPC_DOMAIN_NAME
         self.apiclient.updateZone(cmd)
 
         vpc_off = self.create_VpcOffering(self.dnsdata["vpc_offering"])
@@ -641,7 +546,7 @@ def test_07_VPC_Network_With_InternalDns(self):
         self.verify_vsd_dhcp_option(self.DOMAINNAME, "vpc.com", network_1)
         for nic in vm_1.nic:
             self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
-            self.verify_vsd_dhcp_option(self.DOMAINNAME, "vpc.com", nic, True)
+            self.verify_vsd_dhcp_option(self.DOMAINNAME, VPC_DOMAIN_NAME, nic, True)
             self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
 
         self.test_data["virtual_machine"]["displayname"] = "vm2"
@@ -652,7 +557,7 @@ def test_07_VPC_Network_With_InternalDns(self):
         self.verify_vsd_vm(vm_2)
         for nic in vm_2.nic:
             self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
-            self.verify_vsd_dhcp_option(self.DOMAINNAME, "vpc.com", nic, True)
+            self.verify_vsd_dhcp_option(self.DOMAINNAME, VPC_DOMAIN_NAME, nic, True)
             self.verify_vsd_dhcp_option(self.HOSTNAME, "vm2", nic, True)
 
         public_ip_1 = self.acquire_PublicIPAddress(network_1, vpc)
@@ -665,33 +570,7 @@ def test_07_VPC_Network_With_InternalDns(self):
 
         # VSD verification
         self.verify_vsd_firewall_rule(public_ssh_rule)
-        vm_public_ip = public_ip_1.ipaddress.ipaddress
-
-        try:
-            vm_1.ssh_ip = vm_public_ip
-            vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
-            vm_1.username = self.test_data["virtual_machine"]["username"]
-            vm_1.password = self.test_data["virtual_machine"]["password"]
-            self.debug("SSHing into VM: %s with %s" %
-                       (vm_1.ssh_ip, vm_1.password))
-
-            ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
-
-        except Exception as e:
-            self.fail("SSH into VM failed with exception %s" % e)
-
-        cmd = 'ping -c 2 vm2'
-        self.debug("ping vm2 by hostname with command: " + cmd)
-        outputlist = ssh.execute(cmd)
-        self.debug("command is executed properly " + cmd)
-        completeoutput = str(outputlist).strip('[]')
-        self.debug("complete output is " + completeoutput)
-        expectedlist = ['2 received', 'vm2.vpc.com', vm_2.ipaddress]
-        for item in expectedlist:
-            if item in completeoutput:
-                self.debug("excepted value found in vm: " + item)
-            else:
-                self.fail("excepted value not found in vm: " + item)
+        self.vm_verify_ping(vm_1, public_ip_1, vm_2, VPC_DOMAIN_NAME)
 
     @attr(tags=["advanced", "nuagevsp"], required_hardware="true")
     def test_08_VPC_Network_Restarts_With_InternalDns(self):
@@ -710,7 +589,7 @@ def test_08_VPC_Network_Restarts_With_InternalDns(self):
 
         cmd = updateZone.updateZoneCmd()
         cmd.id = self.zone.id
-        cmd.domain = "vpc.com"
+        cmd.domain = VPC_DOMAIN_NAME
         self.apiclient.updateZone(cmd)
 
         vpc_off = self.create_VpcOffering(self.dnsdata["vpc_offering"])
@@ -731,10 +610,10 @@ def test_08_VPC_Network_Restarts_With_InternalDns(self):
         self.verify_vsd_vm(vm_1)
         # Internal DNS check point on VSD
         self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", network_1)
-        self.verify_vsd_dhcp_option(self.DOMAINNAME, "vpc.com", network_1)
+        self.verify_vsd_dhcp_option(self.DOMAINNAME, VPC_DOMAIN_NAME, network_1)
         for nic in vm_1.nic:
             self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
-            self.verify_vsd_dhcp_option(self.DOMAINNAME, "vpc.com", nic, True)
+            self.verify_vsd_dhcp_option(self.DOMAINNAME, VPC_DOMAIN_NAME, nic, True)
             self.verify_vsd_dhcp_option(self.HOSTNAME, "vm1", nic, True)
 
         self.test_data["virtual_machine"]["displayname"] = "vm2"
@@ -745,7 +624,7 @@ def test_08_VPC_Network_Restarts_With_InternalDns(self):
         self.verify_vsd_vm(vm_2)
         for nic in vm_2.nic:
             self.verify_vsd_dhcp_option(self.DNS, "10.1.1.2", nic, True)
-            self.verify_vsd_dhcp_option(self.DOMAINNAME, "vpc.com", nic, True)
+            self.verify_vsd_dhcp_option(self.DOMAINNAME, VPC_DOMAIN_NAME, nic, True)
             self.verify_vsd_dhcp_option(self.HOSTNAME, "vm2", nic, True)
 
         public_ip_1 = self.acquire_PublicIPAddress(network_1, vpc)
@@ -758,33 +637,8 @@ def test_08_VPC_Network_Restarts_With_InternalDns(self):
 
         # VSD verification
         self.verify_vsd_firewall_rule(public_ssh_rule)
-        vm_public_ip = public_ip_1.ipaddress.ipaddress
-
-        try:
-            vm_1.ssh_ip = vm_public_ip
-            vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
-            vm_1.username = self.test_data["virtual_machine"]["username"]
-            vm_1.password = self.test_data["virtual_machine"]["password"]
-            self.debug("SSHing into VM: %s with %s" %
-                       (vm_1.ssh_ip, vm_1.password))
 
-            ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
-
-        except Exception as e:
-            self.fail("SSH into VM failed with exception %s" % e)
-
-        cmd = 'ping -c 2 vm2'
-        self.debug("ping vm2 by hostname with command: " + cmd)
-        outputlist = ssh.execute(cmd)
-        self.debug("command is executed properly " + cmd)
-        completeoutput = str(outputlist).strip('[]')
-        self.debug("complete output is " + completeoutput)
-        expectedlist = ['2 received', 'vm2.vpc.com', vm_2.ipaddress]
-        for item in expectedlist:
-            if item in completeoutput:
-                self.debug("excepted value found in vm: " + item)
-            else:
-                self.fail("excepted value not found in vm: " + item)
+        self.vm_verify_ping(vm_1, public_ip_1, vm_2, VPC_DOMAIN_NAME)
 
         # Restarting VPC network (cleanup = false)
         self.debug("Restarting the created VPC network without cleanup...")
@@ -801,31 +655,7 @@ def test_08_VPC_Network_Restarts_With_InternalDns(self):
         self.verify_vsd_vm(vm_1)
         self.verify_vsd_vm(vm_2)
 
-        try:
-            vm_1.ssh_ip = vm_public_ip
-            vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
-            vm_1.username = self.test_data["virtual_machine"]["username"]
-            vm_1.password = self.test_data["virtual_machine"]["password"]
-            self.debug("SSHing into VM: %s with %s" %
-                       (vm_1.ssh_ip, vm_1.password))
-
-            ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
-
-        except Exception as e:
-            self.fail("SSH into VM failed with exception %s" % e)
-
-        cmd = 'ping -c 2 vm2'
-        self.debug("ping vm2 by hostname with command: " + cmd)
-        outputlist = ssh.execute(cmd)
-        self.debug("command is executed properly " + cmd)
-        completeoutput = str(outputlist).strip('[]')
-        self.debug("complete output is " + completeoutput)
-        expectedlist = ['2 received', 'vm2.vpc.com', vm_2.ipaddress]
-        for item in expectedlist:
-            if item in completeoutput:
-                self.debug("excepted value found in vm: " + item)
-            else:
-                self.fail("excepted value not found in vm: " + item)
+        self.vm_verify_ping(vm_1, public_ip_1, vm_2, VPC_DOMAIN_NAME)
 
         # Restarting VPC network (cleanup = true)
         self.debug("Restarting the created VPC network with cleanup...")
@@ -842,31 +672,7 @@ def test_08_VPC_Network_Restarts_With_InternalDns(self):
         self.verify_vsd_vm(vm_1)
         self.verify_vsd_vm(vm_2)
 
-        try:
-            vm_1.ssh_ip = vm_public_ip
-            vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
-            vm_1.username = self.test_data["virtual_machine"]["username"]
-            vm_1.password = self.test_data["virtual_machine"]["password"]
-            self.debug("SSHing into VM: %s with %s" %
-                       (vm_1.ssh_ip, vm_1.password))
-
-            ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
-
-        except Exception as e:
-            self.fail("SSH into VM failed with exception %s" % e)
-
-        cmd = 'ping -c 2 vm2'
-        self.debug("ping vm2 by hostname with command: " + cmd)
-        outputlist = ssh.execute(cmd)
-        self.debug("command is executed properly " + cmd)
-        completeoutput = str(outputlist).strip('[]')
-        self.debug("complete output is " + completeoutput)
-        expectedlist = ['2 received', 'vm2.vpc.com', vm_2.ipaddress]
-        for item in expectedlist:
-            if item in completeoutput:
-                self.debug("excepted value found in vm: " + item)
-            else:
-                self.fail("excepted value not found in vm: " + item)
+        self.vm_verify_ping(vm_1, public_ip_1, vm_2, VPC_DOMAIN_NAME)
 
         # Restarting VPC (cleanup = false)
         self.debug("Restarting the VPC without cleanup...")
@@ -882,31 +688,7 @@ def test_08_VPC_Network_Restarts_With_InternalDns(self):
         self.verify_vsd_router(vr)
         self.verify_vsd_vm(vm_1)
 
-        try:
-            vm_1.ssh_ip = vm_public_ip
-            vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
-            vm_1.username = self.test_data["virtual_machine"]["username"]
-            vm_1.password = self.test_data["virtual_machine"]["password"]
-            self.debug("SSHing into VM: %s with %s" %
-                       (vm_1.ssh_ip, vm_1.password))
-
-            ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
-
-        except Exception as e:
-            self.fail("SSH into VM failed with exception %s" % e)
-
-        cmd = 'ping -c 2 vm2'
-        self.debug("ping vm2 by hostname with command: " + cmd)
-        outputlist = ssh.execute(cmd)
-        self.debug("command is executed properly " + cmd)
-        completeoutput = str(outputlist).strip('[]')
-        self.debug("complete output is " + completeoutput)
-        expectedlist = ['2 received', 'vm2.vpc.com', vm_2.ipaddress]
-        for item in expectedlist:
-            if item in completeoutput:
-                self.debug("excepted value found in vm: " + item)
-            else:
-                self.fail("excepted value not found in vm: " + item)
+        self.vm_verify_ping(vm_1, public_ip_1, vm_2, VPC_DOMAIN_NAME)
 
         # Restarting VPC (cleanup = true)
         self.debug("Restarting the VPC with cleanup...")
@@ -922,31 +704,7 @@ def test_08_VPC_Network_Restarts_With_InternalDns(self):
         self.verify_vsd_router(vr)
         self.verify_vsd_vm(vm_1)
 
-        try:
-            vm_1.ssh_ip = vm_public_ip
-            vm_1.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
-            vm_1.username = self.test_data["virtual_machine"]["username"]
-            vm_1.password = self.test_data["virtual_machine"]["password"]
-            self.debug("SSHing into VM: %s with %s" %
-                       (vm_1.ssh_ip, vm_1.password))
-
-            ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
-
-        except Exception as e:
-            self.fail("SSH into VM failed with exception %s" % e)
-
-        cmd = 'ping -c 2 vm2'
-        self.debug("ping vm2 by hostname with command: " + cmd)
-        outputlist = ssh.execute(cmd)
-        self.debug("command is executed properly " + cmd)
-        completeoutput = str(outputlist).strip('[]')
-        self.debug("complete output is " + completeoutput)
-        expectedlist = ['2 received', 'vm2.vpc.com', vm_2.ipaddress]
-        for item in expectedlist:
-            if item in completeoutput:
-                self.debug("excepted value found in vm: " + item)
-            else:
-                self.fail("excepted value not found in vm: " + item)
+        self.vm_verify_ping(vm_1, public_ip_1, vm_2, VPC_DOMAIN_NAME)
 
     @attr(tags=["advanced", "nuagevsp"], required_hardware="true")
     def test_09_update_network_offering_isolated_network(self):
diff --git a/test/integration/plugins/nuagevsp/test_nuage_network_migration.py b/test/integration/plugins/nuagevsp/test_nuage_network_migration.py
index 5d64e4fdf5a..c79e758bc0b 100644
--- a/test/integration/plugins/nuagevsp/test_nuage_network_migration.py
+++ b/test/integration/plugins/nuagevsp/test_nuage_network_migration.py
@@ -31,29 +31,6 @@
 import re
 
 
-class Services:
-    """Test network services
-    """
-    def __init__(self):
-        self.services = {
-            "shared_network_offering": {
-                "name": "MySharedOffering-shared",
-                "displaytext": "MySharedOffering",
-                "guestiptype": "Shared",
-                "supportedservices": "Dhcp,Dns,UserData",
-                "specifyVlan": "True",
-                "specifyIpRanges": "True",
-                "traffictype": "GUEST",
-                "tags": "native",
-                "serviceProviderList": {
-                    "Dhcp": "VirtualRouter",
-                    "Dns": "VirtualRouter",
-                    "UserData": "VirtualRouter"
-                }
-            }
-        }
-
-
 class TestNuageMigration(nuageTestCase):
     """Test Native to Nuage Migration
     """
@@ -61,7 +38,6 @@ class TestNuageMigration(nuageTestCase):
     @classmethod
     def setUpClass(cls):
         super(TestNuageMigration, cls).setUpClass()
-        cls.services = Services().services
 
         if not hasattr(cls.vsp_physical_network, "tags") \
                 or cls.vsp_physical_network.tags != 'nuage':
diff --git a/test/integration/plugins/nuagevsp/test_nuage_password_reset.py b/test/integration/plugins/nuagevsp/test_nuage_password_reset.py
index 7973a3e2bae..28714a7d354 100644
--- a/test/integration/plugins/nuagevsp/test_nuage_password_reset.py
+++ b/test/integration/plugins/nuagevsp/test_nuage_password_reset.py
@@ -138,6 +138,10 @@ def stop_vm(self, vm):
     # cloud-set-guest-password script from people.apache.org in the given VM
     # (SSH client)
     def install_cloud_set_guest_password_script(self, ssh_client):
+        if self.isSimulator:
+            self.debug( "Simulator Environment: Skipping installing"
+                        " cloud-set-guest-password script")
+            return
         self.debug("Installing cloud-set-guest-password script")
         cmd = "cd /etc/init.d;wget http://people.apache.org/~tsp/" \
               "cloud-set-guest-password"
@@ -254,6 +258,10 @@ def test_nuage_UserDataPasswordReset(self):
             self.create_and_verify_fw(self.vm_1, public_ip_1, self.network)
             ssh = self.ssh_into_VM(self.vm_1, public_ip_1)
             user_data_cmd = self.get_userdata_url(self.vm_1)
+            if self.isSimulator:
+                self.debug("Simulator Environment: ending test early "
+                           "because we don't have real vms")
+                return
             self.debug("Getting user data with command: " + user_data_cmd)
             actual_user_data = base64.b64decode(self.execute_cmd
                                                 (ssh, user_data_cmd))
@@ -261,7 +269,7 @@ def test_nuage_UserDataPasswordReset(self):
                        ", Expected user data - " + expected_user_data)
             self.assertEqual(actual_user_data, expected_user_data,
                              "Un-expected VM (VM_1) user data"
-                             )
+                         )
 
             self.debug("Checking for cloud-set-guest-password script in the "
                        "VM for testing password reset functionality...")
@@ -269,6 +277,7 @@ def test_nuage_UserDataPasswordReset(self):
             ls_result = self.execute_cmd(ssh, ls_cmd)
             ls_result = ls_result.lower()
             self.debug("Response from ls_cmd: " + ls_result)
+
             if "no such file" in ls_result:
                 self.debug("No cloud-set-guest-password script in the VM")
                 self.debug("Installing the cloud-set-guest-password script "
diff --git a/test/integration/plugins/nuagevsp/test_nuage_public_sharednetwork_userdata.py b/test/integration/plugins/nuagevsp/test_nuage_public_sharednetwork_userdata.py
index 554741b1a98..afd99416647 100644
--- a/test/integration/plugins/nuagevsp/test_nuage_public_sharednetwork_userdata.py
+++ b/test/integration/plugins/nuagevsp/test_nuage_public_sharednetwork_userdata.py
@@ -409,7 +409,7 @@ def test_01_verify_deployvm_fail_startip_sharednetwork_scope_all(self):
         except Exception as e:
             self.debug("Deploy vm fails as expected with exception %s" % e)
             self.debug("Going to verify the exception message")
-            exceptionmsg = "it is reserved for the VR in network"
+            exceptionmsg = "Unable to start a VM due to insufficient capacity"
             if exceptionmsg in str(e):
                 self.debug("correct exception is raised")
             else:
@@ -819,8 +819,7 @@ def test_10_password_reset_public_sharednetwork_scope_all(self):
         """
         self.updateTemplate(True)
         self.debug("Deploy VM to shared Network scope as all")
-        self.test_data["virtual_machine"]["ipaddress"] = \
-            self.nuagenetworkdata["network_all"]["endip"]
+        self.test_data["virtual_machine"]["ipaddress"] = None
         vm_1 = self.create_VM(
             self.shared_network_all, account=self.account_d11a)
 
@@ -847,8 +846,7 @@ def test_11_password_reset_public_sharednetwork_scope_domain(self):
         """
         self.updateTemplate(True)
         self.debug("Deploy VM to shared Network scope as all")
-        self.test_data["virtual_machine"]["ipaddress"] = \
-            self.nuagenetworkdata["network_all"]["endip"]
+        self.test_data["virtual_machine"]["ipaddress"] = None
         vm_1 = self.create_VM(
             self.shared_network_domain_with_subdomain_d11,
             account=self.account_d11a)
@@ -876,8 +874,7 @@ def test_12_password_reset_public_sharednetwork_scope_account(self):
         """
         self.updateTemplate(True)
         self.debug("Deploy VM to shared Network scope as all")
-        self.test_data["virtual_machine"]["ipaddress"] = \
-            self.nuagenetworkdata["network_all"]["endip"]
+        self.test_data["virtual_machine"]["ipaddress"] = None
         vm_1 = self.create_VM(
             self.shared_network_account_d111a, account=self.account_d11a)
 
@@ -901,8 +898,6 @@ def test_13_public_sharednetwork_domain_cleanup(self):
         """
 
         try:
-            self.test_data["virtual_machine"]["ipaddress"] = \
-                self.nuagenetworkdata["network_all"]["endip"]
             vm_1 = self.create_VM(
                 self.shared_network_domain_with_subdomain_d11,
                 account=self.account_d11a)
diff --git a/test/integration/plugins/nuagevsp/test_nuage_source_nat.py b/test/integration/plugins/nuagevsp/test_nuage_source_nat.py
index 2d9e3b9fb8a..6b53d2d533d 100644
--- a/test/integration/plugins/nuagevsp/test_nuage_source_nat.py
+++ b/test/integration/plugins/nuagevsp/test_nuage_source_nat.py
@@ -140,12 +140,15 @@ def verify_SourceNAT_VM_traffic(self, vm, network, vpc=None,
             self.verify_vsd_firewall_rule(public_ssh_rule)
 
             # Checking for wget file
-            ssh_client = self.ssh_into_VM(vm, public_ip)
-            cmd = "ls /"
-            file_list = self.execute_cmd(ssh_client, cmd)
-            if "index.html" in str(file_list):
-                cmd = "rm -rf /index.html*"
-                self.execute_cmd(ssh_client, cmd)
+            is_in_file_list = None
+            if not self.isSimulator:
+                ssh_client = self.ssh_into_VM(vm, public_ip)
+                cmd = "ls /"
+                file_list = self.execute_cmd(ssh_client, cmd)
+                is_in_file_list = "index.html" in str(file_list)
+                if is_in_file_list:
+                    cmd = "rm -rf /index.html*"
+                    self.execute_cmd(ssh_client, cmd)
 
             # Removing Ingress Firewall/Network ACL rule
             self.debug("Removing the created Ingress Firewall/Network ACL "
@@ -194,11 +197,11 @@ def verify_SourceNAT_VM_traffic(self, vm, network, vpc=None,
                            "VSD")
 
             # Final test result
-            if "index.html" in str(file_list):
+            if is_in_file_list:
                 self.debug("Successfully verified Source NAT traffic "
                            "(wget www.google.com) to the Internet from VM - %s"
                            % vm.name)
-            else:
+            elif not self.isSimulator:
                 self.fail("Failed to verify Source NAT traffic "
                           "(wget www.google.com) to the Internet from VM - %s"
                           % vm.name)
diff --git a/test/integration/plugins/nuagevsp/test_nuage_static_nat.py b/test/integration/plugins/nuagevsp/test_nuage_static_nat.py
index 3aa36d1da1e..e611b97ae08 100644
--- a/test/integration/plugins/nuagevsp/test_nuage_static_nat.py
+++ b/test/integration/plugins/nuagevsp/test_nuage_static_nat.py
@@ -112,6 +112,10 @@ def validate_NuageUnderlayPublicIpRange(self, public_ip_range):
     # server running on the corresponding VM in the given network
     def verify_StaticNAT_traffic(self, network, public_ip, vpc=None,
                                  non_default_nic=False):
+        if self.isSimulator:
+            self.debug("Simulator Environment: skipping static nat"
+                       "traffic tests.")
+            return
         # Adding Ingress Firewall/Network ACL rule
         self.debug("Adding Ingress Firewall/Network ACL rule to make the "
                    "created Static NAT rule (wget) accessible...")
@@ -186,6 +190,11 @@ def wget_from_Internet(self, ssh_client, timeout):
     def verify_StaticNAT_Internet_traffic(self, vm, network, public_ip,
                                           vpc=None, non_default_nic=False,
                                           negative_test=False):
+        if self.isSimulator and not negative_test:
+            self.debug("Simulator Environment: not verifying internet traffic")
+            return
+        elif self.isSimulator:
+            raise Exception("Simulator simulating exception")
         # Adding Ingress Firewall/Network ACL rule
         self.debug("Adding Ingress Firewall/Network ACL rule to make the "
                    "created Static NAT rule (SSH) accessible...")
@@ -1677,15 +1686,17 @@ def test_08_nuage_StaticNAT_vm_nic_operations_traffic(self):
         self.verify_vsd_floating_ip(network_2, vm, public_ip_2.ipaddress)
 
         # Verifying Static NAT traffic
-        with self.assertRaises(AssertionError):
-            self.verify_StaticNAT_traffic(network_1, public_ip_1)
+        if not self.isSimulator:
+            with self.assertRaises(AssertionError):
+                self.verify_StaticNAT_traffic(network_1, public_ip_1)
         self.debug("Static NAT rule not enabled in this VM NIC")
         self.verify_StaticNAT_traffic(network_2, public_ip_2)
 
         # Verifying Static NAT traffic (wget www.google.com) to the Internet
         # from the deployed VM
-        with self.assertRaises(Exception):
-            self.verify_StaticNAT_Internet_traffic(vm, network_1, public_ip_1)
+        if not self.isSimulator:
+            with self.assertRaises(Exception):
+                self.verify_StaticNAT_Internet_traffic(vm, network_1, public_ip_1)
         self.debug("Static NAT rule not enabled in this VM NIC")
         self.verify_StaticNAT_Internet_traffic(vm, network_2, public_ip_2)
 
diff --git a/test/integration/plugins/nuagevsp/test_nuage_vpc_internal_lb.py b/test/integration/plugins/nuagevsp/test_nuage_vpc_internal_lb.py
index 3e7080b0739..f80dcb5cb5e 100644
--- a/test/integration/plugins/nuagevsp/test_nuage_vpc_internal_lb.py
+++ b/test/integration/plugins/nuagevsp/test_nuage_vpc_internal_lb.py
@@ -171,6 +171,10 @@ def check_InternalLbVm_state(self, network, source_ip, state=None):
     # verify_vpc_vm_ingress_traffic - Verifies ingress traffic to the given VM
     # (SSH into VM) via a created Static NAT rule in the given VPC network
     def verify_vpc_vm_ingress_traffic(self, vm, network, vpc):
+        if self.isSimulator:
+            self.debug("Simulator Environment: "
+                       "skipping vpc vm ingress traffic tests.")
+            return
         self.debug("Verifying ingress traffic to the VM (SSH into VM) - %s "
                    "via a created Static NAT rule in the VPC network - %s" %
                    (vm, network))
@@ -236,6 +240,9 @@ def verify_vpc_vm_ingress_traffic(self, vm, network, vpc):
     # wget_from_vm_cmd - From within the given VM (ssh client),
     # fetches index.html file of web server running with the given public IP
     def wget_from_vm_cmd(self, ssh_client, ip_address, port):
+        if self.isSimulator:
+            self.debug("Simulator Environment: not wgeting from vm cmd.")
+            return
         wget_file = ""
         cmd = "rm -rf index.html*"
         self.execute_cmd(ssh_client, cmd)
@@ -260,6 +267,9 @@ def wget_from_vm_cmd(self, ssh_client, ip_address, port):
     # belongs to the given Internal LB rule
     # assigned VMs (vm array)
     def verify_lb_wget_file(self, wget_file, vm_array):
+        if self.isSimulator:
+            self.debug("Simulator Environment: not verifying file on vm.")
+            return
         wget_server_ip = None
         for vm in vm_array:
             for nic in vm.nic:
@@ -1406,6 +1416,10 @@ def test_05_nuage_internallb_traffic(self):
         # VSD verification
         self.verify_vsd_firewall_rule(public_ssh_rule)
 
+        if self.isSimulator:
+            self.debug("Simulator Environment: skipping traffic tests.")
+            return
+
         # Internal LB (wget) traffic tests
         ssh_client = self.ssh_into_VM(public_vm, public_ip)
         wget_file_1 = self.wget_from_vm_cmd(
@@ -1663,6 +1677,10 @@ def test_06_nuage_internallb_algorithms_traffic(self):
         # VSD verification
         self.verify_vsd_firewall_rule(public_ssh_rule)
 
+        if self.isSimulator:
+            self.debug("Simulator Environment: skipping traffic tests.")
+            return
+
         # Internal LB (wget) traffic tests with Round Robin Algorithm
         ssh_client = self.ssh_into_VM(public_vm, public_ip)
         self.validate_internallb_algorithm_traffic(
@@ -1863,14 +1881,8 @@ def test_07_nuage_internallb_vpc_network_restarts_traffic(self):
         self.verify_vsd_firewall_rule(public_ssh_rule)
 
         # Internal LB (wget) traffic test
-        ssh_client = self.ssh_into_VM(public_vm, public_ip)
-        wget_file = self.wget_from_vm_cmd(
-            ssh_client, int_lb_rule_1.sourceipaddress,
-            self.test_data["http_rule"]["publicport"])
-
-        # Verifying Internal LB (wget) traffic test
-        self.verify_lb_wget_file(
-            wget_file, [internal_vm, internal_vm_1, internal_vm_2])
+        self.verify_internal_lb_wget_traffic(int_lb_rule_1, internal_vm, internal_vm_1,
+                                             internal_vm_2, public_ip, public_vm)
 
         # Restart Internal tier (cleanup = false)
         # InternalLbVm gets destroyed and deployed again in the Internal tier
@@ -1909,23 +1921,8 @@ def test_07_nuage_internallb_vpc_network_restarts_traffic(self):
         self.verify_vpc_vm_ingress_traffic(internal_vm_2, internal_tier, vpc)
 
         # Internal LB (wget) traffic test
-        ssh_client = self.ssh_into_VM(public_vm, public_ip)
-        tries = 0
-        while tries < 120:
-            wget_file = self.wget_from_vm_cmd(
-                ssh_client, int_lb_rule_1.sourceipaddress,
-                self.test_data["http_rule"]["publicport"])
-            if wget_file != "":
-                break
-            self.debug("Waiting for the InternalLbVm in the Internal tier to "
-                       "be fully resolved for (wget) traffic test...")
-            time.sleep(5)
-            tries += 1
-
-        # Verifying Internal LB (wget) traffic test
-        self.verify_lb_wget_file(
-            wget_file, [internal_vm, internal_vm_1, internal_vm_2])
-
+        self.verify_internal_lb_wget_traffic(int_lb_rule_1, internal_vm, internal_vm_1,
+                                             internal_vm_2, public_ip, public_vm)
         # Restart Internal tier (cleanup = true)
         # InternalLbVm gets destroyed and deployed again in the Internal tier
         self.debug("Restarting the Internal tier with cleanup...")
@@ -1963,22 +1960,8 @@ def test_07_nuage_internallb_vpc_network_restarts_traffic(self):
         self.verify_vpc_vm_ingress_traffic(internal_vm_2, internal_tier, vpc)
 
         # Internal LB (wget) traffic test
-        ssh_client = self.ssh_into_VM(public_vm, public_ip)
-        tries = 0
-        while tries < 120:
-            wget_file = self.wget_from_vm_cmd(
-                ssh_client, int_lb_rule_1.sourceipaddress,
-                self.test_data["http_rule"]["publicport"])
-            if wget_file != "":
-                break
-            self.debug("Waiting for the InternalLbVm in the Internal tier to "
-                       "be fully resolved for (wget) traffic test...")
-            time.sleep(5)
-            tries += 1
-
-        # Verifying Internal LB (wget) traffic test
-        self.verify_lb_wget_file(
-            wget_file, [internal_vm, internal_vm_1, internal_vm_2])
+        self.verify_internal_lb_wget_traffic(int_lb_rule_1, internal_vm, internal_vm_1,
+                                             internal_vm_2, public_ip, public_vm)
 
         # Restart Public tier (cleanup = false)
         # This restart has no effect on the InternalLbVm functionality
@@ -2057,14 +2040,8 @@ def test_07_nuage_internallb_vpc_network_restarts_traffic(self):
         self.verify_vpc_vm_ingress_traffic(internal_vm_2, internal_tier, vpc)
 
         # Internal LB (wget) traffic test
-        ssh_client = self.ssh_into_VM(public_vm, public_ip)
-        wget_file = self.wget_from_vm_cmd(
-            ssh_client, int_lb_rule_1.sourceipaddress,
-            self.test_data["http_rule"]["publicport"])
-
-        # Verifying Internal LB (wget) traffic test
-        self.verify_lb_wget_file(
-            wget_file, [internal_vm, internal_vm_1, internal_vm_2])
+        self.verify_internal_lb_wget_traffic(int_lb_rule_1, internal_vm, internal_vm_1,
+                                             internal_vm_2, public_ip, public_vm)
 
         # Stopping VMs in the Internal tier
         # wget traffic test fails as all the VMs in the Internal tier are in
@@ -2095,17 +2072,8 @@ def test_07_nuage_internallb_vpc_network_restarts_traffic(self):
         self.verify_vsd_lb_device(int_lb_vm)
 
         # Internal LB (wget) traffic test
-        ssh_client = self.ssh_into_VM(public_vm, public_ip)
-        wget_file = self.wget_from_vm_cmd(
-            ssh_client, int_lb_rule_1.sourceipaddress,
-            self.test_data["http_rule"]["publicport"])
-
-        # Verifying Internal LB (wget) traffic test
-        with self.assertRaises(Exception):
-            self.verify_lb_wget_file(
-                wget_file, [internal_vm, internal_vm_1, internal_vm_2])
-        self.debug("Failed to wget file as all the VMs in the Internal tier "
-                   "are in stopped state")
+        self.verify_internal_lb_wget_traffic(int_lb_rule_1, internal_vm, internal_vm_1,
+                                             internal_vm_2, public_ip, public_vm, should_fail=True)
 
         # Starting VMs in the Internal tier
         # wget traffic test succeeds as all the VMs in the Internal tier are
@@ -2144,22 +2112,8 @@ def test_07_nuage_internallb_vpc_network_restarts_traffic(self):
         self.verify_vpc_vm_ingress_traffic(internal_vm_2, internal_tier, vpc)
 
         # Internal LB (wget) traffic test
-        ssh_client = self.ssh_into_VM(public_vm, public_ip)
-        tries = 0
-        while tries < 120:
-            wget_file = self.wget_from_vm_cmd(
-                ssh_client, int_lb_rule_1.sourceipaddress,
-                self.test_data["http_rule"]["publicport"])
-            if wget_file != "":
-                break
-            self.debug("Waiting for the InternalLbVm in the Internal tier to "
-                       "be fully resolved for (wget) traffic test...")
-            time.sleep(5)
-            tries += 1
-
-        # Verifying Internal LB (wget) traffic test
-        self.verify_lb_wget_file(
-            wget_file, [internal_vm, internal_vm_1, internal_vm_2])
+        self.verify_internal_lb_wget_traffic(int_lb_rule_1, internal_vm, internal_vm_1,
+                                             internal_vm_2, public_ip, public_vm)
 
         # Restarting VPC (cleanup = false)
         # VPC VR gets destroyed and deployed again in the VPC
@@ -2206,14 +2160,8 @@ def test_07_nuage_internallb_vpc_network_restarts_traffic(self):
         self.verify_vpc_vm_ingress_traffic(internal_vm_2, internal_tier, vpc)
 
         # Internal LB (wget) traffic test
-        ssh_client = self.ssh_into_VM(public_vm, public_ip)
-        wget_file = self.wget_from_vm_cmd(
-            ssh_client, int_lb_rule_1.sourceipaddress,
-            self.test_data["http_rule"]["publicport"])
-
-        # Verifying Internal LB (wget) traffic test
-        self.verify_lb_wget_file(
-            wget_file, [internal_vm, internal_vm_1, internal_vm_2])
+        self.verify_internal_lb_wget_traffic(int_lb_rule_1, internal_vm, internal_vm_1,
+                                             internal_vm_2, public_ip, public_vm)
 
         # Restarting VPC (cleanup = true)
         # VPC VR gets destroyed and deployed again in the VPC
@@ -2269,6 +2217,35 @@ def test_07_nuage_internallb_vpc_network_restarts_traffic(self):
         self.verify_lb_wget_file(
             wget_file, [internal_vm, internal_vm_1, internal_vm_2])
 
+    def verify_internal_lb_wget_traffic(self, int_lb_rule_1, internal_vm, internal_vm_1, internal_vm_2, public_ip, public_vm, should_fail=False):
+        if self.isSimulator:
+            self.debug("Simulator Environment: not running wget traffic tests.")
+            return
+        ssh_client = self.ssh_into_VM(public_vm, public_ip)
+        tries = 0
+        wget_file = None
+        while tries < 120:
+            wget_file = self.wget_from_vm_cmd(
+                ssh_client, int_lb_rule_1.sourceipaddress,
+                self.test_data["http_rule"]["publicport"])
+            if wget_file != "":
+                break
+            self.debug("Waiting for the InternalLbVm in the Internal tier to "
+                       "be fully resolved for (wget) traffic test...")
+            time.sleep(5)
+            tries += 1
+
+        # Verifying Internal LB (wget) traffic test
+        if should_fail:
+            with self.assertRaises(Exception):
+                self.verify_lb_wget_file(
+                    wget_file, [internal_vm, internal_vm_1, internal_vm_2])
+            self.debug("Failed to wget file as all the VMs in the Internal tier "
+                       "are in stopped state")
+        else:
+            self.verify_lb_wget_file(
+                wget_file, [internal_vm, internal_vm_1, internal_vm_2])
+
     @skip
     # Skip until CLOUDSTACK-9837 is fixed
     @attr(tags=["advanced", "nuagevsp"], required_hardware="true")
@@ -2452,14 +2429,8 @@ def test_08_nuage_internallb_appliance_operations_traffic(self):
         self.verify_vsd_firewall_rule(public_ssh_rule)
 
         # Internal LB (wget) traffic test
-        ssh_client = self.ssh_into_VM(public_vm, public_ip)
-        wget_file = self.wget_from_vm_cmd(
-            ssh_client, int_lb_rule_1.sourceipaddress,
-            self.test_data["http_rule"]["publicport"])
-
-        # Verifying Internal LB (wget) traffic test
-        self.verify_lb_wget_file(
-            wget_file, [internal_vm, internal_vm_1, internal_vm_2])
+        self.verify_internal_lb_wget_traffic(int_lb_rule_1, internal_vm, internal_vm_1,
+                                             internal_vm_2, public_ip, public_vm)
 
         # # Stopping the InternalLbVm when the VPC VR is in Stopped state
         self.stop_InternalLbVm(int_lb_vm)
@@ -2478,17 +2449,9 @@ def test_08_nuage_internallb_appliance_operations_traffic(self):
         self.verify_vpc_vm_ingress_traffic(internal_vm_2, internal_tier, vpc)
 
         # Internal LB (wget) traffic test
-        ssh_client = self.ssh_into_VM(public_vm, public_ip)
-        wget_file = self.wget_from_vm_cmd(
-            ssh_client, int_lb_rule_1.sourceipaddress,
-            self.test_data["http_rule"]["publicport"])
-
-        # Verifying Internal LB (wget) traffic test
-        with self.assertRaises(Exception):
-            self.verify_lb_wget_file(
-                wget_file, [internal_vm, internal_vm_1, internal_vm_2])
-        self.debug("Failed to wget file as the InternalLbVm is in stopped"
-                   " state")
+        self.verify_internal_lb_wget_traffic(int_lb_rule_1, internal_vm, internal_vm_1,
+                                             internal_vm_2, public_ip, public_vm,
+                                             should_fail=True)
 
         # # Starting the InternalLbVm when the VPC VR is in Stopped state
         self.start_InternalLbVm(int_lb_vm)
@@ -2507,23 +2470,9 @@ def test_08_nuage_internallb_appliance_operations_traffic(self):
         self.verify_vpc_vm_ingress_traffic(internal_vm_2, internal_tier, vpc)
 
         # Internal LB (wget) traffic test
-        ssh_client = self.ssh_into_VM(public_vm, public_ip)
-        tries = 0
-        while tries < 120:
-            wget_file = self.wget_from_vm_cmd(
-                ssh_client, int_lb_rule_1.sourceipaddress,
-                self.test_data["http_rule"]["publicport"])
-            if wget_file != "":
-                break
-            self.debug("Waiting for the InternalLbVm in the Internal tier to "
-                       "be fully resolved for (wget) traffic test...")
-            time.sleep(5)
-            tries += 1
-
-        # Verifying Internal LB (wget) traffic test
         # Bug CLOUDSTACK-9837
-        self.verify_lb_wget_file(
-            wget_file, [internal_vm, internal_vm_1, internal_vm_2])
+        self.verify_internal_lb_wget_traffic(int_lb_rule_1, internal_vm, internal_vm_1,
+                                             internal_vm_2, public_ip, public_vm)
 
         # Starting the VPC VR
         # VPC VR has no effect on the InternalLbVm functionality
@@ -2554,17 +2503,8 @@ def test_08_nuage_internallb_appliance_operations_traffic(self):
         self.verify_vpc_vm_ingress_traffic(internal_vm_2, internal_tier, vpc)
 
         # Internal LB (wget) traffic test
-        ssh_client = self.ssh_into_VM(public_vm, public_ip)
-        wget_file = self.wget_from_vm_cmd(
-            ssh_client, int_lb_rule_1.sourceipaddress,
-            self.test_data["http_rule"]["publicport"])
-
-        # Verifying Internal LB (wget) traffic test
-        with self.assertRaises(Exception):
-            self.verify_lb_wget_file(
-                wget_file, [internal_vm, internal_vm_1, internal_vm_2])
-        self.debug("Failed to wget file as the InternalLbVm is in stopped"
-                   " state")
+        self.verify_internal_lb_wget_traffic(int_lb_rule_1, internal_vm, internal_vm_1,
+                                             internal_vm_2, public_ip, public_vm, should_fail=True)
 
         # # Starting the InternalLbVm when the VPC VR is in Running state
         self.start_InternalLbVm(int_lb_vm)
@@ -2583,22 +2523,8 @@ def test_08_nuage_internallb_appliance_operations_traffic(self):
         self.verify_vpc_vm_ingress_traffic(internal_vm_2, internal_tier, vpc)
 
         # Internal LB (wget) traffic test
-        ssh_client = self.ssh_into_VM(public_vm, public_ip)
-        tries = 0
-        while tries < 120:
-            wget_file = self.wget_from_vm_cmd(
-                ssh_client, int_lb_rule_1.sourceipaddress,
-                self.test_data["http_rule"]["publicport"])
-            if wget_file != "":
-                break
-            self.debug("Waiting for the InternalLbVm in the Internal tier to "
-                       "be fully resolved for (wget) traffic test...")
-            time.sleep(5)
-            tries += 1
-
-        # Verifying Internal LB (wget) traffic test
-        self.verify_lb_wget_file(
-            wget_file, [internal_vm, internal_vm_1, internal_vm_2])
+        self.verify_internal_lb_wget_traffic(int_lb_rule_1, internal_vm, internal_vm_1,
+                                             internal_vm_2, public_ip, public_vm)
 
         # # Force Stopping the InternalLbVm when the VPC VR is in Running state
         self.stop_InternalLbVm(int_lb_vm, force=True)
@@ -2617,17 +2543,9 @@ def test_08_nuage_internallb_appliance_operations_traffic(self):
         self.verify_vpc_vm_ingress_traffic(internal_vm_2, internal_tier, vpc)
 
         # Internal LB (wget) traffic test
-        ssh_client = self.ssh_into_VM(public_vm, public_ip)
-        wget_file = self.wget_from_vm_cmd(
-            ssh_client, int_lb_rule_1.sourceipaddress,
-            self.test_data["http_rule"]["publicport"])
-
-        # Verifying Internal LB (wget) traffic test
-        with self.assertRaises(Exception):
-            self.verify_lb_wget_file(
-                wget_file, [internal_vm, internal_vm_1, internal_vm_2])
-        self.debug("Failed to wget file as the InternalLbVm is in stopped"
-                   " state")
+        self.verify_internal_lb_wget_traffic(int_lb_rule_1, internal_vm, internal_vm_1,
+                                             internal_vm_2, public_ip, public_vm,
+                                             should_fail=True)
 
         # # Starting the InternalLbVm when the VPC VR is in Running state
         self.start_InternalLbVm(int_lb_vm)
@@ -2646,19 +2564,5 @@ def test_08_nuage_internallb_appliance_operations_traffic(self):
         self.verify_vpc_vm_ingress_traffic(internal_vm_2, internal_tier, vpc)
 
         # Internal LB (wget) traffic test
-        ssh_client = self.ssh_into_VM(public_vm, public_ip)
-        tries = 0
-        while tries < 120:
-            wget_file = self.wget_from_vm_cmd(
-                ssh_client, int_lb_rule_1.sourceipaddress,
-                self.test_data["http_rule"]["publicport"])
-            if wget_file != "":
-                break
-            self.debug("Waiting for the InternalLbVm in the Internal tier to "
-                       "be fully resolved for (wget) traffic test...")
-            time.sleep(5)
-            tries += 1
-
-        # Verifying Internal LB (wget) traffic test
-        self.verify_lb_wget_file(
-            wget_file, [internal_vm, internal_vm_1, internal_vm_2])
+        self.verify_internal_lb_wget_traffic(int_lb_rule_1, internal_vm, internal_vm_1,
+                                             internal_vm_2, public_ip, public_vm)
diff --git a/test/integration/plugins/nuagevsp/test_nuage_vsp_domain_template.py b/test/integration/plugins/nuagevsp/test_nuage_vsp_domain_template.py
index 040f379fb6e..165632db701 100644
--- a/test/integration/plugins/nuagevsp/test_nuage_vsp_domain_template.py
+++ b/test/integration/plugins/nuagevsp/test_nuage_vsp_domain_template.py
@@ -453,6 +453,8 @@ def test_01_nuage_Domain_Template_selection_per_VPC(self):
                    "(tier) network gets created on CloudStack as the "
                    "associated pre-configured Nuage VSP domain template is no "
                    "longer existing in VSD")
+        for vpc_2_tier in Network.list(self.api_client, vpcid=vpc_2.id):
+            Network(vpc_2_tier.__dict__).delete(self.api_client)
 
         # Re-creating the associated pre-configured Nuage VSP domain template
         new_domain_template = self.vsdk.NUDomainTemplate(
@@ -504,6 +506,8 @@ def test_01_nuage_Domain_Template_selection_per_VPC(self):
                    "Network ACLs from CloudStack is not supported when the "
                    "VPC is associated with a Nuage VSP pre-configured domain "
                    "template")
+        for vpc_3_tier in Network.list(self.api_client, vpcid=vpc_3.id):
+            Network(vpc_3_tier.__dict__).delete(self.api_client)
 
         vpc_3_tier_1 = self.create_Network(
             self.network_offering, gateway='10.1.2.1', vpc=vpc_3)
diff --git a/test/integration/plugins/nuagevsp/test_nuage_vsp_mngd_subnets.py b/test/integration/plugins/nuagevsp/test_nuage_vsp_mngd_subnets.py
index de4a9f5722f..c60f9309310 100644
--- a/test/integration/plugins/nuagevsp/test_nuage_vsp_mngd_subnets.py
+++ b/test/integration/plugins/nuagevsp/test_nuage_vsp_mngd_subnets.py
@@ -98,43 +98,36 @@ def setUp(self):
         self.cleanup = [self.account]
         return
 
-    def verify_pingtovmipaddress(self, ssh, pingtovmipaddress):
-        """verify ping to ipaddress of the vm and retry 3 times"""
-
+    def verify_ping_to_vm(self, src_vm, dst_vm, public_ip, dst_hostname=None):
         if self.isSimulator:
+            self.debug("Simulator Environment: not verifying pinging")
             return
+        try:
+            src_vm.ssh_ip = public_ip.ipaddress.ipaddress
+            src_vm.ssh_port = self.test_data["virtual_machine"]["ssh_port"]
+            src_vm.username = self.test_data["virtual_machine"]["username"]
+            src_vm.password = self.test_data["virtual_machine"]["password"]
+            self.debug("SSHing into VM: %s with %s" %
+                       (src_vm.ssh_ip, src_vm.password))
 
-        successfull_ping = False
-        nbr_retries = 0
-        max_retries = 5
-        cmd = 'ping -c 2 ' + pingtovmipaddress
+            ssh = self.ssh_into_VM(src_vm, public_ip)
 
-        while not successfull_ping and nbr_retries < max_retries:
-            self.debug("ping vm by ipaddress with command: " + cmd)
-            outputlist = ssh.execute(cmd)
-            self.debug("command is executed properly " + cmd)
-            completeoutput = str(outputlist).strip('[]')
-            self.debug("complete output is " + completeoutput)
-            if '2 received' in completeoutput:
-                self.debug("PASS as vm is pingeable: " + completeoutput)
-                successfull_ping = True
-            else:
-                self.debug("FAIL as vm is not pingeable: " + completeoutput)
-                time.sleep(3)
-                nbr_retries = nbr_retries + 1
+        except Exception as e:
+            self.fail("SSH into VM failed with exception %s" % e)
 
-        if not successfull_ping:
-            self.fail("FAILED TEST as excepted value not found in vm")
+        self.verify_pingtovmipaddress(ssh, dst_vm.ipaddress)
+        if dst_hostname:
+            self.verify_pingtovmipaddress(ssh, dst_hostname)
 
-    def verify_pingtovmhostname(self, ssh, pingtovmhostname):
-        """verify ping to hostname of the vm and retry 3 times"""
+    def verify_pingtovmipaddress(self, ssh, pingtovmipaddress):
+        """verify ping to ipaddress of the vm and retry 3 times"""
         successfull_ping = False
         nbr_retries = 0
         max_retries = 5
-        cmd = 'ping -c 2 ' + pingtovmhostname
+        cmd = 'ping -c 2 ' + pingtovmipaddress
 
         while not successfull_ping and nbr_retries < max_retries:
-            self.debug("ping vm by hostname with command: " + cmd)
+            self.debug("ping vm by ipaddress with command: " + cmd)
             outputlist = ssh.execute(cmd)
             self.debug("command is executed properly " + cmd)
             completeoutput = str(outputlist).strip('[]')
@@ -207,7 +200,6 @@ def test_01_nuage_mngd_subnets_isonw(self):
         zone1 = self.create_vsd_zone(domain1, "ZoneToBeConsumedByACS")
         subnet1 = self.create_vsd_subnet(zone1, "SubnetToBeConsumedByACS",
                                          "10.0.0.1/24")
-        self.create_vsd_dhcp_option(subnet1, 15, ["nuagenetworks1.net"])
 
         domain2 = self.create_vsd_domain(domain_template, enterprise,
                                          "2ndL3DomainToBeConsumedByACS")
@@ -227,13 +219,13 @@ def test_01_nuage_mngd_subnets_isonw(self):
             isolated_network = self.create_Network(
                     self.nuage_isolated_network_offering,
                     gateway="10.0.0.1", netmask="255.255.255.0",
-                    externalid=subnet1.id)
+                    externalid=subnet1.id, cleanup=False)
 
             # On ACS create network using persistent nw offering allow
             isolated_network2 = self.create_Network(
                     self.nuage_isolated_network_offering_persistent,
                     gateway="10.5.0.1", netmask="255.255.255.0",
-                    externalid=subnet2.id)
+                    externalid=subnet2.id, cleanup=False)
 
             with self.assertRaises(Exception):
                 self.create_Network(
@@ -255,11 +247,11 @@ def test_01_nuage_mngd_subnets_isonw(self):
                         externalid=subnet2.id+1)
 
             # verify floating ip and intra subnet connectivity
-            vm_1 = self.create_VM(isolated_network)
+            vm_1 = self.create_VM(isolated_network, cleanup=False)
 
             self.test_data["virtual_machine"]["displayname"] = "vm2"
             self.test_data["virtual_machine"]["name"] = "vm2"
-            vm_2 = self.create_VM(isolated_network)
+            vm_2 = self.create_VM(isolated_network, cleanup=False)
             self.test_data["virtual_machine"]["displayname"] = None
             self.test_data["virtual_machine"]["name"] = None
 
@@ -276,31 +268,12 @@ def test_01_nuage_mngd_subnets_isonw(self):
                     public_ip, isolated_network, static_nat=True, vm=vm_1)
             self.create_FirewallRule(public_ip,
                                      self.test_data["ingress_rule"])
-            if not self.isSimulator:
-                vm_public_ip = public_ip.ipaddress.ipaddress
-                try:
-                    vm_1.ssh_ip = vm_public_ip
-                    vm_1.ssh_port = \
-                        self.test_data["virtual_machine"]["ssh_port"]
-                    vm_1.username = \
-                        self.test_data["virtual_machine"]["username"]
-                    vm_1.password = \
-                        self.test_data["virtual_machine"]["password"]
-                    self.debug("SSHing into VM: %s with %s" %
-                               (vm_1.ssh_ip, vm_1.password))
-
-                    ssh = vm_1.get_ssh_client(ipaddress=vm_public_ip)
-
-                except Exception as e:
-                    self.fail("SSH into VM failed with exception %s" % e)
-
-                self.verify_pingtovmipaddress(ssh, vm_2.ipaddress)
-                self.verify_pingtovmhostname(ssh, "vm2")
-
-            vm_3 = self.create_VM(isolated_network2)
+            self.verify_ping_to_vm(vm_1, vm_2, public_ip, "vm2")
+
+            vm_3 = self.create_VM(isolated_network2, cleanup=False)
             self.test_data["virtual_machine"]["displayname"] = "vm4"
             self.test_data["virtual_machine"]["name"] = "vm4"
-            vm_4 = self.create_VM(isolated_network2)
+            vm_4 = self.create_VM(isolated_network2, cleanup=False)
             self.test_data["virtual_machine"]["displayname"] = None
             self.test_data["virtual_machine"]["name"] = None
             self.verify_vsd_network_not_present(isolated_network2)
@@ -313,37 +286,17 @@ def test_01_nuage_mngd_subnets_isonw(self):
             self.create_StaticNatRule_For_VM(vm_3, public_ip2,
                                              isolated_network2)
             self.validate_PublicIPAddress(
-                    public_ip2, isolated_network2, static_nat=True, vm=vm_3)
+                public_ip2, isolated_network2, static_nat=True, vm=vm_3)
             self.create_FirewallRule(public_ip2,
                                      self.test_data["ingress_rule"])
 
-            if not self.isSimulator:
-                vm_public_ip2 = public_ip2.ipaddress.ipaddress
-                try:
-                    vm_3.ssh_ip = vm_public_ip2
-                    vm_3.ssh_port = \
-                        self.test_data["virtual_machine"]["ssh_port"]
-                    vm_3.username = \
-                        self.test_data["virtual_machine"]["username"]
-                    vm_3.password = \
-                        self.test_data["virtual_machine"]["password"]
-                    self.debug("SSHing into VM: %s with %s" %
-                               (vm_3.ssh_ip, vm_3.password))
-
-                    ssh2 = vm_3.get_ssh_client(ipaddress=vm_public_ip2)
-
-                except Exception as e:
-                    self.fail("SSH into VM failed with exception %s" % e)
-
-                self.verify_pingtovmipaddress(ssh2, vm_4.ipaddress)
-                self.verify_pingtovmhostname(ssh2, "vm4")
-
-            vm_1.delete(self.api_client, expunge=True)
-            vm_2.delete(self.api_client, expunge=True)
-            isolated_network.delete(self.api_client)
-            vm_3.delete(self.api_client, expunge=True)
+            self.verify_ping_to_vm(vm_3, vm_4, public_ip2)
             vm_4.delete(self.api_client, expunge=True)
+            vm_3.delete(self.api_client, expunge=True)
+            vm_2.delete(self.api_client, expunge=True)
+            vm_1.delete(self.api_client, expunge=True)
             isolated_network2.delete(self.api_client)
+            isolated_network.delete(self.api_client)
             self.debug("Number of loops %s" % i)
 
     @attr(tags=["advanced", "nuagevsp", "vpc"], required_hardware="false")
@@ -393,11 +346,11 @@ def test_02_nuage_mngd_subnets_vpc(self):
         vpc = self.create_Vpc(self.nuage_vpc_offering, cidr='10.1.0.0/16')
         self.validate_Vpc(vpc, state="Enabled")
         acl_list = self.create_NetworkAclList(
-                name="acl", description="acl", vpc=vpc)
+            name="acl", description="acl", vpc=vpc)
         self.create_NetworkAclRule(
-                self.test_data["ingress_rule"], acl_list=acl_list)
+            self.test_data["ingress_rule"], acl_list=acl_list)
         self.create_NetworkAclRule(
-                self.test_data["icmprule"], acl_list=acl_list)
+            self.test_data["icmprule"], acl_list=acl_list)
 
         self.debug("Creating another VPC with Static NAT service provider "
                    "as VpcVirtualRouter")
@@ -442,7 +395,8 @@ def test_02_nuage_mngd_subnets_vpc(self):
                                            gateway='10.1.0.1',
                                            vpc=vpc,
                                            acl_list=acl_list,
-                                           externalid=subnet1.id)
+                                           externalid=subnet1.id,
+                                           cleanup=False)
             self.validate_Network(vpc_tier, state="Implemented")
             self.debug("Creating 2nd VPC tier network with Static NAT service")
 
@@ -458,7 +412,8 @@ def test_02_nuage_mngd_subnets_vpc(self):
                                               gateway='10.1.128.1',
                                               vpc=vpc,
                                               acl_list=acl_list,
-                                              externalid=subnet2.id)
+                                              externalid=subnet2.id,
+                                              cleanup=False)
             self.validate_Network(vpc_2ndtier, state="Implemented")
             vpc_vr = self.get_Router(vpc_tier)
             self.check_Router_state(vpc_vr, state="Running")
@@ -514,17 +469,17 @@ def test_02_nuage_mngd_subnets_vpc(self):
             self.debug("Deploying a VM in the created VPC tier network")
             self.test_data["virtual_machine"]["displayname"] = "vpcvm1"
             self.test_data["virtual_machine"]["name"] = "vpcvm1"
-            vpc_vm_1 = self.create_VM(vpc_tier)
+            vpc_vm_1 = self.create_VM(vpc_tier, cleanup=False)
             self.check_VM_state(vpc_vm_1, state="Running")
             self.debug("Deploying another VM in the created VPC tier network")
             self.test_data["virtual_machine"]["displayname"] = "vpcvm2"
             self.test_data["virtual_machine"]["name"] = "vpcvm2"
-            vpc_vm_2 = self.create_VM(vpc_tier)
+            vpc_vm_2 = self.create_VM(vpc_tier, cleanup=False)
             self.check_VM_state(vpc_vm_2, state="Running")
             self.debug("Deploying a VM in the 2nd VPC tier network")
             self.test_data["virtual_machine"]["displayname"] = "vpcvm12"
             self.test_data["virtual_machine"]["name"] = "vpcvm12"
-            vpc_vm_12 = self.create_VM(vpc_2ndtier)
+            vpc_vm_12 = self.create_VM(vpc_2ndtier, cleanup=False)
             self.check_VM_state(vpc_vm_2, state="Running")
             self.test_data["virtual_machine"]["displayname"] = None
             self.test_data["virtual_machine"]["name"] = None
@@ -542,26 +497,8 @@ def test_02_nuage_mngd_subnets_vpc(self):
             self.validate_PublicIPAddress(
                     public_ip_1, vpc_tier, static_nat=True, vm=vpc_vm_1)
 
-            if not self.isSimulator:
-                vm_public_ip_1 = public_ip_1.ipaddress.ipaddress
-                try:
-                    vpc_vm_1.ssh_ip = vm_public_ip_1
-                    vpc_vm_1.ssh_port = \
-                        self.test_data["virtual_machine"]["ssh_port"]
-                    vpc_vm_1.username = \
-                        self.test_data["virtual_machine"]["username"]
-                    vpc_vm_1.password = \
-                        self.test_data["virtual_machine"]["password"]
-                    self.debug("SSHing into VM: %s with %s" %
-                               (vpc_vm_1.ssh_ip, vpc_vm_1.password))
-
-                    ssh = vpc_vm_1.get_ssh_client(ipaddress=vm_public_ip_1)
-
-                except Exception as e:
-                    self.fail("SSH into VM failed with exception %s" % e)
-
-                self.verify_pingtovmipaddress(ssh, vpc_vm_2.ipaddress)
-                self.verify_pingtovmipaddress(ssh, vpc_vm_12.ipaddress)
+            self.verify_ping_to_vm(vpc_vm_1, vpc_vm_2, public_ip_1)
+            self.verify_ping_to_vm(vpc_vm_1, vpc_vm_12, public_ip_1)
 
             vpc_vm_1.delete(self.api_client, expunge=True)
             vpc_vm_2.delete(self.api_client, expunge=True)
@@ -704,8 +641,6 @@ def create_vsd_enterprise(self):
         enterprise = self.vsdk.NUEnterprise()
         enterprise.name = "EnterpriseToBeConsumedByACS"
         enterprise.description = "EnterpriseToBeConsumedByACS"
-        # enterprise.external_id = "ToBeConsumedByACS@" \
-        #                          + str(self.cms_id)
         (enterprise, connection) = self._session.user.create_child(enterprise)
         return enterprise
 
@@ -738,8 +673,6 @@ def create_vsd_domain_template(self, enterprise):
         domain_template = self.vsdk.NUDomainTemplate()
         domain_template.name = "L3DomainTemplateToBeConsumedByACS"
         domain_template.description = "L3DomainTemplateToBeConsumedByACS"
-        # domain_template.external_id = "L3DomainTemplateToBeConsumedByACS@" \
-        #                               + str(self.cms_id)
         (domain_template, connection) = \
             enterprise.create_child(domain_template)
         return domain_template
diff --git a/tools/marvin/marvin/config/test_data.py b/tools/marvin/marvin/config/test_data.py
index 097b890f64d..11595e4a26f 100644
--- a/tools/marvin/marvin/config/test_data.py
+++ b/tools/marvin/marvin/config/test_data.py
@@ -49,27 +49,6 @@
         "forvirtualnetwork": "true",
         "vlan": "300"
     },
-    "publiciprange1": {
-        "gateway": "10.200.100.1",
-        "netmask": "255.255.255.0",
-        "startip": "10.200.100.101",
-        "endip": "10.200.100.105",
-        "forvirtualnetwork": "false"
-    },
-    "publiciprange2": {
-        "gateway": "10.219.1.1",
-        "netmask": "255.255.255.0",
-        "startip": "10.219.1.2",
-        "endip": "10.219.1.5",
-        "forvirtualnetwork": "false"
-    },
-    "publiciprange3": {
-        "gateway": "10.200.100.1",
-        "netmask": "255.255.255.0",
-        "startip": "10.200.100.2",
-        "endip": "10.200.100.20",
-        "forvirtualnetwork": "false"
-    },
     "private_gateway": {
         "ipaddress": "172.16.1.2",
         "gateway": "172.16.1.1",
@@ -92,14 +71,14 @@
         "password": "password"
     },
     "user": {
-         "email": "user@test.com",
-         "firstname": "User",
-         "lastname": "User",
-         "username": "User",
-           # Random characters are appended for unique
-           # username
-         "password": "fr3sca",
-     },
+        "email": "user@test.com",
+        "firstname": "User",
+        "lastname": "User",
+        "username": "User",
+        # Random characters are appended for unique
+        # username
+        "password": "fr3sca",
+    },
     "small": {
         "displayname": "testserver",
         "username": "root",
@@ -153,7 +132,7 @@
             "cpuspeed": 100,
             "memory": 512,
         },
-       "large": {
+        "large": {
             "name": "LargeInstance",
             "displaytext": "LargeInstance",
             "cpunumber": 1,
@@ -179,20 +158,20 @@
         },
     },
     "service_offering_h1": {
-            "name": "Tagged h1 Small Instance",
-            "displaytext": "Tagged h1 Small Instance",
-            "cpunumber": 1,
-            "cpuspeed": 100,
-            "memory": 256,
-            "hosttags": "h1"
+        "name": "Tagged h1 Small Instance",
+        "displaytext": "Tagged h1 Small Instance",
+        "cpunumber": 1,
+        "cpuspeed": 100,
+        "memory": 256,
+        "hosttags": "h1"
     },
     "service_offering_h2": {
-            "name": "Tagged h2 Small Instance",
-            "displaytext": "Tagged h2 Small Instance",
-            "cpunumber": 1,
-            "cpuspeed": 100,
-            "memory": 256,
-            "hosttags": "h2"
+        "name": "Tagged h2 Small Instance",
+        "displaytext": "Tagged h2 Small Instance",
+        "cpunumber": 1,
+        "cpuspeed": 100,
+        "memory": 256,
+        "hosttags": "h2"
     },
     "disk_offering": {
         "name": "Disk offering",
@@ -256,23 +235,23 @@
         },
     },
     "nw_off_isolated_netscaler": {
-                "name": 'Netscaler',
-                "displaytext": 'Netscaler',
-                "guestiptype": 'Isolated',
-                "supportedservices": 'Dhcp,Dns,SourceNat,PortForwarding,Vpn,Firewall,Lb,UserData,StaticNat',
-                "traffictype": 'GUEST',
-                "availability": 'Optional',
-                "serviceProviderList": {
-                    "Dhcp": 'VirtualRouter',
-                    "Dns": 'VirtualRouter',
-                    "SourceNat": 'VirtualRouter',
-                    "PortForwarding": 'VirtualRouter',
-                    "Vpn": 'VirtualRouter',
-                    "Firewall": 'VirtualRouter',
-                    "Lb": 'Netscaler',
-                    "UserData": 'VirtualRouter',
-                    "StaticNat": 'VirtualRouter',
-                },
+        "name": 'Netscaler',
+        "displaytext": 'Netscaler',
+        "guestiptype": 'Isolated',
+        "supportedservices": 'Dhcp,Dns,SourceNat,PortForwarding,Vpn,Firewall,Lb,UserData,StaticNat',
+        "traffictype": 'GUEST',
+        "availability": 'Optional',
+        "serviceProviderList": {
+            "Dhcp": 'VirtualRouter',
+            "Dns": 'VirtualRouter',
+            "SourceNat": 'VirtualRouter',
+            "PortForwarding": 'VirtualRouter',
+            "Vpn": 'VirtualRouter',
+            "Firewall": 'VirtualRouter',
+            "Lb": 'Netscaler',
+            "UserData": 'VirtualRouter',
+            "StaticNat": 'VirtualRouter',
+        },
     },
     "nw_off_isolated_persistent": {
         "name": 'Test Nw off isolated persistent',
@@ -328,50 +307,32 @@
         }
     },
     "network_offering_vlan": {
-    "name": 'Test Network offering',
-    "displaytext": 'Test Network offering',
-    "guestiptype": 'Isolated',
-    "supportedservices": 'Dhcp,Dns,SourceNat,PortForwarding',
-    "traffictype": 'GUEST',
-    "specifyvlan": 'False',
-    "availability": 'Optional',
-    "serviceProviderList": {
-    "Dhcp": 'VirtualRouter',
-    "Dns": 'VirtualRouter',
-    "SourceNat": 'VirtualRouter',
-    "PortForwarding": 'VirtualRouter',
-    },
+        "name": 'Test Network offering',
+        "displaytext": 'Test Network offering',
+        "guestiptype": 'Isolated',
+        "supportedservices": 'Dhcp,Dns,SourceNat,PortForwarding',
+        "traffictype": 'GUEST',
+        "specifyvlan": 'False',
+        "availability": 'Optional',
+        "serviceProviderList": {
+            "Dhcp": 'VirtualRouter',
+            "Dns": 'VirtualRouter',
+            "SourceNat": 'VirtualRouter',
+            "PortForwarding": 'VirtualRouter',
+        },
     },
     "network_offering_without_sourcenat": {
-    "name": 'Test Network offering',
-    "displaytext": 'Test Network offering',
-    "guestiptype": 'Isolated',
-    "supportedservices": 'Dhcp,Dns,UserData',
-    "traffictype": 'GUEST',
-    "availability": 'Optional',
-    "serviceProviderList": {
-    "Dhcp": 'VirtualRouter',
-    "Dns": 'VirtualRouter',
-    "UserData": 'VirtualRouter',
-    },
-    },
-    "isolated_staticnat_network_offering": {
-        "name": 'isolated_staticnat_net_off_marvin',
-        "displaytext": 'isolated_staticnat_net_off_marvin',
+        "name": 'Test Network offering',
+        "displaytext": 'Test Network offering',
         "guestiptype": 'Isolated',
-        "supportedservices": 'Dhcp,SourceNat,StaticNat,UserData,Firewall,Dns',
+        "supportedservices": 'Dhcp,Dns,UserData',
         "traffictype": 'GUEST',
-        "ispersistent": 'True',
         "availability": 'Optional',
-        "tags": 'native',
         "serviceProviderList": {
             "Dhcp": 'VirtualRouter',
-            "StaticNat": 'VirtualRouter',
-            "SourceNat": 'VirtualRouter',
-            "Firewall": 'VirtualRouter',
+            "Dns": 'VirtualRouter',
             "UserData": 'VirtualRouter',
-            "Dns": 'VirtualRouter'
-        }
+        },
     },
     "isolated_network": {
         "name": "Isolated Network",
@@ -494,20 +455,6 @@
             "SecurityGroup": "SecurityGroupProvider"
         }
     },
-    "shared_network_config_drive_offering": {
-        "name": 'shared_network_config_drive_offering',
-        "displaytext": 'shared_network_config_drive_offering',
-        "guestiptype": 'shared',
-        "supportedservices": 'Dhcp,UserData',
-        "traffictype": 'GUEST',
-        "specifyVlan": "True",
-        "specifyIpRanges": "True",
-        "availability": 'Optional',
-        "serviceProviderList": {
-            "Dhcp": "VirtualRouter",
-            "UserData": 'ConfigDrive'
-        }
-    },
     "shared_network_sg": {
         "name": "Shared-Network-SG-Test",
         "displaytext": "Shared-Network_SG-Test",
@@ -526,12 +473,6 @@
         "supportedservices":
             "Dhcp,Dns,SourceNat,PortForwarding,Vpn,Lb,UserData,StaticNat,NetworkACL"
     },
-    "vpc_offering_reduced": {
-        "name": "VPC reduced off",
-        "displaytext": "VPC reduced off",
-        "supportedservices":
-            "Dhcp,Dns,SourceNat,UserData,StaticNat,NetworkACL"
-    },
     "vpc_offering_multi_lb": {
         "name": "VPC offering with multiple Lb service providers",
         "displaytext": "VPC offering with multiple Lb service providers",
@@ -554,10 +495,10 @@
         "cidr": "10.0.0.1/24"
     },
     "vpc_network_domain": {
-    "name": "TestVPC",
-    "displaytext": "TestVPC",
-    "cidr": '10.0.0.1/24',
-    "network_domain": "TestVPC"
+        "name": "TestVPC",
+        "displaytext": "TestVPC",
+        "cidr": '10.0.0.1/24',
+        "network_domain": "TestVPC"
     },
     "clusters": {
         0: {
@@ -697,26 +638,6 @@
             "Lb": "VpcVirtualRouter"
         }
     },
-    "nw_offering_reduced_vpc": {
-        "name": 'Reduced Network for VPC',
-        "displaytext": 'Reduced Network for VPC',
-        "guestiptype": 'Isolated',
-        "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,UserData,'
-                             'Dns',
-        "traffictype": 'GUEST',
-        "availability": 'Optional',
-        "tags": "native",
-        "useVpc": 'on',
-        "ispersistent": 'True',
-        "serviceProviderList": {
-            "Dhcp": "VpcVirtualRouter",
-            "StaticNat": "VpcVirtualRouter",
-            "SourceNat": "VpcVirtualRouter",
-            "NetworkACL": "VpcVirtualRouter",
-            "UserData": "VpcVirtualRouter",
-            "Dns": "VpcVirtualRouter"
-        }
-    },
     "nw_off_persistent_VPCVR_LB": {
         "name": "Persistent Network VPC with LB",
         "displaytext": "Persistent Network VPC No LB",
@@ -855,11 +776,11 @@
 
     },
     "network_acl_rule": {
-    "protocol": "TCP",
-    "traffictype": "ingress",
-    "cidrlist": "0.0.0.0/0",
-    "startport": "1",
-    "endport": "1"
+        "protocol": "TCP",
+        "traffictype": "ingress",
+        "cidrlist": "0.0.0.0/0",
+        "startport": "1",
+        "endport": "1"
     },
     "network_offering_internal_lb": {
         "name": "Network offering for internal lb service",
@@ -900,7 +821,7 @@
         "privateport": 50,
         "privateendport": 55,
     },
-   "egress_80": {
+    "egress_80": {
         "startport": 80,
         "endport": 80,
         "protocol": "TCP",
@@ -948,14 +869,6 @@
         "protocol": "TCP",
         "cidrlist": '0.0.0.0/0',
     },
-    "dns_rule": {
-        "privateport": 53,
-        "publicport": 53,
-        "startport": 53,
-        "endport": 53,
-        "protocol": "UDP",
-        "cidrlist": '0.0.0.0/0',
-    },
     "icmprule": {
         "icmptype": -1,
         "icmpcode": -1,
@@ -1053,9 +966,9 @@
         "urlvmware":"http://dl.openvm.eu/cloudstack/coreos/x86_64/coreos_production_cloudstack_image-vmware.ova",
         "urlxen":"http://dl.openvm.eu/cloudstack/coreos/x86_64/coreos_production_cloudstack_image-xen.vhd.bz2",
         "urlkvm": "http://dl.openvm.eu/cloudstack/coreos/x86_64/" \
-                         "coreos_production_cloudstack_image-kvm.qcow2.bz2",
+                  "coreos_production_cloudstack_image-kvm.qcow2.bz2",
         "urlhyperv":"http://dl.openvm.eu/cloudstack/coreos/x86_64/coreos_production_cloudstack_image-hyperv.vhd.zip"
-        },
+    },
     "CentOS6.3template": {
         "displaytext": "Centos",
         "name": "Centos",
@@ -1105,14 +1018,14 @@
         "hypervisor": "XenServer"
     },
     "Windows Server 2012": {
-            "displaytext": "Windows Server 2012",
-            "name": "Windows Server 2012",
-            "passwordenabled": False,
-            "format": "OVA",
-            "ostype": "Windows Server 2012 (64-bit)",
-            "ispublic": "true",
-            "hypervisor": "Vmware"
-     },
+        "displaytext": "Windows Server 2012",
+        "name": "Windows Server 2012",
+        "passwordenabled": False,
+        "format": "OVA",
+        "ostype": "Windows Server 2012 (64-bit)",
+        "ispublic": "true",
+        "hypervisor": "Vmware"
+    },
     "privatetemplate": {
         "displaytext": "Public Template",
         "name": "Public template",
@@ -1214,29 +1127,29 @@
     },
     "volume": {"diskname": "Test Volume",
                "size": 1
-    },
+               },
     "volume_write_path": {
         "diskname": "APP Data Volume",
         "size": 1,   # in GBs
         "xenserver": {"rootdiskdevice":"/dev/xvda",
-                     "datadiskdevice_1": '/dev/xvdb',
-                    "datadiskdevice_2": '/dev/xvdc',   # Data Disk
-                    },
+                      "datadiskdevice_1": '/dev/xvdb',
+                      "datadiskdevice_2": '/dev/xvdc',   # Data Disk
+                      },
         "kvm":       {"rootdiskdevice": "/dev/vda",
-                    "datadiskdevice_1": "/dev/vdb",
-                    "datadiskdevice_2": "/dev/vdc"
-                    },
+                      "datadiskdevice_1": "/dev/vdb",
+                      "datadiskdevice_2": "/dev/vdc"
+                      },
         "vmware":    {"rootdiskdevice": "/dev/hda",
-                    "datadiskdevice_1": "/dev/hdb",
-                    "datadiskdevice_2": "/dev/hdc"
-                    }
+                      "datadiskdevice_1": "/dev/hdb",
+                      "datadiskdevice_2": "/dev/hdc"
+                      }
     },
     "data_write_paths": {
-                "mount_dir": "/mnt/tmp",
-                "sub_dir": "test",
-                "sub_lvl_dir1": "test1",
-                "sub_lvl_dir2": "test2",
-                "random_data": "random.data",
+        "mount_dir": "/mnt/tmp",
+        "sub_dir": "test",
+        "sub_lvl_dir1": "test1",
+        "sub_lvl_dir2": "test2",
+        "random_data": "random.data",
     },
     "custom_volume": {
         "customdisksize": 1,
@@ -1358,15 +1271,15 @@
             "hypervisor": "XenServer"
         },
         "RHEL 7 (64-bit)": {
-                              "displaytext": "RHEL7 (64-bit)",
-                              "name": "RHEL 7 Insta1",
-                              "passwordenabled": False,
-                              "url": "http://people.apache.org/~sanjeev/RHEL764bitwithtools.vhd",
-                              "format": "VHD" ,
-                              "ostype": "RHEL 7 (64-bit)",
-                              "ispublic": "true",
-                              "hypervisor": "XenServer"
-                              },
+            "displaytext": "RHEL7 (64-bit)",
+            "name": "RHEL 7 Insta1",
+            "passwordenabled": False,
+            "url": "http://people.apache.org/~sanjeev/RHEL764bitwithtools.vhd",
+            "format": "VHD" ,
+            "ostype": "RHEL 7 (64-bit)",
+            "ispublic": "true",
+            "hypervisor": "XenServer"
+        },
         "clusters": {
             "clustername": "Xen Cluster Vgpu",
             "clustertype": "CloudManaged",
@@ -1732,11 +1645,11 @@
             "name": "Primary iSCSI"
         },
         "host": {
-                 "publicport": 22,
-                 "username": "root",
-                 "password": "password",
+            "publicport": 22,
+            "username": "root",
+            "password": "password",
         },
-       "ldap_account": {
+        "ldap_account": {
             "email": "",
             "firstname": "",
             "lastname": "",
@@ -1754,8 +1667,8 @@
             "ldapPassword": ""
         },
         "systemVmDelay": 120,
-	"setUsageConfigurationThroughTestCase": False,
-	"vmware_cluster" : {
+        "setUsageConfigurationThroughTestCase": False,
+        "vmware_cluster" : {
             "hypervisor": 'VMware',
             "clustertype": 'ExternalManaged',
             "username": '',
@@ -1808,87 +1721,87 @@
         ]
     },
 
-"interop":
-    {
-     "VHD":
-     {
-                              "displaytext": "Windows 8 (64-bit)",
-                              "name": "win8withpvxen",
-                              "passwordenabled": False,
-                              "url": "http://people.apache.org/~sanjeev/79211594-1d4a-4dee-ae6c-c5c315ded2be.vhd",
-                              "format": "VHD" ,
-                              "ostype": "Windows 8 (64-bit)",
-                              "ispublic": "true",
-                              "hypervisor": "XenServer"
-
-     },
-     "OVA":
-     {
-                              "displaytext": "Windows 8 (64-bit)",
-                              "name": "win8withpvvmware",
-                              "passwordenabled": False,
-                              "url": "http://pleaseupdateURL/",
-                              "format": "OVA" ,
-                              "ostype": "Windows 8 (64-bit)",
-                              "ispublic": "true",
-                              "hypervisor": "VMware"
-                              },
-    "template": {
-        "displaytext": "windowsxdtemplate",
-        "name": "windowsxdtemplate",
-        "passwordenabled": False,
-        "ostype": "Windows 8 (64-bit)"
-    },
-},
+    "interop":
+        {
+            "VHD":
+                {
+                    "displaytext": "Windows 8 (64-bit)",
+                    "name": "win8withpvxen",
+                    "passwordenabled": False,
+                    "url": "http://people.apache.org/~sanjeev/79211594-1d4a-4dee-ae6c-c5c315ded2be.vhd",
+                    "format": "VHD" ,
+                    "ostype": "Windows 8 (64-bit)",
+                    "ispublic": "true",
+                    "hypervisor": "XenServer"
 
-    "browser_upload_volume":{
-          "VHD": {
-        "diskname": "XenUploadVol",
-        "url": "http://people.apache.org/~sanjeev/rajani-thin-volume.vhd",
-        "checksum": "09b08b6abb1b903fca7711d3ac8d6598",
-                },
-          "OVA": {
-        "diskname": "VMwareUploadVol",
-        "url": "http://people.apache.org/~sanjeev/CentOS5.5(64bit)-vmware-autoscale.ova",
-        "checksum": "da997b697feaa2f1f6e0d4785b0cece2",
                 },
-          "QCOW2": {
-        "diskname": "KVMUploadVol",
-        "url": "http://people.apache.org/~sanjeev/rajani-thin-volume.qcow2",
-        "checksum": "02de0576dd3a61ab59c03fd795fc86ac",
+            "OVA":
+                {
+                    "displaytext": "Windows 8 (64-bit)",
+                    "name": "win8withpvvmware",
+                    "passwordenabled": False,
+                    "url": "http://pleaseupdateURL/",
+                    "format": "OVA" ,
+                    "ostype": "Windows 8 (64-bit)",
+                    "ispublic": "true",
+                    "hypervisor": "VMware"
                 },
-    'browser_resized_disk_offering': {
-        "displaytext": "Resizeddisk",
-        "name": "Resizeddisk",
-        "disksize": 3,
-    }
-},
+            "template": {
+                "displaytext": "windowsxdtemplate",
+                "name": "windowsxdtemplate",
+                "passwordenabled": False,
+                "ostype": "Windows 8 (64-bit)"
+            },
+        },
+
+    "browser_upload_volume":{
+        "VHD": {
+            "diskname": "XenUploadVol",
+            "url": "http://people.apache.org/~sanjeev/rajani-thin-volume.vhd",
+            "checksum": "09b08b6abb1b903fca7711d3ac8d6598",
+        },
+        "OVA": {
+            "diskname": "VMwareUploadVol",
+            "url": "http://people.apache.org/~sanjeev/CentOS5.5(64bit)-vmware-autoscale.ova",
+            "checksum": "da997b697feaa2f1f6e0d4785b0cece2",
+        },
+        "QCOW2": {
+            "diskname": "KVMUploadVol",
+            "url": "http://people.apache.org/~sanjeev/rajani-thin-volume.qcow2",
+            "checksum": "02de0576dd3a61ab59c03fd795fc86ac",
+        },
+        'browser_resized_disk_offering': {
+            "displaytext": "Resizeddisk",
+            "name": "Resizeddisk",
+            "disksize": 3,
+        }
+    },
     "browser_upload_template": {
-          "VHD": {
-        "templatename": "XenUploadtemplate",
-        "displaytext": "XenUploadtemplate",
-        "url": "http://dl.openvm.eu/cloudstack/macchinina/x86_64/macchinina-xen.vhd.bz2",
-        "hypervisor":"XenServer",
-        "checksum": "54ebc933e6e07ae58c0dc97dfd37c824",
-        "ostypeid":"74affaea-c658-11e4-ad38-a6d1374244b4"
-                },
-          "OVA": {
-        "templatename": "VMwareUploadtemplate",
-        "displaytext": "VMwareUploadtemplate",
-        "url": "http://dl.openvm.eu/cloudstack/macchinina/x86_64/macchinina-vmware.ova",
-        "checksum": "d6d97389b129c7d898710195510bf4fb",
-        "hypervisor":"VMware",
-        "ostypeid":"74affaea-c658-11e4-ad38-a6d1374244b4"
-                },
-          "QCOW2": {
-        "templatename": "KVMUploadtemplate",
-        "displaytext": "VMwareUploadtemplate",
-        "url": "http://dl.openvm.eu/cloudstack/macchinina/x86_64/macchinina-kvm.qcow2.bz2",
-        "checksum": "ada77653dcf1e59495a9e1ac670ad95f",
-        "hypervisor":"KVM",
-        "ostypeid":"2e02e376-cdf3-11e4-beb3-8aa6272b57ef"
-                },
-                              },
+        "VHD": {
+            "templatename": "XenUploadtemplate",
+            "displaytext": "XenUploadtemplate",
+            "url": "http://dl.openvm.eu/cloudstack/macchinina/x86_64/macchinina-xen.vhd.bz2",
+            "hypervisor":"XenServer",
+            "checksum": "54ebc933e6e07ae58c0dc97dfd37c824",
+            "ostypeid":"74affaea-c658-11e4-ad38-a6d1374244b4"
+        },
+        "OVA": {
+            "templatename": "VMwareUploadtemplate",
+            "displaytext": "VMwareUploadtemplate",
+            "url": "http://dl.openvm.eu/cloudstack/macchinina/x86_64/macchinina-vmware.ova",
+            "checksum": "d6d97389b129c7d898710195510bf4fb",
+            "hypervisor":"VMware",
+            "ostypeid":"74affaea-c658-11e4-ad38-a6d1374244b4"
+        },
+        "QCOW2": {
+            "templatename": "KVMUploadtemplate",
+            "displaytext": "VMwareUploadtemplate",
+            "url": "http://dl.openvm.eu/cloudstack/macchinina/x86_64/macchinina-kvm.qcow2.bz2",
+            "checksum": "ada77653dcf1e59495a9e1ac670ad95f",
+            "hypervisor":"KVM",
+            "ostypeid":"2e02e376-cdf3-11e4-beb3-8aa6272b57ef"
+        },
+    },
     "configurableData":
         {
             "portableIpRange": {
@@ -1973,401 +1886,36 @@
                     "url": "http://dl.openvm.eu/cloudstack/iso/TinyCore-8.0.iso",
                     "ostype": 'Other Linux (64-bit)',
                     "mode": 'HTTP_DOWNLOAD'
-        },
-     "setHostConfigurationForIngressRule": False,
-     "restartManagementServerThroughTestCase": False,
-     "vmxnet3template": {
-            "displaytext": "VMXNET3 Template",
-            "name": "VMXNET3 template",
-            "ostype": "CentOS 5.6 (64-bit)",
-            "isfeatured": True,
-            "ispublic": False,
-            "isextractable": True,
-            "mode": "HTTP_DOWNLOAD",
-            "templatefilter": "self",
-            "url": "http://people.apache.org/~sanjeev/systemvm64template-2014-09-30-4.3-vmware.ova",
-            "hypervisor": "vmware",
-            "format": "OVA",
-            "nicadapter": "vmxnet3",
+                },
+            "setHostConfigurationForIngressRule": False,
+            "restartManagementServerThroughTestCase": False,
+            "vmxnet3template": {
+                "displaytext": "VMXNET3 Template",
+                "name": "VMXNET3 template",
+                "ostype": "CentOS 5.6 (64-bit)",
+                "isfeatured": True,
+                "ispublic": False,
+                "isextractable": True,
+                "mode": "HTTP_DOWNLOAD",
+                "templatefilter": "self",
+                "url": "http://people.apache.org/~sanjeev/systemvm64template-2014-09-30-4.3-vmware.ova",
+                "hypervisor": "vmware",
+                "format": "OVA",
+                "nicadapter": "vmxnet3",
                 "kvm": {
-                        "url": ""
-                    },
-                    "vmware": {
-                        "url": ""
-                    },
-                    "xenserver": {
-                        "url": ""
-                    },
-                    "hyperv": {
-                        "url": ""
-                    },
-                    "ostype": 'CentOS 5.3 (64-bit)',
-                    "mode": 'HTTP_DOWNLOAD'
-                }
-        },
-    # Nuage VSP SDN plugin specific test data
-    "nuagevsp": {
-        # Services supported by the Nuage VSP plugin for Isolated networks
-        "isolated_network_offering": {
-            "name": 'nuage_marvin',
-            "displaytext": 'nuage_marvin',
-            "guestiptype": 'Isolated',
-            "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,UserData,Firewall,Dns',
-            "traffictype": 'GUEST',
-            "availability": 'Optional',
-            "tags": "nuage",
-            "serviceProviderList": {
-                "Dhcp": 'NuageVsp',
-                "StaticNat": 'NuageVsp',
-                "SourceNat": 'NuageVsp',
-                "Firewall": 'NuageVsp',
-                "Connectivity": 'NuageVsp',
-                "UserData": 'VirtualRouter',
-                "Dns": 'VirtualRouter'
-            },
-            "serviceCapabilityList": {
-                    "SourceNat": {"SupportedSourceNatTypes": "perzone"}
-            }
-        },
-        # Persistent services supported by the Nuage VSP plugin for Isolated networks
-        "isolated_network_offering_persistent": {
-            "name": 'nuage_marvin',
-            "displaytext": 'nuage_marvin',
-            "guestiptype": 'Isolated',
-            "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,UserData,Firewall,Dns',
-            "traffictype": 'GUEST',
-            "availability": 'Optional',
-            "ispersistent": 'True',
-            "tags": "nuage",
-            "serviceProviderList": {
-                "Dhcp": 'NuageVsp',
-                "StaticNat": 'NuageVsp',
-                "SourceNat": 'NuageVsp',
-                "Firewall": 'NuageVsp',
-                "Connectivity": 'NuageVsp',
-                "UserData": 'VirtualRouter',
-                "Dns": 'VirtualRouter'
-            },
-            "serviceCapabilityList": {
-                "SourceNat": {"SupportedSourceNatTypes": "perzone"}
-            }
-        },
-        # Persistent services supported by the Nuage VSP plugin for Isolated networks
-        "isolated_network_offering_persistent": {
-            "name": 'nuage_marvin',
-            "displaytext": 'nuage_marvin',
-            "guestiptype": 'Isolated',
-            "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,UserData,Firewall,Dns',
-            "traffictype": 'GUEST',
-            "availability": 'Optional',
-            "ispersistent": 'True',
-            "tags": "nuage",
-            "serviceProviderList": {
-                "Dhcp": 'NuageVsp',
-                "StaticNat": 'NuageVsp',
-                "SourceNat": 'NuageVsp',
-                "Firewall": 'NuageVsp',
-                "Connectivity": 'NuageVsp',
-                "UserData": 'VirtualRouter',
-                "Dns": 'VirtualRouter'
-            },
-            "serviceCapabilityList": {
-                "SourceNat": {"SupportedSourceNatTypes": "perzone"}
-            }
-        },
-        # Purely nuage network offering
-        "isolated_network_offering_without_vr": {
-            "name": 'nuage_marvin',
-            "displaytext": 'nuage_marvin',
-            "guestiptype": 'Isolated',
-            "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,Firewall',
-            "traffictype": 'GUEST',
-            "availabiliy": 'Optional',
-            "tags": "nuage",
-            "serviceProviderList": {
-                "Dhcp": 'NuageVsp',
-                "StaticNat": 'NuageVsp',
-                "SourceNat": 'NuageVsp',
-                "Firewall": 'NuageVsp',
-                "Connectivity": 'NuageVsp'
-            },
-            "serviceCapabilityList": {
-                "SourceNat": {"SupportedSourceNatTypes": "perzone"}
-            }
-        },
-        # Purely persistent nuage network offering
-        "isolated_network_offering_without_vr_persistent": {
-            "name": 'nuage_marvin',
-            "displaytext": 'nuage_marvin',
-            "guestiptype": 'Isolated',
-            "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,Firewall',
-            "traffictype": 'GUEST',
-            "availability": 'Optional',
-            "tags": "nuage",
-            "ispersistent": 'True',
-            "serviceProviderList": {
-                "Dhcp": 'NuageVsp',
-                "StaticNat": 'NuageVsp',
-                "SourceNat": 'NuageVsp',
-                "Firewall": 'NuageVsp',
-                "Connectivity": 'NuageVsp'
-            },
-            "serviceCapabilityList": {
-                "SourceNat": {"SupportedSourceNatTypes": "perzone"}
-            }
-        },
-        # Purely nuage network offering
-        "isolated_network_offering_without_vr": {
-            "name": 'nuage_marvin',
-            "displaytext": 'nuage_marvin',
-            "guestiptype": 'Isolated',
-            "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,Firewall',
-            "traffictype": 'GUEST',
-            "availabiliy": 'Optional',
-            "tags": "nuage",
-            "serviceProviderList": {
-                "Dhcp": 'NuageVsp',
-                "StaticNat": 'NuageVsp',
-                "SourceNat": 'NuageVsp',
-                "Firewall": 'NuageVsp',
-                "Connectivity": 'NuageVsp'
-            },
-            "serviceCapabilityList": {
-                "SourceNat": {"SupportedSourceNatTypes": "perzone"}
-            }
-        },
-        # Purely persistent nuage network offering
-        "isolated_network_offering_without_vr_persistent": {
-            "name": 'nuage_marvin',
-            "displaytext": 'nuage_marvin',
-            "guestiptype": 'Isolated',
-            "supportedservices": 'Dhcp,SourceNat,Connectivity,StaticNat,Firewall',
-            "traffictype": 'GUEST',
-            "availability": 'Optional',
-            "tags": "nuage",
-            "ispersistent": 'True',
-            "serviceProviderList": {
-                "Dhcp": 'NuageVsp',
-                "StaticNat": 'NuageVsp',
-                "SourceNat": 'NuageVsp',
-                "Firewall": 'NuageVsp',
-                "Connectivity": 'NuageVsp'
-            },
-            "serviceCapabilityList": {
-                "SourceNat": {"SupportedSourceNatTypes": "perzone"}
-            }
-        },
-        # Services supported by the Nuage VSP plugin for VPC networks
-        "vpc_network_offering": {
-            "name": 'nuage_vpc_marvin',
-            "displaytext": 'nuage_vpc_marvin',
-            "guestiptype": 'Isolated',
-            "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,UserData,Dns',
-            "traffictype": 'GUEST',
-            "availability": 'Optional',
-            "useVpc": 'on',
-            "ispersistent": 'True',
-            "tags": "nuage",
-            "serviceProviderList": {
-                "Dhcp": "NuageVsp",
-                "StaticNat": "NuageVsp",
-                "SourceNat": "NuageVsp",
-                "NetworkACL": "NuageVsp",
-                "Connectivity": "NuageVsp",
-                "UserData": "VpcVirtualRouter",
-                "Dns": "VpcVirtualRouter"
-            },
-            "serviceCapabilityList": {
-                "SourceNat": {"SupportedSourceNatTypes": "perzone"}
-            }
-        },
-        "vpc_network_offering_internal_lb": {
-            "name": "nuage_vpc_marvin_internal_lb",
-            "displaytext": "nuage_vpc_marvin_internal_lb",
-            "guestiptype": 'Isolated',
-            "supportedservices": 'Dhcp,Lb,StaticNat,SourceNat,NetworkACL,Connectivity,UserData,Dns',
-            "traffictype": 'GUEST',
-            "availability": 'Optional',
-            "tags": "nuage",
-            "useVpc": 'on',
-            "ispersistent": 'True',
-            "serviceProviderList": {
-                "Dhcp": "NuageVsp",
-                "Lb": "InternalLbVm",
-                "StaticNat": "NuageVsp",
-                "SourceNat": "NuageVsp",
-                "NetworkACL": "NuageVsp",
-                "Connectivity": "NuageVsp",
-                "UserData": "VpcVirtualRouter",
-                "Dns": "VpcVirtualRouter"
-            },
-            "serviceCapabilityList": {
-                "SourceNat": {"SupportedSourceNatTypes": "perzone"},
-                "Lb": {"lbSchemes": "internal", "SupportedLbIsolation": "dedicated"}
-            }
-        },
-        # Services supported by the Nuage VSP plugin for VPCs
-        "vpc_offering": {
-            "name": 'Nuage VSP VPC offering',
-            "displaytext": 'Nuage VSP VPC offering',
-            "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,UserData,Dns',
-            "serviceProviderList": {
-                "Dhcp": "NuageVsp",
-                "StaticNat": "NuageVsp",
-                "SourceNat": "NuageVsp",
-                "NetworkACL": "NuageVsp",
-                "Connectivity": "NuageVsp",
-                "UserData": "VpcVirtualRouter",
-                "Dns": "VpcVirtualRouter"
-            }
-        },
-        "vpc_offering_lb": {
-            "name": 'Nuage VSP VPC offering with Lb',
-            "displaytext": 'Nuage VSP VPC offering with Lb',
-            "supportedservices": 'Dhcp,Lb,StaticNat,SourceNat,NetworkACL,Connectivity,UserData,Dns',
-            "serviceProviderList": {
-                "Dhcp": "NuageVsp",
-                "Lb": "InternalLbVm",
-                "StaticNat": "NuageVsp",
-                "SourceNat": "NuageVsp",
-                "NetworkACL": "NuageVsp",
-                "Connectivity": "NuageVsp",
-                "UserData": "VpcVirtualRouter",
-                "Dns": "VpcVirtualRouter"
-            }
-        },
-        # Services supported by the Nuage VSP plugin for VPC without userdata
-        "vpc_network_offering_nuage_dhcp": {
-            "name": 'nuage_vpc_marvin',
-            "displaytext": 'nuage_vpc_marvin',
-            "guestiptype": 'Isolated',
-            "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,Dns',
-            "traffictype": 'GUEST',
-            "availability": 'Optional',
-            "useVpc": 'on',
-            "ispersistent": 'True',
-            "serviceProviderList": {
-                "Dhcp": "NuageVsp",
-                "StaticNat": "NuageVsp",
-                "SourceNat": "NuageVsp",
-                "NetworkACL": "NuageVsp",
-                "Connectivity": "NuageVsp",
-                "Dns": "VpcVirtualRouter",
-            },
-            "serviceCapabilityList": {
-                "SourceNat": {"SupportedSourceNatTypes": "perzone"}
-            }
-        },
-        # Services supported by the Nuage VSP plugin for VPCs
-        "vpc_offering_nuage_dhcp": {
-            "name": 'Nuage VSP VPC offering',
-            "displaytext": 'Nuage VSP VPC offering',
-            "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,Dns',
-            "serviceProviderList": {
-                "Dhcp": "NuageVsp",
-                "StaticNat": "NuageVsp",
-                "SourceNat": "NuageVsp",
-                "NetworkACL": "NuageVsp",
-                "Connectivity": "NuageVsp",
-                "Dns": "VpcVirtualRouter",
-            }
-        },
-        "shared_nuage_network_offering": {
-            "name": 'nuage_marvin',
-            "displaytext": 'nuage_marvin',
-            "guestiptype": 'shared',
-            "supportedservices": 'Dhcp,Connectivity',
-            "traffictype": 'GUEST',
-            "specifyVlan": "False",
-            "specifyIpRanges": "True",
-            "availability": 'Optional',
-            "tags": "nuage",
-            "serviceProviderList": {
-                "Dhcp": "NuageVsp",
-                "Connectivity": "NuageVsp"
-            }
-        },
-        "shared_nuage_public_network_offering": {
-            "name": 'nuage_marvin',
-            "displaytext": 'nuage_marvin',
-            "guestiptype": 'shared',
-            "supportedservices": 'Dhcp,Connectivity',
-            "traffictype": 'GUEST',
-            "specifyVlan": "False",
-            "specifyIpRanges": "True",
-            "availability": 'Optional',
-            "tags": "nuage",
-            "serviceProviderList": {
-                "Dhcp": "NuageVsp",
-                "Connectivity": "NuageVsp"
-            },
-            "serviceCapabilityList": {
-                "Connectivity": {
-                    "PublicAccess": "true"
-                }
+                    "url": ""
+                },
+                "vmware": {
+                    "url": ""
+                },
+                "xenserver": {
+                    "url": ""
+                },
+                "hyperv": {
+                    "url": ""
+                },
+                "ostype": 'CentOS 5.3 (64-bit)',
+                "mode": 'HTTP_DOWNLOAD'
             }
-
-        },
-        # Test data for Shared Network creation
-        "network_all": {
-            "name": "SharedNetwork-All-nuage",
-            "displaytext": "SharedNetwork-All-nuage",
-            "gateway": "10.200.100.1",
-            "netmask": "255.255.255.0",
-            "startip": "10.200.100.21",
-            "endip": "10.200.100.100",
-            "acltype": "Domain"
-        },
-        "network_domain_with_no_subdomain_access": {
-            "name": "SharedNetwork-Domain-nosubdomain-nuage",
-            "displaytext": "SharedNetwork-Domain-nosubdomain-nuage",
-            "gateway": "10.222.1.1",
-            "netmask": "255.255.255.0",
-            "startip": "10.222.1.2",
-            "endip": "10.222.1.100",
-            "acltype": "Domain",
-            "subdomainaccess": "false"
-        },
-        "network_domain_with_subdomain_access": {
-            "name": "SharedNetwork-Domain-withsubdomain-nuage",
-            "displaytext": "SharedNetwork-Domain-withsubdomain-nuage",
-            "gateway": "10.221.1.1",
-            "netmask": "255.255.255.0",
-            "startip": "10.221.1.2",
-            "endip": "10.221.1.100",
-            "acltype": "Domain",
-            "subdomainaccess": "true"
-        },
-        "network_account": {
-            "name": "SharedNetwork-Account-nuage",
-            "displaytext": "SharedNetwork-Account-nuage",
-            "gateway": "10.220.1.1",
-            "netmask": "255.255.255.0",
-            "startip": "10.220.1.2",
-            "endip": "10.220.1.100",
-            "acltype": "Account"
-        },
-        "publiciprange1": {
-            "gateway": "10.200.100.1",
-            "netmask": "255.255.255.0",
-            "startip": "10.200.100.101",
-            "endip": "10.200.100.105",
-            "forvirtualnetwork": "false"
-        },
-        "publiciprange2": {
-            "gateway": "10.219.1.1",
-            "netmask": "255.255.255.0",
-            "startip": "10.219.1.2",
-            "endip": "10.219.1.5",
-            "forvirtualnetwork": "false"
-        },
-        "publiciprange3": {
-            "gateway": "10.200.100.1",
-            "netmask": "255.255.255.0",
-            "startip": "10.200.100.2",
-            "endip": "10.200.100.20",
-            "forvirtualnetwork": "false"
         }
-    }
 }
-
diff --git a/tools/marvin/setup.py b/tools/marvin/setup.py
index 20b2f2ac8ef..7ff9a371fbc 100644
--- a/tools/marvin/setup.py
+++ b/tools/marvin/setup.py
@@ -57,7 +57,7 @@
           "ipmisim >= 0.7"
       ],
       extras_require={
-        "nuagevsp": ["libVSD", "PyYAML", "futures", "netaddr", "retries", "jpype1"]
+        "nuagevsp": ["vspk", "PyYAML", "futures", "netaddr", "retries", "jpype1"]
       },
       py_modules=['marvin.marvinPlugin'],
       zip_safe=False,


 

----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on GitHub and use the
URL above to go to the specific comment.
 
For queries about this service, please contact Infrastructure at:
users@infra.apache.org


> refactor plugins/nuagevsp tests to run from its own test_data.py file
> ---------------------------------------------------------------------
>
>                 Key: CLOUDSTACK-10303
>                 URL: https://issues.apache.org/jira/browse/CLOUDSTACK-10303
>             Project: CloudStack
>          Issue Type: Improvement
>      Security Level: Public(Anyone can view this level - this is the default.) 
>          Components: marvin
>    Affects Versions: 4.11.0.0
>         Environment: nuagevsp, simulator
>            Reporter: Raf Smeets
>            Assignee: Sigert Goeminne
>            Priority: Major
>
> refactor plugins/nuagevsp tests to run from its own test_data.py file and make sure that all nuagevsp tests run with simulator.



--
This message was sent by Atlassian JIRA
(v7.6.3#76005)


Mime
View raw message