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:45:01 UTC
[3/7] Revert "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/d43d28ee/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
deleted file mode 100644
index 2367253..0000000
--- a/test/integration/component/test_escalations_snapshots.py
+++ /dev/null
@@ -1,647 +0,0 @@
-# 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/d43d28ee/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
deleted file mode 100644
index 083ba90..0000000
--- a/test/integration/component/test_escalations_templates.py
+++ /dev/null
@@ -1,944 +0,0 @@
-# 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