cloudstack-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From tall...@apache.org
Subject [1/6] git commit: updated refs/heads/master to de173bd
Date Thu, 17 Mar 2016 14:19:52 GMT
Repository: cloudstack
Updated Branches:
  refs/heads/master dc0ba6bd1 -> de173bd89


Add nuagevsp userdata testcase (Cloudstack-9095) & Refactor existing testcases


Project: http://git-wip-us.apache.org/repos/asf/cloudstack/repo
Commit: http://git-wip-us.apache.org/repos/asf/cloudstack/commit/3c8d3d0e
Tree: http://git-wip-us.apache.org/repos/asf/cloudstack/tree/3c8d3d0e
Diff: http://git-wip-us.apache.org/repos/asf/cloudstack/diff/3c8d3d0e

Branch: refs/heads/master
Commit: 3c8d3d0ee1288931369650195c8c316508483757
Parents: 359d20e
Author: Sowmya <sowmya.neeladhuri@nokia.com>
Authored: Tue Mar 8 18:13:24 2016 -0800
Committer: Sowmya <sowmya.neeladhuri@nokia.com>
Committed: Tue Mar 8 18:13:24 2016 -0800

----------------------------------------------------------------------
 test/integration/component/test_nuage_vsp.py    | 334 --------
 .../plugins/nuagevsp/nuageTestCase.py           | 830 +++++++++++++++++++
 .../nuagevsp/test_nuage_password_reset.py       | 249 ++++++
 .../plugins/nuagevsp/test_nuage_vpc_network.py  |  98 +++
 .../plugins/nuagevsp/test_nuage_vsp.py          | 106 +++
 tools/marvin/marvin/config/test_data.py         | 110 +++
 tools/marvin/marvin/lib/base.py                 |  55 ++
 7 files changed, 1448 insertions(+), 334 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/cloudstack/blob/3c8d3d0e/test/integration/component/test_nuage_vsp.py
----------------------------------------------------------------------
diff --git a/test/integration/component/test_nuage_vsp.py b/test/integration/component/test_nuage_vsp.py
deleted file mode 100644
index e7bd10e..0000000
--- a/test/integration/component/test_nuage_vsp.py
+++ /dev/null
@@ -1,334 +0,0 @@
-# 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.
-
-""" P1 tests for NuageVsp network Plugin
-"""
-# Import Local Modules
-from nose.plugins.attrib import attr
-from marvin.cloudstackTestCase import cloudstackTestCase
-from marvin.cloudstackAPI import (listPhysicalNetworks,
-                                  listNetworkServiceProviders,
-                                  addNetworkServiceProvider,
-                                  deleteNetworkServiceProvider,
-                                  deleteNuageVspDevice,
-                                  updateNetworkServiceProvider,
-                                  addNuageVspDevice,
-                                  destroyVirtualMachine)
-from marvin.lib.utils import (cleanup_resources)
-from marvin.lib.base import (Account,
-                             VirtualMachine,
-                             ServiceOffering,
-                             NetworkOffering,
-                             Network)
-from marvin.lib.common import (get_domain,
-                               get_zone,
-                               get_template)
-
-import logging
-import unittest
-
-
-class Services:
-
-    """Test NuageVsp plugin
-    """
-
-    def __init__(self):
-        print "in __init__"
-        self.services = {
-            "account": {
-                "email": "cloudstack@cloudmonkey.com",
-                "firstname": "cloudstack",
-                "lastname": "bob",
-                "username": "admin",
-                "password": "password",
-            },
-            "service_offering": {
-                "name": "Tiny Instance",
-                "displaytext": "Tiny Instance",
-                "cpunumber": 1,
-                "cpuspeed": 100,    # in MHz
-                                    "memory": 128,       # In MBs
-            },
-            "virtual_machine": {
-                "displayname": "TestVM",
-                "username": "root",
-                "password": "password",
-                "ssh_port": 22,
-                "hypervisor": 'KVM',
-                "privateport": 22,
-                "publicport": 22,
-                "protocol": 'TCP',
-            },
-            "nuage_vsp_device": {
-                "hostname": '172.31.222.162',
-                "username": 'cloudstackuser1',
-                "password": 'cloudstackuser1',
-                "port": '8443',
-                "apiversion": 'v3_2',
-                "retrycount": '4',
-                "retryinterval": '60'
-            },
-            # services supported by Nuage for isolated networks.
-            "network_offering": {
-                "name": 'nuage_marvin',
-                "displaytext": 'nuage_marvin',
-                "guestiptype": 'Isolated',
-                "supportedservices":
-                'Dhcp,SourceNat,Connectivity,StaticNat,UserData,Firewall',
-                "traffictype": 'GUEST',
-                "availability": 'Optional',
-                "serviceProviderList": {
-                    "UserData": 'VirtualRouter',
-                    "Dhcp": 'NuageVsp',
-                    "Connectivity": 'NuageVsp',
-                    "StaticNat": 'NuageVsp',
-                    "SourceNat": 'NuageVsp',
-                    "Firewall": 'NuageVsp'
-                },
-                "serviceCapabilityList": {
-                    "SourceNat": {"SupportedSourceNatTypes": "perzone"},
-                }
-            },
-            "network": {
-                "name": "nuage",
-                "displaytext": "nuage",
-            },
-            "ostype": 'CentOS 5.5 (64-bit)',
-            "sleep": 60,
-            "timeout": 10
-        }
-
-
-class TestNuageVsp(cloudstackTestCase):
-
-    @classmethod
-    def setUpClass(cls):
-        print "In setup class"
-        cls._cleanup = []
-        cls.testClient = super(TestNuageVsp, cls).getClsTestClient()
-        cls.api_client = cls.testClient.getApiClient()
-
-        cls.services = Services().services
-        # Get Zone, Domain and templates
-        cls.domain = get_domain(cls.api_client)
-        cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests())
-        cls.template = get_template(
-            cls.api_client,
-            cls.zone.id,
-            cls.services["ostype"]
-        )
-        # nuage vsp device brings the Nuage virtual service platform into play
-        cls.nuage_services = cls.services["nuage_vsp_device"]
-        try:
-
-            resp = listPhysicalNetworks.listPhysicalNetworksCmd()
-            print "in cls.setupClass- resp: %s" % resp
-            resp.zoneid = cls.zone.id
-            physical_networks = cls.api_client.listPhysicalNetworks(resp)
-            for pn in physical_networks:
-                if pn.isolationmethods=='VSP':
-                    physical_network = pn
-            #if isinstance(physical_networks, list):
-            #    physical_network = physical_networks[1]
-            resp = listNetworkServiceProviders.listNetworkServiceProvidersCmd()
-            resp.name = 'NuageVsp'
-            resp.physicalnetworkid = physical_network.id
-            nw_service_providers = cls.api_client.listNetworkServiceProviders(
-                resp)
-            if not isinstance(nw_service_providers, list):
-                # create network service provider and add nuage vsp device
-                resp_add_nsp =\
-                    addNetworkServiceProvider.addNetworkServiceProviderCmd()
-                resp_add_nsp.name = 'NuageVsp'
-                resp_add_nsp.physicalnetworkid = physical_network.id
-                cls.api_client.addNetworkServiceProvider(resp_add_nsp)
-                #Get NSP ID
-                nw_service_providers = cls.api_client.listNetworkServiceProviders(
-                    resp)
-                cls.debug("NuageVsp NSP ID: %s" % nw_service_providers[0].id)
-
-                resp_add_device = addNuageVspDevice.addNuageVspDeviceCmd()
-                resp_add_device.physicalnetworkid = physical_network.id
-                resp_add_device.username = cls.nuage_services["username"]
-                resp_add_device.password = cls.nuage_services["password"]
-                resp_add_device.hostname = cls.nuage_services["hostname"]
-                resp_add_device.port = cls.nuage_services["port"]
-                resp_add_device.apiversion = cls.nuage_services[
-                   "apiversion"]
-                resp_add_device.retrycount = cls.nuage_services[
-                    "retrycount"]
-                resp_add_device.retryinterval = cls.nuage_services[
-                    "retryinterval"]
-                cls.nuage = cls.api_client.addNuageVspDevice(
-                    resp_add_device)
-                #Enable NuageVsp NSP 
-                cls.debug("NuageVsp NSP ID : %s" % nw_service_providers[0].id)
-                resp_up_nsp = \
-                    updateNetworkServiceProvider.updateNetworkServiceProviderCmd()
-                resp_up_nsp.id = nw_service_providers[0].id
-                resp_up_nsp.state = 'Enabled'
-                cls.api_client.updateNetworkServiceProvider(resp_up_nsp)
-
-            cls.network_offering = NetworkOffering.create(
-                cls.api_client,
-                cls.services["network_offering"],
-                conservemode=True
-            )
-            cls._cleanup.append(cls.network_offering)
-
-            cls.network_offering.update(cls.api_client, state='Enabled')
-            cls.services["virtual_machine"]["zoneid"] = cls.zone.id
-            cls.services["virtual_machine"]["template"] = cls.template.id
-            cls.service_offering = ServiceOffering.create(
-                cls.api_client,
-                cls.services["service_offering"]
-            )
-            cls._cleanup.append(cls.service_offering)
-        except Exception as e:
-            cls.tearDownClass()
-            raise unittest.SkipTest("Unable to add VSP device")
-        return
-
-    @classmethod
-    def tearDownClass(cls):
-        try:
-            cleanup_resources(cls.api_client, cls._cleanup)
-        except Exception as e:
-            raise Exception("Warning: Exception during cleanup : %s" % e)
-        return
-
-
-    def setUp(self):
-        self.apiclient = self.testClient.getApiClient()
-        self.dbclient = self.testClient.getDbConnection()
-        self.account = Account.create(
-            self.apiclient,
-            self.services["account"],
-            admin=True,
-            domainid=self.domain.id
-        )
-        self.cleanup = [self.account]
-        return
-
-
-    def tearDown(self):
-        try:
-            self.debug("Cleaning up the resources")
-            cleanup_resources(self.apiclient, self.cleanup)
-            self.debug("Cleanup complete!")
-        except Exception as e:
-            raise Exception("Warning: Exception during cleanup : %s" % e)
-        return
-
-    @attr(tags=["advanced"])
-    def test_network_vsp(self):
-        """Test nuage Network and VM Creation
-        """
-
-        self.debug("Creating network with network offering: %s" %
-                   self.network_offering.id)
-        self.network = Network.create(
-            self.apiclient,
-            self.services["network"],
-            accountid=self.account.name,
-            domainid=self.account.domainid,
-            networkofferingid=self.network_offering.id,
-            zoneid=self.zone.id,
-            gateway = "10.1.1.1",
-            netmask = '255.255.255.0'
-        )
-        self.debug("Created network with ID: %s" % self.network.id)
-
-        self.debug("Deploying VM in account: %s" % self.account.name)
-
-        virtual_machine_1 = VirtualMachine.create(
-            self.apiclient,
-            self.services["virtual_machine"],
-            accountid=self.account.name,
-            domainid=self.account.domainid,
-            serviceofferingid=self.service_offering.id,
-            networkids=[str(self.network.id)]
-        )
-        self.debug("Deployed VM in network: %s" % self.network.id)
-        list_vm_response = VirtualMachine.list(
-            self.apiclient,
-            id=virtual_machine_1.id
-        )
-
-        self.debug(
-            "Verify listVirtualMachines response for virtual machine: %s"
-            % virtual_machine_1.id
-        )
-
-        self.assertEqual(
-            isinstance(list_vm_response, list),
-            True,
-            "Check list response returns a valid list"
-        )
-        vm_response = list_vm_response[0]
-
-        self.assertEqual(
-            vm_response.state,
-            "Running",
-            "VM state should be running after deployment"
-        )
-
-        self.debug("Deploying another VM in account: %s" %
-                   self.account.name)
-
-        virtual_machine_2 = VirtualMachine.create(
-            self.apiclient,
-            self.services["virtual_machine"],
-            accountid=self.account.name,
-            domainid=self.account.domainid,
-            serviceofferingid=self.service_offering.id,
-            networkids=[str(self.network.id)]
-        )
-        self.debug("Deployed VM in network: %s" % self.network.id)
-        list_vm_response = VirtualMachine.list(
-            self.apiclient,
-            id=virtual_machine_2.id
-        )
-
-        self.debug(
-            "Verify listVirtualMachines response for virtual machine: %s"
-            % virtual_machine_2.id
-        )
-
-        self.assertEqual(
-            isinstance(list_vm_response, list),
-            True,
-            "Check list response returns a valid list"
-        )
-        vm_response = list_vm_response[0]
-
-        self.assertEqual(
-            vm_response.state,
-            "Running",
-            "VM state should be running after deployment"
-        )
-
-        VirtualMachine.delete(virtual_machine_1, self.apiclient, expunge=True)
-
-        # # Deleting a single VM
-        VirtualMachine.delete(virtual_machine_2, self.apiclient, expunge=True)
-
-        # Delete Network
-        Network.delete(self.network, self.apiclient)
-
-        return

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/3c8d3d0e/test/integration/plugins/nuagevsp/nuageTestCase.py
----------------------------------------------------------------------
diff --git a/test/integration/plugins/nuagevsp/nuageTestCase.py b/test/integration/plugins/nuagevsp/nuageTestCase.py
new file mode 100644
index 0000000..123f2bc
--- /dev/null
+++ b/test/integration/plugins/nuagevsp/nuageTestCase.py
@@ -0,0 +1,830 @@
+# 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.
+
+""" Custom base class for NuageVsp network Plugin specific Marvin tests
+"""
+# Import Local Modules
+from marvin.cloudstackTestCase import cloudstackTestCase, unittest
+from marvin.lib.base import (NetworkServiceProvider,
+                             ServiceOffering,
+                             NetworkOffering,
+                             Network,
+                             Router,
+                             Nuage,
+                             VPC,
+                             VpcOffering,
+                             PublicIPAddress,
+                             VirtualMachine,
+                             StaticNATRule,
+                             NetworkACLList,
+                             NetworkACL,
+                             FireWallRule,
+                             EgressFireWallRule,
+                             Host)
+from marvin.lib.common import (get_zone,
+                               get_domain,
+                               get_template,
+                               list_templates,
+                               wait_for_cleanup)
+from marvin.lib.utils import cleanup_resources
+from marvin.cloudstackAPI import (listPhysicalNetworks,
+                                  updateConfiguration,
+                                  updateTemplate,
+                                  listConfigurations,
+                                  listHypervisors,
+                                  stopRouter,
+                                  startRouter)
+# Import nosetests Modules
+from nose.plugins.attrib import attr
+
+# Import System Modules
+import socket
+import importlib
+import logging
+
+
+class nuageTestCase(cloudstackTestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        cls.debug("setUpClass nuageTestCase")
+
+        # We want to fail quicker, if it's a failure
+        socket.setdefaulttimeout(60)
+
+        test_client = super(nuageTestCase, cls).getClsTestClient()
+        cls.api_client = test_client.getApiClient()
+        cls.db_client = test_client.getDbConnection()
+        cls.test_data = test_client.getParsedTestDataConfig()
+
+        # Get Zone, Domain and templates
+        cls.zone = get_zone(cls.api_client)
+        cls.domain = get_domain(cls.api_client)
+        cls.template = get_template(cls.api_client,
+                                    cls.zone.id,
+                                    cls.test_data["ostype"]
+                                    )
+        cls.test_data["virtual_machine"]["zoneid"] = cls.zone.id
+        cls.test_data["virtual_machine"]["template"] = cls.template.id
+
+        # Create service offering
+        cls.service_offering = ServiceOffering.create(cls.api_client,
+                                                      cls.test_data["service_offering"]
+                                                      )
+        cls._cleanup = [cls.service_offering]
+
+        # Get configured Nuage Vsp device details
+        try:
+            resp = listPhysicalNetworks.listPhysicalNetworksCmd()
+            resp.zoneid = cls.zone.id
+            physical_networks = cls.api_client.listPhysicalNetworks(resp)
+            for pn in physical_networks:
+                if pn.isolationmethods == 'VSP':
+                    cls.vsp_physical_network = pn
+            cls.nuage_vsp_device = Nuage.list(cls.api_client,
+                                              physicalnetworkid=cls.vsp_physical_network.id
+                                              )[0]
+            pns = cls.config.zones[0].physical_networks
+            providers = filter(lambda physical_network: 'VSP' in physical_network.isolationmethods, pns)[0].providers
+            devices = filter(lambda provider: provider.name == 'NuageVsp', providers)[0].devices
+            cls.nuage_vsp_device.username = devices[0].username
+            cls.nuage_vsp_device.password = devices[0].password
+            listConfigurationsCmd = listConfigurations.listConfigurationsCmd()
+            listConfigurationsCmd.name = "nuagevsp.cms.id"
+            listConfigurationsCmd.scopename = "global"
+            cs_config_dict = cls.api_client.listConfigurations(listConfigurationsCmd)
+            cls.cms_id = str(cs_config_dict[0].value).split(":")[1]
+        except Exception as e:
+            cls.tearDownClass()
+            raise unittest.SkipTest("Warning: Couldn't get configured Nuage Vsp device details: %s" % e)
+
+        # Check if the host hypervisor type is simulator
+        resp = listHypervisors.listHypervisorsCmd()
+        resp.zoneid = cls.zone.id
+        cls.isSimulator = cls.api_client.listHypervisors(resp)[0].name == 'Simulator'
+
+        # VSD is a Python SDK for Nuage Vsp
+        try:
+            vspk_module = "vspk." + cls.nuage_vsp_device.apiversion if int(cls.nuage_vsp_device.apiversion[1]) >= 4 \
+                else "vspk.vsdk." + cls.nuage_vsp_device.apiversion
+            vsdk = importlib.import_module(vspk_module)
+            vspk_utils_module = "vspk.utils" if int(cls.nuage_vsp_device.apiversion[1]) >= 4 \
+                else "vspk.vsdk." + cls.nuage_vsp_device.apiversion + ".utils"
+            vsdk_utils = importlib.import_module(vspk_utils_module)
+            set_log_level = getattr(vsdk_utils, "set_log_level")
+            from cms_vspk_wrapper.cms_vspk_wrapper import Cms_vspk_wrapper
+        except:
+            raise unittest.SkipTest("vspk (and/or) cms_vspk_wrapper import failure")
+
+        # Configure VSD session
+        cls._session = vsdk.NUVSDSession(username=cls.nuage_vsp_device.username,
+                                         password=cls.nuage_vsp_device.password,
+                                         enterprise="csp", api_url="https://%s:%d" %
+                                                                   (cls.nuage_vsp_device.hostname,
+                                                                    cls.nuage_vsp_device.port)
+                                         )
+        cls._session.start()
+
+        # Configure cms_vspk_wrapper session
+        cls.log_handler = logging.getLogger("CSLog").handlers[0]
+        vsd_info = cls.nuage_vsp_device.__dict__
+        vsd_info["port"] = str(vsd_info["port"])
+        cls.vsd = Cms_vspk_wrapper(vsd_info, cls.log_handler)
+
+        set_log_level(logging.INFO)
+
+        cls.debug("setUpClass nuageTestCase [DONE]")
+
+    def setUp(self):
+        self.cleanup = []
+        return
+
+    @classmethod
+    def tearDownClass(cls):
+        try:
+            # Cleanup resources used
+            cleanup_resources(cls.api_client, cls._cleanup)
+        except Exception as e:
+            cls.debug("Warning: Exception during cleanup : %s" % e)
+        return
+
+    def tearDown(self):
+        # Cleanup resources used
+        self.debug("Cleaning up the resources")
+        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
+
+    def getConfigurationValue(self, name, scope="global"):
+        listConfigurationsCmd = listConfigurations.listConfigurationsCmd()
+        listConfigurationsCmd.name = name
+        listConfigurationsCmd.scopename = scope
+        if scope is "zone":
+            listConfigurationsCmd.zoneid = self.zone.id
+        return self.api_client.listConfigurations(listConfigurationsCmd)
+
+    def setConfigurationValue(self, name, value, scope="global"):
+        cmd = updateConfiguration.updateConfigurationCmd()
+        cmd.name = name
+        cmd.scopename = scope
+        if scope is "zone":
+            cmd.zoneid = self.zone.id
+        cmd.value = value
+        self.api_client.updateConfiguration(cmd)
+
+    def updateTemplate(self, value):
+        self.debug("UPDATE TEMPLATE")
+        cmd = updateTemplate.updateTemplateCmd()
+        cmd.id = self.template.id
+        cmd.passwordenabled = value
+        self.api_client.updateTemplate(cmd)
+        list_template_response = list_templates(self.api_client,
+                                                templatefilter="all",
+                                                id=self.template.id
+                                                )
+        self.template = list_template_response[0]
+
+    # Creates the vpc offering
+    def create_VpcOffering(self, vpc_offering, suffix=None):
+        self.debug('Create VpcOffering')
+        if suffix:
+            vpc_offering["name"] = "VPC_OFF-" + str(suffix)
+        vpc_off = VpcOffering.create(self.api_client,
+                                     vpc_offering
+                                     )
+        # Enable VPC offering
+        vpc_off.update(self.api_client, state='Enabled')
+        self.cleanup.append(vpc_off)
+        self.debug('Created and Enabled VpcOffering')
+        return vpc_off
+
+    # create_Vpc - Takes the vpc offering as arguments and creates the VPC
+    def create_Vpc(self, vpc_offering, cidr='10.1.1.1/16', cleanup=True):
+        self.debug("Creating a VPC network in the account: %s" % self.account.name)
+        self.test_data["vpc"]["cidr"] = cidr
+        vpc = VPC.create(
+            self.api_client,
+            self.test_data["vpc"],
+            vpcofferingid=vpc_offering.id,
+            zoneid=self.zone.id,
+            account=self.account.name,
+            domainid=self.account.domainid
+        )
+        self.debug("Created VPC with ID: %s" % vpc.id)
+        if cleanup:
+            self.cleanup.append(vpc)
+        return vpc
+
+    # create_NetworkOffering - Takes the network offering as argument and creates the Network Offering
+    def create_NetworkOffering(self, net_offering, suffix=None, conserve_mode=False):
+        self.debug('Create NetworkOffering')
+        if suffix:
+            net_offering["name"] = "NET_OFF-" + str(suffix)
+        nw_off = NetworkOffering.create(self.api_client,
+                                        net_offering,
+                                        conservemode=conserve_mode
+                                        )
+        # Enable Network offering
+        nw_off.update(self.api_client, state='Enabled')
+        self.cleanup.append(nw_off)
+        self.debug('Created and Enabled NetworkOffering')
+        return nw_off
+
+    # create_Network - Takes the network offering as argument and nw_key and creates the network
+    def create_Network(self, nw_off, nw_key="network", gateway='10.1.1.1', netmask='255.255.255.0', vpc=None, acl_list=None):
+        if not hasattr(nw_off, "id"):
+            nw_off = self.create_NetworkOffering(nw_off)
+        self.debug('Adding Network=%s' % self.test_data[nw_key])
+        self.test_data[nw_key]["netmask"] = netmask
+        obj_network = Network.create(self.api_client,
+                                     self.test_data[nw_key],
+                                     accountid=self.account.name,
+                                     domainid=self.account.domainid,
+                                     networkofferingid=nw_off.id,
+                                     zoneid=self.zone.id,
+                                     gateway=gateway,
+                                     vpcid=vpc.id if vpc else self.vpc.id if hasattr(self, "vpc") else None,
+                                     aclid=acl_list.id if acl_list else None
+                                     )
+        self.debug("Created network with ID: %s" % obj_network.id)
+        self.cleanup.append(obj_network)
+        return obj_network
+
+    # upgrade_Network - Upgrades the given network
+    def upgrade_Network(self, nw_off, network):
+        if not hasattr(nw_off, "id"):
+            nw_off = self.create_NetworkOffering(nw_off, network.gateway)
+        self.debug('Update Network=%s' % network)
+        network.update(
+            self.api_client,
+            networkofferingid=nw_off.id,
+            changecidr=False
+        )
+        self.debug("Updated network with ID: %s" % network.id)
+
+    # delete_Network - Deletes the given network
+    def delete_Network(self, network):
+        self.debug('Deleting Network - %s' % network.name)
+        # Wait for network garbage collection before network deletion
+        wait_for_cleanup(self.api_client,
+                         ["network.gc.interval", "network.gc.wait"]
+                         )
+        network.delete(self.api_client)
+        if network in self.cleanup:
+            self.cleanup.remove(network)
+        self.debug('Deleted Network - %s' % network.name)
+
+    # create_VM_in_Network - Creates a VM in the given network, the vm_key - is the key for the services on the vm.
+    def create_VM_in_Network(self, network,  vm_key="virtual_machine", host_id=None, start_vm=True):
+        self.debug('Creating VM in network=%s' % network.name)
+        self.debug('Passed vm_key=%s' % vm_key)
+        self.test_data[vm_key]["zoneid"] = self.zone.id
+        self.test_data[vm_key]["template"] = self.template.id
+        vm = VirtualMachine.create(
+            self.api_client,
+            self.test_data[vm_key],
+            accountid=self.account.name,
+            domainid=self.account.domainid,
+            serviceofferingid=self.service_offering.id,
+            networkids=[str(network.id)],
+            startvm=start_vm,
+            hostid=host_id
+        )
+        self.debug('Created VM=%s in network=%s' % (vm.id, network.name))
+        self.cleanup.append(vm)
+        return vm
+
+    # starts the given vm
+    def start(self, apiclient):
+        """Start the instance"""
+        cmd = startVirtualMachine.startVirtualMachineCmd()
+        cmd.id = self.id
+        apiclient.startVirtualMachine(cmd)
+        response = self.getState(apiclient, VirtualMachine.RUNNING)
+        if response[0] == FAIL:
+            raise Exception(response[1])
+        return
+
+    # stops the given vm
+    def stop(self, apiclient, forced=None):
+        """Stop the instance"""
+        cmd = stopVirtualMachine.stopVirtualMachineCmd()
+        cmd.id = self.id
+        if forced:
+            cmd.forced = forced
+        apiclient.stopVirtualMachine(cmd)
+        response = self.getState(apiclient, VirtualMachine.STOPPED)
+        if response[0] == FAIL:
+            raise Exception(response[1])
+        return
+
+    # delete_VM - Deletes the given VM
+    def delete_VM(self, vm):
+        self.debug('Deleting VM - %s' % vm.name)
+        vm.delete(self.api_client)
+        # Wait for expunge interval to cleanup VM
+        wait_for_cleanup(self.api_client,
+                         ["expunge.delay", "expunge.interval"]
+                         )
+        if vm in self.cleanup:
+            self.cleanup.remove(vm)
+        self.debug('Deleted VM - %s' % vm.name)
+
+    # acquire_Public_IP - Acquires a public IP for the given network
+    def acquire_Public_IP(self, network, vpc=None):
+        self.debug("Associating public IP for network: %s" % network.name)
+        public_ip = PublicIPAddress.create(self.api_client,
+                                           accountid=self.account.name,
+                                           zoneid=self.zone.id,
+                                           domainid=self.account.domainid,
+                                           networkid=network.id if vpc is None else None,
+                                           vpcid=vpc.id if vpc else self.vpc.id if hasattr(self, "vpc") else None
+                                           )
+        self.debug("Associated %s with network %s" % (public_ip.ipaddress.ipaddress,
+                                                      network.id))
+        return public_ip
+
+    # create_StaticNatRule_For_VM - Creates static NAT rule for the given network , VM on the given public ip
+    def create_StaticNatRule_For_VM(self, vm, public_ip, network, vmguestip=None):
+        self.debug("Enabling static NAT for IP: %s" %
+                   public_ip.ipaddress.ipaddress)
+        StaticNATRule.enable(
+            self.api_client,
+            ipaddressid=public_ip.ipaddress.id,
+            virtualmachineid=vm.id,
+            networkid=network.id,
+            vmguestip=vmguestip
+        )
+        self.debug("Static NAT enabled for IP: %s" %
+                   public_ip.ipaddress.ipaddress)
+
+    # delete_StaticNatRule_For_VM - Deletes the static NAT rule for the given VM
+    def delete_StaticNatRule_For_VM(self, vm, public_ip):
+        self.debug("Disabling static NAT for IP: %s" %
+                   public_ip.ipaddress.ipaddress)
+        StaticNATRule.disable(
+            self.api_client,
+            ipaddressid=public_ip.ipaddress.id,
+            virtualmachineid=vm.id
+        )
+        self.debug("Static NAT disabled for IP: %s" %
+                   public_ip.ipaddress.ipaddress)
+
+    # create_firewall_rule - Creates the Ingress firewall rule on the given public ip
+    def create_firewall_rule(self, public_ip, rule=None):
+        if not rule:
+            rule = self.test_data["ingress_rule"]
+        self.debug("Adding an Ingress Firewall rule to make Guest VMs accessible through Static NAT")
+        return FireWallRule.create(self.api_client,
+                                   ipaddressid=public_ip.ipaddress.id,
+                                   protocol=rule["protocol"],
+                                   cidrlist=rule["cidrlist"],
+                                   startport=rule["startport"],
+                                   endport=rule["endport"]
+                                   )
+
+    # create_egress_firewall_rule - Creates the Egress firewall rule on the given public ip
+    def create_egress_firewall_rule(self, network, rule):
+        self.debug("Adding an Egress Firewall rule to allow/deny outgoing traffic from Guest VMs")
+        return EgressFireWallRule.create(self.api_client,
+                                         networkid=network.id,
+                                         protocol=rule["protocol"],
+                                         cidrlist=rule["cidrlist"],
+                                         startport=rule["startport"],
+                                         endport=rule["endport"]
+                                         )
+
+    # create_network_acl_list - Creates network ACL list in the given VPC
+    def create_network_acl_list(self, name, description, vpc):
+        self.debug("Adding NetworkACL list in VPC: %s" % vpc.id)
+        return NetworkACLList.create(self.api_client,
+                                     services={},
+                                     name=name,
+                                     description=description,
+                                     vpcid=vpc.id
+                                     )
+
+    # create_network_acl_rule - Creates network ACL rule Ingree/Egress in the given network
+    def create_network_acl_rule(self, rule, traffic_type="Ingress", network=None, acl_list=None):
+        self.debug("Adding NetworkACL rule: %s" % rule)
+        return NetworkACL.create(self.api_client,
+                                 networkid=network.id if network else None,
+                                 services=rule,
+                                 traffictype=traffic_type,
+                                 aclid=acl_list.id if acl_list else None
+                                 )
+
+    # migrate_vm - Migrates the VM to a different host if available
+    def migrate_vm(self, vm):
+        self.debug("Checking if a host is available for migration?")
+        hosts = Host.listForMigration(self.api_client)
+        self.assertEqual(isinstance(hosts, list), True,
+                         "List hosts should return a valid list"
+                         )
+        # Remove the host of current VM from the hosts list
+        hosts[:] = [host for host in hosts if host.id != vm.hostid]
+        if len(hosts) <= 0:
+            self.skipTest("No host available for migration. Test requires at-least 2 hosts")
+        host = hosts[0]
+        self.debug("Migrating VM-ID: %s to Host: %s" % (vm.id, host.id))
+        try:
+            vm.migrate(self.api_client, hostid=host.id)
+        except Exception as e:
+            self.fail("Failed to migrate instance, %s" % e)
+
+    # get_network_router - returns the router for the given network
+    def get_network_router(self, network):
+        self.debug("Finding the virtual router for network: %s" % network.name)
+        routers = Router.list(self.api_client,
+                              networkid=network.id,
+                              listall=True
+                              )
+        self.assertEqual(isinstance(routers, list), True,
+                         "List routers should return a valid virtual router for network"
+                         )
+        return routers[0]
+
+    # stop_network_router - Stops the given network router
+    def stop_network_router(self, router):
+        self.debug("Stopping Router with ID: %s" % router.id)
+        cmd = stopRouter.stopRouterCmd()
+        cmd.id = router.id
+        self.api_client.stopRouter(cmd)
+
+    # start_network_router - Starts the given network router
+    def start_network_router(self, router):
+        self.debug("Starting Router with ID: %s" % router.id)
+        cmd = startRouter.startRouterCmd()
+        cmd.id = router.id
+        self.api_client.startRouter(cmd)
+
+    # ssh_into_vm - Gets into the shell of the given VM
+    def ssh_into_vm(self, vm, public_ip):
+        self.debug("SSH into VM=%s on public_ip=%s" % (vm.name, public_ip.ipaddress.ipaddress))
+        ssh_client = vm.get_ssh_client(ipaddress=public_ip.ipaddress.ipaddress)
+        return ssh_client
+
+    # execute_cmd - Executes the given command on the given ssh client
+    def execute_cmd(self, ssh_client, cmd):
+        self.debug("EXECUTE SSH COMMAND: " + cmd)
+        ret_data = ""
+        out_list = ssh_client.execute(cmd)
+        if out_list is not None:
+            ret_data = ' '.join(map(str, out_list)).strip()
+            self.debug("ssh execute cmd result=" + ret_data)
+        else:
+            self.debug("ssh execute cmd result is None")
+        return ret_data
+
+    # wget_from_server - fetches the index.html file from the given public Ip
+    def wget_from_server(self, public_ip):
+        import urllib
+        self.debug("wget from a http server on public_ip=%s" % public_ip.ipaddress.ipaddress)
+        wget_file = urllib.urlretrieve("http://%s/index.html" % public_ip.ipaddress.ipaddress,
+                                       filename="index.html"
+                                       )
+        return wget_file
+
+    # validate_NetworkServiceProvider - Validates the Network Service Provider
+    # in the Nuage VSP Physical Network - matches the given provider name
+    # 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"""
+        self.debug("Check if the Network Service Provider is created successfully ?")
+        providers = NetworkServiceProvider.list(self.api_client,
+                                                name=provider_name,
+                                                physicalnetworkid=self.vsp_physical_network.id)
+        self.assertEqual(isinstance(providers, list), True,
+                         "List Network Service Provider should return a valid list"
+                         )
+        self.assertEqual(provider_name, providers[0].name,
+                         "Name of the Network Service Provider should match with the returned list data"
+                         )
+        if state:
+            self.assertEqual(providers[0].state, state,
+                             "Network Service Provider state should be '%s'" % state
+                             )
+        self.debug("Network Service Provider creation successfully validated - %s" % provider_name)
+
+    # validate_vpc_offering - Validates the VPC offering, matches the given VPC off name against the list of VPC offerings fetched
+    def validate_vpc_offering(self, vpc_offering, state=None):
+        """Validates the VPC offering"""
+        self.debug("Check if the VPC offering is created successfully ?")
+        vpc_offs = VpcOffering.list(self.api_client,
+                                    id=vpc_offering.id
+                                    )
+        self.assertEqual(isinstance(vpc_offs, list), True,
+                         "List VPC offering should return a valid list"
+                         )
+        self.assertEqual(vpc_offering.name, vpc_offs[0].name,
+                         "Name of the VPC offering should match with the returned list data"
+                         )
+        if state:
+            self.assertEqual(vpc_offs[0].state, state,
+                             "VPC offering state should be '%s'" % state
+                             )
+        self.debug("VPC offering creation successfully validated - %s" % vpc_offering.name)
+
+    # validate_vpc - Validates the given VPC matches, the given VPC name against the list of VPCs fetched
+    def validate_vpc(self, vpc, state=None):
+        """Validates the VPC"""
+        self.debug("Check if the VPC is created successfully ?")
+        vpcs = VPC.list(self.api_client,
+                        id=vpc.id
+                        )
+        self.assertEqual(isinstance(vpcs, list), True,
+                         "List VPC should return a valid list"
+                         )
+        self.assertEqual(vpc.name, vpcs[0].name,
+                         "Name of the VPC should match with the returned list data"
+                         )
+        if state:
+            self.assertEqual(vpcs[0].state, state,
+                             "VPC state should be '%s'" % state
+                             )
+        self.debug("VPC creation successfully validated - %s" % vpc.name)
+
+    # validate_network_offering - Validates the given  Network offering
+    # matches the given network offering name against the list of network
+    # offerings fetched
+    def validate_network_offering(self, net_offering, state=None):
+        """Validates the Network offering"""
+        self.debug("Check if the Network offering is created successfully ?")
+        net_offs = NetworkOffering.list(self.api_client,
+                                        id=net_offering.id
+                                        )
+        self.assertEqual(isinstance(net_offs, list), True,
+                         "List Network offering should return a valid list"
+                         )
+        self.assertEqual(net_offering.name, net_offs[0].name,
+                         "Name of the Network offering should match with the returned list data"
+                         )
+        if state:
+            self.assertEqual(net_offs[0].state, state,
+                             "Network offering state should be '%s'" % state
+                             )
+        self.debug("Network offering creation successfully validated - %s" % net_offering.name)
+
+    # validate_network - Validates the network - matches the given network name against the list of networks fetched
+    def validate_network(self, network, state=None):
+        """Validates the network"""
+        self.debug("Check if the network is created successfully ?")
+        networks = Network.list(self.api_client,
+                                id=network.id
+                                )
+        self.assertEqual(isinstance(networks, list), True,
+                         "List network should return a valid list"
+                         )
+        self.assertEqual(network.name, networks[0].name,
+                         "Name of the network should match with with the returned list data"
+                         )
+        if state:
+            self.assertEqual(networks[0].state, state,
+                             "Network state should be '%s'" % state
+                             )
+        self.debug("Network creation successfully validated - %s" % network.name)
+
+    # check_router_state - Fetches the list of routers and their states and matches the given router's state
+    def check_router_state(self, router, state=None):
+        self.debug("Check if the virtual router is in state - %s" % state)
+        routers = Router.list(self.api_client,
+                              id=router.id,
+                              listall=True
+                              )
+        self.assertEqual(isinstance(routers, list), True,
+                         "List router should return a valid list"
+                         )
+        if state:
+            self.assertEqual(routers[0].state, state,
+                             "Virtual router is not in the expected state"
+                             )
+        self.debug("Virtual router is in the expected state - %s" % state)
+
+    #   check_vm_state - Fetches the list of VMs and their states and matches the given VM's state
+    def check_vm_state(self, vm, state=None):
+        self.debug("Check if the VM instance is in state - %s" % state)
+        vms = VirtualMachine.list(self.api_client,
+                                  id=vm.id,
+                                  listall=True
+                                  )
+        self.assertEqual(isinstance(vms, list), True,
+                         "List virtual machine should return a valid list"
+                         )
+        if state:
+            self.assertEqual(vms[0].state, state,
+                             "Virtual machine is not in the expected state"
+                             )
+        self.debug("Virtual machine is in the expected state - %s" % state)
+
+    # validate_Public_IP - Looks if the given public ip is in the allocated state form the list of fetched public IPs
+    def validate_Public_IP(self, public_ip, network, static_nat=False, vm=None):
+        """Validates the Public IP"""
+        self.debug("Check if the Public IP is successfully assigned to the network ?")
+        public_ips = PublicIPAddress.list(self.api_client,
+                                          id=public_ip.ipaddress.id,
+                                          networkid=network.id,
+                                          isstaticnat=static_nat,
+                                          listall=True
+                                          )
+        self.assertEqual(isinstance(public_ips, list), True,
+                         "List public Ip for network should return a valid list"
+                         )
+        self.assertEqual(public_ips[0].ipaddress, public_ip.ipaddress.ipaddress,
+                         "List public Ip for network should list the assigned public Ip address"
+                         )
+        self.assertEqual(public_ips[0].state, "Allocated",
+                         "Assigned public Ip is not in the allocated state"
+                         )
+        if static_nat and vm:
+            self.assertEqual(public_ips[0].virtualmachineid, vm.id,
+                             "Static NAT Rule not enabled for the VM using the assigned public Ip"
+                             )
+        self.debug("Assigned Public IP is successfully validated - %s" % public_ip.ipaddress.ipaddress)
+
+    # VSD verifications
+
+    def fetch_by_external_id(self, fetcher, *cs_objects):
+        """ Fetches a child object by external id using the given fetcher, and uuids of the given cloudstack objects.
+        E.G.
+          - fetch_by_external_id(vsdk.NUSubnet(id="954de425-b860-410b-be09-c560e7dbb474").vms, cs_vm)
+          - fetch_by_external_id(session.user.floating_ips, cs_network, cs_public_ip)
+        :param fetcher: VSPK Fetcher to use to find the child entity
+        :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]))
+
+    # VSD verifications using cms_vspk_wrapper
+
+    def get_externalID(self, object_id):
+        return object_id + "@" + self.cms_id
+
+    # verify_vsp_network - Fetches the vsd domain, vsd zone and vsd subnet and Verifies the given network/VPC values match the fetched values
+    def verify_vsp_network(self, domain_id, network, vpc=None):
+        vsd_enterprise = self.vsd.get_enterprise(name=domain_id)
+        if vpc:
+            ext_network_id = self.get_externalID(vpc.id)
+        else:
+            ext_network_id = self.get_externalID(network.id)
+        ext_subnet_id = self.get_externalID(network.id)
+        vsd_domain = self.vsd.get_domain(externalID=ext_network_id)
+        vsd_zone = self.vsd.get_zone(externalID=ext_network_id)
+        vsd_subnet = self.vsd.get_subnet(externalID=ext_subnet_id)
+        self.debug("SHOW ENTERPRISE DATA FORMAT IN VSD")
+        self.debug(vsd_enterprise)
+        self.assertNotEqual(vsd_enterprise, None,
+                            "VSD Enterprise data format should not be a None type"
+                            )
+        self.debug("SHOW NETWORK DATA FORMAT IN VSD")
+        self.debug(vsd_domain)
+        self.debug(vsd_zone)
+        self.debug(vsd_subnet)
+        if vpc:
+            self.assertEqual(vsd_domain['description'], "VPC_" + vpc.name,
+                             "VSD domain description should match VPC name in CloudStack"
+                             )
+            self.assertEqual(vsd_zone['description'], "VPC_" + vpc.name,
+                             "VSD zone description should match VPC name in CloudStack"
+                             )
+        else:
+            self.assertEqual(vsd_domain['description'], network.name,
+                             "VSD domain description should match Isolated Network name in CloudStack"
+                             )
+            self.assertEqual(vsd_zone['description'], network.name,
+                             "VSD zone description should match Isolated Network name in CloudStack"
+                             )
+        self.assertEqual(vsd_subnet['description'], network.name,
+                         "VSD subnet description should match Isolated Network name in CloudStack"
+                         )
+
+    # verify_vsp_vm - Fetches the vsd vport, vsd vm and interface and Verifies the given VM values match the fetched values
+    def verify_vsp_vm(self, vm, stopped=None):
+        ext_vm_id = self.get_externalID(vm.id)
+        for nic in vm.nic:
+            ext_network_id = self.get_externalID(nic.networkid)
+            ext_nic_id = self.get_externalID(nic.id)
+            vsd_vport = self.vsd.get_vport(subnet_externalID=ext_network_id, vport_externalID=ext_nic_id)
+            vsd_vm_interface = self.vsd.get_vm_interface(externalID=ext_nic_id)
+            self.debug("SHOW VPORT and VM INTERFACE DATA FORMAT IN VSD")
+            self.debug(vsd_vport)
+            self.debug(vsd_vm_interface)
+            self.assertEqual(vsd_vport['active'], True,
+                             "VSD VM vport should be active"
+                             )
+            self.assertEqual(vsd_vm_interface['IPAddress'], nic.ipaddress,
+                             "VSD VM interface IP address should match VM's NIC IP address in CloudStack"
+                             )
+        vsd_vm = self.vsd.get_vm(externalID=ext_vm_id)
+        self.debug("SHOW VM DATA FORMAT IN VSD")
+        self.debug(vsd_vm)
+        if not self.isSimulator:
+            if stopped:
+                self.assertEqual(vsd_vm['status'], "DELETE_PENDING",
+                                 "VM state in VSD should be DELETE_PENDING"
+                                 )
+            else:
+                self.assertEqual(vsd_vm['status'], vm.state.upper(),
+                                 "VM state in VSD should match its state in CloudStack"
+                                 )
+    # verify_vsp_router - Fetches the vsd router and Verifies the given router status match the fetched status
+
+    def verify_vsp_router(self, router, stopped=None):
+        ext_router_id = self.get_externalID(router.id)
+        vsd_router = self.vsd.get_vm(externalID=ext_router_id)
+        self.debug("SHOW VIRTUAL ROUTER DATA FORMAT IN VSD")
+        self.debug(vsd_router)
+        if not self.isSimulator:
+            if stopped:
+                self.assertEqual(vsd_router['status'], "DELETE_PENDING",
+                                 "Router state in VSD should be DELETE_PENDING"
+                                 )
+            else:
+                self.assertEqual(vsd_router['status'], router.state.upper(),
+                                 "Router state in VSD should match its state in CloudStack"
+                                 )
+
+    # verify_vsp_floating_ip -  Verifies the floating IPs on the given public IP against the VSD FIP
+    def verify_vsp_floating_ip(self, network, vm, public_ipaddress, vpc=None):
+        ext_fip_id = self.get_externalID(network.id + ":" + public_ipaddress.id)
+        vsd_fip = self.vsd.get_floating_ip(externalID=ext_fip_id)
+        self.debug("SHOW FLOATING IP DATA FORMAT IN VSD")
+        self.debug(vsd_fip)
+        self.assertEqual(vsd_fip['address'], public_ipaddress.ipaddress,
+                         "Floating IP address in VSD should match acquired Public IP address in CloudStack"
+                         )
+        if vpc:
+            ext_network_id = self.get_externalID(vpc.id)
+        else:
+            ext_network_id = self.get_externalID(network.id)
+        vsd_domain = self.vsd.get_domain(externalID=ext_network_id)
+        self.debug("SHOW NETWORK DATA FORMAT IN VSD")
+        self.debug(vsd_domain)
+        self.assertEqual(vsd_domain['ID'], vsd_fip['parentID'],
+                         "Floating IP in VSD should be associated with the correct VSD domain, "
+                         "which in turn should correspond to the correct VPC (or) Isolated network in CloudStack"
+                         )
+        ext_subnet_id = self.get_externalID(network.id)
+        vsd_subnet = self.vsd.get_subnet(externalID=ext_subnet_id)
+        for nic in vm.nic:
+            if nic.networkname == vsd_subnet['description']:
+                ext_network_id = self.get_externalID(nic.networkid)
+                ext_nic_id = self.get_externalID(nic.id)
+                vsd_vport = self.vsd.get_vport(subnet_externalID=ext_network_id, vport_externalID=ext_nic_id)
+                self.debug("SHOW VM VPORT DATA FORMAT IN VSD")
+                self.debug(vsd_vport)
+        self.assertEqual(vsd_vport['associatedFloatingIPID'], vsd_fip['ID'],
+                         "Floating IP in VSD should be associated to the correct VSD vport, "
+                         "which in turn should correspond to the correct Static NAT enabled VM "
+                         "and Isolated Network in CloudStack"
+                         )
+
+    # verify_vsp_firewall_rule - Verifies the start port, destination port,
+    # protocol of the given firewall rule Ingress/Egress against the VSD
+    # firewall rule
+    def verify_vsp_firewall_rule(self, firewall_rule, traffic_type="Ingress"):
+        ext_fw_id = self.get_externalID(firewall_rule.id)
+        if traffic_type is "Ingress":
+            vsd_fw_rule = self.vsd.get_egress_acl_entry(externalID=ext_fw_id)
+        else:
+            vsd_fw_rule = self.vsd.get_ingress_acl_entry(externalID=ext_fw_id)
+        self.debug("SHOW ACL ENTRY IN VSD")
+        self.debug(vsd_fw_rule)
+        dest_port = str(firewall_rule.startport) + "-" + str(firewall_rule.endport)
+        self.assertEqual(vsd_fw_rule['destinationPort'], dest_port,
+                         "Destination Port in VSD should match Destination Port in CloudStack"
+                         )
+        vsd_protocol = str(vsd_fw_rule['protocol'])
+        self.debug("vsd protocol " + vsd_protocol)
+        protocol = "tcp"
+        if vsd_protocol == 6:
+            protocol = "tcp"
+        elif vsd_protocol == 1:
+            protocol = "icmp"
+        elif vsd_protocol == 17:
+            protocol = "udp"
+        self.assertEqual(protocol, firewall_rule.protocol.lower(),
+                         "Protocol in VSD should match Protocol in CloudStack"
+                         )

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/3c8d3d0e/test/integration/plugins/nuagevsp/test_nuage_password_reset.py
----------------------------------------------------------------------
diff --git a/test/integration/plugins/nuagevsp/test_nuage_password_reset.py b/test/integration/plugins/nuagevsp/test_nuage_password_reset.py
new file mode 100644
index 0000000..3e600c2
--- /dev/null
+++ b/test/integration/plugins/nuagevsp/test_nuage_password_reset.py
@@ -0,0 +1,249 @@
+# 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.
+
+""" Component tests for - userdata
+"""
+# Import Local Modules
+from marvin.lib.base import (VirtualMachine,
+                             Account,
+                             PublicIPAddress)
+from nose.plugins.attrib import attr
+from nuageTestCase import nuageTestCase
+from marvin.cloudstackAPI import (createTemplate,
+                                  listVolumes)
+import base64
+
+
+class TestNuagePasswordReset(nuageTestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestNuagePasswordReset, cls).setUpClass()
+
+        return
+
+    def setUp(self):
+        self.cleanup = []
+        self.apiclient = self.testClient.getApiClient()
+
+        self.account = Account.create(
+            self.apiclient,
+            self.test_data["account"],
+            admin=True,
+            domainid=self.domain.id
+        )
+
+        self.cleanup.append(self.account)
+        self.remove_vm2 = False
+        return
+
+    # tearDown() - Cleans up the setup, removes the VMs
+    def tearDown(self):
+        self.debug("CLEANUP: TEARDOWN")
+        self.apiclient = self.testClient.getApiClient()
+        self.updateTemplate(self.defaultTemplateVal)
+        self.vm_1.delete(self.apiclient, expunge=True)
+        if self.remove_vm2:
+            self.vm_2.delete(self.apiclient, expunge=True)
+
+        try:
+            cleanup_resources(self.apiclient, self.cleanup)
+        except Exception as e:
+            self.debug("Warning: Exception during cleanup : %s" % e)
+        return
+
+    # create_template - Takes the VM object as the argument to create the template
+    def create_template(self, vm):
+        self.debug("CREATE TEMPLATE")
+        list_volume = list_volumes(
+            self.apiclient,
+            virtualmachineid=vm.id,
+            type='ROOT',
+            listall=True
+        )
+        if isinstance(list_volume, list):
+            self.volume = list_volume[0]
+        else:
+            raise Exception("Exception: Unable to find root volume for VM: %s" % vm.id)
+
+        self.test_data["template_pr"]["ostype"] = self.test_data["ostype_pr"]
+        self.pw_enabled_template = Template.create(
+            self.apiclient,
+            self.test_data["template_pr"],
+            self.volume.id,
+            account=self.account.name,
+            domainid=self.account.domainid
+        )
+        self.assertEqual(self.pw_enabled_template.passwordenabled, True, "template is not passwordenabled")
+        self.cleanup.append(self.pw_enabled_template)
+
+    # VM object is passed as an argument and its interface id is returned
+    def get_vm_interface_id(self, vm):
+        self.debug("GET VM INTERFACE ID")
+        nic_ext_id = self.get_externalID(vm.nic[0].id)
+        vm_interface = self.vsd.get_vm_interface(externalID=nic_ext_id)
+        vm_interface_id = vm_interface["ID"]
+        return vm_interface_id
+
+    # VM object is passed as an argument and its userdata URL is returned
+    def get_userdata_url(self, vm):
+        self.debug("GET USER DATA URL")
+        nic = vm.nic[0]
+        gateway = str(nic.gateway)
+        self.debug("GATEWAY: " + gateway)
+        user_data_url = 'curl "http://' + gateway + ':80/latest/user-data"'
+        return user_data_url
+
+    # Creates and verifies the firewall rule
+    def create_and_verify_fw(self, vm, public_ip, network):
+        self.debug("CREATE AND VERIFY FIREWALL RULE")
+        self.create_StaticNatRule_For_VM(vm, public_ip, network)
+
+        # VSD verification
+        self.verify_vsp_floating_ip(network, vm, public_ip.ipaddress)
+        vm_public_ip = public_ip.ipaddress.ipaddress
+
+        fw_rule = self.create_firewall_rule(public_ip, self.test_data["ingress_rule"])
+        self.verify_vsp_firewall_rule(fw_rule)
+        vm_interface_id = self.get_vm_interface_id(vm)
+        pd = self.vsd.get_vm_interface_policydecisions(id=vm_interface_id)
+        self.debug(pd)
+        egressAcls = pd['egressACLs'][0]['entries']
+        gotFirewallPolicy = False
+        for acl in egressAcls:
+            if acl['destinationPort'] == "22-22":
+                gotFirewallPolicy = True
+                break
+        if not gotFirewallPolicy:
+            raise ValueError('No firewall policy decision in vm interface')
+
+    @attr(tags=["advanced", "nuagevsp"], required_hardware="true")
+    def test_01_UserDataPasswordReset(self):
+        self.debug("START USER DATA PASSWORD RESET ON VM")
+        """
+         Validate the following:
+         1) user data
+         2) reset vm password.
+
+         Steps:
+         1.  Set password enabled to false in the template.
+         2.  Create an Isolated network - Test Network (10.1.1.1/24).
+         3.  Deploy VM1 in Test Network
+         4.  Verify domain,zone subnet, vm.
+         5.  create public ip , Create Static Nat rule firewall rule and verify
+         6.  SSH to VM should be successful
+         7.  verify userdata
+         8.  check cloud-set-guest-password exist.
+         9.  if cloud-set-guest-password exist.
+          9.1    change template password enabled to true
+          9.2   verify that template is password enbalded
+          9.3   SSH with new password should be successful
+         10. else cloud-set-guest-password does not exist.
+          10.1  get the cloud-set-guest-password file
+          10.2  stop vm
+          10.3  create a new template with password enabled. Verify that template is password enabled.
+          10.4  create vm 2 with new template in Test Network
+          10.5  Verify vm.
+          10.6  create public ip , Create Static Nat rule firewall rule and verify
+          10.7  SSH to VM 2 should be successful
+         11. Reset VM password (VM_1 if guest password file exist.  else it is VM2)
+         12  Starting VM and SSH to VM to verify new password
+        """
+
+        self.defaultTemplateVal = self.template.passwordenabled
+        if self.template.passwordenabled:
+            self.updateTemplate(False)
+
+        self.debug("CREATE AN ISOLATED NETWORK")
+        self.network_1 = self.create_Network(self.test_data["network_offering_pr"])
+        self.cleanup.append(self.network_1)
+        expUserData = "hello world vm1"
+        userdata = base64.b64encode(expUserData)
+        self.test_data["virtual_machine_pr"]["userdata"] = userdata
+        self.debug("DEPLOY VM 1 IN TEST NETWORK")
+        # Pass the network and name of the vm type from the testdata with the configuration for the vm
+        self.vm_1 = self.create_VM_in_Network(self.network_1, "virtual_machine_pr")
+
+        self.vm_1.password = self.test_data["virtual_machine_pr"]["password"]
+        user_data_cmd = self.get_userdata_url(self.vm_1)
+
+        # VSD verification
+        self.debug("VERIFY DOMAIN, ZONE, NETWORK , and VM 1")
+        self.verify_vsp_network(self.domain.id, self.network_1)
+        self.verify_vsp_vm(self.vm_1)
+
+        self.debug("CREATE PUBLIC IP, STATIC NAT RULE, FLOATING IP, FIREWALL AND VERIFY")
+        public_ip_1 = self.acquire_Public_IP(self.network_1)
+        self.create_and_verify_fw(self.vm_1, public_ip_1, self.network_1)
+
+        self.debug("SSH TO VM")
+        ssh = self.ssh_into_vm(self.vm_1, public_ip_1)
+
+        self.debug("VERIFY USER DATA")
+        self.debug("Get User Data with command: " + user_data_cmd)
+        adata = self.execute_cmd(ssh, user_data_cmd)
+        actUserData = base64.b64decode(adata)
+        self.debug("Response User Data=" + actUserData + ", Expected=" + expUserData)
+        self.assertEqual(actUserData, expUserData, "User Data Did Not Match ")
+
+        # check /etc/init.d/cloud-set-quest-password
+        ls_cmd = "ls /etc/init.d/cloud-set-guest-password"
+        ls_result = self.execute_cmd(ssh, ls_cmd)
+        ls_result = ls_result.lower()
+        self.debug("reponse from ls_cmd: " + ls_result)
+        if "no such file" in ls_result:
+            self.debug("NO CLOUD-SET_GUEST_PASSWORD FILE.  NEED TO GET ONE")
+            self.install_cloud_set_guest_password_script(ssh)
+            self.stop_vm(self.vm_1)
+            self.create_template(self.vm_1)
+            self.debug("DEPLOY VM 2 IN TEST NETWORK WITH NEW TEMPLATE")
+            self.vm_1 = self.create_VM_in_Network(self.network_1, "virtual_machine_pr")
+            self.remove_vm2 = True
+            self.debug("STARTING VM_2 ")
+            startCmd = startVirtualMachine.startVirtualMachineCmd()
+            startCmd.id = self.vm_2.id
+            vm_2a = self.apiclient.startVirtualMachine(startCmd)
+            self.vm_2.password = vm_2a.password.strip()
+            self.vm_2.nic = vm_2a.nic
+            self.debug("VM - %s password %s !" % (self.vm_2.name, self.vm_2.password))
+            self.assertNotEqual(self.vm_2.password,
+                                self.test_data["virtual_machine_pr"]["password"],
+                                "Password enabled not working. Password same as virtual_machine password "
+                                )
+            self.verify_vsp_vm(vm_2a)
+            self.debug("GET PUBLIC IP,  CREATE AND VERIFY FIREWALL RULES")
+            public_ip_2 = self.acquire_Public_IP(self.network_1)
+            self.create_and_verify_fw(self.vm_2, public_ip_2, self.network_1)
+
+            ssh = self.ssh_into_vm(self.vm_2, public_ip_2)
+            vm_test = self.vm_2
+            vm_test_public_ip = public_ip_2
+
+        else:
+            self.debug("UPDATE TEMPLATE TO PASSWORD ENABLED")
+            self.updateTemplate(True)
+            self.assertEqual(self.template.passwordenabled, True, "Template is not password enabled")
+            vm_test = self.vm_1
+            vm_test_public_ip = public_ip_1
+
+        self.debug("RESETTING VM PASSWORD for VM: %s" % vm_test.name)
+        vm_test.password = vm_test.resetPassword(self.apiclient)
+        self.debug("Password reset to: %s" % vm_test.password)
+        self.debug("STARTING VM AND SSH TO VM TO VERIFY NEW PASSWORD")
+        vm_test.start(self.apiclient)
+        self.debug("VM - %s started!" % vm_test.name)
+        self.ssh_into_vm(vm_test, vm_test_public_ip)

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/3c8d3d0e/test/integration/plugins/nuagevsp/test_nuage_vpc_network.py
----------------------------------------------------------------------
diff --git a/test/integration/plugins/nuagevsp/test_nuage_vpc_network.py b/test/integration/plugins/nuagevsp/test_nuage_vpc_network.py
new file mode 100644
index 0000000..3fc9c32
--- /dev/null
+++ b/test/integration/plugins/nuagevsp/test_nuage_vpc_network.py
@@ -0,0 +1,98 @@
+# 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.
+
+""" Tests for Basic VPC Network Functionality with NuageVsp network Plugin
+"""
+# Import Local Modules
+from marvin.lib.base import Account
+from nose.plugins.attrib import attr
+from nuageTestCase import nuageTestCase
+
+
+class TestVpcNetworkNuage(nuageTestCase):
+    """ Test Basic VPC Network Functionality with NuageVsp network Plugin
+    """
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestVpcNetworkNuage, cls).setUpClass()
+        return
+
+    def setUp(self):
+        # Create an account
+        self.account = Account.create(self.api_client,
+                                      self.test_data["account"],
+                                      admin=True,
+                                      domainid=self.domain.id
+                                      )
+        self.cleanup = [self.account]
+        return
+
+    @attr(tags=["advanced", "nuagevsp"], required_hardware="false")
+    def test_nuage_vpc_network(self):
+        """ Test Basic VPC Network Functionality with NuageVsp network Plugin
+        """
+
+        # 1. Create Nuage VSP VPC offering, check if it is successfully created and enabled.
+        # 2. Create a VPC with Nuage VSP VPC offering, check if it is successfully created and enabled.
+        # 3. Create Nuage Vsp VPC Network offering, check if it is successfully created and enabled.
+        # 4. Create an ACL list in the created VPC, and add an ACL item to it.
+        # 5. Create a VPC Network with Nuage Vsp VPC Network offering and the created ACL list, check if it is
+        #    successfully created, is in the "Implemented" state, and is added to the VPC VR.
+        # 6. Deploy a VM in the created VPC network, check if the VM is successfully deployed and is in the "Running"
+        #    state.
+        # 7. Verify that the created ACL item is successfully implemented in Nuage Vsp.
+
+        # Creating a VPC offering
+        self.debug("Creating Nuage VSP VPC offering...")
+        vpc_offering = self.create_VpcOffering(self.test_data["nuage_vsp_services"]["vpc_offering"])
+        self.validate_vpc_offering(vpc_offering, state="Enabled")
+
+        # Creating a VPC
+        self.debug("Creating a VPC with Nuage VSP VPC offering...")
+        vpc = self.create_Vpc(vpc_offering, cidr='10.1.0.0/16')
+        self.validate_vpc(vpc, state="Enabled")
+
+        # Creating a network offering
+        self.debug("Creating Nuage Vsp VPC Network offering...")
+        network_offering = self.create_NetworkOffering(self.test_data["nuage_vsp_services"]["vpc_network_offering"])
+        self.validate_network_offering(network_offering, state="Enabled")
+
+        # Creating an ACL list
+        acl_list = self.create_network_acl_list(name="acl", description="acl", vpc=vpc)
+
+        # Creating an ACL item
+        acl_item = self.create_network_acl_rule(self.test_data["ingress_rule"], acl_list=acl_list)
+
+        # Creating a VPC network in the VPC
+        self.debug("Creating a VPC network with Nuage Vsp VPC Network offering...")
+        vpc_network = self.create_Network(network_offering, gateway='10.1.1.1', vpc=vpc, acl_list=acl_list)
+        self.validate_network(vpc_network, state="Implemented")
+        vr = self.get_network_router(vpc_network)
+        self.check_router_state(vr, state="Running")
+
+        # Deploying a VM in the VPC network
+        vm = self.create_VM_in_Network(vpc_network)
+        self.check_vm_state(vm, state="Running")
+
+        # VSPK verification
+        self.verify_vsp_network(self.domain.id, vpc_network, vpc)
+        self.verify_vsp_router(vr)
+        self.verify_vsp_vm(vm)
+
+        # VSPK verification for ACL item
+        self.verify_vsp_firewall_rule(acl_item)

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/3c8d3d0e/test/integration/plugins/nuagevsp/test_nuage_vsp.py
----------------------------------------------------------------------
diff --git a/test/integration/plugins/nuagevsp/test_nuage_vsp.py b/test/integration/plugins/nuagevsp/test_nuage_vsp.py
new file mode 100644
index 0000000..a6ec7e1
--- /dev/null
+++ b/test/integration/plugins/nuagevsp/test_nuage_vsp.py
@@ -0,0 +1,106 @@
+# 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.
+
+""" P1 tests for NuageVsp network Plugin
+"""
+# Import Local Modules
+from marvin.lib.base import Account
+from nose.plugins.attrib import attr
+from nuageTestCase import nuageTestCase
+
+
+class TestNuageVsp(nuageTestCase):
+    """ Test NuageVsp network plugin
+    """
+
+    @classmethod
+    def setUpClass(cls):
+        super(TestNuageVsp, cls).setUpClass()
+        return
+
+    def setUp(self):
+        # Create an account
+        self.account = Account.create(self.api_client,
+                                      self.test_data["account"],
+                                      admin=True,
+                                      domainid=self.domain.id
+                                      )
+        self.cleanup = [self.account]
+        return
+
+    @attr(tags=["advanced", "nuagevsp"], required_hardware="false")
+    def test_nuage_vsp(self):
+        """ Test NuageVsp network plugin with basic Isolated Network functionality
+        """
+
+        # 1. Verify that the NuageVsp network service provider is successfully created and enabled.
+        # 2. Create and enable Nuage Vsp Isolated Network offering, check if it is successfully created and enabled.
+        # 3. Create an Isolated Network with Nuage Vsp Isolated Network offering, check if it is successfully created
+        #    and is in the "Allocated" state.
+        # 4. Deploy a VM in the created Isolated network, check if the Isolated network state is changed to
+        #    "Implemented", and both the VM & VR are successfully deployed and are in the "Running" state.
+        # 5. Deploy one more VM in the created Isolated network, check if the VM is successfully deployed and is in the
+        #    "Running" state.
+        # 6. Delete the created Isolated Network after destroying its VMs, check if the Isolated network is successfully
+        #    deleted.
+
+        self.debug("Validating the NuageVsp network service provider...")
+        self.validate_NetworkServiceProvider("NuageVsp", state="Enabled")
+
+        # Creating a network offering
+        self.debug("Creating and enabling Nuage Vsp Isolated Network offering...")
+        network_offering = self.create_NetworkOffering(
+            self.test_data["nuage_vsp_services"]["isolated_network_offering"])
+        self.validate_network_offering(network_offering, state="Enabled")
+
+        # Creating a network
+        self.debug("Creating an Isolated Network with Nuage Vsp Isolated Network offering...")
+        network = self.create_Network(network_offering, gateway='10.1.1.1')
+        self.validate_network(network, state="Allocated")
+
+        # Deploying a VM in the network
+        vm_1 = self.create_VM_in_Network(network)
+        self.validate_network(network, state="Implemented")
+        vr = self.get_network_router(network)
+        self.check_router_state(vr, state="Running")
+        self.check_vm_state(vm_1, state="Running")
+
+        # VSPK verification
+        self.verify_vsp_network(self.domain.id, network)
+        self.verify_vsp_router(vr)
+        self.verify_vsp_vm(vm_1)
+
+        # Deploying one more VM in the network
+        vm_2 = self.create_VM_in_Network(network)
+        self.check_vm_state(vm_2, state="Running")
+
+        # VSPK verification
+        self.verify_vsp_vm(vm_2)
+
+        # Deleting the network
+        self.debug("Deleting the Isolated Network with Nuage Vsp Isolated Network offering...")
+        self.delete_VM(vm_1)
+        self.delete_VM(vm_2)
+        self.delete_Network(network)
+        with self.assertRaises(Exception):
+            self.validate_network(network)
+        self.debug("Isolated Network successfully deleted in CloudStack")
+
+        # VSPK verification
+        with self.assertRaises(Exception):
+            self.verify_vsp_network(self.domain.id, network)
+        self.debug("Isolated Network successfully deleted in VSD")

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/3c8d3d0e/tools/marvin/marvin/config/test_data.py
----------------------------------------------------------------------
diff --git a/tools/marvin/marvin/config/test_data.py b/tools/marvin/marvin/config/test_data.py
index 3d4745d..352f8a2 100644
--- a/tools/marvin/marvin/config/test_data.py
+++ b/tools/marvin/marvin/config/test_data.py
@@ -1695,5 +1695,115 @@ test_data = {
                     "ostype": 'CentOS 5.3 (64-bit)',
                     "mode": 'HTTP_DOWNLOAD'
                 }
+        },
+    # Nuage Vsp supported services
+    "nuage_vsp_services": {
+        # Services supported by Nuage Vsp for Isolated networks
+        "isolated_network_offering": {
+            "name": 'nuage_marvin',
+            "displaytext": 'nuage_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": 'VirtualRouter'
+            },
+            "serviceCapabilityList": {
+                    "SourceNat": {"SupportedSourceNatTypes": "perzone"}
+            }
+        },
+        # Services supported by Nuage Vsp for VPC networks
+        "vpc_network_offering": {
+            "name": 'nuage_vpc_marvin',
+            "displaytext": 'nuage_vpc_marvin',
+            "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": "VpcVirtualRouter"
+            },
+            "serviceCapabilityList": {
+                "SourceNat": {"SupportedSourceNatTypes": "perzone"}
+            }
+        },
+        # Nuage Vsp supports only pre-defined and custom VPC offerings
+        "vpc_offering": {
+            "name": 'Nuage VSP VPC offering',
+            "displaytext": 'Nuage VSP VPC offering',
+            "supportedservices": 'Dhcp,StaticNat,SourceNat,NetworkACL,Connectivity,UserData',
+            "serviceProviderList": {
+                "Dhcp": "NuageVsp",
+                "StaticNat": "NuageVsp",
+                "SourceNat": "NuageVsp",
+                "NetworkACL": "NuageVsp",
+                "Connectivity": "NuageVsp",
+                "UserData": "VpcVirtualRouter"
+            }
         }
+    },
+   
+    #_pr -_ passwordreset - below services used in test_nuage_password_reset
+    "network_offering_pr": {
+        "name": 'nuage_marvin',
+        "displaytext": 'nuage_marvin',
+        "guestiptype": 'Isolated',
+        "supportedservices":
+        'Dhcp,SourceNat,Connectivity,StaticNat,UserData,Firewall',
+        "traffictype": 'GUEST',
+        "availability": 'Optional',
+        "serviceProviderList": {
+            "UserData": 'VirtualRouter',
+            "Dhcp": 'NuageVsp',
+            "Connectivity": 'NuageVsp',
+            "StaticNat": 'NuageVsp',
+            "SourceNat": 'NuageVsp',
+            "Firewall": 'NuageVsp'
+        },
+    },
+    "network_pr": {
+        "name": "Test Network",
+        "displaytext": "Test Network",
+        "netmask": '255.255.255.0'
+    },
+    "fw_rule_pr": {
+        "startport": 1,
+        "endport": 6000,
+        "cidr": '0.0.0.0/0',
+        # Any network (For creating FW rule)
+        "protocol": "TCP"
+    },
+    "virtual_machine_pr": {
+        "displayname": "Test VM",
+        "username": "root",
+        "password": "password",
+        "ssh_port": 22,
+        "hypervisor": 'kvm',
+        # Hypervisor type should be same as
+        # hypervisor type of cluster
+        "privateport": 22,
+        "publicport": 22,
+        "protocol": 'TCP',
+        "userdata": "This is sample data",
+    },
+    "template_pr": {
+        "displaytext": "Cent OS Template",
+        "name": "Cent OS Template",
+        "passwordenabled": True,
+    },
+    "ostype_pr": 'CentOS 5.5 (64-bit)',
+
 }

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/3c8d3d0e/tools/marvin/marvin/lib/base.py
----------------------------------------------------------------------
diff --git a/tools/marvin/marvin/lib/base.py b/tools/marvin/marvin/lib/base.py
index 0be8909..e2f4a2c 100755
--- a/tools/marvin/marvin/lib/base.py
+++ b/tools/marvin/marvin/lib/base.py
@@ -3957,6 +3957,61 @@ class NetworkServiceProvider:
         return(apiclient.listNetworkServiceProviders(cmd))
 
 
+class Nuage:
+    """Manage external nuage VSD device"""
+
+    def __init__(self, items):
+        self.__dict__.update(items)
+
+    @classmethod
+    def add(cls, apiclient, services, physicalnetworkid, username=None, password=None):
+        """Add external nuage VSD device to cloudstack"""
+
+        cmd = addNuageVspDevice.addNuageVspDeviceCmd()
+        cmd.physicalnetworkid = physicalnetworkid
+        if username:
+            cmd.username = username
+        else:
+            cmd.username = services["username"]
+
+        if password:
+            cmd.password = password
+        else:
+            cmd.password = services["password"]
+
+        cmd.hostname = services["hostname"]
+        cmd.port = services["port"]
+        cmd.retrycount = services["retrycount"]
+        cmd.retryinterval = services["retryinterval"]
+        cmd.apiversion = services["apiversion"]
+
+        return Nuage(apiclient.addNuageVspDevice(cmd).__dict__)
+
+    def update(self, apiclient, **kwargs):
+        """Deletes a nuage VSD device from CloudStack"""
+
+        cmd = updateNuageVspDevice.updateNuageVspDeviceCmd()
+        cmd.physicalnetworkid = self.physicalnetworkid
+        [setattr(cmd, k, v) for k, v in kwargs.items()]
+        return apiclient.updateNuageVspDevice(cmd)
+
+    def delete(self, apiclient):
+        """Deletes a nuage VSD device from CloudStack"""
+
+        cmd = deleteNuageVspDevice.deleteNuageVspDeviceCmd()
+        cmd.vspdeviceid = self.vspdeviceid
+        apiclient.deleteNuageVspDevice(cmd)
+        return
+
+    @classmethod
+    def list(cls, apiclient, **kwargs):
+        """List already registered netscaler devices"""
+
+        cmd = listNuageVspDevices.listNuageVspDevicesCmd()
+        [setattr(cmd, k, v) for k, v in kwargs.items()]
+        return(apiclient.listNuageVspDevices(cmd))
+
+
 class Router:
     """Manage router life cycle"""
 


Mime
View raw message