You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cloudstack.apache.org by gi...@apache.org on 2014/05/19 14:31:48 UTC
[3/7] CLOUDSTACK-6282 - Divided test_escalations.py into individual
files based on functionality and added automed tests for Public IP Addresses
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/2ba63220/test/integration/component/test_escalations_snapshots.py
----------------------------------------------------------------------
diff --git a/test/integration/component/test_escalations_snapshots.py b/test/integration/component/test_escalations_snapshots.py
new file mode 100644
index 0000000..2367253
--- /dev/null
+++ b/test/integration/component/test_escalations_snapshots.py
@@ -0,0 +1,647 @@
+# 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.
+
+#Import Local Modules
+from marvin.cloudstackTestCase import cloudstackTestCase
+from marvin.cloudstackAPI import (createVolume,
+ createTemplate)
+from marvin.lib.base import (Volume,
+ Iso,
+ VirtualMachine,
+ Template,
+ Snapshot,
+ SecurityGroup,
+ Account,
+ Zone,
+ Network,
+ NetworkOffering,
+ DiskOffering,
+ ServiceOffering,
+ VmSnapshot,
+ SnapshotPolicy,
+ SSHKeyPair,
+ Resources,
+ Configurations,
+ VpnCustomerGateway,
+ Hypervisor,
+ VpcOffering,
+ VPC,
+ NetworkACL)
+from marvin.lib.common import (get_zone,
+ get_domain,
+ get_template,
+ list_os_types)
+from marvin.lib.utils import (validateList,
+ cleanup_resources,
+ random_gen)
+from marvin.codes import (PASS, FAIL, EMPTY_LIST)
+from nose.plugins.attrib import attr
+import time
+
+class TestSnapshots(cloudstackTestCase):
+
+ @classmethod
+ def setUpClass(cls):
+ try:
+ cls._cleanup = []
+ cls.testClient = super(TestSnapshots, 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"]
+ )
+ 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['mode'] = cls.zone.networktype
+ cls.services["virtual_machine"]["hypervisor"] = cls.testClient.getHypervisorInfo()
+ cls.services["virtual_machine"]["zoneid"] = cls.zone.id
+ cls.services["virtual_machine"]["template"] = cls.template.id
+ cls.services["custom_volume"]["zoneid"] = cls.zone.id
+ # Creating Disk offering, Service Offering and Account
+ cls.disk_offering = DiskOffering.create(
+ cls.api_client,
+ cls.services["disk_offering"]
+ )
+ cls._cleanup.append(cls.disk_offering)
+ cls.service_offering = ServiceOffering.create(
+ cls.api_client,
+ cls.services["service_offerings"]["tiny"]
+ )
+ cls._cleanup.append(cls.service_offering)
+ cls.account = Account.create(
+ cls.api_client,
+ cls.services["account"],
+ domainid=cls.domain.id
+ )
+ # Getting authentication for user in newly created Account
+ cls.user = cls.account.user[0]
+ cls.userapiclient = cls.testClient.getUserApiClient(cls.user.username, cls.domain.name)
+ cls._cleanup.append(cls.account)
+ # Creating Virtual Machine
+ cls.virtual_machine = VirtualMachine.create(
+ cls.userapiclient,
+ cls.services["virtual_machine"],
+ accountid=cls.account.name,
+ domainid=cls.account.domainid,
+ serviceofferingid=cls.service_offering.id,
+ )
+ cls._cleanup.append(cls.virtual_machine)
+ except Exception as e:
+ cls.tearDownClass()
+ raise Exception("Warning: Exception in setup : %s" % e)
+ return
+
+ def setUp(self):
+
+ self.apiClient = self.testClient.getApiClient()
+ self.cleanup = []
+
+ def tearDown(self):
+ #Clean up, terminate the created resources
+ cleanup_resources(self.apiClient, self.cleanup)
+ return
+
+ @classmethod
+ def tearDownClass(cls):
+ try:
+ cleanup_resources(cls.api_client, cls._cleanup)
+ except Exception as e:
+ raise Exception("Warning: Exception during cleanup : %s" % e)
+
+ return
+
+ def __verify_values(self, expected_vals, actual_vals):
+ """
+ @Desc: Function to verify expected and actual values
+ @Steps:
+ Step1: Initializing return flag to True
+ Step1: Verifying length of expected and actual dictionaries is matching.
+ If not matching returning false
+ Step2: Listing all the keys from expected dictionary
+ Step3: Looping through each key from step2 and verifying expected and actual dictionaries have same value
+ If not making return flag to False
+ Step4: returning the return flag after all the values are verified
+ """
+ return_flag = True
+
+ if len(expected_vals) != len(actual_vals):
+ return False
+
+ keys = expected_vals.keys()
+ for i in range(0, len(expected_vals)):
+ exp_val = expected_vals[keys[i]]
+ act_val = actual_vals[keys[i]]
+ if exp_val == act_val:
+ return_flag = return_flag and True
+ else:
+ return_flag = return_flag and False
+ self.debug("expected Value: %s, is not matching with actual value: %s" % (
+ exp_val,
+ act_val
+ ))
+ return return_flag
+
+ @attr(tags=["advanced", "basic", "provisioning"])
+ def test_01_list_volume_snapshots_pagination(self):
+ """
+ @Desc: Test to List Volume Snapshots pagination
+ @steps:
+ Step1: Listing all the volume snapshots for a user
+ Step2: Verifying that list size is 0
+ Step3: Creating (page size + 1) number of volume snapshots
+ Step4: Listing all the volume snapshots again for a user
+ Step5: Verifying that list size is (page size + 1)
+ Step6: Listing all the volume snapshots in page1
+ Step7: Verifying that list size is (page size)
+ Step8: Listing all the volume snapshots in page2
+ Step9: Verifying that list size is 1
+ Step10: Deleting the volume snapshot present in page 2
+ Step11: Listing all the volume snapshots in page2
+ Step12: Verifying that list size is 0
+ """
+ # Listing all the volume snapshots for a User
+ list_vol_snaps_before = Snapshot.list(
+ self.userapiclient,
+ listall=self.services["listall"]
+ )
+ # Verifying list size is 0
+ self.assertIsNone(
+ list_vol_snaps_before,
+ "Volume snapshots exists for newly created user"
+ )
+ # Listing the root volumes available for the user
+ volumes_list = Volume.list(
+ self.userapiclient,
+ listall=self.services["listall"]
+ )
+ status = validateList(volumes_list)
+ self.assertEquals(
+ PASS,
+ status[0],
+ "Root volume did not get created while deploying a VM"
+ )
+ # Verifying list size to be 1
+ self.assertEquals(
+ 1,
+ len(volumes_list),
+ "More than 1 root volume created for deployed VM"
+ )
+ root_volume = volumes_list[0]
+ # Creating pagesize + 1 number of volume snapshots
+ for i in range(0, (self.services["pagesize"] + 1)):
+ snapshot_created = Snapshot.create(
+ self.userapiclient,
+ root_volume.id,
+ )
+ self.assertIsNotNone(
+ snapshot_created,
+ "Snapshot creation failed"
+ )
+ self.cleanup.append(snapshot_created)
+
+ # Listing all the volume snapshots for user again
+ list_vol_snaps_after = Snapshot.list(
+ self.userapiclient,
+ listall=self.services["listall"]
+ )
+ status = validateList(list_vol_snaps_after)
+ self.assertEquals(
+ PASS,
+ status[0],
+ "Volume snapshot creation failed"
+ )
+ # Verifying that list size is pagesize + 1
+ self.assertEquals(
+ self.services["pagesize"] + 1,
+ len(list_vol_snaps_after),
+ "Failed to create pagesize + 1 number of Volume snapshots"
+ )
+ # Listing all the volume snapshots in page 1
+ list_vol_snaps_page1 = Snapshot.list(
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=1,
+ pagesize=self.services["pagesize"]
+ )
+ status = validateList(list_vol_snaps_page1)
+ self.assertEquals(
+ PASS,
+ status[0],
+ "Failed to list volume snapshots in page 1"
+ )
+ # Verifying the list size to be equal to pagesize
+ self.assertEquals(
+ self.services["pagesize"],
+ len(list_vol_snaps_page1),
+ "Size of volume snapshots in page 1 is not matching"
+ )
+ # Listing all the volume snapshots in page 2
+ list_vol_snaps_page2 = Snapshot.list(
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=2,
+ pagesize=self.services["pagesize"]
+ )
+ status = validateList(list_vol_snaps_page2)
+ self.assertEquals(
+ PASS,
+ status[0],
+ "Failed to list volume snapshots in page 2"
+ )
+ # Verifying the list size to be equal to pagesize
+ self.assertEquals(
+ 1,
+ len(list_vol_snaps_page2),
+ "Size of volume snapshots in page 2 is not matching"
+ )
+ # Deleting the volume snapshot present in page 2
+ Snapshot.delete(
+ snapshot_created,
+ self.userapiclient
+ )
+ # Listing all the snapshots in page 2 again
+ list_vol_snaps_page2 = Snapshot.list(
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=2,
+ pagesize=self.services["pagesize"]
+ )
+ # Verifying that list size is 0
+ self.assertIsNone(
+ list_vol_snaps_page2,
+ "Volume snapshot not deleted from page 2"
+ )
+ return
+
+ @attr(tags=["advanced", "basic", "provisioning"])
+ def test_02_list_volume_snapshots_byid(self):
+ """
+ @Desc: Test to List Volume Snapshots by Id
+ @Steps:
+ Step1: Listing all the volume snapshots for a user
+ Step2: Verifying that list size is 0
+ Step3: Creating a volume snapshot
+ Step4: Listing all the volume snapshots again for a user
+ Step5: Verifying that list size is 1
+ Step6: Listing all the volume snapshots by specifying snapshot id
+ Step7: Verifying that list size is 1
+ Step8: Verifying details of the listed volume snapshot
+ """
+ # Listing all the volume snapshots for a User
+ list_vol_snaps_before = Snapshot.list(
+ self.userapiclient,
+ listall=self.services["listall"]
+ )
+ # Verifying list size is 0
+ self.assertIsNone(
+ list_vol_snaps_before,
+ "Volume snapshots exists for newly created user"
+ )
+ # Listing the root volumes available for the user
+ volumes_list = Volume.list(
+ self.userapiclient,
+ listall=self.services["listall"]
+ )
+ status = validateList(volumes_list)
+ self.assertEquals(
+ PASS,
+ status[0],
+ "Root volume did not get created while deploying a VM"
+ )
+ # Verifying list size to be 1
+ self.assertEquals(
+ 1,
+ len(volumes_list),
+ "More than 1 root volume created for deployed VM"
+ )
+ root_volume = volumes_list[0]
+ # Creating a volume snapshot
+ snapshot_created = Snapshot.create(
+ self.userapiclient,
+ root_volume.id,
+ )
+ self.assertIsNotNone(
+ snapshot_created,
+ "Snapshot creation failed"
+ )
+ self.cleanup.append(snapshot_created)
+ # Listing all the volume snapshots for user again
+ list_vol_snaps_after = Snapshot.list(
+ self.userapiclient,
+ listall=self.services["listall"]
+ )
+ status = validateList(list_vol_snaps_after)
+ self.assertEquals(
+ PASS,
+ status[0],
+ "Volume snapshot creation failed"
+ )
+ # Verifying that list size is 1
+ self.assertEquals(
+ 1,
+ len(list_vol_snaps_after),
+ "Failed to create Volume snapshot"
+ )
+ # Listing volume snapshot by id
+ list_vol_snapshot = Snapshot.list(
+ self.userapiclient,
+ listall=self.services["listall"],
+ id=snapshot_created.id
+ )
+ status = validateList(list_vol_snapshot)
+ self.assertEquals(
+ PASS,
+ status[0],
+ "Failed to list Volume snapshot by Id"
+ )
+ # Verifying that list size is 1
+ self.assertEquals(
+ 1,
+ len(list_vol_snapshot),
+ "Size of the list volume snapshot by Id is not matching"
+ )
+ # Verifying details of the listed snapshot to be same as snapshot created above
+ #Creating expected and actual values dictionaries
+ expected_dict = {
+ "id":snapshot_created.id,
+ "name":snapshot_created.name,
+ "state":snapshot_created.state,
+ "intervaltype":snapshot_created.intervaltype,
+ "account":snapshot_created.account,
+ "domain":snapshot_created.domainid,
+ "volume":snapshot_created.volumeid
+ }
+ actual_dict = {
+ "id":list_vol_snapshot[0].id,
+ "name":list_vol_snapshot[0].name,
+ "state":list_vol_snapshot[0].state,
+ "intervaltype":list_vol_snapshot[0].intervaltype,
+ "account":list_vol_snapshot[0].account,
+ "domain":list_vol_snapshot[0].domainid,
+ "volume":list_vol_snapshot[0].volumeid
+ }
+ vol_snapshot_status = self.__verify_values(
+ expected_dict,
+ actual_dict
+ )
+ self.assertEqual(
+ True,
+ vol_snapshot_status,
+ "Listed Volume Snapshot details are not as expected"
+ )
+ return
+
+ @attr(tags=["advanced", "basic", "provisioning"])
+ def test_03_list_vm_snapshots_pagination(self):
+ """
+ @Desc: Test to List VM Snapshots pagination
+ @Steps:
+ Step1: Listing all the VM snapshots for a user
+ Step2: Verifying that list size is 0
+ Step3: Creating (page size + 1) number of VM snapshots
+ Step4: Listing all the VM snapshots again for a user
+ Step5: Verifying that list size is (page size + 1)
+ Step6: Listing all the VM snapshots in page1
+ Step7: Verifying that list size is (page size)
+ Step8: Listing all the VM snapshots in page2
+ Step9: Verifying that list size is 1
+ Step10: Deleting the VM snapshot present in page 2
+ Step11: Listing all the volume snapshots in page2
+ Step12: Verifying that list size is 0
+ """
+ # Listing all the VM snapshots for a User
+ list_vm_snaps_before = VmSnapshot.list(
+ self.userapiclient,
+ listall=self.services["listall"]
+ )
+ # Verifying list size is 0
+ self.assertIsNone(
+ list_vm_snaps_before,
+ "VM snapshots exists for newly created user"
+ )
+ # Creating pagesize + 1 number of VM snapshots
+ for i in range(0, (self.services["pagesize"] + 1)):
+ snapshot_created = VmSnapshot.create(
+ self.userapiclient,
+ self.virtual_machine.id,
+ )
+ self.assertIsNotNone(
+ snapshot_created,
+ "Snapshot creation failed"
+ )
+
+ # Listing all the VM snapshots for user again
+ list_vm_snaps_after = VmSnapshot.list(
+ self.userapiclient,
+ listall=self.services["listall"]
+ )
+ status = validateList(list_vm_snaps_after)
+ self.assertEquals(
+ PASS,
+ status[0],
+ "VM snapshot creation failed"
+ )
+ # Verifying that list size is pagesize + 1
+ self.assertEquals(
+ self.services["pagesize"] + 1,
+ len(list_vm_snaps_after),
+ "Failed to create pagesize + 1 number of VM snapshots"
+ )
+ # Listing all the VM snapshots in page 1
+ list_vm_snaps_page1 = VmSnapshot.list(
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=1,
+ pagesize=self.services["pagesize"]
+ )
+ status = validateList(list_vm_snaps_page1)
+ self.assertEquals(
+ PASS,
+ status[0],
+ "Failed to list vm snapshots in page 1"
+ )
+ # Verifying the list size to be equal to pagesize
+ self.assertEquals(
+ self.services["pagesize"],
+ len(list_vm_snaps_page1),
+ "Size of vm snapshots in page 1 is not matching"
+ )
+ # Listing all the vm snapshots in page 2
+ list_vm_snaps_page2 = VmSnapshot.list(
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=2,
+ pagesize=self.services["pagesize"]
+ )
+ status = validateList(list_vm_snaps_page2)
+ self.assertEquals(
+ PASS,
+ status[0],
+ "Failed to list vm snapshots in page 2"
+ )
+ # Verifying the list size to be equal to pagesize
+ self.assertEquals(
+ 1,
+ len(list_vm_snaps_page2),
+ "Size of vm snapshots in page 2 is not matching"
+ )
+ # Deleting the vm snapshot present in page 2
+ VmSnapshot.deleteVMSnapshot(
+ self.userapiclient,
+ snapshot_created.id
+ )
+ # Listing all the snapshots in page 2 again
+ list_vm_snaps_page2 = VmSnapshot.list(
+ self.userapiclient,
+ listall=self.services["listall"],
+ page=2,
+ pagesize=self.services["pagesize"]
+ )
+ # Verifying that list size is 0
+ self.assertIsNone(
+ list_vm_snaps_page2,
+ "VM snapshot not deleted from page 2"
+ )
+ # Deleting all the existing VM snapshots
+ list_vm_snaps = VmSnapshot.list(
+ self.userapiclient,
+ listall=self.services["listall"],
+ )
+ status = validateList(list_vm_snaps)
+ self.assertEquals(
+ PASS,
+ status[0],
+ "All VM snapshots deleted"
+ )
+ # Verifying that list size is equal to page size
+ self.assertEquals(
+ self.services["pagesize"],
+ len(list_vm_snaps),
+ "VM Snapshots count is not matching"
+ )
+ # Deleting all the existing VM snapshots
+ for i in range(0, len(list_vm_snaps)):
+ VmSnapshot.deleteVMSnapshot(
+ self.userapiclient,
+ list_vm_snaps[i].id
+ )
+ return
+
+ @attr(tags=["advanced", "basic", "provisioning"])
+ def test_04_list_vm_snapshots_byid(self):
+ """
+ @summary: Test to List VM Snapshots by Id
+
+ Step1: Listing all the VM snapshots for a user
+ Step2: Verifying that list size is 0
+ Step3: Creating a VM snapshot
+ Step4: Listing all the VM snapshots again for a user
+ Step5: Verifying that list size is 1
+ Step6: Listing all the VM snapshots by specifying snapshot id
+ Step7: Verifying that list size is 1
+ Step8: Verifying details of the listed VM snapshot
+ """
+ # Listing all the VM snapshots for a User
+ list_vm_snaps_before = VmSnapshot.list(
+ self.userapiclient,
+ listall=self.services["listall"]
+ )
+ # Verifying list size is 0
+ self.assertIsNone(
+ list_vm_snaps_before,
+ "VM snapshots exists for newly created user"
+ )
+ # Creating a VM snapshot
+ snapshot_created = VmSnapshot.create(
+ self.userapiclient,
+ self.virtual_machine.id,
+ )
+ self.assertIsNotNone(
+ snapshot_created,
+ "Snapshot creation failed"
+ )
+ # Listing all the VM snapshots for user again
+ list_vm_snaps_after = VmSnapshot.list(
+ self.userapiclient,
+ listall=self.services["listall"]
+ )
+ status = validateList(list_vm_snaps_after)
+ self.assertEquals(
+ PASS,
+ status[0],
+ "VM snapshot creation failed"
+ )
+ # Verifying that list size is 1
+ self.assertEquals(
+ 1,
+ len(list_vm_snaps_after),
+ "Failed to create VM snapshot"
+ )
+ # Listing vm snapshot by id
+ list_vm_snapshot = VmSnapshot.list(
+ self.userapiclient,
+ listall=self.services["listall"],
+ vmsnapshotid=snapshot_created.id
+ )
+ status = validateList(list_vm_snapshot)
+ self.assertEquals(
+ PASS,
+ status[0],
+ "Failed to list VM snapshot by Id"
+ )
+ # Verifying that list size is 1
+ self.assertEquals(
+ 1,
+ len(list_vm_snapshot),
+ "Size of the list vm snapshot by Id is not matching"
+ )
+ # Verifying details of the listed snapshot to be same as snapshot created above
+ #Creating expected and actual values dictionaries
+ expected_dict = {
+ "id":snapshot_created.id,
+ "name":snapshot_created.name,
+ "state":snapshot_created.state,
+ "vmid":snapshot_created.virtualmachineid,
+ }
+ actual_dict = {
+ "id":list_vm_snapshot[0].id,
+ "name":list_vm_snapshot[0].name,
+ "state":list_vm_snapshot[0].state,
+ "vmid":list_vm_snapshot[0].virtualmachineid,
+ }
+ vm_snapshot_status = self.__verify_values(
+ expected_dict,
+ actual_dict
+ )
+ self.assertEqual(
+ True,
+ vm_snapshot_status,
+ "Listed VM Snapshot details are not as expected"
+ )
+ return
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cloudstack/blob/2ba63220/test/integration/component/test_escalations_templates.py
----------------------------------------------------------------------
diff --git a/test/integration/component/test_escalations_templates.py b/test/integration/component/test_escalations_templates.py
new file mode 100644
index 0000000..083ba90
--- /dev/null
+++ b/test/integration/component/test_escalations_templates.py
@@ -0,0 +1,944 @@
+# 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.
+
+#Import Local Modules
+from marvin.cloudstackTestCase import cloudstackTestCase
+from marvin.cloudstackAPI import (createVolume,
+ createTemplate)
+from marvin.lib.base import (Volume,
+ Iso,
+ VirtualMachine,
+ Template,
+ Snapshot,
+ SecurityGroup,
+ Account,
+ Zone,
+ Network,
+ NetworkOffering,
+ DiskOffering,
+ ServiceOffering,
+ VmSnapshot,
+ SnapshotPolicy,
+ SSHKeyPair,
+ Resources,
+ Configurations,
+ VpnCustomerGateway,
+ Hypervisor,
+ VpcOffering,
+ VPC,
+ NetworkACL)
+from marvin.lib.common import (get_zone,
+ get_domain,
+ get_template,
+ list_os_types)
+from marvin.lib.utils import (validateList,
+ cleanup_resources,
+ random_gen)
+from marvin.codes import (PASS, FAIL, EMPTY_LIST)
+from nose.plugins.attrib import attr
+import time
+
+class TestTemplates(cloudstackTestCase):
+
+ @classmethod
+ 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.account = Account.create(
+ cls.api_client,
+ cls.services["account"],
+ domainid=cls.domain.id
+ )
+ # Getting authentication for user in newly created Account
+ cls.user = cls.account.user[0]
+ cls.userapiclient = cls.testClient.getUserApiClient(cls.user.username, cls.domain.name)
+ cls._cleanup.append(cls.account)
+ except Exception as e:
+ cls.tearDownClass()
+ raise Exception("Warning: Exception in setup : %s" % e)
+ return
+
+ def setUp(self):
+
+ self.apiClient = self.testClient.getApiClient()
+ self.cleanup = []
+
+ def tearDown(self):
+ #Clean up, terminate the created resources
+ cleanup_resources(self.apiClient, self.cleanup)
+ return
+
+ @classmethod
+ def tearDownClass(cls):
+ try:
+ cleanup_resources(cls.api_client, cls._cleanup)
+ except Exception as e:
+ raise Exception("Warning: Exception during cleanup : %s" % e)
+
+ return
+
+ def __verify_values(self, expected_vals, actual_vals):
+ """
+ @Desc: Function to verify expected and actual values
+ @Steps:
+ Step1: Initializing return flag to True
+ Step1: Verifying length of expected and actual dictionaries is matching.
+ If not matching returning false
+ Step2: Listing all the keys from expected dictionary
+ Step3: Looping through each key from step2 and verifying expected and actual dictionaries have same value
+ If not making return flag to False
+ Step4: returning the return flag after all the values are verified
+ """
+ return_flag = True
+
+ if len(expected_vals) != len(actual_vals):
+ return False
+
+ keys = expected_vals.keys()
+ for i in range(0, len(expected_vals)):
+ exp_val = expected_vals[keys[i]]
+ act_val = actual_vals[keys[i]]
+ if exp_val == act_val:
+ return_flag = return_flag and True
+ else:
+ return_flag = return_flag and False
+ self.debug("expected Value: %s, is not matching with actual value: %s" % (
+ exp_val,
+ act_val
+ ))
+ return return_flag
+
+ @attr(tags=["advanced", "basic", "provisioning"])
+ def test_01_list_templates_pagination(self):
+ """
+ @Desc: Test to List Templates pagination
+ @steps:
+ Step1: Listing all the Templates for a user
+ Step2: Verifying that no Templates are listed
+ Step3: Creating (page size + 1) number of Templates
+ Step4: Listing all the Templates again for a user
+ Step5: Verifying that list size is (page size + 1)
+ Step6: Listing all the Templates in page1
+ Step7: Verifying that list size is (page size)
+ Step8: Listing all the Templates in page2
+ Step9: Verifying that list size is 1
+ Step10: Listing the template by Id
+ Step11: Verifying if the template is downloaded and ready.
+ If yes the continuing
+ If not waiting and checking for template to be ready till timeout
+ Step12: Deleting the Template present in page 2
+ Step13: Listing all the Templates in page2
+ Step14: Verifying that no Templates are listed
+ """
+ # Listing all the Templates for a User
+ list_templates_before = Template.list(
+ self.userapiclient,
+ listall=self.services["listall"],
+ templatefilter=self.services["templatefilter"]
+ )
+ # Verifying that no Templates are listed
+ self.assertIsNone(
+ list_templates_before,
+ "Templates listed for newly created User"
+ )
+ self.services["template"]["url"] = "http://10.147.28.7/templates/ttylinux_pv.vhd"
+ self.services["template"]["format"] = "VHD"
+ self.services["template"]["ostype"] = self.services["ostype"]
+ # Creating pagesize + 1 number of Templates
+ for i in range(0, (self.services["pagesize"] + 1)):
+ template_created = Template.register(
+ self.userapiclient,
+ self.services["template"],
+ self.zone.id,
+ hypervisor=self.hypervisor
+ )
+ self.assertIsNotNone(
+ template_created,
+ "Template creation failed"
+ )
+ if(i < self.services["pagesize"]):
+ self.cleanup.append(template_created)
+
+ # Listing all the Templates for a User
+ list_templates_after = Template.list(
+ self.userapiclient,
+ listall=self.services["listall"],
+ templatefilter=self.services["templatefilter"]
+ )
+ status = validateList(list_templates_after)
+ self.assertEquals(
+ PASS,
+ status[0],
+ "Templates creation failed"
+ )
+ # Verifying that list size is pagesize + 1
+ self.assertEquals(
+ self.services["pagesize"] + 1,
+ len(list_templates_after),
+ "Failed to create pagesize + 1 number of Templates"
+ )
+ # Listing all the Templates in page 1
+ list_templates_page1 = Template.list(
+ self.userapiclient,
+ listall=self.services["listall"],
+ templatefilter=self.services["templatefilter"],
+ page=1,
+ pagesize=self.services["pagesize"]
+ )
+ status = validateList(list_templates_page1)
+ self.assertEquals(
+ PASS,
+ status[0],
+ "Failed to list Templates in page 1"
+ )
+ # Verifying the list size to be equal to pagesize
+ self.assertEquals(
+ self.services["pagesize"],
+ len(list_templates_page1),
+ "Size of Templates in page 1 is not matching"
+ )
+ # Listing all the Templates in page 2
+ list_templates_page2 = Template.list(
+ self.userapiclient,
+ listall=self.services["listall"],
+ templatefilter=self.services["templatefilter"],
+ page=2,
+ pagesize=self.services["pagesize"]
+ )
+ status = validateList(list_templates_page2)
+ self.assertEquals(
+ PASS,
+ status[0],
+ "Failed to list Templates in page 2"
+ )
+ # Verifying the list size to be equal to 1
+ self.assertEquals(
+ 1,
+ len(list_templates_page2),
+ "Size of Templates in page 2 is not matching"
+ )
+ # Verifying the state of the template to be ready. If not waiting for state to become ready
+ template_ready = False
+ count = 0
+ while template_ready is False:
+ list_template = Template.list(
+ self.userapiclient,
+ id=template_created.id,
+ listall=self.services["listall"],
+ templatefilter=self.services["templatefilter"],
+ )
+ status = validateList(list_template)
+ self.assertEquals(
+ PASS,
+ status[0],
+ "Failed to list Templates by Id"
+ )
+ if list_template[0].isready is True:
+ template_ready = True
+ elif (str(list_template[0].status) == "Error"):
+ self.fail("Created Template is in Errored state")
+ break
+ elif count > 10:
+ self.fail("Timed out before Template came into ready state")
+ break
+ else:
+ time.sleep(self.services["sleep"])
+ count = count + 1
+
+ # Deleting the Template present in page 2
+ Template.delete(
+ template_created,
+ self.userapiclient
+ )
+ # Listing all the Templates in page 2 again
+ list_templates_page2 = Template.list(
+ self.userapiclient,
+ listall=self.services["listall"],
+ templatefilter=self.services["templatefilter"],
+ page=2,
+ pagesize=self.services["pagesize"]
+ )
+ # Verifying that there are no Templates listed
+ self.assertIsNone(
+ list_templates_page2,
+ "Templates not deleted from page 2"
+ )
+ del self.services["template"]["url"]
+ del self.services["template"]["format"]
+ del self.services["template"]["ostype"]
+ return
+
+ @attr(tags=["advanced", "basic", "provisioning"])
+ def test_02_download_template(self):
+ """
+ @Desc: Test to Download Template
+ @steps:
+ Step1: Listing all the Templates for a user
+ Step2: Verifying that no Templates are listed
+ Step3: Creating a Templates
+ Step4: Listing all the Templates again for a user
+ Step5: Verifying that list size is 1
+ Step6: Verifying if the template is in ready state.
+ If yes the continuing
+ If not waiting and checking for template to be ready till timeout
+ Step7: Downloading the template (Extract)
+ Step8: Verifying that Template is downloaded
+ """
+ # Listing all the Templates for a User
+ list_templates_before = Template.list(
+ self.userapiclient,
+ listall=self.services["listall"],
+ templatefilter=self.services["templatefilter"]
+ )
+ # Verifying that no Templates are listed
+ self.assertIsNone(
+ list_templates_before,
+ "Templates listed for newly created User"
+ )
+ self.services["template"]["url"] = "http://10.147.28.7/templates/ttylinux_pv.vhd"
+ self.services["template"]["format"] = "VHD"
+ self.services["template"]["ostype"] = self.services["ostype"]
+ self.services["template"]["isextractable"] = True
+ # Creating aTemplate
+ template_created = Template.register(
+ self.userapiclient,
+ self.services["template"],
+ self.zone.id,
+ hypervisor=self.hypervisor
+ )
+ self.assertIsNotNone(
+ template_created,
+ "Template creation failed"
+ )
+ self.cleanup.append(template_created)
+ # Listing all the Templates for a User
+ list_templates_after = Template.list(
+ self.userapiclient,
+ listall=self.services["listall"],
+ templatefilter=self.services["templatefilter"]
+ )
+ status = validateList(list_templates_after)
+ self.assertEquals(
+ PASS,
+ status[0],
+ "Templates creation failed"
+ )
+ # Verifying that list size is 1
+ self.assertEquals(
+ 1,
+ len(list_templates_after),
+ "Failed to create a Template"
+ )
+ # Verifying the state of the template to be ready. If not waiting for state to become ready till time out
+ template_ready = False
+ count = 0
+ while template_ready is False:
+ list_template = Template.list(
+ self.userapiclient,
+ id=template_created.id,
+ listall=self.services["listall"],
+ templatefilter=self.services["templatefilter"],
+ )
+ status = validateList(list_template)
+ self.assertEquals(
+ PASS,
+ status[0],
+ "Failed to list Templates by Id"
+ )
+ if list_template[0].isready is True:
+ template_ready = True
+ elif (str(list_template[0].status) == "Error"):
+ self.fail("Created Template is in Errored state")
+ break
+ elif count > 10:
+ self.fail("Timed out before Template came into ready state")
+ break
+ else:
+ time.sleep(self.services["sleep"])
+ count = count + 1
+
+ # Downloading the Template name
+ download_template = Template.extract(
+ self.userapiclient,
+ template_created.id,
+ mode="HTTP_DOWNLOAD",
+ zoneid=self.zone.id
+ )
+ self.assertIsNotNone(
+ download_template,
+ "Download Template failed"
+ )
+ # Verifying the details of downloaded template
+ self.assertEquals(
+ "DOWNLOAD_URL_CREATED",
+ download_template.state,
+ "Download URL not created for Template"
+ )
+ self.assertIsNotNone(
+ download_template.url,
+ "Download URL not created for Template"
+ )
+ self.assertEquals(
+ template_created.id,
+ download_template.id,
+ "Download Template details are not same as Template created"
+ )
+ del self.services["template"]["url"]
+ del self.services["template"]["format"]
+ del self.services["template"]["ostype"]
+ del self.services["template"]["isextractable"]
+ return
+
+ @attr(tags=["advanced", "basic", "provisioning"])
+ def test_03_edit_template_details(self):
+ """
+ @Desc: Test to Edit Template name, displaytext, OSType
+ @steps:
+ Step1: Listing all the Templates for a user
+ Step2: Verifying that no Templates are listed
+ Step3: Creating a Templates
+ Step4: Listing all the Templates again for a user
+ Step5: Verifying that list size is 1
+ Step6: Verifying if the template is in ready state.
+ If yes the continuing
+ If not waiting and checking for template to be ready till timeout
+ Step7: Editing the template name
+ Step8: Verifying that Template name is edited
+ Step9: Editing the template displaytext
+ Step10: Verifying that Template displaytext is edited
+ Step11: Editing the template ostypeid
+ Step12: Verifying that Template ostypeid is edited
+ Step13: Editing the template name, displaytext
+ Step14: Verifying that Template name, displaytext are edited
+ Step15: Editing the template name, displaytext, ostypeid
+ Step16: Verifying that Template name, displaytext and ostypeid are edited
+ """
+ # Listing all the Templates for a User
+ list_templates_before = Template.list(
+ self.userapiclient,
+ listall=self.services["listall"],
+ templatefilter=self.services["templatefilter"]
+ )
+ # Verifying that no Templates are listed
+ self.assertIsNone(
+ list_templates_before,
+ "Templates listed for newly created User"
+ )
+ self.services["template"]["url"] = "http://10.147.28.7/templates/ttylinux_pv.vhd"
+ self.services["template"]["format"] = "VHD"
+ self.services["template"]["ostype"] = self.services["ostype"]
+ # Creating aTemplate
+ template_created = Template.register(
+ self.userapiclient,
+ self.services["template"],
+ self.zone.id,
+ hypervisor=self.hypervisor
+ )
+ self.assertIsNotNone(
+ template_created,
+ "Template creation failed"
+ )
+ self.cleanup.append(template_created)
+ # Listing all the Templates for a User
+ list_templates_after = Template.list(
+ self.userapiclient,
+ listall=self.services["listall"],
+ templatefilter=self.services["templatefilter"]
+ )
+ status = validateList(list_templates_after)
+ self.assertEquals(
+ PASS,
+ status[0],
+ "Templates creation failed"
+ )
+ # Verifying that list size is 1
+ self.assertEquals(
+ 1,
+ len(list_templates_after),
+ "Failed to create a Template"
+ )
+ # Verifying the state of the template to be ready. If not waiting for state to become ready till time out
+ template_ready = False
+ count = 0
+ while template_ready is False:
+ list_template = Template.list(
+ self.userapiclient,
+ id=template_created.id,
+ listall=self.services["listall"],
+ templatefilter=self.services["templatefilter"],
+ )
+ status = validateList(list_template)
+ self.assertEquals(
+ PASS,
+ status[0],
+ "Failed to list Templates by Id"
+ )
+ if list_template[0].isready is True:
+ template_ready = True
+ elif (str(list_template[0].status) == "Error"):
+ self.fail("Created Template is in Errored state")
+ break
+ elif count > 10:
+ self.fail("Timed out before Template came into ready state")
+ break
+ else:
+ time.sleep(self.services["sleep"])
+ count = count + 1
+
+ # Editing the Template name
+ edited_template = Template.update(
+ template_created,
+ self.userapiclient,
+ name="NewTemplateName"
+ )
+ self.assertIsNotNone(
+ edited_template,
+ "Editing Template failed"
+ )
+ # Verifying the details of edited template
+ expected_dict = {
+ "id":template_created.id,
+ "name":"NewTemplateName",
+ "displaytest":template_created.displaytext,
+ "account":template_created.account,
+ "domainid":template_created.domainid,
+ "format":template_created.format,
+ "ostypeid":template_created.ostypeid,
+ "templatetype":template_created.templatetype,
+ }
+ actual_dict = {
+ "id":edited_template.id,
+ "name":edited_template.name,
+ "displaytest":edited_template.displaytext,
+ "account":edited_template.account,
+ "domainid":edited_template.domainid,
+ "format":edited_template.format,
+ "ostypeid":edited_template.ostypeid,
+ "templatetype":edited_template.templatetype,
+ }
+ edit_template_status = self.__verify_values(
+ expected_dict,
+ actual_dict
+ )
+ self.assertEqual(
+ True,
+ edit_template_status,
+ "Edited Template details are not as expected"
+ )
+ # Editing the Template displaytext
+ edited_template = Template.update(
+ template_created,
+ self.userapiclient,
+ displaytext="TemplateDisplaytext"
+ )
+ self.assertIsNotNone(
+ edited_template,
+ "Editing Template failed"
+ )
+ # Verifying the details of edited template
+ expected_dict = {
+ "id":template_created.id,
+ "name":"NewTemplateName",
+ "displaytest":"TemplateDisplaytext",
+ "account":template_created.account,
+ "domainid":template_created.domainid,
+ "format":template_created.format,
+ "ostypeid":template_created.ostypeid,
+ "templatetype":template_created.templatetype,
+ }
+ actual_dict = {
+ "id":edited_template.id,
+ "name":edited_template.name,
+ "displaytest":edited_template.displaytext,
+ "account":edited_template.account,
+ "domainid":edited_template.domainid,
+ "format":edited_template.format,
+ "ostypeid":edited_template.ostypeid,
+ "templatetype":edited_template.templatetype,
+ }
+ edit_template_status = self.__verify_values(
+ expected_dict,
+ actual_dict
+ )
+ self.assertEqual(
+ True,
+ edit_template_status,
+ "Edited Template details are not as expected"
+ )
+ # Editing the Template ostypeid
+ ostype_list = list_os_types(self.userapiclient)
+ status = validateList(ostype_list)
+ self.assertEquals(
+ PASS,
+ status[0],
+ "Failed to list OS Types"
+ )
+ for i in range(0, len(ostype_list)):
+ if ostype_list[i].id != template_created.ostypeid:
+ newostypeid = ostype_list[i].id
+ break
+
+ edited_template = Template.update(
+ template_created,
+ self.userapiclient,
+ ostypeid=newostypeid
+ )
+ self.assertIsNotNone(
+ edited_template,
+ "Editing Template failed"
+ )
+ # Verifying the details of edited template
+ expected_dict = {
+ "id":template_created.id,
+ "name":"NewTemplateName",
+ "displaytest":"TemplateDisplaytext",
+ "account":template_created.account,
+ "domainid":template_created.domainid,
+ "format":template_created.format,
+ "ostypeid":newostypeid,
+ "templatetype":template_created.templatetype,
+ }
+ actual_dict = {
+ "id":edited_template.id,
+ "name":edited_template.name,
+ "displaytest":edited_template.displaytext,
+ "account":edited_template.account,
+ "domainid":edited_template.domainid,
+ "format":edited_template.format,
+ "ostypeid":edited_template.ostypeid,
+ "templatetype":edited_template.templatetype,
+ }
+ edit_template_status = self.__verify_values(
+ expected_dict,
+ actual_dict
+ )
+ self.assertEqual(
+ True,
+ edit_template_status,
+ "Edited Template details are not as expected"
+ )
+ # Editing the Template name, displaytext
+ edited_template = Template.update(
+ template_created,
+ self.userapiclient,
+ name=template_created.name,
+ displaytext=template_created.displaytext
+ )
+ self.assertIsNotNone(
+ edited_template,
+ "Editing Template failed"
+ )
+ # Verifying the details of edited template
+ expected_dict = {
+ "id":template_created.id,
+ "name":template_created.name,
+ "displaytest":template_created.displaytext,
+ "account":template_created.account,
+ "domainid":template_created.domainid,
+ "format":template_created.format,
+ "ostypeid":newostypeid,
+ "templatetype":template_created.templatetype,
+ }
+ actual_dict = {
+ "id":edited_template.id,
+ "name":edited_template.name,
+ "displaytest":edited_template.displaytext,
+ "account":edited_template.account,
+ "domainid":edited_template.domainid,
+ "format":edited_template.format,
+ "ostypeid":edited_template.ostypeid,
+ "templatetype":edited_template.templatetype,
+ }
+ edit_template_status = self.__verify_values(
+ expected_dict,
+ actual_dict
+ )
+ self.assertEqual(
+ True,
+ edit_template_status,
+ "Edited Template details are not as expected"
+ )
+ # Editing the Template name, displaytext, ostypeid
+ edited_template = Template.update(
+ template_created,
+ self.userapiclient,
+ name="NewTemplateName",
+ displaytext="TemplateDisplaytext",
+ ostypeid=template_created.ostypeid
+ )
+ self.assertIsNotNone(
+ edited_template,
+ "Editing Template failed"
+ )
+ # Verifying the details of edited template
+ expected_dict = {
+ "id":template_created.id,
+ "name":"NewTemplateName",
+ "displaytest":"TemplateDisplaytext",
+ "account":template_created.account,
+ "domainid":template_created.domainid,
+ "format":template_created.format,
+ "ostypeid":template_created.ostypeid,
+ "templatetype":template_created.templatetype,
+ }
+ actual_dict = {
+ "id":edited_template.id,
+ "name":edited_template.name,
+ "displaytest":edited_template.displaytext,
+ "account":edited_template.account,
+ "domainid":edited_template.domainid,
+ "format":edited_template.format,
+ "ostypeid":edited_template.ostypeid,
+ "templatetype":edited_template.templatetype,
+ }
+ edit_template_status = self.__verify_values(
+ expected_dict,
+ actual_dict
+ )
+ self.assertEqual(
+ True,
+ edit_template_status,
+ "Edited Template details are not as expected"
+ )
+ del self.services["template"]["url"]
+ del self.services["template"]["format"]
+ del self.services["template"]["ostype"]
+ return
+
+ @attr(tags=["advanced", "basic", "provisioning"])
+ def test_04_copy_template(self):
+ """
+ @Desc: Test to copy Template from one zone to another
+ @steps:
+ Step1: Listing Zones available for a user
+ Step2: Verifying if the zones listed are greater than 1.
+ If Yes continuing.
+ If not halting the test.
+ Step3: Listing all the templates for a user in zone1
+ Step4: Verifying that no templates are listed
+ Step5: Listing all the templates for a user in zone2
+ Step6: Verifying that no templates are listed
+ Step7: Creating a Template in zone 1
+ Step8: Listing all the Templates again for a user in zone1
+ Step9: Verifying that list size is 1
+ Step10: Listing all the templates for a user in zone2
+ Step11: Verifying that no templates are listed
+ Step12: Copying the template created in step7 from zone1 to zone2
+ Step13: Listing all the templates for a user in zone2
+ Step14: Verifying that list size is 1
+ Step15: Listing all the Templates for a user in zone1
+ Step16: Verifying that list size is 1
+ """
+ # Listing Zones available for a user
+ zones_list = Zone.list(
+ self.userapiclient,
+ available=True
+ )
+ status = validateList(zones_list)
+ self.assertEquals(
+ PASS,
+ status[0],
+ "Failed to list Zones"
+ )
+ if not len(zones_list) > 1:
+ self.fail("Enough zones doesnot exists to copy template")
+ else:
+ # Listing all the Templates for a User in Zone 1
+ list_templates_zone1 = Template.list(
+ self.userapiclient,
+ listall=self.services["listall"],
+ templatefilter=self.services["templatefilter"],
+ zoneid=zones_list[0].id
+ )
+ # Verifying that no Templates are listed
+ self.assertIsNone(
+ list_templates_zone1,
+ "Templates listed for newly created User in Zone1"
+ )
+ # Listing all the Templates for a User in Zone 2
+ list_templates_zone2 = Template.list(
+ self.userapiclient,
+ listall=self.services["listall"],
+ templatefilter=self.services["templatefilter"],
+ zoneid=zones_list[1].id
+ )
+ # Verifying that no Templates are listed
+ self.assertIsNone(
+ list_templates_zone2,
+ "Templates listed for newly created User in Zone2"
+ )
+ self.services["template"]["url"] = "http://10.147.28.7/templates/ttylinux_pv.vhd"
+ self.services["template"]["format"] = "VHD"
+ self.services["template"]["ostype"] = self.services["ostype"]
+ #Listing Hypervisors in Zone 1
+ hypervisor_list = Hypervisor.list(
+ self.apiClient,
+ zoneid=zones_list[0].id
+ )
+ status = validateList(zones_list)
+ self.assertEquals(
+ PASS,
+ status[0],
+ "Failed to list Hypervisors in Zone 1"
+ )
+ # Creating aTemplate in Zone 1
+ template_created = Template.register(
+ self.userapiclient,
+ self.services["template"],
+ zones_list[0].id,
+ hypervisor=hypervisor_list[0].name
+ )
+ self.assertIsNotNone(
+ template_created,
+ "Template creation failed"
+ )
+ self.cleanup.append(template_created)
+ # Listing all the Templates for a User in Zone 1
+ list_templates_zone1 = Template.list(
+ self.userapiclient,
+ listall=self.services["listall"],
+ templatefilter=self.services["templatefilter"],
+ zoneid=zones_list[0].id
+ )
+ status = validateList(list_templates_zone1)
+ self.assertEquals(
+ PASS,
+ status[0],
+ "Templates creation failed in Zone1"
+ )
+ # Verifying that list size is 1
+ self.assertEquals(
+ 1,
+ len(list_templates_zone1),
+ "Failed to create a Template"
+ )
+ # Listing all the Templates for a User in Zone 2
+ list_templates_zone2 = Template.list(
+ self.userapiclient,
+ listall=self.services["listall"],
+ templatefilter=self.services["templatefilter"],
+ zoneid=zones_list[1].id
+ )
+ # Verifying that no Templates are listed
+ self.assertIsNone(
+ list_templates_zone2,
+ "Templates listed for newly created User in Zone2"
+ )
+ # Verifying the state of the template to be ready. If not waiting for state to become ready till time out
+ template_ready = False
+ count = 0
+ while template_ready is False:
+ list_template = Template.list(
+ self.userapiclient,
+ id=template_created.id,
+ listall=self.services["listall"],
+ templatefilter=self.services["templatefilter"],
+ )
+ status = validateList(list_template)
+ self.assertEquals(
+ PASS,
+ status[0],
+ "Failed to list Templates by Id"
+ )
+ if list_template[0].isready is True:
+ template_ready = True
+ elif (str(list_template[0].status) == "Error"):
+ self.fail("Created Template is in Errored state")
+ break
+ elif count > 10:
+ self.fail("Timed out before Template came into ready state")
+ break
+ else:
+ time.sleep(self.services["sleep"])
+ count = count + 1
+
+ # Copying the Template from Zone1 to Zone2
+ copied_template = Template.copy(
+ self.userapiclient,
+ template_created.id,
+ sourcezoneid=template_created.zoneid,
+ destzoneid=zones_list[1].id
+ )
+ self.assertIsNotNone(
+ copied_template,
+ "Copying Template from Zone1 to Zone2 failed"
+ )
+ # Listing all the Templates for a User in Zone 1
+ list_templates_zone1 = Template.list(
+ self.userapiclient,
+ listall=self.services["listall"],
+ templatefilter=self.services["templatefilter"],
+ zoneid=zones_list[0].id
+ )
+ status = validateList(list_templates_zone1)
+ self.assertEquals(
+ PASS,
+ status[0],
+ "Templates creation failed in Zone1"
+ )
+ # Verifying that list size is 1
+ self.assertEquals(
+ 1,
+ len(list_templates_zone1),
+ "Failed to create a Template"
+ )
+ # Listing all the Templates for a User in Zone 2
+ list_templates_zone2 = Template.list(
+ self.userapiclient,
+ listall=self.services["listall"],
+ templatefilter=self.services["templatefilter"],
+ zoneid=zones_list[1].id
+ )
+ status = validateList(list_templates_zone2)
+ self.assertEquals(
+ PASS,
+ status[0],
+ "Template failed to copy into Zone2"
+ )
+ # Verifying that list size is 1
+ self.assertEquals(
+ 1,
+ len(list_templates_zone2),
+ "Template failed to copy into Zone2"
+ )
+ self.assertNotEquals(
+ "Connection refused",
+ list_templates_zone2[0].status,
+ "Failed to copy Template"
+ )
+ self.assertEquals(
+ True,
+ list_templates_zone2[0].isready,
+ "Failed to copy Template"
+ )
+ del self.services["template"]["url"]
+ del self.services["template"]["format"]
+ del self.services["template"]["ostype"]
+ return
\ No newline at end of file