def setupAccounts(self): self.debug("Creating a sub-domain under: %s" % self.domain.name) self.child_domain = Domain.create( self.apiclient, services=self.services["domain"], parentdomainid=self.domain.id ) self.child_do_admin = Account.create( self.apiclient, self.services["account"], admin=True, domainid=self.child_domain.id ) # Cleanup the resources created at end of test self.cleanup.append(self.child_do_admin) self.cleanup.append(self.child_domain) Resources.updateLimit( self.apiclient, resourcetype=8, max=16, account=self.child_do_admin.name, domainid=self.child_do_admin.domainid, ) self.domain = Domain.create(self.apiclient, services=self.services["domain"], parentdomainid=self.domain.id) self.admin = Account.create(self.apiclient, self.services["account"], admin=True, domainid=self.domain.id) # Cleanup the resources created at end of test self.cleanup.append(self.admin) self.cleanup.append(self.domain) Resources.updateLimit( self.apiclient, resourcetype=8, max=16, account=self.admin.name, domainid=self.admin.domainid ) 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 setupAccounts(self): self.debug("Creating a domain under: %s" % self.domain.name) self.child_domain_1 = Domain.create(self.apiclient, services=self.services["domain"], parentdomainid=self.domain.id) self.child_do_admin_1 = Account.create(self.apiclient, self.services["account"], admin=True, domainid=self.child_domain_1.id) # Cleanup the resources created at end of test self.cleanup.append(self.child_do_admin_1) self.cleanup.append(self.child_domain_1) self.debug("Creating a domain under: %s" % self.domain.name) self.child_domain_2 = Domain.create(self.apiclient, services=self.services["domain"], parentdomainid=self.domain.id) self.child_do_admin_2 = Account.create(self.apiclient, self.services["account"], admin=True, domainid=self.child_domain_2.id) # Cleanup the resources created at end of test self.cleanup.append(self.child_do_admin_2) self.cleanup.append(self.child_domain_2) return
def setUpClass(cls): testClient = super(TestDomainsDiskOfferings, cls).getClsTestClient() cls.apiclient = cls.testClient.getApiClient() cls.services = cls.testClient.getParsedTestDataConfig() # Create domains cls.domain_1 = Domain.create(cls.apiclient, cls.services["acl"]["domain1"]) cls.domain_11 = Domain.create(cls.apiclient, cls.services["acl"]["domain11"], parentdomainid=cls.domain_1.id) cls.domain_2 = Domain.create(cls.apiclient, cls.services["acl"]["domain2"]) cls.domain_3 = Domain.create(cls.apiclient, cls.services["acl"]["domain12"]) cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests()) cls.disk_offering = DiskOffering.create(cls.apiclient, cls.services["disk_offering"], domainid=cls.domain_1.id) cls._cleanup = [ cls.disk_offering, cls.domain_11, cls.domain_1, cls.domain_2, cls.domain_3 ] return
def setUpClass(cls): testClient = super(TestDomainsVpcOfferings, cls).getClsTestClient() cls.apiclient = testClient.getApiClient() cls.localservices = Services().services cls.services = testClient.getParsedTestDataConfig() # Create domains cls.domain_1 = Domain.create(cls.apiclient, cls.services["acl"]["domain1"]) cls.domain_11 = Domain.create(cls.apiclient, cls.services["acl"]["domain11"], parentdomainid=cls.domain_1.id) cls.domain_2 = Domain.create(cls.apiclient, cls.services["acl"]["domain2"]) cls.domain_3 = Domain.create(cls.apiclient, cls.services["acl"]["domain12"]) cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests()) cls.vpc_offering = VpcOffering.create(cls.apiclient, cls.services["vpc_offering"]) # Enable Vpc offering cls.vpc_offering.update(cls.apiclient, state='Enabled') cls._cleanup = [ cls.vpc_offering, cls.domain_11, cls.domain_1, cls.domain_2, cls.domain_3 ] return
def setupAccounts(self): self.debug("Creating a domain under: %s" % self.domain.name) self.child_domain_1 = Domain.create(self.apiclient, services=self.services["domain"], parentdomainid=self.domain.id) self.child_do_admin_1 = Account.create( self.apiclient, self.services["account"], admin=True, domainid=self.child_domain_1.id ) # Cleanup the resources created at end of test self.cleanup.append(self.child_do_admin_1) self.cleanup.append(self.child_domain_1) self.debug("Creating a domain under: %s" % self.domain.name) self.child_domain_2 = Domain.create(self.apiclient, services=self.services["domain"], parentdomainid=self.domain.id) self.child_do_admin_2 = Account.create( self.apiclient, self.services["account"], admin=True, domainid=self.child_domain_2.id) # Cleanup the resources created at end of test self.cleanup.append(self.child_do_admin_2) self.cleanup.append(self.child_domain_2) return
def setupAccounts(self): self.debug("Creating a domain under: %s" % self.domain.name) self.parent_domain = Domain.create( self.apiclient, services=self.services["domain"], parentdomainid=self.domain.id ) self.parentd_admin = Account.create( self.apiclient, self.services["account"], admin=True, domainid=self.domain.id ) self.debug("Updating the Memory resource count for domain: %s" % self.domain.name) Resources.updateLimit( self.apiclient, resourcetype=9, max=4096, account=self.parentd_admin.name, domainid=self.parentd_admin.domainid, ) self.debug("Creating a sub-domain under: %s" % self.parent_domain.name) self.cdomain_1 = Domain.create( self.apiclient, services=self.services["domain"], parentdomainid=self.parent_domain.id ) self.debug("Creating a sub-domain under: %s" % self.parent_domain.name) self.cdomain_2 = Domain.create( self.apiclient, services=self.services["domain"], parentdomainid=self.parent_domain.id ) self.cadmin_1 = Account.create(self.apiclient, self.services["account"], admin=True, domainid=self.cdomain_1.id) self.debug("Updating the Memory resource count for domain: %s" % self.cdomain_1.name) Resources.updateLimit(self.apiclient, resourcetype=9, max=2048, domainid=self.cadmin_1.domainid) self.debug("Updating the Memory resource count for account: %s" % self.cadmin_1.name) Resources.updateLimit( self.apiclient, resourcetype=9, max=2048, account=self.cadmin_1.name, domainid=self.cadmin_1.domainid ) self.cadmin_2 = Account.create(self.apiclient, self.services["account"], admin=True, domainid=self.cdomain_2.id) self.debug("Updating the Memory resource count for domain: %s" % self.cdomain_2.name) Resources.updateLimit(self.apiclient, resourcetype=9, max=2048, domainid=self.cadmin_2.domainid) self.debug("Updating the Memory resource count for domain: %s" % self.cadmin_2.name) Resources.updateLimit( self.apiclient, resourcetype=9, max=2048, account=self.cadmin_2.name, domainid=self.cadmin_2.domainid ) # Cleanup the resources created at end of test self.cleanup.append(self.cadmin_1) self.cleanup.append(self.cadmin_2) self.cleanup.append(self.cdomain_1) self.cleanup.append(self.cdomain_2) self.cleanup.append(self.parentd_admin) self.cleanup.append(self.parent_domain) users = {self.parent_domain: self.parentd_admin, self.cdomain_1: self.cadmin_1, self.cdomain_2: self.cadmin_2} return users
def setUpClass(cls): testClient = super(TestDomainsServiceOfferings, cls).getClsTestClient() cls.apiclient = testClient.getApiClient() cls.services = testClient.getParsedTestDataConfig() cls.hypervisor = testClient.getHypervisorInfo() # Create domains cls.domain_1 = Domain.create( cls.apiclient, cls.services["acl"]["domain1"] ) cls.domain_11 = Domain.create( cls.apiclient, cls.services["acl"]["domain11"], parentdomainid=cls.domain_1.id ) cls.domain_2 = Domain.create( cls.apiclient, cls.services["acl"]["domain2"] ) cls.domain_3 = Domain.create( cls.apiclient, cls.services["acl"]["domain12"] ) cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests()) cls.services['mode'] = cls.zone.networktype cls.service_offering = ServiceOffering.create( cls.apiclient, cls.services["service_offerings"]["tiny"], domainid=cls.domain_1.id ) template = get_test_template( cls.apiclient, cls.zone.id, cls.hypervisor ) if template == FAILED: assert False, "get_test_template() failed to return template" # Set Zones and disk offerings cls.services["small"]["zoneid"] = cls.zone.id cls.services["small"]["template"] = template.id cls._cleanup = [ cls.service_offering, cls.domain_11, cls.domain_1, cls.domain_2, cls.domain_3 ] return
def setupAccounts(self): try: self.parent_domain = Domain.create( self.apiclient, services=self.services["domain"], parentdomainid=self.domain.id) self.parentd_admin = Account.create( self.apiclient, self.services["account"], admin=True, domainid=self.parent_domain.id) # Create sub-domains and their admin accounts self.cdomain_1 = Domain.create( self.apiclient, services=self.services["domain"], parentdomainid=self.parent_domain.id) self.cdomain_2 = Domain.create( self.apiclient, services=self.services["domain"], parentdomainid=self.parent_domain.id) self.cadmin_1 = Account.create( self.apiclient, self.services["account"], admin=True, domainid=self.cdomain_1.id) self.cadmin_2 = Account.create( self.apiclient, self.services["account"], admin=True, domainid=self.cdomain_2.id) # Cleanup the resources created at end of test self.cleanup.append(self.cadmin_1) self.cleanup.append(self.cadmin_2) self.cleanup.append(self.cdomain_1) self.cleanup.append(self.cdomain_2) self.cleanup.append(self.parentd_admin) self.cleanup.append(self.parent_domain) users = { self.cdomain_1: self.cadmin_1, self.cdomain_2: self.cadmin_2 } except Exception as e: return [FAIL, e, None] return [PASS, None, users]
def setUpClass(cls): testClient = super(TestCreateDomainsDiskOffering, cls).getClsTestClient() cls.apiclient = testClient.getApiClient() cls.services = testClient.getParsedTestDataConfig() # Create domains cls.domain_1 = Domain.create(cls.apiclient, cls.services["acl"]["domain1"]) cls.domain_11 = Domain.create(cls.apiclient, cls.services["acl"]["domain11"], parentdomainid=cls.domain_1.id) cls.domain_2 = Domain.create(cls.apiclient, cls.services["acl"]["domain2"]) cls._cleanup = [cls.domain_11, cls.domain_1, cls.domain_2] return
def test_01_ldap(self): """Check the linkDomainToLdap functionality""" self.domain1 = Domain.create( self.apiclient, services=self.services["domain"], parentdomainid=self.domain.id) self.ldaplink4 = linkDomainToLdap.linkDomainToLdapCmd() self.ldaplink4.domainid = self.domain1.id self.ldaplink4.accounttype = self.services[ "configurableData"]["link_ldap_details"]["accounttype"] self.ldaplink4.name = self.services[ "configurableData"]["link_ldap_details"]["name"] self.ldaplink4.type = self.services[ "configurableData"]["link_ldap_details"]["type"] if self.services["configurableData"][ "link_ldap_details"]["admin"] is not None: self.ldaplink4.admin = self.services[ "configurableData"]["link_ldap_details"]["admin"] try: self.ldaplinkRes4 = self.apiClient.linkDomainToLdap(self.ldaplink4) except Exception as e: raise Exception( "Linking LDAP failed,please check the configuration") try: self.domain1.delete(self.apiclient) except Exception as e: raise Exception( "Warning: Exception during deletion of domain : %s" % e)
def setUpClass(cls): cls.testClient = super(TestPublicIpAddress, cls).getClsTestClient() cls.api_client = cls.testClient.getApiClient() cls.services = Services().services cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests()) cls.services["mode"] = cls.zone.networktype cls.template = get_template(cls.api_client, cls.zone.id, cls.services["ostype"]) cls.services["server"]["zoneid"] = cls.zone.id # Create Domains, Account etc cls.domain = Domain.create(cls.api_client, cls.services["domain"]) cls.account = Account.create(cls.api_client, cls.services["account"], domainid=cls.domain.id) # Create project as a domain admin cls.project = Project.create( cls.api_client, cls.services["project"], account=cls.account.name, domainid=cls.account.domainid ) cls.services["account"] = cls.account.name # Create Service offering and disk offerings etc cls.service_offering = ServiceOffering.create(cls.api_client, cls.services["service_offering"]) cls.virtual_machine = VirtualMachine.create( cls.api_client, cls.services["server"], templateid=cls.template.id, serviceofferingid=cls.service_offering.id, projectid=cls.project.id, ) cls._cleanup = [cls.project, cls.service_offering, cls.account, cls.domain] return
def test_04_nuage_mngd_subnets_noadminaccount(self): """Test Nuage VSP Managed Subnets for ACS domains without admin account """ vsd_enterprise = self.create_vsd_enterprise() vsd_domain_template = self.create_vsd_domain_template(vsd_enterprise) self.create_vsd_default_acls(vsd_domain_template) vsd_domain1 = self.create_vsd_domain(vsd_domain_template, vsd_enterprise, "L3DomainToBeConsumedByACS") vsd_zone1 = self.create_vsd_zone(vsd_domain1, "ZoneToBeConsumedByACS") vsd_subnet1 = self.create_vsd_subnet(vsd_zone1, "SubnetToBeConsumedByACS", "10.0.0.1/24") acs_domain_1 = Domain.create(self.api_client, {}, name="DomainManagedbyVsd", domainid=vsd_enterprise.id) # Create an no admin and an user account under domain D1 acs_account_1 = Account.create(self.api_client, self.test_data["acl"]["accountD1"], admin=False, domainid=acs_domain_1.id) self.cleanup.append(acs_domain_1) self.cleanup.append(acs_account_1) # On ACS create network fails as non admin account with self.assertRaises(Exception): self.create_Network(self.nuage_isolated_network_offering, gateway="10.0.0.1", netmask="255.255.255.0", account=acs_account_1, externalid=vsd_subnet1.id)
def setUpClass(cls): cls.testClient = super(TestResourceLimitsProject, cls).getClsTestClient() cls.api_client = cls.testClient.getApiClient() cls.hypervisor = cls.testClient.getHypervisorInfo() cls.services = Services().services cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests()) cls.services["mode"] = cls.zone.networktype cls.template = get_template(cls.api_client, cls.zone.id, cls.services["ostype"]) cls.services["server"]["zoneid"] = cls.zone.id # Create Domains, Account etc cls.domain = Domain.create(cls.api_client, cls.services["domain"]) cls.account = Account.create(cls.api_client, cls.services["account"], domainid=cls.domain.id) cls.userapiclient = cls.testClient.getUserApiClient(UserName=cls.account.name, DomainName=cls.account.domain) # Create project as a domain admin cls.project = Project.create( cls.api_client, cls.services["project"], account=cls.account.name, domainid=cls.account.domainid ) cls.services["account"] = cls.account.name # Create Service offering and disk offerings etc cls.service_offering = ServiceOffering.create(cls.api_client, cls.services["service_offering"]) cls.disk_offering = DiskOffering.create(cls.api_client, cls.services["disk_offering"]) cls._cleanup = [cls.project, cls.service_offering, cls.disk_offering, cls.account, cls.domain] return
def setupProjectAccounts(self): self.debug("Creating a domain under: %s" % self.domain.name) self.domain = Domain.create(self.apiclient, services=self.testdata["domain"], parentdomainid=self.domain.id) self.admin = Account.create( self.apiclient, self.testdata["account"], admin=True, domainid=self.domain.id ) # Create project as a domain admin self.project = Project.create(self.apiclient, self.testdata["project"], account=self.admin.name, domainid=self.admin.domainid) # Cleanup created project at end of test self.cleanup.append(self.project) self.cleanup.append(self.admin) self.cleanup.append(self.domain) self.debug("Created project with domain admin with name: %s" % self.project.name) projects = Project.list(self.apiclient, id=self.project.id, listall=True) self.assertEqual(isinstance(projects, list), True, "Check for a valid list projects response") project = projects[0] self.assertEqual(project.name, self.project.name, "Check project name from list response") return
def create_domain_account_user(parentDomain=None): domain = Domain.create(cls.api_client, cls.services["domain"], parentdomainid=parentDomain.id if parentDomain else None) cls._cleanup.append(domain) # Create an Account associated with domain account = Account.create(cls.api_client, cls.services["account"], domainid=domain.id) cls._cleanup.append(account) # Create an User, Project, Volume associated with account user = User.create(cls.api_client, cls.services["user"], account=account.name, domainid=account.domainid) cls._cleanup.append(user) project = Project.create(cls.api_client, cls.services["project"], account=account.name, domainid=account.domainid) cls._cleanup.append(project) volume = Volume.create(cls.api_client, cls.services["volume"], zoneid=cls.zone.id, account=account.name, domainid=account.domainid, diskofferingid=cls.disk_offering.id) cls._cleanup.append(volume) return {'domain':domain, 'account':account, 'user':user, 'project':project, 'volume':volume}
def setupNormalAccount(self): """Setup the account required for the test""" try: self.domain = Domain.create(self.apiclient, services=self.services["domain"], parentdomainid=self.domain.id) self.account = Account.create(self.apiclient, self.services["account"], domainid=self.domain.id, admin=False) self.cleanup.append(self.account) self.cleanup.append(self.domain) self.virtualMachine = VirtualMachine.create(self.api_client, self.services["virtual_machine"], accountid=self.account.name, domainid=self.account.domainid, diskofferingid=self.disk_offering.id, serviceofferingid=self.service_offering.id) accounts = Account.list(self.apiclient, id=self.account.id) self.assertEqual(validateList(accounts)[0], PASS, "accounts list validation failed") self.initialResourceCount = int(accounts[0].primarystoragetotal) primarystoragelimit = self.initialResourceCount update_resource_limit(self.api_client, RESOURCE_PRIMARY_STORAGE, account=self.account.name, domainid=self.account.domainid, max=primarystoragelimit) except Exception as e: return [FAIL, e] return [PASS, None]
def setupAccount(self, accountType): """Setup the account required for the test""" try: if accountType == CHILD_DOMAIN_ADMIN: self.domain = Domain.create(self.apiclient, services=self.services["domain"], parentdomainid=self.domain.id) self.account = Account.create(self.apiclient, self.services["account"], domainid=self.domain.id, admin=True) self.cleanup.append(self.account) if accountType == CHILD_DOMAIN_ADMIN: self.cleanup.append(self.domain) self.virtualMachine = VirtualMachine.create(self.api_client, self.services["virtual_machine"], accountid=self.account.name, domainid=self.account.domainid, diskofferingid=self.disk_offering.id, serviceofferingid=self.service_offering.id) accounts = Account.list(self.apiclient, id=self.account.id) self.assertEqual(validateList(accounts)[0], PASS, "accounts list validation failed") self.initialResourceCount = int(accounts[0].primarystoragetotal) except Exception as e: return [FAIL, e] return [PASS, None]
def setUpClass(cls): cls._cleanup = [] cls.testClient = super(TestEgressFWRules, cls).getClsTestClient() cls.api_client = cls.testClient.getApiClient() cls.services = Services().services # Get Zone, Domain and templates cls.domain = get_domain(cls.api_client) cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests()) cls.services['mode'] = cls.zone.networktype # Get and set template id for VM creation. cls.template = get_template(cls.api_client, cls.zone.id, cls.services["ostype"]) cls.services["virtual_machine"]["zoneid"] = cls.zone.id cls.services["virtual_machine"]["template"] = cls.template.id parentDomain = None cls.domain = Domain.create( cls.api_client, cls.services["domain"], parentdomainid=parentDomain.id if parentDomain else None) cls._cleanup.append(cls.domain) # Create an Account associated with domain cls.account = Account.create(cls.api_client, cls.services["account"], domainid=cls.domain.id) cls._cleanup.append(cls.account) # Create service offerings. cls.service_offering = ServiceOffering.create( cls.api_client, cls.services["service_offering"]) # Cleanup cls._cleanup.append(cls.service_offering)
def setUpClass(cls): cls._cleanup = [] cls.testClient = super(TestEgressFWRules, cls).getClsTestClient() cls.api_client = cls.testClient.getApiClient() cls.services = Services().services # Get Zone, Domain and templates cls.domain = get_domain(cls.api_client) cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests()) cls.services['mode'] = cls.zone.networktype # Get and set template id for VM creation. cls.template = get_template(cls.api_client, cls.zone.id, cls.services["ostype"]) cls.services["virtual_machine"]["zoneid"] = cls.zone.id cls.services["virtual_machine"]["template"] = cls.template.id parentDomain = None cls.domain = Domain.create(cls.api_client, cls.services["domain"], parentdomainid=parentDomain.id if parentDomain else None) cls._cleanup.append(cls.domain) # Create an Account associated with domain cls.account = Account.create(cls.api_client, cls.services["account"], domainid=cls.domain.id) cls._cleanup.append(cls.account) # Create service offerings. cls.service_offering = ServiceOffering.create(cls.api_client, cls.services["service_offering"]) # Cleanup cls._cleanup.append(cls.service_offering)
def setupAccounts(self): try: self.child_domain = Domain.create(self.apiclient, services=self.services["domain"], parentdomainid=self.domain.id) self.child_do_admin = Account.create(self.apiclient, self.services["account"], admin=True, domainid=self.child_domain.id) # Create project as a domain admin self.project = Project.create( self.apiclient, self.services["project"], account=self.child_do_admin.name, domainid=self.child_do_admin.domainid) # Cleanup created project at end of test self.cleanup.append(self.project) # Cleanup accounts created self.cleanup.append(self.child_do_admin) self.cleanup.append(self.child_domain) except Exception as e: return [FAIL, e] return [PASS, None]
def test_es_1863_register_template_s3_domain_admin_user(self): """ @Desc: Test whether cloudstack allows Domain admin or user to register a template using S3/Swift object store. @Steps: Step1: create a Domain and users in it. Step2: Register a template as Domain admin. Step3: Register a template as Domain user. Step4: Template should be registered successfully. """ # Step1: create a Domain and users in it. self.newdomain = Domain.create(self.apiClient, self.services["domain"]) # create account in the domain self.account_domain = Account.create( self.apiClient, self.services["account"], domainid=self.newdomain.id ) self.cleanup.append(self.account_domain) self.cleanup.append(self.newdomain) # Getting authentication for user in newly created Account in domain self.domain_user = self.account_domain.user[0] self.domain_userapiclient = self.testClient.getUserApiClient( self.domain_user.username, self.newdomain.name ) # Step2: Register a template as Domain admin. self.services["templateregister"]["ostype"] = self.services["ostype"] self.domain_template = Template.register( self.apiClient, self.services["templateregister"], zoneid=self.zone.id, account=self.account_domain.name, domainid=self.newdomain.id, hypervisor=self.hypervisor ) # Wait for template to download self.domain_template.download(self.api_client) # Wait for template status to be changed across time.sleep(60) # Step3: Register a template as Domain user. self.domain_user_template = Template.register( self.domain_userapiclient, self.services["templateregister"], zoneid=self.zone.id, account=self.account_domain.name, domainid=self.newdomain.id, hypervisor=self.hypervisor ) # Wait for template to download self.domain_user_template.download(self.api_client) # Wait for template status to be changed across time.sleep(60) # TODO: Step4: Template should be registered successfully. return
def setupAccounts(self): try: self.child_domain = Domain.create(self.apiclient,services=self.services["domain"], parentdomainid=self.domain.id) self.child_do_admin = Account.create(self.apiclient, self.services["account"], admin=True, domainid=self.child_domain.id) self.userapiclient = self.testClient.getUserApiClient( UserName=self.child_do_admin.name, DomainName=self.child_do_admin.domain) # Create project as a domain admin self.project = Project.create(self.apiclient, self.services["project"], account=self.child_do_admin.name, domainid=self.child_do_admin.domainid) # Cleanup created project at end of test self.cleanup.append(self.project) # Cleanup accounts created self.cleanup.append(self.child_do_admin) self.cleanup.append(self.child_domain) except Exception as e: return [FAIL, e] return [PASS, None]
def setUpClass(cls): cls.testClient = super(TestRAMCPUResourceAccounting, cls).getClsTestClient() cls.api_client = cls.testClient.getApiClient() cls.services = Services().services cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests()) cls.services['mode'] = cls.zone.networktype cls.hypervisor = cls.testClient.getHypervisorInfo() # Create an account, domain etc cls.domain = Domain.create( cls.api_client, cls.services["domain"], ) cls.account = Account.create(cls.api_client, cls.services["account"], admin=True, domainid=cls.domain.id) cls.template = get_test_template(cls.api_client, cls.zone.id, cls.hypervisor) cls.services["virtual_machine_1"]["zoneid"] = cls.zone.id cls.services["virtual_machine_1"]["template"] = cls.template.id cls.services["virtual_machine_2"]["zoneid"] = cls.zone.id cls.services["virtual_machine_2"]["template"] = cls.template.id cls._cleanup = [cls.account, cls.domain]
def setupProjectAccounts(self): self.debug("Creating a domain under: %s" % self.domain.name) self.domain = Domain.create(self.apiclient, services=self.services["domain"], parentdomainid=self.domain.id) self.admin = Account.create( self.apiclient, self.services["account"], admin=True, domainid=self.domain.id ) # Create project as a domain admin self.project = Project.create(self.apiclient, self.services["project"], account=self.admin.name, domainid=self.admin.domainid) # Cleanup created project at end of test self.cleanup.append(self.project) self.cleanup.append(self.admin) self.cleanup.append(self.domain) self.debug("Created project with domain admin with name: %s" % self.project.name) projects = Project.list(self.apiclient, id=self.project.id, listall=True) self.assertEqual(isinstance(projects, list), True, "Check for a valid list projects response") project = projects[0] self.assertEqual(project.name, self.project.name, "Check project name from list response") return
def setUp(self): self.apiclient = self.testClient.getApiClient() self.hypervisor = self.testClient.getHypervisorInfo() self.dbclient = self.testClient.getDbConnection() self.cleanup = [] self.services = Services().services # Get Zone, Domain and templates self.domain = get_domain(self.apiclient) self.account = Account.create( self.apiclient, self.services["account"], domainid=self.domain.id ) self.newdomain = Domain.create( self.apiclient, self.services["testdomain"], parentdomainid=self.domain.id ) self.newdomain_account = Account.create( self.apiclient, self.services["account"], admin=True, domainid=self.newdomain.id ) self.cleanup = [ self.account, self.newdomain_account, self.newdomain, ]
def setupAccounts(self, account_limit=2, domain_limit=2, project_limit=2): self.debug("Creating a domain under: %s" % self.domain.name) self.child_domain = Domain.create(self.apiclient, services=self.testdata["domain"], parentdomainid=self.domain.id) self.debug("domain crated with domain id %s" % self.child_domain.id) self.child_do_admin = Account.create(self.apiclient, self.testdata["account"], admin=True, domainid=self.child_domain.id) self.debug("domain admin created for domain id %s" % self.child_do_admin.domainid) # Create project as a domain admin self.project = Project.create(self.apiclient, self.testdata["project"], account=self.child_do_admin.name, domainid=self.child_do_admin.domainid) # Cleanup created project at end of test self.cleanup.append(self.project) # Cleanup accounts created self.cleanup.append(self.child_do_admin) self.cleanup.append(self.child_domain) self.debug("Updating the CPU resource count for domain: %s" % self.child_domain.name) # Update resource limits for account 1 responses = Resources.updateLimit(self.apiclient, resourcetype=8, max=account_limit, account=self.child_do_admin.name, domainid=self.child_do_admin.domainid) self.debug("CPU Resource count for child domain admin account is now: %s" % responses.max) self.debug("Updating the CPU limit for project") responses = Resources.updateLimit(self.apiclient, resourcetype=8, max=project_limit, projectid=self.project.id) self.debug("CPU Resource count for project is now") self.debug(responses.max) self.debug("Updating the CPU limit for domain only") responses = Resources.updateLimit(self.apiclient, resourcetype=8, max=domain_limit, domainid=self.child_domain.id) self.debug("CPU Resource count for domain %s with id %s is now %s" % (responses.domain, responses.domainid, responses.max)) return
def setupAccounts(self): try: self.child_domain = Domain.create(self.apiclient, services=self.services["domain"], parentdomainid=self.domain.id) self.cleanup.append(self.child_domain) self.child_do_admin = Account.create(self.apiclient, self.services["account"], admin=True, domainid=self.child_domain.id) self.cleanup.append(self.child_do_admin) self.userapiclient = self.testClient.getUserApiClient( UserName=self.child_do_admin.name, DomainName=self.child_do_admin.domain) # Create project as a domain admin self.project = Project.create( self.apiclient, self.services["project"], account=self.child_do_admin.name, domainid=self.child_do_admin.domainid) self.cleanup.append(self.project) except Exception as e: return [FAIL, e] return [PASS, None]
def setupAccount(self, accountType): """Setup the account required for the test""" try: if accountType == CHILD_DOMAIN_ADMIN: self.domain = Domain.create(self.apiclient, services=self.services["domain"], parentdomainid=self.domain.id) self.account = Account.create(self.apiclient, self.services["account"], domainid=self.domain.id, admin=True) self.cleanup.append(self.account) if accountType == CHILD_DOMAIN_ADMIN: self.cleanup.append(self.domain) self.virtualMachine = VirtualMachine.create( self.api_client, self.services["virtual_machine"], accountid=self.account.name, domainid=self.account.domainid, diskofferingid=self.disk_offering.id, serviceofferingid=self.service_offering.id) accounts = Account.list(self.apiclient, id=self.account.id) self.assertEqual( validateList(accounts)[0], PASS, "accounts list validation failed") self.initialResourceCount = int(accounts[0].primarystoragetotal) except Exception as e: return [FAIL, e] return [PASS, None]
def setupAccounts(self): try: self.parent_domain = Domain.create( self.apiclient, services=self.services["domain"], parentdomainid=self.domain.id) self.parentd_admin = Account.create(self.apiclient, self.services["account"], admin=True, domainid=self.parent_domain.id) # Create sub-domains and their admin accounts self.cdomain_1 = Domain.create( self.apiclient, services=self.services["domain"], parentdomainid=self.parent_domain.id) self.cdomain_2 = Domain.create( self.apiclient, services=self.services["domain"], parentdomainid=self.parent_domain.id) self.cadmin_1 = Account.create(self.apiclient, self.services["account"], admin=True, domainid=self.cdomain_1.id) self.cadmin_2 = Account.create(self.apiclient, self.services["account"], admin=True, domainid=self.cdomain_2.id) # Cleanup the resources created at end of test self.cleanup.append(self.cadmin_1) self.cleanup.append(self.cadmin_2) self.cleanup.append(self.cdomain_1) self.cleanup.append(self.cdomain_2) self.cleanup.append(self.parentd_admin) self.cleanup.append(self.parent_domain) users = { self.cdomain_1: self.cadmin_1, self.cdomain_2: self.cadmin_2 } except Exception as e: return [FAIL, e, None] return [PASS, None, users]
def create_domain(cls, domain_to_create, parent_domain = None): cls.logger.debug("Creating domain: %s under %s" % (domain_to_create[LdapTestData.name], parent_domain)) if parent_domain: domain_to_create["parentdomainid"] = parent_domain tmpDomain = Domain.create(cls.apiclient, domain_to_create) cls.logger.debug("Created domain %s with id %s " % (tmpDomain.name, tmpDomain.id)) cls._cleanup.append(tmpDomain) return tmpDomain
def setUp(self): self.user = self.services["configurableData"]["link_ldap_details"]["linkLdapUsername"] self.password = self.services["configurableData"]["link_ldap_details"]["linkLdapPassword"] self.delflag1 = 0 self.delflag2 = 0 self.delflag3 = 0 self.delflag4 = 0 self.apiclient = self.testClient.getApiClient() self.dbclient = self.testClient.getDbConnection() self.cleanup = [] self.parent_domain = Domain.create( self.apiclient, services=self.services["domain"], parentdomainid=self.domain.id) self.ldaplink = linkDomainToLdap.linkDomainToLdapCmd() self.ldaplink.domainid = self.parent_domain.id self.ldaplink.accounttype = self.services[ "configurableData"]["link_ldap_details"]["accounttype"] self.ldaplink.name = self.services[ "configurableData"]["link_ldap_details"]["name"] self.ldaplink.type = self.services[ "configurableData"]["link_ldap_details"]["type"] if self.services["configurableData"][ "link_ldap_details"]["admin"] is not None: self.ldaplink.admin = self.services[ "configurableData"]["link_ldap_details"]["admin"] if self.ldaplink.domainid == "" or self.ldaplink.accounttype == "" \ or self.ldaplink.name == "" \ or self.ldaplink.type == "": self.debug( "Please rerun the test by providing " "values in link_ldap configuration user details") self.skipTest( "Please rerun the test by providing " "proper values in configuration file(link ldap)") else: self.delflag1 = 1 self.ldaplinkRes = self.apiClient.linkDomainToLdap(self.ldaplink) self.assertEquals( self.delflag1, 1, "Linking LDAP failed,please check the configuration") loginRes = checklogin(self, self.user, self.password, self.parent_domain.name, method="POST") self.debug(loginRes) self.assertEquals(loginRes, 1, self.reason) lsap_user = Account.list(self.api_client, domainid=self.parent_domain.id, name=self.user ) self.ldapacctID = lsap_user[0].id
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 deploy_domain(self, domain_data): if domain_data['name'] == 'ROOT': domain_list = Domain.list(api_client=self.api_client, name=domain_data['name']) domain = domain_list[0] else: self.logger.debug('>>> DOMAIN => Creating "%s"...', domain_data['name']) domain = Domain.create( api_client=self.api_client, name=domain_data['name'] + ('-' + random_gen() if self.randomizeNames else '')) self.logger.debug( '>>> DOMAIN => ID: %s => Name: %s => Path: %s => State: %s', domain.id, domain.name, domain.path, domain.state) self.deploy_accounts(domain_data['accounts'], domain)
def deploy_domain(self, domain_data): if domain_data['name'] == 'ROOT': domain_list = Domain.list( api_client=self.api_client, name=domain_data['name'] ) domain = domain_list[0] else: self.logger.debug('>>> DOMAIN => Creating "%s"...', domain_data['name']) domain = Domain.create( api_client=self.api_client, name=domain_data['name'] + ('-' + random_gen() if self.randomizeNames else '') ) self.logger.debug('>>> DOMAIN => ID: %s => Name: %s => Path: %s => State: %s', domain.id, domain.name, domain.path, domain.state) self.deploy_accounts(domain_data['accounts'], domain)
def setUpClass(cls): cls.testClient = super(TestResourceLimitsProject, cls).getClsTestClient() cls.api_client = cls.testClient.getApiClient() cls.hypervisor = cls.testClient.getHypervisorInfo() cls.services = Services().services cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests()) cls.services['mode'] = cls.zone.networktype cls.template = get_template( cls.api_client, cls.zone.id, cls.services["ostype"] ) cls.services["server"]["zoneid"] = cls.zone.id # Create Domains, Account etc cls.domain = Domain.create( cls.api_client, cls.services["domain"] ) cls.account = Account.create( cls.api_client, cls.services["account"], domainid=cls.domain.id ) cls.userapiclient = cls.testClient.getUserApiClient( UserName=cls.account.name, DomainName=cls.account.domain) # Create project as a domain admin cls.project = Project.create( cls.api_client, cls.services["project"], account=cls.account.name, domainid=cls.account.domainid ) cls.services["account"] = cls.account.name # Create Service offering and disk offerings etc cls.service_offering = ServiceOffering.create( cls.api_client, cls.services["service_offering"] ) cls.disk_offering = DiskOffering.create( cls.api_client, cls.services["disk_offering"] ) cls._cleanup = [ cls.project, cls.service_offering, cls.disk_offering, cls.account, cls.domain ] return
def setUp(self): self.apiclient = self.api_client self.dbclient = self.testClient.getDbConnection() self.egressruleid = None self.cleanup = [] self.domain = Domain.create(self.apiclient, self.services["domain"]) # Create an Account associated with domain self.account = Account.create(self.apiclient, self.services["account"], domainid=self.domain.id) self.cleanup.append(self.account) self.cleanup.append(self.domain) return
def getAdminKeys(self, apiClient): domains = Domain.list(apiClient, name="ROOT") listuser = listUsers.listUsersCmd() listuser.username = "******" listuser.domainid = domains[0].id listuser.listall = True listuserRes = apiClient.listUsers(listuser) userId = listuserRes[0].id apiKey = listuserRes[0].apikey securityKey = listuserRes[0].secretkey return [apiKey, securityKey]
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): 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 setUp(self): self.apiclient = self.api_client self.dbclient = self.testClient.getDbConnection() self.egressruleid = None self.cleanup = [] self.domain = Domain.create(self.apiclient, self.services["domain"]) self.cleanup.append(self.domain) self.account = Account.create(self.apiclient, self.services["account"], domainid=self.domain.id) self.cleanup.append(self.account) return
def setupAccounts(self): self.debug("Creating a sub-domain under: %s" % self.domain.name) self.child_domain = Domain.create(self.apiclient, services=self.services["domain"], parentdomainid=self.domain.id) self.child_do_admin = Account.create(self.apiclient, self.services["account"], admin=True, domainid=self.child_domain.id) # Cleanup the resources created at end of test self.cleanup.append(self.child_do_admin) self.cleanup.append(self.child_domain) Resources.updateLimit(self.apiclient, resourcetype=8, max=16, account=self.child_do_admin.name, domainid=self.child_do_admin.domainid) self.domain = Domain.create(self.apiclient, services=self.services["domain"], parentdomainid=self.domain.id) self.admin = Account.create(self.apiclient, self.services["account"], admin=True, domainid=self.domain.id) # Cleanup the resources created at end of test self.cleanup.append(self.admin) self.cleanup.append(self.domain) Resources.updateLimit(self.apiclient, resourcetype=8, max=16, account=self.admin.name, domainid=self.admin.domainid) return
def test_create_volume_under_domain(self): """Create a volume under a non-root domain as non-root-domain user 1. Create a domain under ROOT 2. Create a user within this domain 3. As user in step 2. create a volume with standard disk offering 4. Ensure the volume is created in the domain and available to the user in his listVolumes call """ dom = Domain.create(self.apiclient, services={}, name="NROOT", parentdomainid=self.domain.id) self.cleanup.append(dom) self.assertTrue(dom is not None, msg="Domain creation failed") domuser = Account.create(apiclient=self.apiclient, services=self.services["account"], admin=False, domainid=dom.id) self.cleanup.insert(-2, domuser) self.assertTrue(domuser is not None) domapiclient = self.testClient.getUserApiClient(UserName=domuser.name, DomainName=dom.name) diskoffering = DiskOffering.list(self.apiclient) self.assertTrue(isinstance(diskoffering, list), msg="DiskOffering list is not a list?") self.assertTrue( len(diskoffering) > 0, "no disk offerings in the deployment") vol = Volume.create(domapiclient, services=self.services["volume"], zoneid=self.zone.id, account=domuser.name, domainid=dom.id, diskofferingid=diskoffering[0].id) self.assertTrue( vol is not None, "volume creation fails in domain %s as user %s" % (dom.name, domuser.name)) listed_vol = Volume.list(domapiclient, id=vol.id) self.assertTrue( listed_vol is not None and isinstance(listed_vol, list), "invalid response from listVolumes for volume %s" % vol.id) self.assertTrue( listed_vol[0].id == vol.id, "Volume returned by list volumes %s not matching with queried\ volume %s in domain %s" % (listed_vol[0].id, vol.id, dom.name))
def setupAccounts(self): try: self.parent_domain = Domain.create(self.apiclient, services=self.services["domain"], parentdomainid=self.domain.id) self.parentd_admin = Account.create(self.apiclient, self.services["account"], admin=True, domainid=self.parent_domain.id) # Cleanup the resources created at end of test self.cleanup.append(self.parentd_admin) self.cleanup.append(self.parent_domain) except Exception as e: return [FAIL, e] return [PASS, None]
def setUpClass(cls): cls.testClient = super(TestProjectLimits, cls).getClsTestClient() cls.api_client = cls.testClient.getApiClient() cls.services = Services().services cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests()) cls.services["mode"] = cls.zone.networktype # Create domains, account etc. cls.domain = Domain.create(cls.api_client, cls.services["domain"]) cls.admin = Account.create(cls.api_client, cls.services["account"], admin=True, domainid=cls.domain.id) cls.user = Account.create(cls.api_client, cls.services["user"], domainid=cls.domain.id) cls.disk_offering = DiskOffering.create(cls.api_client, cls.services["disk_offering"]) cls._cleanup = [cls.admin, cls.user, cls.domain, cls.disk_offering] return
def setupAccount(self, accountType): """Setup the account required for the test""" try: if accountType == CHILD_DOMAIN_ADMIN: self.domain = Domain.create( self.apiclient, services=self.services["domain"], parentdomainid=self.domain.id ) self.account = Account.create(self.apiclient, self.services["account"], domainid=self.domain.id, admin=True) self.cleanup.append(self.account) if accountType == CHILD_DOMAIN_ADMIN: self.cleanup.append(self.domain) except Exception as e: return [FAIL, e] return [PASS, None]
def setUpClass(cls): cls.testClient = super(TestRouters, cls).getClsTestClient() cls.api_client = cls.testClient.getApiClient() cls.services = Services().services # Get Zone, Domain and templates cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests()) cls.services['mode'] = cls.zone.networktype cls.template = get_template( cls.api_client, cls.zone.id, cls.services["ostype"] ) # Create an account, domain etc cls.domain = Domain.create( cls.api_client, cls.services["domain"], ) cls.admin_account = Account.create( cls.api_client, cls.services["account"], admin=True, domainid=cls.domain.id ) cls.user_account = Account.create( cls.api_client, cls.services["account"], domainid=cls.domain.id ) cls.services["virtual_machine"]["zoneid"] = cls.zone.id cls.services["virtual_machine"]["template"] = cls.template.id cls.service_offering = ServiceOffering.create( cls.api_client, cls.services["service_offering"] ) cls._cleanup = [ cls.service_offering, cls.admin_account, cls.user_account, cls.domain ] return
def test_create_volume_under_domain(self): """Create a volume under a non-root domain as non-root-domain user 1. Create a domain under ROOT 2. Create a user within this domain 3. As user in step 2. create a volume with standard disk offering 4. Ensure the volume is created in the domain and available to the user in his listVolumes call """ dom = Domain.create(self.apiclient, services={}, name="NROOT", parentdomainid=self.domain.id) self.cleanup.append(dom) self.assertTrue(dom is not None, msg="Domain creation failed") domuser = Account.create( apiclient=self.apiclient, services=self.services["account"], admin=False, domainid=dom.id ) self.cleanup.insert(-2, domuser) self.assertTrue(domuser is not None) domapiclient = self.testClient.getUserApiClient(UserName=domuser.name, DomainName=dom.name) diskoffering = DiskOffering.list(self.apiclient) self.assertTrue(isinstance(diskoffering, list), msg="DiskOffering list is not a list?") self.assertTrue(len(diskoffering) > 0, "no disk offerings in the deployment") vol = Volume.create( domapiclient, services=self.services["volume"], zoneid=self.zone.id, account=domuser.name, domainid=dom.id, diskofferingid=diskoffering[0].id, ) self.assertTrue(vol is not None, "volume creation fails in domain %s as user %s" % (dom.name, domuser.name)) listed_vol = Volume.list(domapiclient, id=vol.id) self.assertTrue( listed_vol is not None and isinstance(listed_vol, list), "invalid response from listVolumes for volume %s" % vol.id, ) self.assertTrue( listed_vol[0].id == vol.id, "Volume returned by list volumes %s not matching with queried\ volume %s in domain %s" % (listed_vol[0].id, vol.id, dom.name), )
def setUpClass(cls): cls.testClient = super(TestNetwork, cls).getClsTestClient() cls.api_client = cls.testClient.getApiClient() cls.services = Services().services cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests()) cls.services["mode"] = cls.zone.networktype cls.template = get_template(cls.api_client, cls.zone.id, cls.services["ostype"]) cls.services["server"]["zoneid"] = cls.zone.id # Create domains, account etc. cls.domain = Domain.create(cls.api_client, cls.services["domain"]) cls.account = Account.create(cls.api_client, cls.services["account"], admin=True, domainid=cls.domain.id) cls.service_offering = ServiceOffering.create( cls.api_client, cls.services["service_offering"], domainid=cls.domain.id ) cls._cleanup = [cls.account, cls.domain] return
def setupProjectAccounts(self): try: self.domain = Domain.create(self.apiclient, services=self.services["domain"], parentdomainid=self.domain.id) self.admin = Account.create( self.apiclient, self.services["account"], admin=True, domainid=self.domain.id) # Create project as a domain admin self.project = Project.create( self.apiclient,self.services["project"], account=self.admin.name,domainid=self.admin.domainid) # Cleanup created project at end of test self.cleanup.append(self.project) self.cleanup.append(self.admin) self.cleanup.append(self.domain) except Exception as e: return [FAIL, e] return [PASS, None]
def setupNormalAccount(self): """Setup the account required for the test""" try: self.domain = Domain.create(self.apiclient, services=self.services["domain"], parentdomainid=self.domain.id) self.account = Account.create( self.apiclient, self.services["account"], domainid=self.domain.id, admin=False ) self.cleanup.append(self.account) self.cleanup.append(self.domain) self.virtualMachine = VirtualMachine.create( self.api_client, self.services["virtual_machine"], accountid=self.account.name, domainid=self.account.domainid, diskofferingid=self.disk_offering.id, serviceofferingid=self.service_offering.id, ) accounts = Account.list(self.apiclient, id=self.account.id) self.assertEqual(validateList(accounts)[0], PASS, "accounts list validation failed") self.initialResourceCount = int(accounts[0].primarystoragetotal) primarystoragelimit = self.initialResourceCount update_resource_limit( self.api_client, RESOURCE_PRIMARY_STORAGE, account=self.account.name, domainid=self.account.domainid, max=primarystoragelimit, ) except Exception as e: return [FAIL, e] return [PASS, None]
def test_04_nuage_mngd_subnets_noadminaccount(self): """Test Nuage VSP Managed Subnets for ACS domains without admin account """ vsd_enterprise = self.create_vsd_enterprise() vsd_domain_template = self.create_vsd_domain_template(vsd_enterprise) self.create_vsd_default_acls(vsd_domain_template) vsd_domain1 = self.create_vsd_domain(vsd_domain_template, vsd_enterprise, "L3DomainToBeConsumedByACS") vsd_zone1 = self.create_vsd_zone(vsd_domain1, "ZoneToBeConsumedByACS") vsd_subnet1 = self.create_vsd_subnet(vsd_zone1, "SubnetToBeConsumedByACS", "10.0.0.1/24") acs_domain_1 = Domain.create( self.api_client, {}, name="DomainManagedbyVsd", domainid=vsd_enterprise.id ) # Create an no admin and an user account under domain D1 acs_account_1 = Account.create( self.api_client, self.test_data["acl"]["accountD1"], admin=False, domainid=acs_domain_1.id ) self.cleanup.append(acs_domain_1) self.cleanup.append(acs_account_1) # On ACS create network fails as non admin account with self.assertRaises(Exception): self.create_Network( self.nuage_isolated_network_offering, gateway="10.0.0.1", netmask="255.255.255.0", account=acs_account_1, externalid=vsd_subnet1.id)
def setUpClass(cls): cls.testClient = super(TestResizeVolume, cls).getClsTestClient() cls.api_client = cls.testClient.getApiClient() cls.hypervisor = (cls.testClient.getHypervisorInfo()).lower() cls.storageID = None # Fill services from the external config file cls.services = cls.testClient.getParsedTestDataConfig() # Get Zone, Domain and templates cls.domain = get_domain(cls.api_client) cls.zone = get_zone( cls.api_client, cls.testClient.getZoneForTests()) cls.services["mode"] = cls.zone.networktype cls._cleanup = [] cls.unsupportedStorageType = False cls.unsupportedHypervisorType = False cls.updateclone = False if cls.hypervisor not in ['xenserver',"kvm","vmware"]: cls.unsupportedHypervisorType=True return cls.template = get_template( cls.api_client, cls.zone.id ) cls.services["virtual_machine"]["zoneid"] = cls.zone.id cls.services["virtual_machine"]["template"] = cls.template.id cls.services["volume"]["zoneid"] = cls.zone.id try: cls.parent_domain = Domain.create(cls.api_client, services=cls.services[ "domain"], parentdomainid=cls.domain.id) cls.parentd_admin = Account.create(cls.api_client, cls.services["account"], admin=True, domainid=cls.parent_domain.id) cls._cleanup.append(cls.parentd_admin) cls._cleanup.append(cls.parent_domain) list_pool_resp = list_storage_pools(cls.api_client, account=cls.parentd_admin.name,domainid=cls.parent_domain.id) res = validateList(list_pool_resp) if res[2]== INVALID_INPUT: raise Exception("Failed to list storage pool-no storagepools found ") #Identify the storage pool type and set vmware fullclone to true if storage is VMFS if cls.hypervisor == 'vmware': for strpool in list_pool_resp: if strpool.type.lower() == "vmfs" or strpool.type.lower()== "networkfilesystem": list_config_storage_response = list_configurations( cls.api_client , name= "vmware.create.full.clone",storageid=strpool.id) res = validateList(list_config_storage_response) if res[2]== INVALID_INPUT: raise Exception("Failed to list configurations ") if list_config_storage_response[0].value == "false": Configurations.update(cls.api_client, "vmware.create.full.clone", value="true",storageid=strpool.id) cls.updateclone = True StoragePool.update(cls.api_client,id=strpool.id,tags="scsi") cls.storageID = strpool.id cls.unsupportedStorageType = False break else: cls.unsupportedStorageType = True # Creating service offering with normal config cls.service_offering = ServiceOffering.create( cls.api_client, cls.services["service_offering"]) cls.services_offering_vmware=ServiceOffering.create( cls.api_client,cls.services["service_offering"],tags="scsi") cls._cleanup.extend([cls.service_offering,cls.services_offering_vmware]) except Exception as e: cls.tearDownClass() return