def _test_detach_iso(self): datacenter = self.store.datacenter domain = self.store.isoattach self.api.delete(domain) domains = self.api.getall(schema.StorageDomain, base=datacenter) assert not util.contains_id(domains, domain.id) domains = self.api.getall(schema.StorageDomain) assert util.contains_id(domains, domain.id)
def _test_detach_network(self): cluster = self.store.cluster network = self.store.network atnetwork = self.store.atnetwork self.api.delete(atnetwork) networks = self.api.getall(schema.Network, base=cluster) assert not util.contains_id(networks, atnetwork.id) networks = self.api.getall(schema.Network) assert util.contains_id(networks, network.id) self.api.delete(network) networks = self.api.getall(schema.Network) assert not util.contains_id(networks, network.id)
def test_getall(self): vms = self.api.getall(schema.VM) assert isinstance(vms, schema.VMs) for vm in vms: assert isinstance(vm, schema.VM) vm = self.store.vm assert util.contains_id(vms, vm.id)
def _test_getall_attached(self): datacenter = self.store.datacenter domain = self.store.attachdomain domains = self.api.getall(schema.StorageDomain, base=datacenter) assert isinstance(domains, schema.StorageDomains) assert len(domains) > 0 assert util.contains_id(domains, domain.id)
def test_getall(self): template = self.store.template templates = self.api.getall(schema.Template) assert isinstance(templates, schema.Templates) for template2 in templates: assert isinstance(template2, schema.Template) assert util.contains_id(templates, template.id)
def test_getall(self): pool = self.store.pool pools = self.api.getall(schema.VmPool) assert isinstance(pools, schema.VmPools) for pool2 in pools: assert isinstance(pool2, schema.VmPool) assert util.contains_id(pools, pool.id)
def _test_getall(self): host = self.store.host hosts = self.api.getall(schema.Host) assert isinstance(hosts, schema.Hosts) assert len(hosts) > 0 for h in hosts: assert isinstance(h, schema.Host) assert util.contains_id(hosts, host.id)
def _test_getall(self): network = self.store.network networks = self.api.getall(schema.Network) assert isinstance(networks, schema.Networks) assert len(networks) > 0 for network in networks: assert isinstance(network, schema.Network) assert util.contains_id(networks, network.id)
def _test_delete_iso(self): host = self.store.host domain = self.store.isodomain params = schema.new(schema.StorageDomain) params.host = schema.ref(host) params.format = True self.api.delete(domain, data=params) domains = self.api.getall(schema.StorageDomain) assert not util.contains_id(domains, domain.id)
def _test_getall(self): nic = self.store.nic host = self.store.host nics = self.api.getall(schema.HostNIC, base=host) assert isinstance(nics, schema.HostNics) assert len(nics) > 0 for nic2 in nics: assert isinstance(nic2, schema.HostNIC) assert util.contains_id(nics, nic.id)
def _test_delete(self): host = self.store.host assert host.status == "UP" # A deactivate can fail if the host is currently contending to become # an SPM, which is possible as _test_prepare may have just activate # it. Retry a couple of times. assert self.retry_action(host, "deactivate") assert self.wait_for_status(host, "MAINTENANCE") self.api.delete(host) hosts = self.api.getall(schema.Host) assert not util.contains_id(hosts, host.id)
def test_delete(self): pool = self.store.pool vms = self.api.getall(schema.VM, filter={'vmpool.id': pool.id}) for vm in vms: action = self.api.action(vm, 'detach') assert action.status == 'COMPLETE' self.api.delete(vm) self.api.delete(pool) pools = self.api.getall(schema.VmPool) assert not util.contains_id(pools, pool.id) self.api.delete(self.store.template) self.api.delete(self.store.vm)
def test_import(self): template = self.store.template self.api.delete(template) storagedomain = self.store.storagedomain exportdomain = self.store.exportdomain templates = self.api.getall(schema.Template, base=exportdomain) assert len(templates) > 0 assert isinstance(templates, schema.Templates) assert util.contains_id(templates, template.id) for template2 in templates: if template2.id == template.id: break action = schema.new(schema.Action) action.storage_domain = schema.ref(storagedomain) action.cluster = schema.ref(template.cluster) action = self.api.action(template2, 'import', action) assert action.status == 'COMPLETE'
def test_import(self): vm = self.store.vm self.api.delete(vm) storagedomain = self.store.storagedomain exportdomain = self.store.exportdomain vms = self.api.getall(schema.VM, base=exportdomain) assert len(vms) > 0 assert isinstance(vms, schema.VMs) assert util.contains_id(vms, vm.id) for vm2 in vms: if vm2.id == vm.id: break action = schema.new(schema.Action) action.storage_domain = schema.ref(storagedomain) action.cluster = schema.ref(vm.cluster) action = self.api.action(vm2, 'import', action) assert action.status == 'COMPLETE'
def _test_attach_network(self): cluster = self.store.cluster network = schema.new(schema.Network) network.name = util.random_name('net') network.description = 'foo' network.data_center = schema.ref(self.store.datacenter) network.stp = False network.vlan = self.get_vlan() network.ip = self.get_unused_ip() network.display = False network = self.api.create(network) assert network is not None atnetwork = self.api.create(network, base=cluster) networks = self.api.getall(schema.Network, base=cluster) assert util.contains_id(networks, atnetwork.id) self.store.network = network self.store.atnetwork = atnetwork
def _test_getall(self): cluster = self.store.cluster clusters = self.api.getall(schema.Cluster) assert isinstance(clusters, schema.Clusters) assert len(clusters) > 0 assert util.contains_id(clusters, cluster.id)
def test_delete(self): template = self.store.template self.api.delete(template) templates = self.api.getall(schema.Template) assert not util.contains_id(templates, template.id) self.api.delete(self.store.vm)
def _test_getall(self): domain = self.store.storagedomain domains = self.api.getall(schema.StorageDomain) assert isinstance(domains, schema.StorageDomains) assert len(domains) > 0 assert util.contains_id(domains, domain.id)
def test_getall(self): tag = self.store.tag tags = self.api.getall(schema.Tag) assert isinstance(tags, schema.Tags) assert len(tags) > 0 assert util.contains_id(tags, tag.id)
def test_delete_child(self): child = self.store.child self.api.delete(child) tags = self.api.getall(schema.Tag) assert not util.contains_id(tags, child.id)
def _test_getall(self): dc = self.store.dc dcs = self.api.getall(schema.DataCenter) assert isinstance(dcs, schema.DataCenters) assert len(dcs) > 0 assert util.contains_id(dcs, dc.id)
def test_delete(self): tag = self.store.tag self.api.delete(tag) tags = self.api.getall(schema.Tag) assert not util.contains_id(tags, tag.id)