cloudstack/test/integration/component/test_public_ip.py

# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.
""" Tests for acquiring/listing public ip address
"""
from nose.plugins.attrib import attr
from marvin.cloudstackTestCase import cloudstackTestCase
from marvin.lib.utils import cleanup_resources
from marvin.lib.base import (Account,
                             Configurations,
                             Domain,
                             PublicIpRange,
                             PublicIPAddress,
                             Network,
                             NetworkOffering,
                             ServiceOffering,
                             VPC,
                             VpcOffering,
                             Zone)
from marvin.lib.common import (get_zone,
                               get_domain,
                               get_template,
                               get_free_vlan
                              )
import logging
import random

class TestPublicIp(cloudstackTestCase):
    @classmethod
    def setUpClass(cls):
        cls.testClient = super(TestPublicIp, cls).getClsTestClient()
        cls.apiclient = cls.testClient.getApiClient()
        cls.services = cls.testClient.getParsedTestDataConfig()

        # Get Zone, Domain and templates
        cls.zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests())
        cls.services['mode'] = cls.zone.networktype
        cls.logger = logging.getLogger("TestPublicIp")
        cls.domain = get_domain(cls.apiclient)
        cls.services["virtual_machine"]["zoneid"] = cls.zone.id

        cls.template = get_template(
            cls.apiclient,
            cls.zone.id,
            cls.services["ostype"]
        )

        cls.use_system_ips_config_name = "use.system.public.ips"
        cls.use_system_ips_config = Configurations.list(
            cls.apiclient,
            name=cls.use_system_ips_config_name
        )
        cls.use_system_ips_config_value = cls.use_system_ips_config[0].value
        Configurations.update(
            cls.apiclient,
            name=cls.use_system_ips_config_name,
            value="false"
        )

        cls._cleanup = []
        cls.unsupportedHypervisor = False
        cls.hypervisor = cls.testClient.getHypervisorInfo()
        if cls.hypervisor.lower() in ['lxc']:
            cls.unsupportedHypervisor = True
            return

        # Create new domain1
        cls.domain1 = Domain.create(
            cls.apiclient,
            services=cls.services["acl"]["domain1"],
            parentdomainid=cls.domain.id)

        # Create account1
        cls.account1 = Account.create(
            cls.apiclient,
            cls.services["account"],
            # cls.services["acl"]["accountD1"],
            admin=True,
            domainid=cls.domain1.id
        )

        # Create new sub-domain
        cls.sub_domain = Domain.create(
            cls.apiclient,
            services=cls.services["acl"]["domain11"],
            parentdomainid=cls.domain1.id)

        # Create account for sub-domain
        cls.sub_account = Account.create(
            cls.apiclient,
            cls.services["acl"]["accountD11"],
            domainid=cls.sub_domain.id
        )

        # Create new domain2
        cls.domain2 = Domain.create(
            cls.apiclient,
            services=cls.services["acl"]["domain2"],
            parentdomainid=cls.domain.id)

        # Create account2
        cls.account2 = Account.create(
            cls.apiclient,
            cls.services["acl"]["accountD2"],
            domainid=cls.domain2.id
        )

        cls.services["publiciprange"]["zoneid"] = cls.zone.id
        cls.services["publiciprange"]["forvirtualnetwork"] = "true"

        # Create public ip range 1
        cls.services["publiciprange"]["vlan"] = get_free_vlan(
            cls.apiclient,
            cls.zone.id)[1]
        random_subnet_number = random.randrange(10,20)
        cls.services["publiciprange"]["gateway"] = "10.100." + \
                                                   str(random_subnet_number) + ".254"
        cls.services["publiciprange"]["startip"] = "10.100." + \
                                                   str(random_subnet_number) + ".1"
        cls.services["publiciprange"]["endip"] = "10.100." + \
                                                 str(random_subnet_number) + ".10"
        cls.services["publiciprange"]["netmask"] = "255.255.255.0"
        cls.public_ip_range1 = PublicIpRange.create(
            cls.apiclient,
            cls.services["publiciprange"],
            account=cls.account1.name,
            domainid=cls.account1.domainid
        )

        # dedicate ip range to sub domain
        cls.services["publiciprange"]["vlan"] = get_free_vlan(
            cls.apiclient,
            cls.zone.id)[1]
        random_subnet_number = random.randrange(10,20)
        cls.services["publiciprange"]["gateway"] = "10.110." + \
                                                    str(random_subnet_number) + ".254"
        cls.services["publiciprange"]["startip"] = "10.110." + \
                                                    str(random_subnet_number) + ".1"
        cls.services["publiciprange"]["endip"] = "10.110." + \
                                                  str(random_subnet_number) + ".10"
        cls.services["publiciprange"]["netmask"] = "255.255.255.0"
        cls.public_ip_range2 = PublicIpRange.create(
            cls.apiclient,
            cls.services["publiciprange"],
            account=cls.sub_account.name,
            domainid=cls.sub_account.domainid
        )

        # dedicate ip range to second domain
        cls.services["publiciprange"]["vlan"] = get_free_vlan(
            cls.apiclient,
            cls.zone.id)[1]
        random_subnet_number = random.randrange(10,20)
        cls.services["publiciprange"]["gateway"] = "10.120." + \
                                                   str(random_subnet_number) + ".254"
        cls.services["publiciprange"]["startip"] = "10.120." + \
                                                   str(random_subnet_number) + ".1"
        cls.services["publiciprange"]["endip"] = "10.120." + \
                                                 str(random_subnet_number) + ".10"
        cls.services["publiciprange"]["netmask"] = "255.255.255.0"
        cls.public_ip_range3 = PublicIpRange.create(
            cls.apiclient,
            cls.services["publiciprange"],
            account=cls.account2.name,
            domainid=cls.account2.domainid
        )

        # create vpc offering and VPC
        cls.vpc_off = VpcOffering.create(
            cls.apiclient,
            cls.services["vpc_offering"]
        )
        cls.vpc_off.update(cls.apiclient, state='Enabled')

        # create network offering
        cls.isolated_network_offering = NetworkOffering.create(
            cls.apiclient,
            cls.services["isolated_network_offering"],
            conservemode=False
        )

        NetworkOffering.update(
            cls.isolated_network_offering,
            cls.apiclient,
            id=cls.isolated_network_offering.id,
            state="enabled"
        )

        physical_network, shared_vlan = get_free_vlan(
            cls.apiclient, cls.zone.id)
        if shared_vlan is None:
            cls.fail("Failed to get free vlan id for shared network")

        cls.services["shared_network_offering"]["specifyVlan"] = "True"
        cls.services["shared_network_offering"]["specifyIpRanges"] = "True"

        cls.shared_network_offering = NetworkOffering.create(
            cls.apiclient,
            cls.services["shared_network_offering"],
            conservemode=False
        )

        NetworkOffering.update(
            cls.shared_network_offering,
            cls.apiclient,
            id=cls.shared_network_offering.id,
            state="enabled"
        )

        # create network using the shared network offering created
        cls.services["shared_network"]["acltype"] = "Domain"
        cls.services["shared_network"][
            "networkofferingid"] = cls.shared_network_offering.id
        cls.services["shared_network"][
            "physicalnetworkid"] = physical_network.id
        cls.services["shared_network"]["vlan"] = shared_vlan
        shared_network_subnet_number = random.randrange(1, 254)

        cls.services["shared_network"]["netmask"] = "255.255.255.0"
        cls.services["shared_network"]["gateway"] = "172.16." + \
                                                     str(shared_network_subnet_number) + ".254"
        cls.services["shared_network"]["startip"] = "172.16." + \
                                                     str(shared_network_subnet_number) + ".1"
        cls.services["shared_network"]["endip"] = "172.16." + \
                                                   str(shared_network_subnet_number) + ".10"

        cls.guest_network = Network.create(
            cls.apiclient,
            cls.services["shared_network"],
            networkofferingid=cls.shared_network_offering.id,
            zoneid=cls.zone.id
        )

        cls._cleanup.append(cls.guest_network)
        cls._cleanup.append(cls.shared_network_offering)
        cls._cleanup.append(cls.account1)
        cls._cleanup.append(cls.account2)
        cls._cleanup.append(cls.sub_account)
        cls._cleanup.append(cls.sub_domain)
        cls._cleanup.append(cls.domain1)
        cls._cleanup.append(cls.domain2)
        cls._cleanup.append(cls.public_ip_range1)
        cls._cleanup.append(cls.public_ip_range2)
        cls._cleanup.append(cls.public_ip_range3)

    @classmethod
    def tearDownClass(cls):
        try:
            cls.apiclient = super(
                TestPublicIp,
                cls).getClsTestClient().getApiClient()

            Configurations.update(
                cls.apiclient,
                name=cls.use_system_ips_config_name,
                value=cls.use_system_ips_config_value
            )
            # Cleanup resources used
            cleanup_resources(cls.apiclient, cls._cleanup)

        except Exception as e:
            raise Exception("Warning: Exception during cleanup : %s" % e)

        return

    def setUp(self):
        self.apiclient = self.testClient.getApiClient()
        self.cleanup = []
        return

    def tearDown(self):
        try:
            # Clean up, terminate the resources created
            cleanup_resources(self.apiclient, self.cleanup)
        except Exception as e:
            raise Exception("Warning: Exception during cleanup : %s" % e)
        return

    @attr(tags=["advanced", "basic", "sg"], required_hardware="false")
    def test_01_list_publicip_root_domain(self):
        """
        ROOT domain should be able to list public IP address of all
        sub domains

        Step 1: List all public ip address
        Step 2: Ensure that the count is greater than or equal to 30
        Step 3: Display only allocated ip address
        Step 4: Ensure that the count is greater than or equal to 0
        Step 5: Display ip address from shared networks
        Step 6: Ensure that the count is greater than or equal to 30
        :return:
        """
        # Step 1
        ipAddresses = PublicIPAddress.list(
            self.apiclient,
            allocatedonly=False,
            isrecursive=True,
            listall=True,
            forvirtualnetwork=True)

        # Step 2
        self.assertGreaterEqual(
            len(ipAddresses),
            30,
            "Unable to display all public ip for ROOT domain"
        )

        # Step 4
        ipAddresses = PublicIPAddress.list(
            self.apiclient,
            allocatedonly=True,
            isrecursive=True,
            listall=True,
            forvirtualnetwork=True)

        self.assertGreaterEqual(
            len(ipAddresses),
            0,
            "Unable to display all public ip for ROOT domain"
        )

        # Step 5
        ipAddresses = PublicIPAddress.list(
            self.apiclient,
            allocatedonly=False,
            isrecursive=True,
            listall=True,
            forvirtualnetwork=False)

        # Step 6
        self.assertGreaterEqual(
            len(ipAddresses),
            10,
            "Unable to display all public ip for ROOT domain"
        )

    @attr(tags=["advanced", "basic", "sg"], required_hardware="false")
    def test_02_list_publicip_domain_admin(self):
        """
        A domain admin should be able to list public IP address of
        his/her domain and all sub domains

        Step 1: Create an isolated network in the user domain and sub domain
        Step 2: Associate IP in the range, dedicated to domain1
        Step 3: Display all public ip address in domain1
        Step 4: Ensure that the count is greater than or equal to 10
        Step 5: Display only the allocated Ip address in domain1
        Step 6: Ensure that the count is 1
        Step 7: Try to display public ip address from shared networks
        Step 8: It should not return any result
        Step 9: Try to display ip address of domain1 from domain2
        Step 10: Ensure that it doesn't not return any result
        :return:
        """
        # Step 1. Create isolated network
        self.isolated_network1 = Network.create(
            self.apiclient,
            self.services["isolated_network"],
            accountid=self.account1.name,
            domainid=self.account1.domainid,
            networkofferingid=self.isolated_network_offering.id,
            zoneid=self.zone.id
        )

        # Step 2. Associate IP in range dedicated to domain1
        ip_address_1 = self.get_free_ipaddress(self.public_ip_range1.vlan.id, self.account1.domainid, self.account1.name)
        ipaddress = PublicIPAddress.create(
            self.apiclient,
            zoneid=self.zone.id,
            networkid=self.isolated_network1.id,
            ipaddress=ip_address_1
        )
        self.assertIsNotNone(
            ipaddress,
            "Failed to Associate IP Address"
        )

        # Step 3: Display all public ip address in domain1
        user = self.account1.user[0]
        user_api_client = self.testClient.getUserApiClient(user.username, self.domain1.name)

        ipAddresses = PublicIPAddress.list(
            user_api_client,
            allocatedonly=False,
            isrecursive=True,
            listall=True,
            forvirtualnetwork=True)

        # Step 4: Ensure that the count is equal to 10
        self.assertEqual(
            len(ipAddresses),
            10,
            "Failed to display all public ip address is domain %s" % self.domain1.name
        )

        # Display public ip address using network id
        ipAddresses = PublicIPAddress.list(
            self.apiclient,
            associatednetworkid=self.isolated_network1.id,
            account=self.account1.name,
            domainid=self.account1.domainid,
            allocatedonly=False,
            listall=True,
            forvirtualnetwork=True)

        # Step 4: Ensure that the count is greater than or equal to 10
        self.assertEqual(
            len(ipAddresses),
            10,
            "Failed to display all public ip address using network id"
        )

        # Step 5: Display all allocated public ip address in domain1
        ipAddresses = PublicIPAddress.list(
            user_api_client,
            allocatedonly=True,
            isrecursive=True,
            listall=True,
            forvirtualnetwork=True)

        # Step 6: Ensure that the count is greater than or equal to 1
        self.assertEqual(
            len(ipAddresses),
            1,
            "Allocated IP address is greater than 1"
        )

        # Step 7: Display public ip address from shared networks
        ipAddresses = PublicIPAddress.list(
            user_api_client,
            allocatedonly=True,
            isrecursive=True,
            listall=True,
            forvirtualnetwork=False)

        # Step 8: Ensure that the result is empty
        self.assertIsNone(
            ipAddresses,
            "Users should not display ip from shared networks"
        )

        try:
            # Step 9
            user = self.account2.user[0]
            user_api_client = self.testClient.getUserApiClient(user.username, self.domain2.name)

            ipAddresses = PublicIPAddress.list(
                user_api_client,
                allocatedonly=False,
                listall=True,
                associatednetworkid=self.isolated_network1.id,
                forvirtualnetwork=True)

            # Step 10
            self.fail("Domain should not access public ip of sibling domain")
        except Exception as e:
            self.info("Got exception as expected since domain2 can't access network of domain1")

    @attr(tags=["advanced", "basic", "sg"], required_hardware="false")
    def test_03_list_publicip_user_domain(self):
        """
        A regular user should be able to display public ip address
        only in their domain

        Step 1: Create an isolated network in the user domain
        Step 2: Display all public ip address in that domain
        Step 3: Ensure that the count is 10
        Step 4: Associate IP in the range, dedicated to domain2
        Step 5: Display only the allocated Ip address in domain2
        Step 6: Ensure that the count is 1
        Step 7: Try to display public ip address from shared networks
        Step 8: It should not return any result
        Step 9: Try to display allocated public ip address of child domain using networkid
        Step 10: It should display all allocated ip address from child domain
        Step 11: Try to display all public ip address from child domain
        Step 12: It should display all public ip of child domain
        Step 13: Try to display ip of domain2 from a different domain
        Step 14: Ensure that we get exception when trying to do so
        :return:
        """
        user = self.sub_account.user[0]
        sub_user_api_client = self.testClient.getUserApiClient(user.username, self.sub_domain.name)

        # Step 1: create network in child domain
        self.isolated_network2 = Network.create(
            self.apiclient,
            self.services["isolated_network"],
            accountid=self.sub_account.name,
            domainid=self.sub_account.domainid,
            networkofferingid=self.isolated_network_offering.id,
            zoneid=self.zone.id
        )

        # Step 2: Display all public ip address in sub domain
        ipAddresses = PublicIPAddress.list(
            sub_user_api_client,
            allocatedonly=False,
            listall=True,
            forvirtualnetwork=True)

        # Step 3: Ensure that sub domain can list only the ip address in their domain
        self.assertEqual(
            len(ipAddresses),
            10,
            "Allocated IP address is greater than 1"
        )

        # Step 4: Associate IP in range dedicated to sub domain
        ip_address_1 = self.get_free_ipaddress(self.public_ip_range2.vlan.id, self.sub_account.domainid, self.sub_account.name)
        ipaddress = PublicIPAddress.create(
            sub_user_api_client,
            zoneid=self.zone.id,
            networkid=self.isolated_network2.id,
            ipaddress=ip_address_1
        )

        # Step 5: Display all allocated ip address in sub domain
        ipAddresses = PublicIPAddress.list(
            sub_user_api_client,
            allocatedonly=True,
            listall=True,
            forvirtualnetwork=True)

        # Step 6: Ensure that the count is 1
        self.assertEqual(
            len(ipAddresses),
            1,
            "Allocated IP address is greater than 1"
        )

        # Step 7: Display ip address from shared networks
        ipAddresses = PublicIPAddress.list(
            sub_user_api_client,
            allocatedonly=True,
            listall=True,
            forvirtualnetwork=False)

        # Step 8: It should not return any result
        self.assertIsNone(
            ipAddresses,
            "Users should not display ip from shared networks"
        )

        user = self.account1.user[0]
        user_api_client = self.testClient.getUserApiClient(user.username, self.domain1.name)

        # Step 9: display ip of child domain using network id
        ipAddresses = PublicIPAddress.list(
            user_api_client,
            allocatedonly=True,
            listall=True,
            isrecursive=True,
            associatednetworkid=self.isolated_network2.id,
            forvirtualnetwork=True)

        # Step 10: Ensure that the count is 1 as only 1 ip is acquired in test 3
        self.assertEqual(
            len(ipAddresses),
            1,
            "Unable to display IP address of child domain using network id"
        )

        # Step 11: display ip of child domain using network id
        ipAddresses = PublicIPAddress.list(
            user_api_client,
            allocatedonly=False,
            listall=True,
            isrecursive=True,
            associatednetworkid=self.isolated_network2.id,
            forvirtualnetwork=True)

        # Step 12: Ensure that the count is 1 as only 1 ip is acquired in test 3
        self.assertEqual(
            len(ipAddresses),
            10,
            "Unable to display IP address of child domain using network id"
        )

        try:
            # Step 13
            user = self.account2.user[0]
            user_api_client = self.testClient.getUserApiClient(user.username, self.domain2.name)

            PublicIPAddress.list(
                user_api_client,
                allocatedonly=False,
                listall=True,
                associatednetworkid=self.isolated_network2.id,
                forvirtualnetwork=True)

            # Step 14
            self.fail("Domain should not access public ip of sibling domain")
        except Exception as e:
            self.info("Got exception as expected since domain2 can't access network of domain1")

    @attr(tags=["advanced", "basic", "sg"], required_hardware="false")
    def test_04_list_publicip_all_subdomains(self):
        """
        A domain admin should be able to display public ip address
        in their domain and also all child domains

        Step 1: Display all public ip address in that domain and sub domain
        Step 2: Ensure that the count is 11 (all ip from parent domain and allocated from sub domain)
        Step 3: Display only the allocated Ip address
        Step 4: Ensure that the count is 2
        Step 5: Display public ip of child domain using domain/account
        Step 6: Ensure that the count is 10
        Step 7: Display public ip of child domain using network id
        Step 8: Ensure that the count is 1 as only one IP is allocated
        :return:
        """
        user = self.account1.user[0]
        user_api_client = self.testClient.getUserApiClient(user.username, self.domain1.name)

        # Step 1: Display all public ip
        ipAddresses = PublicIPAddress.list(
            user_api_client,
            allocatedonly=False,
            listall=True,
            isrecursive=True,
            forvirtualnetwork=True)

        # Step 2: Ensure that it can display all ip from current domain and
        # only allocated ip from child domains
        self.assertEqual(
            len(ipAddresses),
            11,
            "Unable to display all IP address is domain %s" % self.domain1.name
        )

        # Step 3: display only allocated ip for parent and sub domain
        ipAddresses = PublicIPAddress.list(
            user_api_client,
            allocatedonly=True,
            listall=True,
            isrecursive=True,
            forvirtualnetwork=True)

        # Step 4: Ensure that the count is 2
        self.assertEqual(
            len(ipAddresses),
            2,
            "Unable to display all allocated IP address is domain %s" % self.domain1.name
        )

        # Step 5: display ip of child domain using domainid/account
        ipAddresses = PublicIPAddress.list(
            user_api_client,
            allocatedonly=False,
            listall=True,
            isrecursive=True,
            domainid=self.sub_domain.id,
            account=self.sub_account.name,
            forvirtualnetwork=True)

        # Step 6: Ensure that the count is 10
        self.assertEqual(
            len(ipAddresses),
            10,
            "Unable to display IP address of child domain"
        )

    @attr(tags=["advanced", "basic", "sg"], required_hardware="false")
    def test_05_list_publicip_user_domain(self):
        """
        A domain admin should be able to display public ip address
        in their domain and also all child domains

        Step 1: Display all public ip address in that domain and sub domain
        Step 2: Ensure that the count is 20
        Step 3: Display only the allocated Ip address
        Step 4: Ensure that the count is 2
        Step 5: Try to display public ip of vpc from different domain
        Step 6: Ensure that we get exception when trying to do so
        :return:
        """
        user = self.account2.user[0]
        user_api_client = self.testClient.getUserApiClient(user.username, self.domain2.name)

        self.services["vpc"]["cidr"] = "10.1.1.1/16"
        vpc_1 = VPC.create(
            user_api_client,
            self.services["vpc"],
            vpcofferingid=self.vpc_off.id,
            zoneid=self.zone.id,
            account=self.account2.name,
            domainid=self.account2.domainid
        )
        self.validate_vpc_network(vpc_1)

        ipAddresses = PublicIPAddress.list(
            user_api_client,
            allocatedonly=False,
            listall=True,
            forvirtualnetwork=True)

        self.assertGreaterEqual(
            len(ipAddresses),
            10,
            "Unable to display all public ip in VPC"
        )

        # List ip address using vpcid
        ipAddresses = PublicIPAddress.list(
            self.apiclient,
            vpcid=vpc_1.id,
            allocatedonly=False,
            account=self.account2.name,
            domainid=self.domain2.id,
            forvirtualnetwork=True)

        self.assertGreaterEqual(
            len(ipAddresses),
            10,
            "Unable to display all public ip in VPC"
        )

        # Acquire public ip address from VPC
        ip_address_1 = self.get_free_ipaddress(self.public_ip_range3.vlan.id, self.account2.domainid, self.account2.name)
        PublicIPAddress.create(
            user_api_client,
            zoneid=self.zone.id,
            vpcid=vpc_1.id,
            ipaddress=ip_address_1
        )

        ipAddresses = PublicIPAddress.list(
            user_api_client,
            allocatedonly=True,
            listall=True,
            forvirtualnetwork=True)

        self.assertGreaterEqual(
            len(ipAddresses),
            2,
            "Unable to display allocated public ip in VPC"
        )

        try:
            # Step 5
            user = self.account1.user[0]
            user_api_client = self.testClient.getUserApiClient(user.username, self.domain1.name)

            PublicIPAddress.list(
                user_api_client,
                allocatedonly=False,
                listall=True,
                vpcid=vpc_1.id,
                forvirtualnetwork=True)

            # Step 6
            self.fail("Domain should not access public ip of sibling domain")
        except Exception as e:
            self.info("Got exception as expected since domain2 can't access network of domain1")

        self.vpc_off.update(self.apiclient, state='Disabled')
        self.cleanup.append(vpc_1)
        self.cleanup.append(self.vpc_off)

    @attr(tags=["advanced", "basic", "sg"], required_hardware="false")
    def test_06_list_publicip_user_domain(self):
        """
        Display public ip address from shared networks
        1. List public ip address of shared network as root admin
        2. Ensure that it can display all public ip address
        3. List public ip address of shared networks as domain admin
        4. It should not return any result
        5. Try to display public ip by passing network id
        6. Ensure that we get exception when trying to do so
        :return:
        """
        # Step 1
        ipAddresses = PublicIPAddress.list(
            self.apiclient,
            allocatedonly=False,
            listall=True,
            networkid=self.guest_network.id,
            forvirtualnetwork=False)

        # Step 2
        self.assertGreaterEqual(
            len(ipAddresses),
            10,
            "Unable to display allocated public ip in VPC"
        )

        user = self.account1.user[0]
        user_api_client = self.testClient.getUserApiClient(user.username, self.domain1.name)

        # Step 3
        ipAddresses = PublicIPAddress.list(
            user_api_client,
            allocatedonly=False,
            listall=True,
            networkid=self.guest_network.id,
            forvirtualnetwork=False)

        # Step 4
        self.assertIsNone(
            ipAddresses,
            "Unable to display allocated public ip in VPC"
        )

        try:
            # Step 5
            PublicIPAddress.list(
                user_api_client,
                allocatedonly=False,
                listall=True,
                associatednetworkid=self.guest_network.id,
                forvirtualnetwork=True)

            # Step 6
            self.fail("Domain should not access public ip of sibling domain")
        except Exception as e:
            self.info("Got exception as expected since domain2 can't access network of domain1")

    def get_free_ipaddress(self, vlanId, domainId, account):
        ipaddresses = PublicIPAddress.list(
            self.apiclient,
            vlanid=vlanId,
            domainId=domainId,
            account=account,
            state='Free'
        )
        self.assertEqual(
            isinstance(ipaddresses, list),
            True,
            "List ipaddresses should return a valid response for Free ipaddresses"
        )
        random.shuffle(ipaddresses)
        return ipaddresses[0].ipaddress

    def validate_vpc_network(self, network, state=None):
        """Validates the VPC network"""

        self.debug("Check if the VPC network is created successfully?")
        vpc_networks = VPC.list(
            self.apiclient,
            id=network.id
        )
        self.assertEqual(
            isinstance(vpc_networks, list),
            True,
            "List VPC network should return a valid list"
        )
        self.assertEqual(
            network.name,
            vpc_networks[0].name,
            "Name of the VPC network should match with listVPC data"
        )
        if state:
            self.assertEqual(
                vpc_networks[0].state,
                state,
                "VPC state should be '%s'" % state
            )
        self.debug("VPC network validated - %s" % network.name)
        return