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):
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_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_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_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_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_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
