Return-Path: X-Original-To: apmail-cloudstack-commits-archive@www.apache.org Delivered-To: apmail-cloudstack-commits-archive@www.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id B685311C62 for ; Mon, 19 May 2014 12:31:46 +0000 (UTC) Received: (qmail 33734 invoked by uid 500); 19 May 2014 12:31:46 -0000 Delivered-To: apmail-cloudstack-commits-archive@cloudstack.apache.org Received: (qmail 33585 invoked by uid 500); 19 May 2014 12:31:46 -0000 Mailing-List: contact commits-help@cloudstack.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@cloudstack.apache.org Delivered-To: mailing list commits@cloudstack.apache.org Received: (qmail 33471 invoked by uid 99); 19 May 2014 12:31:46 -0000 Received: from tyr.zones.apache.org (HELO tyr.zones.apache.org) (140.211.11.114) by apache.org (qpsmtpd/0.29) with ESMTP; Mon, 19 May 2014 12:31:46 +0000 Received: by tyr.zones.apache.org (Postfix, from userid 65534) id 2D6B0986EFD; Mon, 19 May 2014 12:31:46 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: girish@apache.org To: commits@cloudstack.apache.org Date: Mon, 19 May 2014 12:31:50 -0000 Message-Id: In-Reply-To: <64bdd0ae4089486385f769b9b97e58fe@git.apache.org> References: <64bdd0ae4089486385f769b9b97e58fe@git.apache.org> X-Mailer: ASF-Git Admin Mailer Subject: [5/7] CLOUDSTACK-6282 - Divided test_escalations.py into individual files based on functionality and added automed tests for Public IP Addresses http://git-wip-us.apache.org/repos/asf/cloudstack/blob/2ba63220/test/integration/component/test_escalations_ipaddresses.py ---------------------------------------------------------------------- diff --git a/test/integration/component/test_escalations_ipaddresses.py b/test/integration/component/test_escalations_ipaddresses.py new file mode 100644 index 0000000..23dd76b --- /dev/null +++ b/test/integration/component/test_escalations_ipaddresses.py @@ -0,0 +1,4192 @@ +# 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.cloudstackException import * +from marvin.cloudstackAPI import * +from marvin.sshClient import SshClient +from marvin.lib.utils import * +from marvin.lib.base import * +from marvin.lib.common import * +from marvin.lib.utils import checkVolumeSize +from marvin.codes import SUCCESS +from nose.plugins.attrib import attr +from time import sleep + +class TestIpAddresses(cloudstackTestCase): + + @classmethod + def setUpClass(cls): + try: + cls._cleanup = [] + cls.testClient = super(TestIpAddresses, cls).getClsTestClient() + cls.api_client = cls.testClient.getApiClient() + cls.services = cls.testClient.getParsedTestDataConfig() + # 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.services["ostype"] + ) + if cls.zone.localstorageenabled: + cls.storagetype = 'local' + cls.services["service_offerings"]["tiny"]["storagetype"] = 'local' + else: + cls.storagetype = 'shared' + cls.services["service_offerings"]["tiny"]["storagetype"] = 'shared' + + cls.services['mode'] = cls.zone.networktype + cls.services["virtual_machine"]["hypervisor"] = cls.testClient.getHypervisorInfo() + cls.services["virtual_machine"]["zoneid"] = cls.zone.id + cls.services["virtual_machine"]["template"] = cls.template.id + cls.service_offering = ServiceOffering.create( + cls.api_client, + cls.services["service_offerings"]["tiny"] + ) + cls._cleanup.append(cls.service_offering) + cls.services['mode'] = cls.zone.networktype + cls.account = Account.create( + cls.api_client, + cls.services["account"], + domainid=cls.domain.id + ) + # 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._cleanup.append(cls.account) + 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): + #Clean up, terminate the created volumes + cleanup_resources(self.apiClient, self.cleanup) + return + + @classmethod + def tearDownClass(cls): + try: + cleanup_resources(cls.api_client, cls._cleanup) + except Exception as e: + raise Exception("Warning: Exception during cleanup : %s" % e) + + 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 = 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", "provisioning"]) + def test_01_list_ipaddresses_pagination(self): + """ + @summary: Test List IP Addresses pagination + @Steps: + Step1: Creating a network for the user + Step2: Listing all the IP Addresses for a user + Step3: Verifying that no IP Addresses are listed + Step4: Associating (pagesize + 1) number of IP Addresses + Step5: Listing all the IP Addresses again + Step6: Verifying the length of the IP Addresses is (page size + 1) + Step7: Listing all the IP Addresses in page1 + Step8: Verifying that the length of the IP Addresses in page 1 is (page size) + Step9: Listing all the IP Addresses in page2 + Step10: Verifying that the length of the IP Addresses in page 2 is 1 + Step11: Dis-Associating the IP Addresses present in page 2 + Step12: Listing for the IP Addresses on page 2 + Step13: Verifying that no IP Addresses are listed + """ + # Listing all the networks available + networks_list_before = Network.list( + self.userapiclient, + forvpc="false", + domainid=self.domain.id, + account=self.account.name, + ) + self.assertIsNone( + networks_list_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 + ) + status = validateList(network_offerings_list) + self.assertEquals( + PASS, + status[0], + "Isolated Network Offerings with sourceNat enabled are not found" + ) + # Creating a network + network = Network.create( + self.userapiclient, + self.services["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 all the networks available + networks_list_after = Network.list( + self.userapiclient, + forvpc="false", + domainid=self.domain.id, + account=self.account.name, + ) + status = validateList(networks_list_after) + self.assertEquals( + PASS, + status[0], + "Network Creation Failed" + ) + self.assertEquals( + 1, + len(networks_list_after), + "Network creation failed" + ) + # Listing all the IP Addresses for a user + list_ipaddresses_before = PublicIPAddress.list( + self.userapiclient, + listall=self.services["listall"] + ) + self.assertIsNone( + list_ipaddresses_before, + "IP Addresses listed for newly created user" + ) + # Associating (pagesize + 1) number of IP Addresses + for i in range(0, (self.services["pagesize"] + 1)): + ipaddress = PublicIPAddress.create( + self.userapiclient, + services=self.services["network"], + networkid=network.id + ) + self.assertIsNotNone( + ipaddress, + "Failed to Associate IP Address" + ) + + # Listing all the IP Addresses for a user + list_ipaddresses_after = PublicIPAddress.list( + self.userapiclient, + listall=self.services["listall"] + ) + status = validateList(list_ipaddresses_after) + self.assertEquals( + PASS, + status[0], + "IP Addresses Association Failed" + ) + # Verifying the length of the volumes is (page size + 1) + self.assertEqual( + (self.services["pagesize"] + 1), + len(list_ipaddresses_after), + "Number of IP Addresses associated are not matching expected" + ) + # Listing IP Address in page 1 + list_ipaddress_page1 = PublicIPAddress.list( + self.userapiclient, + listall=self.services["listall"], + page=1, + pagesize=self.services["pagesize"] + ) + status = validateList(list_ipaddress_page1) + self.assertEquals( + PASS, + status[0], + "Failed to list IP Addresses in page1" + ) + # Verifying that list size is equals to pagesize + self.assertEquals( + self.services["pagesize"], + len(list_ipaddress_page1), + "Failed to list pagesize number of IP Addresses in page1" + ) + # Listing IP Address in page 2 + list_ipaddress_page2 = PublicIPAddress.list( + self.userapiclient, + listall=self.services["listall"], + page=2, + pagesize=self.services["pagesize"] + ) + status = validateList(list_ipaddress_page2) + self.assertEquals( + PASS, + status[0], + "Failed to list IP Addresses in page2" + ) + # Verifying that List size is equal to 1 + self.assertEquals( + 1, + len(list_ipaddress_page2), + "Failed to list IP Addresses in page2" + ) + # Dis-associating an IP Address + ipaddress.delete(self.userapiclient) + # Listing IP Address in page 2 + list_ipaddress_page2 = PublicIPAddress.list( + self.userapiclient, + listall=self.services["listall"], + page=2, + pagesize=self.services["pagesize"] + ) + # Verifying that no IP Addresses are listed + self.assertIsNone( + list_ipaddress_page2, + "Disassociation of IP Address Failed" + ) + return + + @attr(tags=["advanced", "provisioning"]) + def test_02_list_ipaddresses_byid(self): + """ + @summary: Test List IP Addresses details by ID + @Steps: + Step1: Creating a network for the user + Step2: Listing all the IP Addresses for a user + Step3: Verifying that no IP Addresses are listed + Step4: Associating an IP Addresses for Network + Step5: Listing all the IP Addresses again + Step6: Verifying the length of the IP Addresses is 1 + Step7: Listing the IP Addresses by Id + Step8: Verifying that the length of the IP Addresses list is 1 + Step9: Verifying the details of the Listed IP Address + """ + # Listing all the networks available + networks_list_before = Network.list( + self.userapiclient, + forvpc="false", + domainid=self.domain.id, + account=self.account.name, + ) + self.assertIsNone( + networks_list_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 + ) + status = validateList(network_offerings_list) + self.assertEquals( + PASS, + status[0], + "Isolated Network Offerings with sourceNat enabled are not found" + ) + # Creating a network + network = Network.create( + self.userapiclient, + self.services["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 all the networks available + networks_list_after = Network.list( + self.userapiclient, + forvpc="false", + domainid=self.domain.id, + account=self.account.name, + ) + status = validateList(networks_list_after) + self.assertEquals( + PASS, + status[0], + "Network Creation Failed" + ) + self.assertEquals( + 1, + len(networks_list_after), + "Network creation failed" + ) + # Listing the Network By ID + network_list_byid = Network.list( + self.userapiclient, + listall=self.services["listall"], + id=network.id + ) + status = validateList(network_list_byid) + self.assertEquals( + PASS, + status[0], + "Failed to list Network by Id" + ) + self.assertEquals( + 1, + len(network_list_byid), + "Failed to list Network by Id" + ) + # Listing all the IP Addresses for a user + list_ipaddresses_before = PublicIPAddress.list( + self.userapiclient, + listall=self.services["listall"] + ) + self.assertIsNone( + list_ipaddresses_before, + "IP Addresses listed for newly created user" + ) + # Associating an IP Addresses to Network created + associated_ipaddress = PublicIPAddress.create( + self.userapiclient, + services=self.services["network"], + networkid=network_list_byid[0].id + ) + self.assertIsNotNone( + associated_ipaddress, + "Failed to Associate IP Address" + ) + # Listing all the IP Addresses for a user + list_ipaddresses_after = PublicIPAddress.list( + self.userapiclient, + listall=self.services["listall"] + ) + status = validateList(list_ipaddresses_after) + self.assertEquals( + PASS, + status[0], + "IP Addresses Association Failed" + ) + # Verifying the length of the list is 1 + self.assertEqual( + 1, + len(list_ipaddresses_after), + "Number of IP Addresses associated are not matching expected" + ) + # Listing IP Address by id + list_ipaddress_byid = PublicIPAddress.list( + self.userapiclient, + id=associated_ipaddress.ipaddress.id + ) + status = validateList(list_ipaddress_byid) + self.assertEquals( + PASS, + status[0], + "Failed to list IP Addresses by ID" + ) + # Verifying that list size is equals to 1 + self.assertEquals( + 1, + len(list_ipaddress_byid), + "Failed to list IP Addresses by ID" + ) + # Verifying details of the listed IP Address to be same as IP Address created above + # Creating expected and actual values dictionaries + expected_dict = { + "id":associated_ipaddress.ipaddress.id, + "associatednetworkid":associated_ipaddress.ipaddress.associatednetworkid, + "associatednetworkname":associated_ipaddress.ipaddress.associatednetworkname, + "ipaddress":associated_ipaddress.ipaddress.ipaddress, + "issourcenat":associated_ipaddress.ipaddress.issourcenat, + "isstaticnat":associated_ipaddress.ipaddress.isstaticnat, + "networkid":associated_ipaddress.ipaddress.networkid + } + actual_dict = { + "id":list_ipaddress_byid[0].id, + "associatednetworkid":list_ipaddress_byid[0].associatednetworkid, + "associatednetworkname":list_ipaddress_byid[0].associatednetworkname, + "ipaddress":list_ipaddress_byid[0].ipaddress, + "issourcenat":list_ipaddress_byid[0].issourcenat, + "isstaticnat":list_ipaddress_byid[0].isstaticnat, + "networkid":list_ipaddress_byid[0].networkid + } + ipaddress_status = self.__verify_values( + expected_dict, + actual_dict + ) + self.assertEqual( + True, + ipaddress_status, + "Listed IP Address details are not as expected" + ) + return + + @attr(tags=["advanced", "provisioning"]) + def test_03_associate_ipaddress_for_vpc(self): + """ + @summary: Test to Associate IP Address for VPC + @Steps: + Step1: Creating a VPC for the user + Step2: Listing all the IP Addresses for a user + Step3: Verifying that 1 IP Addresses is listed + Step4: Associating an IP Addresses for VPC + Step5: Listing all the IP Addresses again + Step6: Verifying the length of the IP Addresses list is 2 + Step7: Listing the IP Addresses by Id + Step8: Verifying that the length of the IP Addresses list is 1 + Step9: Verifying the details of the Listed IP Address + """ + # 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's Listed for newly Created User" + ) + # Listing VPC Offerings + list_vpc_offering = VpcOffering.list(self.userapiclient) + status = validateList(list_vpc_offering) + self.assertEquals( + PASS, + status[0], + "list vpc offering is none") + # Creating a vpc + vpc_created = VPC.create( + self.userapiclient, + self.services["vpc"], + list_vpc_offering[0].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.assertEquals( + PASS, + status[0], + "list VPC not as expected" + ) + # Verifying the list vpc size is increased by 1 + self.assertEquals( + 1, + len(list_vpc_after), + "list VPC not equal as expected" + ) + # Listing all the IP Addresses for a user + list_ipaddresses_before = PublicIPAddress.list( + self.userapiclient, + listall=self.services["listall"] + ) + status = validateList(list_ipaddresses_before) + self.assertEquals( + PASS, + status[0], + "Failed to List VPC IP Address" + ) + self.assertEquals( + 1, + len(list_ipaddresses_before), + "Failed to List VPC IP Address" + ) + # Associating an IP Addresses to VPC created + associated_ipaddress = PublicIPAddress.create( + self.userapiclient, + services=self.services["network"], + vpcid=vpc_created.id + ) + self.assertIsNotNone( + associated_ipaddress, + "Failed to Associate IP Address" + ) + # Listing all the IP Addresses for a user + list_ipaddresses_after = PublicIPAddress.list( + self.userapiclient, + listall=self.services["listall"] + ) + status = validateList(list_ipaddresses_after) + self.assertEquals( + PASS, + status[0], + "IP Addresses Association Failed" + ) + # Verifying the length of the list is 1 + self.assertEqual( + len(list_ipaddresses_before) + 1, + len(list_ipaddresses_after), + "Number of IP Addresses associated are not matching expected" + ) + # Listing IP Address by id + list_ipaddress_byid = PublicIPAddress.list( + self.userapiclient, + listall=self.services["listall"], + page=1, + pagesize=self.services["pagesize"], + id=associated_ipaddress.ipaddress.id + ) + status = validateList(list_ipaddress_byid) + self.assertEquals( + PASS, + status[0], + "Failed to list IP Addresses by ID" + ) + # Verifying that list size is equals to 1 + self.assertEquals( + 1, + len(list_ipaddress_byid), + "Failed to list IP Addresses by ID" + ) + # Verifying details of the listed IP Address to be same as IP Address created above + # Creating expected and actual values dictionaries + expected_dict = { + "id":associated_ipaddress.ipaddress.id, + "associatednetworkid":associated_ipaddress.ipaddress.associatednetworkid, + "associatednetworkname":associated_ipaddress.ipaddress.associatednetworkname, + "ipaddress":associated_ipaddress.ipaddress.ipaddress, + "issourcenat":associated_ipaddress.ipaddress.issourcenat, + "isstaticnat":associated_ipaddress.ipaddress.isstaticnat, + "networkid":associated_ipaddress.ipaddress.networkid, + "vpcid":associated_ipaddress.ipaddress.vpcid + } + actual_dict = { + "id":list_ipaddress_byid[0].id, + "associatednetworkid":list_ipaddress_byid[0].associatednetworkid, + "associatednetworkname":list_ipaddress_byid[0].associatednetworkname, + "ipaddress":list_ipaddress_byid[0].ipaddress, + "issourcenat":list_ipaddress_byid[0].issourcenat, + "isstaticnat":list_ipaddress_byid[0].isstaticnat, + "networkid":list_ipaddress_byid[0].networkid, + "vpcid":list_ipaddress_byid[0].vpcid + } + ipaddress_status = self.__verify_values( + expected_dict, + actual_dict + ) + self.assertEqual( + True, + ipaddress_status, + "Listed IP Address details are not as expected" + ) + return + + @attr(tags=["advanced", "provisioning"]) + def test_04_create_delete_lbrule_fornonvpc(self): + """ + @summary: Test to list, create and delete Load Balancer Rule for IP Address associated to Non VPC network + @Steps: + Step1: Creating a Network for the user + Step2: Associating an IP Addresses for Network + Step3: Listing Load Balancer Rules for the IP Address associated in Step2 + Step4: Verifying that no Load Balancer Rules are listed + Step5: Creating a Load Balancer Rule for IP Address associated in Step2 + Step6: Listing Load Balancer Rules for the IP Address associated in Step2 + Step7: Verifying 1 Load Balancer Rule is listed + Step8: Deleting the Load Balancer Rule created in Step5 + Step9: Listing Load Balancer Rules for the IP Address associated in Step2 + Step10: Verifying that no Load Balancer Rules are listed + """ + # Listing all the Networks's for a user + list_networks_before = Network.list( + self.userapiclient, + listall=self.services["listall"] + ) + # 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,Lb", + zoneid=self.zone.id + ) + status = validateList(network_offerings_list) + self.assertEquals( + PASS, + status[0], + "Isolated Network Offerings with sourceNat, Lb enabled are not found" + ) + # Creating a network + network = Network.create( + self.userapiclient, + self.services["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 all the IP Addresses for a user + list_ipaddresses_before = PublicIPAddress.list( + self.userapiclient, + listall=self.services["listall"] + ) + # Verifying no IP Addresses are listed + self.assertIsNone( + list_ipaddresses_before, + "IP Addresses listed for newly created User" + ) + # Associating an IP Addresses to Network created + associated_ipaddress = PublicIPAddress.create( + self.userapiclient, + services=self.services["network"], + networkid=network.id + ) + self.assertIsNotNone( + associated_ipaddress, + "Failed to Associate IP Address" + ) + # Listing all the IP Addresses for a user + list_ipaddresses_after = PublicIPAddress.list( + self.userapiclient, + listall=self.services["listall"] + ) + status = validateList(list_ipaddresses_after) + self.assertEquals( + PASS, + status[0], + "IP Addresses Association Failed" + ) + # Verifying the length of the list is 1 + self.assertEqual( + 1, + len(list_ipaddresses_after), + "Number of IP Addresses associated are not matching expected" + ) + # Listing Load Balancer Rules for the Ip Address + list_lbrules_before = LoadBalancerRule.list( + self.userapiclient, + listall=self.services["listall"], + publicipid=associated_ipaddress.ipaddress.id + ) + # Verifying no Load Balancer Rules are listed + self.assertIsNone( + list_lbrules_before, + "Load Balancer Rules listed for newly Acquired Ip Address" + ) + self.services["lbrule"]["openfirewall"] = 'false' + # Creating a Load Balancer Rule for Ip Address + lb_rule = LoadBalancerRule.create( + self.userapiclient, + self.services["lbrule"], + ipaddressid=associated_ipaddress.ipaddress.id, + ) + self.assertIsNotNone( + lb_rule, + "Failed to create Load Balancer Rule" + ) + # Verifying details of created Load Balancer Rule + # Creating expected and actual values dictionaries + expected_dict = { + "algorithm":self.services["lbrule"]["alg"], + "privateport":str(self.services["lbrule"]["privateport"]), + "publicport":str(self.services["lbrule"]["publicport"]), + "name":self.services["lbrule"]["name"], + } + actual_dict = { + "algorithm":str(lb_rule.algorithm), + "privateport":str(lb_rule.privateport), + "publicport":str(lb_rule.publicport), + "name":str(lb_rule.name), + } + lbrule_status = self.__verify_values( + expected_dict, + actual_dict + ) + self.assertEqual( + True, + lbrule_status, + "Created Load Balancer Rule details are not as expected" + ) + # Listing Load Balancer Rules for the Ip Address + list_lbrules_after = LoadBalancerRule.list( + self.userapiclient, + listall=self.services["listall"], + publicipid=associated_ipaddress.ipaddress.id + ) + status = validateList(list_lbrules_after) + self.assertEquals( + PASS, + status[0], + "Load Balancer Rule creation Failed" + ) + # Verifying the length of the list is 1 + self.assertEqual( + 1, + len(list_lbrules_after), + "Load Balancer Rule creation Failed" + ) + # Deleting Load Balancer Rule + lb_rule.delete(self.userapiclient) + # Listing Load Balancer Rules for the Ip Address + list_lbrules_after = LoadBalancerRule.list( + self.userapiclient, + listall=self.services["listall"], + publicipid=associated_ipaddress.ipaddress.id + ) + # Verifying no Load Balancer Rules are Listed + self.assertIsNone( + list_lbrules_after, + "Failed to delete Load Balancer Rule" + ) + return + + @attr(tags=["advanced", "provisioning"]) + def test_05_create_delete_lbrule_forvpc(self): + """ + @summary: Test to list, create and delete Load Balancer Rule for IP Address associated to VPC + @Steps: + Step1: Creating a VPC for the user + Step2: Creating Network inside VPC + Step3: Associating an IP Addresses for VPC + Step4: Listing Load Balancer Rules for the IP Address associated in Step2 + Step5: Verifying that no Load Balancer Rules are listed + Step6: Creating a Load Balancer Rule for IP Address associated in Step2 + Step7: Listing Load Balancer Rules for the IP Address associated in Step2 + Step8: Verifying 1 Load Balancer Rule is listed + Step9: Deleting the Load Balancer Rule created in Step5 + Step10: Listing Load Balancer Rules for the IP Address associated in Step2 + Step11: Verifying that no Load Balancer Rules are listed + """ + # 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's Listed for newly Created User" + ) + # Listing VPC Offerings + list_vpc_offering = VpcOffering.list(self.userapiclient) + status = validateList(list_vpc_offering) + self.assertEquals( + PASS, + status[0], + "list vpc offering is none") + # Creating a vpc + vpc_created = VPC.create( + self.userapiclient, + self.services["vpc"], + list_vpc_offering[0].id, + self.zone.id + ) + self.assertIsNotNone( + vpc_created, + "VPC Creation Failed" + ) + # Listing the vpc for a user after creating a vpc + list_vpc_after = VPC.list(self.userapiclient) + status = validateList(list_vpc_after) + self.assertEquals( + PASS, + status[0], + "list VPC not as expected" + ) + # Verifying the list vpc size is increased by 1 + self.assertEquals( + 1, + len(list_vpc_after), + "list VPC not equal as expected" + ) + #List network offering for vpc = true + network_offering_vpc_true_list = NetworkOffering.list( + self.userapiclient, + forvpc = "true", + zoneid = self.zone.id, + supportedServices = "Lb", + state = "Enabled" + ) + status = validateList(network_offering_vpc_true_list) + self.assertEquals(PASS, status[0], "Default network offering not present for vpc = true with Lb") + # Creating network under VPC + network_created = Network.create( + self.userapiclient, + self.services["ntwk"], + networkofferingid = network_offering_vpc_true_list[0].id, + vpcid = vpc_created.id, + zoneid=self.zone.id, + gateway= self.services["ntwk"]["gateway"], + netmask = self.services["ntwk"]["netmask"] + ) + self.cleanup.append(network_created) + self.assertIsNotNone( + network_created, + "Network is not created" + ) + self.cleanup.append(vpc_created) + # Listing all the IP Addresses for a user + list_ipaddresses_before = PublicIPAddress.list( + self.userapiclient, + listall=self.services["listall"] + ) + status = validateList(list_ipaddresses_before) + self.assertEquals( + PASS, + status[0], + "list IP Addresses not as expected" + ) + # Verifying the list vpc size is increased by 1 + self.assertEquals( + 1, + len(list_ipaddresses_before), + "list IP Addresses not equal as expected" + ) + # Associating an IP Addresses to VPC created + associated_ipaddress = PublicIPAddress.create( + self.userapiclient, + services=self.services["network"], + vpcid=vpc_created.id + ) + self.assertIsNotNone( + associated_ipaddress, + "Failed to Associate IP Address" + ) + # Listing all the IP Addresses for a user + list_ipaddresses_after = PublicIPAddress.list( + self.userapiclient, + listall=self.services["listall"] + ) + status = validateList(list_ipaddresses_after) + self.assertEquals( + PASS, + status[0], + "IP Addresses Association Failed" + ) + # Verifying the length of the list is 1 + self.assertEqual( + len(list_ipaddresses_before) + 1, + len(list_ipaddresses_after), + "Number of IP Addresses associated are not matching expected" + ) + # Listing Load Balancer Rules for the Ip Address + list_lbrules_before = LoadBalancerRule.list( + self.userapiclient, + listall=self.services["listall"], + publicipid=associated_ipaddress.ipaddress.id + ) + # Verifying no Load Balancer Rules are listed + self.assertIsNone( + list_lbrules_before, + "Load Balancer Rules listed for newly Acquired Ip Address" + ) + self.services["lbrule"]["openfirewall"] = 'false' + # Creating a Load Balancer Rule for Ip Address + lb_rule = LoadBalancerRule.create( + self.userapiclient, + self.services["lbrule"], + ipaddressid=associated_ipaddress.ipaddress.id, + networkid=network_created.id + ) + self.assertIsNotNone( + lb_rule, + "Failed to create Load Balancer Rule" + ) + # Verifying details of created Load Balancer Rule + # Creating expected and actual values dictionaries + expected_dict = { + "algorithm":self.services["lbrule"]["alg"], + "privateport":str(self.services["lbrule"]["privateport"]), + "publicport":str(self.services["lbrule"]["publicport"]), + "name":self.services["lbrule"]["name"], + } + actual_dict = { + "algorithm":str(lb_rule.algorithm), + "privateport":str(lb_rule.privateport), + "publicport":str(lb_rule.publicport), + "name":str(lb_rule.name), + } + lbrule_status = self.__verify_values( + expected_dict, + actual_dict + ) + self.assertEqual( + True, + lbrule_status, + "Created Load Balancer Rule details are not as expected" + ) + # Listing Load Balancer Rules for the Ip Address + list_lbrules_after = LoadBalancerRule.list( + self.userapiclient, + listall=self.services["listall"], + publicipid=associated_ipaddress.ipaddress.id, + ) + status = validateList(list_lbrules_after) + self.assertEquals( + PASS, + status[0], + "Load Balancer Rule creation Failed" + ) + # Verifying the length of the list is 1 + self.assertEqual( + 1, + len(list_lbrules_after), + "Load Balancer Rule creation Failed" + ) + # Deleting Load Balancer Rule + lb_rule.delete(self.userapiclient) + # Listing Load Balancer Rules for the Ip Address + list_lbrules_after = LoadBalancerRule.list( + self.userapiclient, + listall=self.services["listall"], + publicipid=associated_ipaddress.ipaddress.id + ) + # Verifying no Load Balancer Rules are Listed + self.assertIsNone( + list_lbrules_after, + "Failed to delete Load Balancer Rule" + ) + return + + @attr(tags=["advanced", "provisioning"]) + def test_06_update_lbrule_name(self): + """ + @summary: Test to Update Load Balancer Rule Name for IP Address associated to Non VPC network + @Steps: + Step1: Creating a Network for the user + Step2: Associating an IP Addresses for Network + Step3: Listing Load Balancer Rules for the IP Address associated in Step2 + Step4: Verifying that no Load Balancer Rules are listed + Step5: Creating a Load Balancer Rule for IP Address associated in Step2 + Step6: Listing Load Balancer Rules for the IP Address associated in Step2 + Step7: Verifying 1 Load Balancer Rule is listed + Step8: Updating the Load Balancer Rule created in Step5 + Step9: Verifying that Load Balancer Rule details are updated + """ + # Listing all the Networks's for a user + list_networks_before = Network.list( + self.userapiclient, + listall=self.services["listall"] + ) + # 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,Lb", + zoneid=self.zone.id + ) + status = validateList(network_offerings_list) + self.assertEquals( + PASS, + status[0], + "Isolated Network Offerings with sourceNat, Lb enabled are not found" + ) + # Creating a network + network = Network.create( + self.userapiclient, + self.services["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 again + list_networks_after = Network.list( + self.userapiclient, + listall=self.services["listall"] + ) + status = validateList(list_networks_after) + self.assertEquals( + PASS, + status[0], + "Network Creation Failed" + ) + # Verifying network list count is increased by 1 + self.assertEquals( + 1, + len(list_networks_after), + "Network Creation Failed" + ) + # Listing all the IP Addresses for a user + list_ipaddresses_before = PublicIPAddress.list( + self.userapiclient, + listall=self.services["listall"] + ) + # Verifying no IP Addresses are listed + self.assertIsNone( + list_ipaddresses_before, + "IP Addresses listed for newly created User" + ) + # Associating an IP Addresses to Network created + associated_ipaddress = PublicIPAddress.create( + self.userapiclient, + services=self.services["network"], + networkid=network.id + ) + self.assertIsNotNone( + associated_ipaddress, + "Failed to Associate IP Address" + ) + # Listing all the IP Addresses for a user + list_ipaddresses_after = PublicIPAddress.list( + self.userapiclient, + listall=self.services["listall"] + ) + status = validateList(list_ipaddresses_after) + self.assertEquals( + PASS, + status[0], + "IP Addresses Association Failed" + ) + # Verifying the length of the list is 1 + self.assertEqual( + 1, + len(list_ipaddresses_after), + "Number of IP Addresses associated are not matching expected" + ) + # Listing Load Balancer Rules for the Ip Address + list_lbrules_before = LoadBalancerRule.list( + self.userapiclient, + listall=self.services["listall"], + publicipid=associated_ipaddress.ipaddress.id + ) + # Verifying no Load Balancer Rules are listed + self.assertIsNone( + list_lbrules_before, + "Load Balancer Rules listed for newly Acquired Ip Address" + ) + self.services["lbrule"]["openfirewall"] = 'false' + # Creating a Load Balancer Rule for Ip Address + lb_rule = LoadBalancerRule.create( + self.userapiclient, + self.services["lbrule"], + ipaddressid=associated_ipaddress.ipaddress.id, + ) + self.assertIsNotNone( + lb_rule, + "Failed to create Load Balancer Rule" + ) + # Listing Load Balancer Rules for the Ip Address + list_lbrules_after = LoadBalancerRule.list( + self.userapiclient, + listall=self.services["listall"], + publicipid=associated_ipaddress.ipaddress.id + ) + status = validateList(list_lbrules_after) + self.assertEquals( + PASS, + status[0], + "Load Balancer Rule creation Failed" + ) + # Verifying the length of the list is 1 + self.assertEqual( + 1, + len(list_lbrules_after), + "Load Balancer Rule creation Failed" + ) + # Updating Load Balancer Rule Name + updated_lb_rule = LoadBalancerRule.update( + lb_rule, + self.userapiclient, + algorithm="source", + name="NewLBRuleName" + ) + self.assertIsNotNone( + updated_lb_rule, + "Failed to update Load Balancer Rule details" + ) + # Verifying details of the updated Load Balancer Rule + # Creating expected and actual values dictionaries + expected_dict = { + "id":lb_rule.id, + "account":lb_rule.account, + "algorithm":"source", + "domainid":lb_rule.domainid, + "name":"NewLBRuleName", + "networkid":lb_rule.networkid, + "zoneid":lb_rule.zoneid, + "privateport":lb_rule.privateport, + "publicip":lb_rule.publicip, + "publicport":lb_rule.publicport, + } + actual_dict = { + "id":updated_lb_rule.id, + "account":updated_lb_rule.account, + "algorithm":updated_lb_rule.algorithm, + "domainid":updated_lb_rule.domainid, + "name":updated_lb_rule.name, + "networkid":updated_lb_rule.networkid, + "zoneid":updated_lb_rule.zoneid, + "privateport":updated_lb_rule.privateport, + "publicip":updated_lb_rule.publicip, + "publicport":updated_lb_rule.publicport, + } + lbrule_status = self.__verify_values( + expected_dict, + actual_dict + ) + self.assertEqual( + True, + lbrule_status, + "Updated Load Balancer Rule details are not as expected" + ) + return + + @attr(tags=["advanced", "provisioning"]) + def test_07_assign_remove_lbrule_toinstance(self): + """ + @summary: Test to Assign and Remove Load Balancer Rule to an Instance + @Steps: + Step1: Creating a Network for the user + Step2: Associating an IP Addresses for Network + Step3: Launching a VM using the network created in Step 1 + Step4: Creating a Load Balancer Rule for IP Address associated in Step2 + Step5: Listing Load Balancer Rule Instances for applied as true + Step6: Verifying no Load balancer rule instances are listed + Step7: Listing Load Balancer Rule Instances for applied as false + Step8: Verifying that list size is 1 + Step9: Assigning the Instance to Load Balancer Rule + Step10: Listing Load Balancer Rule Instances for applied as true + Step11: Verifying list size is 1 + Step12: Listing Load Balancer Rule Instances for applied as false + Step13: Verifying no Load balancer rule instances are listed + Step14: Removing the Load Balancer Rule assigned form Instance + Step15: Listing Load Balancer Rule Instances for applied as true + Step16: Verifying no Load balancer rule instances are listed + Step17: Listing Load Balancer Rule Instances for applied as false + Step18: Verifying that list size is 1 + """ + # Listing all the Networks's for a user + list_networks_before = Network.list( + self.userapiclient, + listall=self.services["listall"] + ) + # 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,Lb", + zoneid=self.zone.id + ) + status = validateList(network_offerings_list) + self.assertEquals( + PASS, + status[0], + "Isolated Network Offerings with sourceNat, Lb enabled are not found" + ) + # Creating a network + network = Network.create( + self.userapiclient, + self.services["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" + ) + # Listing all the IP Addresses for a user + list_ipaddresses_before = PublicIPAddress.list( + self.userapiclient, + listall=self.services["listall"] + ) + # Verifying no IP Addresses are listed + self.assertIsNone( + list_ipaddresses_before, + "IP Addresses listed for newly created User" + ) + # Associating an IP Addresses to Network created + associated_ipaddress = PublicIPAddress.create( + self.userapiclient, + services=self.services["network"], + networkid=network.id + ) + self.assertIsNotNone( + associated_ipaddress, + "Failed to Associate IP Address" + ) + # Listing all the IP Addresses for a user + list_ipaddresses_after = PublicIPAddress.list( + self.userapiclient, + listall=self.services["listall"] + ) + status = validateList(list_ipaddresses_after) + self.assertEquals( + PASS, + status[0], + "IP Addresses Association Failed" + ) + # Verifying the length of the list is 1 + self.assertEqual( + 1, + len(list_ipaddresses_after), + "Number of IP Addresses associated are not matching expected" + ) + # Launching a Virtual Machine with above created Network + vm_created = VirtualMachine.create( + self.userapiclient, + self.services["virtual_machine"], + accountid=self.account.name, + domainid=self.account.domainid, + networkids=network.id, + serviceofferingid=self.service_offering.id, + ) + self.assertIsNotNone( + vm_created, + "Failed to launch a VM under network created" + ) + self.cleanup.append(network) + # Listing Virtual Machines in Running state in the network created above + list_vms_running = VirtualMachine.list( + self.userapiclient, + listall=self.services["listall"], + account=self.account.name, + domainid=self.domain.id, + state="Running", + networkid=network.id + ) + status = validateList(list_vms_running) + self.assertEquals( + PASS, + status[0], + "VM Created is not in Running state" + ) + # Verifying the length of the list is 1 + self.assertEqual( + 1, + len(list_vms_running), + "VM Created is not in Running state" + ) + self.assertEquals( + vm_created.id, + list_vms_running[0].id, + "VM Created is not in Running state" + ) + # Listing Virtual Machines in Stopped state in the network created above + list_vms_stopped = VirtualMachine.list( + self.userapiclient, + listall=self.services["listall"], + account=self.account.name, + domainid=self.domain.id, + state="Stopped", + networkid=network.id + ) + # Verifying that no vms are listed + self.assertIsNone( + list_vms_stopped, + "Created VM is in Stopped state" + ) + # Listing Load Balancer Rules for the Ip Address + list_lbrules_before = LoadBalancerRule.list( + self.userapiclient, + listall=self.services["listall"], + publicipid=associated_ipaddress.ipaddress.id + ) + # Verifying no Load Balancer Rules are listed + self.assertIsNone( + list_lbrules_before, + "Load Balancer Rules listed for newly Acquired Ip Address" + ) + self.services["lbrule"]["openfirewall"] = 'false' + # Creating a Load Balancer Rule for Ip Address + lb_rule = LoadBalancerRule.create( + self.userapiclient, + self.services["lbrule"], + ipaddressid=associated_ipaddress.ipaddress.id, + ) + self.assertIsNotNone( + lb_rule, + "Failed to create Load Balancer Rule" + ) + # Listing Load Balancer Rules for the Ip Address + list_lbrules_after = LoadBalancerRule.list( + self.userapiclient, + listall=self.services["listall"], + publicipid=associated_ipaddress.ipaddress.id + ) + status = validateList(list_lbrules_after) + self.assertEquals( + PASS, + status[0], + "Load Balancer Rule creation Failed" + ) + # Verifying the length of the list is 1 + self.assertEqual( + 1, + len(list_lbrules_after), + "Load Balancer Rule creation Failed" + ) + # Listing Load Balancer Rule Instances for applied as true + list_lbruleinstance_applied_true = LoadBalancerRule.listLoadBalancerRuleInstances( + self.userapiclient, + id=lb_rule.id, + applied="true" + ) + # Verifying No Instances are assigned to the Load Balancer Rule + self.assertIsNone( + list_lbruleinstance_applied_true, + "Instances are assigned to Newly created Load Balancer Rule" + ) + # Listing Load Balancer Rule Instances for applied as false + list_lbruleinstance_applied_false = LoadBalancerRule.listLoadBalancerRuleInstances( + self.userapiclient, + id=lb_rule.id, + applied="false" + ) + status = validateList(list_lbruleinstance_applied_false) + self.assertEquals( + PASS, + status[0], + "No Instances are available to assign to Load Balancer Rule" + ) + # Verifying the length of the list is 1 + self.assertEqual( + 1, + len(list_lbruleinstance_applied_false), + "No Instances are available to assign to Load Balancer Rule" + ) + # Verifying that Instance created above is listed + self.assertEquals( + vm_created.id, + list_lbruleinstance_applied_false[0].id, + "Failed to list Instance available to asign a Load Balancer Rule" + ) + # Assigning Instance created to Load Balancer Rule + LoadBalancerRule.assign( + lb_rule, + self.userapiclient, + vms=[vm_created] + ) + # Listing Load Balancer Rule Instances for applied as true + list_lbruleinstance_applied_true = LoadBalancerRule.listLoadBalancerRuleInstances( + self.userapiclient, + id=lb_rule.id, + applied="true" + ) + status = validateList(list_lbruleinstance_applied_false) + self.assertEquals( + PASS, + status[0], + "No Instances are available to assign to Load Balancer Rule" + ) + # Verifying the length of the list is 1 + self.assertEqual( + 1, + len(list_lbruleinstance_applied_false), + "No Instances are available to assign to Load Balancer Rule" + ) + # Verifying Instances is assigned to the Load Balancer Rule + self.assertEquals( + vm_created.id, + list_lbruleinstance_applied_true[0].id, + "Failed to assign Load Balancer Rule to given Instance" + ) + # Listing Load Balancer Rule Instances for applied as false + list_lbruleinstance_applied_false = LoadBalancerRule.listLoadBalancerRuleInstances( + self.userapiclient, + id=lb_rule.id, + applied="false" + ) + # Verifying No Load Balancer Rules Instances are available to assign + self.assertIsNone( + list_lbruleinstance_applied_false, + "Instances are available for assigning a Load Balancer Rule" + ) + # Removing Load balancer Rule from Instance + LoadBalancerRule.remove( + lb_rule, + self.userapiclient, + vms=[vm_created] + ) + # Listing Load Balancer Rule Instances for applied as true + list_lbruleinstance_applied_true = LoadBalancerRule.listLoadBalancerRuleInstances( + self.userapiclient, + id=lb_rule.id, + applied="true" + ) + # Verifying that there are no Instances assigned to the Load Balancer Rule + self.assertIsNone( + list_lbruleinstance_applied_true, + "Instances is assigned to Load balancer Rule" + ) + # Listing Load Balancer Rule Instances for applied as false + list_lbruleinstance_applied_false = LoadBalancerRule.listLoadBalancerRuleInstances( + self.userapiclient, + id=lb_rule.id, + applied="false" + ) + status = validateList(list_lbruleinstance_applied_false) + self.assertEquals( + PASS, + status[0], + "No Instances are available to assign to Load Balancer Rule" + ) + # Verifying the length of the list is 1 + self.assertEqual( + 1, + len(list_lbruleinstance_applied_false), + "No Instances are available to assign to Load Balancer Rule" + ) + # Verifying that Instance created above is listed + self.assertEquals( + vm_created.id, + list_lbruleinstance_applied_false[0].id, + "Failed to list Instance available to asign a Load Balancer Rule" + ) + # Destroying the VM Launched + vm_created.delete(self.userapiclient) + vm_created.expung(self.apiClient) + return + + @attr(tags=["advanced", "provisioning"]) + def test_08_list_create_delete_lbsticky_policy(self): + """ + @summary: Test to List, Create, Delete Load Balancer Stickyness Policy + @Steps: + Step1: Creating a Network for the user + Step2: Associating an IP Addresses for Network + Step3: Creating a Load Balancer Rule for IP Address associated in Step2 + Step4: Listing Load Balancer Sticky Policies for LB Rule created in Step3 + Step5: Verifying that no Load Balancer Sticky Policies are listed + Step6: Creating a Load Balancer Sticky Policies for LB Rule created in Step3 + Step7: Listing Load Balancer Sticky Policies for LB Rule created in Step3 + Step8: Verifying 1 Load Balancer Sticky Policy is listed + Step9: Deleting the Load Balancer Sticky Policies + Step10: Listing Load Balancer Sticky Policies for LB Rule created in Step3 + Step11: Verifying that no Load Balancer Sticky Policies are listed + """ + # Listing all the Networks's for a user + list_networks_before = Network.list( + self.userapiclient, + listall=self.services["listall"] + ) + # 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,Lb", + zoneid=self.zone.id + ) + status = validateList(network_offerings_list) + self.assertEquals( + PASS, + status[0], + "Isolated Network Offerings with sourceNat, Lb enabled are not found" + ) + # Creating a network + network = Network.create( + self.userapiclient, + self.services["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 again + list_networks_after = Network.list( + self.userapiclient, + listall=self.services["listall"] + ) + status = validateList(list_networks_after) + self.assertEquals( + PASS, + status[0], + "Network Creation Failed" + ) + # Verifying network list count is increased by 1 + self.assertEquals( + 1, + len(list_networks_after), + "Network Creation Failed" + ) + # Listing all the IP Addresses for a user + list_ipaddresses_before = PublicIPAddress.list( + self.userapiclient, + listall=self.services["listall"] + ) + # Verifying no IP Addresses are listed + self.assertIsNone( + list_ipaddresses_before, + "IP Addresses listed for newly created User" + ) + # Associating an IP Addresses to Network created + associated_ipaddress = PublicIPAddress.create( + self.userapiclient, + services=self.services["network"], + networkid=network.id + ) + self.assertIsNotNone( + associated_ipaddress, + "Failed to Associate IP Address" + ) + # Listing all the IP Addresses for a user + list_ipaddresses_after = PublicIPAddress.list( + self.userapiclient, + listall=self.services["listall"] + ) + status = validateList(list_ipaddresses_after) + self.assertEquals( + PASS, + status[0], + "IP Addresses Association Failed" + ) + # Verifying the length of the list is 1 + self.assertEqual( + 1, + len(list_ipaddresses_after), + "Number of IP Addresses associated are not matching expected" + ) + # Listing Load Balancer Rules for the Ip Address + list_lbrules_before = LoadBalancerRule.list( + self.userapiclient, + listall=self.services["listall"], + publicipid=associated_ipaddress.ipaddress.id + ) + # Verifying no Load Balancer Rules are listed + self.assertIsNone( + list_lbrules_before, + "Load Balancer Rules listed for newly Acquired Ip Address" + ) + self.services["lbrule"]["openfirewall"] = 'false' + # Creating a Load Balancer Rule for Ip Address + lb_rule = LoadBalancerRule.create( + self.userapiclient, + self.services["lbrule"], + ipaddressid=associated_ipaddress.ipaddress.id, + ) + self.assertIsNotNone( + lb_rule, + "Failed to create Load Balancer Rule" + ) + # Listing Load Balancer Rules for the Ip Address + list_lbrules_after = LoadBalancerRule.list( + self.userapiclient, + listall=self.services["listall"], + publicipid=associated_ipaddress.ipaddress.id + ) + status = validateList(list_lbrules_after) + self.assertEquals( + PASS, + status[0], + "Load Balancer Rule creation Failed" + ) + # Verifying the length of the list is 1 + self.assertEqual( + 1, + len(list_lbrules_after), + "Load Balancer Rule creation Failed" + ) + # Listing Load Balancer Stickyness Policies for LB Rule + list_lbstickypolicy_before = LoadBalancerRule.listStickyPolicies( + self.userapiclient, + lbruleid=lb_rule.id, + listall=self.services["listall"] + ) + # Verifying no Sticky Policies are listed + self.assertEquals( + 0, + len(list_lbstickypolicy_before[0].stickinesspolicy), + "Sticky Policy listed for newly created Load Balancer Rule" + ) + # Creating a Sticy Policy for Load Balancer Rule + sticky_policy = LoadBalancerRule.createSticky( + lb_rule, + self.userapiclient, + methodname='LbCookie', + name='LbCookieSticky' + ) + self.assertIsNotNone( + sticky_policy, + "Failed to create Sticky Policy for Load Balancer Rule" + ) +