# 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 Local Modules
from marvin.cloudstackTestCase import *
from marvin.lib.utils import *
from marvin.lib.base import *
from marvin.lib.common import *
from marvin.codes import PASS, FAIL
from nose.plugins.attrib import attr

class TestNetworks_1(cloudstackTestCase):

    @classmethod
    def setUpClass(cls):
        try:
            cls._cleanup = []
            cls.testClient = super(TestNetworks_1, cls).getClsTestClient()
            cls.api_client = cls.testClient.getApiClient()
            cls.test_data = cls.testClient.getParsedTestDataConfig()
            cls.hypervisor = cls.testClient.getHypervisorInfo()
            # Get Domain, Zone, Template
            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.test_data["ostype"]
            )
            if cls.zone.localstorageenabled:
                cls.storagetype = 'local'
                cls.test_data["service_offerings"][
                    "tiny"]["storagetype"] = 'local'
            else:
                cls.storagetype = 'shared'
                cls.test_data["service_offerings"][
                    "tiny"]["storagetype"] = 'shared'

            cls.test_data['mode'] = cls.zone.networktype
            cls.test_data["virtual_machine"][
                "hypervisor"] = cls.hypervisor
            cls.test_data["virtual_machine"]["zoneid"] = cls.zone.id
            cls.test_data["virtual_machine"]["template"] = cls.template.id
            cls.test_data["network_without_acl"]["zoneid"] = cls.zone.id
            # Create Network offering
            cls.network_offering = NetworkOffering.create(
                cls.api_client,
                cls.test_data["network_offering_vlan"],
            )
            cls._cleanup.append(cls.network_offering)
            cls.network_offering.update(cls.api_client, state='Enabled')
            cls.test_data["network_without_acl"][
                "networkoffering"] = cls.network_offering.id
            cls.service_offering = ServiceOffering.create(
                cls.api_client,
                cls.test_data["service_offerings"]["tiny"]
            )
            cls._cleanup.append(cls.service_offering)

            cls.account = Account.create(
                cls.api_client,
                cls.test_data["account"],
                domainid=cls.domain.id
            )
            cls._cleanup.append(cls.account)
            # Getting authentication for user in newly created Account
            cls.user = cls.account.user[0]
            cls.userapiclient = cls.testClient.getUserApiClient(
                cls.user.username,
                cls.domain.name)
            cls.account_network = Network.create(
                cls.userapiclient,
                cls.test_data["network_without_acl"],
                cls.account.name,
                cls.account.domainid
            )
            cls._cleanup.append(cls.account_network)
        except Exception as e:
            cls.tearDownClass()
            raise Exception("Warning: Exception in setup : %s" % e)
        return

    def setUp(self):

        self.apiClient = self.testClient.getApiClient()
        self.cleanup = []

    def tearDown(self):
        super(TestNetworks_1, self).tearDown()

    @classmethod
    def tearDownClass(cls):
        super(TestNetworks_1, cls).tearDownClass()

    def __verify_values(self, expected_vals, actual_vals):
        """
        @summary: Function to verify expected and actual values
        Step1: Initializing return flag to True
        Step2: Verifying length of expected and actual dictionaries is
               matching.
               If not matching returning false
        Step3: Listing all the keys from expected dictionary
        Step4: Looping through each key from step2 and verifying expected
               and actual dictionaries have same value
               If not making return flag to False
        Step5: returning the return flag after all the values are verified
        """
        return_flag = True

        if len(expected_vals) != len(actual_vals):
            return False

        keys = list(expected_vals.keys())
        for i in range(0, len(expected_vals)):
            exp_val = expected_vals[keys[i]]
            act_val = actual_vals[keys[i]]
            if exp_val == act_val:
                return_flag = return_flag and True
            else:
                return_flag = return_flag and False
                self.debug(
                    "expected Value: %s, is not matching with actual value: %s"
                    %
                    (exp_val, act_val))
        return return_flag

    @attr(tags=["advanced"], required_hardware="true")
    def test_01_list_networks_pagination(self):
        """
        @Desc: Test List Networks pagination
        @Steps
        Step1    : Listing the networks for a user
        Step2    : Verifying listed networks for account created at class level
        Step3    : If number of networks is less than (pagesize  1), then
                   creating them
        Step4    : Listing the networks again
        Step5    : Verifying for the length of the networks that it is
                   (pagesize  1)
        Step6    : Listing and verifying all the networks in page1
        Step7    : Listing and verifying all the networks in page2
        Step8    : Verifying that on page 2 only 1 network is present and
                   the network on page 2 is not present in page1
        """
        list_zones = Zone.list(
            self.userapiclient,
            id=self.zone.id
        )
        status = validateList(list_zones)
        self.assertEqual(PASS, status[0], "No Zones found for a given id")
        self.test_data["network_without_acl"]["zoneid"] = list_zones[0].id
        # Listing the networks for a user
        list_networks_before = Network.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            type="Isolated"
        )
        # Verifying listed networks for account created at class level
        if list_networks_before is None:
            self.assertEqual(
                len(list_networks_before),
                0,
                "Network create failed at class level"
            )
        # If number of networks is less than (pagesize  1), then creating
        # network
        elif len(list_networks_before) == 1:
            for i in range(0, (self.test_data["pagesize"])):
                network_created = Network.create(
                    self.userapiclient,
                    self.test_data["network_without_acl"],
                )
                self.cleanup.append(network_created)
                self.assertIsNotNone(
                    network_created,
                    "Network is not created"
                )
                # Creating expected and actual values dictionaries
                expected_dict = {
                    "id": list_zones[0].id,
                    "name": self.test_data["network_without_acl"]["name"],
                }
                actual_dict = {
                    "id": network_created.zoneid,
                    "name": network_created.name,
                }
                network_status = self.__verify_values(
                    expected_dict,
                    actual_dict
                )
                self.assertEqual(
                    True,
                    network_status,
                    "Listed network details are not as expected"
                )
        else:
            self.assertEqual(
                len(list_networks_before),
                1,
                "more than 1 network created at class level"
            )
        # Listing the networks
        list_networks_after = Network.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            type="Isolated")
        status = validateList(list_networks_after)
        self.assertEqual(PASS, status[0], "No networks found using list call")
        # Asserting for the length of the networks
        self.assertEqual(
            len(list_networks_after),
            (self.test_data["pagesize"] + 1),
            "Number of networks created is not matching expected"
        )
        # Listing all the networks in page1
        list_networks_page1 = Network.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            page=1,
            pagesize=self.test_data["pagesize"],
            type="Isolated"
        )
        status = validateList(list_networks_page1)
        self.assertEqual(PASS, status[0], "No networks found at page 1")
        self.assertEqual(
            len(list_networks_page1),
            self.test_data["pagesize"],
            "List network response is not matching with the page\
                    size length for page 1")
        # Listing all the networks in page2
        list_networks_page2 = Network.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            page=2,
            pagesize=self.test_data["pagesize"],
            type="Isolated"
        )
        status = validateList(list_networks_page2)
        self.assertEqual(PASS, status[0], "No networks found at page 2")
        self.assertEqual(
            len(list_networks_page2),
            1,
            "List network response is not matching with the page size\
            length for page 2"
        )
        network_page2 = list_networks_page2[0]
        for i in range(0, len(list_networks_page1)):
            network_page1 = list_networks_page1[i]
            self.assertNotEqual(
                network_page2.id,
                network_page1.id,
                "Network listed in page 2 is also listed in page 1"
            )
        return

    @attr(tags=["advanced"], required_hardware="true")
    def test_02_create_network_without_sourcenat(self):
        """
        @Desc: Test create network if supported services doesn't have sourcenat
        @Steps
        Step1    : Create Network Offering without sourcenat
        Step2    : Enable network offering
        Step3    : Create network with sourcenat diasbled network offering
        Step4    : Verifying that it raises an exception
        """
        # Create Network offering specifically sourcenat disabled
        network_offering_without_sourcenat = NetworkOffering.create(
            self.apiClient,
            self.test_data["network_offering_without_sourcenat"],
        )
        self.cleanup.append(network_offering_without_sourcenat)
        if network_offering_without_sourcenat is None:
            self.fail("Creation of network offering without sourcenat failed")
        # Enable network offering
        network_offering_without_sourcenat.update(
            self.apiClient,
            state='Enabled')
        self.test_data["network_without_acl"][
            "networkoffering"] = network_offering_without_sourcenat.id
        # Network create call raise an exception
        with self.assertRaises(Exception):
            network_created = Network.create(
                self.userapiclient,
                self.test_data["network_without_acl"],
            )
            if network_created is not None:
                self.cleanup.append(network_created)
        self.test_data["network_without_acl"][
            "networkoffering"] = self.network_offering.id
        return

    @attr(tags=["advanced"], required_hardware="true")
    def test_03_list_vpc_pagination(self):
        """
        @Desc: Test create vpc with network domain as parameter
        @Steps
        Step1    : List VPC Offering
        Step2    : List VPCs for newly created user
        Step3    : Create VPCs without network domain based on page size
        Step4    : Verify count of VPCs created
        Step5    : Listing all the VPCs in page1
        Step6    : Listing all the VPCs in page2
        Step7    : Verifying that on page 2 only 1 vpc is present and
                   the vpc on page 2 is not present in page1
        Step8    : Deleting a single vpc and verifying that vpc does
                   not exists on page 2
        """
        if self.hypervisor.lower() in ['hyperv']:
            raise unittest.SkipTest("This feature is not supported on existing hypervisor. Hence, skipping the test")
        # List VPC Offering
        vpc_offs_list = VpcOffering.list(self.userapiclient, isdefault="true", name='Default VPC offering')
        if vpc_offs_list is None:
            self.fail("Default VPC offerings not found")
        else:
            vpc_offs = vpc_offs_list[0]
        # List VPCs
        vpc_list = VPC.list(
            self.userapiclient,
            listall=self.test_data["listall"]
        )
        # verify no vpc is present for newly created user
        status = validateList(vpc_list)
        self.assertEqual(FAIL, status[0], "VPCs found for newly created user")
        for i in range(0, (self.test_data["pagesize"] + 1)):
            vpc_1 = VPC.create(
                self.userapiclient,
                self.test_data["vpc"],
                vpcofferingid=vpc_offs.id,
                zoneid=self.zone.id,
            )
            if(i < (self.test_data["pagesize"])):
                self.cleanup.append(vpc_1)
            # verify vpc is created and not none
            self.assertIsNotNone(vpc_1, "VPC is not created")
            # Verify VPC name with test data
            self.assertNotEqual(
                -1,
                vpc_1.name.find(self.test_data["vpc"]["name"]),
                "VPC name not matched"
            )
            # verify zone with test data
            self.assertEqual(
                self.zone.id,
                vpc_1.zoneid,
                "Zone is not matching in the vpc created"
            )
        # Asserting for the length of the VPCs
        vpc_count_after = VPC.list(
            self.userapiclient,
            listall=self.test_data["listall"])
        status = validateList(vpc_count_after)
        self.assertEqual(PASS, status[0], "VPC list count is null")
        self.assertEqual(
            len(vpc_count_after),
            (self.test_data["pagesize"] + 1),
            "Number of VPCs created is not matching expected"
        )
        # Listing all the VPCs in page1
        list_vpcs_page1 = VPC.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            page=1,
            pagesize=self.test_data["pagesize"]
        )
        status = validateList(list_vpcs_page1)
        self.assertEqual(PASS, status[0], "No vpcs found in Page 1")
        self.assertEqual(
            len(list_vpcs_page1),
            self.test_data["pagesize"],
            "List vpc response is not matching with the page\
            size length for page 1")
        # Listing all the vpcs in page2
        list_vpcs_page2 = VPC.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            page=2,
            pagesize=self.test_data["pagesize"]
        )
        status = validateList(list_vpcs_page2)
        self.assertEqual(PASS, status[0], "No vpc found in Page 2")
        self.assertEqual(
            1,
            len(list_vpcs_page2),
            "List VPCs response is not matching with the\
                    page size length for page 2"
        )
        vpc_page2 = list_vpcs_page2[0]
        # Verifying that on page 2 only 1 vpc is present and the vpc on page 2
        # is not present in page1
        for i in range(0, len(list_vpcs_page1)):
            vpc_page1 = list_vpcs_page1[i]
            self.assertNotEqual(
                vpc_page2.id,
                vpc_page1.id,
                "VPC listed in page 2 is also listed in page 1"
            )
        # Deleting a single vpc and verifying that vpc does not exists on page
        # 2
        VPC.delete(vpc_1, self.userapiclient)
        list_vpc_response = VPC.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            page=2,
            pagesize=self.test_data["pagesize"]
        )
        self.assertEqual(
            list_vpc_response,
            None,
            "vpc was not deleted"
        )
        return

    @attr(tags=["advanced"], required_hardware="true")
    def test_04_create_vpc_with_networkdomain(self):
        """
        @Desc: Test create vpc with network domain as parameter
        @Steps
        Step1    : List VPC Offering
        Step2    : List VPCs for newly created user
        Step3    : Create VPC
        Step4    : List VPC and verify that count is increased by 1
        """
        if self.hypervisor.lower() in ['hyperv']:
            raise unittest.SkipTest("This feature is not supported on existing hypervisor. Hence, skipping the test")
        # List VPC Offering
        vpc_offs_list = VpcOffering.list(self.userapiclient, isdefault="true", name='Default VPC offering')
        if vpc_offs_list is None:
            self.fail("Default VPC offerings not found")
        else:
            vpc_offs = vpc_offs_list[0]
        # List VPCs for newly created user
        vpc_list = VPC.list(
            self.userapiclient,
            listall=self.test_data["listall"]
        )
        # No VPCs should be present for newly created user
        status = validateList(vpc_list)
        self.assertEqual(FAIL, status[0], "VPCs found for newly created user")
        vpc_count_before = 0
        vpc_1 = VPC.create(
            self.userapiclient,
            self.test_data["vpc_network_domain"],
            vpcofferingid=vpc_offs.id,
            zoneid=self.zone.id,
        )
        self.assertIsNotNone(vpc_1, "VPC is not created")
        self.cleanup.append(vpc_1)
        # List VPCs
        vpc_list = VPC.list(
            self.userapiclient,
            listall=self.test_data["listall"]
        )
        status = validateList(vpc_list)
        self.assertEqual(PASS, status[0], "VPC is not created")
        self.assertEqual(
            vpc_count_before + 1,
            len(vpc_list),
            "VPC is not created"
        )
        return

    # was tags=["advanced"]
    @attr(tags=["TODO"], required_hardware="true")
    def test_05_list_network_offerings_with_and_without_vpc(self):
        """
        @Desc: Test list network offerings for vpc true and false parameters
        @Steps
        Step1    : List network offering
        Step2    : Create network offering with default setting of vpc = false
        Step3    : List network offering
        Step4    : Verify that count is incremented by 1
        Step5    : List network offering with additional parameter of
                   vpc = true
        Step6    : Verify that its count is same as step 1
        Step7    : List network offering with additional parameter of
                   vpc = false
        Step8    : Verify that its count is same as step 3
        """
        # List all network offering
        network_offering_before_count = NetworkOffering.list(
            self.userapiclient)
        status = validateList(network_offering_before_count)
        self.assertEqual(
            PASS,
            status[0],
            "Default network offering not present")
        # List network offering for vpc = true
        network_offering_vpc_true_before_count = NetworkOffering.list(
            self.userapiclient,
            forvpc="true",
            zoneid=self.zone.id,
            guestiptype=self.test_data["network_offering_vlan"]["guestiptype"],
            supportedServices="SourceNat",
            specifyvlan=self.test_data["network_offering_vlan"]["specifyvlan"],
            state="Enabled"
        )
        status = validateList(network_offering_vpc_true_before_count)
        self.assertEqual(
            PASS,
            status[0],
            "Default network offering not present for vpc = true")
        # List network offering
        network_offering_vpc_false_before_count = NetworkOffering.list(
            self.userapiclient,
            forvpc="false",
            zoneid=self.zone.id,
            guestiptype=self.test_data["network_offering_vlan"]["guestiptype"],
            supportedServices="SourceNat",
            specifyvlan=self.test_data["network_offering_vlan"]["specifyvlan"],
            state="Enabled"
        )
        status = validateList(network_offering_vpc_false_before_count)
        self.assertEqual(
            PASS,
            status[0],
            "Default network offering not present for vpc = false")
        # Create network Offering
        network_offering = NetworkOffering.create(
            self.apiClient,
            self.test_data["network_offering_vlan"],
        )
        self.cleanup.append(network_offering)
        self.assertIsNotNone(
            network_offering,
            "Network offering is not created")
        # Enable Network offering
        network_offering.update(self.apiClient, state='Enabled')
        # List network offering
        network_offering_after_count = NetworkOffering.list(self.userapiclient)
        status = validateList(network_offering_after_count)
        self.assertEqual(
            PASS,
            status[0],
            "Network Offering list results in null")
        # Verify that count is incremented by 1
        self.assertEqual(
            len(network_offering_before_count) + 1,
            len(network_offering_after_count),
            "Network offering is not created"
        )
        # List network offering with additional parameter of vpc = true
        network_offering_vpc_true_after_count = NetworkOffering.list(
            self.userapiclient,
            forvpc="true",
            zoneid=self.zone.id,
            guestiptype=self.test_data["network_offering_vlan"]["guestiptype"],
            supportedServices="SourceNat",
            specifyvlan=self.test_data["network_offering_vlan"]["specifyvlan"],
            state="Enabled"
        )
        status = validateList(network_offering_vpc_true_after_count)
        self.assertEqual(
            PASS,
            status[0],
            "Network Offering list results in null")
        # Verify that its count is same as step 1
        self.assertEqual(
            len(network_offering_vpc_true_before_count),
            len(network_offering_vpc_true_after_count),
            "Default Network offering is created with vpc as true"
        )
        # List network offering with additional parameter of vpc = false
        network_offering_vpc_false_after_count = NetworkOffering.list(
            self.userapiclient,
            forvpc="false",
            zoneid=self.zone.id,
            guestiptype=self.test_data["network_offering_vlan"]["guestiptype"],
            supportedServices="SourceNat",
            specifyvlan=self.test_data["network_offering_vlan"]["specifyvlan"],
            state="Enabled"
        )
        status = validateList(network_offering_vpc_false_after_count)
        self.assertEqual(
            PASS,
            status[0],
            "Network Offering list results in null")
        # Verify that its count is same as step 3
        self.assertEqual(
            len(network_offering_vpc_false_before_count) + 1,
            len(network_offering_vpc_false_after_count),
            "Default Network offering is not created with vpc as false"
        )
        return

    # @attr(tags=["advanced"], required_hardware="true")
    @attr(tags=["TODO"], required_hardware="true")
    def test_06_create_network_in_vpc(self):
        """
        @Desc: Test create network in vpc and verify VPC name
        @Steps
        Step1    : List VPC Offering
        Step2    : List VPCs for newly created user
        Step3    : Create VPC
        Step4    : List VPC and verify that count is increased by 1
        Step5    : Create network
        Step6    : List VPCs for specific network created in vpc
        Step7    : Verify vpc name matches for newly created vpc name
                   and name from vpc list
        """
        if self.hypervisor.lower() in ['hyperv']:
            raise unittest.SkipTest("This feature is not supported on existing hypervisor. Hence, skipping the test")
        # List VPC Offering
        vpc_offs_list = VpcOffering.list(self.userapiclient, isdefault="true", name='Default VPC offering')

        if vpc_offs_list is None:
            self.fail("Default VPC offerings not found")
        else:
            vpc_offs = vpc_offs_list[0]
        # List VPCs for newly created user
        vpc_list = VPC.list(
            self.userapiclient,
            listall=self.test_data["listall"]
        )
        # No VPCs should be present for newly created user
        status = validateList(vpc_list)
        self.assertEqual(FAIL, status[0], "VPCs found for newly created user")
        vpc_count_before = 0
        vpc_1 = VPC.create(
            self.userapiclient,
            self.test_data["vpc"],
            vpcofferingid=vpc_offs.id,
            zoneid=self.zone.id,
        )
        self.assertIsNotNone(vpc_1, "VPC is not created")
        self.cleanup.append(vpc_1)
        # List VPCs
        vpc_list = VPC.list(
            self.userapiclient,
            listall=self.test_data["listall"]
        )
        status = validateList(vpc_list)
        self.assertEqual(PASS, status[0], "VPC is not created")
        self.assertEqual(
            vpc_count_before + 1,
            len(vpc_list),
            "VPC is not created"
        )
        # Listing the networks for a user
        list_networks_before = Network.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            type="Isolated")
        # Verifying listed networks for account created at class level
        self.assertIsNotNone(
            list_networks_before,
            "Network create failed at class level")
        # List network offering for vpc = true
        network_offering_vpc_true_list = NetworkOffering.list(
            self.userapiclient,
            forvpc="true",
            zoneid=self.zone.id,
            guestiptype=self.test_data["network_offering_vlan"]["guestiptype"],
            supportedServices="SourceNat",
            specifyvlan=self.test_data["network_offering_vlan"]["specifyvlan"],
            state="Enabled"
        )
        status = validateList(network_offering_vpc_true_list)
        self.assertEqual(
            PASS,
            status[0],
            "Default network offering not present for vpc = true")
        # Listing networks in VPC
        list_networks_in_vpc = Network.list(self.userapiclient,
                                            vpcid=vpc_1.id,
                                            type="Isolated"
                                            )
        self.assertIsNone(
            list_networks_in_vpc,
            "Networks found for newly created VPC")
        # If number of networks is 1, then creating network
        if len(list_networks_before) == 1:
            network_created = Network.create(
                self.userapiclient,
                self.test_data["network_without_acl"],
                networkofferingid=network_offering_vpc_true_list[0].id,
                vpcid=vpc_1.id,
                gateway=self.test_data["ntwk"]["gateway"],
                netmask=self.test_data["ntwk"]["netmask"],
                domainid=self.domain.id,
                accountid=self.account.name,
            )
            self.assertIsNotNone(
                network_created,
                "Network is not created"
            )
            self.cleanup.append(network_created)
            # Creating expected and actual values dictionaries
            expected_dict = {
                "id": self.test_data["network_without_acl"]["zoneid"],
                "name": self.test_data["network_without_acl"]["name"],
            }
            actual_dict = {
                "id": network_created.zoneid,
                "name": network_created.name,
            }
            network_status = self.__verify_values(
                expected_dict,
                actual_dict
            )
            self.assertEqual(
                True,
                network_status,
                "Listed network details are not as expected"
            )
        else:
            self.assertEqual(
                len(list_networks_before),
                1,
                "more than 1 network created at class level"
            )
        # Listing the networks
        list_networks_after = Network.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            type="Isolated")
        status = validateList(list_networks_after)
        self.assertEqual(PASS, status[0], "No networks found using list call")
        # Asserting for the length of the networks
        self.assertEqual(
            2,
            len(list_networks_after),
            "Number of networks created is not matching expected"
        )
        # Listing networks in VPC after creation of network
        list_networks_in_vpc = Network.list(self.userapiclient,
                                            vpcid=vpc_1.id,
                                            type="Isolated"
                                            )
        status = validateList(list_networks_in_vpc)
        self.assertEqual(PASS, status[0], "No networks found in vpc")
        # Asserting for the length of the networks
        self.assertEqual(
            1,
            len(list_networks_in_vpc),
            "Number of networks created in vpc is not matching expected"
        )
        # List VPCs for specific network created in vpc
        vpc_list = VPC.list(
            self.userapiclient,
            id=network_created.vpcid
        )
        # verify no vpc is present for newly created user
        status = validateList(vpc_list)
        self.assertEqual(PASS, status[0], "VPCs not found.")
        # verify vpc name matches for newly created vpc name and vpc list name
        self.assertEqual(
            vpc_1.name,
            vpc_list[0].name,
            "VPC names not matching"
        )
        return

    # was tags=["advanced"]
    @attr(tags=["TODO"], required_hardware="true")
    def test_07_create_delete_network(self):
        """
        @Desc: Test delete network
        @Steps
        Step1    : Create Network
        Step2    : Verify Network is created
        Step3    : Delete Network
        Step4    : Verify network is deleted
        """
        # Listing the networks for a user
        list_networks_before = Network.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            type="Isolated")
        # Verifying listed networks for account created at class level
        self.assertIsNotNone(
            list_networks_before,
            "Network create failed at class level")
        # List network offering for vpc = false
        network_offering_vpc_false_list = NetworkOffering.list(
            self.userapiclient,
            forvpc="false",
            zoneid=self.zone.id,
            guestiptype=self.test_data["network_offering_vlan"]["guestiptype"],
            supportedServices="SourceNat",
            specifyvlan=self.test_data["network_offering_vlan"]["specifyvlan"],
            state="Enabled"
        )
        status = validateList(network_offering_vpc_false_list)
        self.assertEqual(
            PASS,
            status[0],
            "Default network offering not present for vpc = false")
        # If number of networks is 1, then creating network
        if len(list_networks_before) == 1:
            network_created = Network.create(
                self.userapiclient,
                self.test_data["network_without_acl"],
                networkofferingid=network_offering_vpc_false_list[0].id,
            )
            self.assertIsNotNone(
                network_created,
                "Network is not created"
            )
            # Creating expected and actual values dictionaries
            expected_dict = {
                "id": self.test_data["network_without_acl"]["zoneid"],
                "name": self.test_data["network_without_acl"]["name"],
            }
            actual_dict = {
                "id": network_created.zoneid,
                "name": network_created.name,
            }
            network_status = self.__verify_values(
                expected_dict,
                actual_dict
            )
            self.assertEqual(
                True,
                network_status,
                "Listed network details are not as expected"
            )
        else:
            self.assertEqual(
                len(list_networks_before),
                1,
                "more than 1 network created at class level"
            )
        # Listing the networks
        list_networks_after = Network.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            type="Isolated"
        )
        status = validateList(list_networks_after)
        self.assertEqual(PASS, status[0], "No networks found using list call")
        # Asserting for the length of the networks
        self.assertEqual(
            2,
            len(list_networks_after),
            "Number of networks created is not matching expected"
        )
        # Delete Network
        Network.delete(network_created, self.userapiclient)
        # List Networks
        list_networks_after_delete = Network.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            type="Isolated"
        )
        status = validateList(list_networks_after_delete)
        self.assertEqual(PASS, status[0], "No networks found using list call")
        self.assertEqual(
            1,
            len(list_networks_after_delete),
            "Number of networks created is not matching expected"
        )
        # Verify deleted network is not present
        self.assertNotEqual(
            network_created.id,
            list_networks_after_delete[0].id,
            "Deleted network present"
        )
        return

    # was tags=["advanced"]
    @attr(tags=["TODO"], required_hardware="true")
    def test_08_update_network(self):
        """
        @Desc: Test update network
        @Steps
        Step1    : Create Network
        Step2    : Verify Network is created
        Step3    : Update Network name, display text and network domain
        Step4    : Verify network is updated
        """
        # Listing the networks for a user
        list_networks_before = Network.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            type="Isolated")
        # Verifying listed networks for account created at class level
        self.assertIsNotNone(
            list_networks_before,
            "Network create failed at class level")
        self.assertEqual(
            1,
            len(list_networks_before),
            "More than 1 network created at class level"
        )
        # List network offering for vpc = false
        network_offering_vpc_false_list = NetworkOffering.list(
            self.userapiclient,
            forvpc="false",
            zoneid=self.zone.id,
            guestiptype=self.test_data["network_offering_vlan"]["guestiptype"],
            supportedServices="SourceNat",
            specifyvlan=self.test_data["network_offering_vlan"]["specifyvlan"],
            state="Enabled"
        )
        status = validateList(network_offering_vpc_false_list)
        self.assertEqual(
            PASS,
            status[0],
            "Default network offering not present for vpc = false")
        # creating network
        network_created = Network.create(
            self.userapiclient,
            self.test_data["network_without_acl"],
            networkofferingid=network_offering_vpc_false_list[0].id,
        )
        self.assertIsNotNone(
            network_created,
            "Network is not created"
        )
        self.cleanup.append(network_created)
        # Creating expected and actual values dictionaries
        expected_dict = {
            "id": self.test_data["network_without_acl"]["zoneid"],
            "name": self.test_data["network_without_acl"]["name"],
        }
        actual_dict = {
            "id": network_created.zoneid,
            "name": network_created.name,
        }
        network_status = self.__verify_values(
            expected_dict,
            actual_dict
        )
        self.assertEqual(
            True,
            network_status,
            "Listed network details are not as expected"
        )
        # Listing the networks
        list_networks_after = Network.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            type="Isolated")
        status = validateList(list_networks_after)
        self.assertEqual(PASS, status[0], "No networks found using list call")
        # Asserting for the length of the networks
        self.assertEqual(
            2,
            len(list_networks_after),
            "Number of networks created is not matching expected"
        )
        # Update Network
        network_updated = Network.update(network_created,
                                         self.userapiclient,
                                         name="NewNetworkName",
                                         displaytext="NewNetworkDisplayText",
                                         networkdomain="cs13cloud.internal.new"
                                         )
        # List Networks
        list_networks_after_update = Network.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            type="Isolated")
        status = validateList(list_networks_after_update)
        self.assertEqual(PASS, status[0], "No networks found using list call")
        self.assertEqual(
            2,
            len(list_networks_after_update),
            "Number of networks created is not matching expected"
        )
        # Creating expected and actual values dictionaries
        expected_dict = {
            "name": "NewNetworkName",
            "displaytext": "NewNetworkDisplayText",
            "networkdomain": "cs13cloud.internal.new"
        }
        actual_dict = {
            "name": network_updated.name,
            "displaytext": network_updated.displaytext,
            "networkdomain": network_updated.networkdomain
        }
        network_status = self.__verify_values(
            expected_dict,
            actual_dict
        )
        self.assertEqual(
            True,
            network_status,
            "Listed network details are not as expected"
        )
        return

    @attr(tags=["advanced"], required_hardware="true")
    def test_09_list_virtual_machines_single_network(self):
        """
        @Desc: Test update network
        @Steps
        Step1    : Create Network
        Step2    : Verify Network is created
        Step3    : Create Virtual Machine as per page size
        Step4    : Verify list Virtual machines and pagination
        """
        # Listing the networks for a user
        list_networks_before = Network.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            type="Isolated")
        # Verifying listed networks for account created at class level
        self.assertIsNotNone(
            list_networks_before,
            "Network create failed at class level")
        # Create Virtual Machine
        # Listing all the instances for a user
        list_instances_before = VirtualMachine.list(
            self.userapiclient,
            listall=self.test_data["listall"])
        # Verifying listed instances for account created at class level
        self.assertIsNone(
            list_instances_before,
            "Virtual Machine already exists for newly created user"
        )
        # If number of instances are less than (pagesize  1), then creating
        # them
        for i in range(0, (self.test_data["pagesize"] + 1)):
            vm_created = VirtualMachine.create(
                self.userapiclient,
                self.test_data["virtual_machine"],
                accountid=self.account.name,
                domainid=self.account.domainid,
                networkids=list_networks_before[0].id,
                serviceofferingid=self.service_offering.id,
            )
            self.assertIsNotNone(
                vm_created,
                "VM creation failed"
            )
            if(i < (self.test_data["pagesize"])):
                self.cleanup.append(vm_created)

            self.assertEqual(
                self.test_data["virtual_machine"]["displayname"],
                vm_created.displayname,
                "Newly created VM name and the test data VM\
                        name are not matching")
        # Listing all the instances again after creating VM's
        list_instances_after = VirtualMachine.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            networkid=list_networks_before[0].id
        )
        status = validateList(list_instances_after)
        self.assertEqual(
            PASS,
            status[0],
            "Listing of instances after creation failed"
        )
        # Verifying the length of the instances is (page size  1)
        self.assertEqual(
            len(list_instances_after),
            (self.test_data["pagesize"] + 1),
            "Number of instances created is not matching as expected"
        )
        # Listing all the volumes in page1
        list_instances_page1 = VirtualMachine.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            page=1,
            pagesize=self.test_data["pagesize"],
            networkid=list_networks_before[0].id
        )
        status = validateList(list_instances_page1)
        self.assertEqual(
            PASS,
            status[0],
            "Listing of instances in page1 failed"
        )
        # Verifying that the length of the instances in page 1 is (page size)
        self.assertEqual(
            self.test_data["pagesize"],
            len(list_instances_page1),
            "List VM response is not matching with the\
                    page size length for page 1")
        # Listing all the VM's in page2
        list_instances_page2 = VirtualMachine.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            page=2,
            pagesize=self.test_data["pagesize"],
            networkid=list_networks_before[0].id
        )
        status = validateList(list_instances_page2)
        self.assertEqual(
            PASS,
            status[0],
            "Listing of instances in page2 failed"
        )
        # Verifying that the length of the VM's in page 2 is 1
        self.assertEqual(
            1,
            len(list_instances_page2),
            "List VM response is not matching with the\
                    page size length for page 2"
        )
        # Deleting a single VM
        VirtualMachine.delete(vm_created, self.apiClient)
        # Listing the VM's in page 2
        list_instance_response = VirtualMachine.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            page=2,
            pagesize=self.test_data["pagesize"],
            networkid=list_networks_before[0].id
        )
        # verifying that VM does not exists on page 2
        self.assertEqual(
            list_instance_response,
            None,
            "VM was not deleted"
        )
        return

    # was tags=["advanced"]
    @attr(tags=["TODO"], required_hardware="true")
    def test_10_list_networks_in_vpc(self):
        """
        @Desc: Test list networks in vpc and verify VPC name
        @Steps
        Step1    : List VPC Offering
        Step2    : List VPCs for newly created user
        Step3    : Create VPC
        Step4    : List VPC and verify that count is increased by 1
        Step5    : Create network
        Step6    : List Networks in created vpc
        Step7    : Verify network name matches for newly created network name
                   and name from network list
        """
        if self.hypervisor.lower() in ['hyperv']:
            raise unittest.SkipTest("This feature is not supported on existing hypervisor. Hence, skipping the test")
        # List VPC Offering
        vpc_offs_list = VpcOffering.list(self.userapiclient, isdefault="true", name='Default VPC offering')
        if vpc_offs_list is None:
            self.fail("Default VPC offerings not found")
        else:
            vpc_offs = vpc_offs_list[0]
        # List VPCs for newly created user
        vpc_list = VPC.list(
            self.userapiclient,
            listall=self.test_data["listall"]
        )
        # No VPCs should be present for newly created user
        status = validateList(vpc_list)
        self.assertEqual(FAIL, status[0], "VPCs found for newly created user")
        vpc_count_before = 0
        vpc_1 = VPC.create(
            self.userapiclient,
            self.test_data["vpc"],
            vpcofferingid=vpc_offs.id,
            zoneid=self.zone.id,
        )
        self.assertIsNotNone(vpc_1, "VPC is not created")
        self.cleanup.append(vpc_1)
        # List VPCs
        vpc_list = VPC.list(
            self.userapiclient,
            listall=self.test_data["listall"]
        )
        status = validateList(vpc_list)
        self.assertEqual(PASS, status[0], "VPC is not created")
        self.assertEqual(
            vpc_count_before + 1,
            len(vpc_list),
            "VPC is not created"
        )
        # Listing the networks for a user
        list_networks_before = Network.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            type="Isolated")
        # Verifying listed networks for account created at class level
        self.assertIsNotNone(
            list_networks_before,
            "Network create failed at class level")
        # List network offering for vpc = true
        network_offering_vpc_true_list = NetworkOffering.list(
            self.userapiclient,
            forvpc="true",
            zoneid=self.zone.id,
            guestiptype=self.test_data["network_offering_vlan"]["guestiptype"],
            supportedServices="SourceNat",
            specifyvlan=self.test_data["network_offering_vlan"]["specifyvlan"],
            state="Enabled"
        )
        status = validateList(network_offering_vpc_true_list)
        self.assertEqual(
            PASS,
            status[0],
            "Default network offering not present for vpc = true")
        # If number of networks is 1, then creating network
        if len(list_networks_before) == 1:
            network_created = Network.create(
                self.userapiclient,
                self.test_data["network_without_acl"],
                networkofferingid=network_offering_vpc_true_list[0].id,
                vpcid=vpc_1.id,
                gateway=self.test_data["ntwk"]["gateway"],
                netmask=self.test_data["ntwk"]["netmask"]
            )
            self.assertIsNotNone(
                network_created,
                "Network is not created"
            )
            self.cleanup.append(network_created)
            # Creating expected and actual values dictionaries
            expected_dict = {
                "id": self.test_data["network_without_acl"]["zoneid"],
                "name": self.test_data["network_without_acl"]["name"],
            }
            actual_dict = {
                "id": network_created.zoneid,
                "name": network_created.name,
            }
            network_status = self.__verify_values(
                expected_dict,
                actual_dict
            )
            self.assertEqual(
                True,
                network_status,
                "Listed network details are not as expected"
            )
        else:
            self.assertEqual(
                len(list_networks_before),
                1,
                "more than 1 network created at class level"
            )
        # Listing the networks
        list_networks_after = Network.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            type="Isolated")
        status = validateList(list_networks_after)
        self.assertEqual(PASS, status[0], "No networks found using list call")
        # Asserting for the length of the networks
        self.assertEqual(
            2,
            len(list_networks_after),
            "Number of networks created is not matching expected"
        )
        # Listing the networks
        list_networks_in_vpc = Network.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            vpcid=vpc_1.id,
            type="Isolated"
        )
        status = validateList(list_networks_in_vpc)
        self.assertEqual(PASS, status[0], "No networks found using list call")
        # Verify network name matches for newly created network name and name
        # from network list
        self.assertEqual(
            network_created.name,
            list_networks_in_vpc[0].name,
            "Network names not matching"
        )
        return

    # @attr(tags=["advanced"], required_hardware="true")
    @attr(tags=["TODO"], required_hardware="true")
    def test_11_update_vpc(self):
        """
        @Desc: Test create vpc with network domain as parameter
        @Steps
        Step1    : List VPC Offering
        Step2    : List VPCs for newly created user
        Step3    : Create VPCs
        Step4    : Verify count of VPCs created
        Step5    : Update VPC name and display text
        Step6    : Verify name and display text is updated
        """
        if self.hypervisor.lower() in ['hyperv']:
            raise unittest.SkipTest("This feature is not supported on existing hypervisor. Hence, skipping the test")
        # List VPC Offering
        vpc_offs_list = VpcOffering.list(self.userapiclient, isdefault="true", name='Default VPC offering')
        if vpc_offs_list is None:
            self.fail("Default VPC offerings not found")
        else:
            vpc_offs = vpc_offs_list[0]
        # List VPCs
        vpc_list = VPC.list(
            self.userapiclient,
            listall=self.test_data["listall"]
        )
        # verify no vpc is present for newly created user
        status = validateList(vpc_list)
        self.assertEqual(FAIL, status[0], "VPCs found for newly created user")
        vpc_1 = VPC.create(
            self.userapiclient,
            self.test_data["vpc"],
            vpcofferingid=vpc_offs.id,
            zoneid=self.zone.id,
        )
        self.assertIsNotNone(vpc_1, "VPC is not created")
        self.cleanup.append(vpc_1)
        # verify vpc is created and not none
        # Verify VPC name with test data
        self.assertNotEqual(
            -1,
            vpc_1.name.find(self.test_data["vpc"]["name"]),
            "VPC name not matched"
        )
        # verify zone with test data
        self.assertEqual(
            self.zone.id,
            vpc_1.zoneid,
            "Zone is not matching in the vpc created"
        )
        # Asserting for the length of the VPCs
        vpc_count_after = VPC.list(
            self.userapiclient,
            listall=self.test_data["listall"])
        status = validateList(vpc_count_after)
        self.assertEqual(PASS, status[0], "VPC list count is null")
        self.assertEqual(
            1,
            len(vpc_count_after),
            "Number of VPCs created is not matching expected"
        )
        # Update VPC
        vpc_updated = VPC.update(
            vpc_1,
            self.userapiclient,
            name="NewVPCName",
            displaytext="NewVPCDisplayText",
        )
        # List Networks
        list_vpcs_after_update = VPC.list(
            self.userapiclient,
            listall=self.test_data["listall"]
        )
        status = validateList(list_vpcs_after_update)
        self.assertEqual(PASS, status[0], "No vpcs found using list call")
        self.assertEqual(
            1,
            len(list_vpcs_after_update),
            "Number of vpcs created is not matching expected"
        )
        # Creating expected and actual values dictionaries
        expected_dict = {
            "name": "NewVPCName",
            "displaytext": "NewVPCDisplayText",
        }
        actual_dict = {
            "name": vpc_updated.name,
            "displaytext": vpc_updated.displaytext,
        }
        vpc_status = self.__verify_values(
            expected_dict,
            actual_dict
        )
        self.assertEqual(
            True,
            vpc_status,
            "Listed vpc details are not as expected"
        )
        return

    # was tags=["advanced"]
    @attr(tags=["TODO"], required_hardware="true")
    def test_12_list_create_delete_networkACL(self):
        """
        @Desc: Test create network in vpc and verify VPC name
        @Steps
        Step1    : List VPC Offering
        Step2    : List VPCs for newly created user
        Step3    : Create VPC
        Step4    : List VPC and verify that count is increased by 1
        Step5    : Create network
        Step6    : Verify network is created
        Step7    : List Network ACLs
        Step8    : Create Network ACL
        Step9    : Verify NetworkACL is created
        Step10   : Delete NetworkACL
        Step11   : Verify NetworkACL is deleted
        """
        if self.hypervisor.lower() in ['hyperv']:
            raise unittest.SkipTest("This feature is not supported on existing hypervisor. Hence, skipping the test")
        # List VPC Offering
        vpc_offs_list = VpcOffering.list(self.userapiclient, isdefault="true", name='Default VPC offering')

        if vpc_offs_list is None:
            self.fail("Default VPC offerings not found")
        else:
            vpc_offs = vpc_offs_list[0]
        # List VPCs for newly created user
        vpc_list = VPC.list(
            self.userapiclient,
            listall=self.test_data["listall"]
        )
        # No VPCs should be present for newly created user
        status = validateList(vpc_list)
        self.assertEqual(FAIL, status[0], "VPCs found for newly created user")
        vpc_count_before = 0
        vpc_1 = VPC.create(
            self.userapiclient,
            self.test_data["vpc"],
            vpcofferingid=vpc_offs.id,
            zoneid=self.zone.id,
        )
        self.cleanup.append(vpc_1)
        self.assertIsNotNone(vpc_1, "VPC is not created")
        # List VPCs
        vpc_list = VPC.list(
            self.userapiclient,
            listall=self.test_data["listall"]
        )
        status = validateList(vpc_list)
        self.assertEqual(PASS, status[0], "VPC is not created")
        self.assertEqual(
            vpc_count_before + 1,
            len(vpc_list),
            "VPC is not created"
        )
        # Listing the networks for a user
        list_networks_before = Network.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            type="Isolated"
        )
        # Verifying listed networks for account created at class level
        self.assertIsNotNone(
            list_networks_before,
            "Network create failed at class level")
        # List network offering for vpc = true
        network_offering_vpc_true_list = NetworkOffering.list(
            self.userapiclient,
            forvpc="true",
            zoneid=self.zone.id,
            guestiptype=self.test_data["network_offering_vlan"]["guestiptype"],
            supportedServices="SourceNat",
            specifyvlan=self.test_data["network_offering_vlan"]["specifyvlan"],
            state="Enabled"
        )
        status = validateList(network_offering_vpc_true_list)
        self.assertEqual(
            PASS,
            status[0],
            "Default network offering not present for vpc = true")
        # Listing networks in VPC
        list_networks_in_vpc = Network.list(self.userapiclient,
                                            vpcid=vpc_1.id,
                                            type="Isolated"
                                            )
        self.assertIsNone(
            list_networks_in_vpc,
            "Networks found for newly created VPC")
        # If number of networks is 1, then creating network
        if len(list_networks_before) == 1:
            network_created = Network.create(
                self.userapiclient,
                self.test_data["network_without_acl"],
                networkofferingid=network_offering_vpc_true_list[0].id,
                vpcid=vpc_1.id,
                gateway=self.test_data["ntwk"]["gateway"],
                netmask=self.test_data["ntwk"]["netmask"],
                domainid=self.domain.id,
                accountid=self.account.name,
            )
            self.cleanup.append(network_created)
            self.assertIsNotNone(
                network_created,
                "Network is not created"
            )
            # Creating expected and actual values dictionaries
            expected_dict = {
                "id": self.test_data["network_without_acl"]["zoneid"],
                "name": self.test_data["network_without_acl"]["name"],
            }
            actual_dict = {
                "id": network_created.zoneid,
                "name": network_created.name,
            }
            network_status = self.__verify_values(
                expected_dict,
                actual_dict
            )
            self.assertEqual(
                True,
                network_status,
                "Listed network details are not as expected"
            )
        else:
            self.assertEqual(
                len(list_networks_before),
                1,
                "more than 1 network created at class level"
            )
        # Listing the networks
        list_networks_after = Network.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            type="Isolated")
        status = validateList(list_networks_after)
        self.assertEqual(PASS, status[0], "No networks found using list call")
        # Asserting for the length of the networks
        self.assertEqual(
            2,
            len(list_networks_after),
            "Number of networks created is not matching expected"
        )
        # Listing networks in VPC after creation of network
        list_networks_in_vpc = Network.list(self.userapiclient,
                                            vpcid=vpc_1.id,
                                            type="Isolated"
                                            )
        status = validateList(list_networks_in_vpc)
        self.assertEqual(PASS, status[0], "No networks found in vpc")
        # Asserting for the length of the networks
        self.assertEqual(
            1,
            len(list_networks_in_vpc),
            "Number of networks created in vpc is not matching expected"
        )
        # List VPCs for specific network created in vpc
        vpc_list = VPC.list(
            self.userapiclient,
            id=network_created.vpcid
        )
        # List Network ACLs
        list_network_acl = NetworkACL.list(
            self.userapiclient,
            networkid=network_created.id
        )
        self.assertIsNone(
            list_network_acl,
            "ACL list is not empty for newly created network")
        # Create NetworkACL
        network_acl_created = NetworkACL.create(
            self.userapiclient,
            self.test_data["network_acl_rule"],
            networkid=network_created.id
        )
        self.assertIsNotNone(
            network_acl_created,
            "NetworkACL is not created"
        )
        # List Network ACL
        list_network_acl = NetworkACL.list(
            self.userapiclient,
            networkid=network_created.id
        )
        status = validateList(list_network_acl)
        self.assertEqual(
            PASS,
            status[0],
            "No networks acls found after creating")
        # Asserting for the length of the networks
        self.assertEqual(
            1,
            len(list_network_acl),
            "Number of networks acls reated is not matching expected"
        )
        # Delete Network ACL
        NetworkACL.delete(network_acl_created, self.userapiclient)
        # List Network ACL
        list_network_acl = NetworkACL.list(
            self.userapiclient,
            networkid=network_created.id
        )
        self.assertIsNone(
            list_network_acl,
            "ACL list is not empty for newly created network")
        return


class TestNetworks_2(cloudstackTestCase):

    @classmethod
    def setUpClass(cls):
        try:
            cls._cleanup = []
            cls.testClient = super(TestNetworks_2, cls).getClsTestClient()
            cls.api_client = cls.testClient.getApiClient()
            cls.test_data = cls.testClient.getParsedTestDataConfig()
            cls.hypervisor = cls.testClient.getHypervisorInfo()
            # Get Domain, Zone, Template
            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.test_data["ostype"]
            )
            cls.test_data['mode'] = cls.zone.networktype
            cls.account = Account.create(
                cls.api_client,
                cls.test_data["account"],
                domainid=cls.domain.id
            )
            cls._cleanup.append(cls.account)

            # Getting authentication for user in newly created Account
            cls.user = cls.account.user[0]
            cls.userapiclient = cls.testClient.getUserApiClient(
                cls.user.username,
                cls.domain.name)

            cls.vpc_offering = VpcOffering.create(cls.api_client,
                                                  cls.test_data["vpc_offering"]
                                                  )
            cls.vpc_offering.update(cls.api_client, state='Enabled')
            cls._cleanup.append(cls.vpc_offering)
        except Exception as e:
            cls.tearDownClass()
            raise Exception("Warning: Exception in setup : %s" % e)
        return

    def setUp(self):

        self.apiClient = self.testClient.getApiClient()
        self.cleanup = []

    def tearDown(self):
        super(TestNetworks_2, self).tearDown()

    @classmethod
    def tearDownClass(cls):
        super(TestNetworks_2, cls).tearDownClass()

    def __verify_values(self, expected_vals, actual_vals):
        """
        @summary: Function to verify expected and actual values
        Step1: Initializing return flag to True
        Step1: Verifying length of expected and actual dictionaries is matching
               If not matching returning false
        Step2: Listing all the keys from expected dictionary
        Step3: Looping through each key from step2 and verifying expected
               and actual dictionaries have same value
               If not making return flag to False
        Step4: returning the return flag after all the values are verified
        """
        return_flag = True

        if len(expected_vals) != len(actual_vals):
            return False

        keys = list(expected_vals.keys())
        for i in range(0, len(expected_vals)):
            exp_val = expected_vals[keys[i]]
            act_val = actual_vals[keys[i]]
            if exp_val == act_val:
                return_flag = return_flag and True
            else:
                return_flag = return_flag and False
                self.debug(
                    "expected Value: %s, is not matching with actual value: %s"
                    %
                    (exp_val, act_val))
        return return_flag

    @attr(tags=["advanced"], required_hardware="true")
    def test_13_list_vpc_byid(self):
        """
        @summary: Test List VPC with Id
        @Steps
        Step1: Listing all the vpc for a user before creating a vpc
        Step2: Verifying no VPCs are listed
        Step3: Creating a vpc
        Step4: Listing the vpc for a user after creating a vpc
        Step5: Verifying the list vpc size is increased by 1
        Step6: Listing the vpc by specifying vpc ID
        Step7: Verifying the list vpc size is 1
        Step8: Verifying the details of the vpc
        """
        if self.hypervisor.lower() in ['hyperv']:
            raise unittest.SkipTest("This feature is not supported on existing hypervisor. Hence, skipping the test")
        # Listing all the vpc's for a user
        list_vpc_before = VPC.list(self.userapiclient)
        # Verifying No VPCs are listed
        self.assertIsNone(
            list_vpc_before,
            "Vpc listed for newly created user"
        )
        # Creating a vpc
        vpc_created = VPC.create(
            self.userapiclient,
            self.test_data["vpc"],
            self.vpc_offering.id,
            self.zone.id
        )
        self.assertIsNotNone(vpc_created, "VPC Creation Failed")
        self.cleanup.append(vpc_created)
        # Listing the vpc for a user after creating a vpc
        list_vpc_after = VPC.list(self.userapiclient)
        status = validateList(list_vpc_after)
        self.assertEqual(
            PASS,
            status[0],
            "list VPC not as expected"
        )
        # Verifying the list vpc size is increased by 1
        self.assertEqual(
            1,
            len(list_vpc_after),
            "list VPC not equal as expected"
        )
        # List the vpc by specifying vpc ID
        list_vpc_byid = VPC.list(
            self.userapiclient,
            id=vpc_created.id,
            listall=self.test_data["listall"]
        )
        status = validateList(list_vpc_byid)
        self.assertEqual(
            PASS,
            status[0],
            "list VPC not as expected"
        )
        # Verifying the list vpc size is 1
        self.assertEqual(
            1,
            len(list_vpc_byid),
            "list VPC not equal as expected"
        )
        # Verifying the details of the vpc
        expected_dict = {
            "cidr": self.test_data["vpc"]["cidr"],
            "id": vpc_created.id,
            "displaytext": vpc_created.displaytext,
            "account": self.account.name,
            "domain": vpc_created.domain,
            "domainid": self.domain.id,
            "name": vpc_created.name
        }
        actual_dict = {
            "cidr": str(list_vpc_byid[0].cidr),
            "id": list_vpc_byid[0].id,
            "displaytext": list_vpc_byid[0].displaytext,
            "account": list_vpc_byid[0].account,
            "domain": list_vpc_byid[0].domain,
            "domainid": list_vpc_byid[0].domainid,
            "name": list_vpc_byid[0].name
        }
        list_vpc_status = self.__verify_values(
            expected_dict,
            actual_dict
        )
        self.assertEqual(
            True,
            list_vpc_status,
            "Listed VPC details are not as expected"
        )
        return

    @attr(tags=["advanced"], required_hardware="true")
    def test_14_list_public_ipaddress_by_associated_networkid(self):
        """
        @summary: Test List Public IPAddress with associatednetworkid
        @Steps
        Step1: Listing all the public ipaddresses for a user before creating
               a public ipaddress
        Step2: Verifying no Public ipaddress are listed
        Step3: Creating a network
        Step4: Associating public ipaddress for network created in step3
        Step5: Listing the public ipaddress for a user after creating a
               public ipaddress
        Step6: Verifying the list public ipaddress size is increased by 1
        Step7: Listing the public ipaddress by specifying associatednetworkid
        Step8: Verifying the list public ipaddress size is 1
        Step9: Verifying the details of the public ipaddress
        """
        # Listing all the public ipaddresses for a user
        list_public_ipaddress_before = PublicIPAddress.list(self.userapiclient)
        # Verifying No VPCs are listed
        self.assertIsNone(
            list_public_ipaddress_before,
            "Public ipaddresses listed for newly created user"
        )
        # Listing Network Offerings
        network_offerings_list = NetworkOffering.list(
            self.apiClient,
            forvpc="false",
            guestiptype="Isolated",
            state="Enabled",
            supportedServices="SourceNat",
            zoneid=self.zone.id
        )
        self.assertIsNotNone(
            network_offerings_list,
            "Isolated Network Offerings with sourceNat enabled are not found"
        )
        # Creating a Network
        network = Network.create(
            self.userapiclient,
            self.test_data["network"],
            accountid=self.account.name,
            domainid=self.domain.id,
            networkofferingid=network_offerings_list[0].id,
            zoneid=self.zone.id
        )
        self.assertIsNotNone(
            network,
            "Network creation failed"
        )
        self.cleanup.append(network)
        #  Associating public ipaddress for network created
        public_ipaddress_created = PublicIPAddress.create(
            self.userapiclient,
            accountid=self.account.name,
            zoneid=self.zone.id,
            domainid=self.domain.id,
            networkid=network.id
        )
        self.assertIsNotNone(
            public_ipaddress_created,
            "Failed to Associate Public IpAddress for Network"
        )
        # Listing the public ipaddress for a user after associating a public
        # ipaddress for network
        list_public_ipaddress_after = PublicIPAddress.list(self.userapiclient)
        status = validateList(list_public_ipaddress_after)
        self.assertEqual(
            PASS,
            status[0],
            "list Public IPAddress not as expected"
        )
        # Verifying the list public ipaddress size is increased by 1
        self.assertEqual(
            1,
            len(list_public_ipaddress_after),
            "list Public IPAddress not equal as expected"
        )
        # List the public ipaddress by specifying public ipaddress ID
        list_public_ipaddress_byid = PublicIPAddress.list(
            self.userapiclient,
            associatednetworkid=network.id,
            listall=self.test_data["listall"]
        )
        status = validateList(list_public_ipaddress_byid)
        self.assertEqual(
            PASS,
            status[0],
            "list public ipaddress not as expected"
        )
        # Verifying the list public ipaddress size is 1
        self.assertEqual(
            1,
            len(list_public_ipaddress_byid),
            "list public ipaddress not equal as expected"
        )
        # Verifying the details of the public ipaddress
        expected_dict = {
            "account": public_ipaddress_created.ipaddress.account,
            "associatednetworkid":
            public_ipaddress_created.ipaddress.associatednetworkid,
            "associatednetworkname":
            public_ipaddress_created.ipaddress.associatednetworkname,
            "domainid": public_ipaddress_created.ipaddress.domainid,
            "forvirtualnetwork":
            public_ipaddress_created.ipaddress.forvirtualnetwork,
            "id": public_ipaddress_created.ipaddress.id,
            "ipaddress": public_ipaddress_created.ipaddress.ipaddress,
            "isportable": public_ipaddress_created.ipaddress.isportable,
            "issourcenat": public_ipaddress_created.ipaddress.issourcenat,
            "isstatisnat": public_ipaddress_created.ipaddress.isstaticnat,
            "issystem": public_ipaddress_created.ipaddress.issystem,
            "networkid": public_ipaddress_created.ipaddress.network,
            "physicalnetworkid":
            public_ipaddress_created.ipaddress.physicalnetworkid,
            "zoneid": public_ipaddress_created.ipaddress.zoneid}
        actual_dict = {
            "account": list_public_ipaddress_byid[0].account,
            "associatednetworkid":
            list_public_ipaddress_byid[0].associatednetworkid,
            "associatednetworkname":
            list_public_ipaddress_byid[0].associatednetworkname,
            "domainid": list_public_ipaddress_byid[0].domainid,
            "forvirtualnetwork":
            list_public_ipaddress_byid[0].forvirtualnetwork,
            "id": list_public_ipaddress_byid[0].id,
            "ipaddress": list_public_ipaddress_byid[0].ipaddress,
            "isportable": list_public_ipaddress_byid[0].isportable,
            "issourcenat": list_public_ipaddress_byid[0].issourcenat,
            "isstatisnat": list_public_ipaddress_byid[0].isstaticnat,
            "issystem": list_public_ipaddress_byid[0].issystem,
            "networkid": list_public_ipaddress_byid[0].network,
            "physicalnetworkid":
            list_public_ipaddress_byid[0].physicalnetworkid,
            "zoneid": list_public_ipaddress_byid[0].zoneid}
        list_public_ipaddress_status = self.__verify_values(
            expected_dict,
            actual_dict
        )
        self.assertEqual(
            True,
            list_public_ipaddress_status,
            "Listed Public IPAddress details are not as expected"
        )
        return

    @attr(tags=["advanced"], required_hardware="true")
    def test_15_list_privategateway_byvpcid(self):
        """
        @summary: Test List PrivateGateway by vpcid
        @Steps
        Step1: Creating a VPC
        Step2: Listing all the private gateway before creating a
               private gateway
        Step3: Verifying no Private Gateway are listed
        Step4: Listing the Private Gateway  after creating a Private Gateway
        Step5: Verifying the list Private Gateway size is increased by 1
        Step6: Listing the Private Gateway by specifying VPCID
        Step7: Verifying the list Private Gateway size is 1
        Step8: Verifying the details of the Private Gateway
        """
        if self.hypervisor.lower() in ['hyperv']:
            raise unittest.SkipTest("This feature is not supported on existing hypervisor. Hence, skipping the test")
        # Creating a vpc
        vpc_created = VPC.create(
            self.userapiclient,
            self.test_data["vpc"],
            self.vpc_offering.id,
            self.zone.id
        )
        self.assertIsNotNone(vpc_created, "VPC Creation Failed")
        self.cleanup.append(vpc_created)
        # Listing all the PrivateGateways
        list_private_gateways_before = PrivateGateway.list(
            self.apiClient,
            listall=self.test_data["listall"],
            vpcid=vpc_created.id
        )
        # Verifying No PrivateGateways are listed
        self.assertIsNone(
            list_private_gateways_before,
            "Listed private gateways for newly created VPC "
        )
        # Creating a Private Gateway
        private_gateway_created = PrivateGateway.create(
            self.apiClient,
            vpcid=vpc_created.id,
            gateway=self.test_data["private_gateway"]["gateway"],
            ipaddress=self.test_data["private_gateway"]["ipaddress"],
            netmask=self.test_data["private_gateway"]["netmask"],
            vlan=self.test_data["private_gateway"]["vlan"]
        )
        self.assertIsNotNone(
            private_gateway_created,
            "Private Gateway Creation Failed"
        )
        # Listing all the PrivateGateways
        list_private_gateways_after = PrivateGateway.list(
            self.apiClient,
            listall=self.test_data["listall"],
            vpcid=vpc_created.id
        )
        # Verifying PrivateGateways are listed
        status = validateList(list_private_gateways_after)
        self.assertEqual(PASS, status[0], "Private Gateway Creation Failed")
        self.assertEqual(
            1,
            len(list_private_gateways_after),
            "list Private Gateway not equal as expected"
        )
        # Listing Private Gateway by vpcid
        list_privategateway_byvpcid = PrivateGateway.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            vpcid=vpc_created.id
        )
        status = validateList(list_privategateway_byvpcid)
        self.assertEqual(
            PASS,
            status[0],
            "list private gateway not as expected"
        )
        # Verifying the list private gateway size is 1
        self.assertEqual(
            1,
            len(list_privategateway_byvpcid),
            "list private gateway not equal as expected"
        )
        # Verifying the details of the private gateway
        expected_dict = {
            "account": private_gateway_created.account,
            "aclid": private_gateway_created.aclid,
            "domainid": private_gateway_created.domainid,
            "gateway": self.test_data["private_gateway"]["gateway"],
            "id": private_gateway_created.id,
            "ipaddress": self.test_data["private_gateway"]["ipaddress"],
            "netmask": self.test_data["private_gateway"]["netmask"],
            "sourcenatsupported": private_gateway_created.sourcenatsupported,
            "vlan": self.test_data["private_gateway"]["vlan"],
            "vpcid": private_gateway_created.vpcid,
            "zoneid": private_gateway_created.zoneid
        }
        actual_dict = {
            "account": list_privategateway_byvpcid[0].account,
            "aclid": list_privategateway_byvpcid[0].aclid,
            "domainid": list_privategateway_byvpcid[0].domainid,
            "gateway": list_privategateway_byvpcid[0].gateway,
            "id": list_privategateway_byvpcid[0].id,
            "ipaddress": list_privategateway_byvpcid[0].ipaddress,
            "netmask": list_privategateway_byvpcid[0].netmask,
            "sourcenatsupported":
            list_privategateway_byvpcid[0].sourcenatsupported,
            "vlan": list_privategateway_byvpcid[0].vlan,
            "vpcid": list_privategateway_byvpcid[0].vpcid,
            "zoneid": list_privategateway_byvpcid[0].zoneid}
        list_private_gateway_status = self.__verify_values(
            expected_dict,
            actual_dict
        )
        self.assertEqual(
            True,
            list_private_gateway_status,
            "Listed Private Gateway details are not as expected"
        )
        return

    @attr(tags=["advanced"], required_hardware="true")
    def test_16_create_list_delete_egressfirewallrule_bynetworkid(self):
        """
        @summary: Test Create List Delete Egress Firewall Rule by Network ID
        @Steps
        Step1: Creating a Nerwork
        Step2: Listing all the egressfirewall rule before creating a
               egressfirewall rule
        Step3: Verifying no egressfirewall rule are listed
        Step4: Creating a egressfirewall rule for a user
        Step5: Listing the egressfirewall rule by specifying Network ID
        Step7: Verifying the list egressfirewall rule size is 1
        Step8: Verifying the details of the egressfirewall rule
        Step9: Deleting the egressfirewall rule by network id
        Step10: Verifying no egressfirewall rule is listed
        """
        # Listing all the Networks's for a user
        list_networks_before = Network.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            type="Isolated"
        )
        # Verifying No Networks are listed
        self.assertIsNone(
            list_networks_before,
            "Networks listed for newly created User"
        )
        # Listing Network Offerings
        network_offerings_list = NetworkOffering.list(
            self.apiClient,
            forvpc="false",
            guestiptype="Isolated",
            state="Enabled",
            supportedservices="SourceNat",
            zoneid=self.zone.id
        )
        self.assertIsNotNone(
            network_offerings_list,
            "Isolated Network Offerings with sourceNat enabled are not found"
        )
        # Creating a Network
        network = Network.create(
            self.userapiclient,
            self.test_data["network"],
            accountid=self.account.name,
            domainid=self.domain.id,
            networkofferingid=network_offerings_list[0].id,
            zoneid=self.zone.id
        )
        self.assertIsNotNone(
            network,
            "Network creation failed"
        )
        self.cleanup.append(network)
        # Listing Networks after
        list_networks_after = Network.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            type="Isolated"
        )
        status = validateList(list_networks_after)
        self.assertEqual(
            PASS,
            status[0],
            "Network Creation Failed"
        )
        # Verifying network list count is increased by 1
        self.assertEqual(
            1,
            len(list_networks_after),
            "Network Creation Failed"
        )
        # Listing EgressFirewall Rule
        list_egressfirewallrule_before = EgressFireWallRule.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            networkid=network.id
        )
        # Verifying No EgressFirewall Rule are listed
        self.assertIsNone(
            list_egressfirewallrule_before,
            "Listed egressfirewall rule for a user"
        )
        # Creating a EgressFirewall Rule
        egressfirewallrule_created = EgressFireWallRule.create(
            self.userapiclient,
            networkid=network.id,
            protocol=self.test_data["ingress_rule"]["protocol"],
            cidrlist=self.test_data["ingress_rule"]["cidrlist"],
            startport=self.test_data["ingress_rule"]["startport"],
            endport=self.test_data["ingress_rule"]["endport"],
        )
        self.assertIsNotNone(
            egressfirewallrule_created,
            "EgressFirewall Rule Creation Failed"
        )
        # ListingEgressFirewall Rule by networkid
        list_egressfirewallrule_bynetworkid = EgressFireWallRule.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            networkid=network.id
        )
        status = validateList(list_egressfirewallrule_bynetworkid)
        self.assertEqual(
            PASS,
            status[0],
            "list EgressFirewall Rule not as expected"
        )
        # Verifying the list EgressFirewall Rule size is 1
        self.assertEqual(
            1,
            len(list_egressfirewallrule_bynetworkid),
            "list EgressFirewall Rule not equal as expected"
        )
        # Verifying the details of the EgressFirewall Rule
        expected_dict = {
            "cidrlist": self.zone.guestcidraddress,
            "id": egressfirewallrule_created.id,
            "networkid": egressfirewallrule_created.networkid,
            "protocol": self.test_data["ingress_rule"]["protocol"]
        }
        actual_dict = {
            "cidrlist": str(
                list_egressfirewallrule_bynetworkid[0].cidrlist),
            "id": list_egressfirewallrule_bynetworkid[0].id,
            "networkid": list_egressfirewallrule_bynetworkid[0].networkid,
            "protocol": str(
                list_egressfirewallrule_bynetworkid[0].protocol).upper()}
        list_egressfirewallrule_status = self.__verify_values(
            expected_dict,
            actual_dict
        )
        self.assertEqual(
            True,
            list_egressfirewallrule_status,
            "Listed EgressFirewall Rule details are not as expected"
        )
        # Deleting the EgressFirewall Rule by networkid
        egressfirewallrule_created.delete(self.userapiclient)
        # Listing the EgressFirewall Rule by networkid
        list_deleted_egressfirewallrule_bynetworkid = EgressFireWallRule.list(
            self.userapiclient,
            listall=self.test_data["listall"],
            networkid=network.id
        )
        # Verifying No EgressFirewall Rule are listed
        self.assertIsNone(
            list_deleted_egressfirewallrule_bynetworkid,
            "EgressFirewall Rule deletion fails"
        )
        return

    @attr(tags=["advanced"], required_hardware="true")
    def test_17_restart_vpc(self):
        """
        @summary: Test to restart VPC
        @Steps
        Step1: Listing the VPC  before creating a VPC for a user
        Step2: Verifying No VPCs are listed
        Step3: Creating a VPC
        Step4: Listing the VPC  after creating a VPC for a user
        Step5: Verifying the list VPC size is increased by 1
        Step6: Restarting the VPC
        Step7: Verifying the Restart function return true
        Step8: Listing the VPC by specifying VPCID
        Step9: Verfying state of vpc
        """
        if self.hypervisor.lower() in ['hyperv']:
            raise unittest.SkipTest("This feature is not supported on existing hypervisor. Hence, skipping the test")
        # Listing all the vpc's for a user
        list_vpc_before = VPC.list(self.userapiclient)
        # Verifying No VPCs are listed
        self.assertIsNone(
            list_vpc_before,
            "Vpc listed for newly created user"
        )
        # Creating a vpc
        vpc_created = VPC.create(
            self.userapiclient,
            self.test_data["vpc"],
            self.vpc_offering.id,
            self.zone.id
        )
        self.assertIsNotNone(vpc_created, "VPC Creation Failed")
        self.cleanup.append(vpc_created)
        # Listing the vpc for a user after creating a vpc
        list_vpc_after = VPC.list(self.userapiclient)
        status = validateList(list_vpc_after)
        self.assertEqual(
            PASS,
            status[0],
            "list VPC not as expected"
        )
        # Verifying the list vpc size is increased by 1
        self.assertEqual(
            1,
            len(list_vpc_after),
            "list VPC not equal as expected"
        )
        # Restarting VPC
        vpc_restarted = VPC.restart(vpc_created, self.userapiclient)
        # Verifying restart function resturns true
        self.assertTrue(vpc_restarted, "Restart fails")
        # List the vpc by specifying vpc ID
        list_vpc_byid = VPC.list(
            self.userapiclient,
            id=vpc_created.id,
            listall=self.test_data["listall"]
        )
        status = validateList(list_vpc_byid)
        self.assertEqual(
            PASS,
            status[0],
            "list VPC not as expected"
        )
        # Verifying the list vpc size is 1
        self.assertEqual(
            1,
            len(list_vpc_byid),
            "list VPC not equal as expected"
        )
        # Verfying whether sate is Enabled
        self.assertEqual(
            "Enabled",
            list_vpc_byid[0].state,
            "Restarted VPC is not in Enabled state"
        )
        return

    @attr(tags=["advanced"], required_hardware="true")
    def test_18_create_list_vpn_gateway(self):
        """
        @Desc: Test to Create and list Vpn Gateway by VPCid
        @steps:
        Step1: Create VPC
        Step2: Listing VPN gateways for user before creating any VPN gateway
        Step3: Verifying No VPN Gateways are listed
        Step4: Creating a VPN Gateway using the vpc
        Step5: Listing VPN gateway for user by vpcid
        Step6: Verifying the list size is increased by 1
        Step7: Verifying the details of a VPN gateway
         """
        if self.hypervisor.lower() in ['hyperv']:
            raise unittest.SkipTest("This feature is not supported on existing hypervisor. Hence, skipping the test")
        # Listing all the vpc's for a user
        list_vpc_before = VPC.list(self.userapiclient)
        # Verifying No VPCs are listed
        self.assertIsNone(
            list_vpc_before,
            "Vpc listed for newly created user"
        )
        # Creating a vpc
        vpc_created = VPC.create(
            self.userapiclient,
            self.test_data["vpc"],
            self.vpc_offering.id,
            self.zone.id
        )
        self.assertIsNotNone(vpc_created, "VPC Creation Failed")
        self.cleanup.append(vpc_created)
        # Listing the vpc for a user after creating a vpc
        list_vpc_after = VPC.list(self.userapiclient)
        status = validateList(list_vpc_after)
        self.assertEqual(
            PASS,
            status[0],
            "list VPC not as expected"
        )
        # Verifying the list vpc size is increased by 1
        self.assertEqual(
            1,
            len(list_vpc_after),
            "list VPC not equal as expected"
        )
        # Listing all the vpn gateways for a user
        list_vpngateway_before = Vpn.listVpnGateway(
            self.userapiclient,
            listall=self.test_data["listall"],
            vpcid=vpc_created.id
        )
        # Verifying No VPN Gateways are listed
        self.assertIsNone(
            list_vpngateway_before,
            "Vpn gateway listed for newly created user"
        )
        # Creating a VPN Gateway
        vpngateway_created = Vpn.createVpnGateway(
            self.userapiclient,
            vpcid=vpc_created.id,
        )
        self.assertIsNotNone(
            vpngateway_created,
            "VPN Gateway creation failed"
        )
        # Listing all the VPN Gateways for a User
        list_vpngateway_after = Vpn.listVpnGateway(
            self.userapiclient,
            listall=self.test_data["listall"],
            vpcid=vpc_created.id
        )
        status = validateList(list_vpngateway_after)
        self.assertEqual(
            PASS,
            status[0],
            "List VPN Gateway not equal as expected"
        )
        # Verifying that list size is  1
        self.assertEqual(
            1,
            len(list_vpngateway_after
                ),
            "Failed to list vpn gateway"
        )
        # Verifying the details of the vpn gateway
        expected_dict = {
            "account": vpngateway_created["account"],
            "domainid": vpngateway_created["domainid"],
            "id": vpngateway_created["id"],
            "publicip": vpngateway_created["publicip"],
            "vpcid": vpngateway_created["vpcid"]
        }
        actual_dict = {
            "account": list_vpngateway_after[0].account,
            "domainid": list_vpngateway_after[0].domainid,
            "id": list_vpngateway_after[0].id,
            "publicip": list_vpngateway_after[0].publicip,
            "vpcid": list_vpngateway_after[0].vpcid
        }
        list_vpn_gateway_status = self.__verify_values(
            expected_dict,
            actual_dict
        )
        self.assertEqual(
            True,
            list_vpn_gateway_status,
            "Listed VPN Gateway details are not as expected"
        )
        return

    # @attr(tags=["advanced"], required_hardware="true")
    @attr(tags=["TODO"], required_hardware="true")
    def test_19_create_list_reset_delete_vpnconnections(self):
        """
        @Desc: Test to List Create Reset and Delete VPN Customer
               Gateways pagination
        @steps:
        Step1: Create VPC
        Step2: Create VPN gateway
        Step3: Create VPN Customer Gateway
        Step4: Listing all the VPN Connections for a user
        Step5: Verifying No VPN Connection are listed
        Step6: Create a VPN Connection using VPN Gateway and
               VPN Customer Gateway
        Step7: Listing all the VPN Connections by vpcid for a user
        Step8: Verifying that list size is 1
        Step9: Reset the vpn connection
        Step10:List the Vpn connection by vpcid
        Step11: Verify the details of VPN Connection after reset
        Step12: Deleting the VPN Connection
        Step13: Listing all the VPN Connection for a user
        Step14: Verifying that no VPN Connection are listed
        """
        if self.hypervisor.lower() in ['hyperv']:
            raise unittest.SkipTest("This feature is not supported on existing hypervisor. Hence, skipping the test")
        # Listing all the vpc's for a user
        list_vpc_before = VPC.list(self.userapiclient)
        # Verifying No VPCs are listed
        self.assertIsNone(
            list_vpc_before,
            "Vpc listed for newly created user"
        )
        # Creating a vpc
        vpc_created = VPC.create(
            self.userapiclient,
            self.test_data["vpc"],
            self.vpc_offering.id,
            self.zone.id
        )
        self.assertIsNotNone(vpc_created, "VPC Creation Failed")
        self.cleanup.append(vpc_created)
        # Listing the vpc for a user after creating a vpc
        list_vpc_after = VPC.list(self.userapiclient)
        status = validateList(list_vpc_after)
        self.assertEqual(
            PASS,
            status[0],
            "list VPC not as expected"
        )
        # Verifying the list vpc size is increased by 1
        self.assertEqual(
            1,
            len(list_vpc_after),
            "list VPC not equal as expected"
        )
        # Listing all the vpn gateways for a user
        list_vpngateway_before = Vpn.listVpnGateway(
            self.userapiclient,
            listall=self.test_data["listall"],
            vpcid=vpc_created.id
        )
        # Verifying No VPN Gateways are listed
        self.assertIsNone(
            list_vpngateway_before,
            "Vpn gateway listed for newly created user"
        )
        # Creating a VPN Gateway
        vpngateway_created = Vpn.createVpnGateway(
            self.userapiclient,
            vpcid=vpc_created.id,
        )
        self.assertIsNotNone(
            vpngateway_created,
            "VPN Gateway creation failed"
        )
        # Listing all the VPN Gateways for a User
        list_vpngateway_after = Vpn.listVpnGateway(
            self.userapiclient,
            listall=self.test_data["listall"],
            vpcid=vpc_created.id
        )
        status = validateList(list_vpngateway_after)
        self.assertEqual(
            PASS,
            status[0],
            "List VPN Gateway not equal as expected"
        )
        # Verifying that list size is  1
        self.assertEqual(
            1,
            len(list_vpngateway_after
                ),
            "Failed to list vpn gateway"
        )
        # Listing all the VPN Customer Gateways for a User
        list_vpncustomergateways_before = VpnCustomerGateway.list(
            self.userapiclient,
            listall=self.test_data["listall"]
        )
        # Verifying that no VPN Customer Gateways are listed
        self.assertIsNone(
            list_vpncustomergateways_before,
            "VPN Customer Gateways listed for newly created User"
        )
        # Creating  VPN Customer Gateways
        vpncustomergateway_created = VpnCustomerGateway.create(
            self.userapiclient,
            self.test_data["vpncustomergateway"],
            name="VPNCustGateway",
            gateway="10.102.153.1",
            cidrlist="10.0.0.0/24",
            account=self.account.name,
            domainid=self.domain.id
        )
        self.assertIsNotNone(
            vpncustomergateway_created,
            "VPN Customer Gateway creation failed"
        )
        self.cleanup.append(vpncustomergateway_created)
        # Listing all the VPN Customer Gateways for a User
        list_vpncustomergateways_after = VpnCustomerGateway.list(
            self.userapiclient,
            listall=self.test_data["listall"],
        )
        status = validateList(list_vpncustomergateways_after)
        self.assertEqual(
            PASS,
            status[0],
            "VPN Customer Gateway list failed"
        )
        # Verifying that list size is 1
        self.assertEqual(
            1,
            len(list_vpncustomergateways_after),
            "Failed to list VPN Customer Gateways"
        )
        # Listing all the vpc's for a user
        list_vpn_connection_before = Vpn.listVpnConnection(
            self.userapiclient,
            listall=self.test_data["listall"],
            vpcid=vpc_created.id
        )
        # Verifying No VPC Connections are listed
        self.assertIsNone(
            list_vpn_connection_before,
            "Vpn connection listed for newly created user"
        )
        # Creating VPN Connection
        vpnconnections_created = Vpn.createVpnConnection(
            self.userapiclient,
            s2scustomergatewayid=vpncustomergateway_created.id,
            s2svpngatewayid=vpngateway_created["id"]
        )
        self.assertIsNotNone(
            vpnconnections_created,
            "VPN Connection creation failed"
        )
        # Listing the vpn connection for a user after creating a vpn connection
        list_vpn_connection_after = Vpn.listVpnConnection(
            self.userapiclient,
            listall=self.test_data["listall"],
            vpcid=vpc_created.id
        )
        status = validateList(list_vpn_connection_after)
        self.assertEqual(
            PASS,
            status[0],
            "list VPN Connection not as expected"
        )
        # Verifying the list vpn connection size is increased by 1
        self.assertEqual(
            1,
            len(list_vpn_connection_after),
            "list VPC Connection equal as expected"
        )
        # Resets VPN Connection
        Vpn.resetVpnConnection(
            self.userapiclient,
            id=list_vpn_connection_after[0].id,
        )
        # Lists VPN Connection by vpcid
        list_vpn_connection_after_reset = Vpn.listVpnConnection(
            self.userapiclient,
            listall=self.test_data["listall"],
            vpcid=vpc_created.id
        )
        status = validateList(list_vpn_connection_after_reset)
        self.assertEqual(
            PASS,
            status[0],
            "list VPN Connection not as expected"
        )
        # Verifying the list vpn connection size is increased by 1
        self.assertEqual(
            1,
            len(list_vpn_connection_after_reset),
            "list VPN Connection not equal as expected"
        )
        # Verifying the details of the vpn connection after reset
        expected_dict = {
            "account": list_vpn_connection_after[0].account,
            "cidrlist": list_vpn_connection_after[0].cidrlist,
            "domain": list_vpn_connection_after[0].domain,
            "dpd": list_vpn_connection_after[0].dpd,
            "gateway": list_vpn_connection_after[0].gateway,
            "id": list_vpn_connection_after[0].id,
            "passive": list_vpn_connection_after[0].passive,
            "publicip": list_vpn_connection_after[0].publicip,
            "s2scustomergatewayid":
            list_vpn_connection_after[0].s2scustomergatewayid,
            "s2svpngatewayid": list_vpn_connection_after[0].s2svpngatewayid}
        actual_dict = {
            "account": list_vpn_connection_after_reset[0].account,
            "cidrlist": list_vpn_connection_after_reset[0].cidrlist,
            "domain": list_vpn_connection_after_reset[0].domain,
            "dpd": list_vpn_connection_after_reset[0].dpd,
            "gateway": list_vpn_connection_after_reset[0].gateway,
            "id": list_vpn_connection_after_reset[0].id,
            "passive": list_vpn_connection_after_reset[0].passive,
            "publicip": list_vpn_connection_after_reset[0].publicip,
            "s2scustomergatewayid":
            list_vpn_connection_after_reset[0].s2scustomergatewayid,
            "s2svpngatewayid":
            list_vpn_connection_after_reset[0].s2svpngatewayid}
        list_vpn_connection_status = self.__verify_values(
            expected_dict,
            actual_dict
        )
        self.assertEqual(
            True,
            list_vpn_connection_status,
            "Listed VPN Connection details are not as expected"
        )
        # Delete VPN Connection
        Vpn.deleteVpnConnection(
            self.userapiclient,
            id=list_vpn_connection_after[0].id
        )
        # Listing all the vpc connections for a user
        list_vpn_connection_after_delete = Vpn.listVpnConnection(
            self.userapiclient,
            listall=self.test_data["listall"],
            vpcid=vpc_created.id
        )
        # Verifying No VPN Connections are listed
        self.assertIsNone(
            list_vpn_connection_after_delete,
            "Vpn connection listed for newly created user"
        )
        return

    @attr(tags=["advanced"], required_hardware="true")
    def test_20_list_capabilities(self):
        """
        @summary: Test List Capabilities
        @Steps
        Step1: Listing all the Capabilities for a user
        Step2: Verifying the listcapabilities object is not null
        Step3: Verifying list.cloudstack version is not null
         """
        # Listing all the Capabilities for a user
        listCapabilities = Configurations.listCapabilities(self.userapiclient)
        # Verifying the listcapabilities object is not null
        self.assertIsNotNone(
            listCapabilities,
            "Failed to list Capabilities"
        )
        # Verifying list.cloudstack version is not null
        self.assertIsNotNone(
            listCapabilities.cloudstackversion,
            "Failed to list cloud Stack version"
        )
        return

    @attr(tags=["advanced"], required_hardware="true")
    def test_21_listNetworkacls_by_privategateway_aclid(self):
        """
        @summary: Test to list Networkacllists by private gateway aclid
        @Steps
        Step1: Listing the Network acl's for a user
        Step2: Verifying list is not none
        Step3: Creating a VPC
        Step4: Listing the privategateway for user
        Step5: Verifying the no private gateway are listed for a user
        Step6: Creating a private gateway using aclid
        Step7: Listing private gateway for a user
        Step8: Verifying list size is increased by 1
        Step9: Listing Networkacllist by paymentgateway aclid
        """
        if self.hypervisor.lower() in ['hyperv']:
            raise unittest.SkipTest("This feature is not supported on existing hypervisor. Hence, skipping the test")
        # Listing all thenetwork acl list for a user
        list_networkacl = NetworkACLList.list(self.userapiclient)
        self.assertIsNotNone(
            list_networkacl,
            "Failed to list network acl list")
        # Verfying list is not none
        status = validateList(list_networkacl)
        self.assertEqual(
            PASS,
            status[0],
            "Failed to list network acl list"
        )
        # Creating a vpc
        vpc_created = VPC.create(
            self.userapiclient,
            self.test_data["vpc"],
            self.vpc_offering.id,
            self.zone.id
        )
        self.assertIsNotNone(vpc_created, "VPC Creation Failed")
        self.cleanup.append(vpc_created)
        # Listing all the PrivateGateways
        list_private_gateways_before = PrivateGateway.list(
            self.apiClient,
            listall=self.test_data["listall"],
            vpcid=vpc_created.id
        )
        # Verifying No PrivateGateways are listed
        self.assertIsNone(
            list_private_gateways_before,
            "Listed private gateways for newly created VPC "
        )
        # Creating a Private Gateway using aclid
        private_gateway_created = PrivateGateway.create(
            self.apiClient,
            vpcid=vpc_created.id,
            gateway=self.test_data["private_gateway"]["gateway"],
            ipaddress=self.test_data["private_gateway"]["ipaddress"],
            netmask=self.test_data["private_gateway"]["netmask"],
            vlan=self.test_data["private_gateway"]["vlan"],
            aclid=list_networkacl[0].id
        )
        self.assertIsNotNone(
            private_gateway_created,
            "Private Gateway Creation Failed"
        )
        # Listing all the PrivateGateways
        list_private_gateways_after = PrivateGateway.list(
            self.apiClient,
            listall=self.test_data["listall"],
            vpcid=vpc_created.id
        )
        # Verifying PrivateGateways are listed
        status = validateList(list_private_gateways_after)
        self.assertEqual(PASS, status[0], "Failed to list Private Gateway")
        self.assertEqual(
            1,
            len(list_private_gateways_after),
            "list Private Gateway not equal as expected"
        )
        # Listing network acl list by paymentgateway.aclid
        list = NetworkACLList.list(self.userapiclient,
                                   listall=self.test_data["listall"],
                                   id=private_gateway_created.aclid
                                   )
        # Verifying the details of the Network acl list
        expected_dict = {
            "description": list_networkacl[0].description,
            "id": list_networkacl[0].id,
            "name": list_networkacl[0].name
        }
        actual_dict = {
            "description": list[0].description,
            "id": list[0].id,
            "name": list[0].name
        }
        list_networkacl_status = self.__verify_values(
            expected_dict,
            actual_dict
        )
        self.assertEqual(
            True,
            list_networkacl_status,
            "Listed Network acl list details are not as expected"
        )
        return
