def setUpClass(cls): cls.testClient = super(TestMultiplePublicIpSubnets, cls).getClsTestClient() cls.apiclient = cls.testClient.getApiClient() cls.services = cls.testClient.getParsedTestDataConfig() zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests()) cls.zone = Zone(zone.__dict__) cls.template = get_template(cls.apiclient, cls.zone.id) cls._cleanup = [] cls.skip = False if str(cls.zone.securitygroupsenabled) == "True": cls.skip = True return cls.hypervisor = cls.testClient.getHypervisorInfo() if cls.hypervisor.lower() not in ['kvm']: cls.skip = True return cls.logger = logging.getLogger("TestMultiplePublicIpSubnets") cls.stream_handler = logging.StreamHandler() cls.logger.setLevel(logging.DEBUG) cls.logger.addHandler(cls.stream_handler) # Get Zone, Domain and templates cls.domain = get_domain(cls.apiclient) # Create small service offering cls.service_offering = ServiceOffering.create( cls.apiclient, cls.services["service_offerings"]["small"]) cls._cleanup.append(cls.service_offering)
def setUpClass(cls): cls.testClient = super(TestHosts, cls).getClsTestClient() cls.testdata = cls.testClient.getParsedTestDataConfig() cls.apiclient = cls.testClient.getApiClient() cls.dbclient = cls.testClient.getDbConnection() cls._cleanup = [] # get zone, domain etc cls.zone = Zone(get_zone(cls.apiclient, cls.testClient.getZoneForTests()).__dict__) cls.domain = get_domain(cls.apiclient) cls.pod = get_pod(cls.apiclient, cls.zone.id) cls.logger = logging.getLogger('TestHosts') cls.stream_handler = logging.StreamHandler() cls.logger.setLevel(logging.DEBUG) cls.logger.addHandler(cls.stream_handler) cls.storage_pool_db_id = None # list hosts hosts = list_hosts(cls.apiclient, type="Routing") i = 0 while (i < len(hosts)): host_id = hosts[i].id cls.logger.debug("Trying host id : %s" % host_id) host_db_id = cls.dbclient.execute( "select id from host where uuid='%s';" % host_id) if host_db_id and host_db_id[0]: cls.logger.debug("found host db id : %s" % host_db_id) storage_pool_db_id = cls.dbclient.execute( "select id from storage_pool where id='%s' and removed is null;" % host_db_id[0][0]) if storage_pool_db_id and storage_pool_db_id[0]: cls.logger.debug("Found storage_pool_db_id : %s" % storage_pool_db_id[0][0]) capacity_state = cls.dbclient.execute( "select count(capacity_state) from op_host_capacity where host_id='%s' and capacity_type in (0,1,3) and capacity_state = 'Enabled'" % host_db_id[0][0]) if capacity_state and capacity_state[0]: cls.logger.debug("Check capacity count : %s" % capacity_state[0][0]) if capacity_state[0][0] == 3: cls.logger.debug("found host id : %s, can be used for this test" % host_id) cls.my_host_id = host_id cls.host_db_id = host_db_id cls.storage_pool_db_id = storage_pool_db_id break if not cls.storage_pool_db_id: i = i + 1 if cls.storage_pool_db_id is None: raise unittest.SkipTest("There is no host and storage pool available in the setup to run this test")
def tearDownClass(cls): try: zoneList = Zone.list(cls.apiclient, id=cls.zone.id) if zoneList[0].allocationstate == DISABLED: cmd = updateZone.updateZoneCmd() cmd.id = zoneList[0].id cmd.allocationstate = ENABLED cls.apiclient.updateZone(cmd) cleanup_resources(cls.apiclient, cls._cleanup) except Exception as e: raise Exception("Warning: Exception during cleanup : %s" % e)
def setUpClass(cls): cls.testClient = super( TestProtocolNumberSecurityGroup, cls).getClsTestClient() cls.apiclient = cls.testClient.getApiClient() cls.testdata = cls.testClient.getParsedTestDataConfig() cls.services = cls.testClient.getParsedTestDataConfig() zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests()) cls.zone = Zone(zone.__dict__) cls.template = get_template(cls.apiclient, cls.zone.id) cls._cleanup = [] if str(cls.zone.securitygroupsenabled) != "True": sys.exit(1) cls.logger = logging.getLogger("TestProtocolNumberSecurityGroup") cls.stream_handler = logging.StreamHandler() cls.logger.setLevel(logging.DEBUG) cls.logger.addHandler(cls.stream_handler) # Get Zone, Domain and templates cls.domain = get_domain(cls.apiclient) testClient = super(TestProtocolNumberSecurityGroup, cls).getClsTestClient() cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests()) cls.services['mode'] = cls.zone.networktype # Create new domain, account, network and VM cls.user_domain = Domain.create( cls.apiclient, services=cls.testdata["acl"]["domain2"], parentdomainid=cls.domain.id) # Create account cls.account = Account.create( cls.apiclient, cls.testdata["acl"]["accountD2"], admin=True, domainid=cls.user_domain.id ) cls.service_offering = ServiceOffering.create( cls.apiclient, cls.testdata["service_offering"] ) cls.testdata["domainid"] = cls.domain.id cls.testdata["virtual_machine_userdata"]["zoneid"] = cls.zone.id cls.testdata["virtual_machine_userdata"]["template"] = cls.template.id cls._cleanup.append(cls.service_offering) cls._cleanup.append(cls.account) cls._cleanup.append(cls.user_domain)
def test_01_zones(self): """Check the status of zones""" # Validate the following # 1. List zones # 2. Check allocation state is "enabled" or not zones = Zone.list(self.apiclient, id=self.zone.id, listall=True) self.assertEqual(isinstance(zones, list), True, "Check if listZones returns a valid response") for zone in zones: self.assertEqual(zone.allocationstate, 'Enabled', "Zone allocation state should be enabled") return
def test_nuage_vpc_network_multizone(self): """ Test basic VPC Network functionality with Nuage VSP SDN plugin on multiple zones """ # Repeat the tests in the above testcase "test_nuage_vpc_network" on multiple zones self.debug("Testing basic VPC Network functionality with Nuage VSP SDN plugin on multiple zones...") zones = Zone.list(self.api_client) if len(zones) == 1: self.skipTest("There is only one Zone configured: skipping test") for zone in zones: self.debug("Zone - %s" % zone.name) self.setUpClass(zone=zone) self.test_nuage_vpc_network()
def test_nuage_vpc_network_multizone(self): """ Test basic VPC Network functionality with Nuage VSP SDN plugin on multiple zones """ # Repeat the tests in the above testcase "test_nuage_vpc_network" on multiple zones self.debug( "Testing basic VPC Network functionality with Nuage VSP SDN plugin on multiple zones..." ) zones = Zone.list(self.api_client) if len(zones) == 1: self.skipTest("There is only one Zone configured: skipping test") for zone in zones: self.debug("Zone - %s" % zone.name) self.setUpClass(zone=zone) self.test_nuage_vpc_network()
def test_04_list_zones_with_no_params(self): """ Test list zones """ zonesavailable = 0 listallzones = Zone.list(self.user_api_client) self.assertEqual(isinstance(listallzones, list), True, "Check list zones response returns a valid list") for zone1 in listallzones: if zone1.allocationstate == "Enabled": zonesavailable = zonesavailable + 1 if zonesavailable < 1: self.fail("Check if zones are listed") return
def test_04_list_zones_with_no_params(self): """ Test list zones """ zonesavailable=0 listallzones=Zone.list(self.user_api_client) self.assertEqual( isinstance(listallzones, list), True, "Check list zones response returns a valid list" ) for zone1 in listallzones: if zone1.allocationstate=="Enabled": zonesavailable=zonesavailable+1 if zonesavailable<1: self.fail("Check if zones are listed") return
def setUpClass(cls): cls.testClient = super(TestHosts, cls).getClsTestClient() cls.testdata = cls.testClient.getParsedTestDataConfig() cls.apiclient = cls.testClient.getApiClient() cls.dbclient = cls.testClient.getDbConnection() cls._cleanup = [] # get zone, domain etc cls.zone = Zone( get_zone(cls.apiclient, cls.testClient.getZoneForTests()).__dict__) cls.domain = get_domain(cls.apiclient) cls.pod = get_pod(cls.apiclient, cls.zone.id) # list hosts hosts = list_hosts(cls.apiclient, type="Routing") if len(hosts) > 0: cls.my_host_id = hosts[0].id cls.host_db_id = cls.dbclient.execute( "select id from host where uuid='%s';" % cls.my_host_id) cls.my_cluster_id = hosts[0].clusterid else: raise unittest.SkipTest("There is no host available in the setup")
def setUpClass(cls): cls.testClient = super(TestNetworkManagement, cls).getClsTestClient() cls.apiclient = cls.testClient.getApiClient() cls.dbclient = cls.testClient.getDbConnection() cls.testdata = cls.testClient.getParsedTestDataConfig() cls.services = cls.testClient.getParsedTestDataConfig() zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests()) cls.zone = Zone(zone.__dict__) cls._cleanup = [] cls.logger = logging.getLogger("TestNetworkManagement") cls.stream_handler = logging.StreamHandler() cls.logger.setLevel(logging.DEBUG) cls.logger.addHandler(cls.stream_handler) # Get Zone, Domain and templates cls.domain = get_domain(cls.apiclient) testClient = super(TestNetworkManagement, cls).getClsTestClient() cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests()) cls.services['mode'] = cls.zone.networktype # Create new domain, account, network and VM cls.user_domain = Domain.create( cls.apiclient, services=cls.testdata["acl"]["domain2"], parentdomainid=cls.domain.id) # Create account cls.account = Account.create(cls.apiclient, cls.testdata["acl"]["accountD2"], admin=True, domainid=cls.user_domain.id) # Create small service offering cls.service_offering = ServiceOffering.create( cls.apiclient, cls.testdata["service_offerings"]["small"]) cls._cleanup.append(cls.service_offering) cls._cleanup.append(cls.account) cls._cleanup.append(cls.user_domain)
def test_01_zones(self): """Check the status of zones""" # Validate the following # 1. List zones # 2. Check allocation state is "enabled" or not zones = Zone.list( self.apiclient, id=self.zone.id, listall=True ) self.assertEqual( isinstance(zones, list), True, "Check if listZones returns a valid response" ) for zone in zones: self.assertEqual( zone.allocationstate, 'Enabled', "Zone allocation state should be enabled" ) return
def setUpClass(cls): cls.testClient = super( TestAcquireSpecifiedPublicIp, cls).getClsTestClient() cls.apiclient = cls.testClient.getApiClient() cls.services = cls.testClient.getParsedTestDataConfig() zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests()) cls.zone = Zone(zone.__dict__) cls.template = get_template(cls.apiclient, cls.zone.id) cls._cleanup = [] if str(cls.zone.securitygroupsenabled) == "True": sys.exit(1) cls.logger = logging.getLogger("TestAcquireSpecifiedPublicIp") cls.stream_handler = logging.StreamHandler() cls.logger.setLevel(logging.DEBUG) cls.logger.addHandler(cls.stream_handler) # Get Zone, Domain and templates cls.domain = get_domain(cls.apiclient) # Create new domain1 cls.domain1 = Domain.create( cls.apiclient, services=cls.services["acl"]["domain1"], parentdomainid=cls.domain.id) # Create account1 cls.account1 = Account.create( cls.apiclient, cls.services["acl"]["accountD1"], domainid=cls.domain1.id ) # Create domain2 cls.domain2 = Domain.create( cls.apiclient, services=cls.services["acl"]["domain2"], parentdomainid=cls.domain.id) # Create account2 cls.account2 = Account.create( cls.apiclient, cls.services["acl"]["accountD2"], domainid=cls.domain2.id ) cls.services["publiciprange"]["zoneid"] = cls.zone.id cls.services["publiciprange"]["forvirtualnetwork"] = "true" # Create public ip range 1 cls.services["publiciprange"]["vlan"] = get_free_vlan( cls.apiclient, cls.zone.id)[1] random_subnet_number = random.randrange(10,20) cls.services["publiciprange"]["gateway"] = "172.16." + \ str(random_subnet_number) + ".1" cls.services["publiciprange"]["startip"] = "172.16." + \ str(random_subnet_number) + ".2" cls.services["publiciprange"]["endip"] = "172.16." + \ str(random_subnet_number) + ".10" cls.services["publiciprange"]["netmask"] = "255.255.255.0" cls.public_ip_range1 = PublicIpRange.create( cls.apiclient, cls.services["publiciprange"] ) PublicIpRange.dedicate( cls.apiclient, cls.public_ip_range1.vlan.id, domainid=cls.account1.domainid ) # Create public ip range 2 cls.services["publiciprange"]["vlan"] = get_free_vlan( cls.apiclient, cls.zone.id)[1] cls.services["publiciprange"]["gateway"] = "172.16." + \ str(random_subnet_number + 1) + ".1" cls.services["publiciprange"]["startip"] = "172.16." + \ str(random_subnet_number + 1) + ".2" cls.services["publiciprange"]["endip"] = "172.16." + \ str(random_subnet_number + 1) + ".10" cls.services["publiciprange"]["netmask"] = "255.255.255.0" cls.public_ip_range2 = PublicIpRange.create( cls.apiclient, cls.services["publiciprange"] ) PublicIpRange.dedicate( cls.apiclient, cls.public_ip_range2.vlan.id, account=cls.account1.name, domainid=cls.account1.domainid ) # Create public ip range 3 cls.services["publiciprange"]["vlan"] = get_free_vlan( cls.apiclient, cls.zone.id)[1] cls.services["publiciprange"]["gateway"] = "172.16." + \ str(random_subnet_number + 2) + ".1" cls.services["publiciprange"]["startip"] = "172.16." + \ str(random_subnet_number + 2) + ".2" cls.services["publiciprange"]["endip"] = "172.16." + \ str(random_subnet_number + 2) + ".10" cls.services["publiciprange"]["netmask"] = "255.255.255.0" cls.public_ip_range3 = PublicIpRange.create( cls.apiclient, cls.services["publiciprange"] ) PublicIpRange.dedicate( cls.apiclient, cls.public_ip_range3.vlan.id, domainid=cls.account2.domainid ) # Create public ip range 4 cls.services["publiciprange"]["vlan"] = get_free_vlan( cls.apiclient, cls.zone.id)[1] cls.services["publiciprange"]["gateway"] = "172.16." + \ str(random_subnet_number + 3) + ".1" cls.services["publiciprange"]["startip"] = "172.16." + \ str(random_subnet_number + 3) + ".2" cls.services["publiciprange"]["endip"] = "172.16." + \ str(random_subnet_number + 3) + ".10" cls.services["publiciprange"]["netmask"] = "255.255.255.0" cls.public_ip_range4 = PublicIpRange.create( cls.apiclient, cls.services["publiciprange"] ) PublicIpRange.dedicate( cls.apiclient, cls.public_ip_range4.vlan.id, account=cls.account2.name, domainid=cls.account2.domainid ) # Create public ip range 5 cls.services["publiciprange"]["vlan"] = get_free_vlan( cls.apiclient, cls.zone.id)[1] cls.services["publiciprange"]["gateway"] = "172.16." + \ str(random_subnet_number + 4) + ".1" cls.services["publiciprange"]["startip"] = "172.16." + \ str(random_subnet_number + 4) + ".2" cls.services["publiciprange"]["endip"] = "172.16." + \ str(random_subnet_number + 4) + ".10" cls.services["publiciprange"]["netmask"] = "255.255.255.0" cls.public_ip_range5 = PublicIpRange.create( cls.apiclient, cls.services["publiciprange"] ) cls._cleanup.append(cls.account1) cls._cleanup.append(cls.domain1) cls._cleanup.append(cls.account2) cls._cleanup.append(cls.domain2) cls._cleanup.append(cls.public_ip_range1) cls._cleanup.append(cls.public_ip_range2) cls._cleanup.append(cls.public_ip_range3) cls._cleanup.append(cls.public_ip_range4) cls._cleanup.append(cls.public_ip_range5)
def test_04_copy_template(self): """ @Desc: Test to copy Template from one zone to another @steps: Step1: Listing Zones available for a user Step2: Verifying if the zones listed are greater than 1. If Yes continuing. If not halting the test. Step3: Listing all the templates for a user in zone1 Step4: Verifying that no templates are listed Step5: Listing all the templates for a user in zone2 Step6: Verifying that no templates are listed Step7: Creating a Template in zone 1 Step8: Listing all the Templates again for a user in zone1 Step9: Verifying that list size is 1 Step10: Listing all the templates for a user in zone2 Step11: Verifying that no templates are listed Step12: Copying the template created in step7 from zone1 to zone2 Step13: Listing all the templates for a user in zone2 Step14: Verifying that list size is 1 Step15: Listing all the Templates for a user in zone1 Step16: Verifying that list size is 1 """ # Listing Zones available for a user zones_list = Zone.list( self.userapiclient, available=True ) status = validateList(zones_list) self.assertEquals( PASS, status[0], "Failed to list Zones" ) if not len(zones_list) > 1: raise unittest.SkipTest("Not enough zones exist to copy template") else: # Listing all the Templates for a User in Zone 1 list_templates_zone1 = Template.list( self.userapiclient, listall=self.services["listall"], templatefilter=self.services["templatefilter"], zoneid=zones_list[0].id ) # Verifying that no Templates are listed self.assertIsNone( list_templates_zone1, "Templates listed for newly created User in Zone1" ) # Listing all the Templates for a User in Zone 2 list_templates_zone2 = Template.list( self.userapiclient, listall=self.services["listall"], templatefilter=self.services["templatefilter"], zoneid=zones_list[1].id ) # Verifying that no Templates are listed self.assertIsNone( list_templates_zone2, "Templates listed for newly created User in Zone2" ) self.services["privatetemplate"][ "ostype"] = self.services["ostype"] # Listing Hypervisors in Zone 1 hypervisor_list = Hypervisor.list( self.apiClient, zoneid=zones_list[0].id ) status = validateList(zones_list) self.assertEquals( PASS, status[0], "Failed to list Hypervisors in Zone 1" ) # Creating aTemplate in Zone 1 template_created = Template.register( self.userapiclient, self.services["privatetemplate"], zones_list[0].id, hypervisor=hypervisor_list[0].name ) self.assertIsNotNone( template_created, "Template creation failed" ) # Listing all the Templates for a User in Zone 1 list_templates_zone1 = Template.list( self.userapiclient, listall=self.services["listall"], templatefilter=self.services["templatefilter"], zoneid=zones_list[0].id ) status = validateList(list_templates_zone1) self.assertEquals( PASS, status[0], "Templates creation failed in Zone1" ) # Verifying that list size is 1 self.assertEquals( 1, len(list_templates_zone1), "Failed to create a Template" ) # Listing all the Templates for a User in Zone 2 list_templates_zone2 = Template.list( self.userapiclient, listall=self.services["listall"], templatefilter=self.services["templatefilter"], zoneid=zones_list[1].id ) # Verifying that no Templates are listed self.assertIsNone( list_templates_zone2, "Templates listed for newly created User in Zone2" ) # Verifying the state of the template to be ready. If not waiting # for state to become ready till time out template_ready = False count = 0 while template_ready is False: list_template = Template.list( self.userapiclient, id=template_created.id, listall=self.services["listall"], templatefilter=self.services["templatefilter"], ) status = validateList(list_template) self.assertEquals( PASS, status[0], "Failed to list Templates by Id" ) if list_template[0].isready is True: template_ready = True elif (str(list_template[0].status) == "Error"): self.fail("Created Template is in Errored state") break elif count > 10: self.fail( "Timed out before Template came into ready state") break else: time.sleep(self.services["sleep"]) count = count + 1 # Copying the Template from Zone1 to Zone2 copied_template = template_created.copy( self.userapiclient, sourcezoneid=template_created.zoneid, destzoneid=zones_list[1].id ) self.assertIsNotNone( copied_template, "Copying Template from Zone1 to Zone2 failed" ) # Listing all the Templates for a User in Zone 1 list_templates_zone1 = Template.list( self.userapiclient, listall=self.services["listall"], templatefilter=self.services["templatefilter"], zoneid=zones_list[0].id ) status = validateList(list_templates_zone1) self.assertEquals( PASS, status[0], "Templates creation failed in Zone1" ) # Verifying that list size is 1 self.assertEquals( 1, len(list_templates_zone1), "Failed to create a Template" ) # Listing all the Templates for a User in Zone 2 list_templates_zone2 = Template.list( self.userapiclient, listall=self.services["listall"], templatefilter=self.services["templatefilter"], zoneid=zones_list[1].id ) status = validateList(list_templates_zone2) self.assertEquals( PASS, status[0], "Template failed to copy into Zone2" ) # Verifying that list size is 1 self.assertEquals( 1, len(list_templates_zone2), "Template failed to copy into Zone2" ) self.assertNotEquals( "Connection refused", list_templates_zone2[0].status, "Failed to copy Template" ) self.assertEquals( True, list_templates_zone2[0].isready, "Failed to copy Template" ) del self.services["privatetemplate"]["ostype"] return
def test_04_copy_iso(self): """ @Desc: Test to copy ISO from one zone to another @steps: Step1: Listing Zones available for a user Step2: Verifying if the zones listed are greater than 1. If Yes continuing. If not halting the test. Step3: Listing all the ISO's for a user in zone1 Step4: Verifying that no ISO's are listed Step5: Listing all the ISO's for a user in zone2 Step6: Verifying that no ISO's are listed Step7: Creating an ISO in zone 1 Step8: Listing all the ISO's again for a user in zone1 Step9: Verifying that list size is 1 Step10: Listing all the ISO's for a user in zone2 Step11: Verifying that no ISO's are listed Step12: Copying the ISO created in step7 from zone1 to zone2 Step13: Listing all the ISO's for a user in zone2 Step14: Verifying that list size is 1 Step15: Listing all the ISO's for a user in zone1 Step16: Verifying that list size is 1 """ # Listing Zones available for a user zones_list = Zone.list( self.userapiclient, available=True ) status = validateList(zones_list) self.assertEquals( PASS, status[0], "Failed to list Zones" ) if not len(zones_list) > 1: self.skipTest("Enough zones doesnot exists to copy iso") else: # Listing all the ISO's for a User in Zone 1 list_isos_zone1 = Iso.list( self.userapiclient, listall=self.services["listall"], isofilter=self.services["templatefilter"], zoneid=zones_list[0].id ) # Verifying that no ISO's are listed self.assertIsNone( list_isos_zone1, "ISO's listed for newly created User in Zone1" ) # Listing all the ISO's for a User in Zone 2 list_isos_zone2 = Iso.list( self.userapiclient, listall=self.services["listall"], isofilter=self.services["templatefilter"], zoneid=zones_list[1].id ) # Verifying that no ISO's are listed self.assertIsNone( list_isos_zone2, "ISO's listed for newly created User in Zone2" ) self.services["iso"]["zoneid"] = zones_list[0].id # Creating an ISO in Zone 1 iso_created = Iso.create( self.userapiclient, self.services["iso"] ) self.assertIsNotNone( iso_created, "ISO creation failed" ) self.cleanup.append(iso_created) # Listing all the ISO's for a User in Zone 1 list_isos_zone1 = Iso.list( self.userapiclient, listall=self.services["listall"], isofilter=self.services["templatefilter"], zoneid=zones_list[0].id ) status = validateList(list_isos_zone1) self.assertEquals( PASS, status[0], "ISO creation failed in Zone1" ) # Verifying that list size is 1 self.assertEquals( 1, len(list_isos_zone1), "Failed to create a Template" ) # Listing all the ISO's for a User in Zone 2 list_isos_zone2 = Iso.list( self.userapiclient, listall=self.services["listall"], isofilter=self.services["templatefilter"], zoneid=zones_list[1].id ) # Verifying that no ISO's are listed self.assertIsNone( list_isos_zone2, "ISO's listed for newly created User in Zone2" ) # Verifying the state of the ISO to be ready. If not waiting for state to become ready iso_ready = False count = 0 while iso_ready is False: list_iso = Iso.list( self.userapiclient, listall=self.services["listall"], isofilter=self.services["templatefilter"], id=iso_created.id ) status = validateList(list_iso) self.assertEquals( PASS, status[0], "Failed to list ISO by Id" ) if list_iso[0].isready is True: iso_ready = True elif (str(list_iso[0].status) == "Error"): self.fail("Created ISO is in Errored state") break elif count > 10: self.fail("Timed out before ISO came into ready state") break else: time.sleep(self.services["sleep"]) count = count + 1 # Copying the ISO from Zone1 to Zone2 copied_iso = Iso.copy( self.userapiclient, iso_created.id, sourcezoneid=iso_created.zoneid, destzoneid=zones_list[1].id ) self.assertIsNotNone( copied_iso, "Copying ISO from Zone1 to Zone2 failed" ) # Listing all the ISO's for a User in Zone 1 list_isos_zone1 = Iso.list( self.userapiclient, listall=self.services["listall"], isofilter=self.services["templatefilter"], zoneid=zones_list[0].id ) status = validateList(list_isos_zone1) self.assertEquals( PASS, status[0], "ISO creation failed in Zone1" ) # Verifying that list size is 1 self.assertEquals( 1, len(list_isos_zone1), "Failed to create a Template" ) # Listing all the ISO's for a User in Zone 2 list_isos_zone2 = Iso.list( self.userapiclient, listall=self.services["listall"], isofilter=self.services["templatefilter"], zoneid=zones_list[1].id ) status = validateList(list_isos_zone2) self.assertEquals( PASS, status[0], "ISO failed to copy into Zone2" ) # Verifying that list size is 1 self.assertEquals( 1, len(list_isos_zone2), "ISO failed to copy into Zone2" ) self.assertNotEquals( "Connection refused", list_isos_zone2[0].status, "Failed to copy ISO" ) self.assertEquals( True, list_isos_zone2[0].isready, "Failed to copy ISO" ) del self.services["iso"]["zoneid"] return
tc_run_logger = log_obj.getLogger() else: print "\n=== Log Creation Failed. Please Check ===" exit(1) obj_tc_client = CSTestClient(cfg.mgtSvr[0], cfg.dbSvr, logger=tc_run_logger) if obj_tc_client and obj_tc_client.createTestClient() == FAILED: print "\n=== TestClient Creation Failed ===" exit(1) if (options.input) and (os.path.isfile(options.input)): apiClient = obj_tc_client.getApiClient() tmp_dict = {} zones = Zone.list(apiClient) if zones: for zone in zones: print "zone name={}, id={}".format(zone.name, zone.id) if zone.allocationstate == 'Enabled': print "Disable zone" zoneCmd = updateZone.updateZoneCmd() zoneCmd.id = zone.id zoneCmd.allocationstate = 'Disabled' apiClient.updateZone(zoneCmd) ssvms = list_ssvms(apiClient) if ssvms: for ssvm in ssvms: print "ssvm name={}, id={}".format(ssvm.name, ssvm.id) print "Destroy SSVM"
def setUpClass(cls): testClient = super(TestTemplates, cls).getClsTestClient() cls.apiclient = testClient.getApiClient() cls._cleanup = [] cls.services = testClient.getParsedTestDataConfig() cls.unsupportedHypervisor = False cls.hypervisor = testClient.getHypervisorInfo() if cls.hypervisor.lower() in ['lxc']: # Template creation from root volume is not supported in LXC cls.unsupportedHypervisor = True return # Get Zone, Domain and templates cls.domain = get_domain(cls.apiclient) cls.zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests()) cls.services['mode'] = cls.zone.networktype #populate second zone id for iso copy cls.zones = Zone.list(cls.apiclient) if not isinstance(cls.zones, list): raise Exception("Failed to find zones.") cls.disk_offering = DiskOffering.create( cls.apiclient, cls.services["disk_offering"] ) template = get_template( cls.apiclient, cls.zone.id, cls.services["ostype"] ) if template == FAILED: assert False, "get_template() failed to return template with description %s" % cls.services["ostype"] cls.services["virtual_machine"]["zoneid"] = cls.zone.id cls.services["volume"]["diskoffering"] = cls.disk_offering.id cls.services["volume"]["zoneid"] = cls.zone.id cls.services["template_2"]["zoneid"] = cls.zone.id cls.services["sourcezoneid"] = cls.zone.id cls.services["template"]["ostypeid"] = template.ostypeid cls.services["template_2"]["ostypeid"] = template.ostypeid cls.services["ostypeid"] = template.ostypeid cls.account = Account.create( cls.apiclient, cls.services["account"], admin=True, domainid=cls.domain.id ) cls.user = Account.create( cls.apiclient, cls.services["account"], domainid=cls.domain.id ) cls.service_offering = ServiceOffering.create( cls.apiclient, cls.services["service_offerings"]["tiny"] ) #create virtual machine cls.virtual_machine = VirtualMachine.create( cls.apiclient, cls.services["virtual_machine"], templateid=template.id, accountid=cls.account.name, domainid=cls.account.domainid, serviceofferingid=cls.service_offering.id, mode=cls.services["mode"] ) #Stop virtual machine cls.virtual_machine.stop(cls.apiclient) list_volume = Volume.list( cls.apiclient, virtualmachineid=cls.virtual_machine.id, type='ROOT', listall=True ) try: cls.volume = list_volume[0] except Exception as e: raise Exception( "Exception: Unable to find root volume foe VM: %s - %s" % (cls.virtual_machine.id, e)) #Create templates for Edit, Delete & update permissions testcases cls.template_1 = Template.create( cls.apiclient, cls.services["template"], cls.volume.id, account=cls.account.name, domainid=cls.account.domainid ) cls.template_2 = Template.create( cls.apiclient, cls.services["template_2"], cls.volume.id, account=cls.account.name, domainid=cls.account.domainid ) cls._cleanup = [ cls.service_offering, cls.disk_offering, cls.account, cls.user ]
def setUpClass(cls): # Set up API client testclient = super(TestManagedSystemVMs, cls).getClsTestClient() cls.apiClient = testclient.getApiClient() cls.configData = testclient.getParsedTestDataConfig() cls.dbConnection = testclient.getDbConnection() cls.testdata = TestData().testdata cls._connect_to_hypervisor() # Set up SolidFire connection solidfire = cls.testdata[TestData.solidFire] cls.sfe = ElementFactory.create(solidfire[TestData.mvip], solidfire[TestData.username], solidfire[TestData.password]) # Get Resources from Cloud Infrastructure cls.zone = Zone(get_zone(cls.apiClient, zone_id=cls.testdata[TestData.zoneId]).__dict__) cls.cluster = list_clusters(cls.apiClient)[0] cls.template = get_template(cls.apiClient, cls.zone.id, cls.configData["ostype"]) cls.domain = get_domain(cls.apiClient, cls.testdata[TestData.domainId]) # Create test account cls.account = Account.create( cls.apiClient, cls.testdata["account"], admin=1 ) # Set up connection to make customized API calls cls.user = User.create( cls.apiClient, cls.testdata["user"], account=cls.account.name, domainid=cls.domain.id ) url = cls.testdata[TestData.url] api_url = "http://" + url + ":8080/client/api" userkeys = User.registerUserKeys(cls.apiClient, cls.user.id) cls.cs_api = SignedAPICall.CloudStack(api_url, userkeys.apikey, userkeys.secretkey) cls.compute_offering = ServiceOffering.create( cls.apiClient, cls.testdata[TestData.computeOffering] ) systemoffering = cls.testdata[TestData.systemOffering] systemoffering[TestData.name] = "Managed SSVM" systemoffering['systemvmtype'] = "secondarystoragevm" cls.secondary_storage_offering = ServiceOffering.create( cls.apiClient, systemoffering ) systemoffering[TestData.name] = "Managed CPVM" systemoffering['systemvmtype'] = "consoleproxy" cls.console_proxy_offering = ServiceOffering.create( cls.apiClient, systemoffering ) systemoffering[TestData.name] = "Managed VR" systemoffering['systemvmtype'] = "domainrouter" cls.virtual_router_offering = ServiceOffering.create( cls.apiClient, systemoffering ) # Resources that are to be destroyed cls._cleanup = [ cls.secondary_storage_offering, cls.console_proxy_offering, cls.virtual_router_offering, cls.compute_offering, cls.user, cls.account ]
def setUpClass(cls): cls.testClient = super(TestNetworkPermissions, cls).getClsTestClient() cls.apiclient = cls.testClient.getApiClient() cls.services = cls.testClient.getParsedTestDataConfig() zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests()) cls.zone = Zone(zone.__dict__) cls.template = get_template(cls.apiclient, cls.zone.id) cls._cleanup = [] cls.logger = logging.getLogger("TestNetworkPermissions") cls.stream_handler = logging.StreamHandler() cls.logger.setLevel(logging.DEBUG) cls.logger.addHandler(cls.stream_handler) cls.domain = get_domain(cls.apiclient) # Create small service offering cls.service_offering = ServiceOffering.create( cls.apiclient, cls.services["service_offerings"]["small"]) cls._cleanup.append(cls.service_offering) # Create network offering for isolated networks cls.network_offering_isolated = NetworkOffering.create( cls.apiclient, cls.services["isolated_network_offering"]) cls.network_offering_isolated.update(cls.apiclient, state='Enabled') cls._cleanup.append(cls.network_offering_isolated) # Create sub-domain cls.sub_domain = Domain.create(cls.apiclient, cls.services["acl"]["domain1"]) cls._cleanup.append(cls.sub_domain) # Create domain admin and normal user cls.domain_admin = Account.create(cls.apiclient, cls.services["acl"]["accountD1A"], admin=True, domainid=cls.sub_domain.id) cls._cleanup.append(cls.domain_admin) cls.network_owner = Account.create(cls.apiclient, cls.services["acl"]["accountD11A"], domainid=cls.sub_domain.id) cls._cleanup.append(cls.network_owner) cls.other_user = Account.create(cls.apiclient, cls.services["acl"]["accountD11B"], domainid=cls.sub_domain.id) cls._cleanup.append(cls.other_user) # Create project cls.project = Project.create(cls.apiclient, cls.services["project"], account=cls.domain_admin.name, domainid=cls.domain_admin.domainid) cls._cleanup.append(cls.project) # Create api clients for domain admin and normal user cls.domainadmin_user = cls.domain_admin.user[0] cls.domainadmin_apiclient = cls.testClient.getUserApiClient( cls.domainadmin_user.username, cls.sub_domain.name) cls.networkowner_user = cls.network_owner.user[0] cls.user_apiclient = cls.testClient.getUserApiClient( cls.networkowner_user.username, cls.sub_domain.name) cls.otheruser_user = cls.other_user.user[0] cls.otheruser_apiclient = cls.testClient.getUserApiClient( cls.otheruser_user.username, cls.sub_domain.name) # Create networks for domain admin, normal user and project cls.services["network"]["name"] = "Test Network Isolated - Project" cls.project_network = Network.create( cls.apiclient, cls.services["network"], networkofferingid=cls.network_offering_isolated.id, domainid=cls.sub_domain.id, projectid=cls.project.id, zoneid=cls.zone.id) cls._cleanup.append(cls.project_network) cls.services["network"][ "name"] = "Test Network Isolated - Domain admin" cls.domainadmin_network = Network.create( cls.apiclient, cls.services["network"], networkofferingid=cls.network_offering_isolated.id, domainid=cls.sub_domain.id, accountid=cls.domain_admin.name, zoneid=cls.zone.id) cls._cleanup.append(cls.domainadmin_network) cls.services["network"]["name"] = "Test Network Isolated - Normal user" cls.user_network = Network.create( cls.apiclient, cls.services["network"], networkofferingid=cls.network_offering_isolated.id, domainid=cls.sub_domain.id, accountid=cls.network_owner.name, zoneid=cls.zone.id) cls._cleanup.append(cls.user_network)
def setUpClass(cls): cls.testClient = super(TestVolumeDestroyRecover, cls).getClsTestClient() cls.apiclient = cls.testClient.getApiClient() cls.services = cls.testClient.getParsedTestDataConfig() zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests()) cls.zone = Zone(zone.__dict__) cls._cleanup = [] cls.logger = logging.getLogger("TestVolumeDestroyRecover") cls.stream_handler = logging.StreamHandler() cls.logger.setLevel(logging.DEBUG) cls.logger.addHandler(cls.stream_handler) # Get Domain and templates cls.domain = get_domain(cls.apiclient) cls.template = get_template(cls.apiclient, cls.zone.id, hypervisor="KVM") if cls.template == FAILED: sys.exit(1) cls.templatesize = (cls.template.size / (1024**3)) cls.services['mode'] = cls.zone.networktype # Create Account cls.account = Account.create(cls.apiclient, cls.services["account"], admin=True, domainid=cls.domain.id) cls._cleanup.append(cls.account) accounts = Account.list(cls.apiclient, id=cls.account.id) cls.expectedCount = int(accounts[0].primarystoragetotal) cls.volumeTotal = int(accounts[0].volumetotal) if cls.zone.securitygroupsenabled: cls.services["shared_network_offering"]["specifyVlan"] = 'True' cls.services["shared_network_offering"]["specifyIpRanges"] = 'True' cls.network_offering = NetworkOffering.create( cls.apiclient, cls.services["shared_network_offering"]) cls._cleanup.append(cls.network_offering) cls.network_offering.update(cls.apiclient, state='Enabled') cls.account_network = Network.create( cls.apiclient, cls.services["network2"], networkofferingid=cls.network_offering.id, zoneid=cls.zone.id, accountid=cls.account.name, domainid=cls.account.domainid) cls._cleanup.append(cls.account_network) else: cls.network_offering = NetworkOffering.create( cls.apiclient, cls.services["isolated_network_offering"], ) cls._cleanup.append(cls.network_offering) # Enable Network offering cls.network_offering.update(cls.apiclient, state='Enabled') # Create account network cls.services["network"]["zoneid"] = cls.zone.id cls.services["network"][ "networkoffering"] = cls.network_offering.id cls.account_network = Network.create(cls.apiclient, cls.services["network"], cls.account.name, cls.account.domainid) cls._cleanup.append(cls.account_network) # Create small service offering cls.service_offering = ServiceOffering.create( cls.apiclient, cls.services["service_offerings"]["small"]) cls._cleanup.append(cls.service_offering) # Create disk offering cls.disk_offering = DiskOffering.create( cls.apiclient, cls.services["disk_offering"], ) cls._cleanup.append(cls.disk_offering)
log_folder_path = log_obj.getLogFolderPath() tc_run_logger = log_obj.getLogger() else: print "\n=== Log Creation Failed. Please Check ===" exit(1) obj_tc_client = CSTestClient(cfg.mgtSvr[0], cfg.dbSvr, logger=tc_run_logger) if obj_tc_client and obj_tc_client.createTestClient() == FAILED: print "\n=== TestClient Creation Failed ===" exit(1) if (options.input) and (os.path.isfile(options.input)): apiClient = obj_tc_client.getApiClient() zones = Zone.list(apiClient) if zones: for zone in zones: print "zone name={}, id={}".format(zone.name, zone.id) if zone.allocationstate == 'Enabled': services = {} services["displaytext"] = "Debian" services["name"] = "deb" if options.upload_tmpl is not None: services["hypervisor"] = "KVM" services["format"] = "QCOW2" services["url"] = options.upload_tmpl if options.upload_iso is not None: services["url"] = options.upload_iso services["ostype"] = "Debian GNU/Linux 7(64-bit)" services["zoneid"] = zone.id
if ret != FAILED: log_folder_path = log_obj.getLogFolderPath() tc_run_logger = log_obj.getLogger() else: print "\n=== Log Creation Failed. Please Check ===" exit(1) obj_tc_client = CSTestClient(cfg.mgtSvr[0], cfg.dbSvr, logger=tc_run_logger) if obj_tc_client and obj_tc_client.createTestClient() == FAILED: print "\n=== TestClient Creation Failed ===" exit(1) if (options.input) and (os.path.isfile(options.input)): apiClient = obj_tc_client.getApiClient() zones = Zone.list(apiClient) if zones: for zone in zones: print "zone name={}, id={}".format(zone.name, zone.id) if zone.allocationstate == 'Enabled': services = {} services["displaytext"] = "Debian" services["name"] = "deb" if options.upload_tmpl is not None: services["hypervisor"] = "KVM" services["format"] = "QCOW2" services["url"] = options.upload_tmpl if options.upload_iso is not None: services["url"] = options.upload_iso services["ostype"] = "Debian GNU/Linux 7(64-bit)" services["zoneid"] = zone.id
def test_01_disable_enable_zone(self): """disable enable zone 1. Disable zone and verify following things: For admin user: 1. Should be create to start/stop exsiting vms 2. Should be create to deploy new vm, snapshot,volume, template,iso in the same zone For Non-admin user: 1. Should be create to start/stop exsiting vms 2. Should not be create to deploy new vm, snapshot,volume, template,iso in the same zone 2. Enable the above disabled zone and verify that: -All users should be create to deploy new vm, snapshot,volume,template,iso in the same zone 3. Try to delete the zone and it should fail with error message: -"The zone is not deletable because there are servers running in this zone" """ # Step 1 vm_user = VirtualMachine.create( self.userapiclient, self.testdata["small"], templateid=self.template.id, accountid=self.account.name, domainid=self.account.domainid, serviceofferingid=self.service_offering.id, zoneid=self.zone.id, ) vm_root = VirtualMachine.create( self.apiclient, self.testdata["small"], templateid=self.template.id, accountid=self.admin_account.name, domainid=self.admin_account.domainid, serviceofferingid=self.service_offering.id, zoneid=self.zone.id, ) cmd = updateZone.updateZoneCmd() cmd.id = self.zone.id cmd.allocationstate = DISABLED self.apiclient.updateZone(cmd) zoneList = Zone.list(self.apiclient, id=self.zone.id) self.assertEqual(zoneList[0].allocationstate, DISABLED, "Check if the zone is in disabled state") # Both user and admin vms shoul be running self.assertEqual(vm_user.state.lower(), "running", "Verify that the user vm is running") self.assertEqual(vm_root.state.lower(), "running", "Verify that the admin vm is running") vm_root.stop(self.apiclient) vm_user.stop(self.apiclient) root_state = self.dbclient.execute("select state from vm_instance where name='%s'" % vm_root.name)[0][0] user_state = self.dbclient.execute("select state from vm_instance where name='%s'" % vm_user.name)[0][0] self.assertEqual(root_state.lower(), "stopped", "verify that vm is Stopped") self.assertEqual(user_state.lower(), "stopped", "verify that vm is stopped") root_volume = list_volumes(self.apiclient, virtualmachineid=vm_root.id, type="ROOT", listall=True) self.assertEqual(validateList(root_volume)[0], PASS, "list volume is empty for vmid %s" % vm_root.id) root_vm_new = VirtualMachine.create( self.apiclient, self.testdata["small"], templateid=self.template.id, accountid=self.admin_account.name, domainid=self.admin_account.domainid, serviceofferingid=self.service_offering.id, zoneid=self.zone.id, ) self.assertEqual(root_vm_new.state.lower(), "running", "Verify that admin should create new VM") if self.snapshotSupported: Snapshot.create(self.apiclient, root_volume[0].id) snapshots = list_snapshots(self.apiclient, volumeid=root_volume[0].id, listall=True) self.assertEqual( validateList(snapshots)[0], PASS, "list snapshot is empty for volume id %s" % root_volume[0].id ) Template.create_from_snapshot(self.apiclient, snapshots[0], self.testdata["privatetemplate"]) builtin_info = get_builtin_template_info(self.apiclient, self.zone.id) self.testdata["privatetemplate"]["url"] = builtin_info[0] self.testdata["privatetemplate"]["hypervisor"] = builtin_info[1] self.testdata["privatetemplate"]["format"] = builtin_info[2] """ //commenting it for now will uncomment once expected behaviour is known Template.register( self.apiclient, self.testdata["privatetemplate"], zoneid=self.zone.id) """ Volume.create( self.apiclient, self.testdata["volume"], zoneid=self.zone.id, account=self.admin_account.name, domainid=self.admin_account.domainid, diskofferingid=self.disk_offering.id, ) """ //commenting it for now will uncomment once expected behaviour is known Iso.create( self.apiclient, self.testdata["iso2"], zoneid=self.zone.id, account=self.admin_account.name, domainid=self.admin_account.domainid, ) """ # non-admin user should fail to create vm, snap, temp etc with self.assertRaises(Exception): VirtualMachine.create( self.userapiclient, self.testdata["small"], templateid=self.template.id, accountid=self.account.name, domainid=self.account.domainid, serviceofferingid=self.service_offering.id, zoneid=self.zone.id, ) root_volume = list_volumes(self.userapiclient, virtualmachineid=vm_user.id, type="ROOT", listall=True) self.assertEqual(validateList(root_volume)[0], PASS, "list volume is empty for vmid id %s" % vm_user.id) if self.snapshotSupported: with self.assertRaises(Exception): Snapshot.create(self.userapiclient, root_volume[0].id) with self.assertRaises(Exception): Template.register(self.userapiclient, self.testdata["privatetemplate"], zoneid=self.zone.id) with self.assertRaises(Exception): Volume.create( self.userapiclient, self.testdata["volume"], zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid, diskofferingid=self.disk_offering.id, ) with self.assertRaises(Exception): Iso.create( self.userapiclient, self.testdata["iso2"], zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid, ) # Step 2 cmd.allocationstate = ENABLED self.apiclient.updateZone(cmd) # After enabling the zone all users should be able to add new VM, # volume, template and iso root_vm_new = VirtualMachine.create( self.apiclient, self.testdata["small"], templateid=self.template.id, accountid=self.admin_account.name, domainid=self.admin_account.domainid, serviceofferingid=self.service_offering.id, zoneid=self.zone.id, ) self.assertEqual(root_vm_new.state.lower(), "running", "Verify that admin should create new VM") if self.snapshotSupported: Snapshot.create(self.apiclient, root_volume[0].id) snapshots = list_snapshots(self.apiclient, volumeid=root_volume[0].id, listall=True) self.assertEqual( validateList(snapshots)[0], PASS, "list snapshot is empty for volume id %s" % root_volume[0].id ) Template.create_from_snapshot(self.apiclient, snapshots[0], self.testdata["privatetemplate"]) Template.register(self.apiclient, self.testdata["privatetemplate"], zoneid=self.zone.id) Volume.create( self.apiclient, self.testdata["volume"], zoneid=self.zone.id, account=self.admin_account.name, domainid=self.admin_account.domainid, diskofferingid=self.disk_offering.id, ) Iso.create( self.apiclient, self.testdata["iso2"], zoneid=self.zone.id, account=self.admin_account.name, domainid=self.admin_account.domainid, ) # Non root user user_vm_new = VirtualMachine.create( self.userapiclient, self.testdata["small"], templateid=self.template.id, accountid=self.account.name, domainid=self.account.domainid, serviceofferingid=self.service_offering.id, zoneid=self.zone.id, ) self.assertEqual(user_vm_new.state.lower(), "running", "Verify that admin should create new VM") if self.snapshotSupported: Snapshot.create(self.userapiclient, root_volume[0].id) snapshots = list_snapshots(self.userapiclient, volumeid=root_volume[0].id, listall=True) self.assertEqual( validateList(snapshots)[0], PASS, "list snapshot is empty for volume id %s" % root_volume[0].id ) Template.register(self.userapiclient, self.testdata["privatetemplate"], zoneid=self.zone.id) Volume.create( self.userapiclient, self.testdata["volume"], zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid, diskofferingid=self.disk_offering.id, ) Iso.create( self.userapiclient, self.testdata["iso2"], zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid, ) # Step 3 # Deletion of zone should fail if vm,volume is present on the zone with self.assertRaises(Exception): self.zone.delete(self.apiclient) return
def setUpClass(cls): testClient = super(TestTemplates, cls).getClsTestClient() cls.apiclient = testClient.getApiClient() cls._cleanup = [] cls.services = testClient.getParsedTestDataConfig() cls.unsupportedHypervisor = False cls.hypervisor = testClient.getHypervisorInfo() if cls.hypervisor.lower() in ['lxc']: # Template creation from root volume is not supported in LXC cls.unsupportedHypervisor = True return # Get Zone, Domain and templates cls.domain = get_domain(cls.apiclient) cls.zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests()) cls.services['mode'] = cls.zone.networktype #populate second zone id for iso copy cls.zones = Zone.list(cls.apiclient) if not isinstance(cls.zones, list): raise Exception("Failed to find zones.") cls.disk_offering = DiskOffering.create(cls.apiclient, cls.services["disk_offering"]) template = get_template(cls.apiclient, cls.zone.id, cls.services["ostype"]) if template == FAILED: assert False, "get_template() failed to return template with description %s" % cls.services[ "ostype"] cls.services["virtual_machine"]["zoneid"] = cls.zone.id cls.services["volume"]["diskoffering"] = cls.disk_offering.id cls.services["volume"]["zoneid"] = cls.zone.id cls.services["template_2"]["zoneid"] = cls.zone.id cls.services["sourcezoneid"] = cls.zone.id cls.services["template"]["ostypeid"] = template.ostypeid cls.services["template_2"]["ostypeid"] = template.ostypeid cls.services["ostypeid"] = template.ostypeid cls.account = Account.create(cls.apiclient, cls.services["account"], admin=True, domainid=cls.domain.id) cls.user = Account.create(cls.apiclient, cls.services["account"], domainid=cls.domain.id) cls.service_offering = ServiceOffering.create( cls.apiclient, cls.services["service_offerings"]["tiny"]) #create virtual machine cls.virtual_machine = VirtualMachine.create( cls.apiclient, cls.services["virtual_machine"], templateid=template.id, accountid=cls.account.name, domainid=cls.account.domainid, serviceofferingid=cls.service_offering.id, mode=cls.services["mode"]) #Stop virtual machine cls.virtual_machine.stop(cls.apiclient) list_volume = Volume.list(cls.apiclient, virtualmachineid=cls.virtual_machine.id, type='ROOT', listall=True) try: cls.volume = list_volume[0] except Exception as e: raise Exception( "Exception: Unable to find root volume foe VM: %s - %s" % (cls.virtual_machine.id, e)) #Create templates for Edit, Delete & update permissions testcases cls.template_1 = Template.create(cls.apiclient, cls.services["template"], cls.volume.id, account=cls.account.name, domainid=cls.account.domainid) cls.template_2 = Template.create(cls.apiclient, cls.services["template_2"], cls.volume.id, account=cls.account.name, domainid=cls.account.domainid) cls._cleanup = [ cls.service_offering, cls.disk_offering, cls.account, cls.user ]
def setUpClass(cls): cls.testClient = super(TestUserPrivateGateways, cls).getClsTestClient() cls.apiclient = cls.testClient.getApiClient() cls.apiclient = cls.testClient.getApiClient() cls.services = cls.testClient.getParsedTestDataConfig() zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests()) cls.zone = Zone(zone.__dict__) cls.template = get_template(cls.apiclient, cls.zone.id) cls._cleanup = [] cls.logger = logging.getLogger("TestUserPrivateGateways") cls.stream_handler = logging.StreamHandler() cls.logger.setLevel(logging.DEBUG) cls.logger.addHandler(cls.stream_handler) cls.domain = get_domain(cls.apiclient) # Create small service offering cls.service_offering = ServiceOffering.create( cls.apiclient, cls.services["service_offerings"]["small"]) cls._cleanup.append(cls.service_offering) # Create network offering for isolated networks cls.network_offering_isolated = NetworkOffering.create( cls.apiclient, cls.services["network_offering"]) cls.network_offering_isolated.update(cls.apiclient, state='Enabled') cls._cleanup.append(cls.network_offering_isolated) # Create vpc offering cls.vpc_offering = VpcOffering.create( cls.apiclient, cls.services["vpc_offering_multi_lb"]) cls.vpc_offering.update(cls.apiclient, state='Enabled') cls._cleanup.append(cls.vpc_offering) # Create network offering for vpc tiers cls.network_offering_vpc = NetworkOffering.create( cls.apiclient, cls.services["nw_offering_isolated_vpc"], conservemode=False) cls.network_offering_vpc.update(cls.apiclient, state='Enabled') cls._cleanup.append(cls.network_offering_vpc) # Create sub-domain cls.sub_domain = Domain.create(cls.apiclient, cls.services["acl"]["domain1"]) cls._cleanup.append(cls.sub_domain) # Create domain admin and normal user cls.domain_admin = Account.create(cls.apiclient, cls.services["acl"]["accountD1A"], admin=True, domainid=cls.sub_domain.id) cls._cleanup.append(cls.domain_admin) cls.normal_user = Account.create(cls.apiclient, cls.services["acl"]["accountD1B"], domainid=cls.sub_domain.id) cls._cleanup.append(cls.normal_user) # Create project cls.project = Project.create(cls.apiclient, cls.services["project"], account=cls.domain_admin.name, domainid=cls.domain_admin.domainid) cls._cleanup.append(cls.project) # Create api clients for domain admin and normal user cls.domainadmin_user = cls.domain_admin.user[0] cls.domainapiclient = cls.testClient.getUserApiClient( cls.domainadmin_user.username, cls.sub_domain.name) cls.normaluser_user = cls.normal_user.user[0] cls.normaluser_apiclient = cls.testClient.getUserApiClient( cls.normaluser_user.username, cls.sub_domain.name)
def setUpClass(cls): cls.testClient = super(TestMulipleNicSupport, cls).getClsTestClient() cls.apiclient = cls.testClient.getApiClient() cls.testdata = cls.testClient.getParsedTestDataConfig() cls.services = cls.testClient.getParsedTestDataConfig() zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests()) cls.zone = Zone(zone.__dict__) cls._cleanup = [] cls.skip = False if str(cls.zone.securitygroupsenabled) != "True": cls.skip = True return cls.logger = logging.getLogger("TestMulipleNicSupport") cls.stream_handler = logging.StreamHandler() cls.logger.setLevel(logging.DEBUG) cls.logger.addHandler(cls.stream_handler) # Get Domain and templates cls.domain = get_domain(cls.apiclient) cls.services['mode'] = cls.zone.networktype cls.template = get_template(cls.apiclient, cls.zone.id, hypervisor="KVM") if cls.template == FAILED: cls.skip = True return # Create new domain, account, network and VM cls.user_domain = Domain.create( cls.apiclient, services=cls.testdata["acl"]["domain2"], parentdomainid=cls.domain.id) # Create account cls.account1 = Account.create(cls.apiclient, cls.testdata["acl"]["accountD2"], admin=True, domainid=cls.user_domain.id) # Create small service offering cls.service_offering = ServiceOffering.create( cls.apiclient, cls.testdata["service_offerings"]["small"]) cls._cleanup.append(cls.service_offering) cls.services["network"]["zoneid"] = cls.zone.id cls.network_offering = NetworkOffering.create( cls.apiclient, cls.services["network_offering"], ) # Enable Network offering cls.network_offering.update(cls.apiclient, state='Enabled') cls._cleanup.append(cls.network_offering) cls.testdata["virtual_machine"]["zoneid"] = cls.zone.id cls.testdata["virtual_machine"]["template"] = cls.template.id if cls.zone.securitygroupsenabled: # Enable networking for reaching to VM thorugh SSH security_group = SecurityGroup.create( cls.apiclient, cls.testdata["security_group"], account=cls.account1.name, domainid=cls.account1.domainid) # Authorize Security group to SSH to VM ingress_rule = security_group.authorize( cls.apiclient, cls.testdata["ingress_rule"], account=cls.account1.name, domainid=cls.account1.domainid) # Authorize Security group to SSH to VM ingress_rule2 = security_group.authorize( cls.apiclient, cls.testdata["ingress_rule_ICMP"], account=cls.account1.name, domainid=cls.account1.domainid) cls.testdata["shared_network_offering_sg"]["specifyVlan"] = 'True' cls.testdata["shared_network_offering_sg"]["specifyIpRanges"] = 'True' cls.shared_network_offering = NetworkOffering.create( cls.apiclient, cls.testdata["shared_network_offering_sg"], conservemode=False) NetworkOffering.update(cls.shared_network_offering, cls.apiclient, id=cls.shared_network_offering.id, state="enabled") physical_network, vlan = get_free_vlan(cls.apiclient, cls.zone.id) cls.testdata["shared_network_sg"][ "physicalnetworkid"] = physical_network.id random_subnet_number = random.randrange(90, 99) cls.testdata["shared_network_sg"][ "name"] = "Shared-Network-SG-Test-vlan" + str(random_subnet_number) cls.testdata["shared_network_sg"][ "displaytext"] = "Shared-Network-SG-Test-vlan" + str( random_subnet_number) cls.testdata["shared_network_sg"]["vlan"] = "vlan://" + str( random_subnet_number) cls.testdata["shared_network_sg"]["startip"] = "192.168." + str( random_subnet_number) + ".240" cls.testdata["shared_network_sg"]["endip"] = "192.168." + str( random_subnet_number) + ".250" cls.testdata["shared_network_sg"]["gateway"] = "192.168." + str( random_subnet_number) + ".254" cls.network1 = Network.create( cls.apiclient, cls.testdata["shared_network_sg"], networkofferingid=cls.shared_network_offering.id, zoneid=cls.zone.id, accountid=cls.account1.name, domainid=cls.account1.domainid) random_subnet_number = random.randrange(100, 110) cls.testdata["shared_network_sg"][ "name"] = "Shared-Network-SG-Test-vlan" + str(random_subnet_number) cls.testdata["shared_network_sg"][ "displaytext"] = "Shared-Network-SG-Test-vlan" + str( random_subnet_number) cls.testdata["shared_network_sg"]["vlan"] = "vlan://" + str( random_subnet_number) cls.testdata["shared_network_sg"]["startip"] = "192.168." + str( random_subnet_number) + ".240" cls.testdata["shared_network_sg"]["endip"] = "192.168." + str( random_subnet_number) + ".250" cls.testdata["shared_network_sg"]["gateway"] = "192.168." + str( random_subnet_number) + ".254" cls.network2 = Network.create( cls.apiclient, cls.testdata["shared_network_sg"], networkofferingid=cls.shared_network_offering.id, zoneid=cls.zone.id, accountid=cls.account1.name, domainid=cls.account1.domainid) random_subnet_number = random.randrange(111, 120) cls.testdata["shared_network_sg"][ "name"] = "Shared-Network-SG-Test-vlan" + str(random_subnet_number) cls.testdata["shared_network_sg"][ "displaytext"] = "Shared-Network-SG-Test-vlan" + str( random_subnet_number) cls.testdata["shared_network_sg"]["vlan"] = "vlan://" + str( random_subnet_number) cls.testdata["shared_network_sg"]["startip"] = "192.168." + str( random_subnet_number) + ".240" cls.testdata["shared_network_sg"]["endip"] = "192.168." + str( random_subnet_number) + ".250" cls.testdata["shared_network_sg"]["gateway"] = "192.168." + str( random_subnet_number) + ".254" cls.network3 = Network.create( cls.apiclient, cls.testdata["shared_network_sg"], networkofferingid=cls.shared_network_offering.id, zoneid=cls.zone.id, accountid=cls.account1.name, domainid=cls.account1.domainid) try: cls.virtual_machine1 = VirtualMachine.create( cls.apiclient, cls.testdata["virtual_machine"], accountid=cls.account1.name, domainid=cls.account1.domainid, serviceofferingid=cls.service_offering.id, templateid=cls.template.id, securitygroupids=[security_group.id], networkids=cls.network1.id) for nic in cls.virtual_machine1.nic: if nic.isdefault: cls.virtual_machine1.ssh_ip = nic.ipaddress cls.virtual_machine1.default_network_id = nic.networkid break except Exception as e: cls.fail("Exception while deploying virtual machine: %s" % e) try: cls.virtual_machine2 = VirtualMachine.create( cls.apiclient, cls.testdata["virtual_machine"], accountid=cls.account1.name, domainid=cls.account1.domainid, serviceofferingid=cls.service_offering.id, templateid=cls.template.id, securitygroupids=[security_group.id], networkids=[str(cls.network1.id), str(cls.network2.id)]) for nic in cls.virtual_machine2.nic: if nic.isdefault: cls.virtual_machine2.ssh_ip = nic.ipaddress cls.virtual_machine2.default_network_id = nic.networkid break except Exception as e: cls.fail("Exception while deploying virtual machine: %s" % e) cls._cleanup.append(cls.virtual_machine1) cls._cleanup.append(cls.virtual_machine2) cls._cleanup.append(cls.network1) cls._cleanup.append(cls.network2) cls._cleanup.append(cls.network3) cls._cleanup.append(cls.shared_network_offering) if cls.zone.securitygroupsenabled: cls._cleanup.append(security_group) cls._cleanup.append(cls.account1) cls._cleanup.append(cls.user_domain)
def test_01_disable_enable_zone(self): """disable enable zone 1. Disable zone and verify following things: For admin user: 1. Should be create to start/stop exsiting vms 2. Should be create to deploy new vm, snapshot,volume, template,iso in the same zone For Non-admin user: 1. Should be create to start/stop exsiting vms 2. Should not be create to deploy new vm, snapshot,volume, template,iso in the same zone 2. Enable the above disabled zone and verify that: -All users should be create to deploy new vm, snapshot,volume,template,iso in the same zone 3. Try to delete the zone and it should fail with error message: -"The zone is not deletable because there are servers running in this zone" """ # Step 1 vm_user = VirtualMachine.create( self.userapiclient, self.testdata["small"], templateid=self.template.id, accountid=self.account.name, domainid=self.account.domainid, serviceofferingid=self.service_offering.id, zoneid=self.zone.id ) vm_root = VirtualMachine.create( self.apiclient, self.testdata["small"], templateid=self.template.id, accountid=self.account.name, domainid=self.account.domainid, serviceofferingid=self.service_offering.id, zoneid=self.zone.id ) cmd = updateZone.updateZoneCmd() cmd.id = self.zone.id cmd.allocationstate = DISABLED self.apiclient.updateZone(cmd) zoneList = Zone.list(self.apiclient, id=self.zone.id) self.assertEqual(zoneList[0].allocationstate, DISABLED, "Check if the zone is in disabled state" ) # Both user and admin vms shoul be running self.assertEqual(vm_user.state, RUNNING, "Verify that the user vm is running") self.assertEqual(vm_root.state, RUNNING, "Verify that the admin vm is running") vm_root.stop(self.apiclient) vm_user.stop(self.apiclient) root_state = self.dbclient.execute( "select state from vm_instance where name='%s'" % vm_root.name)[0][0] user_state = self.dbclient.execute( "select state from vm_instance where name='%s'" % vm_user.name)[0][0] self.assertEqual(root_state, STOPPED, "verify that vm is Stopped") self.assertEqual(user_state, STOPPED, "verify that vm is stopped") root_volume = list_volumes( self.userapiclient, virtualmachineid=vm_root.id, type='ROOT', listall=True ) snap = Snapshot.create( self.apiclient, root_volume[0].id) self.assertNotEqual(snap, None, "Verify that admin should be \ able to create snapshot") snapshots = list_snapshots( self.apiclient, volumeid=root_volume[0].id, listall=True) template_from_snapshot = Template.create_from_snapshot( self.apiclient, snapshots[0], self.testdata["privatetemplate"]) self.assertNotEqual( template_from_snapshot, None, "Verify that admin should be able to create template" ) builtin_info = get_builtin_template_info(self.apiclient, self.zone.id) self.testdata["privatetemplate"]["url"] = builtin_info[0] self.testdata["privatetemplate"]["hypervisor"] = builtin_info[1] self.testdata["privatetemplate"]["format"] = builtin_info[2] template_regis = Template.register( self.apiclient, self.testdata["privatetemplate"], zoneid=self.zone.id) self.assertNotEqual( template_regis, None, "Check if template gets created" ) self.assertNotEqual( template_from_snapshot, None, "Check if template gets created" ) data_volume = Volume.create( self.apiclient, self.testdata["volume"], zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid, diskofferingid=self.disk_offering.id ) self.assertNotEqual( data_volume, None, "Check if volume gets created" ) ISO = Iso.create( self.apiclient, self.testdata["iso2"], zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid, ) self.assertNotEqual( ISO, None, "Check if volume gets created" ) # non-admin user should fail to create vm, snap, temp etc with self.assertRaises(Exception): VirtualMachine.create(self.userapiclient, self.testdata["small"], templateid=self.template.id, accountid=self.account.name, domainid=self.account.domainid, serviceofferingid=self.service_offering.id, zoneid=self.zone.id ) root_volume = list_volumes( self.userapiclient, virtualmachineid=vm_user.id, type='ROOT', listall=True ) with self.assertRaises(Exception): snap = Snapshot.create( self.userapiclient, root_volume[0].id) with self.assertRaises(Exception): Template.register( self.userapiclient, self.testdata["privatetemplate"], zoneid=self.zone.id) with self.assertRaises(Exception): Volume.create( self.userapiclient, self.testdata["volume"], zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid, diskofferingid=self.disk_offering.id ) with self.assertRaises(Exception): ISO = Iso.create( self.userapiclient, self.testdata["iso2"], zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid, ) # Step 2 cmd.allocationstate = ENABLED self.apiclient.updateZone(cmd) # After enabling the zone all users should be able to add new VM, # volume, template and iso root_vm_new = VirtualMachine.create( self.apiclient, self.testdata["small"], templateid=self.template.id, accountid=self.account.name, domainid=self.account.domainid, serviceofferingid=self.service_offering.id, zoneid=self.zone.id ) self.assertNotEqual(root_vm_new, None, "Verify that admin should create new VM") snap = Snapshot.create( self.apiclient, root_volume[0].id) self.assertNotEqual(snap, None, "Verify that admin should snashot") snapshots = list_snapshots( self.apiclient, volumeid=root_volume[0].id, listall=True) template_from_snapshot = Template.create_from_snapshot( self.apiclient, snapshots[0], self.testdata["privatetemplate"]) self.assertNotEqual( template_from_snapshot, None, "Check if template gets created" ) template_regis = Template.register( self.apiclient, self.testdata["privatetemplate"], zoneid=self.zone.id) self.assertNotEqual( template_regis, None, "Check if template gets created" ) self.assertNotEqual( template_from_snapshot, None, "Check if template gets created" ) data_volume = Volume.create( self.apiclient, self.testdata["volume"], zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid, diskofferingid=self.disk_offering.id ) self.assertNotEqual( data_volume, None, "Check if volume gets created" ) ISO = Iso.create( self.apiclient, self.testdata["iso2"], zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid, ) self.assertNotEqual( ISO, None, "Check if volume gets created" ) root_vm_new.delete(self.apiclient) # Non root user user_vm_new = VirtualMachine.create( self.userapiclient, self.testdata["small"], templateid=self.template.id, accountid=self.account.name, domainid=self.account.domainid, serviceofferingid=self.service_offering.id, zoneid=self.zone.id ) self.assertNotEqual(user_vm_new, None, "Verify that admin should create new VM") snap = Snapshot.create( self.userapiclient, root_volume[0].id) self.assertNotEqual(snap, None, "Verify that admin should snashot") snapshots = list_snapshots( self.userapiclient, volumeid=root_volume[0].id, listall=True) template_regis = Template.register( self.userapiclient, self.testdata["privatetemplate"], zoneid=self.zone.id) self.assertNotEqual( template_regis, None, "Check if template gets created" ) self.assertNotEqual( template_from_snapshot, None, "Check if template gets created" ) data_volume = Volume.create( self.userapiclient, self.testdata["volume"], zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid, diskofferingid=self.disk_offering.id ) self.assertNotEqual( data_volume, None, "Check if volume gets created" ) ISO = Iso.create( self.userapiclient, self.testdata["iso2"], zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid, ) self.assertNotEqual( ISO, None, "Check if volume gets created" ) user_vm_new.delete(self.apiclient) # Step 3 # Deletion of zone should fail if vm,volume is present on the zone with self.assertRaises(Exception): self.zone.delete(self.apiclient) return