| # Licensed to the Apache Software Foundation (ASF) under one | |
| # or more contributor license agreements. See the NOTICE file | |
| # distributed with this work for additional information | |
| # regarding copyright ownership. The ASF licenses this file | |
| # to you under the Apache License, Version 2.0 (the | |
| # "License"); you may not use this file except in compliance | |
| # with the License. You may obtain a copy of the License at | |
| # | |
| # http://www.apache.org/licenses/LICENSE-2.0 | |
| # | |
| # Unless required by applicable law or agreed to in writing, | |
| # software distributed under the License is distributed on an | |
| # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| # KIND, either express or implied. See the License for the | |
| # specific language governing permissions and limitations | |
| # under the License. | |
| # Import Local Modules | |
| from marvin.cloudstackTestCase import * | |
| from marvin.lib.utils import * | |
| from marvin.lib.base import * | |
| from marvin.lib.common import * | |
| from marvin.codes import PASS, FAIL | |
| from nose.plugins.attrib import attr | |
| class TestNetworks_1(cloudstackTestCase): | |
| @classmethod | |
| def setUpClass(cls): | |
| try: | |
| cls._cleanup = [] | |
| cls.testClient = super(TestNetworks_1, cls).getClsTestClient() | |
| cls.api_client = cls.testClient.getApiClient() | |
| cls.test_data = cls.testClient.getParsedTestDataConfig() | |
| cls.hypervisor = cls.testClient.getHypervisorInfo() | |
| # Get Domain, Zone, Template | |
| cls.domain = get_domain(cls.api_client) | |
| cls.zone = get_zone( | |
| cls.api_client, | |
| cls.testClient.getZoneForTests()) | |
| cls.template = get_template( | |
| cls.api_client, | |
| cls.zone.id, | |
| cls.test_data["ostype"] | |
| ) | |
| if cls.zone.localstorageenabled: | |
| cls.storagetype = 'local' | |
| cls.test_data["service_offerings"][ | |
| "tiny"]["storagetype"] = 'local' | |
| else: | |
| cls.storagetype = 'shared' | |
| cls.test_data["service_offerings"][ | |
| "tiny"]["storagetype"] = 'shared' | |
| cls.test_data['mode'] = cls.zone.networktype | |
| cls.test_data["virtual_machine"][ | |
| "hypervisor"] = cls.hypervisor | |
| cls.test_data["virtual_machine"]["zoneid"] = cls.zone.id | |
| cls.test_data["virtual_machine"]["template"] = cls.template.id | |
| cls.test_data["network_without_acl"]["zoneid"] = cls.zone.id | |
| # Create Network offering | |
| cls.network_offering = NetworkOffering.create( | |
| cls.api_client, | |
| cls.test_data["network_offering_vlan"], | |
| ) | |
| cls._cleanup.append(cls.network_offering) | |
| cls.network_offering.update(cls.api_client, state='Enabled') | |
| cls.test_data["network_without_acl"][ | |
| "networkoffering"] = cls.network_offering.id | |
| cls.service_offering = ServiceOffering.create( | |
| cls.api_client, | |
| cls.test_data["service_offerings"]["tiny"] | |
| ) | |
| cls._cleanup.append(cls.service_offering) | |
| cls.account = Account.create( | |
| cls.api_client, | |
| cls.test_data["account"], | |
| domainid=cls.domain.id | |
| ) | |
| cls._cleanup.append(cls.account) | |
| # Getting authentication for user in newly created Account | |
| cls.user = cls.account.user[0] | |
| cls.userapiclient = cls.testClient.getUserApiClient( | |
| cls.user.username, | |
| cls.domain.name) | |
| cls.account_network = Network.create( | |
| cls.userapiclient, | |
| cls.test_data["network_without_acl"], | |
| cls.account.name, | |
| cls.account.domainid | |
| ) | |
| cls._cleanup.append(cls.account_network) | |
| except Exception as e: | |
| cls.tearDownClass() | |
| raise Exception("Warning: Exception in setup : %s" % e) | |
| return | |
| def setUp(self): | |
| self.apiClient = self.testClient.getApiClient() | |
| self.cleanup = [] | |
| def tearDown(self): | |
| super(TestNetworks_1, self).tearDown() | |
| @classmethod | |
| def tearDownClass(cls): | |
| super(TestNetworks_1, cls).tearDownClass() | |
| def __verify_values(self, expected_vals, actual_vals): | |
| """ | |
| @summary: Function to verify expected and actual values | |
| Step1: Initializing return flag to True | |
| Step2: Verifying length of expected and actual dictionaries is | |
| matching. | |
| If not matching returning false | |
| Step3: Listing all the keys from expected dictionary | |
| Step4: Looping through each key from step2 and verifying expected | |
| and actual dictionaries have same value | |
| If not making return flag to False | |
| Step5: returning the return flag after all the values are verified | |
| """ | |
| return_flag = True | |
| if len(expected_vals) != len(actual_vals): | |
| return False | |
| keys = list(expected_vals.keys()) | |
| for i in range(0, len(expected_vals)): | |
| exp_val = expected_vals[keys[i]] | |
| act_val = actual_vals[keys[i]] | |
| if exp_val == act_val: | |
| return_flag = return_flag and True | |
| else: | |
| return_flag = return_flag and False | |
| self.debug( | |
| "expected Value: %s, is not matching with actual value: %s" | |
| % | |
| (exp_val, act_val)) | |
| return return_flag | |
| @attr(tags=["advanced"], required_hardware="true") | |
| def test_01_list_networks_pagination(self): | |
| """ | |
| @Desc: Test List Networks pagination | |
| @Steps | |
| Step1 : Listing the networks for a user | |
| Step2 : Verifying listed networks for account created at class level | |
| Step3 : If number of networks is less than (pagesize 1), then | |
| creating them | |
| Step4 : Listing the networks again | |
| Step5 : Verifying for the length of the networks that it is | |
| (pagesize 1) | |
| Step6 : Listing and verifying all the networks in page1 | |
| Step7 : Listing and verifying all the networks in page2 | |
| Step8 : Verifying that on page 2 only 1 network is present and | |
| the network on page 2 is not present in page1 | |
| """ | |
| list_zones = Zone.list( | |
| self.userapiclient, | |
| id=self.zone.id | |
| ) | |
| status = validateList(list_zones) | |
| self.assertEqual(PASS, status[0], "No Zones found for a given id") | |
| self.test_data["network_without_acl"]["zoneid"] = list_zones[0].id | |
| # Listing the networks for a user | |
| list_networks_before = Network.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| type="Isolated" | |
| ) | |
| # Verifying listed networks for account created at class level | |
| if list_networks_before is None: | |
| self.assertEqual( | |
| len(list_networks_before), | |
| 0, | |
| "Network create failed at class level" | |
| ) | |
| # If number of networks is less than (pagesize 1), then creating | |
| # network | |
| elif len(list_networks_before) == 1: | |
| for i in range(0, (self.test_data["pagesize"])): | |
| network_created = Network.create( | |
| self.userapiclient, | |
| self.test_data["network_without_acl"], | |
| ) | |
| self.cleanup.append(network_created) | |
| self.assertIsNotNone( | |
| network_created, | |
| "Network is not created" | |
| ) | |
| # Creating expected and actual values dictionaries | |
| expected_dict = { | |
| "id": list_zones[0].id, | |
| "name": self.test_data["network_without_acl"]["name"], | |
| } | |
| actual_dict = { | |
| "id": network_created.zoneid, | |
| "name": network_created.name, | |
| } | |
| network_status = self.__verify_values( | |
| expected_dict, | |
| actual_dict | |
| ) | |
| self.assertEqual( | |
| True, | |
| network_status, | |
| "Listed network details are not as expected" | |
| ) | |
| else: | |
| self.assertEqual( | |
| len(list_networks_before), | |
| 1, | |
| "more than 1 network created at class level" | |
| ) | |
| # Listing the networks | |
| list_networks_after = Network.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| type="Isolated") | |
| status = validateList(list_networks_after) | |
| self.assertEqual(PASS, status[0], "No networks found using list call") | |
| # Asserting for the length of the networks | |
| self.assertEqual( | |
| len(list_networks_after), | |
| (self.test_data["pagesize"] + 1), | |
| "Number of networks created is not matching expected" | |
| ) | |
| # Listing all the networks in page1 | |
| list_networks_page1 = Network.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| page=1, | |
| pagesize=self.test_data["pagesize"], | |
| type="Isolated" | |
| ) | |
| status = validateList(list_networks_page1) | |
| self.assertEqual(PASS, status[0], "No networks found at page 1") | |
| self.assertEqual( | |
| len(list_networks_page1), | |
| self.test_data["pagesize"], | |
| "List network response is not matching with the page\ | |
| size length for page 1") | |
| # Listing all the networks in page2 | |
| list_networks_page2 = Network.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| page=2, | |
| pagesize=self.test_data["pagesize"], | |
| type="Isolated" | |
| ) | |
| status = validateList(list_networks_page2) | |
| self.assertEqual(PASS, status[0], "No networks found at page 2") | |
| self.assertEqual( | |
| len(list_networks_page2), | |
| 1, | |
| "List network response is not matching with the page size\ | |
| length for page 2" | |
| ) | |
| network_page2 = list_networks_page2[0] | |
| for i in range(0, len(list_networks_page1)): | |
| network_page1 = list_networks_page1[i] | |
| self.assertNotEqual( | |
| network_page2.id, | |
| network_page1.id, | |
| "Network listed in page 2 is also listed in page 1" | |
| ) | |
| return | |
| @attr(tags=["advanced"], required_hardware="true") | |
| def test_02_create_network_without_sourcenat(self): | |
| """ | |
| @Desc: Test create network if supported services doesn't have sourcenat | |
| @Steps | |
| Step1 : Create Network Offering without sourcenat | |
| Step2 : Enable network offering | |
| Step3 : Create network with sourcenat diasbled network offering | |
| Step4 : Verifying that it raises an exception | |
| """ | |
| # Create Network offering specifically sourcenat disabled | |
| network_offering_without_sourcenat = NetworkOffering.create( | |
| self.apiClient, | |
| self.test_data["network_offering_without_sourcenat"], | |
| ) | |
| self.cleanup.append(network_offering_without_sourcenat) | |
| if network_offering_without_sourcenat is None: | |
| self.fail("Creation of network offering without sourcenat failed") | |
| # Enable network offering | |
| network_offering_without_sourcenat.update( | |
| self.apiClient, | |
| state='Enabled') | |
| self.test_data["network_without_acl"][ | |
| "networkoffering"] = network_offering_without_sourcenat.id | |
| # Network create call raise an exception | |
| with self.assertRaises(Exception): | |
| network_created = Network.create( | |
| self.userapiclient, | |
| self.test_data["network_without_acl"], | |
| ) | |
| if network_created is not None: | |
| self.cleanup.append(network_created) | |
| self.test_data["network_without_acl"][ | |
| "networkoffering"] = self.network_offering.id | |
| return | |
| @attr(tags=["advanced"], required_hardware="true") | |
| def test_03_list_vpc_pagination(self): | |
| """ | |
| @Desc: Test create vpc with network domain as parameter | |
| @Steps | |
| Step1 : List VPC Offering | |
| Step2 : List VPCs for newly created user | |
| Step3 : Create VPCs without network domain based on page size | |
| Step4 : Verify count of VPCs created | |
| Step5 : Listing all the VPCs in page1 | |
| Step6 : Listing all the VPCs in page2 | |
| Step7 : Verifying that on page 2 only 1 vpc is present and | |
| the vpc on page 2 is not present in page1 | |
| Step8 : Deleting a single vpc and verifying that vpc does | |
| not exists on page 2 | |
| """ | |
| if self.hypervisor.lower() in ['hyperv']: | |
| raise unittest.SkipTest("This feature is not supported on existing hypervisor. Hence, skipping the test") | |
| # List VPC Offering | |
| vpc_offs_list = VpcOffering.list(self.userapiclient, isdefault="true", name='Default VPC offering') | |
| if vpc_offs_list is None: | |
| self.fail("Default VPC offerings not found") | |
| else: | |
| vpc_offs = vpc_offs_list[0] | |
| # List VPCs | |
| vpc_list = VPC.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"] | |
| ) | |
| # verify no vpc is present for newly created user | |
| status = validateList(vpc_list) | |
| self.assertEqual(FAIL, status[0], "VPCs found for newly created user") | |
| for i in range(0, (self.test_data["pagesize"] + 1)): | |
| vpc_1 = VPC.create( | |
| self.userapiclient, | |
| self.test_data["vpc"], | |
| vpcofferingid=vpc_offs.id, | |
| zoneid=self.zone.id, | |
| ) | |
| if(i < (self.test_data["pagesize"])): | |
| self.cleanup.append(vpc_1) | |
| # verify vpc is created and not none | |
| self.assertIsNotNone(vpc_1, "VPC is not created") | |
| # Verify VPC name with test data | |
| self.assertNotEqual( | |
| -1, | |
| vpc_1.name.find(self.test_data["vpc"]["name"]), | |
| "VPC name not matched" | |
| ) | |
| # verify zone with test data | |
| self.assertEqual( | |
| self.zone.id, | |
| vpc_1.zoneid, | |
| "Zone is not matching in the vpc created" | |
| ) | |
| # Asserting for the length of the VPCs | |
| vpc_count_after = VPC.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"]) | |
| status = validateList(vpc_count_after) | |
| self.assertEqual(PASS, status[0], "VPC list count is null") | |
| self.assertEqual( | |
| len(vpc_count_after), | |
| (self.test_data["pagesize"] + 1), | |
| "Number of VPCs created is not matching expected" | |
| ) | |
| # Listing all the VPCs in page1 | |
| list_vpcs_page1 = VPC.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| page=1, | |
| pagesize=self.test_data["pagesize"] | |
| ) | |
| status = validateList(list_vpcs_page1) | |
| self.assertEqual(PASS, status[0], "No vpcs found in Page 1") | |
| self.assertEqual( | |
| len(list_vpcs_page1), | |
| self.test_data["pagesize"], | |
| "List vpc response is not matching with the page\ | |
| size length for page 1") | |
| # Listing all the vpcs in page2 | |
| list_vpcs_page2 = VPC.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| page=2, | |
| pagesize=self.test_data["pagesize"] | |
| ) | |
| status = validateList(list_vpcs_page2) | |
| self.assertEqual(PASS, status[0], "No vpc found in Page 2") | |
| self.assertEqual( | |
| 1, | |
| len(list_vpcs_page2), | |
| "List VPCs response is not matching with the\ | |
| page size length for page 2" | |
| ) | |
| vpc_page2 = list_vpcs_page2[0] | |
| # Verifying that on page 2 only 1 vpc is present and the vpc on page 2 | |
| # is not present in page1 | |
| for i in range(0, len(list_vpcs_page1)): | |
| vpc_page1 = list_vpcs_page1[i] | |
| self.assertNotEqual( | |
| vpc_page2.id, | |
| vpc_page1.id, | |
| "VPC listed in page 2 is also listed in page 1" | |
| ) | |
| # Deleting a single vpc and verifying that vpc does not exists on page | |
| # 2 | |
| VPC.delete(vpc_1, self.userapiclient) | |
| list_vpc_response = VPC.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| page=2, | |
| pagesize=self.test_data["pagesize"] | |
| ) | |
| self.assertEqual( | |
| list_vpc_response, | |
| None, | |
| "vpc was not deleted" | |
| ) | |
| return | |
| @attr(tags=["advanced"], required_hardware="true") | |
| def test_04_create_vpc_with_networkdomain(self): | |
| """ | |
| @Desc: Test create vpc with network domain as parameter | |
| @Steps | |
| Step1 : List VPC Offering | |
| Step2 : List VPCs for newly created user | |
| Step3 : Create VPC | |
| Step4 : List VPC and verify that count is increased by 1 | |
| """ | |
| if self.hypervisor.lower() in ['hyperv']: | |
| raise unittest.SkipTest("This feature is not supported on existing hypervisor. Hence, skipping the test") | |
| # List VPC Offering | |
| vpc_offs_list = VpcOffering.list(self.userapiclient, isdefault="true", name='Default VPC offering') | |
| if vpc_offs_list is None: | |
| self.fail("Default VPC offerings not found") | |
| else: | |
| vpc_offs = vpc_offs_list[0] | |
| # List VPCs for newly created user | |
| vpc_list = VPC.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"] | |
| ) | |
| # No VPCs should be present for newly created user | |
| status = validateList(vpc_list) | |
| self.assertEqual(FAIL, status[0], "VPCs found for newly created user") | |
| vpc_count_before = 0 | |
| vpc_1 = VPC.create( | |
| self.userapiclient, | |
| self.test_data["vpc_network_domain"], | |
| vpcofferingid=vpc_offs.id, | |
| zoneid=self.zone.id, | |
| ) | |
| self.assertIsNotNone(vpc_1, "VPC is not created") | |
| self.cleanup.append(vpc_1) | |
| # List VPCs | |
| vpc_list = VPC.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"] | |
| ) | |
| status = validateList(vpc_list) | |
| self.assertEqual(PASS, status[0], "VPC is not created") | |
| self.assertEqual( | |
| vpc_count_before + 1, | |
| len(vpc_list), | |
| "VPC is not created" | |
| ) | |
| return | |
| # was tags=["advanced"] | |
| @attr(tags=["TODO"], required_hardware="true") | |
| def test_05_list_network_offerings_with_and_without_vpc(self): | |
| """ | |
| @Desc: Test list network offerings for vpc true and false parameters | |
| @Steps | |
| Step1 : List network offering | |
| Step2 : Create network offering with default setting of vpc = false | |
| Step3 : List network offering | |
| Step4 : Verify that count is incremented by 1 | |
| Step5 : List network offering with additional parameter of | |
| vpc = true | |
| Step6 : Verify that its count is same as step 1 | |
| Step7 : List network offering with additional parameter of | |
| vpc = false | |
| Step8 : Verify that its count is same as step 3 | |
| """ | |
| # List all network offering | |
| network_offering_before_count = NetworkOffering.list( | |
| self.userapiclient) | |
| status = validateList(network_offering_before_count) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Default network offering not present") | |
| # List network offering for vpc = true | |
| network_offering_vpc_true_before_count = NetworkOffering.list( | |
| self.userapiclient, | |
| forvpc="true", | |
| zoneid=self.zone.id, | |
| guestiptype=self.test_data["network_offering_vlan"]["guestiptype"], | |
| supportedServices="SourceNat", | |
| specifyvlan=self.test_data["network_offering_vlan"]["specifyvlan"], | |
| state="Enabled" | |
| ) | |
| status = validateList(network_offering_vpc_true_before_count) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Default network offering not present for vpc = true") | |
| # List network offering | |
| network_offering_vpc_false_before_count = NetworkOffering.list( | |
| self.userapiclient, | |
| forvpc="false", | |
| zoneid=self.zone.id, | |
| guestiptype=self.test_data["network_offering_vlan"]["guestiptype"], | |
| supportedServices="SourceNat", | |
| specifyvlan=self.test_data["network_offering_vlan"]["specifyvlan"], | |
| state="Enabled" | |
| ) | |
| status = validateList(network_offering_vpc_false_before_count) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Default network offering not present for vpc = false") | |
| # Create network Offering | |
| network_offering = NetworkOffering.create( | |
| self.apiClient, | |
| self.test_data["network_offering_vlan"], | |
| ) | |
| self.cleanup.append(network_offering) | |
| self.assertIsNotNone( | |
| network_offering, | |
| "Network offering is not created") | |
| # Enable Network offering | |
| network_offering.update(self.apiClient, state='Enabled') | |
| # List network offering | |
| network_offering_after_count = NetworkOffering.list(self.userapiclient) | |
| status = validateList(network_offering_after_count) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Network Offering list results in null") | |
| # Verify that count is incremented by 1 | |
| self.assertEqual( | |
| len(network_offering_before_count) + 1, | |
| len(network_offering_after_count), | |
| "Network offering is not created" | |
| ) | |
| # List network offering with additional parameter of vpc = true | |
| network_offering_vpc_true_after_count = NetworkOffering.list( | |
| self.userapiclient, | |
| forvpc="true", | |
| zoneid=self.zone.id, | |
| guestiptype=self.test_data["network_offering_vlan"]["guestiptype"], | |
| supportedServices="SourceNat", | |
| specifyvlan=self.test_data["network_offering_vlan"]["specifyvlan"], | |
| state="Enabled" | |
| ) | |
| status = validateList(network_offering_vpc_true_after_count) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Network Offering list results in null") | |
| # Verify that its count is same as step 1 | |
| self.assertEqual( | |
| len(network_offering_vpc_true_before_count), | |
| len(network_offering_vpc_true_after_count), | |
| "Default Network offering is created with vpc as true" | |
| ) | |
| # List network offering with additional parameter of vpc = false | |
| network_offering_vpc_false_after_count = NetworkOffering.list( | |
| self.userapiclient, | |
| forvpc="false", | |
| zoneid=self.zone.id, | |
| guestiptype=self.test_data["network_offering_vlan"]["guestiptype"], | |
| supportedServices="SourceNat", | |
| specifyvlan=self.test_data["network_offering_vlan"]["specifyvlan"], | |
| state="Enabled" | |
| ) | |
| status = validateList(network_offering_vpc_false_after_count) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Network Offering list results in null") | |
| # Verify that its count is same as step 3 | |
| self.assertEqual( | |
| len(network_offering_vpc_false_before_count) + 1, | |
| len(network_offering_vpc_false_after_count), | |
| "Default Network offering is not created with vpc as false" | |
| ) | |
| return | |
| # @attr(tags=["advanced"], required_hardware="true") | |
| @attr(tags=["TODO"], required_hardware="true") | |
| def test_06_create_network_in_vpc(self): | |
| """ | |
| @Desc: Test create network in vpc and verify VPC name | |
| @Steps | |
| Step1 : List VPC Offering | |
| Step2 : List VPCs for newly created user | |
| Step3 : Create VPC | |
| Step4 : List VPC and verify that count is increased by 1 | |
| Step5 : Create network | |
| Step6 : List VPCs for specific network created in vpc | |
| Step7 : Verify vpc name matches for newly created vpc name | |
| and name from vpc list | |
| """ | |
| if self.hypervisor.lower() in ['hyperv']: | |
| raise unittest.SkipTest("This feature is not supported on existing hypervisor. Hence, skipping the test") | |
| # List VPC Offering | |
| vpc_offs_list = VpcOffering.list(self.userapiclient, isdefault="true", name='Default VPC offering') | |
| if vpc_offs_list is None: | |
| self.fail("Default VPC offerings not found") | |
| else: | |
| vpc_offs = vpc_offs_list[0] | |
| # List VPCs for newly created user | |
| vpc_list = VPC.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"] | |
| ) | |
| # No VPCs should be present for newly created user | |
| status = validateList(vpc_list) | |
| self.assertEqual(FAIL, status[0], "VPCs found for newly created user") | |
| vpc_count_before = 0 | |
| vpc_1 = VPC.create( | |
| self.userapiclient, | |
| self.test_data["vpc"], | |
| vpcofferingid=vpc_offs.id, | |
| zoneid=self.zone.id, | |
| ) | |
| self.assertIsNotNone(vpc_1, "VPC is not created") | |
| self.cleanup.append(vpc_1) | |
| # List VPCs | |
| vpc_list = VPC.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"] | |
| ) | |
| status = validateList(vpc_list) | |
| self.assertEqual(PASS, status[0], "VPC is not created") | |
| self.assertEqual( | |
| vpc_count_before + 1, | |
| len(vpc_list), | |
| "VPC is not created" | |
| ) | |
| # Listing the networks for a user | |
| list_networks_before = Network.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| type="Isolated") | |
| # Verifying listed networks for account created at class level | |
| self.assertIsNotNone( | |
| list_networks_before, | |
| "Network create failed at class level") | |
| # List network offering for vpc = true | |
| network_offering_vpc_true_list = NetworkOffering.list( | |
| self.userapiclient, | |
| forvpc="true", | |
| zoneid=self.zone.id, | |
| guestiptype=self.test_data["network_offering_vlan"]["guestiptype"], | |
| supportedServices="SourceNat", | |
| specifyvlan=self.test_data["network_offering_vlan"]["specifyvlan"], | |
| state="Enabled" | |
| ) | |
| status = validateList(network_offering_vpc_true_list) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Default network offering not present for vpc = true") | |
| # Listing networks in VPC | |
| list_networks_in_vpc = Network.list(self.userapiclient, | |
| vpcid=vpc_1.id, | |
| type="Isolated" | |
| ) | |
| self.assertIsNone( | |
| list_networks_in_vpc, | |
| "Networks found for newly created VPC") | |
| # If number of networks is 1, then creating network | |
| if len(list_networks_before) == 1: | |
| network_created = Network.create( | |
| self.userapiclient, | |
| self.test_data["network_without_acl"], | |
| networkofferingid=network_offering_vpc_true_list[0].id, | |
| vpcid=vpc_1.id, | |
| gateway=self.test_data["ntwk"]["gateway"], | |
| netmask=self.test_data["ntwk"]["netmask"], | |
| domainid=self.domain.id, | |
| accountid=self.account.name, | |
| ) | |
| self.assertIsNotNone( | |
| network_created, | |
| "Network is not created" | |
| ) | |
| self.cleanup.append(network_created) | |
| # Creating expected and actual values dictionaries | |
| expected_dict = { | |
| "id": self.test_data["network_without_acl"]["zoneid"], | |
| "name": self.test_data["network_without_acl"]["name"], | |
| } | |
| actual_dict = { | |
| "id": network_created.zoneid, | |
| "name": network_created.name, | |
| } | |
| network_status = self.__verify_values( | |
| expected_dict, | |
| actual_dict | |
| ) | |
| self.assertEqual( | |
| True, | |
| network_status, | |
| "Listed network details are not as expected" | |
| ) | |
| else: | |
| self.assertEqual( | |
| len(list_networks_before), | |
| 1, | |
| "more than 1 network created at class level" | |
| ) | |
| # Listing the networks | |
| list_networks_after = Network.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| type="Isolated") | |
| status = validateList(list_networks_after) | |
| self.assertEqual(PASS, status[0], "No networks found using list call") | |
| # Asserting for the length of the networks | |
| self.assertEqual( | |
| 2, | |
| len(list_networks_after), | |
| "Number of networks created is not matching expected" | |
| ) | |
| # Listing networks in VPC after creation of network | |
| list_networks_in_vpc = Network.list(self.userapiclient, | |
| vpcid=vpc_1.id, | |
| type="Isolated" | |
| ) | |
| status = validateList(list_networks_in_vpc) | |
| self.assertEqual(PASS, status[0], "No networks found in vpc") | |
| # Asserting for the length of the networks | |
| self.assertEqual( | |
| 1, | |
| len(list_networks_in_vpc), | |
| "Number of networks created in vpc is not matching expected" | |
| ) | |
| # List VPCs for specific network created in vpc | |
| vpc_list = VPC.list( | |
| self.userapiclient, | |
| id=network_created.vpcid | |
| ) | |
| # verify no vpc is present for newly created user | |
| status = validateList(vpc_list) | |
| self.assertEqual(PASS, status[0], "VPCs not found.") | |
| # verify vpc name matches for newly created vpc name and vpc list name | |
| self.assertEqual( | |
| vpc_1.name, | |
| vpc_list[0].name, | |
| "VPC names not matching" | |
| ) | |
| return | |
| # was tags=["advanced"] | |
| @attr(tags=["TODO"], required_hardware="true") | |
| def test_07_create_delete_network(self): | |
| """ | |
| @Desc: Test delete network | |
| @Steps | |
| Step1 : Create Network | |
| Step2 : Verify Network is created | |
| Step3 : Delete Network | |
| Step4 : Verify network is deleted | |
| """ | |
| # Listing the networks for a user | |
| list_networks_before = Network.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| type="Isolated") | |
| # Verifying listed networks for account created at class level | |
| self.assertIsNotNone( | |
| list_networks_before, | |
| "Network create failed at class level") | |
| # List network offering for vpc = false | |
| network_offering_vpc_false_list = NetworkOffering.list( | |
| self.userapiclient, | |
| forvpc="false", | |
| zoneid=self.zone.id, | |
| guestiptype=self.test_data["network_offering_vlan"]["guestiptype"], | |
| supportedServices="SourceNat", | |
| specifyvlan=self.test_data["network_offering_vlan"]["specifyvlan"], | |
| state="Enabled" | |
| ) | |
| status = validateList(network_offering_vpc_false_list) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Default network offering not present for vpc = false") | |
| # If number of networks is 1, then creating network | |
| if len(list_networks_before) == 1: | |
| network_created = Network.create( | |
| self.userapiclient, | |
| self.test_data["network_without_acl"], | |
| networkofferingid=network_offering_vpc_false_list[0].id, | |
| ) | |
| self.assertIsNotNone( | |
| network_created, | |
| "Network is not created" | |
| ) | |
| # Creating expected and actual values dictionaries | |
| expected_dict = { | |
| "id": self.test_data["network_without_acl"]["zoneid"], | |
| "name": self.test_data["network_without_acl"]["name"], | |
| } | |
| actual_dict = { | |
| "id": network_created.zoneid, | |
| "name": network_created.name, | |
| } | |
| network_status = self.__verify_values( | |
| expected_dict, | |
| actual_dict | |
| ) | |
| self.assertEqual( | |
| True, | |
| network_status, | |
| "Listed network details are not as expected" | |
| ) | |
| else: | |
| self.assertEqual( | |
| len(list_networks_before), | |
| 1, | |
| "more than 1 network created at class level" | |
| ) | |
| # Listing the networks | |
| list_networks_after = Network.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| type="Isolated" | |
| ) | |
| status = validateList(list_networks_after) | |
| self.assertEqual(PASS, status[0], "No networks found using list call") | |
| # Asserting for the length of the networks | |
| self.assertEqual( | |
| 2, | |
| len(list_networks_after), | |
| "Number of networks created is not matching expected" | |
| ) | |
| # Delete Network | |
| Network.delete(network_created, self.userapiclient) | |
| # List Networks | |
| list_networks_after_delete = Network.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| type="Isolated" | |
| ) | |
| status = validateList(list_networks_after_delete) | |
| self.assertEqual(PASS, status[0], "No networks found using list call") | |
| self.assertEqual( | |
| 1, | |
| len(list_networks_after_delete), | |
| "Number of networks created is not matching expected" | |
| ) | |
| # Verify deleted network is not present | |
| self.assertNotEqual( | |
| network_created.id, | |
| list_networks_after_delete[0].id, | |
| "Deleted network present" | |
| ) | |
| return | |
| # was tags=["advanced"] | |
| @attr(tags=["TODO"], required_hardware="true") | |
| def test_08_update_network(self): | |
| """ | |
| @Desc: Test update network | |
| @Steps | |
| Step1 : Create Network | |
| Step2 : Verify Network is created | |
| Step3 : Update Network name, display text and network domain | |
| Step4 : Verify network is updated | |
| """ | |
| # Listing the networks for a user | |
| list_networks_before = Network.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| type="Isolated") | |
| # Verifying listed networks for account created at class level | |
| self.assertIsNotNone( | |
| list_networks_before, | |
| "Network create failed at class level") | |
| self.assertEqual( | |
| 1, | |
| len(list_networks_before), | |
| "More than 1 network created at class level" | |
| ) | |
| # List network offering for vpc = false | |
| network_offering_vpc_false_list = NetworkOffering.list( | |
| self.userapiclient, | |
| forvpc="false", | |
| zoneid=self.zone.id, | |
| guestiptype=self.test_data["network_offering_vlan"]["guestiptype"], | |
| supportedServices="SourceNat", | |
| specifyvlan=self.test_data["network_offering_vlan"]["specifyvlan"], | |
| state="Enabled" | |
| ) | |
| status = validateList(network_offering_vpc_false_list) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Default network offering not present for vpc = false") | |
| # creating network | |
| network_created = Network.create( | |
| self.userapiclient, | |
| self.test_data["network_without_acl"], | |
| networkofferingid=network_offering_vpc_false_list[0].id, | |
| ) | |
| self.assertIsNotNone( | |
| network_created, | |
| "Network is not created" | |
| ) | |
| self.cleanup.append(network_created) | |
| # Creating expected and actual values dictionaries | |
| expected_dict = { | |
| "id": self.test_data["network_without_acl"]["zoneid"], | |
| "name": self.test_data["network_without_acl"]["name"], | |
| } | |
| actual_dict = { | |
| "id": network_created.zoneid, | |
| "name": network_created.name, | |
| } | |
| network_status = self.__verify_values( | |
| expected_dict, | |
| actual_dict | |
| ) | |
| self.assertEqual( | |
| True, | |
| network_status, | |
| "Listed network details are not as expected" | |
| ) | |
| # Listing the networks | |
| list_networks_after = Network.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| type="Isolated") | |
| status = validateList(list_networks_after) | |
| self.assertEqual(PASS, status[0], "No networks found using list call") | |
| # Asserting for the length of the networks | |
| self.assertEqual( | |
| 2, | |
| len(list_networks_after), | |
| "Number of networks created is not matching expected" | |
| ) | |
| # Update Network | |
| network_updated = Network.update(network_created, | |
| self.userapiclient, | |
| name="NewNetworkName", | |
| displaytext="NewNetworkDisplayText", | |
| networkdomain="cs13cloud.internal.new" | |
| ) | |
| # List Networks | |
| list_networks_after_update = Network.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| type="Isolated") | |
| status = validateList(list_networks_after_update) | |
| self.assertEqual(PASS, status[0], "No networks found using list call") | |
| self.assertEqual( | |
| 2, | |
| len(list_networks_after_update), | |
| "Number of networks created is not matching expected" | |
| ) | |
| # Creating expected and actual values dictionaries | |
| expected_dict = { | |
| "name": "NewNetworkName", | |
| "displaytext": "NewNetworkDisplayText", | |
| "networkdomain": "cs13cloud.internal.new" | |
| } | |
| actual_dict = { | |
| "name": network_updated.name, | |
| "displaytext": network_updated.displaytext, | |
| "networkdomain": network_updated.networkdomain | |
| } | |
| network_status = self.__verify_values( | |
| expected_dict, | |
| actual_dict | |
| ) | |
| self.assertEqual( | |
| True, | |
| network_status, | |
| "Listed network details are not as expected" | |
| ) | |
| return | |
| @attr(tags=["advanced"], required_hardware="true") | |
| def test_09_list_virtual_machines_single_network(self): | |
| """ | |
| @Desc: Test update network | |
| @Steps | |
| Step1 : Create Network | |
| Step2 : Verify Network is created | |
| Step3 : Create Virtual Machine as per page size | |
| Step4 : Verify list Virtual machines and pagination | |
| """ | |
| # Listing the networks for a user | |
| list_networks_before = Network.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| type="Isolated") | |
| # Verifying listed networks for account created at class level | |
| self.assertIsNotNone( | |
| list_networks_before, | |
| "Network create failed at class level") | |
| # Create Virtual Machine | |
| # Listing all the instances for a user | |
| list_instances_before = VirtualMachine.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"]) | |
| # Verifying listed instances for account created at class level | |
| self.assertIsNone( | |
| list_instances_before, | |
| "Virtual Machine already exists for newly created user" | |
| ) | |
| # If number of instances are less than (pagesize 1), then creating | |
| # them | |
| for i in range(0, (self.test_data["pagesize"] + 1)): | |
| vm_created = VirtualMachine.create( | |
| self.userapiclient, | |
| self.test_data["virtual_machine"], | |
| accountid=self.account.name, | |
| domainid=self.account.domainid, | |
| networkids=list_networks_before[0].id, | |
| serviceofferingid=self.service_offering.id, | |
| ) | |
| self.assertIsNotNone( | |
| vm_created, | |
| "VM creation failed" | |
| ) | |
| if(i < (self.test_data["pagesize"])): | |
| self.cleanup.append(vm_created) | |
| self.assertEqual( | |
| self.test_data["virtual_machine"]["displayname"], | |
| vm_created.displayname, | |
| "Newly created VM name and the test data VM\ | |
| name are not matching") | |
| # Listing all the instances again after creating VM's | |
| list_instances_after = VirtualMachine.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| networkid=list_networks_before[0].id | |
| ) | |
| status = validateList(list_instances_after) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Listing of instances after creation failed" | |
| ) | |
| # Verifying the length of the instances is (page size 1) | |
| self.assertEqual( | |
| len(list_instances_after), | |
| (self.test_data["pagesize"] + 1), | |
| "Number of instances created is not matching as expected" | |
| ) | |
| # Listing all the volumes in page1 | |
| list_instances_page1 = VirtualMachine.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| page=1, | |
| pagesize=self.test_data["pagesize"], | |
| networkid=list_networks_before[0].id | |
| ) | |
| status = validateList(list_instances_page1) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Listing of instances in page1 failed" | |
| ) | |
| # Verifying that the length of the instances in page 1 is (page size) | |
| self.assertEqual( | |
| self.test_data["pagesize"], | |
| len(list_instances_page1), | |
| "List VM response is not matching with the\ | |
| page size length for page 1") | |
| # Listing all the VM's in page2 | |
| list_instances_page2 = VirtualMachine.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| page=2, | |
| pagesize=self.test_data["pagesize"], | |
| networkid=list_networks_before[0].id | |
| ) | |
| status = validateList(list_instances_page2) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Listing of instances in page2 failed" | |
| ) | |
| # Verifying that the length of the VM's in page 2 is 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_instances_page2), | |
| "List VM response is not matching with the\ | |
| page size length for page 2" | |
| ) | |
| # Deleting a single VM | |
| VirtualMachine.delete(vm_created, self.apiClient) | |
| # Listing the VM's in page 2 | |
| list_instance_response = VirtualMachine.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| page=2, | |
| pagesize=self.test_data["pagesize"], | |
| networkid=list_networks_before[0].id | |
| ) | |
| # verifying that VM does not exists on page 2 | |
| self.assertEqual( | |
| list_instance_response, | |
| None, | |
| "VM was not deleted" | |
| ) | |
| return | |
| # was tags=["advanced"] | |
| @attr(tags=["TODO"], required_hardware="true") | |
| def test_10_list_networks_in_vpc(self): | |
| """ | |
| @Desc: Test list networks in vpc and verify VPC name | |
| @Steps | |
| Step1 : List VPC Offering | |
| Step2 : List VPCs for newly created user | |
| Step3 : Create VPC | |
| Step4 : List VPC and verify that count is increased by 1 | |
| Step5 : Create network | |
| Step6 : List Networks in created vpc | |
| Step7 : Verify network name matches for newly created network name | |
| and name from network list | |
| """ | |
| if self.hypervisor.lower() in ['hyperv']: | |
| raise unittest.SkipTest("This feature is not supported on existing hypervisor. Hence, skipping the test") | |
| # List VPC Offering | |
| vpc_offs_list = VpcOffering.list(self.userapiclient, isdefault="true", name='Default VPC offering') | |
| if vpc_offs_list is None: | |
| self.fail("Default VPC offerings not found") | |
| else: | |
| vpc_offs = vpc_offs_list[0] | |
| # List VPCs for newly created user | |
| vpc_list = VPC.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"] | |
| ) | |
| # No VPCs should be present for newly created user | |
| status = validateList(vpc_list) | |
| self.assertEqual(FAIL, status[0], "VPCs found for newly created user") | |
| vpc_count_before = 0 | |
| vpc_1 = VPC.create( | |
| self.userapiclient, | |
| self.test_data["vpc"], | |
| vpcofferingid=vpc_offs.id, | |
| zoneid=self.zone.id, | |
| ) | |
| self.assertIsNotNone(vpc_1, "VPC is not created") | |
| self.cleanup.append(vpc_1) | |
| # List VPCs | |
| vpc_list = VPC.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"] | |
| ) | |
| status = validateList(vpc_list) | |
| self.assertEqual(PASS, status[0], "VPC is not created") | |
| self.assertEqual( | |
| vpc_count_before + 1, | |
| len(vpc_list), | |
| "VPC is not created" | |
| ) | |
| # Listing the networks for a user | |
| list_networks_before = Network.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| type="Isolated") | |
| # Verifying listed networks for account created at class level | |
| self.assertIsNotNone( | |
| list_networks_before, | |
| "Network create failed at class level") | |
| # List network offering for vpc = true | |
| network_offering_vpc_true_list = NetworkOffering.list( | |
| self.userapiclient, | |
| forvpc="true", | |
| zoneid=self.zone.id, | |
| guestiptype=self.test_data["network_offering_vlan"]["guestiptype"], | |
| supportedServices="SourceNat", | |
| specifyvlan=self.test_data["network_offering_vlan"]["specifyvlan"], | |
| state="Enabled" | |
| ) | |
| status = validateList(network_offering_vpc_true_list) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Default network offering not present for vpc = true") | |
| # If number of networks is 1, then creating network | |
| if len(list_networks_before) == 1: | |
| network_created = Network.create( | |
| self.userapiclient, | |
| self.test_data["network_without_acl"], | |
| networkofferingid=network_offering_vpc_true_list[0].id, | |
| vpcid=vpc_1.id, | |
| gateway=self.test_data["ntwk"]["gateway"], | |
| netmask=self.test_data["ntwk"]["netmask"] | |
| ) | |
| self.assertIsNotNone( | |
| network_created, | |
| "Network is not created" | |
| ) | |
| self.cleanup.append(network_created) | |
| # Creating expected and actual values dictionaries | |
| expected_dict = { | |
| "id": self.test_data["network_without_acl"]["zoneid"], | |
| "name": self.test_data["network_without_acl"]["name"], | |
| } | |
| actual_dict = { | |
| "id": network_created.zoneid, | |
| "name": network_created.name, | |
| } | |
| network_status = self.__verify_values( | |
| expected_dict, | |
| actual_dict | |
| ) | |
| self.assertEqual( | |
| True, | |
| network_status, | |
| "Listed network details are not as expected" | |
| ) | |
| else: | |
| self.assertEqual( | |
| len(list_networks_before), | |
| 1, | |
| "more than 1 network created at class level" | |
| ) | |
| # Listing the networks | |
| list_networks_after = Network.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| type="Isolated") | |
| status = validateList(list_networks_after) | |
| self.assertEqual(PASS, status[0], "No networks found using list call") | |
| # Asserting for the length of the networks | |
| self.assertEqual( | |
| 2, | |
| len(list_networks_after), | |
| "Number of networks created is not matching expected" | |
| ) | |
| # Listing the networks | |
| list_networks_in_vpc = Network.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| vpcid=vpc_1.id, | |
| type="Isolated" | |
| ) | |
| status = validateList(list_networks_in_vpc) | |
| self.assertEqual(PASS, status[0], "No networks found using list call") | |
| # Verify network name matches for newly created network name and name | |
| # from network list | |
| self.assertEqual( | |
| network_created.name, | |
| list_networks_in_vpc[0].name, | |
| "Network names not matching" | |
| ) | |
| return | |
| # @attr(tags=["advanced"], required_hardware="true") | |
| @attr(tags=["TODO"], required_hardware="true") | |
| def test_11_update_vpc(self): | |
| """ | |
| @Desc: Test create vpc with network domain as parameter | |
| @Steps | |
| Step1 : List VPC Offering | |
| Step2 : List VPCs for newly created user | |
| Step3 : Create VPCs | |
| Step4 : Verify count of VPCs created | |
| Step5 : Update VPC name and display text | |
| Step6 : Verify name and display text is updated | |
| """ | |
| if self.hypervisor.lower() in ['hyperv']: | |
| raise unittest.SkipTest("This feature is not supported on existing hypervisor. Hence, skipping the test") | |
| # List VPC Offering | |
| vpc_offs_list = VpcOffering.list(self.userapiclient, isdefault="true", name='Default VPC offering') | |
| if vpc_offs_list is None: | |
| self.fail("Default VPC offerings not found") | |
| else: | |
| vpc_offs = vpc_offs_list[0] | |
| # List VPCs | |
| vpc_list = VPC.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"] | |
| ) | |
| # verify no vpc is present for newly created user | |
| status = validateList(vpc_list) | |
| self.assertEqual(FAIL, status[0], "VPCs found for newly created user") | |
| vpc_1 = VPC.create( | |
| self.userapiclient, | |
| self.test_data["vpc"], | |
| vpcofferingid=vpc_offs.id, | |
| zoneid=self.zone.id, | |
| ) | |
| self.assertIsNotNone(vpc_1, "VPC is not created") | |
| self.cleanup.append(vpc_1) | |
| # verify vpc is created and not none | |
| # Verify VPC name with test data | |
| self.assertNotEqual( | |
| -1, | |
| vpc_1.name.find(self.test_data["vpc"]["name"]), | |
| "VPC name not matched" | |
| ) | |
| # verify zone with test data | |
| self.assertEqual( | |
| self.zone.id, | |
| vpc_1.zoneid, | |
| "Zone is not matching in the vpc created" | |
| ) | |
| # Asserting for the length of the VPCs | |
| vpc_count_after = VPC.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"]) | |
| status = validateList(vpc_count_after) | |
| self.assertEqual(PASS, status[0], "VPC list count is null") | |
| self.assertEqual( | |
| 1, | |
| len(vpc_count_after), | |
| "Number of VPCs created is not matching expected" | |
| ) | |
| # Update VPC | |
| vpc_updated = VPC.update( | |
| vpc_1, | |
| self.userapiclient, | |
| name="NewVPCName", | |
| displaytext="NewVPCDisplayText", | |
| ) | |
| # List Networks | |
| list_vpcs_after_update = VPC.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"] | |
| ) | |
| status = validateList(list_vpcs_after_update) | |
| self.assertEqual(PASS, status[0], "No vpcs found using list call") | |
| self.assertEqual( | |
| 1, | |
| len(list_vpcs_after_update), | |
| "Number of vpcs created is not matching expected" | |
| ) | |
| # Creating expected and actual values dictionaries | |
| expected_dict = { | |
| "name": "NewVPCName", | |
| "displaytext": "NewVPCDisplayText", | |
| } | |
| actual_dict = { | |
| "name": vpc_updated.name, | |
| "displaytext": vpc_updated.displaytext, | |
| } | |
| vpc_status = self.__verify_values( | |
| expected_dict, | |
| actual_dict | |
| ) | |
| self.assertEqual( | |
| True, | |
| vpc_status, | |
| "Listed vpc details are not as expected" | |
| ) | |
| return | |
| # was tags=["advanced"] | |
| @attr(tags=["TODO"], required_hardware="true") | |
| def test_12_list_create_delete_networkACL(self): | |
| """ | |
| @Desc: Test create network in vpc and verify VPC name | |
| @Steps | |
| Step1 : List VPC Offering | |
| Step2 : List VPCs for newly created user | |
| Step3 : Create VPC | |
| Step4 : List VPC and verify that count is increased by 1 | |
| Step5 : Create network | |
| Step6 : Verify network is created | |
| Step7 : List Network ACLs | |
| Step8 : Create Network ACL | |
| Step9 : Verify NetworkACL is created | |
| Step10 : Delete NetworkACL | |
| Step11 : Verify NetworkACL is deleted | |
| """ | |
| if self.hypervisor.lower() in ['hyperv']: | |
| raise unittest.SkipTest("This feature is not supported on existing hypervisor. Hence, skipping the test") | |
| # List VPC Offering | |
| vpc_offs_list = VpcOffering.list(self.userapiclient, isdefault="true", name='Default VPC offering') | |
| if vpc_offs_list is None: | |
| self.fail("Default VPC offerings not found") | |
| else: | |
| vpc_offs = vpc_offs_list[0] | |
| # List VPCs for newly created user | |
| vpc_list = VPC.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"] | |
| ) | |
| # No VPCs should be present for newly created user | |
| status = validateList(vpc_list) | |
| self.assertEqual(FAIL, status[0], "VPCs found for newly created user") | |
| vpc_count_before = 0 | |
| vpc_1 = VPC.create( | |
| self.userapiclient, | |
| self.test_data["vpc"], | |
| vpcofferingid=vpc_offs.id, | |
| zoneid=self.zone.id, | |
| ) | |
| self.cleanup.append(vpc_1) | |
| self.assertIsNotNone(vpc_1, "VPC is not created") | |
| # List VPCs | |
| vpc_list = VPC.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"] | |
| ) | |
| status = validateList(vpc_list) | |
| self.assertEqual(PASS, status[0], "VPC is not created") | |
| self.assertEqual( | |
| vpc_count_before + 1, | |
| len(vpc_list), | |
| "VPC is not created" | |
| ) | |
| # Listing the networks for a user | |
| list_networks_before = Network.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| type="Isolated" | |
| ) | |
| # Verifying listed networks for account created at class level | |
| self.assertIsNotNone( | |
| list_networks_before, | |
| "Network create failed at class level") | |
| # List network offering for vpc = true | |
| network_offering_vpc_true_list = NetworkOffering.list( | |
| self.userapiclient, | |
| forvpc="true", | |
| zoneid=self.zone.id, | |
| guestiptype=self.test_data["network_offering_vlan"]["guestiptype"], | |
| supportedServices="SourceNat", | |
| specifyvlan=self.test_data["network_offering_vlan"]["specifyvlan"], | |
| state="Enabled" | |
| ) | |
| status = validateList(network_offering_vpc_true_list) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Default network offering not present for vpc = true") | |
| # Listing networks in VPC | |
| list_networks_in_vpc = Network.list(self.userapiclient, | |
| vpcid=vpc_1.id, | |
| type="Isolated" | |
| ) | |
| self.assertIsNone( | |
| list_networks_in_vpc, | |
| "Networks found for newly created VPC") | |
| # If number of networks is 1, then creating network | |
| if len(list_networks_before) == 1: | |
| network_created = Network.create( | |
| self.userapiclient, | |
| self.test_data["network_without_acl"], | |
| networkofferingid=network_offering_vpc_true_list[0].id, | |
| vpcid=vpc_1.id, | |
| gateway=self.test_data["ntwk"]["gateway"], | |
| netmask=self.test_data["ntwk"]["netmask"], | |
| domainid=self.domain.id, | |
| accountid=self.account.name, | |
| ) | |
| self.cleanup.append(network_created) | |
| self.assertIsNotNone( | |
| network_created, | |
| "Network is not created" | |
| ) | |
| # Creating expected and actual values dictionaries | |
| expected_dict = { | |
| "id": self.test_data["network_without_acl"]["zoneid"], | |
| "name": self.test_data["network_without_acl"]["name"], | |
| } | |
| actual_dict = { | |
| "id": network_created.zoneid, | |
| "name": network_created.name, | |
| } | |
| network_status = self.__verify_values( | |
| expected_dict, | |
| actual_dict | |
| ) | |
| self.assertEqual( | |
| True, | |
| network_status, | |
| "Listed network details are not as expected" | |
| ) | |
| else: | |
| self.assertEqual( | |
| len(list_networks_before), | |
| 1, | |
| "more than 1 network created at class level" | |
| ) | |
| # Listing the networks | |
| list_networks_after = Network.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| type="Isolated") | |
| status = validateList(list_networks_after) | |
| self.assertEqual(PASS, status[0], "No networks found using list call") | |
| # Asserting for the length of the networks | |
| self.assertEqual( | |
| 2, | |
| len(list_networks_after), | |
| "Number of networks created is not matching expected" | |
| ) | |
| # Listing networks in VPC after creation of network | |
| list_networks_in_vpc = Network.list(self.userapiclient, | |
| vpcid=vpc_1.id, | |
| type="Isolated" | |
| ) | |
| status = validateList(list_networks_in_vpc) | |
| self.assertEqual(PASS, status[0], "No networks found in vpc") | |
| # Asserting for the length of the networks | |
| self.assertEqual( | |
| 1, | |
| len(list_networks_in_vpc), | |
| "Number of networks created in vpc is not matching expected" | |
| ) | |
| # List VPCs for specific network created in vpc | |
| vpc_list = VPC.list( | |
| self.userapiclient, | |
| id=network_created.vpcid | |
| ) | |
| # List Network ACLs | |
| list_network_acl = NetworkACL.list( | |
| self.userapiclient, | |
| networkid=network_created.id | |
| ) | |
| self.assertIsNone( | |
| list_network_acl, | |
| "ACL list is not empty for newly created network") | |
| # Create NetworkACL | |
| network_acl_created = NetworkACL.create( | |
| self.userapiclient, | |
| self.test_data["network_acl_rule"], | |
| networkid=network_created.id | |
| ) | |
| self.assertIsNotNone( | |
| network_acl_created, | |
| "NetworkACL is not created" | |
| ) | |
| # List Network ACL | |
| list_network_acl = NetworkACL.list( | |
| self.userapiclient, | |
| networkid=network_created.id | |
| ) | |
| status = validateList(list_network_acl) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "No networks acls found after creating") | |
| # Asserting for the length of the networks | |
| self.assertEqual( | |
| 1, | |
| len(list_network_acl), | |
| "Number of networks acls reated is not matching expected" | |
| ) | |
| # Delete Network ACL | |
| NetworkACL.delete(network_acl_created, self.userapiclient) | |
| # List Network ACL | |
| list_network_acl = NetworkACL.list( | |
| self.userapiclient, | |
| networkid=network_created.id | |
| ) | |
| self.assertIsNone( | |
| list_network_acl, | |
| "ACL list is not empty for newly created network") | |
| return | |
| class TestNetworks_2(cloudstackTestCase): | |
| @classmethod | |
| def setUpClass(cls): | |
| try: | |
| cls._cleanup = [] | |
| cls.testClient = super(TestNetworks_2, cls).getClsTestClient() | |
| cls.api_client = cls.testClient.getApiClient() | |
| cls.test_data = cls.testClient.getParsedTestDataConfig() | |
| cls.hypervisor = cls.testClient.getHypervisorInfo() | |
| # Get Domain, Zone, Template | |
| cls.domain = get_domain(cls.api_client) | |
| cls.zone = get_zone( | |
| cls.api_client, | |
| cls.testClient.getZoneForTests()) | |
| cls.template = get_template( | |
| cls.api_client, | |
| cls.zone.id, | |
| cls.test_data["ostype"] | |
| ) | |
| cls.test_data['mode'] = cls.zone.networktype | |
| cls.account = Account.create( | |
| cls.api_client, | |
| cls.test_data["account"], | |
| domainid=cls.domain.id | |
| ) | |
| cls._cleanup.append(cls.account) | |
| # Getting authentication for user in newly created Account | |
| cls.user = cls.account.user[0] | |
| cls.userapiclient = cls.testClient.getUserApiClient( | |
| cls.user.username, | |
| cls.domain.name) | |
| cls.vpc_offering = VpcOffering.create(cls.api_client, | |
| cls.test_data["vpc_offering"] | |
| ) | |
| cls.vpc_offering.update(cls.api_client, state='Enabled') | |
| cls._cleanup.append(cls.vpc_offering) | |
| except Exception as e: | |
| cls.tearDownClass() | |
| raise Exception("Warning: Exception in setup : %s" % e) | |
| return | |
| def setUp(self): | |
| self.apiClient = self.testClient.getApiClient() | |
| self.cleanup = [] | |
| def tearDown(self): | |
| super(TestNetworks_2, self).tearDown() | |
| @classmethod | |
| def tearDownClass(cls): | |
| super(TestNetworks_2, cls).tearDownClass() | |
| def __verify_values(self, expected_vals, actual_vals): | |
| """ | |
| @summary: Function to verify expected and actual values | |
| Step1: Initializing return flag to True | |
| Step1: Verifying length of expected and actual dictionaries is matching | |
| If not matching returning false | |
| Step2: Listing all the keys from expected dictionary | |
| Step3: Looping through each key from step2 and verifying expected | |
| and actual dictionaries have same value | |
| If not making return flag to False | |
| Step4: returning the return flag after all the values are verified | |
| """ | |
| return_flag = True | |
| if len(expected_vals) != len(actual_vals): | |
| return False | |
| keys = list(expected_vals.keys()) | |
| for i in range(0, len(expected_vals)): | |
| exp_val = expected_vals[keys[i]] | |
| act_val = actual_vals[keys[i]] | |
| if exp_val == act_val: | |
| return_flag = return_flag and True | |
| else: | |
| return_flag = return_flag and False | |
| self.debug( | |
| "expected Value: %s, is not matching with actual value: %s" | |
| % | |
| (exp_val, act_val)) | |
| return return_flag | |
| @attr(tags=["advanced"], required_hardware="true") | |
| def test_13_list_vpc_byid(self): | |
| """ | |
| @summary: Test List VPC with Id | |
| @Steps | |
| Step1: Listing all the vpc for a user before creating a vpc | |
| Step2: Verifying no VPCs are listed | |
| Step3: Creating a vpc | |
| Step4: Listing the vpc for a user after creating a vpc | |
| Step5: Verifying the list vpc size is increased by 1 | |
| Step6: Listing the vpc by specifying vpc ID | |
| Step7: Verifying the list vpc size is 1 | |
| Step8: Verifying the details of the vpc | |
| """ | |
| if self.hypervisor.lower() in ['hyperv']: | |
| raise unittest.SkipTest("This feature is not supported on existing hypervisor. Hence, skipping the test") | |
| # Listing all the vpc's for a user | |
| list_vpc_before = VPC.list(self.userapiclient) | |
| # Verifying No VPCs are listed | |
| self.assertIsNone( | |
| list_vpc_before, | |
| "Vpc listed for newly created user" | |
| ) | |
| # Creating a vpc | |
| vpc_created = VPC.create( | |
| self.userapiclient, | |
| self.test_data["vpc"], | |
| self.vpc_offering.id, | |
| self.zone.id | |
| ) | |
| self.assertIsNotNone(vpc_created, "VPC Creation Failed") | |
| self.cleanup.append(vpc_created) | |
| # Listing the vpc for a user after creating a vpc | |
| list_vpc_after = VPC.list(self.userapiclient) | |
| status = validateList(list_vpc_after) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "list VPC not as expected" | |
| ) | |
| # Verifying the list vpc size is increased by 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_vpc_after), | |
| "list VPC not equal as expected" | |
| ) | |
| # List the vpc by specifying vpc ID | |
| list_vpc_byid = VPC.list( | |
| self.userapiclient, | |
| id=vpc_created.id, | |
| listall=self.test_data["listall"] | |
| ) | |
| status = validateList(list_vpc_byid) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "list VPC not as expected" | |
| ) | |
| # Verifying the list vpc size is 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_vpc_byid), | |
| "list VPC not equal as expected" | |
| ) | |
| # Verifying the details of the vpc | |
| expected_dict = { | |
| "cidr": self.test_data["vpc"]["cidr"], | |
| "id": vpc_created.id, | |
| "displaytext": vpc_created.displaytext, | |
| "account": self.account.name, | |
| "domain": vpc_created.domain, | |
| "domainid": self.domain.id, | |
| "name": vpc_created.name | |
| } | |
| actual_dict = { | |
| "cidr": str(list_vpc_byid[0].cidr), | |
| "id": list_vpc_byid[0].id, | |
| "displaytext": list_vpc_byid[0].displaytext, | |
| "account": list_vpc_byid[0].account, | |
| "domain": list_vpc_byid[0].domain, | |
| "domainid": list_vpc_byid[0].domainid, | |
| "name": list_vpc_byid[0].name | |
| } | |
| list_vpc_status = self.__verify_values( | |
| expected_dict, | |
| actual_dict | |
| ) | |
| self.assertEqual( | |
| True, | |
| list_vpc_status, | |
| "Listed VPC details are not as expected" | |
| ) | |
| return | |
| @attr(tags=["advanced"], required_hardware="true") | |
| def test_14_list_public_ipaddress_by_associated_networkid(self): | |
| """ | |
| @summary: Test List Public IPAddress with associatednetworkid | |
| @Steps | |
| Step1: Listing all the public ipaddresses for a user before creating | |
| a public ipaddress | |
| Step2: Verifying no Public ipaddress are listed | |
| Step3: Creating a network | |
| Step4: Associating public ipaddress for network created in step3 | |
| Step5: Listing the public ipaddress for a user after creating a | |
| public ipaddress | |
| Step6: Verifying the list public ipaddress size is increased by 1 | |
| Step7: Listing the public ipaddress by specifying associatednetworkid | |
| Step8: Verifying the list public ipaddress size is 1 | |
| Step9: Verifying the details of the public ipaddress | |
| """ | |
| # Listing all the public ipaddresses for a user | |
| list_public_ipaddress_before = PublicIPAddress.list(self.userapiclient) | |
| # Verifying No VPCs are listed | |
| self.assertIsNone( | |
| list_public_ipaddress_before, | |
| "Public ipaddresses listed for newly created user" | |
| ) | |
| # Listing Network Offerings | |
| network_offerings_list = NetworkOffering.list( | |
| self.apiClient, | |
| forvpc="false", | |
| guestiptype="Isolated", | |
| state="Enabled", | |
| supportedServices="SourceNat", | |
| zoneid=self.zone.id | |
| ) | |
| self.assertIsNotNone( | |
| network_offerings_list, | |
| "Isolated Network Offerings with sourceNat enabled are not found" | |
| ) | |
| # Creating a Network | |
| network = Network.create( | |
| self.userapiclient, | |
| self.test_data["network"], | |
| accountid=self.account.name, | |
| domainid=self.domain.id, | |
| networkofferingid=network_offerings_list[0].id, | |
| zoneid=self.zone.id | |
| ) | |
| self.assertIsNotNone( | |
| network, | |
| "Network creation failed" | |
| ) | |
| self.cleanup.append(network) | |
| # Associating public ipaddress for network created | |
| public_ipaddress_created = PublicIPAddress.create( | |
| self.userapiclient, | |
| accountid=self.account.name, | |
| zoneid=self.zone.id, | |
| domainid=self.domain.id, | |
| networkid=network.id | |
| ) | |
| self.assertIsNotNone( | |
| public_ipaddress_created, | |
| "Failed to Associate Public IpAddress for Network" | |
| ) | |
| # Listing the public ipaddress for a user after associating a public | |
| # ipaddress for network | |
| list_public_ipaddress_after = PublicIPAddress.list(self.userapiclient) | |
| status = validateList(list_public_ipaddress_after) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "list Public IPAddress not as expected" | |
| ) | |
| # Verifying the list public ipaddress size is increased by 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_public_ipaddress_after), | |
| "list Public IPAddress not equal as expected" | |
| ) | |
| # List the public ipaddress by specifying public ipaddress ID | |
| list_public_ipaddress_byid = PublicIPAddress.list( | |
| self.userapiclient, | |
| associatednetworkid=network.id, | |
| listall=self.test_data["listall"] | |
| ) | |
| status = validateList(list_public_ipaddress_byid) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "list public ipaddress not as expected" | |
| ) | |
| # Verifying the list public ipaddress size is 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_public_ipaddress_byid), | |
| "list public ipaddress not equal as expected" | |
| ) | |
| # Verifying the details of the public ipaddress | |
| expected_dict = { | |
| "account": public_ipaddress_created.ipaddress.account, | |
| "associatednetworkid": | |
| public_ipaddress_created.ipaddress.associatednetworkid, | |
| "associatednetworkname": | |
| public_ipaddress_created.ipaddress.associatednetworkname, | |
| "domainid": public_ipaddress_created.ipaddress.domainid, | |
| "forvirtualnetwork": | |
| public_ipaddress_created.ipaddress.forvirtualnetwork, | |
| "id": public_ipaddress_created.ipaddress.id, | |
| "ipaddress": public_ipaddress_created.ipaddress.ipaddress, | |
| "isportable": public_ipaddress_created.ipaddress.isportable, | |
| "issourcenat": public_ipaddress_created.ipaddress.issourcenat, | |
| "isstatisnat": public_ipaddress_created.ipaddress.isstaticnat, | |
| "issystem": public_ipaddress_created.ipaddress.issystem, | |
| "networkid": public_ipaddress_created.ipaddress.network, | |
| "physicalnetworkid": | |
| public_ipaddress_created.ipaddress.physicalnetworkid, | |
| "zoneid": public_ipaddress_created.ipaddress.zoneid} | |
| actual_dict = { | |
| "account": list_public_ipaddress_byid[0].account, | |
| "associatednetworkid": | |
| list_public_ipaddress_byid[0].associatednetworkid, | |
| "associatednetworkname": | |
| list_public_ipaddress_byid[0].associatednetworkname, | |
| "domainid": list_public_ipaddress_byid[0].domainid, | |
| "forvirtualnetwork": | |
| list_public_ipaddress_byid[0].forvirtualnetwork, | |
| "id": list_public_ipaddress_byid[0].id, | |
| "ipaddress": list_public_ipaddress_byid[0].ipaddress, | |
| "isportable": list_public_ipaddress_byid[0].isportable, | |
| "issourcenat": list_public_ipaddress_byid[0].issourcenat, | |
| "isstatisnat": list_public_ipaddress_byid[0].isstaticnat, | |
| "issystem": list_public_ipaddress_byid[0].issystem, | |
| "networkid": list_public_ipaddress_byid[0].network, | |
| "physicalnetworkid": | |
| list_public_ipaddress_byid[0].physicalnetworkid, | |
| "zoneid": list_public_ipaddress_byid[0].zoneid} | |
| list_public_ipaddress_status = self.__verify_values( | |
| expected_dict, | |
| actual_dict | |
| ) | |
| self.assertEqual( | |
| True, | |
| list_public_ipaddress_status, | |
| "Listed Public IPAddress details are not as expected" | |
| ) | |
| return | |
| @attr(tags=["advanced"], required_hardware="true") | |
| def test_15_list_privategateway_byvpcid(self): | |
| """ | |
| @summary: Test List PrivateGateway by vpcid | |
| @Steps | |
| Step1: Creating a VPC | |
| Step2: Listing all the private gateway before creating a | |
| private gateway | |
| Step3: Verifying no Private Gateway are listed | |
| Step4: Listing the Private Gateway after creating a Private Gateway | |
| Step5: Verifying the list Private Gateway size is increased by 1 | |
| Step6: Listing the Private Gateway by specifying VPCID | |
| Step7: Verifying the list Private Gateway size is 1 | |
| Step8: Verifying the details of the Private Gateway | |
| """ | |
| if self.hypervisor.lower() in ['hyperv']: | |
| raise unittest.SkipTest("This feature is not supported on existing hypervisor. Hence, skipping the test") | |
| # Creating a vpc | |
| vpc_created = VPC.create( | |
| self.userapiclient, | |
| self.test_data["vpc"], | |
| self.vpc_offering.id, | |
| self.zone.id | |
| ) | |
| self.assertIsNotNone(vpc_created, "VPC Creation Failed") | |
| self.cleanup.append(vpc_created) | |
| # Listing all the PrivateGateways | |
| list_private_gateways_before = PrivateGateway.list( | |
| self.apiClient, | |
| listall=self.test_data["listall"], | |
| vpcid=vpc_created.id | |
| ) | |
| # Verifying No PrivateGateways are listed | |
| self.assertIsNone( | |
| list_private_gateways_before, | |
| "Listed private gateways for newly created VPC " | |
| ) | |
| # Creating a Private Gateway | |
| private_gateway_created = PrivateGateway.create( | |
| self.apiClient, | |
| vpcid=vpc_created.id, | |
| gateway=self.test_data["private_gateway"]["gateway"], | |
| ipaddress=self.test_data["private_gateway"]["ipaddress"], | |
| netmask=self.test_data["private_gateway"]["netmask"], | |
| vlan=self.test_data["private_gateway"]["vlan"] | |
| ) | |
| self.assertIsNotNone( | |
| private_gateway_created, | |
| "Private Gateway Creation Failed" | |
| ) | |
| # Listing all the PrivateGateways | |
| list_private_gateways_after = PrivateGateway.list( | |
| self.apiClient, | |
| listall=self.test_data["listall"], | |
| vpcid=vpc_created.id | |
| ) | |
| # Verifying PrivateGateways are listed | |
| status = validateList(list_private_gateways_after) | |
| self.assertEqual(PASS, status[0], "Private Gateway Creation Failed") | |
| self.assertEqual( | |
| 1, | |
| len(list_private_gateways_after), | |
| "list Private Gateway not equal as expected" | |
| ) | |
| # Listing Private Gateway by vpcid | |
| list_privategateway_byvpcid = PrivateGateway.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| vpcid=vpc_created.id | |
| ) | |
| status = validateList(list_privategateway_byvpcid) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "list private gateway not as expected" | |
| ) | |
| # Verifying the list private gateway size is 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_privategateway_byvpcid), | |
| "list private gateway not equal as expected" | |
| ) | |
| # Verifying the details of the private gateway | |
| expected_dict = { | |
| "account": private_gateway_created.account, | |
| "aclid": private_gateway_created.aclid, | |
| "domainid": private_gateway_created.domainid, | |
| "gateway": self.test_data["private_gateway"]["gateway"], | |
| "id": private_gateway_created.id, | |
| "ipaddress": self.test_data["private_gateway"]["ipaddress"], | |
| "netmask": self.test_data["private_gateway"]["netmask"], | |
| "sourcenatsupported": private_gateway_created.sourcenatsupported, | |
| "vlan": self.test_data["private_gateway"]["vlan"], | |
| "vpcid": private_gateway_created.vpcid, | |
| "zoneid": private_gateway_created.zoneid | |
| } | |
| actual_dict = { | |
| "account": list_privategateway_byvpcid[0].account, | |
| "aclid": list_privategateway_byvpcid[0].aclid, | |
| "domainid": list_privategateway_byvpcid[0].domainid, | |
| "gateway": list_privategateway_byvpcid[0].gateway, | |
| "id": list_privategateway_byvpcid[0].id, | |
| "ipaddress": list_privategateway_byvpcid[0].ipaddress, | |
| "netmask": list_privategateway_byvpcid[0].netmask, | |
| "sourcenatsupported": | |
| list_privategateway_byvpcid[0].sourcenatsupported, | |
| "vlan": list_privategateway_byvpcid[0].vlan, | |
| "vpcid": list_privategateway_byvpcid[0].vpcid, | |
| "zoneid": list_privategateway_byvpcid[0].zoneid} | |
| list_private_gateway_status = self.__verify_values( | |
| expected_dict, | |
| actual_dict | |
| ) | |
| self.assertEqual( | |
| True, | |
| list_private_gateway_status, | |
| "Listed Private Gateway details are not as expected" | |
| ) | |
| return | |
| @attr(tags=["advanced"], required_hardware="true") | |
| def test_16_create_list_delete_egressfirewallrule_bynetworkid(self): | |
| """ | |
| @summary: Test Create List Delete Egress Firewall Rule by Network ID | |
| @Steps | |
| Step1: Creating a Nerwork | |
| Step2: Listing all the egressfirewall rule before creating a | |
| egressfirewall rule | |
| Step3: Verifying no egressfirewall rule are listed | |
| Step4: Creating a egressfirewall rule for a user | |
| Step5: Listing the egressfirewall rule by specifying Network ID | |
| Step7: Verifying the list egressfirewall rule size is 1 | |
| Step8: Verifying the details of the egressfirewall rule | |
| Step9: Deleting the egressfirewall rule by network id | |
| Step10: Verifying no egressfirewall rule is listed | |
| """ | |
| # Listing all the Networks's for a user | |
| list_networks_before = Network.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| type="Isolated" | |
| ) | |
| # Verifying No Networks are listed | |
| self.assertIsNone( | |
| list_networks_before, | |
| "Networks listed for newly created User" | |
| ) | |
| # Listing Network Offerings | |
| network_offerings_list = NetworkOffering.list( | |
| self.apiClient, | |
| forvpc="false", | |
| guestiptype="Isolated", | |
| state="Enabled", | |
| supportedservices="SourceNat", | |
| zoneid=self.zone.id | |
| ) | |
| self.assertIsNotNone( | |
| network_offerings_list, | |
| "Isolated Network Offerings with sourceNat enabled are not found" | |
| ) | |
| # Creating a Network | |
| network = Network.create( | |
| self.userapiclient, | |
| self.test_data["network"], | |
| accountid=self.account.name, | |
| domainid=self.domain.id, | |
| networkofferingid=network_offerings_list[0].id, | |
| zoneid=self.zone.id | |
| ) | |
| self.assertIsNotNone( | |
| network, | |
| "Network creation failed" | |
| ) | |
| self.cleanup.append(network) | |
| # Listing Networks after | |
| list_networks_after = Network.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| type="Isolated" | |
| ) | |
| status = validateList(list_networks_after) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Network Creation Failed" | |
| ) | |
| # Verifying network list count is increased by 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_networks_after), | |
| "Network Creation Failed" | |
| ) | |
| # Listing EgressFirewall Rule | |
| list_egressfirewallrule_before = EgressFireWallRule.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| networkid=network.id | |
| ) | |
| # Verifying No EgressFirewall Rule are listed | |
| self.assertIsNone( | |
| list_egressfirewallrule_before, | |
| "Listed egressfirewall rule for a user" | |
| ) | |
| # Creating a EgressFirewall Rule | |
| egressfirewallrule_created = EgressFireWallRule.create( | |
| self.userapiclient, | |
| networkid=network.id, | |
| protocol=self.test_data["ingress_rule"]["protocol"], | |
| cidrlist=self.test_data["ingress_rule"]["cidrlist"], | |
| startport=self.test_data["ingress_rule"]["startport"], | |
| endport=self.test_data["ingress_rule"]["endport"], | |
| ) | |
| self.assertIsNotNone( | |
| egressfirewallrule_created, | |
| "EgressFirewall Rule Creation Failed" | |
| ) | |
| # ListingEgressFirewall Rule by networkid | |
| list_egressfirewallrule_bynetworkid = EgressFireWallRule.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| networkid=network.id | |
| ) | |
| status = validateList(list_egressfirewallrule_bynetworkid) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "list EgressFirewall Rule not as expected" | |
| ) | |
| # Verifying the list EgressFirewall Rule size is 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_egressfirewallrule_bynetworkid), | |
| "list EgressFirewall Rule not equal as expected" | |
| ) | |
| # Verifying the details of the EgressFirewall Rule | |
| expected_dict = { | |
| "cidrlist": self.zone.guestcidraddress, | |
| "id": egressfirewallrule_created.id, | |
| "networkid": egressfirewallrule_created.networkid, | |
| "protocol": self.test_data["ingress_rule"]["protocol"] | |
| } | |
| actual_dict = { | |
| "cidrlist": str( | |
| list_egressfirewallrule_bynetworkid[0].cidrlist), | |
| "id": list_egressfirewallrule_bynetworkid[0].id, | |
| "networkid": list_egressfirewallrule_bynetworkid[0].networkid, | |
| "protocol": str( | |
| list_egressfirewallrule_bynetworkid[0].protocol).upper()} | |
| list_egressfirewallrule_status = self.__verify_values( | |
| expected_dict, | |
| actual_dict | |
| ) | |
| self.assertEqual( | |
| True, | |
| list_egressfirewallrule_status, | |
| "Listed EgressFirewall Rule details are not as expected" | |
| ) | |
| # Deleting the EgressFirewall Rule by networkid | |
| egressfirewallrule_created.delete(self.userapiclient) | |
| # Listing the EgressFirewall Rule by networkid | |
| list_deleted_egressfirewallrule_bynetworkid = EgressFireWallRule.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| networkid=network.id | |
| ) | |
| # Verifying No EgressFirewall Rule are listed | |
| self.assertIsNone( | |
| list_deleted_egressfirewallrule_bynetworkid, | |
| "EgressFirewall Rule deletion fails" | |
| ) | |
| return | |
| @attr(tags=["advanced"], required_hardware="true") | |
| def test_17_restart_vpc(self): | |
| """ | |
| @summary: Test to restart VPC | |
| @Steps | |
| Step1: Listing the VPC before creating a VPC for a user | |
| Step2: Verifying No VPCs are listed | |
| Step3: Creating a VPC | |
| Step4: Listing the VPC after creating a VPC for a user | |
| Step5: Verifying the list VPC size is increased by 1 | |
| Step6: Restarting the VPC | |
| Step7: Verifying the Restart function return true | |
| Step8: Listing the VPC by specifying VPCID | |
| Step9: Verfying state of vpc | |
| """ | |
| if self.hypervisor.lower() in ['hyperv']: | |
| raise unittest.SkipTest("This feature is not supported on existing hypervisor. Hence, skipping the test") | |
| # Listing all the vpc's for a user | |
| list_vpc_before = VPC.list(self.userapiclient) | |
| # Verifying No VPCs are listed | |
| self.assertIsNone( | |
| list_vpc_before, | |
| "Vpc listed for newly created user" | |
| ) | |
| # Creating a vpc | |
| vpc_created = VPC.create( | |
| self.userapiclient, | |
| self.test_data["vpc"], | |
| self.vpc_offering.id, | |
| self.zone.id | |
| ) | |
| self.assertIsNotNone(vpc_created, "VPC Creation Failed") | |
| self.cleanup.append(vpc_created) | |
| # Listing the vpc for a user after creating a vpc | |
| list_vpc_after = VPC.list(self.userapiclient) | |
| status = validateList(list_vpc_after) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "list VPC not as expected" | |
| ) | |
| # Verifying the list vpc size is increased by 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_vpc_after), | |
| "list VPC not equal as expected" | |
| ) | |
| # Restarting VPC | |
| vpc_restarted = VPC.restart(vpc_created, self.userapiclient) | |
| # Verifying restart function resturns true | |
| self.assertTrue(vpc_restarted, "Restart fails") | |
| # List the vpc by specifying vpc ID | |
| list_vpc_byid = VPC.list( | |
| self.userapiclient, | |
| id=vpc_created.id, | |
| listall=self.test_data["listall"] | |
| ) | |
| status = validateList(list_vpc_byid) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "list VPC not as expected" | |
| ) | |
| # Verifying the list vpc size is 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_vpc_byid), | |
| "list VPC not equal as expected" | |
| ) | |
| # Verfying whether sate is Enabled | |
| self.assertEqual( | |
| "Enabled", | |
| list_vpc_byid[0].state, | |
| "Restarted VPC is not in Enabled state" | |
| ) | |
| return | |
| @attr(tags=["advanced"], required_hardware="true") | |
| def test_18_create_list_vpn_gateway(self): | |
| """ | |
| @Desc: Test to Create and list Vpn Gateway by VPCid | |
| @steps: | |
| Step1: Create VPC | |
| Step2: Listing VPN gateways for user before creating any VPN gateway | |
| Step3: Verifying No VPN Gateways are listed | |
| Step4: Creating a VPN Gateway using the vpc | |
| Step5: Listing VPN gateway for user by vpcid | |
| Step6: Verifying the list size is increased by 1 | |
| Step7: Verifying the details of a VPN gateway | |
| """ | |
| if self.hypervisor.lower() in ['hyperv']: | |
| raise unittest.SkipTest("This feature is not supported on existing hypervisor. Hence, skipping the test") | |
| # Listing all the vpc's for a user | |
| list_vpc_before = VPC.list(self.userapiclient) | |
| # Verifying No VPCs are listed | |
| self.assertIsNone( | |
| list_vpc_before, | |
| "Vpc listed for newly created user" | |
| ) | |
| # Creating a vpc | |
| vpc_created = VPC.create( | |
| self.userapiclient, | |
| self.test_data["vpc"], | |
| self.vpc_offering.id, | |
| self.zone.id | |
| ) | |
| self.assertIsNotNone(vpc_created, "VPC Creation Failed") | |
| self.cleanup.append(vpc_created) | |
| # Listing the vpc for a user after creating a vpc | |
| list_vpc_after = VPC.list(self.userapiclient) | |
| status = validateList(list_vpc_after) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "list VPC not as expected" | |
| ) | |
| # Verifying the list vpc size is increased by 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_vpc_after), | |
| "list VPC not equal as expected" | |
| ) | |
| # Listing all the vpn gateways for a user | |
| list_vpngateway_before = Vpn.listVpnGateway( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| vpcid=vpc_created.id | |
| ) | |
| # Verifying No VPN Gateways are listed | |
| self.assertIsNone( | |
| list_vpngateway_before, | |
| "Vpn gateway listed for newly created user" | |
| ) | |
| # Creating a VPN Gateway | |
| vpngateway_created = Vpn.createVpnGateway( | |
| self.userapiclient, | |
| vpcid=vpc_created.id, | |
| ) | |
| self.assertIsNotNone( | |
| vpngateway_created, | |
| "VPN Gateway creation failed" | |
| ) | |
| # Listing all the VPN Gateways for a User | |
| list_vpngateway_after = Vpn.listVpnGateway( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| vpcid=vpc_created.id | |
| ) | |
| status = validateList(list_vpngateway_after) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "List VPN Gateway not equal as expected" | |
| ) | |
| # Verifying that list size is 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_vpngateway_after | |
| ), | |
| "Failed to list vpn gateway" | |
| ) | |
| # Verifying the details of the vpn gateway | |
| expected_dict = { | |
| "account": vpngateway_created["account"], | |
| "domainid": vpngateway_created["domainid"], | |
| "id": vpngateway_created["id"], | |
| "publicip": vpngateway_created["publicip"], | |
| "vpcid": vpngateway_created["vpcid"] | |
| } | |
| actual_dict = { | |
| "account": list_vpngateway_after[0].account, | |
| "domainid": list_vpngateway_after[0].domainid, | |
| "id": list_vpngateway_after[0].id, | |
| "publicip": list_vpngateway_after[0].publicip, | |
| "vpcid": list_vpngateway_after[0].vpcid | |
| } | |
| list_vpn_gateway_status = self.__verify_values( | |
| expected_dict, | |
| actual_dict | |
| ) | |
| self.assertEqual( | |
| True, | |
| list_vpn_gateway_status, | |
| "Listed VPN Gateway details are not as expected" | |
| ) | |
| return | |
| # @attr(tags=["advanced"], required_hardware="true") | |
| @attr(tags=["TODO"], required_hardware="true") | |
| def test_19_create_list_reset_delete_vpnconnections(self): | |
| """ | |
| @Desc: Test to List Create Reset and Delete VPN Customer | |
| Gateways pagination | |
| @steps: | |
| Step1: Create VPC | |
| Step2: Create VPN gateway | |
| Step3: Create VPN Customer Gateway | |
| Step4: Listing all the VPN Connections for a user | |
| Step5: Verifying No VPN Connection are listed | |
| Step6: Create a VPN Connection using VPN Gateway and | |
| VPN Customer Gateway | |
| Step7: Listing all the VPN Connections by vpcid for a user | |
| Step8: Verifying that list size is 1 | |
| Step9: Reset the vpn connection | |
| Step10:List the Vpn connection by vpcid | |
| Step11: Verify the details of VPN Connection after reset | |
| Step12: Deleting the VPN Connection | |
| Step13: Listing all the VPN Connection for a user | |
| Step14: Verifying that no VPN Connection are listed | |
| """ | |
| if self.hypervisor.lower() in ['hyperv']: | |
| raise unittest.SkipTest("This feature is not supported on existing hypervisor. Hence, skipping the test") | |
| # Listing all the vpc's for a user | |
| list_vpc_before = VPC.list(self.userapiclient) | |
| # Verifying No VPCs are listed | |
| self.assertIsNone( | |
| list_vpc_before, | |
| "Vpc listed for newly created user" | |
| ) | |
| # Creating a vpc | |
| vpc_created = VPC.create( | |
| self.userapiclient, | |
| self.test_data["vpc"], | |
| self.vpc_offering.id, | |
| self.zone.id | |
| ) | |
| self.assertIsNotNone(vpc_created, "VPC Creation Failed") | |
| self.cleanup.append(vpc_created) | |
| # Listing the vpc for a user after creating a vpc | |
| list_vpc_after = VPC.list(self.userapiclient) | |
| status = validateList(list_vpc_after) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "list VPC not as expected" | |
| ) | |
| # Verifying the list vpc size is increased by 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_vpc_after), | |
| "list VPC not equal as expected" | |
| ) | |
| # Listing all the vpn gateways for a user | |
| list_vpngateway_before = Vpn.listVpnGateway( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| vpcid=vpc_created.id | |
| ) | |
| # Verifying No VPN Gateways are listed | |
| self.assertIsNone( | |
| list_vpngateway_before, | |
| "Vpn gateway listed for newly created user" | |
| ) | |
| # Creating a VPN Gateway | |
| vpngateway_created = Vpn.createVpnGateway( | |
| self.userapiclient, | |
| vpcid=vpc_created.id, | |
| ) | |
| self.assertIsNotNone( | |
| vpngateway_created, | |
| "VPN Gateway creation failed" | |
| ) | |
| # Listing all the VPN Gateways for a User | |
| list_vpngateway_after = Vpn.listVpnGateway( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| vpcid=vpc_created.id | |
| ) | |
| status = validateList(list_vpngateway_after) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "List VPN Gateway not equal as expected" | |
| ) | |
| # Verifying that list size is 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_vpngateway_after | |
| ), | |
| "Failed to list vpn gateway" | |
| ) | |
| # Listing all the VPN Customer Gateways for a User | |
| list_vpncustomergateways_before = VpnCustomerGateway.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"] | |
| ) | |
| # Verifying that no VPN Customer Gateways are listed | |
| self.assertIsNone( | |
| list_vpncustomergateways_before, | |
| "VPN Customer Gateways listed for newly created User" | |
| ) | |
| # Creating VPN Customer Gateways | |
| vpncustomergateway_created = VpnCustomerGateway.create( | |
| self.userapiclient, | |
| self.test_data["vpncustomergateway"], | |
| name="VPNCustGateway", | |
| gateway="10.102.153.1", | |
| cidrlist="10.0.0.0/24", | |
| account=self.account.name, | |
| domainid=self.domain.id | |
| ) | |
| self.assertIsNotNone( | |
| vpncustomergateway_created, | |
| "VPN Customer Gateway creation failed" | |
| ) | |
| self.cleanup.append(vpncustomergateway_created) | |
| # Listing all the VPN Customer Gateways for a User | |
| list_vpncustomergateways_after = VpnCustomerGateway.list( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| ) | |
| status = validateList(list_vpncustomergateways_after) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "VPN Customer Gateway list failed" | |
| ) | |
| # Verifying that list size is 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_vpncustomergateways_after), | |
| "Failed to list VPN Customer Gateways" | |
| ) | |
| # Listing all the vpc's for a user | |
| list_vpn_connection_before = Vpn.listVpnConnection( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| vpcid=vpc_created.id | |
| ) | |
| # Verifying No VPC Connections are listed | |
| self.assertIsNone( | |
| list_vpn_connection_before, | |
| "Vpn connection listed for newly created user" | |
| ) | |
| # Creating VPN Connection | |
| vpnconnections_created = Vpn.createVpnConnection( | |
| self.userapiclient, | |
| s2scustomergatewayid=vpncustomergateway_created.id, | |
| s2svpngatewayid=vpngateway_created["id"] | |
| ) | |
| self.assertIsNotNone( | |
| vpnconnections_created, | |
| "VPN Connection creation failed" | |
| ) | |
| # Listing the vpn connection for a user after creating a vpn connection | |
| list_vpn_connection_after = Vpn.listVpnConnection( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| vpcid=vpc_created.id | |
| ) | |
| status = validateList(list_vpn_connection_after) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "list VPN Connection not as expected" | |
| ) | |
| # Verifying the list vpn connection size is increased by 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_vpn_connection_after), | |
| "list VPC Connection equal as expected" | |
| ) | |
| # Resets VPN Connection | |
| Vpn.resetVpnConnection( | |
| self.userapiclient, | |
| id=list_vpn_connection_after[0].id, | |
| ) | |
| # Lists VPN Connection by vpcid | |
| list_vpn_connection_after_reset = Vpn.listVpnConnection( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| vpcid=vpc_created.id | |
| ) | |
| status = validateList(list_vpn_connection_after_reset) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "list VPN Connection not as expected" | |
| ) | |
| # Verifying the list vpn connection size is increased by 1 | |
| self.assertEqual( | |
| 1, | |
| len(list_vpn_connection_after_reset), | |
| "list VPN Connection not equal as expected" | |
| ) | |
| # Verifying the details of the vpn connection after reset | |
| expected_dict = { | |
| "account": list_vpn_connection_after[0].account, | |
| "cidrlist": list_vpn_connection_after[0].cidrlist, | |
| "domain": list_vpn_connection_after[0].domain, | |
| "dpd": list_vpn_connection_after[0].dpd, | |
| "gateway": list_vpn_connection_after[0].gateway, | |
| "id": list_vpn_connection_after[0].id, | |
| "passive": list_vpn_connection_after[0].passive, | |
| "publicip": list_vpn_connection_after[0].publicip, | |
| "s2scustomergatewayid": | |
| list_vpn_connection_after[0].s2scustomergatewayid, | |
| "s2svpngatewayid": list_vpn_connection_after[0].s2svpngatewayid} | |
| actual_dict = { | |
| "account": list_vpn_connection_after_reset[0].account, | |
| "cidrlist": list_vpn_connection_after_reset[0].cidrlist, | |
| "domain": list_vpn_connection_after_reset[0].domain, | |
| "dpd": list_vpn_connection_after_reset[0].dpd, | |
| "gateway": list_vpn_connection_after_reset[0].gateway, | |
| "id": list_vpn_connection_after_reset[0].id, | |
| "passive": list_vpn_connection_after_reset[0].passive, | |
| "publicip": list_vpn_connection_after_reset[0].publicip, | |
| "s2scustomergatewayid": | |
| list_vpn_connection_after_reset[0].s2scustomergatewayid, | |
| "s2svpngatewayid": | |
| list_vpn_connection_after_reset[0].s2svpngatewayid} | |
| list_vpn_connection_status = self.__verify_values( | |
| expected_dict, | |
| actual_dict | |
| ) | |
| self.assertEqual( | |
| True, | |
| list_vpn_connection_status, | |
| "Listed VPN Connection details are not as expected" | |
| ) | |
| # Delete VPN Connection | |
| Vpn.deleteVpnConnection( | |
| self.userapiclient, | |
| id=list_vpn_connection_after[0].id | |
| ) | |
| # Listing all the vpc connections for a user | |
| list_vpn_connection_after_delete = Vpn.listVpnConnection( | |
| self.userapiclient, | |
| listall=self.test_data["listall"], | |
| vpcid=vpc_created.id | |
| ) | |
| # Verifying No VPN Connections are listed | |
| self.assertIsNone( | |
| list_vpn_connection_after_delete, | |
| "Vpn connection listed for newly created user" | |
| ) | |
| return | |
| @attr(tags=["advanced"], required_hardware="true") | |
| def test_20_list_capabilities(self): | |
| """ | |
| @summary: Test List Capabilities | |
| @Steps | |
| Step1: Listing all the Capabilities for a user | |
| Step2: Verifying the listcapabilities object is not null | |
| Step3: Verifying list.cloudstack version is not null | |
| """ | |
| # Listing all the Capabilities for a user | |
| listCapabilities = Configurations.listCapabilities(self.userapiclient) | |
| # Verifying the listcapabilities object is not null | |
| self.assertIsNotNone( | |
| listCapabilities, | |
| "Failed to list Capabilities" | |
| ) | |
| # Verifying list.cloudstack version is not null | |
| self.assertIsNotNone( | |
| listCapabilities.cloudstackversion, | |
| "Failed to list cloud Stack version" | |
| ) | |
| return | |
| @attr(tags=["advanced"], required_hardware="true") | |
| def test_21_listNetworkacls_by_privategateway_aclid(self): | |
| """ | |
| @summary: Test to list Networkacllists by private gateway aclid | |
| @Steps | |
| Step1: Listing the Network acl's for a user | |
| Step2: Verifying list is not none | |
| Step3: Creating a VPC | |
| Step4: Listing the privategateway for user | |
| Step5: Verifying the no private gateway are listed for a user | |
| Step6: Creating a private gateway using aclid | |
| Step7: Listing private gateway for a user | |
| Step8: Verifying list size is increased by 1 | |
| Step9: Listing Networkacllist by paymentgateway aclid | |
| """ | |
| if self.hypervisor.lower() in ['hyperv']: | |
| raise unittest.SkipTest("This feature is not supported on existing hypervisor. Hence, skipping the test") | |
| # Listing all thenetwork acl list for a user | |
| list_networkacl = NetworkACLList.list(self.userapiclient) | |
| self.assertIsNotNone( | |
| list_networkacl, | |
| "Failed to list network acl list") | |
| # Verfying list is not none | |
| status = validateList(list_networkacl) | |
| self.assertEqual( | |
| PASS, | |
| status[0], | |
| "Failed to list network acl list" | |
| ) | |
| # Creating a vpc | |
| vpc_created = VPC.create( | |
| self.userapiclient, | |
| self.test_data["vpc"], | |
| self.vpc_offering.id, | |
| self.zone.id | |
| ) | |
| self.assertIsNotNone(vpc_created, "VPC Creation Failed") | |
| self.cleanup.append(vpc_created) | |
| # Listing all the PrivateGateways | |
| list_private_gateways_before = PrivateGateway.list( | |
| self.apiClient, | |
| listall=self.test_data["listall"], | |
| vpcid=vpc_created.id | |
| ) | |
| # Verifying No PrivateGateways are listed | |
| self.assertIsNone( | |
| list_private_gateways_before, | |
| "Listed private gateways for newly created VPC " | |
| ) | |
| # Creating a Private Gateway using aclid | |
| private_gateway_created = PrivateGateway.create( | |
| self.apiClient, | |
| vpcid=vpc_created.id, | |
| gateway=self.test_data["private_gateway"]["gateway"], | |
| ipaddress=self.test_data["private_gateway"]["ipaddress"], | |
| netmask=self.test_data["private_gateway"]["netmask"], | |
| vlan=self.test_data["private_gateway"]["vlan"], | |
| aclid=list_networkacl[0].id | |
| ) | |
| self.assertIsNotNone( | |
| private_gateway_created, | |
| "Private Gateway Creation Failed" | |
| ) | |
| # Listing all the PrivateGateways | |
| list_private_gateways_after = PrivateGateway.list( | |
| self.apiClient, | |
| listall=self.test_data["listall"], | |
| vpcid=vpc_created.id | |
| ) | |
| # Verifying PrivateGateways are listed | |
| status = validateList(list_private_gateways_after) | |
| self.assertEqual(PASS, status[0], "Failed to list Private Gateway") | |
| self.assertEqual( | |
| 1, | |
| len(list_private_gateways_after), | |
| "list Private Gateway not equal as expected" | |
| ) | |
| # Listing network acl list by paymentgateway.aclid | |
| list = NetworkACLList.list(self.userapiclient, | |
| listall=self.test_data["listall"], | |
| id=private_gateway_created.aclid | |
| ) | |
| # Verifying the details of the Network acl list | |
| expected_dict = { | |
| "description": list_networkacl[0].description, | |
| "id": list_networkacl[0].id, | |
| "name": list_networkacl[0].name | |
| } | |
| actual_dict = { | |
| "description": list[0].description, | |
| "id": list[0].id, | |
| "name": list[0].name | |
| } | |
| list_networkacl_status = self.__verify_values( | |
| expected_dict, | |
| actual_dict | |
| ) | |
| self.assertEqual( | |
| True, | |
| list_networkacl_status, | |
| "Listed Network acl list details are not as expected" | |
| ) | |
| return |