blob: 2696db8f96b43425943c627b7b0f91175522d74d [file] [log] [blame]
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
""" BVT tests for Templates ISO
"""
#Import Local Modules
from marvin.cloudstackException import *
from marvin.cloudstackAPI import *
from marvin.codes import FAILED
from marvin.cloudstackTestCase import cloudstackTestCase
import unittest
from marvin.cloudstackAPI import listZones
from marvin.lib.utils import random_gen, cleanup_resources
from marvin.lib.base import (Account,
ServiceOffering,
VirtualMachine,
DiskOffering,
Template,
Volume,
Zone)
from marvin.lib.common import (get_domain,
get_zone,
get_template)
from nose.plugins.attrib import attr
import urllib.request, urllib.parse, urllib.error
#Import System modules
import time
from marvin.cloudstackAPI import (createTemplate, listOsTypes)
_multiprocess_shared_ = True
class TestCreateTemplateWithChecksum(cloudstackTestCase):
def setUp(self):
self.testClient = super(TestCreateTemplateWithChecksum, self).getClsTestClient()
self.apiclient = self.testClient.getApiClient()
self.dbclient = self.testClient.getDbConnection()
self.cleanup = []
self.services = self.testClient.getParsedTestDataConfig()
self.unsupportedHypervisor = False
self.hypervisor = self.testClient.getHypervisorInfo()
if self.hypervisor.lower() in ['lxc']:
# Template creation from root volume is not supported in LXC
self.unsupportedHypervisor = True
return
# Get Zone, Domain and templates
self.domain = get_domain(self.apiclient)
self.zone = get_zone(self.apiclient, self.testClient.getZoneForTests())
if "kvm" in self.hypervisor.lower():
self.test_template = registerTemplate.registerTemplateCmd()
self.test_template = registerTemplate.registerTemplateCmd()
self.test_template.checksum = "{SHA-1}" + "6952e58f39b470bd166ace11ffd20bf479bed936"
self.test_template.hypervisor = self.hypervisor
self.test_template.zoneid = self.zone.id
self.test_template.name = 'test sha-2333'
self.test_template.displaytext = 'test sha-1'
self.test_template.url = "http://dl.openvm.eu/cloudstack/macchinina/x86_64/macchinina-kvm.qcow2.bz2"
self.test_template.format = "QCOW2"
self.test_template.ostypeid = self.getOsType("Other Linux (64-bit)")
self.md5 = "88c60fd500ce7ced985cf845df0db9da"
self.sha256 = "bc4cc040bbab843000fab78db6cb4a33f3a06ae1ced2cf563d36b38c7fee3049"
if "vmware" in self.hypervisor.lower():
self.test_template = registerTemplate.registerTemplateCmd()
self.test_template = registerTemplate.registerTemplateCmd()
self.test_template.checksum = "{SHA-1}" + "8b82224fd3c6429b6914f32d8339e650770c7526"
self.test_template.hypervisor = self.hypervisor
self.test_template.zoneid = self.zone.id
self.test_template.name = 'test sha-2333'
self.test_template.displaytext = 'test sha-1'
self.test_template.url = "http://dl.openvm.eu/cloudstack/macchinina/x86_64/macchinina-vmware.ova"
self.test_template.format = "OVA"
self.test_template.ostypeid = self.getOsType("Other Linux (64-bit)")
self.md5 = "b4e8bff3882b23175974e692533b4381"
self.sha256 = "e1dffca3c3ab545a753cb42d838a341624cf25841d1bcf3d1e45556c9fce7cf3"
if "xen" in self.hypervisor.lower():
self.test_template = registerTemplate.registerTemplateCmd()
self.test_template = registerTemplate.registerTemplateCmd()
self.test_template.checksum = "{SHA-1}" + "80af2c18f96e94273188808c3d56e561a1cda717"
self.test_template.hypervisor = self.hypervisor
self.test_template.zoneid = self.zone.id
self.test_template.name = 'test sha-2333'
self.test_template.displaytext = 'test sha-1'
self.test_template.url = "http://dl.openvm.eu/cloudstack/macchinina/x86_64/macchinina-xen.vhd.bz2"
self.test_template.format = "VHD"
self.test_template.ostypeid = self.getOsType("Other Linux (64-bit)")
self.md5 = "1662bbf224e41bb62b1dee043d785731"
self.sha256 = "80fba5a7a83842ec4e5f67cc6755d61d4fca46ae170d59b0c6ed47ebf7162722"
if self.unsupportedHypervisor:
self.skipTest("Skipping test because unsupported hypervisor\
%s" % self.hypervisor)
return
def tearDown(self):
try:
# Clean up the created templates
for temp in self.cleanup:
cmd = deleteTemplate.deleteTemplateCmd()
cmd.id = temp.id
cmd.zoneid = self.zone.id
cmd.forced = True
self.apiclient.deleteTemplate(cmd)
except Exception as e:
raise Exception("Warning: Exception during cleanup : %s" % e)
return
@attr(tags=["advanced", "smoke"], required_hardware="true")
def test_02_create_template_with_checksum_sha1(self):
template = self.registerTemplate(self.test_template)
self.download(self.apiclient, template.id)
@attr(tags=["advanced", "smoke"], required_hardware="true")
def test_03_create_template_with_checksum_sha256(self):
self.test_template.checksum = "{SHA-256}" + self.sha256
template = self.registerTemplate(self.test_template)
self.download(self.apiclient, template.id)
@attr(tags=["advanced", "smoke"], required_hardware="true")
def test_04_create_template_with_checksum_md5(self):
self.test_template.checksum = "{md5}" + self.md5
template = self.registerTemplate(self.test_template)
self.download(self.apiclient, template.id)
@attr(tags=["advanced", "smoke"], required_hardware="true")
def test_02_1_create_template_with_checksum_sha1_negative(self):
self.test_template.checksum = "{sha-1}" + "someInvalidValue"
template = self.registerTemplate(self.test_template)
try:
self.download(self.apiclient, template.id)
except Exception as e:
print("Negative Test Passed - Exception Occurred Under template download " \
"%s" % GetDetailExceptionInfo(e))
else:
self.fail("Negative Test Failed - Exception DID NOT Occurred Under template download ")
@attr(tags=["advanced", "smoke"], required_hardware="true")
def test_03_1_create_template_with_checksum_sha256_negative(self):
self.test_template.checksum = "{SHA-256}" + "someInvalidValue"
template = self.registerTemplate(self.test_template)
try:
self.download(self.apiclient, template.id)
except Exception as e:
print("Negative Test Passed - Exception Occurred Under template download " \
"%s" % GetDetailExceptionInfo(e))
else:
self.fail("Negative Test Failed - Exception DID NOT Occurred Under template download ")
@attr(tags=["advanced", "smoke"], required_hardware="true")
def test_04_1_create_template_with_checksum_md5_negative(self):
self.test_template.checksum = "{md5}" + "someInvalidValue"
template = self.registerTemplate(self.test_template)
try:
self.download(self.apiclient, template.id)
except Exception as e:
print("Negative Test Passed - Exception Occurred Under template download " \
"%s" % GetDetailExceptionInfo(e))
else:
self.fail("Negative Test Failed - Exception DID NOT Occurred Under template download ")
@attr(tags=["advanced", "smoke"], required_hardware="true")
def test_05_create_template_with_no_checksum(self):
self.test_template.checksum = None
template = self.registerTemplate(self.test_template)
self.download(self.apiclient, template.id)
def registerTemplate(self, cmd):
temp = self.apiclient.registerTemplate(cmd)[0]
if not temp:
self.cleanup.append(temp)
return temp
def getOsType(self, param):
cmd = listOsTypes.listOsTypesCmd()
cmd.description = param
return self.apiclient.listOsTypes(cmd)[0].id
def download(self, apiclient, template_id, retries=12, interval=5):
"""Check if template download will finish in 1 minute"""
while retries > -1:
time.sleep(interval)
template_response = Template.list(
apiclient,
id=template_id,
zoneid=self.zone.id,
templatefilter='self'
)
if isinstance(template_response, list):
template = template_response[0]
if not hasattr(template, 'status') or not template or not template.status:
retries = retries - 1
continue
# If template is ready,
# template.status = Download Complete
# Downloading - x% Downloaded
# if Failed
# Error - Any other string
if 'Failed' in template.status:
raise Exception(
"Failed to download template: status - %s" %
template.status)
elif template.status == 'Download Complete' and template.isready:
return
elif 'Downloaded' in template.status:
retries = retries - 1
continue
elif 'Installing' not in template.status:
if retries >= 0:
retries = retries - 1
continue
raise Exception(
"Error in downloading template: status - %s" %
template.status)
else:
retries = retries - 1
raise Exception("Template download failed exception.")
class TestCreateTemplate(cloudstackTestCase):
def setUp(self):
self.apiclient = self.testClient.getApiClient()
self.dbclient = self.testClient.getDbConnection()
self.cleanup = []
if self.unsupportedHypervisor:
self.skipTest("Skipping test because unsupported hypervisor\
%s" % self.hypervisor)
return
def tearDown(self):
try:
#Clean up, terminate the created templates
cleanup_resources(self.apiclient, reversed(self.cleanup))
except Exception as e:
raise Exception("Warning: Exception during cleanup : %s" % e)
return
@classmethod
def setUpClass(cls):
testClient = super(TestCreateTemplate, cls).getClsTestClient()
cls.apiclient = testClient.getApiClient()
cls._cleanup = []
cls.services = testClient.getParsedTestDataConfig()
cls.unsupportedHypervisor = False
cls.hypervisor = testClient.getHypervisorInfo()
if cls.hypervisor.lower() in ['lxc']:
# Template creation from root volume is not supported in LXC
cls.unsupportedHypervisor = True
return
# 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
try:
cls.disk_offering = DiskOffering.create(
cls.apiclient,
cls.services["disk_offering"]
)
cls._cleanup.append(cls.disk_offering)
template = get_template(
cls.apiclient,
cls.zone.id,
cls.services["ostype"]
)
if template == FAILED:
assert False, "get_template() failed to return template with description %s" % cls.services["ostype"]
cls.services["template"]["ostypeid"] = template.ostypeid
cls.services["template_2"]["ostypeid"] = template.ostypeid
cls.services["ostypeid"] = template.ostypeid
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["volume"]["diskoffering"] = cls.disk_offering.id
cls.services["volume"]["zoneid"] = cls.zone.id
cls.services["sourcezoneid"] = cls.zone.id
cls.account = Account.create(
cls.apiclient,
cls.services["account"],
domainid=cls.domain.id
)
cls._cleanup.append(cls.account)
cls.service_offering = ServiceOffering.create(
cls.apiclient,
cls.services["service_offerings"]["tiny"]
)
cls._cleanup.append(cls.service_offering)
#create virtual machine
cls.virtual_machine = VirtualMachine.create(
cls.apiclient,
cls.services["virtual_machine"],
templateid=template.id,
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=cls.service_offering.id,
mode=cls.services["mode"]
)
#Stop virtual machine
cls.virtual_machine.stop(cls.apiclient)
list_volume = Volume.list(
cls.apiclient,
virtualmachineid=cls.virtual_machine.id,
type='ROOT',
listall=True
)
cls.volume = list_volume[0]
except Exception as e:
cls.tearDownClass()
raise unittest.SkipTest("Exception in setUpClass: %s" % e)
return
@classmethod
def tearDownClass(cls):
try:
#Cleanup resources used
cleanup_resources(cls.apiclient, reversed(cls._cleanup))
except Exception as e:
raise Exception("Warning: Exception during cleanup : %s" % e)
return
@attr(tags = ["advanced", "advancedns", "smoke"], required_hardware="false")
def test_CreateTemplateWithDuplicateName(self):
"""Test when createTemplate is used to create templates having the same name all of them get
different unique names so that the templates with same name does not get deleted during template sync"""
#1. Create 2 templates with same name
#2. check the db that the templates with same name have different unique_name
#Create templates from Virtual machine and Volume ID
template1 = Template.create(self.apiclient,
self.services["template"],
self.volume.id,
account=self.account.name,
randomise=False)
self.cleanup.append(template1)
template2 = Template.create(self.apiclient,
self.services["template"],
self.volume.id,
account=self.account.name,
randomise=False)
self.cleanup.append(template2)
self.debug("Created template with ID: %s" % template1.id)
self.debug("Created template with ID: %s" % template2.id)
self.assertEqual(
template1.name, template2.name, "Created templates with same name")
self.debug("select unique_name from vm_template where name='%s';"
% template1.name)
#Db query to check for unique_name for the templates with same name
qresultset = self.dbclient.execute("select unique_name from vm_template where name='%s' and removed is NULL ;"
% template1.name)
self.debug("unique_name of template1 is '%s' and unique_name of template2 is '%s'", qresultset[0],
qresultset[1])
self.assertNotEqual(qresultset[0], qresultset[1],
"unique names are different")
@attr(tags = ["advanced", "advancedns", "smoke"], required_hardware="false")
def test_01_create_template(self):
"""Test create public & private template
"""
# Validate the following:
# 1. database (vm_template table) should be updated
# with newly created template
# 2. UI should show the newly added template
# 3. ListTemplates API should show the newly added template
#Create template from Virtual machine and Volume ID
template = Template.create(
self.apiclient,
self.services["template"],
self.volume.id,
account=self.account.name,
domainid=self.account.domainid
)
self.cleanup.append(template)
self.debug("Created template with ID: %s" % template.id)
list_template_response = Template.list(
self.apiclient,
templatefilter=\
self.services["templatefilter"],
id=template.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.displaytext,
self.services["template"]["displaytext"],
"Check display text of newly created template"
)
name = template_response.name
self.assertEqual(
name.count(self.services["template"]["name"]),
1,
"Check name of newly created template"
)
self.assertEqual(
template_response.ostypeid,
self.services["template"]["ostypeid"],
"Check osTypeID of newly created template"
)
return
class TestTemplates(cloudstackTestCase):
@classmethod
def setUpClass(cls):
testClient = super(TestTemplates, cls).getClsTestClient()
cls.apiclient = testClient.getApiClient()
cls._cleanup = []
cls.services = testClient.getParsedTestDataConfig()
cls.unsupportedHypervisor = False
cls.hypervisor = testClient.getHypervisorInfo()
if cls.hypervisor.lower() in ['lxc']:
# Template creation from root volume is not supported in LXC
cls.unsupportedHypervisor = True
return
# Get Zone, Domain and templates
cls.domain = get_domain(cls.apiclient)
cls.zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests())
cls.services['mode'] = cls.zone.networktype
#populate second zone id for iso copy
cls.zones = Zone.list(cls.apiclient)
if not isinstance(cls.zones, list):
raise Exception("Failed to find zones.")
cls.disk_offering = DiskOffering.create(
cls.apiclient,
cls.services["disk_offering"]
)
template = get_template(
cls.apiclient,
cls.zone.id,
cls.services["ostype"]
)
if template == FAILED:
assert False, "get_template() failed to return template with description %s" % cls.services["ostype"]
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["volume"]["diskoffering"] = cls.disk_offering.id
cls.services["volume"]["zoneid"] = cls.zone.id
cls.services["template_2"]["zoneid"] = cls.zone.id
cls.services["sourcezoneid"] = cls.zone.id
cls.services["template"]["ostypeid"] = template.ostypeid
cls.services["template_2"]["ostypeid"] = template.ostypeid
cls.services["ostypeid"] = template.ostypeid
cls.account = Account.create(
cls.apiclient,
cls.services["account"],
admin=True,
domainid=cls.domain.id
)
cls.user = Account.create(
cls.apiclient,
cls.services["account"],
domainid=cls.domain.id
)
cls.service_offering = ServiceOffering.create(
cls.apiclient,
cls.services["service_offerings"]["tiny"]
)
#create virtual machine
cls.virtual_machine = VirtualMachine.create(
cls.apiclient,
cls.services["virtual_machine"],
templateid=template.id,
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=cls.service_offering.id,
mode=cls.services["mode"]
)
#Stop virtual machine
cls.virtual_machine.stop(cls.apiclient)
list_volume = Volume.list(
cls.apiclient,
virtualmachineid=cls.virtual_machine.id,
type='ROOT',
listall=True
)
try:
cls.volume = list_volume[0]
except Exception as e:
raise Exception(
"Exception: Unable to find root volume foe VM: %s - %s" %
(cls.virtual_machine.id, e))
#Create templates for Edit, Delete & update permissions testcases
cls.template_1 = Template.create(
cls.apiclient,
cls.services["template"],
cls.volume.id,
account=cls.account.name,
domainid=cls.account.domainid
)
cls.services["isdynamicallyscalable"] = cls.template_1.isdynamicallyscalable
cls.template_2 = Template.create(
cls.apiclient,
cls.services["template_2"],
cls.volume.id,
account=cls.account.name,
domainid=cls.account.domainid
)
cls._cleanup = [
cls.service_offering,
cls.disk_offering,
cls.account,
cls.user
]
@classmethod
def tearDownClass(cls):
try:
cls.apiclient = super(TestTemplates, cls).getClsTestClient().getApiClient()
#Cleanup created resources such as templates and VMs
cleanup_resources(cls.apiclient, cls._cleanup)
except Exception as e:
raise Exception("Warning: Exception during cleanup : %s" % e)
return
def setUp(self):
self.apiclient = self.testClient.getApiClient()
self.dbclient = self.testClient.getDbConnection()
self.cleanup = []
if self.unsupportedHypervisor:
self.skipTest("Skipping test because unsupported hypervisor\
%s" % self.hypervisor)
return
def tearDown(self):
try:
#Clean up, terminate the created templates
cleanup_resources(self.apiclient, self.cleanup)
except Exception as e:
raise Exception("Warning: Exception during cleanup : %s" % e)
return
@attr(tags = ["advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="false")
def test_02_edit_template(self):
"""Test Edit template
"""
# Validate the following:
# 1. UI should show the edited values for template
# 2. database (vm_template table) should have updated values
new_displayText = random_gen()
new_name = random_gen()
self.template_1.update(self.apiclient,
displaytext = new_displayText,
name = new_name,
bootable = self.services["bootable"],
passwordenabled = self.services["passwordenabled"])
self.debug("Edited template with new name: %s" % new_name)
# Sleep to ensure update reflected across all the calls
time.sleep(self.services["sleep"])
timeout = self.services["timeout"]
while True:
# Verify template response for updated attributes
list_template_response = Template.list(
self.apiclient,
templatefilter=\
self.services["templatefilter"],
id=self.template_1.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(10)
timeout = timeout -1
self.assertEqual(
isinstance(list_template_response, list),
True,
"Check list response returns a valid list"
)
self.assertNotEqual(
len(list_template_response),
0,
"Check template available in List Templates"
)
template_response = list_template_response[0]
self.debug("New Name: %s" % new_displayText)
self.debug("Name in Template response: %s"
% template_response.displaytext)
self.assertEqual(
template_response.displaytext,
new_displayText,
"Check display text of updated template"
)
self.assertEqual(
template_response.name,
new_name,
"Check name of updated template"
)
self.assertEqual(
str(template_response.passwordenabled).lower(),
str(self.services["passwordenabled"]).lower(),
"Check passwordenabled field of updated template"
)
self.assertEqual(
template_response.ostypeid,
self.services["ostypeid"],
"Check OSTypeID of updated template"
)
self.assertEqual(
template_response.isdynamicallyscalable,
self.services["isdynamicallyscalable"],
"Check isdynamicallyscalable of updated template"
)
return
@attr(tags = ["advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="false")
def test_03_delete_template(self):
"""Test delete template
"""
# Validate the following:
# 1. UI should not show the deleted template
# 2. database (vm_template table) should not contain deleted template
self.debug("Deleting Template ID: %s" % self.template_1.id)
self.template_1.delete(self.apiclient)
list_template_response = Template.list(
self.apiclient,
templatefilter=\
self.services["templatefilter"],
id=self.template_1.id,
account=self.account.name,
domainid=self.account.domainid
)
# Verify template is deleted properly using ListTemplates
self.assertEqual(
list_template_response,
None,
"Check if template exists in List Templates"
)
return
@attr(tags = ["advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
def test_04_extract_template(self):
"Test for extract template"
# Validate the following
# 1. Admin should able extract and download the templates
# 2. ListTemplates should display all the public templates
# for all kind of users
# 3 .ListTemplates should not display the system templates
self.debug("Extracting template with ID: %s" % self.template_2.id)
list_extract_response = Template.extract(self.apiclient,
id=self.template_2.id,
mode= self.services["template_2"]["mode"],
zoneid=self.zone.id)
try:
# Format URL to ASCII to retrieve response code
formatted_url = urllib.parse.unquote_plus(list_extract_response.url)
url_response = urllib.request.urlopen(formatted_url)
response_code = url_response.getcode()
except Exception:
self.fail(
"Extract Template Failed with invalid URL %s (template id: %s)" \
% (formatted_url, self.template_2.id)
)
self.assertEqual(
list_extract_response.id,
self.template_2.id,
"Check ID of the extracted template"
)
self.assertEqual(
list_extract_response.extractMode,
self.services["template_2"]["mode"],
"Check mode of extraction"
)
self.assertEqual(
list_extract_response.zoneid,
self.services["template_2"]["zoneid"],
"Check zone ID of extraction"
)
self.assertEqual(
response_code,
200,
"Check for a valid response download URL"
)
return
@attr(tags = ["advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="false")
def test_05_template_permissions(self):
"""Update & Test for template permissions"""
# Validate the following
# 1. listTemplatePermissions returns valid
# permissions set for template
# 2. permission changes should be reflected in vm_template
# table in database
self.debug("Updating Template permissions ID:%s" % self.template_2.id)
self.template_2.updatePermissions(self.apiclient,
isfeatured = self.services["isfeatured"],
ispublic = self.services["ispublic"],
isextractable = self.services["isextractable"])
list_template_response = Template.list(
self.apiclient,
templatefilter='featured',
id=self.template_2.id,
account=self.account.name,
domainid=self.account.domainid
)
self.assertEqual(
isinstance(list_template_response, list),
True,
"Check list response returns a valid list"
)
# Verify template response for updated permissions for normal user
template_response = list_template_response[0]
self.assertEqual(
template_response.id,
self.template_2.id,
"Check template ID"
)
self.assertEqual(
template_response.ispublic,
int(True),
"Check ispublic permission of template"
)
self.assertNotEqual(
template_response.templatetype,
'SYSTEM',
"ListTemplates should not list any system templates"
)
return
@attr(tags = ["advanced", "advancedns", "smoke", "basic", "sg", "multizone"], required_hardware="true")
def test_06_copy_template(self):
"""Test for copy template from one zone to another"""
# Validate the following
# 1. copy template should be successful and
# secondary storage should contain new copied template.
if len(self.zones) <= 1:
self.skipTest("Not enough zones available to perform copy template")
self.services["destzoneid"] = [z for z in self.zones if z.id != self.services["sourcezoneid"]][0].id
self.debug("Copy template from Zone: %s to %s" % (
self.services["sourcezoneid"],
self.services["destzoneid"]
))
self.template_2.copy(self.apiclient,
sourcezoneid=self.services["sourcezoneid"],
destzoneid=self.services["destzoneid"])
# Verify template is copied to another zone using ListTemplates
list_template_response = Template.list(
self.apiclient,
templatefilter=\
self.services["templatefilter"],
id=self.template_2.id,
zoneid=self.services["destzoneid"]
)
self.assertEqual(
isinstance(list_template_response, list),
True,
"Check list response returns a valid list"
)
self.assertNotEqual(
len(list_template_response),
0,
"Check template extracted in List Templates"
)
template_response = list_template_response[0]
self.assertEqual(
template_response.id,
self.template_2.id,
"Check ID of the downloaded template"
)
self.assertEqual(
template_response.zoneid,
self.services["destzoneid"],
"Check zone ID of the copied template"
)
# Cleanup- Delete the copied template
timeout = self.services["timeout"]
while True:
time.sleep(self.services["sleep"])
list_template_response = Template.list(
self.apiclient,
templatefilter=\
self.services["templatefilter"],
id=self.template_2.id,
zoneid=self.services["destzoneid"]
)
self.assertEqual(
isinstance(list_template_response, list),
True,
"Check list response returns a valid list"
)
self.assertNotEqual(
len(list_template_response),
0,
"Check template extracted in List Templates"
)
template_response = list_template_response[0]
if template_response.isready == True:
break
if timeout == 0:
raise Exception(
"Failed to download copied template(ID: %s)" % template_response.id)
timeout = timeout - 1
self.template_2.delete(self.apiclient, zoneid=self.services["destzoneid"])
return
@attr(tags = ["advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="false")
def test_07_list_public_templates(self):
"""Test only public templates are visible to normal user"""
# Validate the following
# 1. ListTemplates should show only 'public' templates for normal user
list_template_response = Template.list(
self.apiclient,
templatefilter='featured',
account=self.user.name,
domainid=self.user.domainid
)
self.assertEqual(
isinstance(list_template_response, list),
True,
"Check list response returns a valid list"
)
self.assertNotEqual(
len(list_template_response),
0,
"Check template available in List Templates"
)
#Template response should list all 'public' templates
for template in list_template_response:
self.assertEqual(
template.ispublic,
True,
"ListTemplates should list only public templates"
)
return
@attr(tags = ["advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="false")
def test_08_list_system_templates(self):
"""Test System templates are not visible to normal user"""
# Validate the following
# 1. ListTemplates should not show 'SYSTEM' templates for normal user
list_template_response = Template.list(
self.apiclient,
templatefilter='featured',
account=self.user.name,
domainid=self.user.domainid
)
self.assertEqual(
isinstance(list_template_response, list),
True,
"Check list response returns a valid list"
)
self.assertNotEqual(
len(list_template_response),
0,
"Check template available in List Templates"
)
for template in list_template_response:
self.assertNotEqual(
template.templatetype,
'SYSTEM',
"ListTemplates should not list any system templates"
)
return
@attr(tags = ["advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="false")
def test_09_list_templates_download_details(self):
"""Test if list templates returns download details"""
# Validate the following
# 1. ListTemplates API has been extended to support viewing the download details - progress, download states and datastore
list_template_response = Template.list(
self.apiclient,
templatefilter='all',
account=self.user.name,
domainid=self.user.domainid
)
self.assertEqual(
isinstance(list_template_response, list),
True,
"Check list response returns a valid list"
)
self.assertNotEqual(
len(list_template_response),
0,
"Check template available in List Templates"
)
for template in list_template_response:
if template.directdownload == True:
continue
self.assertNotEqual(
len(template.downloaddetails),
0,
"Not all templates have download details"
)
return
class TestCopyAndDeleteTemplatesAcrossZones(cloudstackTestCase):
@classmethod
def setUpClass(cls):
testClient = super(TestCopyAndDeleteTemplatesAcrossZones, cls).getClsTestClient()
cls.apiclient = testClient.getApiClient()
cls._cleanup = []
cls.services = testClient.getParsedTestDataConfig()
cls.unsupportedHypervisor = False
cls.hypervisor = testClient.getHypervisorInfo()
if cls.hypervisor.lower() in ['lxc']:
# Template creation from root volume is not supported in LXC
cls.unsupportedHypervisor = True
return
# 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
try:
cls.disk_offering = DiskOffering.create(
cls.apiclient,
cls.services["disk_offering"]
)
cls._cleanup.append(cls.disk_offering)
cls.template = get_template(
cls.apiclient,
cls.zone.id,
cls.services["ostype"]
)
if cls.template == FAILED:
assert False, "get_template() failed to return template with description %s" % cls.services["ostype"]
cls.services["template"]["ostypeid"] = cls.template.ostypeid
cls.services["template_2"]["ostypeid"] = cls.template.ostypeid
cls.services["ostypeid"] = cls.template.ostypeid
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.services["volume"]["diskoffering"] = cls.disk_offering.id
cls.services["volume"]["zoneid"] = cls.zone.id
cls.services["sourcezoneid"] = cls.zone.id
cls.account = Account.create(
cls.apiclient,
cls.services["account"],
domainid=cls.domain.id
)
cls._cleanup.append(cls.account)
cls.service_offering = ServiceOffering.create(
cls.apiclient,
cls.services["service_offerings"]["tiny"]
)
cls._cleanup.append(cls.service_offering)
#create virtual machine
cls.virtual_machine = VirtualMachine.create(
cls.apiclient,
cls.services["virtual_machine"],
templateid=cls.template.id,
accountid=cls.account.name,
domainid=cls.account.domainid,
serviceofferingid=cls.service_offering.id,
mode=cls.services["mode"]
)
#Stop virtual machine
cls.virtual_machine.stop(cls.apiclient)
list_volume = Volume.list(
cls.apiclient,
virtualmachineid=cls.virtual_machine.id,
type='ROOT',
listall=True
)
cls.volume = list_volume[0]
except Exception as e:
cls.tearDownClass()
raise unittest.SkipTest("Exception in setUpClass: %s" % e)
return
@classmethod
def tearDownClass(cls):
try:
#Cleanup resources used
cleanup_resources(cls.apiclient, cls._cleanup)
except Exception as e:
raise Exception("Warning: Exception during cleanup : %s" % e)
return
def setUp(self):
self.apiclient = self.testClient.getApiClient()
self.dbclient = self.testClient.getDbConnection()
self.cleanup = []
if self.unsupportedHypervisor:
self.skipTest("Skipping test because unsupported hypervisor\
%s" % self.hypervisor)
return
def tearDown(self):
try:
#Clean up, terminate the created templates
cleanup_resources(self.apiclient, self.cleanup)
except Exception as e:
raise Exception("Warning: Exception during cleanup : %s" % e)
return
@attr(tags=["advanced", "advancedns"], required_hardware="true")
def test_09_copy_delete_template(self):
cmd = listZones.listZonesCmd()
zones = self.apiclient.listZones(cmd)
if not isinstance(zones, list):
raise Exception("Failed to find zones.")
if len(zones) < 2:
self.skipTest("Skipping test due to there are less than two zones.")
return
self.sourceZone = zones[0]
self.destZone = zones[1]
template = Template.create(
self.apiclient,
self.services["template"],
self.volume.id,
account=self.account.name,
domainid=self.account.domainid
)
self.cleanup.append(template)
self.debug("Created template with ID: %s" % template.id)
list_template_response = Template.list(
self.apiclient,
templatefilter= self.services["templatefilter"],
id=template.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"
)
# todo: check for template ready
# Copy template from zone1 to zone2
self.copytemplate = template.copy(
self.apiclient,
sourcezoneid=self.sourceZone.id,
destzoneid=self.destZone.id
)
self.cleanup.append(self.copytemplate)
list_template_response = Template.list(
self.apiclient,
templatefilter=self.services["templatefilter"],
id=self.template.id,
zoneid=self.destZone.id
)
self.assertEqual(
list_template_response,
None,
"Check template available in List Templates"
)
self.deltemplate = list_template_response[0]
self.debug("Deleting template: %s" % self.deltemplate)
# Delete the template
self.deltemplate.delete(self.apiclient)
self.debug("Delete template: %s successful" % self.deltemplate)
copytemplate = template.copy(
self.apiclient,
sourcezoneid=self.sourceZone.id,
destzoneid = self.destZone.id
)
self.cleanup.append(copytemplate)
removed = self.dbclient.execute("select removed from template_zone_ref where zone_id='%s' and template_id='%s';" % self.destZone.id, self.template.id)
self.assertEqual(
removed,
None,
"Removed state is not correct."
)
return
class TestCreateTemplateWithDirectDownload(cloudstackTestCase):
@classmethod
def setUpClass(cls):
cls.testClient = super(TestCreateTemplateWithDirectDownload, cls).getClsTestClient()
cls.apiclient = cls.testClient.getApiClient()
cls.dbclient = cls.testClient.getDbConnection()
cls._cleanup = []
cls.templates = []
cls.services = cls.testClient.getParsedTestDataConfig()
cls.unsupportedHypervisor = False
cls.hypervisor = cls.testClient.getHypervisorInfo()
if cls.hypervisor.lower() not in ['kvm']:
# Direct Download is only available for KVM hypervisor
cls.unsupportedHypervisor = True
return
# Get Zone, Domain and templates
cls.domain = get_domain(cls.apiclient)
cls.zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests())
cls.services["mode"] = cls.zone.networktype
cls.services["virtual_machine"]["zoneid"] = cls.zone.id
cls.account = Account.create(
cls.apiclient,
cls.services["account"],
admin=True,
domainid=cls.domain.id
)
cls._cleanup.append(cls.account)
cls.user = Account.create(
cls.apiclient,
cls.services["account"],
domainid=cls.domain.id
)
cls._cleanup.append(cls.user)
cls.service_offering = ServiceOffering.create(
cls.apiclient,
cls.services["service_offerings"]["tiny"]
)
cls._cleanup.append(cls.service_offering)
cls.template = {
"name": "tiny-kvm",
"displaytext": "tiny kvm",
"format": "QCOW2",
"url": "http://dl.openvm.eu/cloudstack/macchinina/x86_64/macchinina-kvm.qcow2.bz2",
"requireshvm": "True",
"ispublic": "True",
"isextractable": "True",
"checksum": "{SHA-1}" + "6952e58f39b470bd166ace11ffd20bf479bed936",
"hypervisor": cls.hypervisor,
"zoneid": cls.zone.id,
"ostype": "Other Linux (64-bit)",
"directdownload": True
}
return
@classmethod
def tearDownClass(cls):
super(TestCreateTemplateWithDirectDownload, cls).tearDownClass()
def setUp(self):
self.apiclient = self.testClient.getApiClient()
self.dbclient = self.testClient.getDbConnection()
self.cleanup = []
if self.unsupportedHypervisor:
self.skipTest("Skipping test because unsupported hypervisor %s" % self.hypervisor)
return
def tearDown(self):
super(TestCreateTemplateWithDirectDownload, self).tearDown()
@attr(tags=["advanced", "smoke"], required_hardware="true")
def test_01_register_template_direct_download_flag(self):
"""
Register a template using Direct Download flag
"""
self.bypassed_template = Template.register(self.apiclient, self.template, zoneid=self.zone.id, hypervisor=self.hypervisor, randomize_name=False)
self._cleanup.append(self.bypassed_template)
self.templates.append(self.bypassed_template)
tmplt = self.dbclient.execute("select id, direct_download from vm_template where uuid='%s';" % self.bypassed_template.id)
det = tmplt[0]
self.assertEqual(det[1],
1,
"Template should be marked as Direct Download"
)
qresultset = self.dbclient.execute("select download_state, state from template_store_ref where template_id='%s' and store_id is NULL;"
% det[0])
ref = qresultset[0]
self.assertEqual(ref[0],
"BYPASSED",
"Template store ref download state should be marked as BYPASSED"
)
self.assertEqual(ref[1],
"Ready",
"Template store ref state should be marked as Ready"
)
return
@attr(tags=["advanced", "smoke"], required_hardware="true")
def test_02_deploy_vm_from_direct_download_template(self):
"""
Deploy a VM from a Direct Download registered template
"""
bp = self.templates[0]
virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
templateid=bp.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id
)
self.cleanup.append(virtual_machine)
return
@attr(tags=["advanced", "smoke"], required_hardware="true")
def test_03_deploy_vm_wrong_checksum(self):
"""
Deploy a VM from a Direct Download registered template with wrong checksum
"""
self.template["checksum"]="{MD5}" + ("X" * 32)
tmpl = Template.register(self.apiclient, self.template, zoneid=self.zone.id, hypervisor=self.hypervisor, randomize_name=False)
self.cleanup.append(tmpl)
failed = False
try:
virtual_machine = VirtualMachine.create(
self.apiclient,
self.services["virtual_machine"],
templateid=tmpl.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id
)
self.cleanup.append(virtual_machine)
failed = True
except Exception as e:
self.debug("Expected exception")
list_virtual_machine_response = VirtualMachine.list(
self.apiclient,
templateid=tmpl.id,
listall=True
)
if type(list_virtual_machine_response) == list and len(list_virtual_machine_response) > 0:
for virtual_machine_response in list_virtual_machine_response:
VirtualMachine.delete(virtual_machine_response, self.apiclient, expunge=True)
if failed == True:
self.fail("Expected to fail VM deployment with wrong checksum template")
return