def setUp(self): self.apiclient = self.testClient.getApiClient() self.hypervisor = self.testClient.getHypervisorInfo() self.dbclient = self.testClient.getDbConnection() self.services = Services().services self.services["virtual_machine"]["zoneid"] = self.zone.id self.account = Account.create(self.apiclient, self.services["account"], domainid=self.domain.id) builtin_info = get_builtin_template_info(self.apiclient, self.zone.id) self.services["template"]["url"] = builtin_info[0] self.services["template"]["hypervisor"] = builtin_info[1] self.services["template"]["format"] = builtin_info[2] # Register new template self.template = Template.register( self.apiclient, self.services["template"], zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid, hypervisor=self.hypervisor, ) self.debug( "Registered a template of format: %s with ID: %s" % (self.services["template"]["format"], self.template.id) ) try: self.template.download(self.apiclient) except Exception as e: raise Exception("Template download failed: %s" % e) self.cleanup = [self.account] return
def setUpClass(cls): testClient = super(TestlistTemplatesDomainAdmin, cls).getClsTestClient() cls.apiclient = testClient.getApiClient() cls.testdata = testClient.getParsedTestDataConfig() cls.zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests()) cls.hypervisor = cls.testClient.getHypervisorInfo() builtin_info = get_builtin_template_info(cls.apiclient, cls.zone.id) cls.testdata["privatetemplate"]["url"] = builtin_info[0] cls.testdata["privatetemplate"]["hypervisor"] = builtin_info[1] cls.testdata["privatetemplate"]["format"] = builtin_info[2] cls.cleanup = [] # Create 2 domain admin accounts cls.domain1 = Domain.create(cls.apiclient, cls.testdata["domain"]) cls.domain2 = Domain.create(cls.apiclient, cls.testdata["domain"]) cls.account1 = Account.create(cls.apiclient, cls.testdata["account"], admin=True, domainid=cls.domain1.id) cls.account2 = Account.create(cls.apiclient, cls.testdata["account2"], admin=True, domainid=cls.domain2.id) cls.debug("Created account %s in domain %s" % (cls.account1.name, cls.domain1.id)) cls.debug("Created account %s in domain %s" % (cls.account2.name, cls.domain2.id)) cls.cleanup.append(cls.account1) cls.cleanup.append(cls.account2) cls.cleanup.append(cls.domain1) cls.cleanup.append(cls.domain2)
def setUpClass(cls): try: cls._cleanup = [] cls.testClient = super(TestTemplates, cls).getClsTestClient() cls.api_client = cls.testClient.getApiClient() cls.services = cls.testClient.getParsedTestDataConfig() # Get Domain, Zone, Template cls.domain = get_domain(cls.api_client) cls.zone = get_zone( cls.api_client, cls.testClient.getZoneForTests()) cls.template = get_template( cls.api_client, cls.zone.id, cls.services["ostype"] ) cls.hypervisor = cls.testClient.getHypervisorInfo() cls.services['mode'] = cls.zone.networktype builtin_info = get_builtin_template_info(cls.api_client, cls.zone.id) cls.services["privatetemplate"]["url"] = builtin_info[0] cls.services["privatetemplate"]["hypervisor"] = builtin_info[1] cls.services["privatetemplate"]["format"] = builtin_info[2] except Exception as e: cls.tearDownClass() raise Exception("Warning: Exception in setup : %s" % e) return
def registerTemplate(self, inProject=False): """Register and download template by default in the account/domain, in project if stated so""" try: builtin_info = get_builtin_template_info(self.apiclient, self.zone.id) self.services["template_2"]["url"] = builtin_info[0] self.services["template_2"]["hypervisor"] = builtin_info[1] self.services["template_2"]["format"] = builtin_info[2] template = Template.register(self.apiclient, self.services["template_2"], zoneid=self.zone.id, account=self.child_do_admin.name if not inProject else None, domainid=self.child_do_admin.domainid if not inProject else None, projectid=self.project.id if inProject else None) template.download(self.apiclient) templates = Template.list(self.apiclient, templatefilter=\ self.services["template_2"]["templatefilter"], id=template.id) self.assertEqual(validateList(templates)[0], PASS,\ "templates list validation failed") self.templateSize = (templates[0].size / (1024**3)) except Exception as e: return [FAIL, e] return [PASS, None]
def test_01_register_template(self, value): """Test register template # Validate the following: 1. Create a root domain admin/ child domain admin account 2. Register and download a template according to hypervisor type 3. Verify that the template is listed 4. Verify that the secondary storage count for the account equals the size of the template 5. Delete the template 6. Verify that the secondary storage resource count of the account equals 0 """ response = self.setupAccount(value) self.assertEqual(response[0], PASS, response[1]) builtin_info = get_builtin_template_info(self.apiclient, self.zone.id) self.services["template_2"]["url"] = builtin_info[0] self.services["template_2"]["hypervisor"] = builtin_info[1] self.services["template_2"]["format"] = builtin_info[2] try: template = Template.register(self.apiclient, self.services["template_2"], zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid, hypervisor=self.hypervisor) template.download(self.apiclient) except Exception as e: self.fail("Failed to register template: %s" % e) templates = Template.list(self.apiclient, templatefilter=\ self.services["template_2"]["templatefilter"], id=template.id) self.assertEqual(validateList(templates)[0],PASS,\ "templates list validation failed") templateSize = (templates[0].size / (1024**3)) expectedCount = templateSize response = matchResourceCount( self.apiclient, expectedCount, RESOURCE_SECONDARY_STORAGE, accountid=self.account.id) self.assertEqual(response[0], PASS, response[1]) try: template.delete(self.apiclient) except Exception as e: self.fail("Failed to delete template: %s" % e) expectedCount = 0 response = matchResourceCount( self.apiclient, expectedCount, RESOURCE_SECONDARY_STORAGE, accountid=self.account.id) self.assertEqual(response[0], PASS, response[1]) return
def setUpClass(cls): testClient = super( TestlistTemplates, cls).getClsTestClient() cls.apiclient = testClient.getApiClient() cls.testdata = testClient.getParsedTestDataConfig() cls.zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests()) cls.template = get_template( cls.apiclient, cls.zone.id, cls.testdata["ostype"] ) cls.hypervisor = cls.testClient.getHypervisorInfo() builtin_info = get_builtin_template_info(cls.apiclient, cls.zone.id) cls.testdata["templates"]["url"] = builtin_info[0] cls.testdata["templates"]["hypervisor"] = builtin_info[1] cls.testdata["templates"]["format"] = builtin_info[2] if cls.zone.localstorageenabled: cls.storagetype = 'local' cls.testdata["service_offerings"]["tiny"]["storagetype"] = 'local' cls.testdata["disk_offering"]["storagetype"] = 'local' else: cls.storagetype = 'shared' cls.testdata["service_offerings"]["tiny"]["storagetype"] = 'shared' cls.testdata["disk_offering"]["storagetype"] = 'shared' cls.testdata["virtual_machine"]["hypervisor"] = cls.hypervisor cls.testdata["virtual_machine"]["zoneid"] = cls.zone.id cls.testdata["virtual_machine"]["template"] = cls.template.id cls.testdata["custom_volume"]["zoneid"] = cls.zone.id cls.service_offering = ServiceOffering.create( cls.apiclient, cls.testdata["service_offerings"]["tiny"] ) cls.mgtSvrDetails = cls.config.__dict__["mgtSvr"][0].__dict__ cls.cleanup = [] # Create 1 domain admin account cls.domain = Domain.create( cls.apiclient, cls.testdata["domain"]) cls.account = Account.create( cls.apiclient, cls.testdata["account"], admin=True, domainid=cls.domain.id) cls.debug("Created account %s in domain %s" % (cls.account.name, cls.domain.id)) cls.cleanup.append(cls.account) cls.cleanup.append(cls.domain)
def setUpClass(cls): try: cls._cleanup = [] cls.testClient = super(TestTemplates, cls).getClsTestClient() cls.api_client = cls.testClient.getApiClient() cls.services = cls.testClient.getParsedTestDataConfig() # Get Domain, Zone, Template cls.domain = get_domain(cls.api_client) cls.zone = get_zone( cls.api_client, cls.testClient.getZoneForTests()) cls.template = get_template( cls.api_client, cls.zone.id, cls.services["ostype"] ) cls.hypervisor = cls.testClient.getHypervisorInfo() cls.services['mode'] = cls.zone.networktype cls.mgtSvrDetails = cls.config.__dict__["mgtSvr"][0].__dict__ builtin_info = get_builtin_template_info(cls.api_client, cls.zone.id) cls.services["privatetemplate"]["url"] = builtin_info[0] cls.services["privatetemplate"]["hypervisor"] = builtin_info[1] cls.services["privatetemplate"]["format"] = builtin_info[2] cls.services["templates"]["url"] = builtin_info[0] cls.services["templates"]["hypervisor"] = builtin_info[1] cls.services["templates"]["format"] = builtin_info[2] if cls.zone.localstorageenabled: cls.storagetype = 'local' cls.services["service_offerings"][ "tiny"]["storagetype"] = 'local' cls.services["disk_offering"]["storagetype"] = 'local' else: cls.storagetype = 'shared' cls.services["service_offerings"][ "tiny"]["storagetype"] = 'shared' cls.services["disk_offering"]["storagetype"] = 'shared' cls.services["virtual_machine"]["hypervisor"] = cls.hypervisor cls.services["virtual_machine"]["zoneid"] = cls.zone.id cls.services["virtual_machine"]["template"] = cls.template.id cls.services["custom_volume"]["zoneid"] = cls.zone.id cls.service_offering = ServiceOffering.create( cls.api_client, cls.services["service_offerings"]["tiny"] ) cls._cleanup.append(cls.service_offering) except Exception as e: cls.tearDownClass() raise Exception("Warning: Exception in setup : %s" % e) return
def setUpClass(cls): try: testClient = super(TestGatewayOnSharedNetwork, cls).getClsTestClient() cls.apiclient = testClient.getApiClient() cls.services = testClient.getParsedTestDataConfig() cls._cleanup = [] # Get Zone, Domain and templates cls.domain = get_domain(cls.apiclient) cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests()) cls.services['mode'] = cls.zone.networktype cls.hypervisor = testClient.getHypervisorInfo() cls.service_offering = ServiceOffering.create( cls.apiclient, cls.services["service_offering"]) cls._cleanup.append(cls.service_offering) builtin_info = get_builtin_template_info(cls.apiclient, cls.zone.id) cls.services["template"]["url"] = builtin_info[0] cls.services["template"]["hypervisor"] = builtin_info[1] cls.services["template"]["format"] = builtin_info[2] cls.template = get_template(cls.apiclient, cls.zone.id) # # Register new template # cls.template = Template.register( # cls.apiclient, # cls.services["template"], # zoneid=cls.zone.id, # hypervisor=cls.hypervisor # ) # cls._cleanup.append(cls.template) cls.services["shared_network_offering"]["specifyVlan"] = "True" cls.services["shared_network_offering"]["specifyIpRanges"] = "True" cls.shared_network_offering = NetworkOffering.create( cls.apiclient, cls.services["shared_network_offering"], conservemode=False) cls._cleanup.append(cls.shared_network_offering) NetworkOffering.update(cls.shared_network_offering, cls.apiclient, id=cls.shared_network_offering.id, state="enabled") except Exception as e: cls.tearDownClass() raise unittest.SkipTest("Exception in setUpClass: %s" % e)
def setUpClass(cls): testClient = super( TestlistTemplatesDomainAdmin, cls).getClsTestClient() cls.apiclient = testClient.getApiClient() cls.testdata = testClient.getParsedTestDataConfig() cls.zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests()) cls.hypervisor = cls.testClient.getHypervisorInfo() builtin_info = get_builtin_template_info(cls.apiclient, cls.zone.id) cls.testdata["privatetemplate"]["url"] = builtin_info[0] cls.testdata["privatetemplate"]["hypervisor"] = builtin_info[1] cls.testdata["privatetemplate"]["format"] = builtin_info[2] cls.cleanup = [] # Create 2 domain admin accounts cls.domain1 = Domain.create( cls.apiclient, cls.testdata["domain"]) cls.domain2 = Domain.create( cls.apiclient, cls.testdata["domain"]) cls.account1 = Account.create( cls.apiclient, cls.testdata["account"], admin=True, domainid=cls.domain1.id) cls.account2 = Account.create( cls.apiclient, cls.testdata["account2"], admin=True, domainid=cls.domain2.id) cls.debug("Created account %s in domain %s" % (cls.account1.name, cls.domain1.id)) cls.debug("Created account %s in domain %s" % (cls.account2.name, cls.domain2.id)) cls.cleanup.append(cls.account1) cls.cleanup.append(cls.account2) cls.cleanup.append(cls.domain1) cls.cleanup.append(cls.domain2)
def test_07_templates_per_project(self): """Test Templates limit per project """ # 1. set max no of templates per project to 1. # 2. Create a template in this project. Both template should be in # ready state # 3. Try create 2nd template in the project. It should give the user # appropriate error and an alert should be generated. # Reset the volume limits update_resource_limit( self.apiclient, 2, # Volume max=5, projectid=self.project.id ) self.debug( "Updating template resource limits for domain: %s" % self.account.domainid) # Set usage_vm=1 for Account 1 update_resource_limit( self.apiclient, 4, # Template max=1, projectid=self.project.id ) # Register the First Template in the project self.debug("Register the First Template in the project") builtin_info = get_builtin_template_info(self.apiclient, self.zone.id) self.services["template"]["url"] = builtin_info[0] self.services["template"]["hypervisor"] = builtin_info[1] self.services["template"]["format"] = builtin_info[2] # Register new template template = Template.register( self.userapiclient, self.services["template"], zoneid=self.zone.id, projectid=self.project.id ) self.debug( "Registered a template of format: %s with ID: %s" % ( self.services["template"]["format"], template.id )) self.cleanup.append(template) # Wait for template status to be changed across time.sleep(self.services["sleep"]) timeout = self.services["timeout"] while True: list_template_response = Template.list( self.apiclient, templatefilter='all', id=template.id, zoneid=self.zone.id, projectid=self.project.id, ) if list_template_response[0].isready is True: break elif timeout == 0: raise Exception("Template state is not ready, it is %s" % list_template_response[0].isready) time.sleep(self.services["sleep"]) timeout = timeout - 1 #Verify template response to check whether template added successfully self.assertEqual( isinstance(list_template_response, list), True, "Check for list template response return valid data" ) self.assertNotEqual( len(list_template_response), 0, "Check template available in List Templates" ) template_response = list_template_response[0] self.assertEqual( template_response.isready, True, "Template state is not ready, it is %s" % template_response.isready ) # Exception should be raised for second template with self.assertRaises(Exception): Template.register( self.userapiclient, self.services["template"], zoneid=self.zone.id, projectid=self.project.id ) return
def test_01_disable_enable_pod(self): """disable enable Pod 1. Disable pod and verify following things: For admin user: -- Should be able to create new vm, snapshot, volume,template,iso in the same pod For Non-admin user: -- Should not be able to create new vm, snapshot, volume,template,iso in the same pod 2. Enable the above disabled pod and verify that: -All users should be able to create new vm, snapshot, volume,template,iso in the same pod 3. Try to delete the pod and it should fail with error message: - "The pod is not deletable because there are servers running in this pod" """ # 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 = updatePod.updatePodCmd() cmd.id = self.pod.id cmd.allocationstate = DISABLED self.apiclient.updatePod(cmd) podList = Pod.list(self.apiclient, id=self.pod.id) self.assertEqual(podList[0].allocationstate, DISABLED, "Check if the pod is in disabled state") 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") 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, ) root_volume = list_volumes(self.apiclient, virtualmachineid=vm_root.id, type="ROOT", listall=True) self.assertEqual(validateList(root_volume)[0], PASS, "list snapshot is empty for volume id %s" % vm_root.id) 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] 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, ) 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 volume id %s" % vm_user.id) if self.snapshotSupported: Snapshot.create(self.userapiclient, 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 2 cmd.allocationstate = ENABLED self.apiclient.updatePod(cmd) podList = Pod.list(self.apiclient, id=self.pod.id) self.assertEqual(podList[0].allocationstate, ENABLED, "Check if the pod is in enabled state") 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 be able \ to 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, ) user_vm_new.delete(self.apiclient) # Step 3 # Deletion of zone should fail if resources are running on the zone with self.assertRaises(Exception): self.pod.delete(self.apiclient) return
def test_02_multiple_domains_secondary_storage_counts(self): """Test secondary storage counts in multiple child domains # Steps 1. Create a parent domain and two sub-domains in it (also admin accounts of each domain) Repeat following steps for both the child domains 2. Register template in child domain 3. Check if the resource count for domain is updated correctly 4. Delete the template 5. Verify that the resource count for the domain is 0 """ users = None # Setting up account and domain hierarchy result = self.setupAccounts() self.assertEqual(result[0], PASS, result[1]) users = result[2] for domain, admin in users.items(): self.account = admin self.domain = domain try: builtin_info = get_builtin_template_info( self.apiclient, self.zone.id) self.services["template_2"]["url"] = builtin_info[0] self.services["template_2"]["hypervisor"] = builtin_info[1] self.services["template_2"]["format"] = builtin_info[2] template = Template.register(self.apiclient, self.services["template_2"], zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid) template.download(self.apiclient) templates = Template.list(self.apiclient, templatefilter=\ self.services["template_2"]["templatefilter"], id=template.id) if validateList(templates)[0] == FAIL: raise Exception("templates list validation failed") templateSize = int(int(templates[0].size) / (1024**3)) expectedCount = templateSize result = isDomainResourceCountEqualToExpectedCount( self.apiclient, self.domain.id, expectedCount, RESOURCE_SECONDARY_STORAGE) self.assertFalse(result[0], result[1]) self.assertTrue(result[2], "Resource count does not match") template.delete(self.apiclient) expectedCount = 0 result = isDomainResourceCountEqualToExpectedCount( self.apiclient, self.domain.id, expectedCount, RESOURCE_SECONDARY_STORAGE) self.assertFalse(result[0], result[1]) self.assertTrue(result[2], "Resource count does not match") except Exception as e: self.fail("Failed to get zone list: %s" % e) return
def test_01_create_template(self): """TS_BUG_002-Test to create and deploy VM using password enabled template """ # Validate the following: #1. Create a password enabled template #2. Deploy VM using this template #3. Deploy VM should return password set in template. builtin_info = get_builtin_template_info(self.apiclient, self.zone.id) self.services["template"]["url"] = builtin_info[0] self.services["template"]["hypervisor"] = builtin_info[1] self.services["template"]["format"] = builtin_info[2] self.debug("Registering a new template") # Register new template template = Template.register(self.apiclient, self.services["template"], zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid, hypervisor=self.hypervisor) self.debug("Registered a template of format: %s with ID: %s" % (self.services["template"]["format"], template.id)) try: # Wait for template to download template.download(self.apiclient) except Exception as e: self.fail("Exception while downloading template %s: %s"\ % (template.id, e)) self.cleanup.append(template) # Wait for template status to be changed across time.sleep(self.services["sleep"]) list_template_response = Template.list( self.apiclient, templatefilter=\ self.services["template"]["templatefilter"], id=template.id, zoneid=self.zone.id ) self.assertEqual(isinstance(list_template_response, list), True, "Check list response returns a valid list") #Verify template response to check whether template added successfully self.assertNotEqual(len(list_template_response), 0, "Check template available in List Templates") template_response = list_template_response[0] self.assertEqual( template_response.isready, True, "Template state is not ready, it is %s" % template_response.isready) # Deploy new virtual machine using template virtual_machine = VirtualMachine.create( self.apiclient, self.services["virtual_machine"], templateid=template.id, accountid=self.account.name, domainid=self.account.domainid, serviceofferingid=self.service_offering.id, ) self.debug("Deployed VM with ID: %s " % virtual_machine.id) self.assertEqual(hasattr(virtual_machine, "password"), True, "Check if the deployed VM returned a password") return
def setUpClass(cls): testClient = super(TestPathVMLC, cls).getClsTestClient() cls.apiclient = testClient.getApiClient() cls.testdata = testClient.getParsedTestDataConfig() cls.hypervisor = testClient.getHypervisorInfo() # Get Zone, Domain and templates cls.domain = get_domain(cls.apiclient) cls.zone = get_zone(cls.apiclient) cls._cleanup = [] try: # Create an account cls.account = Account.create( cls.apiclient, cls.testdata["account"], domainid=cls.domain.id ) cls._cleanup.append(cls.account) # If local storage is enabled, alter the offerings to use # localstorage if cls.zone.localstorageenable: cls.testdata["service_offering"]["storagetype"] = 'local' # Create 3 service offerings with different values for # for cpunumber, cpuspeed, and memory cls.testdata["service_offering"]["cpuspeed"] = 128 cls.testdata["service_offering"]["memory"] = 256 cls.testdata["service_offering"]["cpunumber"] = 1 cls.service_offering_1 = ServiceOffering.create( cls.apiclient, cls.testdata["service_offering"] ) cls._cleanup.append(cls.service_offering_1) cls.testdata["service_offering"]["cpunumber"] = 2 cls.service_offering_2 = ServiceOffering.create( cls.apiclient, cls.testdata["service_offering"] ) cls._cleanup.append(cls.service_offering_2) # Create isolated network offering cls.isolated_network_offering = CreateEnabledNetworkOffering( cls.apiclient, cls.testdata["isolated_network_offering"] ) cls._cleanup.append(cls.isolated_network_offering) # Create shared network offering cls.testdata["shared_network_offering_all_services"][ "specifyVlan"] = "True" cls.testdata["shared_network_offering_all_services"][ "specifyIpRanges"] = "True" cls.shared_network_offering = CreateEnabledNetworkOffering( cls.apiclient, cls.testdata["shared_network_offering_all_services"] ) cls._cleanup.append(cls.shared_network_offering) cls.isolated_network_offering_vpc = CreateEnabledNetworkOffering( cls.apiclient, cls.testdata["nw_offering_isolated_vpc"] ) cls._cleanup.append(cls.isolated_network_offering_vpc) cls.vpc_off = VpcOffering.create(cls.apiclient, cls.testdata["vpc_offering"] ) cls.vpc_off.update(cls.apiclient, state='Enabled') cls._cleanup.append(cls.vpc_off) # This variable will store the id of vpc network whenever # test case creates it # If not created, it will be None and will not be used cls.vpcid = None # Create user api client of the account cls.userapiclient = testClient.getUserApiClient( UserName=cls.account.name, DomainName=cls.account.domain ) # Register a private template in the account builtin_info = get_builtin_template_info(cls.apiclient, cls.zone.id) cls.testdata["privatetemplate"]["url"] = builtin_info[0] cls.testdata["privatetemplate"]["hypervisor"] = builtin_info[1] cls.testdata["privatetemplate"]["format"] = builtin_info[2] # Register new template cls.template = Template.register( cls.userapiclient, cls.testdata["privatetemplate"], zoneid=cls.zone.id, account=cls.account.name, domainid=cls.account.domainid ) # Wait for template to download cls.template.download(cls.apiclient) # Check that we are able to login to the created account respose = User.login( cls.apiclient, username=cls.account.name, password=cls.testdata["account"]["password"] ) assert respose.sessionkey is not None,\ "Login to the CloudStack should be successful\ response shall have non Null key" except Exception as e: cls.tearDownClass() raise e return
def test_01_create_template(self): """Test create public & private template """ # Validate the following: # 1. Upload a templates in raw img format. Create a Vm instances from # raw img template. # 2. Upload a templates in zip file format. Create a Vm instances from # zip template. # 3. Upload a templates in tar format.Create a Vm instances from tar # template. # 4. Upload a templates in tar gzip format.Create a Vm instances from # tar gzip template. # 5. Upload a templates in tar bzip format. Create a Vm instances from # tar bzip template. # 6. Verify VMs & Templates is up and in ready state builtin_info = get_builtin_template_info(self.apiclient, self.zone.id) self.services["templates"][0]["url"] = builtin_info[0] self.services["templates"][0]["hypervisor"] = builtin_info[1] self.services["templates"][0]["format"] = builtin_info[2] # Register new template template = Template.register( self.apiclient, self.services["templates"][0], zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid, hypervisor=self.hypervisor ) self.debug( "Registered a template of format: %s with ID: %s" % ( self.services["templates"][0]["format"], template.id )) # Wait for template to download template.download(self.apiclient) self.cleanup.append(template) # Wait for template status to be changed across time.sleep(self.services["sleep"]) timeout = self.services["timeout"] while True: list_template_response = Template.list( self.apiclient, templatefilter='all', id=template.id, zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid) if isinstance(list_template_response, list): break elif timeout == 0: raise Exception("List template failed!") time.sleep(5) timeout = timeout - 1 # Verify template response to check whether template added successfully self.assertEqual( isinstance(list_template_response, list), True, "Check for list template response return valid data" ) self.assertNotEqual( len(list_template_response), 0, "Check template available in List Templates" ) template_response = list_template_response[0] self.assertEqual( template_response.isready, True, "Template state is not ready, it is %s" % template_response.isready ) # Deploy new virtual machine using template virtual_machine = VirtualMachine.create( self.apiclient, self.services["virtual_machine"], templateid=template.id, accountid=self.account.name, domainid=self.account.domainid, serviceofferingid=self.service_offering.id, mode=self.services["mode"] ) self.debug("creating an instance with template ID: %s" % template.id) vm_response = VirtualMachine.list(self.apiclient, id=virtual_machine.id, account=self.account.name, domainid=self.account.domainid) self.assertEqual( isinstance(vm_response, list), True, "Check for list VMs response after VM deployment" ) # Verify VM response to check whether VM deployment was successful self.assertNotEqual( len(vm_response), 0, "Check VMs available in List VMs response" ) vm = vm_response[0] self.assertEqual( vm.state, 'Running', "Check the state of VM created from Template" ) return
def test_01_create_template_snampshot(self): builtin_info = get_builtin_template_info(self.apiclient, self.zone.id) self.services["templates"][0]["url"] = builtin_info[0] self.services["templates"][0]["hypervisor"] = builtin_info[1] self.services["templates"][0]["format"] = builtin_info[2] # Register new template template = Template.register( self.apiclient, self.services["templates"][0], zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid, hypervisor=self.hypervisor, details=[{"keyboard":"us","nicAdapter":"e1000","rootDiskController":"scsi"}] ) self.debug( "Registered a template of format: %s with ID: %s" % ( self.services["templates"][0]["format"], template.id )) # Wait for template to download template.download(self.apiclient) self.cleanup.append(template) # Wait for template status to be changed across time.sleep(self.services["sleep"]) timeout = self.services["timeout"] while True: list_template_response = Template.list( self.apiclient, templatefilter='all', id=template.id, zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid) if isinstance(list_template_response, list): break elif timeout == 0: raise Exception("List template failed!") time.sleep(5) timeout = timeout - 1 # Verify template response to check whether template added successfully self.assertEqual( isinstance(list_template_response, list), True, "Check for list template response return valid data" ) self.assertNotEqual( len(list_template_response), 0, "Check template available in List Templates" ) template_response = list_template_response[0] self.assertEqual( template_response.isready, True, "Template state is not ready, it is %s" % template_response.isready ) self.assertIsNotNone( template_response.details, "Template details is %s" % template_response.details ) # Deploy new virtual machine using template virtual_machine = VirtualMachine.create( self.apiclient, self.services["virtual_machine"], templateid=template.id, accountid=self.account.name, domainid=self.account.domainid, serviceofferingid=self.service_offering.id, mode=self.services["mode"] ) self.debug("creating an instance with template ID: %s" % template.id) vm_response = VirtualMachine.list(self.apiclient, id=virtual_machine.id, account=self.account.name, domainid=self.account.domainid) self.assertEqual( isinstance(vm_response, list), True, "Check for list VMs response after VM deployment" ) # Verify VM response to check whether VM deployment was successful self.assertNotEqual( len(vm_response), 0, "Check VMs available in List VMs response" ) vm = vm_response[0] self.assertEqual( vm.state, 'Running', "Check the state of VM created from Template" ) volumes = list_volumes( self.apiclient, virtualmachineid=vm.id, type='ROOT', listall=True ) snapshot = Snapshot.create( self.apiclient, volumes[0].id, account=self.account.name, domainid=self.account.domainid ) time.sleep(self.services["sleep"]) self.cleanup.append(snapshot) self.debug("Snapshot created: ID - %s" % snapshot.id) snapshots = list_snapshots( self.apiclient, id=snapshot.id ) self.assertEqual( isinstance(snapshots, list), True, "Check list response returns a valid list" ) self.assertNotEqual( snapshots, None, "Check if result exists in list item call" ) self.assertEqual( snapshots[0].id, snapshot.id, "Check resource id in list resources call" ) virtual_machine.delete(self.apiclient, expunge=False) list_vm_response = VirtualMachine.list( self.apiclient, id=virtual_machine.id ) self.assertEqual( isinstance(list_vm_response, list), True, "Check list response returns a valid list" ) self.assertNotEqual( len(list_vm_response), 0, "Check VM avaliable in List Virtual Machines" ) template = Template.create_from_snapshot( self.apiclient, snapshot, self.services["template"] ) self.cleanup.append(template) # Verify created template templates = Template.list( self.apiclient , templatefilter=self.services["template"]["templatefilter"], id=template.id ) self.assertNotEqual( templates, None, "Check if result exists in list item call" ) self.assertEqual( templates[0].id, template.id, "Check new template id in list resources call" ) self.assertIsNotNone( templates[0].details, "Template details is %s" % template_response.details ) return
def test_04_create_template_delete_account(self): """Test secondary storage limit of domain and its sub-domains # Steps 1. Create a parent domain and two sub-domains in it (also admin accounts of each domain) 2. Register template in child domain 1 3. Verify that the secondary storage count for child domain 1 equals the template size 4. Register template in child domain 2 5. Vreify that the seconday storage count for child domain 2 equals the template size 6. Verify that the secondary storage count for parent domain equals double of template size 7. Delete child domain 1 admin account 8. Verify that secondary storage count for parent domain now equals to only 1 template size """ # Setting up account and domain hierarchy result = self.setupAccounts() self.assertEqual(result[0], PASS, result[1]) try: builtin_info = get_builtin_template_info(self.apiclient, self.zone.id) self.services["template_2"]["url"] = builtin_info[0] self.services["template_2"]["hypervisor"] = builtin_info[1] self.services["template_2"]["format"] = builtin_info[2] template = Template.register(self.apiclient, self.services["template_2"], zoneid=self.zone.id, account=self.cadmin_1.name, domainid=self.cadmin_1.domainid) template.download(self.apiclient) templates = Template.list(self.apiclient, templatefilter=\ self.services["template_2"]["templatefilter"], id=template.id) if validateList(templates)[0] == FAIL: raise Exception("templates list validation failed") self.templateSize = int(int(templates[0].size) / (1024**3)) except Exception as e: self.fail("Failed with exception as ee: %s" % e) # Checking Primary Storage count of Parent domain admin before deleting child domain user account expectedCount = self.templateSize result = isDomainResourceCountEqualToExpectedCount( self.apiclient, self.cadmin_1.domainid, expectedCount, RESOURCE_SECONDARY_STORAGE) self.assertFalse(result[0], result[1]) self.assertTrue(result[2], "Resource count does not match") try: template = Template.register(self.apiclient, self.services["template_2"], zoneid=self.zone.id, account=self.cadmin_2.name, domainid=self.cadmin_2.domainid) template.download(self.apiclient) except Exception as e: self.fail("Failed while registering/downloading template: %s" % e) result = isDomainResourceCountEqualToExpectedCount( self.apiclient, self.cadmin_2.domainid, expectedCount, RESOURCE_SECONDARY_STORAGE) self.assertFalse(result[0], result[1]) self.assertTrue(result[2], "Resource count does not match") expectedCount *= 2 result = isDomainResourceCountEqualToExpectedCount( self.apiclient, self.parent_domain.id, expectedCount, RESOURCE_SECONDARY_STORAGE) self.assertFalse(result[0], result[1]) self.assertTrue(result[2], "Resource count does not match") try: self.cadmin_1.delete(self.apiclient) except Exception as e: self.fail("Failed to delete account: %s" % e) expectedCount /= 2 result = isDomainResourceCountEqualToExpectedCount( self.apiclient, self.parent_domain.id, expectedCount, RESOURCE_SECONDARY_STORAGE) self.assertFalse(result[0], result[1]) self.assertTrue(result[2], "Resource count does not match") return
def test_01_multiple_domains_secondary_storage_limits(self): """Test secondary storage limit of domain and its sub-domains # Steps 1. Create a parent domain and two sub-domains in it (also admin accounts of each domain) 2. Register template in child domain 1 so that total secondary storage is less than the limit of child domain 3. Set the child domain limit equal to template size and parent domain domain limit as double of the template size 4. Repeat step 2 for child domain 2 5. Try to register template in parent domain now so that the total secondary storage in parent domain (including that in sub-domains is more than the secondary storage limit of the parent domain) 6. Delete the admin account of child domain 1 and check resource count of the parent domain 7. Delete template in account 2 and check secondary storage count of parent domain # Validations: 1. Step 2 and 4 should succeed 2. Step 5 should fail as the resource limit exceeds in parent domain 3. After step 6, resource count in parent domain should decrease by equivalent quantity 4. After step 7, resource count in parent domain should be 0""" # Setting up account and domain hierarchy result = self.setupAccounts() self.assertEqual(result[0], PASS, result[1]) try: builtin_info = get_builtin_template_info(self.apiclient, self.zone.id) self.services["template_2"]["url"] = builtin_info[0] self.services["template_2"]["hypervisor"] = builtin_info[1] self.services["template_2"]["format"] = builtin_info[2] templateChildAccount1 = Template.register(self.apiclient, self.services["template_2"], zoneid=self.zone.id, account=self.cadmin_1.name, domainid=self.cadmin_1.domainid) templateChildAccount1.download(self.apiclient) templates = Template.list(self.apiclient, templatefilter=\ self.services["template_2"]["templatefilter"], id=templateChildAccount1.id) if validateList(templates)[0] == FAIL: raise Exception("templates list validation failed") self.templateSize = int(int(templates[0].size) / (1024**3)) except Exception as e: self.fail("Failed with exception as ee: %s" % e) subdomainlimit = (self.templateSize) result = self.updateDomainResourceLimits(((subdomainlimit*2)), subdomainlimit) self.assertEqual(result[0], PASS, result[1]) # Checking Primary Storage count of Parent domain admin before deleting child domain user account result = isDomainResourceCountEqualToExpectedCount( self.apiclient, self.cadmin_1.domainid, self.templateSize, RESOURCE_SECONDARY_STORAGE) self.assertFalse(result[0], result[1]) self.assertTrue(result[2], "Resource count does not match") try: templateChildAccount2 = Template.register(self.apiclient, self.services["template_2"], zoneid=self.zone.id, account=self.cadmin_2.name, domainid=self.cadmin_2.domainid) templateChildAccount2.download(self.apiclient) except Exception as e: self.fail("Failed while registering/downloading template: %s" % e) result = isDomainResourceCountEqualToExpectedCount( self.apiclient, self.cadmin_2.domainid, self.templateSize, RESOURCE_SECONDARY_STORAGE) self.assertFalse(result[0], result[1]) self.assertTrue(result[2], "Resource count does not match") with self.assertRaises(Exception): Template.register(self.apiclient, self.services["template_2"], zoneid=self.zone.id, account=self.parentd_admin.name, domainid=self.parentd_admin.domainid) self.cadmin_1.delete(self.apiclient) self.cleanup.remove(self.cadmin_1) result = isDomainResourceCountEqualToExpectedCount( self.apiclient, self.parent_domain.id, self.templateSize, RESOURCE_SECONDARY_STORAGE) self.assertFalse(result[0], result[1]) self.assertTrue(result[2], "Resource count does not match") try: templateChildAccount2.delete(self.apiclient) except Exception as e: self.fail("Failed to delete template: %s" % e) result = isDomainResourceCountEqualToExpectedCount( self.apiclient, self.parent_domain.id, 0, RESOURCE_SECONDARY_STORAGE) self.assertFalse(result[0], result[1]) self.assertTrue(result[2], "Resource count does not match") return
def test_04_copy_template(self, value): """Test copy template between zones Steps and validations: This test requires at least two zones present in the setup 1. Create a root domain/child domain admin account 2. Register and download a template in the account 3. Verify the secondary storage resource count of the account equals the size of the template 4. Copy this template to other zone 5. Verify that the secondary storage resource count is now doubled as there are two templates now in two zones under the admin account """ zones = list_zones(self.apiclient) self.assertEqual(validateList(zones)[0], PASS, "zones list validation faield") if len(zones) < 2: self.skipTest("At least 2 zones should be present for this test case") response = self.setupAccount(value) self.assertEqual(response[0], PASS, response[1]) builtin_info = get_builtin_template_info(self.apiclient, self.zone.id) self.services["template_2"]["url"] = builtin_info[0] self.services["template_2"]["hypervisor"] = builtin_info[1] self.services["template_2"]["format"] = builtin_info[2] try: template = Template.register( self.apiclient, self.services["template_2"], zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid, hypervisor=self.hypervisor, ) template.download(self.apiclient) except Exception as e: self.fail("Failed to register template: %s" % e) templates = Template.list( self.apiclient, templatefilter=self.services["template_2"]["templatefilter"], id=template.id ) self.assertEqual(validateList(templates)[0], PASS, "templates list validation failed") templateSize = templates[0].size / (1024 ** 3) expectedCount = templateSize response = matchResourceCount( self.apiclient, expectedCount, RESOURCE_SECONDARY_STORAGE, accountid=self.account.id ) self.assertEqual(response[0], PASS, response[1]) templateDestinationZoneId = None for zone in zones: if template.zoneid != zone.id: templateDestinationZoneId = zone.id break template.copy(self.apiclient, destzoneid=templateDestinationZoneId, sourcezoneid=template.zoneid) expectedCount = templateSize * 2 response = matchResourceCount( self.apiclient, expectedCount, RESOURCE_SECONDARY_STORAGE, accountid=self.account.id ) self.assertEqual(response[0], PASS, response[1]) return
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
def test_03_copy_template(self): """Test secondary storage counts in multiple child domains # Steps 1. Create a parent domain and two sub-domains in it (also admin accounts of each domain) Repeat following steps for both the child domains 2. Register template in child domain 3. Check if the resource count for domain is updated correctly 4. Copy template to other zone 5. Verify that secondary storage count for the domain is doubled as there are two templates now """ zones = list_zones(self.apiclient) self.assertEqual( validateList(zones)[0], PASS, "zones list validation faield") if len(zones) < 2: self.skipTest( "At least 2 zones should be present for this test case") users = None # Setting up account and domain hierarchy result = self.setupAccounts() self.assertEqual(result[0], PASS, result[1]) users = result[2] for domain, admin in users.items(): self.account = admin self.domain = domain try: builtin_info = get_builtin_template_info( self.apiclient, self.zone.id) self.services["template_2"]["url"] = builtin_info[0] self.services["template_2"]["hypervisor"] = builtin_info[1] self.services["template_2"]["format"] = builtin_info[2] template = Template.register(self.apiclient, self.services["template_2"], zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid) template.download(self.apiclient) templates = Template.list(self.apiclient, templatefilter=\ self.services["template_2"]["templatefilter"], id=template.id) if validateList(templates)[0] == FAIL: raise Exception("templates list validation failed") templateSize = int(int(templates[0].size) / (1024**3)) expectedCount = templateSize result = isDomainResourceCountEqualToExpectedCount( self.apiclient, self.domain.id, expectedCount, RESOURCE_SECONDARY_STORAGE) self.assertFalse(result[0], result[1]) self.assertTrue(result[2], "Resource count does not match") templateDestinationZoneId = None for zone in zones: if template.zoneid != zone.id: templateDestinationZoneId = zone.id break template.copy(self.apiclient, destzoneid=templateDestinationZoneId, sourcezoneid=template.zoneid) expectedCount *= 2 result = isDomainResourceCountEqualToExpectedCount( self.apiclient, self.domain.id, expectedCount, RESOURCE_SECONDARY_STORAGE) self.assertFalse(result[0], result[1]) self.assertTrue(result[2], "Resource count does not match") except Exception as e: self.fail("Failed to get zone list: %s" % e) return
def test_01_create_template(self): """TS_BUG_002-Test to create and deploy VM using password enabled template """ # Validate the following: #1. Create a password enabled template #2. Deploy VM using this template #3. Deploy VM should return password set in template. builtin_info = get_builtin_template_info(self.apiclient, self.zone.id) self.services["template"]["url"] = builtin_info[0] self.services["template"]["hypervisor"] = builtin_info[1] self.services["template"]["format"] = builtin_info[2] self.debug("Registering a new template") # Register new template template = Template.register( self.apiclient, self.services["template"], zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid, hypervisor=self.hypervisor ) self.debug( "Registered a template of format: %s with ID: %s" % ( self.services["template"]["format"], template.id )) try: # Wait for template to download template.download(self.apiclient) except Exception as e: self.fail("Exception while downloading template %s: %s"\ % (template.id, e)) self.cleanup.append(template) # Wait for template status to be changed across time.sleep(self.services["sleep"]) list_template_response = Template.list( self.apiclient, templatefilter=\ self.services["template"]["templatefilter"], id=template.id, zoneid=self.zone.id ) self.assertEqual( isinstance(list_template_response, list), True, "Check list response returns a valid list" ) #Verify template response to check whether template added successfully self.assertNotEqual( len(list_template_response), 0, "Check template available in List Templates" ) template_response = list_template_response[0] self.assertEqual( template_response.isready, True, "Template state is not ready, it is %s" % template_response.isready ) # Deploy new virtual machine using template virtual_machine = VirtualMachine.create( self.apiclient, self.services["virtual_machine"], templateid=template.id, accountid=self.account.name, domainid=self.account.domainid, serviceofferingid=self.service_offering.id, ) self.debug("Deployed VM with ID: %s " % virtual_machine.id) self.assertEqual( hasattr(virtual_machine, "password"), True, "Check if the deployed VM returned a password" ) return
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(TestPathVMLC, cls).getClsTestClient() cls.apiclient = testClient.getApiClient() cls.testdata = testClient.getParsedTestDataConfig() cls.hypervisor = testClient.getHypervisorInfo() # Get Zone, Domain and templates cls.domain = get_domain(cls.apiclient) cls.zone = get_zone(cls.apiclient) cls._cleanup = [] try: # Create an account cls.account = Account.create(cls.apiclient, cls.testdata["account"], domainid=cls.domain.id) cls._cleanup.append(cls.account) # If local storage is enabled, alter the offerings to use # localstorage if cls.zone.localstorageenable: cls.testdata["service_offering"]["storagetype"] = 'local' # Create 3 service offerings with different values for # for cpunumber, cpuspeed, and memory cls.testdata["service_offering"]["cpuspeed"] = 128 cls.testdata["service_offering"]["memory"] = 256 cls.testdata["service_offering"]["cpunumber"] = 1 cls.service_offering_1 = ServiceOffering.create( cls.apiclient, cls.testdata["service_offering"]) cls._cleanup.append(cls.service_offering_1) cls.testdata["service_offering"]["cpunumber"] = 2 cls.service_offering_2 = ServiceOffering.create( cls.apiclient, cls.testdata["service_offering"]) cls._cleanup.append(cls.service_offering_2) # Create isolated network offering cls.isolated_network_offering = CreateEnabledNetworkOffering( cls.apiclient, cls.testdata["isolated_network_offering"]) cls._cleanup.append(cls.isolated_network_offering) # Create shared network offering cls.testdata["shared_network_offering_all_services"][ "specifyVlan"] = "True" cls.testdata["shared_network_offering_all_services"][ "specifyIpRanges"] = "True" cls.shared_network_offering = CreateEnabledNetworkOffering( cls.apiclient, cls.testdata["shared_network_offering_all_services"]) cls._cleanup.append(cls.shared_network_offering) cls.isolated_network_offering_vpc = CreateEnabledNetworkOffering( cls.apiclient, cls.testdata["nw_offering_isolated_vpc"]) cls._cleanup.append(cls.isolated_network_offering_vpc) cls.vpc_off = VpcOffering.create(cls.apiclient, cls.testdata["vpc_offering"]) cls.vpc_off.update(cls.apiclient, state='Enabled') cls._cleanup.append(cls.vpc_off) # This variable will store the id of vpc network whenever # test case creates it # If not created, it will be None and will not be used cls.vpcid = None # Create user api client of the account cls.userapiclient = testClient.getUserApiClient( UserName=cls.account.name, DomainName=cls.account.domain) # Register a private template in the account builtin_info = get_builtin_template_info(cls.apiclient, cls.zone.id) cls.testdata["privatetemplate"]["url"] = builtin_info[0] cls.testdata["privatetemplate"]["hypervisor"] = builtin_info[1] cls.testdata["privatetemplate"]["format"] = builtin_info[2] # Register new template cls.template = Template.register(cls.userapiclient, cls.testdata["privatetemplate"], zoneid=cls.zone.id, account=cls.account.name, domainid=cls.account.domainid) # Wait for template to download cls.template.download(cls.apiclient) # Check that we are able to login to the created account respose = User.login(cls.apiclient, username=cls.account.name, password=cls.testdata["account"]["password"]) assert respose.sessionkey is not None,\ "Login to the CloudStack should be successful\ response shall have non Null key" except Exception as e: cls.tearDownClass() raise e return
def test_04_copy_template(self, value): """Test copy template between zones Steps and validations: This test requires at least two zones present in the setup 1. Create a root domain/child domain admin account 2. Register and download a template in the account 3. Verify the secondary storage resource count of the account equals the size of the template 4. Copy this template to other zone 5. Verify that the secondary storage resource count is now doubled as there are two templates now in two zones under the admin account """ zones = list_zones(self.apiclient) self.assertEqual( validateList(zones)[0], PASS, "zones list validation faield") if len(zones) < 2: self.skipTest( "At least 2 zones should be present for this test case") response = self.setupAccount(value) self.assertEqual(response[0], PASS, response[1]) builtin_info = get_builtin_template_info(self.apiclient, self.zone.id) self.services["template_2"]["url"] = builtin_info[0] self.services["template_2"]["hypervisor"] = builtin_info[1] self.services["template_2"]["format"] = builtin_info[2] try: template = Template.register(self.apiclient, self.services["template_2"], zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid, hypervisor=self.hypervisor) template.download(self.apiclient) except Exception as e: self.fail("Failed to register template: %s" % e) templates = Template.list(self.apiclient, templatefilter=\ self.services["template_2"]["templatefilter"], id=template.id) self.assertEqual(validateList(templates)[0],PASS,\ "templates list validation failed") templateSize = (templates[0].size / (1024**3)) expectedCount = templateSize response = matchResourceCount(self.apiclient, expectedCount, RESOURCE_SECONDARY_STORAGE, accountid=self.account.id) self.assertEqual(response[0], PASS, response[1]) templateDestinationZoneId = None for zone in zones: if template.zoneid != zone.id: templateDestinationZoneId = zone.id break template.copy(self.apiclient, destzoneid=templateDestinationZoneId, sourcezoneid=template.zoneid) expectedCount = (templateSize * 2) response = matchResourceCount(self.apiclient, expectedCount, RESOURCE_SECONDARY_STORAGE, accountid=self.account.id) self.assertEqual(response[0], PASS, response[1]) return
def test_01_disable_enable_cluster(self): """disable enable cluster 1. Disable cluster and verify following things: For admin user: --Should be able to create new vm, snapshot, volume,template,iso in the same cluster For Non-admin user: --Should not be able create new vm, snapshot, volume,template,iso in the same cluster 2. Enable the above disabled cluster and verify that: -All users should be create to deploy new vm, snapshot, volume,template,iso in the same cluster 3. Disable the managestate of the cluster and verify that: --Host in the cluster should get disconnected --VM's in the cluster are ping-able and ssh to --Creation of new VM in the cluster should fail 4. Enable the managestate of the cluster and verify that: --Hosts in the cluster get connected --VM's in the cluster are accessible 5. Try to delete the cluster and it should fail with error message: -"The cluster is not deletable because there are servers running in this cluster" """ # 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, mode=self.zone.networktype, ) self.vm_list.append(vm_user) 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, mode=self.zone.networktype, ) self.vm_list.append(vm_root) cmd = updateCluster.updateClusterCmd() cmd.id = self.cluster.id cmd.allocationstate = DISABLED self.apiclient.updateCluster(cmd) clusterList = Cluster.list(self.apiclient, id=self.cluster.id) self.assertEqual(clusterList[0].allocationstate, DISABLED, "Check if the cluster is in disabled state") # Verify the existing vms should 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 root vm is running") 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, ) root_volume = list_volumes(self.apiclient, virtualmachineid=vm_root.id, type="ROOT", listall=True) self.assertEqual( validateList(root_volume)[0], PASS, "list root volume response is empty for volume id %s" % vm_root.id ) 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] 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-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, mode=self.zone.networktype, ) root_volume = list_volumes(self.userapiclient, virtualmachineid=vm_user.id, type="ROOT", listall=True) self.assertEqual( validateList(root_volume)[0], PASS, "list root volume response is empty for volume id %s" % vm_user.id ) if self.snapshotSupported: Snapshot.create(self.userapiclient, 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 2 cmd.allocationstate = ENABLED self.apiclient.updateCluster(cmd) clusterList = Cluster.list(self.apiclient, id=self.cluster.id) self.assertEqual(clusterList[0].allocationstate, ENABLED, "Check if the cluster is in disabled state") # After enabling the zone all users should be able to add new VM, # volume, templatee 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) # 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) # Step 3 cmd = updateCluster.updateClusterCmd() cmd.id = self.cluster.id cmd.managedstate = "Unmanaged" self.apiclient.updateCluster(cmd) clusterList = Cluster.list(self.apiclient, id=self.cluster.id) self.assertEqual( clusterList[0].managedstate.lower(), "unmanaged", "Check if the cluster is in unmanaged state" ) # Hosts in the cluster takes some time to go into disconnected state time.sleep(60) hostList = Host.list(self.apiclient, clusterid=self.cluster.id) for host in hostList: self.assertEqual(host.state.lower(), "disconnected", "Check if host in the cluster gets disconnected") exception_list = [] for vm in self.vm_list: try: SshClient(vm.ssh_ip, vm.ssh_port, vm.username, vm.password) except Exception as e: exception_list.append(e) self.assertEqual(len(exception_list), 0, "Check if vm's are accesible") # 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, mode=self.zone.networktype, ) root_volume = list_volumes(self.userapiclient, virtualmachineid=vm_user.id, type="ROOT", listall=True) if self.snapshotSupported: with self.assertRaises(Exception): Snapshot.create(self.userapiclient, root_volume[0].id) Template.register(self.userapiclient, self.testdata["privatetemplate"], zoneid=self.zone.id) # Step 4 cmd.managedstate = "Managed" self.apiclient.updateCluster(cmd) # After changing the cluster's managestate to Managed hosts in the # cluster takes some time to come back to Up state time.sleep(120) hostList = Host.list(self.apiclient, clusterid=self.cluster.id) for host in hostList: self.assertEqual(host.state.lower(), "up", "Check if host in the cluster gets up") 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 should stop") self.assertEqual(user_state, "Stopped", "verify that vm should stop") 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") # Step 5 # Deletion of zone should fail if resources are running on the zone with self.assertRaises(Exception): self.pod.delete(self.apiclient) return
def test_02_multiple_domains_secondary_storage_counts(self): """Test secondary storage counts in multiple child domains # Steps 1. Create a parent domain and two sub-domains in it (also admin accounts of each domain) Repeat following steps for both the child domains 2. Register template in child domain 3. Check if the resource count for domain is updated correctly 4. Delete the template 5. Verify that the resource count for the domain is 0 """ users = None # Setting up account and domain hierarchy result = self.setupAccounts() self.assertEqual(result[0], PASS, result[1]) users = result[2] for domain, admin in users.items(): self.account = admin self.domain = domain try: builtin_info = get_builtin_template_info(self.apiclient, self.zone.id) self.services["template_2"]["url"] = builtin_info[0] self.services["template_2"]["hypervisor"] = builtin_info[1] self.services["template_2"]["format"] = builtin_info[2] template = Template.register(self.apiclient, self.services["template_2"], zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid) template.download(self.apiclient) templates = Template.list(self.apiclient, templatefilter=\ self.services["template_2"]["templatefilter"], id=template.id) if validateList(templates)[0] == FAIL: raise Exception("templates list validation failed") templateSize = int(int(templates[0].size) / (1024**3)) expectedCount = templateSize result = isDomainResourceCountEqualToExpectedCount( self.apiclient, self.domain.id, expectedCount, RESOURCE_SECONDARY_STORAGE) self.assertFalse(result[0], result[1]) self.assertTrue(result[2], "Resource count does not match") template.delete(self.apiclient) expectedCount = 0 result = isDomainResourceCountEqualToExpectedCount( self.apiclient, self.domain.id, expectedCount, RESOURCE_SECONDARY_STORAGE) self.assertFalse(result[0], result[1]) self.assertTrue(result[2], "Resource count does not match") except Exception as e: self.fail("Failed to get zone list: %s" % e) return
def test_01_multiple_domains_secondary_storage_limits(self): """Test secondary storage limit of domain and its sub-domains # Steps 1. Create a parent domain and two sub-domains in it (also admin accounts of each domain) 2. Register template in child domain 1 so that total secondary storage is less than the limit of child domain 3. Set the child domain limit equal to template size and parent domain domain limit as double of the template size 4. Repeat step 2 for child domain 2 5. Try to register template in parent domain now so that the total secondary storage in parent domain (including that in sub-domains is more than the secondary storage limit of the parent domain) 6. Delete the admin account of child domain 1 and check resource count of the parent domain 7. Delete template in account 2 and check secondary storage count of parent domain # Validations: 1. Step 2 and 4 should succeed 2. Step 5 should fail as the resource limit exceeds in parent domain 3. After step 6, resource count in parent domain should decrease by equivalent quantity 4. After step 7, resource count in parent domain should be 0""" # Setting up account and domain hierarchy result = self.setupAccounts() self.assertEqual(result[0], PASS, result[1]) try: builtin_info = get_builtin_template_info(self.apiclient, self.zone.id) self.services["template_2"]["url"] = builtin_info[0] self.services["template_2"]["hypervisor"] = builtin_info[1] self.services["template_2"]["format"] = builtin_info[2] templateChildAccount1 = Template.register( self.apiclient, self.services["template_2"], zoneid=self.zone.id, account=self.cadmin_1.name, domainid=self.cadmin_1.domainid) templateChildAccount1.download(self.apiclient) templates = Template.list(self.apiclient, templatefilter=\ self.services["template_2"]["templatefilter"], id=templateChildAccount1.id) if validateList(templates)[0] == FAIL: raise Exception("templates list validation failed") self.templateSize = int(int(templates[0].size) / (1024**3)) except Exception as e: self.fail("Failed with exception as ee: %s" % e) subdomainlimit = (self.templateSize) result = self.updateDomainResourceLimits(((subdomainlimit * 2)), subdomainlimit) self.assertEqual(result[0], PASS, result[1]) # Checking Primary Storage count of Parent domain admin before deleting child domain user account result = isDomainResourceCountEqualToExpectedCount( self.apiclient, self.cadmin_1.domainid, self.templateSize, RESOURCE_SECONDARY_STORAGE) self.assertFalse(result[0], result[1]) self.assertTrue(result[2], "Resource count does not match") try: templateChildAccount2 = Template.register( self.apiclient, self.services["template_2"], zoneid=self.zone.id, account=self.cadmin_2.name, domainid=self.cadmin_2.domainid) templateChildAccount2.download(self.apiclient) except Exception as e: self.fail("Failed while registering/downloading template: %s" % e) result = isDomainResourceCountEqualToExpectedCount( self.apiclient, self.cadmin_2.domainid, self.templateSize, RESOURCE_SECONDARY_STORAGE) self.assertFalse(result[0], result[1]) self.assertTrue(result[2], "Resource count does not match") with self.assertRaises(Exception): Template.register(self.apiclient, self.services["template_2"], zoneid=self.zone.id, account=self.parentd_admin.name, domainid=self.parentd_admin.domainid) self.cadmin_1.delete(self.apiclient) self.cleanup.remove(self.cadmin_1) result = isDomainResourceCountEqualToExpectedCount( self.apiclient, self.parent_domain.id, self.templateSize, RESOURCE_SECONDARY_STORAGE) self.assertFalse(result[0], result[1]) self.assertTrue(result[2], "Resource count does not match") try: templateChildAccount2.delete(self.apiclient) except Exception as e: self.fail("Failed to delete template: %s" % e) result = isDomainResourceCountEqualToExpectedCount( self.apiclient, self.parent_domain.id, 0, RESOURCE_SECONDARY_STORAGE) self.assertFalse(result[0], result[1]) self.assertTrue(result[2], "Resource count does not match") return
def test_01_create_template(self): """Test create public & private template """ # Validate the following: # 1. Upload a templates in raw img format. Create a Vm instances from # raw img template. # 2. Upload a templates in zip file format. Create a Vm instances from # zip template. # 3. Upload a templates in tar format.Create a Vm instances from tar # template. # 4. Upload a templates in tar gzip format.Create a Vm instances from # tar gzip template. # 5. Upload a templates in tar bzip format. Create a Vm instances from # tar bzip template. # 6. Verify VMs & Templates is up and in ready state builtin_info = get_builtin_template_info(self.apiclient, self.zone.id) self.services["templates"][0]["url"] = builtin_info[0] self.services["templates"][0]["hypervisor"] = builtin_info[1] self.services["templates"][0]["format"] = builtin_info[2] # Register new template template = Template.register(self.apiclient, self.services["templates"][0], zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid, hypervisor=self.hypervisor) self.debug("Registered a template of format: %s with ID: %s" % (self.services["templates"][0]["format"], template.id)) # Wait for template to download template.download(self.apiclient) self.cleanup.append(template) # Wait for template status to be changed across time.sleep(self.services["sleep"]) timeout = self.services["timeout"] while True: list_template_response = Template.list( self.apiclient, templatefilter='all', id=template.id, zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid) if isinstance(list_template_response, list): break elif timeout == 0: raise Exception("List template failed!") time.sleep(5) timeout = timeout - 1 #Verify template response to check whether template added successfully self.assertEqual(isinstance(list_template_response, list), True, "Check for list template response return valid data") self.assertNotEqual(len(list_template_response), 0, "Check template available in List Templates") template_response = list_template_response[0] self.assertEqual( template_response.isready, True, "Template state is not ready, it is %s" % template_response.isready) # Deploy new virtual machine using template virtual_machine = VirtualMachine.create( self.apiclient, self.services["virtual_machine"], templateid=template.id, accountid=self.account.name, domainid=self.account.domainid, serviceofferingid=self.service_offering.id, mode=self.services["mode"]) self.debug("creating an instance with template ID: %s" % template.id) vm_response = VirtualMachine.list(self.apiclient, id=virtual_machine.id, account=self.account.name, domainid=self.account.domainid) self.assertEqual(isinstance(vm_response, list), True, "Check for list VMs response after VM deployment") #Verify VM response to check whether VM deployment was successful self.assertNotEqual(len(vm_response), 0, "Check VMs available in List VMs response") vm = vm_response[0] self.assertEqual(vm.state, 'Running', "Check the state of VM created from Template") return
def test_03_copy_template(self): """Test secondary storage counts in multiple child domains # Steps 1. Create a parent domain and two sub-domains in it (also admin accounts of each domain) Repeat following steps for both the child domains 2. Register template in child domain 3. Check if the resource count for domain is updated correctly 4. Copy template to other zone 5. Verify that secondary storage count for the domain is doubled as there are two templates now """ zones = list_zones(self.apiclient) self.assertEqual(validateList(zones)[0], PASS, "zones list validation faield") if len(zones) < 2: self.skipTest("At least 2 zones should be present for this test case") users = None # Setting up account and domain hierarchy result = self.setupAccounts() self.assertEqual(result[0], PASS, result[1]) users = result[2] for domain, admin in users.items(): self.account = admin self.domain = domain try: builtin_info = get_builtin_template_info(self.apiclient, self.zone.id) self.services["template_2"]["url"] = builtin_info[0] self.services["template_2"]["hypervisor"] = builtin_info[1] self.services["template_2"]["format"] = builtin_info[2] template = Template.register(self.apiclient, self.services["template_2"], zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid) template.download(self.apiclient) templates = Template.list(self.apiclient, templatefilter=\ self.services["template_2"]["templatefilter"], id=template.id) if validateList(templates)[0] == FAIL: raise Exception("templates list validation failed") templateSize = int(int(templates[0].size) / (1024**3)) expectedCount = templateSize result = isDomainResourceCountEqualToExpectedCount( self.apiclient, self.domain.id, expectedCount, RESOURCE_SECONDARY_STORAGE) self.assertFalse(result[0], result[1]) self.assertTrue(result[2], "Resource count does not match") templateDestinationZoneId = None for zone in zones: if template.zoneid != zone.id : templateDestinationZoneId = zone.id break template.copy(self.apiclient, destzoneid=templateDestinationZoneId, sourcezoneid = template.zoneid) expectedCount *= 2 result = isDomainResourceCountEqualToExpectedCount( self.apiclient, self.domain.id, expectedCount, RESOURCE_SECONDARY_STORAGE) self.assertFalse(result[0], result[1]) self.assertTrue(result[2], "Resource count does not match") except Exception as e: self.fail("Failed to get zone list: %s" % e) return