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)
