| # 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 cloudstackTestCase | |
| import unittest | |
| from marvin.lib.base import (PublicIPAddress, | |
| NetworkOffering, | |
| Autoscale, | |
| Network, | |
| NetworkServiceProvider, | |
| Template, | |
| VirtualMachine, | |
| VPC, | |
| VpcOffering, | |
| StaticNATRule, | |
| FireWallRule, | |
| NATRule, | |
| Vpn, | |
| VpnUser, | |
| LoadBalancerRule, | |
| Account, | |
| ServiceOffering, | |
| PhysicalNetwork, | |
| User) | |
| from marvin.lib.common import (get_domain, | |
| get_zone, | |
| get_template) | |
| from marvin.lib.utils import validateList, cleanup_resources | |
| from marvin.codes import PASS | |
| from nose.plugins.attrib import attr | |
| 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() | |
| 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.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.hypervisor | |
| 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.vpc_offering = VpcOffering.create(cls.api_client, | |
| cls.services["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 = [] | |
| self.account = Account.create( | |
| self.apiClient, | |
| self.services["account"], | |
| domainid=self.domain.id | |
| ) | |
| # Getting authentication for user in newly created Account | |
| self.user = self.account.user[0] | |
| self.userapiclient = self.testClient.getUserApiClient( | |
| self.user.username, | |
| self.domain.name) | |
| 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 = 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", "dvs"], required_hardware="true") | |
| 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, | |
| type="Isolated" | |
| ) | |
| 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.assertEqual( | |
| 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, | |
| type="Isolated" | |
| ) | |
| status = validateList(networks_list_after) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Network Creation Failed" | |
| ) | |
| self.assertEqual( | |
| 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.assertEqual( | |
| 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.assertEqual( | |
| PASS, | |
| status[0], | |
| "Failed to list IP Addresses in page1" | |
| ) | |
| # Verifying that list size is equals to pagesize | |
| self.assertEqual( | |
| 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.assertEqual( | |
| PASS, | |
| status[0], | |
| "Failed to list IP Addresses in page2" | |
| ) | |
| # Verifying that List size is equal to 1 | |
| self.assertEqual( | |
| 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" | |
| ) | |
| self.cleanup.append(self.account) | |
| return | |
| @attr(tags=["advanced"], required_hardware="true") | |
| 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, | |
| type="Isolated" | |
| ) | |
| 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.assertEqual( | |
| 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, | |
| type="Isolated" | |
| ) | |
| status = validateList(networks_list_after) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Network Creation Failed" | |
| ) | |
| self.assertEqual( | |
| 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.assertEqual( | |
| PASS, | |
| status[0], | |
| "Failed to list Network by Id" | |
| ) | |
| self.assertEqual( | |
| 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.assertEqual( | |
| 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.assertEqual( | |
| PASS, | |
| status[0], | |
| "Failed to list IP Addresses by ID" | |
| ) | |
| # Verifying that list size is equals to 1 | |
| self.assertEqual( | |
| 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" | |
| ) | |
| self.cleanup.append(self.account) | |
| return | |
| @attr(tags=["advanced"], required_hardware="true") | |
| 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 | |
| """ | |
| if self.hypervisor.lower() in ['hyperv']: | |
| self.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's Listed for newly Created User" | |
| ) | |
| # Creating a vpc | |
| vpc_created = VPC.create( | |
| self.userapiclient, | |
| self.services["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 IP Addresses for a user | |
| list_ipaddresses_before = PublicIPAddress.list( | |
| self.userapiclient, | |
| listall=self.services["listall"] | |
| ) | |
| status = validateList(list_ipaddresses_before) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Failed to List VPC IP Address" | |
| ) | |
| self.assertEqual( | |
| 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.assertEqual( | |
| 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.assertEqual( | |
| PASS, | |
| status[0], | |
| "Failed to list IP Addresses by ID" | |
| ) | |
| # Verifying that list size is equals to 1 | |
| self.assertEqual( | |
| 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" | |
| ) | |
| self.cleanup.append(self.account) | |
| return | |
| @attr(tags=["advanced"], required_hardware="true") | |
| 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"], | |
| 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,Lb", | |
| zoneid=self.zone.id | |
| ) | |
| status = validateList(network_offerings_list) | |
| self.assertEqual( | |
| 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.assertEqual( | |
| 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.assertEqual( | |
| 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" | |
| ) | |
| self.cleanup.append(self.account) | |
| return | |
| @attr(tags=["advanced"], required_hardware="true") | |
| 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 | |
| """ | |
| if self.hypervisor.lower() in ['hyperv']: | |
| self.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's Listed for newly Created User" | |
| ) | |
| # Creating a vpc | |
| vpc_created = VPC.create( | |
| self.userapiclient, | |
| self.services["vpc"], | |
| self.vpc_offering.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.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 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.assertEqual( | |
| 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.assertEqual( | |
| PASS, | |
| status[0], | |
| "list IP Addresses not as expected" | |
| ) | |
| # Verifying the list vpc size is increased by 1 | |
| self.assertEqual( | |
| 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.assertEqual( | |
| 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.assertEqual( | |
| 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" | |
| ) | |
| self.cleanup.append(self.account) | |
| return | |
| @attr(tags=["advanced"], required_hardware="true") | |
| 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"], | |
| 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,Lb", | |
| zoneid=self.zone.id | |
| ) | |
| status = validateList(network_offerings_list) | |
| self.assertEqual( | |
| 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"], | |
| 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 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.assertEqual( | |
| 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.assertEqual( | |
| 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" | |
| ) | |
| self.cleanup.append(self.account) | |
| return | |
| @attr(tags=["advanced"], required_hardware="true") | |
| 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"], | |
| 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,Lb", | |
| zoneid=self.zone.id | |
| ) | |
| status = validateList(network_offerings_list) | |
| self.assertEqual( | |
| 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.assertEqual( | |
| 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.assertEqual( | |
| 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.assertEqual( | |
| 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.assertEqual( | |
| 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.assertEqual( | |
| 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.assertEqual( | |
| vm_created.id, | |
| list_lbruleinstance_applied_false[0].id, | |
| "Failed to list Instance available to assign 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.assertEqual( | |
| 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.assertEqual( | |
| 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.assertEqual( | |
| 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.assertEqual( | |
| vm_created.id, | |
| list_lbruleinstance_applied_false[0].id, | |
| "Failed to list Instance available to assign a Load Balancer Rule" | |
| ) | |
| # Destroying the VM Launched | |
| vm_created.delete(self.apiClient) | |
| self.cleanup.append(self.account) | |
| return | |
| @attr(tags=["advanced"], required_hardware="true") | |
| 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"], | |
| 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,Lb", | |
| zoneid=self.zone.id | |
| ) | |
| status = validateList(network_offerings_list) | |
| self.assertEqual( | |
| 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"], | |
| 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 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.assertEqual( | |
| 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.assertEqual( | |
| 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.assertEqual( | |
| 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" | |
| ) | |
| # Verifying details of Sticky Policy created | |
| # Creating expected and actual values dictionaries | |
| expected_dict = { | |
| "account": self.account.name, | |
| "domainid": self.domain.id, | |
| "lbruleid": lb_rule.id, | |
| "methodname": "LbCookie", | |
| "name": "LbCookieSticky", | |
| } | |
| actual_dict = { | |
| "account": sticky_policy.account, | |
| "domainid": sticky_policy.domainid, | |
| "lbruleid": sticky_policy.lbruleid, | |
| "methodname": sticky_policy.stickinesspolicy[0].methodname, | |
| "name": sticky_policy.stickinesspolicy[0].name, | |
| } | |
| lbstickypolicy_status = self.__verify_values( | |
| expected_dict, | |
| actual_dict | |
| ) | |
| self.assertEqual( | |
| True, | |
| lbstickypolicy_status, | |
| "Created Load Balancer Sticky Policy details are not as expected" | |
| ) | |
| # Listing Load Balancer Stickyness Policies for LB Rule | |
| list_lbstickypolicy_after = LoadBalancerRule.listStickyPolicies( | |
| self.userapiclient, | |
| lbruleid=lb_rule.id, | |
| listall=self.services["listall"] | |
| ) | |
| status = validateList(list_lbstickypolicy_after[0].stickinesspolicy) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Load Balancer Sticky Policy creation Failed" | |
| ) | |
| # Verifying the length of the list is 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_lbstickypolicy_after[0].stickinesspolicy), | |
| "Load Balancer Sticky Policy creation Failed" | |
| ) | |
| # Deleting the Sticky Policy | |
| LoadBalancerRule.deleteSticky( | |
| lb_rule, | |
| self.userapiclient, | |
| id=sticky_policy.stickinesspolicy[0].id | |
| ) | |
| # Listing Load Balancer Stickyness Policies for LB Rule | |
| list_lbstickypolicy_after = LoadBalancerRule.listStickyPolicies( | |
| self.userapiclient, | |
| lbruleid=lb_rule.id, | |
| listall=self.services["listall"] | |
| ) | |
| # Verifying no Sticky Policies are listed | |
| self.assertEqual( | |
| 0, | |
| len(list_lbstickypolicy_after[0].stickinesspolicy), | |
| "Sticky Policy listed for newly created Load Balancer Rule" | |
| ) | |
| self.cleanup.append(self.account) | |
| return | |
| @attr(tags=["advanced"], required_hardware="true") | |
| def test_09_create_delete_portforwarding_fornonvpc(self): | |
| """ | |
| @summary: Test to list, create and delete Port Forwarding for | |
| IP Address associated to Non VPC network | |
| @Steps: | |
| Step1: Creating a Network for the user | |
| Step2: Associating an IP Addresses for Network | |
| Step3: Launching Virtual Machine in network created in step 2 | |
| Step4: Listing Port Forwarding Rules for the IP Address associated | |
| in Step2 | |
| Step5: Verifying that no Port Forwarding Rules are listed | |
| Step6: Creating a Port Forwarding Rule for IP Address associated in | |
| Step2 | |
| Step7: Listing Port Forwarding Rules for the IP Address associated in | |
| Step2 | |
| Step8: Verifying 1 Port Forwarding Rule is listed | |
| Step9: Deleting the Port Forwarding Rule created in Step6 | |
| Step10: Listing Port Forwarding Rules for the IP Address associated in | |
| Step2 | |
| Step11: Verifying that no Port Forwarding Rules are listed | |
| """ | |
| # Listing all the Networks's for a user | |
| list_networks_before = Network.list( | |
| self.userapiclient, | |
| listall=self.services["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,PortForwarding", | |
| zoneid=self.zone.id | |
| ) | |
| status = validateList(network_offerings_list) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Isolated Network Offerings with sourceNat,\ | |
| PortForwarding 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.assertEqual( | |
| 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 above created network | |
| list_vms_running = VirtualMachine.list( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| state="Running", | |
| networkid=network.id | |
| ) | |
| status = validateList(list_vms_running) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "VM Created is not in Running state" | |
| ) | |
| # Verifying the length of the list is 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_ipaddresses_after), | |
| "VM Created is not in Running state" | |
| ) | |
| self.assertEqual( | |
| vm_created.id, | |
| list_vms_running[0].id, | |
| "VM Created is not in Running state" | |
| ) | |
| # Listing Virtual Machines in stopped state in above created network | |
| list_vms_stopped = VirtualMachine.list( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| state="Stopped", | |
| networkid=network.id | |
| ) | |
| # Verifying no VMs are in stopped state | |
| self.assertIsNone( | |
| list_vms_stopped, | |
| "VM Created is in stopped state" | |
| ) | |
| # Listing Port Forwarding Rules for the IP Address associated | |
| list_prtfwdrule_before = NATRule.list( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| ipaddressid=associated_ipaddress.ipaddress.id | |
| ) | |
| # Verifying no port forwarding rules are listed | |
| self.assertIsNone( | |
| list_prtfwdrule_before, | |
| "Port Forwarding Rules listed for newly associated IP Address" | |
| ) | |
| # Creating a Port Forwarding rule | |
| portfwd_rule = NATRule.create( | |
| self.userapiclient, | |
| virtual_machine=vm_created, | |
| services=self.services["natrule"], | |
| ipaddressid=associated_ipaddress.ipaddress.id, | |
| ) | |
| self.assertIsNotNone( | |
| portfwd_rule, | |
| "Failed to create Port Forwarding Rule" | |
| ) | |
| # Verifying details of Sticky Policy created | |
| # Creating expected and actual values dictionaries | |
| expected_dict = { | |
| "ipaddressid": associated_ipaddress.ipaddress.id, | |
| "privateport": str(self.services["natrule"]["privateport"]), | |
| "publicport": str(self.services["natrule"]["publicport"]), | |
| "protocol": str(self.services["natrule"]["protocol"]).lower(), | |
| } | |
| actual_dict = { | |
| "ipaddressid": portfwd_rule.ipaddressid, | |
| "privateport": str(portfwd_rule.privateport), | |
| "publicport": str(portfwd_rule.publicport), | |
| "protocol": portfwd_rule.protocol, | |
| } | |
| portfwd_status = self.__verify_values( | |
| expected_dict, | |
| actual_dict | |
| ) | |
| self.assertEqual( | |
| True, | |
| portfwd_status, | |
| "Created Port Forward Rule details are not as expected" | |
| ) | |
| # Listing Port Forwarding Rules for the IP Address associated | |
| list_prtfwdrule_after = NATRule.list( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| ipaddressid=associated_ipaddress.ipaddress.id | |
| ) | |
| status = validateList(list_prtfwdrule_after) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Failed to create Port Forwarding Rule" | |
| ) | |
| # Verifying the length of the list is 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_prtfwdrule_after), | |
| "Failed to create Port Forwarding Rule" | |
| ) | |
| # Deleting Port Forwarding Rule | |
| portfwd_rule.delete(self.userapiclient) | |
| # Listing Port Forwarding Rules for the IP Address associated | |
| list_prtfwdrule_after = NATRule.list( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| ipaddressid=associated_ipaddress.ipaddress.id | |
| ) | |
| # Verifying no port forwarding rules are listed | |
| self.assertIsNone( | |
| list_prtfwdrule_after, | |
| "Port Forwarding Rules listed after deletion" | |
| ) | |
| # Destroying the VM Launched | |
| vm_created.delete(self.apiClient) | |
| self.cleanup.append(self.account) | |
| return | |
| @attr(tags=["advanced"], required_hardware="true") | |
| def test_10_create_delete_portforwarding_forvpc(self): | |
| """ | |
| @summary: Test to list, create and delete Port Forwarding 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: Launching a VM in the Network created in Step 2 | |
| Step5: Listing Port Forwarding Rules for the IP Address | |
| associated in Step3 | |
| Step6: Verifying that no Port Forwarding Rules are listed | |
| Step7: Creating a Port Forwarding Rule for IP Address associated | |
| in Step3 | |
| Step8: Listing Port Forwarding Rules for the IP Address | |
| associated in Step3 | |
| Step9: Verifying 1 Port Forwarding Rule is listed | |
| Step10: Deleting the Port Forwarding Rule created in Step7 | |
| Step11: Listing Port Forwarding Rules for the IP Address | |
| associated in Step3 | |
| Step12: Verifying that no Port Forwarding Rules 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's Listed for newly Created User" | |
| ) | |
| # Creating a vpc | |
| vpc_created = VPC.create( | |
| self.userapiclient, | |
| self.services["vpc"], | |
| self.vpc_offering.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.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 network offering for vpc = true | |
| network_offering_vpc_true_list = NetworkOffering.list( | |
| self.userapiclient, | |
| forvpc="true", | |
| zoneid=self.zone.id, | |
| supportedServices="SourceNat,PortForwarding", | |
| state="Enabled" | |
| ) | |
| status = validateList(network_offering_vpc_true_list) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Default network offering not present for\ | |
| vpc = true with PortForwarding") | |
| # 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.assertIsNotNone( | |
| network_created, | |
| "Network is not 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.assertEqual( | |
| PASS, | |
| status[0], | |
| "list IP Addresses not as expected" | |
| ) | |
| # Verifying the list vpc size is increased by 1 | |
| self.assertEqual( | |
| 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.assertEqual( | |
| 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" | |
| ) | |
| # 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_created.id, | |
| serviceofferingid=self.service_offering.id, | |
| ) | |
| self.assertIsNotNone( | |
| vm_created, | |
| "Failed to launch a VM under network created" | |
| ) | |
| self.cleanup.append(network_created) | |
| self.cleanup.append(vpc_created) | |
| # Listing Port Forwarding Rules for the IP Address associated | |
| list_prtfwdrule_before = NATRule.list( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| ipaddressid=associated_ipaddress.ipaddress.id | |
| ) | |
| # Verifying no port forwarding rules are listed | |
| self.assertIsNone( | |
| list_prtfwdrule_before, | |
| "Port Forwarding Rules listed for newly associated IP Address" | |
| ) | |
| # Creating a Port Forwarding rule | |
| portfwd_rule = NATRule.create( | |
| self.userapiclient, | |
| virtual_machine=vm_created, | |
| services=self.services["natrule"], | |
| ipaddressid=associated_ipaddress.ipaddress.id, | |
| networkid=network_created.id | |
| ) | |
| self.assertIsNotNone( | |
| portfwd_rule, | |
| "Failed to create Port Forwarding Rule" | |
| ) | |
| # Verifying details of Sticky Policy created | |
| # Creating expected and actual values dictionaries | |
| expected_dict = { | |
| "ipaddressid": associated_ipaddress.ipaddress.id, | |
| "privateport": str(self.services["natrule"]["privateport"]), | |
| "publicport": str(self.services["natrule"]["publicport"]), | |
| "protocol": str(self.services["natrule"]["protocol"]).lower(), | |
| } | |
| actual_dict = { | |
| "ipaddressid": portfwd_rule.ipaddressid, | |
| "privateport": str(portfwd_rule.privateport), | |
| "publicport": str(portfwd_rule.publicport), | |
| "protocol": portfwd_rule.protocol, | |
| } | |
| portfwd_status = self.__verify_values( | |
| expected_dict, | |
| actual_dict | |
| ) | |
| self.assertEqual( | |
| True, | |
| portfwd_status, | |
| "Created Port Forward Rule details are not as expected" | |
| ) | |
| # Listing Port Forwarding Rules for the IP Address associated | |
| list_prtfwdrule_after = NATRule.list( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| ipaddressid=associated_ipaddress.ipaddress.id | |
| ) | |
| status = validateList(list_prtfwdrule_after) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Failed to create Port Forwarding Rule" | |
| ) | |
| # Verifying the length of the list is 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_prtfwdrule_after), | |
| "Failed to create Port Forwarding Rule" | |
| ) | |
| # Deleting Port Forwarding Rule | |
| portfwd_rule.delete(self.userapiclient) | |
| # Listing Port Forwarding Rules for the IP Address associated | |
| list_prtfwdrule_after = NATRule.list( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| ipaddressid=associated_ipaddress.ipaddress.id | |
| ) | |
| # Verifying no port forwarding rules are listed | |
| self.assertIsNone( | |
| list_prtfwdrule_after, | |
| "Port Forwarding Rules listed after deletion" | |
| ) | |
| # Destroying the VM Launched | |
| vm_created.delete(self.apiClient) | |
| self.cleanup.append(self.account) | |
| return | |
| @attr(tags=["advanced"], required_hardware="true") | |
| def test_11_create_delete_firewallrule(self): | |
| """ | |
| @summary: Test to list, create and delete Firewall 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 Firewall Rules for the IP Address associated in Step2 | |
| Step4: Verifying that no Rules are listed | |
| Step5: Creating a Firewall Rule for IP Address associated in Step2 | |
| Step6: Listing Firewall Rules for the IP Address associated in Step2 | |
| Step7: Verifying 1 Firewall Rule is listed | |
| Step8: Deleting the Firewall Rule created in Step5 | |
| Step9: Listing Firewall Rules for the IP Address associated in Step2 | |
| Step10: Verifying that no Firewall Rules are listed | |
| """ | |
| # Listing all the Networks's for a user | |
| list_networks_before = Network.list( | |
| self.userapiclient, | |
| listall=self.services["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,Firewall", | |
| zoneid=self.zone.id | |
| ) | |
| status = validateList(network_offerings_list) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Isolated Network Offerings with sourceNat,\ | |
| Firewall 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.assertEqual( | |
| 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 Firewall rules for the IP Associated | |
| list_firewalls_before = FireWallRule.list( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| ipaddressid=associated_ipaddress.ipaddress.id | |
| ) | |
| # Verifying no firewall rules are listed | |
| self.assertIsNone( | |
| list_firewalls_before, | |
| "Firewall Rules listed for newly associated IP Address" | |
| ) | |
| # Creating a Firewall Rule | |
| firewall_rule = FireWallRule.create( | |
| self.userapiclient, | |
| ipaddressid=associated_ipaddress.ipaddress.id, | |
| protocol='tcp', | |
| cidrlist='10.1.1.1/16', | |
| startport='22', | |
| endport='2222' | |
| ) | |
| self.assertIsNotNone( | |
| firewall_rule, | |
| "Failed to create Firewall Rule" | |
| ) | |
| # Verifying details of the created Firewall Rule | |
| # Creating expected and actual values dictionaries | |
| expected_dict = { | |
| "ipaddressid": associated_ipaddress.ipaddress.id, | |
| "startport": 22, | |
| "endport": 2222, | |
| "protocol": "tcp", | |
| "cidrlist": "10.1.1.1/16" | |
| } | |
| actual_dict = { | |
| "ipaddressid": firewall_rule.ipaddressid, | |
| "startport": firewall_rule.startport, | |
| "endport": firewall_rule.endport, | |
| "protocol": firewall_rule.protocol, | |
| "cidrlist": firewall_rule.cidrlist | |
| } | |
| firewall_status = self.__verify_values( | |
| expected_dict, | |
| actual_dict | |
| ) | |
| self.assertEqual( | |
| True, | |
| firewall_status, | |
| "Created Firewall Rule details are not as expected" | |
| ) | |
| # Listing Firewall rules for the IP Associated | |
| list_firewalls_after = FireWallRule.list( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| ipaddressid=associated_ipaddress.ipaddress.id | |
| ) | |
| status = validateList(list_firewalls_after) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Failed to create Firewall Rule" | |
| ) | |
| # Verifying the length of the list is 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_firewalls_after), | |
| "Failed to create Firewall Rule" | |
| ) | |
| # Deleting the Firewall Rule | |
| firewall_rule.delete(self.userapiclient) | |
| # Listing Firewall rules for the IP Associated | |
| list_firewalls_after = FireWallRule.list( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| ipaddressid=associated_ipaddress.ipaddress.id | |
| ) | |
| # Verifying no firewall rules are listed | |
| self.assertIsNone( | |
| list_firewalls_after, | |
| "Failed to create Firewall Rule" | |
| ) | |
| self.cleanup.append(self.account) | |
| return | |
| @attr(tags=["advanced"], required_hardware="true") | |
| def test_12_create_delete_remoteaccessvpn(self): | |
| """ | |
| @summary: Test to list, create and delete Remote Access VPNs | |
| @Steps: | |
| Step1: Creating a Network for the user | |
| Step2: Associating an IP Addresses for Network | |
| Step3: Listing Remore Access VPNs for the IP Address associated | |
| in Step2 | |
| Step4: Verifying that no Remore Access VPNs are listed | |
| Step5: Creating a Remore Access VPN for IP Address associated | |
| in Step2 | |
| Step6: Listing Remore Access VPNs for the IP Address associated in | |
| Step2 | |
| Step7: Verifying 1 Remore Access VPN is listed | |
| Step8: Deleting the Remore Access VPNs created in Step5 | |
| Step9: Listing Remore Access VPNs for the IP Address associated i | |
| Step2 | |
| Step10: Verifying that no Remore Access VPNs are listed | |
| """ | |
| # Listing all the Networks's for a user | |
| list_networks_before = Network.list( | |
| self.userapiclient, | |
| listall=self.services["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,Vpn", | |
| zoneid=self.zone.id | |
| ) | |
| status = validateList(network_offerings_list) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Isolated Network Offerings with sourceNat,\ | |
| Vpn 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.assertEqual( | |
| 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 Remote access VPNs for the IP Associated | |
| list_vpns_before = Vpn.list( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| ipaddressid=associated_ipaddress.ipaddress.id | |
| ) | |
| # Verifying no Remote Access VPNs are listed | |
| self.assertIsNone( | |
| list_vpns_before, | |
| "Remote Access VPNs listed for newly associated IP Address" | |
| ) | |
| # Creating a Remote Access VPN | |
| vpn_created = Vpn.create( | |
| self.userapiclient, | |
| publicipid=associated_ipaddress.ipaddress.id, | |
| account=self.account.name, | |
| domainid=self.domain.id, | |
| openfirewall='false' | |
| ) | |
| self.assertIsNotNone( | |
| vpn_created, | |
| "Failed to create Remote Access VPN" | |
| ) | |
| # Verifying details of the created Remote Access VPN | |
| # Creating expected and actual values dictionaries | |
| expected_dict = { | |
| "ipaddressid": associated_ipaddress.ipaddress.id, | |
| "account": self.account.name, | |
| "domainid": self.domain.id, | |
| "state": "Running", | |
| } | |
| actual_dict = { | |
| "ipaddressid": vpn_created.publicipid, | |
| "account": vpn_created.account, | |
| "domainid": vpn_created.domainid, | |
| "state": vpn_created.state, | |
| } | |
| vpn_status = self.__verify_values( | |
| expected_dict, | |
| actual_dict | |
| ) | |
| self.assertEqual( | |
| True, | |
| vpn_status, | |
| "Created Remote Access VPN details are not as expected" | |
| ) | |
| # Listing Remote Access VPNs for the IP Associated | |
| list_vpns_after = Vpn.list( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| ipaddressid=associated_ipaddress.ipaddress.id | |
| ) | |
| status = validateList(list_vpns_after) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Failed to create Remote Access VPN" | |
| ) | |
| # Verifying the length of the list is 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_vpns_after), | |
| "Failed to create Remote Access VPN" | |
| ) | |
| # Deleting the Remote Access VPN | |
| vpn_created.delete(self.userapiclient) | |
| # Listing Remote Access VPNs for the IP Associated | |
| list_vpns_after = Vpn.list( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| ipaddressid=associated_ipaddress.ipaddress.id | |
| ) | |
| # Verifying no Remote Access VPNs are listed | |
| self.assertIsNone( | |
| list_vpns_after, | |
| "Failed to create Remote Access VPN" | |
| ) | |
| self.cleanup.append(self.account) | |
| return | |
| @attr(tags=["advanced"], required_hardware="true") | |
| def test_13_add_remove_vpnusers(self): | |
| """ | |
| @summary: Test to list, add and remove VPN Users | |
| @Steps: | |
| Step1: Creating a Network for the user | |
| Step2: Associating an IP Addresses for Network | |
| Step3: Launching a VM under network created in Step1 | |
| Step4: Creating Remote Access VPN | |
| Step5: Listing VPN Users | |
| Step6: Verifying that no VPN Users are listed | |
| Step7: Adding a VPN user | |
| Step8: Listing VPN Users | |
| Step9: Verifying 1 VPN is listed | |
| Step10: Deleting VPN user | |
| Step11: Listing VPN Users | |
| Step12: Verifying that no VPN Users are listed | |
| """ | |
| # Listing all the Networks's for a user | |
| list_networks_before = Network.list( | |
| self.userapiclient, | |
| listall=self.services["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,Vpn", | |
| zoneid=self.zone.id | |
| ) | |
| status = validateList(network_offerings_list) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Isolated Network Offerings with sourceNat,\ | |
| Vpn 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.assertEqual( | |
| 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 Virtual Machine | |
| 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" | |
| ) | |
| # Listing Remote access VPNs for the IP Associated | |
| list_vpns_before = Vpn.list( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| ipaddressid=associated_ipaddress.ipaddress.id | |
| ) | |
| # Verifying no Remote Access VPNs are listed | |
| self.assertIsNone( | |
| list_vpns_before, | |
| "Remote Access VPNs listed for newly associated IP Address" | |
| ) | |
| # Creating a Remote Access VPN | |
| vpn_created = Vpn.create( | |
| self.userapiclient, | |
| publicipid=associated_ipaddress.ipaddress.id, | |
| account=self.account.name, | |
| domainid=self.domain.id, | |
| openfirewall='false' | |
| ) | |
| self.assertIsNotNone( | |
| vpn_created, | |
| "Failed to create Remote Access VPN" | |
| ) | |
| # Listing Remote Access VPNs for the IP Associated | |
| list_vpns_after = Vpn.list( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| ipaddressid=associated_ipaddress.ipaddress.id | |
| ) | |
| status = validateList(list_vpns_after) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Failed to create Remote Access VPN" | |
| ) | |
| # Verifying the length of the list is 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_vpns_after), | |
| "Failed to create Remote Access VPN" | |
| ) | |
| # Listing VPN Users | |
| list_vpnusers_beore = VpnUser.list( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| account=self.account.name, | |
| domainid=self.domain.id | |
| ) | |
| # Verifying no VPN Users listed | |
| self.assertIsNone( | |
| list_vpnusers_beore, | |
| "VPN Users listed for newly created VPN" | |
| ) | |
| # Creating a VPN User | |
| vpnuser_created = VpnUser.create( | |
| self.userapiclient, | |
| username=self.services["vpn_user"]["username"], | |
| password=self.services["vpn_user"]["password"], | |
| account=self.account.name, | |
| domainid=self.domain.id | |
| ) | |
| self.assertIsNotNone( | |
| vpnuser_created, | |
| "Failed to create VPN User" | |
| ) | |
| # Listing VPN Users | |
| list_vpnusers_after = VpnUser.list( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| account=self.account.name, | |
| domainid=self.domain.id | |
| ) | |
| status = validateList(list_vpnusers_after) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Failed to list VPN user after creation" | |
| ) | |
| # Verifying the length of the list is 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_vpnusers_after), | |
| "Failed to list VPN user after creation" | |
| ) | |
| # Deleting the VPN User | |
| vpnuser_created.delete(self.userapiclient) | |
| # Listing VPN Users | |
| list_vpnusers_after = VpnUser.list( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| account=self.account.name, | |
| domainid=self.domain.id | |
| ) | |
| # Verifying no VPN Users are listed | |
| self.assertIsNone( | |
| list_vpnusers_after, | |
| "VPN User listed after deletion" | |
| ) | |
| # Destroying the VM | |
| vm_created.delete(self.apiClient) | |
| self.cleanup.append(self.account) | |
| return | |
| @attr(tags=["advanced"], required_hardware="true") | |
| def test_14_enable_disable_staticnat_fornonvpc(self): | |
| """ | |
| @summary: Test to Enable and Disable StaticNat for | |
| IP Address associated to Non VPC Network | |
| @Steps: | |
| Step1: Creating a Network for the user | |
| Step2: Associating an IP Addresses for Network created in step1 | |
| Step3: Associating one more Ip Address to Network created in step1 | |
| Step4: Launching the VM in network created in step1 | |
| Step5: Enabling the staticNat to IP Associated in Step3 | |
| Step6: Verifying that StaticNat is enabled | |
| Step7: Disabling the staticNat to IP Associated in Step3 | |
| Step8: Verifying that StaticNat is disabled | |
| """ | |
| # Listing all the Networks's for a user | |
| list_networks_before = Network.list( | |
| self.userapiclient, | |
| listall=self.services["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,StaticNat", | |
| zoneid=self.zone.id | |
| ) | |
| status = validateList(network_offerings_list) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Isolated Network Offerings with sourceNat,\ | |
| Vpn 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_ipaddress1 = PublicIPAddress.create( | |
| self.userapiclient, | |
| services=self.services["network"], | |
| networkid=network.id | |
| ) | |
| self.assertIsNotNone( | |
| associated_ipaddress1, | |
| "Failed to Associate IP Address" | |
| ) | |
| # Associating another IP Addresses to Network created | |
| associated_ipaddress2 = PublicIPAddress.create( | |
| self.userapiclient, | |
| services=self.services["network"], | |
| networkid=network.id | |
| ) | |
| self.assertIsNotNone( | |
| associated_ipaddress2, | |
| "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.assertEqual( | |
| PASS, | |
| status[0], | |
| "IP Addresses Association Failed" | |
| ) | |
| # Verifying the length of the list is 1 | |
| self.assertEqual( | |
| 2, | |
| len(list_ipaddresses_after), | |
| "Number of IP Addresses associated are not matching expected" | |
| ) | |
| # Launching a Virtual Machine | |
| 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" | |
| ) | |
| # Enabling static Nat for Ip Address associated | |
| StaticNATRule.enable( | |
| self.userapiclient, | |
| ipaddressid=associated_ipaddress2.ipaddress.id, | |
| virtualmachineid=vm_created.id, | |
| ) | |
| # Listing Ip Address by id | |
| list_ipaddress = PublicIPAddress.list( | |
| self.userapiclient, | |
| id=associated_ipaddress2.ipaddress.id, | |
| listall=self.services["listall"] | |
| ) | |
| status = validateList(list_ipaddress) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Failed to List IP Address" | |
| ) | |
| # Verifying the length of the list is 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_ipaddress), | |
| "Failed to List IP Address" | |
| ) | |
| self.assertEqual( | |
| True, | |
| list_ipaddress[0].isstaticnat, | |
| "Failed to Enable Static Nat" | |
| ) | |
| # Disabling static Nat | |
| StaticNATRule.disable( | |
| self.userapiclient, | |
| ipaddressid=associated_ipaddress2.ipaddress.id | |
| ) | |
| # Listing Ip Address by id | |
| list_ipaddress = PublicIPAddress.list( | |
| self.userapiclient, | |
| id=associated_ipaddress2.ipaddress.id, | |
| listall=self.services["listall"] | |
| ) | |
| status = validateList(list_ipaddress) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Failed to List IP Address" | |
| ) | |
| # Verifying the length of the list is 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_ipaddress), | |
| "Failed to List IP Address" | |
| ) | |
| self.assertEqual( | |
| False, | |
| list_ipaddress[0].isstaticnat, | |
| "Failed to Disable Static Nat" | |
| ) | |
| # Destroying the VM | |
| vm_created.delete(self.apiClient) | |
| self.cleanup.append(self.account) | |
| return | |
| @attr(tags=["advanced"], required_hardware="true") | |
| def test_15_enable_disable_staticnat_forvpc(self): | |
| """ | |
| @summary: Test to Enable and Disable StaticNat for | |
| IP Address associated to VPC Network | |
| @Steps: | |
| Step1: Creating a VPC | |
| Step2: Creating a Network under VPC for the user | |
| Step3: Associating an IP Addresses for Network created in step1 | |
| Step4: Launching the VM in network created in step2 | |
| Step5: Enabling the staticNat to IP Associated in Step3 | |
| Step6: Verifying that StaticNat is enabled | |
| Step7: Disabling the staticNat to IP Associated in Step3 | |
| Step8: Verifying that StaticNat is disabled | |
| """ | |
| if self.hypervisor.lower() in ['hyperv']: | |
| self.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's Listed for newly Created User" | |
| ) | |
| # Creating a vpc | |
| vpc_created = VPC.create( | |
| self.userapiclient, | |
| self.services["vpc"], | |
| self.vpc_offering.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.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 network offering for vpc = true | |
| network_offering_vpc_true_list = NetworkOffering.list( | |
| self.userapiclient, | |
| forvpc="true", | |
| zoneid=self.zone.id, | |
| supportedServices="SourceNat,PortForwarding,StaticNat", | |
| state="Enabled" | |
| ) | |
| status = validateList(network_offering_vpc_true_list) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Default network offering not present\ | |
| for vpc = true with PortForwarding") | |
| # 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.assertIsNotNone( | |
| network_created, | |
| "Network is not 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.assertEqual( | |
| PASS, | |
| status[0], | |
| "list IP Addresses not as expected" | |
| ) | |
| # Verifying the list vpc size is increased by 1 | |
| self.assertEqual( | |
| 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.assertEqual( | |
| 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" | |
| ) | |
| # 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_created.id, | |
| serviceofferingid=self.service_offering.id, | |
| ) | |
| self.assertIsNotNone( | |
| vm_created, | |
| "Failed to launch a VM under network created" | |
| ) | |
| self.cleanup.append(network_created) | |
| self.cleanup.append(vpc_created) | |
| # Enabling static Nat for Ip Address associated | |
| StaticNATRule.enable( | |
| self.userapiclient, | |
| ipaddressid=associated_ipaddress.ipaddress.id, | |
| virtualmachineid=vm_created.id, | |
| networkid=network_created.id | |
| ) | |
| # Listing Ip Address by id | |
| list_ipaddress = PublicIPAddress.list( | |
| self.userapiclient, | |
| id=associated_ipaddress.ipaddress.id, | |
| listall=self.services["listall"] | |
| ) | |
| status = validateList(list_ipaddress) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Failed to List IP Address" | |
| ) | |
| # Verifying the length of the list is 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_ipaddress), | |
| "Failed to List IP Address" | |
| ) | |
| self.assertEqual( | |
| True, | |
| list_ipaddress[0].isstaticnat, | |
| "Failed to Enable Static Nat" | |
| ) | |
| # Disabling static Nat | |
| StaticNATRule.disable( | |
| self.userapiclient, | |
| ipaddressid=associated_ipaddress.ipaddress.id | |
| ) | |
| # Listing Ip Address by id | |
| list_ipaddress = PublicIPAddress.list( | |
| self.userapiclient, | |
| id=associated_ipaddress.ipaddress.id, | |
| listall=self.services["listall"] | |
| ) | |
| status = validateList(list_ipaddress) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Failed to List IP Address" | |
| ) | |
| # Verifying the length of the list is 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_ipaddress), | |
| "Failed to List IP Address" | |
| ) | |
| self.assertEqual( | |
| False, | |
| list_ipaddress[0].isstaticnat, | |
| "Failed to Disable Static Nat" | |
| ) | |
| # Destroying the VM | |
| vm_created.delete(self.apiClient) | |
| self.cleanup.append(self.account) | |
| return | |
| @attr(tags=["advanced"], required_hardware="true") | |
| def test_16_create_delete_ipforwardingrule(self): | |
| """ | |
| @summary: Test to list, create and | |
| delete IP Forwarding Rules for IP Address | |
| @Steps: | |
| Step1: Creating a Network for the user | |
| Step2: Associating an IP Addresses for Network created in step1 | |
| Step3: Associating one more Ip Address to Network created in step1 | |
| Step4: Launching the VM in network created in step1 | |
| Step5: Enabling the staticNat to IP Associated in Step3 | |
| Step6: Listing IP Forwarding rules | |
| Step7: Verifying no IP Forwarding rules are listed | |
| Step8: Creating a IP Forwarding Rule | |
| Step9: Listing IP Forwarding rules | |
| Step10: Verifying 1 IP Forwarding rule is listed | |
| Step11: Deleting the IP Forwarding rule | |
| Step12: Listing IP Forwarding rules | |
| Step13: Verifying no IP Forwarding rules are listed | |
| """ | |
| # Listing all the Networks's for a user | |
| list_networks_before = Network.list( | |
| self.userapiclient, | |
| listall=self.services["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,Vpn", | |
| zoneid=self.zone.id | |
| ) | |
| status = validateList(network_offerings_list) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Isolated Network Offerings with sourceNat,\ | |
| Vpn 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_ipaddress1 = PublicIPAddress.create( | |
| self.userapiclient, | |
| services=self.services["network"], | |
| networkid=network.id | |
| ) | |
| self.assertIsNotNone( | |
| associated_ipaddress1, | |
| "Failed to Associate IP Address" | |
| ) | |
| # Associating another IP Addresses to Network created | |
| associated_ipaddress2 = PublicIPAddress.create( | |
| self.userapiclient, | |
| services=self.services["network"], | |
| networkid=network.id | |
| ) | |
| self.assertIsNotNone( | |
| associated_ipaddress2, | |
| "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.assertEqual( | |
| PASS, | |
| status[0], | |
| "IP Addresses Association Failed" | |
| ) | |
| # Verifying the length of the list is 1 | |
| self.assertEqual( | |
| 2, | |
| len(list_ipaddresses_after), | |
| "Number of IP Addresses associated are not matching expected" | |
| ) | |
| # Launching a Virtual Machine | |
| 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" | |
| ) | |
| # Enabling static Nat for Ip Address associated | |
| StaticNATRule.enable( | |
| self.userapiclient, | |
| ipaddressid=associated_ipaddress2.ipaddress.id, | |
| virtualmachineid=vm_created.id, | |
| ) | |
| # Listing Ip Address by id | |
| list_ipaddress = PublicIPAddress.list( | |
| self.userapiclient, | |
| id=associated_ipaddress2.ipaddress.id, | |
| listall=self.services["listall"] | |
| ) | |
| status = validateList(list_ipaddress) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Failed to List IP Address" | |
| ) | |
| # Verifying the length of the list is 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_ipaddress), | |
| "Failed to List IP Address" | |
| ) | |
| self.assertEqual( | |
| True, | |
| list_ipaddress[0].isstaticnat, | |
| "Failed to Enable Static Nat" | |
| ) | |
| # Listing IP Forwarding Rules | |
| list_ipfwdrule_before = StaticNATRule.list( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| ipaddressid=associated_ipaddress2.ipaddress.id | |
| ) | |
| # Verifying no IP Forwarding Rules are listed | |
| self.assertIsNone( | |
| list_ipfwdrule_before, | |
| "IP Forwardign Rule listed for newly enabled StaticNat IP" | |
| ) | |
| # Creating IP Forwardign Rule | |
| ipfwd_rule = StaticNATRule.createIpForwardingRule( | |
| self.userapiclient, | |
| startport='80', | |
| endport='89', | |
| protocol='tcp', | |
| ipaddressid=associated_ipaddress2.ipaddress.id, | |
| openfirewall=False | |
| ) | |
| self.assertIsNotNone( | |
| ipfwd_rule, | |
| "Failed to create IP Forwarding Rule" | |
| ) | |
| # Listing IP Forwarding Rules | |
| list_ipfwdrule_after = StaticNATRule.list( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| ipaddressid=associated_ipaddress2.ipaddress.id | |
| ) | |
| status = validateList(list_ipfwdrule_after) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Failed to List IP Forwarding Rule after Creation" | |
| ) | |
| # Verifying the length of the list is 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_ipfwdrule_after), | |
| "Failed to List IP Forwarding Rule after Creation" | |
| ) | |
| # Deleting IP Forwarding Rule | |
| ipfwd_rule.delete(self.userapiclient) | |
| # Listing IP Forwarding Rules | |
| list_ipfwdrule_after = StaticNATRule.list( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| ipaddressid=associated_ipaddress2.ipaddress.id | |
| ) | |
| # Verifying no IP Forwarding Rules are listed | |
| self.assertIsNone( | |
| list_ipfwdrule_after, | |
| "IP Forwardign Rule listed after deletion" | |
| ) | |
| # Destroying the VM | |
| vm_created.delete(self.apiClient) | |
| self.cleanup.append(self.account) | |
| return | |
| @attr(tags=["advanced"], required_hardware="true") | |
| def test_17_create_update_autoscalepolicy(self): | |
| """ | |
| @summary: Test to list, create and update Autoscale Policy | |
| @Steps: | |
| Step1: Creating a Network Offering for Supported | |
| Service LB with Netscaler | |
| Step2: Create a Network using Network Offering created in Step1 | |
| Step3: Launching a VM using Network created in Step2 | |
| Step4: Associating IP Address for Network created in Step2 | |
| Step5: Listing Counters | |
| Step6: Listing Conditions for the user | |
| Step7: Verifying no Conditions are listed | |
| Step8: Creating a 2 conditions | |
| Step9: Listing conditions again | |
| Step10: Verifying 2 conditions are listed | |
| Step11: Listing Autoscale Policies for User | |
| Step12: Verifying No Autoscale policy is listed | |
| Step13: Creating Autoscale Policy using Condition1 | |
| Step14: Verifying that Autoscale Policy is created with Condition1 | |
| Step15: Listing Autoscale Policies | |
| Step16: Verifying 1 Autoscale Policy is listed | |
| Step17: Updating Autoscale Policy created in step13 with condition2 | |
| Step18: Verifying Autoscale policy is updated with condition2 | |
| """ | |
| if self.hypervisor.lower() == 'kvm': | |
| self.skipTest("Test not supported on KVM. Skipping it") | |
| list_physical_networks = PhysicalNetwork.list( | |
| self.apiClient, | |
| zoneid=self.zone.id | |
| ) | |
| run_flag = False | |
| for i in range(0, len(list_physical_networks)): | |
| list_network_serviceprovider = NetworkServiceProvider.list( | |
| self.apiClient, | |
| physicalnetworkid=list_physical_networks[i].id | |
| ) | |
| for j in range(0, len(list_network_serviceprovider)): | |
| if((list_network_serviceprovider[j].name == 'Netscaler') and | |
| (list_network_serviceprovider[j].state == 'Enabled')): | |
| run_flag = True | |
| break | |
| if not run_flag: | |
| self.debug( | |
| "Netscaler is not enabled and auto scale VM is\ | |
| applicable only for Netscaler") | |
| else: | |
| # Listing Network Offerings | |
| list_nwoff_before = NetworkOffering.list( | |
| self.apiClient, | |
| forvpc="false", | |
| guestiptype="Isolated", | |
| state="Enabled", | |
| supportedservices="SourceNat,Lb", | |
| zoneid=self.zone.id | |
| ) | |
| # Creating Network Offerign with LB as Netscalar | |
| nwoff_created = NetworkOffering.create( | |
| self.apiClient, | |
| self.services["nw_off_isolated_netscaler"] | |
| ) | |
| self.assertIsNotNone( | |
| nwoff_created, | |
| "Failed to Create Network Offering with\ | |
| LB sercvice for Netscaler") | |
| # Enable Network offering | |
| nwoff_created.update(self.apiClient, state='Enabled') | |
| # Listing Network Offerings again | |
| list_nwoff_after = NetworkOffering.list( | |
| self.apiClient, | |
| forvpc="false", | |
| guestiptype="Isolated", | |
| state="Enabled", | |
| supportedservices="SourceNat,Lb", | |
| zoneid=self.zone.id | |
| ) | |
| self.assertEqual( | |
| len(list_nwoff_before) + 1, | |
| len(list_nwoff_after), | |
| "Failed to create Network Offering" | |
| ) | |
| # Creating a Network Using the Network Offering | |
| network = Network.create( | |
| self.userapiclient, | |
| self.services["network"], | |
| accountid=self.account.name, | |
| domainid=self.domain.id, | |
| networkofferingid=nwoff_created.id, | |
| zoneid=self.zone.id | |
| ) | |
| self.assertIsNotNone( | |
| network, | |
| "Network creation failed" | |
| ) | |
| self.cleanup.append(network) | |
| self.cleanup.append(nwoff_created) | |
| # Launching a Virtual Machine | |
| 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" | |
| ) | |
| # 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.assertEqual( | |
| PASS, | |
| status[0], | |
| "IP Addresses Association Failed while launching a VM" | |
| ) | |
| # Verifying the length of the list is 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_ipaddresses_before), | |
| "IP Addresses Association Failed while launching a VM" | |
| ) | |
| # 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.assertEqual( | |
| PASS, | |
| status[0], | |
| "IP Addresses Association Failed" | |
| ) | |
| # Verifying the length of the list is 1 | |
| self.assertEqual( | |
| 2, | |
| len(list_ipaddresses_after), | |
| "Number of IP Addresses associated are not matching expected" | |
| ) | |
| # Listing Counters | |
| list_counters = Autoscale.listCounters( | |
| self.userapiclient, | |
| ) | |
| status = validateList(list_counters) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Failed to list counters" | |
| ) | |
| # Listing Conditions | |
| list_conditions_before = Autoscale.listConditions( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| account=self.account.name, | |
| domainid=self.domain.id | |
| ) | |
| self.assertIsNone( | |
| list_conditions_before, | |
| "Listed Conditions for newly created user" | |
| ) | |
| # Creating first Condition | |
| condition_created1 = Autoscale.createCondition( | |
| self.userapiclient, | |
| counterid=list_counters[0].id, | |
| relationaloperator='GT', | |
| threshold='1000' | |
| ) | |
| self.assertIsNotNone( | |
| condition_created1, | |
| "Failed to create Condition" | |
| ) | |
| # Creating second Condition | |
| condition_created2 = Autoscale.createCondition( | |
| self.userapiclient, | |
| counterid=list_counters[0].id, | |
| relationaloperator='GT', | |
| threshold='1500' | |
| ) | |
| self.assertIsNotNone( | |
| condition_created2, | |
| "Failed to create Condition" | |
| ) | |
| # Listing Conditions again | |
| list_conditions_after = Autoscale.listConditions( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| account=self.account.name, | |
| domainid=self.domain.id | |
| ) | |
| status = validateList(list_conditions_after) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Failed to list Conditions after creation" | |
| ) | |
| # Listing Autoscale policies | |
| list_autoscalepolicies_before = Autoscale.listAutoscalePolicies( | |
| self.userapiclient, | |
| listall=self.services["listall"] | |
| ) | |
| # Verifying no Autoscale policies are listed | |
| self.assertIsNone( | |
| list_autoscalepolicies_before, | |
| "Autoscale policies listed" | |
| ) | |
| # Creating Autoscale Policy | |
| autoscalepolicy_created = Autoscale.createAutoscalePolicy( | |
| self.userapiclient, | |
| action='scaleup', | |
| conditionids=condition_created1.id, | |
| duration='100', | |
| quiettime='100' | |
| ) | |
| self.assertIsNotNone( | |
| autoscalepolicy_created, | |
| "Failed to create Autoscale VM Policy" | |
| ) | |
| # Verifying autoscalepolicy is created using condition1 | |
| self.assertEqual( | |
| condition_created1.id, | |
| autoscalepolicy_created.conditions[0].id, | |
| "Autoscale Policy not created by given condition" | |
| ) | |
| # Listing Autoscale policies | |
| list_autoscalepolicies_after = Autoscale.listAutoscalePolicies( | |
| self.userapiclient, | |
| listall=self.services["listall"] | |
| ) | |
| status = validateList(list_autoscalepolicies_after) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Failed to list Autoscale Policy after creation" | |
| ) | |
| self.assertEqual( | |
| 1, | |
| len(list_autoscalepolicies_after), | |
| "Autoscale Policies count is not matching" | |
| ) | |
| # Updating Autoscale Policy | |
| autoscalepolicy_updated = Autoscale.updateAutoscalePolicy( | |
| self.userapiclient, | |
| id=autoscalepolicy_created.id, | |
| conditionids=condition_created2.id, | |
| duration='100', | |
| quiettime='100' | |
| ) | |
| self.assertIsNotNone( | |
| autoscalepolicy_updated, | |
| "Failed to update Autoscale Policy" | |
| ) | |
| # Verifying the Autoscale Policy is updated | |
| self.assertEqual( | |
| condition_created2.id, | |
| autoscalepolicy_updated.conditions[0].id, | |
| "Autoscale Policy not updated to given condition" | |
| ) | |
| # Destroying the VM | |
| vm_created.delete(self.apiClient) | |
| self.cleanup.append(self.account) | |
| return | |
| @attr(tags=["advanced"], required_hardware="true") | |
| def test_18_create_update_autoscaleprofiles(self): | |
| """ | |
| @summary: Test to list, create and update Autoscale VM Profiles | |
| @Steps: | |
| Step1: Creating a Network Offering for Supported Service LB with | |
| Netscaler | |
| Step2: Create a Network using Network Offering created in Step1 | |
| Step3: Launching a VM using Network created in Step2 | |
| Step4: Associating IP Address for Network created in Step2 | |
| Step5: Listing Available Service Offerings | |
| Step6: Listing all types of templates | |
| Step7: Verifying only featured templates are listed for | |
| newly created user | |
| Step8: Listing autoscale vm profiles | |
| Step9: Verifying no Autoscale VM Profiles are listed | |
| Step10: Creating a Autoscale VM Profile | |
| Step11: Listing Autoscale VM Profile | |
| Step12: Verifying 1 Autoscale VM Profile is listed | |
| Step13: Listing Autoscale VM Profile by id | |
| Step14: Verifying details of the created autoscale | |
| vm profile are matching with listed autoscal vm profile | |
| Step15: Updating Autoscale VM profile with expunge vm grace period | |
| Step16: Verifying that Autoscale VM is updated | |
| """ | |
| if self.hypervisor.lower() == 'kvm': | |
| self.skipTest("Test not supported on KVM. Skipping it") | |
| list_physical_networks = PhysicalNetwork.list( | |
| self.apiClient, | |
| zoneid=self.zone.id | |
| ) | |
| run_flag = False | |
| for i in range(0, len(list_physical_networks)): | |
| list_network_serviceprovider = NetworkServiceProvider.list( | |
| self.apiClient, | |
| physicalnetworkid=list_physical_networks[i].id | |
| ) | |
| for j in range(0, len(list_network_serviceprovider)): | |
| if((list_network_serviceprovider[j].name == 'Netscaler') and | |
| (list_network_serviceprovider[j].state == 'Enabled')): | |
| run_flag = True | |
| break | |
| if not run_flag: | |
| self.debug( | |
| "Netscaler is not enabled and auto scale VM\ | |
| is applicable only for Netscaler") | |
| else: | |
| # Listing Network Offerings | |
| list_nwoff_before = NetworkOffering.list( | |
| self.apiClient, | |
| forvpc="false", | |
| guestiptype="Isolated", | |
| state="Enabled", | |
| supportedservices="SourceNat,Lb", | |
| zoneid=self.zone.id | |
| ) | |
| # Creating Network Offerign with LB as Netscalar | |
| nwoff_created = NetworkOffering.create( | |
| self.apiClient, | |
| self.services["nw_off_isolated_netscaler"] | |
| ) | |
| self.assertIsNotNone( | |
| nwoff_created, | |
| "Failed to Create Network Offering with\ | |
| LB sercvice for Netscaler") | |
| # Enable Network offering | |
| nwoff_created.update(self.apiClient, state='Enabled') | |
| # Listing Network Offerings again | |
| list_nwoff_after = NetworkOffering.list( | |
| self.apiClient, | |
| forvpc="false", | |
| guestiptype="Isolated", | |
| state="Enabled", | |
| supportedservices="SourceNat,Lb", | |
| zoneid=self.zone.id | |
| ) | |
| self.assertEqual( | |
| len(list_nwoff_before) + 1, | |
| len(list_nwoff_after), | |
| "Failed to create Network Offering" | |
| ) | |
| # Creating a Network Using the Network Offering | |
| network = Network.create( | |
| self.userapiclient, | |
| self.services["network"], | |
| accountid=self.account.name, | |
| domainid=self.domain.id, | |
| networkofferingid=nwoff_created.id, | |
| zoneid=self.zone.id | |
| ) | |
| self.assertIsNotNone( | |
| network, | |
| "Network creation failed" | |
| ) | |
| self.cleanup.append(network) | |
| self.cleanup.append(nwoff_created) | |
| # Launching a Virtual Machine | |
| 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" | |
| ) | |
| # 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.assertEqual( | |
| PASS, | |
| status[0], | |
| "IP Addresses Association Failed while launching a VM" | |
| ) | |
| # Verifying the length of the list is 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_ipaddresses_before), | |
| "IP Addresses Association Failed while launching a VM" | |
| ) | |
| # 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.assertEqual( | |
| PASS, | |
| status[0], | |
| "IP Addresses Association Failed" | |
| ) | |
| # Verifying the length of the list is 1 | |
| self.assertEqual( | |
| 2, | |
| len(list_ipaddresses_after), | |
| "Number of IP Addresses associated are not matching expected" | |
| ) | |
| # Listing Service Offerings | |
| list_service_offerings = ServiceOffering.list( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| issystem='false' | |
| ) | |
| status = validateList(list_service_offerings) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Failed to list Service Offerings" | |
| ) | |
| # Listing Users | |
| list_users = User.list( | |
| self.apiClient, | |
| listall=self.services["listall"], | |
| account=self.account.name, | |
| domainid=self.domain.id | |
| ) | |
| status = validateList(list_users) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Failed to list Users" | |
| ) | |
| # Listing Featured Templates | |
| list_templates_featured = Template.list( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| templatefilter="featured", | |
| zoneid=self.zone.id | |
| ) | |
| status = validateList(list_templates_featured) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Failed to list Featured Templates" | |
| ) | |
| # Listing Community Templates | |
| list_templates_community = Template.list( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| templatefilter="community", | |
| zoneid=self.zone.id | |
| ) | |
| self.assertIsNone( | |
| list_templates_community, | |
| "Community Templates listed for newly created User" | |
| ) | |
| # Listing selfexecutable Templates | |
| list_templates_selfexecutable = Template.list( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| templatefilter="selfexecutable", | |
| zoneid=self.zone.id | |
| ) | |
| self.assertIsNone( | |
| list_templates_selfexecutable, | |
| "Self Executable Templates listed for newly created User" | |
| ) | |
| # Listing Autoscale VM Profiles | |
| list_autoscalevm_profiles_before =\ | |
| Autoscale.listAutoscaleVmPofiles( | |
| self.userapiclient, | |
| listall=self.services["listall"] | |
| ) | |
| self.assertIsNone( | |
| list_autoscalevm_profiles_before, | |
| "Autoscale VM Profiles listed" | |
| ) | |
| # Creating Autoscale VM Profile | |
| counterparam = {"snmpcommunity": "public", "snmpport": "161"} | |
| autoscalevm_profile = Autoscale.createAutoscaleVmProfile( | |
| self.userapiclient, | |
| serviceofferingid=list_service_offerings[0].id, | |
| zoneid=self.zone.id, | |
| templateid=list_templates_featured[0].id, | |
| autoscaleuserid=list_users[0].id, | |
| expungevmgraceperiod='100', | |
| counterparam=counterparam | |
| ) | |
| self.assertIsNotNone( | |
| autoscalevm_profile, | |
| "Failed to create Autoscale VM Profile" | |
| ) | |
| # Listing Autoscale VM Profiles | |
| list_autoscalevm_profiles_after = Autoscale.listAutoscaleVmPofiles( | |
| self.userapiclient, | |
| listall=self.services["listall"] | |
| ) | |
| status = validateList(list_autoscalevm_profiles_after) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Failed to list Autoscale VM Profile after creation" | |
| ) | |
| # Verifying only 1 autoscale vm profile is created | |
| self.assertEqual( | |
| 1, | |
| len(list_autoscalevm_profiles_after), | |
| "Count of Autoscale VM profiles listed is not matching" | |
| ) | |
| # Listing the Autoscale VM Profile by id | |
| list_autoscalvmprofile = Autoscale.listAutoscaleVmPofiles( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| id=autoscalevm_profile.id | |
| ) | |
| status = validateList(list_autoscalvmprofile) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Failed to list Autoscale VM Profile by Id after creation" | |
| ) | |
| # Verifying details of the listed Autoscale VM Profile | |
| # Creating expected and actual values dictionaries | |
| expected_dict = { | |
| "id": autoscalevm_profile.id, | |
| "account": self.account.name, | |
| "domainid": self.domain.id, | |
| "autoscaleuserid": list_users[0].id, | |
| "serviceofferingid": list_service_offerings[0].id, | |
| "zoneid": self.zone.id, | |
| "templateid": list_templates_featured[0].id, | |
| "expungevmgraceperiod": | |
| autoscalevm_profile.expungevmgraceperiod} | |
| actual_dict = { | |
| "id": list_autoscalvmprofile[0].id, | |
| "account": list_autoscalvmprofile[0].account, | |
| "domainid": list_autoscalvmprofile[0].domainid, | |
| "autoscaleuserid": | |
| list_autoscalvmprofile[0].autoscaleuserid, | |
| "serviceofferingid": | |
| list_autoscalvmprofile[0].serviceofferingid, | |
| "zoneid": list_autoscalvmprofile[0].zoneid, | |
| "templateid": list_autoscalvmprofile[0].templateid, | |
| "expungevmgraceperiod": | |
| list_autoscalvmprofile[0].expungevmgraceperiod} | |
| autoscalevm_profile_status = self.__verify_values( | |
| expected_dict, | |
| actual_dict | |
| ) | |
| self.assertEqual( | |
| True, | |
| autoscalevm_profile_status, | |
| "Created Autoscale VM Profile details are not as expected" | |
| ) | |
| # Updating destroyvmgrageperiod for created Autoscale VM Profile | |
| autoscalevm_profile_updated = Autoscale.updateAutoscaleVMProfile( | |
| self.userapiclient, | |
| id=autoscalevm_profile.id, | |
| autoscaleuserid=list_users[0].id, | |
| expungevmgraceperiod='200', | |
| templateid=list_templates_featured[0].id, | |
| ) | |
| self.assertIsNotNone( | |
| autoscalevm_profile_updated, | |
| "Failed to update Autoscale VM Profile" | |
| ) | |
| # Verifyign that Expunge VM Grace period is updated in autoscale VM | |
| # Profile | |
| self.assertEqual( | |
| 200, | |
| autoscalevm_profile_updated.expungevmgraceperiod, | |
| "Failed to update expunge vm grace period" | |
| ) | |
| # Destroying the VM | |
| vm_created.delete(self.apiClient) | |
| self.cleanup.append(self.account) | |
| return | |
| @attr(tags=["advanced"], required_hardware="true") | |
| def test_19_create_update_autoscalevmgroup(self): | |
| """ | |
| @summary: Test to list, create, update, enable,\ | |
| disable Autoscale VM Profiles | |
| @Steps: | |
| Step1: Creating a Network Offering for Supported Service LB with | |
| Netscaler | |
| Step2: Create a Network using Network Offering created in Step1 | |
| Step3: Launching a VM using Network created in Step2 | |
| Step4: Associating IP Address for Network created in Step2 | |
| Step5: Creating Scaleup condition and scaleup policy | |
| Step6: Creating Scaledown condition and scaledown policy | |
| Step7: Creating Autoscale VM profile | |
| Step8: Creating Load Balancer Rule | |
| Step9: Listing Autoscale Vm groups and verifying no Autoscale VM groups | |
| are listed | |
| Step10: Creating Autoscale VM Group and verifying it was created | |
| Step11: Listing Autoscale Vm groups and verifying 1 Autoscale VM groups | |
| is listed | |
| Step12: Disabling Autoscale VM group and verifying it was disabled | |
| Step13: Updating Autoscale VM group and verifying it was updated | |
| Step14: Enabling Autoscale VM group and verifying it was enabled | |
| """ | |
| if self.hypervisor.lower() == 'kvm': | |
| self.skipTest("Test not supported on KVM. Skipping it.") | |
| list_physical_networks = PhysicalNetwork.list( | |
| self.apiClient, | |
| zoneid=self.zone.id | |
| ) | |
| run_flag = False | |
| for i in range(0, len(list_physical_networks)): | |
| list_network_serviceprovider = NetworkServiceProvider.list( | |
| self.apiClient, | |
| physicalnetworkid=list_physical_networks[i].id | |
| ) | |
| for j in range(0, len(list_network_serviceprovider)): | |
| if((list_network_serviceprovider[j].name == 'Netscaler') and | |
| (list_network_serviceprovider[j].state == 'Enabled')): | |
| run_flag = True | |
| break | |
| if not run_flag: | |
| self.debug( | |
| "Netscaler is not enabled and auto scale VM is\ | |
| applicable only for Netscaler") | |
| else: | |
| # Listing Network Offerings | |
| list_nwoff_before = NetworkOffering.list( | |
| self.apiClient, | |
| forvpc="false", | |
| guestiptype="Isolated", | |
| state="Enabled", | |
| supportedservices="SourceNat,Lb", | |
| zoneid=self.zone.id | |
| ) | |
| # Creating Network Offerign with LB as Netscalar | |
| nwoff_created = NetworkOffering.create( | |
| self.apiClient, | |
| self.services["nw_off_isolated_netscaler"] | |
| ) | |
| self.assertIsNotNone( | |
| nwoff_created, | |
| "Failed to Create Network Offering with\ | |
| LB sercvice for Netscaler") | |
| # Enable Network offering | |
| nwoff_created.update(self.apiClient, state='Enabled') | |
| # Listing Network Offerings again | |
| list_nwoff_after = NetworkOffering.list( | |
| self.apiClient, | |
| forvpc="false", | |
| guestiptype="Isolated", | |
| state="Enabled", | |
| supportedservices="SourceNat,Lb", | |
| zoneid=self.zone.id | |
| ) | |
| self.assertEqual( | |
| len(list_nwoff_before) + 1, | |
| len(list_nwoff_after), | |
| "Failed to create Network Offering" | |
| ) | |
| # Creating a Network Using the Network Offering | |
| network = Network.create( | |
| self.userapiclient, | |
| self.services["network"], | |
| accountid=self.account.name, | |
| domainid=self.domain.id, | |
| networkofferingid=nwoff_created.id, | |
| zoneid=self.zone.id | |
| ) | |
| self.assertIsNotNone( | |
| network, | |
| "Network creation failed" | |
| ) | |
| self.cleanup.append(network) | |
| # self.cleanup.append(nwoff_created) | |
| # Launching a Virtual Machine | |
| 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" | |
| ) | |
| # 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.assertEqual( | |
| PASS, | |
| status[0], | |
| "IP Addresses Association Failed while launching a VM" | |
| ) | |
| # Verifying the length of the list is 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_ipaddresses_before), | |
| "IP Addresses Association Failed while launching a VM" | |
| ) | |
| # 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.assertEqual( | |
| PASS, | |
| status[0], | |
| "IP Addresses Association Failed" | |
| ) | |
| # Verifying the length of the list is 1 | |
| self.assertEqual( | |
| 2, | |
| len(list_ipaddresses_after), | |
| "Number of IP Addresses associated are not matching expected" | |
| ) | |
| # Listing Users | |
| list_users = User.list( | |
| self.apiClient, | |
| listall=self.services["listall"], | |
| account=self.account.name, | |
| domainid=self.domain.id | |
| ) | |
| status = validateList(list_users) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Failed to list Users" | |
| ) | |
| # Listing counters | |
| list_counters = Autoscale.listCounters(self.userapiclient) | |
| status = validateList(list_counters) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Failed to list Counters" | |
| ) | |
| # Create Condition for scaleup Vm Policy | |
| condition_scaleup = Autoscale.createCondition( | |
| self.userapiclient, | |
| counterid=list_counters[0].id, | |
| relationaloperator='GT', | |
| threshold='40' | |
| ) | |
| self.assertIsNotNone( | |
| condition_scaleup, | |
| "Failed to create Scaleup Condition" | |
| ) | |
| # Creating scaleup Vm Policy | |
| scaleup_policy = Autoscale.createAutoscalePolicy( | |
| self.userapiclient, | |
| action='scaleup', | |
| conditionids=condition_scaleup.id, | |
| duration='40', | |
| quiettime='300' | |
| ) | |
| self.assertIsNotNone( | |
| scaleup_policy, | |
| "Failed to create Scaleup VM Policy" | |
| ) | |
| # Create Condition for scaledown Vm Policy | |
| condition_scaledown = Autoscale.createCondition( | |
| self.userapiclient, | |
| counterid=list_counters[0].id, | |
| relationaloperator='GT', | |
| threshold='10' | |
| ) | |
| self.assertIsNotNone( | |
| condition_scaledown, | |
| "Failed to create Scaledown Condition" | |
| ) | |
| # Creating scaledown Vm Policy | |
| scaledown_policy = Autoscale.createAutoscalePolicy( | |
| self.userapiclient, | |
| action='scaledown', | |
| conditionids=condition_scaledown.id, | |
| duration='40', | |
| quiettime='300' | |
| ) | |
| self.assertIsNotNone( | |
| scaledown_policy, | |
| "Failed to create Scaledown VM Policy" | |
| ) | |
| counterparam = {"snmpcommunity": "public", "snmpport": "161"} | |
| # Create Autoscale VM Profile | |
| vmprofile = Autoscale.createAutoscaleVmProfile( | |
| self.userapiclient, | |
| serviceofferingid=self.service_offering.id, | |
| zoneid=self.zone.id, | |
| templateid=self.template.id, | |
| autoscaleuserid=list_users[0].id, | |
| expungevmgraceperiod='30', | |
| counterparam=counterparam | |
| ) | |
| self.assertIsNotNone( | |
| vmprofile, | |
| "Failed to create Autoscale Vm Profile" | |
| ) | |
| self.services["lbrule"]["openfirewall"] = False | |
| # Creating Load Balancer Rule | |
| lbrule = LoadBalancerRule.create( | |
| self.userapiclient, | |
| self.services["lbrule"], | |
| ipaddressid=associated_ipaddress.ipaddress.id, | |
| accountid=self.account.name, | |
| networkid=network.id, | |
| domainid=self.domain.id | |
| ) | |
| self.assertIsNotNone( | |
| lbrule, | |
| "Failed to create Load Balancer Rule" | |
| ) | |
| # Listing Autoscale VM Groups | |
| list_vmgroup_before = Autoscale.listAutoscaleVmGroup( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| lbruleid=lbrule.id | |
| ) | |
| # Verifying No Autoscale VM Groups are listed | |
| self.assertIsNone( | |
| list_vmgroup_before, | |
| "Listed Autoscale VM Groups for newly created LB Rule" | |
| ) | |
| # Creating Autoscale VM Group | |
| vmgroup = Autoscale.createAutoscaleVmGroup( | |
| self.userapiclient, | |
| lbruleid=lbrule.id, | |
| minmembers='3', | |
| maxmembers='10', | |
| scaledownpolicyids=scaledown_policy.id, | |
| scaleuppolicyids=scaleup_policy.id, | |
| vmprofileid=vmprofile.id, | |
| interval='30' | |
| ) | |
| self.assertIsNotNone( | |
| vmgroup, | |
| "Failed to create Autoscale VM Group" | |
| ) | |
| # Listing Autoscale VM Groups | |
| list_vmgroup_after = Autoscale.listAutoscaleVmGroup( | |
| self.userapiclient, | |
| listall=self.services["listall"], | |
| lbruleid=lbrule.id | |
| ) | |
| status = validateList(list_vmgroup_after) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Failed to list Autoscale VM group after creation" | |
| ) | |
| # Verifying only 1 Autoscale VM group is listed | |
| self.assertEqual( | |
| 1, | |
| len(list_vmgroup_after), | |
| "Autoscale VM group list count is not matching" | |
| ) | |
| # Disabling Autoscale VM group | |
| vmgroup_disabled = Autoscale.disableAutoscaleVmGroup( | |
| self.userapiclient, | |
| id=vmgroup.id | |
| ) | |
| self.assertIsNotNone( | |
| vmgroup_disabled, | |
| "Failed to disable Autoscale VM group" | |
| ) | |
| # Verifying the state of the VM Group after renabling | |
| self.assertEqual( | |
| "disabled", | |
| vmgroup_disabled.state, | |
| "Disabled VM Group state is not matching" | |
| ) | |
| # Updating Autoscale VM Group | |
| vmgroup_updated = Autoscale.updateAutoscaleVMGroup( | |
| self.userapiclient, | |
| id=vmgroup.id, | |
| minmembers='3', | |
| maxmembers='10', | |
| scaledownpolicyids=scaledown_policy.id, | |
| scaleuppolicyids=scaleup_policy.id, | |
| interval='40' | |
| ) | |
| self.assertIsNotNone( | |
| vmgroup_updated, | |
| "Failed to update Autoscale VM group" | |
| ) | |
| self.assertEqual( | |
| 40, | |
| vmgroup_updated.interval, | |
| "Updated Autoscale VM group interval value is not matching" | |
| ) | |
| # Enabling Autoscale VM group | |
| vmgroup_enabled = Autoscale.enableAutoscaleVmGroup( | |
| self.userapiclient, | |
| id=vmgroup.id | |
| ) | |
| self.assertIsNotNone( | |
| vmgroup_enabled, | |
| "Failed to enable Autoscale VM group" | |
| ) | |
| # Verifying the state of the VM Group after renabling | |
| self.assertEqual( | |
| "enabled", | |
| vmgroup_enabled.state, | |
| "Enabled VM Group state is not matching" | |
| ) | |
| # Destroying the VM | |
| vm_created.delete(self.apiClient) | |
| self.cleanup.append(self.account) | |
| return |