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:04 UTC
[6/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_instances.py
----------------------------------------------------------------------
diff --git a/test/integration/component/test_escalations_instances.py b/test/integration/component/test_escalations_instances.py
deleted file mode 100644
index 9e040db..0000000
--- a/test/integration/component/test_escalations_instances.py
+++ /dev/null
@@ -1,3448 +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 TestListInstances(cloudstackTestCase):
-
- @classmethod
- def setUpClass(cls):
- try:
- cls._cleanup = []
- cls.testClient = super(TestListInstances, 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.service_offering = ServiceOffering.create(
- cls.api_client,
- cls.services["service_offerings"]["tiny"]
- )
- 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)
- # Updating resource Limits
- for i in range(0,12):
- Resources.updateLimit(
- cls.api_client,
- account=cls.account.name,
- domainid=cls.domain.id,
- max=-1,
- resourcetype=i
- )
-
- cls._cleanup.append(cls.account)
- cls._cleanup.append(cls.service_offering)
- cls._cleanup.append(cls.disk_offering)
- 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", "selfservice"])
- def test_01_list_instances_pagination(self):
- """
- @Desc: Test List Instances pagination
- @Steps:
- Step1: Listing all the Instances for a user
- Step2: Verifying listed Instances for account created at class level
- Step3: If number of volumes is less than (page size + 1), then creating them
- Step4: Listing all the volumes again after creation of volumes
- Step5: Verifying the length of the volumes is (page size + 1)
- Step6: Listing all the volumes in page1
- Step7: Verifying that the length of the volumes in page 1 is (page size)
- Step8: Listing all the volumes in page2
- Step9: Verifying that the length of the volumes in page 2 is 1
- Step10: Deleting the volume present in page 2
- Step11: Listing for the volumes on page 2
- Step12: Verifying that there are no volumes present in page 2
- """
- # Listing all the instances for a user
- list_instances_before = VirtualMachine.list(self.userapiclient, listall=self.services["listall"])
-
- # Verifying listed instances for account created at class level
- self.assertIsNone(
- list_instances_before,
- "Virtual Machine already exists for newly created user"
- )
- # If number of instances are less than (pagesize + 1), then creating them
- for i in range(0, (self.services["pagesize"] + 1)):
- vm_created = VirtualMachine.create(
- self.userapiclient,
- self.services["virtual_machine"],
- accountid=self.account.name,
- domainid=self.account.domainid,
- serviceofferingid=self.service_offering.id,
- )
- self.assertIsNotNone(
- vm_created,
- "VM creation failed"
- )
- if(i < (self.services["pagesize"])):
- self.cleanup.append(vm_created)
-
- self.assertEqual(
- self.services["virtual_machine"]["displayname"],
- vm_created.displayname,
- "Newly created VM name and the test data VM name are not matching"
- )
-
- # Listing all the instances again after creating VM's
- list_instances_after = VirtualMachine.list(self.userapiclient, listall=self.services["listall"])
- status = validateList(list_instances_after)
- self.assertEquals(
- PASS,
- status[0],
- "Listing of instances after creation failed"
- )
- # Verifying the length of the instances is (page size + 1)
- self.assertEqual(
- len(list_instances_after),
- (self.services["pagesize"] + 1),
- "Number of instances created is not matching as expected"
- )
-
- # Listing all the volumes in page1
- list_instances_page1 = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid
- )
- status = validateList(list_instances_page1)
- self.assertEquals(
- PASS,
- status[0],
- "Listing of instances in page1 failed"
- )
- # Verifying that the length of the instances in page 1 is (page size)
- self.assertEqual(
- self.services["pagesize"],
- len(list_instances_page1),
- "List VM response is not matching with the page size length for page 1"
- )
-
- # Listing all the VM's in page2
- list_instances_page2 = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=2,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid
- )
- status = validateList(list_instances_page2)
- self.assertEquals(
- PASS,
- status[0],
- "Listing of instances in page2 failed"
- )
- # Verifying that the length of the VM's in page 2 is 1
- self.assertEqual(
- 1,
- len(list_instances_page2),
- "List VM response is not matching with the page size length for page 2"
- )
- instance_page2 = list_instances_page2[0]
-
- # Verifying that the VM on page 2 is not present in page1
- for i in range(0, len(list_instances_page1)):
- instance_page1 = list_instances_page1[i]
- self.assertNotEquals(
- instance_page2.id,
- instance_page1.id,
- "VM listed in page 2 is also listed in page 1"
- )
-
- # Deleting a single VM
- VirtualMachine.delete(vm_created, self.userapiclient)
-
- # Listing the VM's in page 2
- list_instance_response = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=2,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid
- )
- # verifying that VM does not exists on page 2
- self.assertEqual(
- list_instance_response,
- None,
- "VM was not deleted"
- )
- return
-
- @attr(tags=["advanced", "basic", "selfservice"])
- def test_02_list_Running_vm(self):
- """
- @Desc: Test List Running VM's
- @Steps:
- Step1: Listing all the Running VMs for a user
- Step2: Verifying that the size of the list is 0
- Step3: Deploying a VM
- Step4: Listing all the Running VMs for a user again
- Step5: Verifying that the size of the list is increased by 1
- Step6: Verifying that the details of the Running VM listed are same as the VM deployed in Step3
- """
- # Listing all the Running VM's for a User
- list_running_vms_before = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- state="Running"
- )
- self.assertIsNone(
- list_running_vms_before,
- "Virtual Machine already exists for newly created user"
- )
- # Deploying a VM
- vm_created = VirtualMachine.create(
- self.userapiclient,
- self.services["virtual_machine"],
- accountid=self.account.name,
- domainid=self.account.domainid,
- serviceofferingid=self.service_offering.id,
- )
- self.assertIsNotNone(
- vm_created,
- "VM creation failed"
- )
- self.cleanup.append(vm_created)
- # Listing all the Running VM's for a User
- list_running_vms_after = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- state="Running"
- )
- status = validateList(list_running_vms_after)
- self.assertEquals(
- PASS,
- status[0],
- "Newly created VM is not in Running state"
- )
- # Verifying list size is 1
- self.assertEquals(
- 1,
- len(list_running_vms_after),
- "Running VM list count is not matching"
- )
- running_vm = list_running_vms_after[0]
-
- #Creating expected and actual values dictionaries
- expected_dict = {
- "id":vm_created.id,
- "name":vm_created.name,
- "displayname":vm_created.displayname,
- "state":"Running",
- "zoneid":vm_created.zoneid,
- "account":vm_created.account,
- "template":vm_created.templateid
- }
- actual_dict = {
- "id":running_vm.id,
- "name":running_vm.name,
- "displayname":running_vm.displayname,
- "state":running_vm.state,
- "zoneid":running_vm.zoneid,
- "account":running_vm.account,
- "template":running_vm.templateid
- }
- running_vm_status = self.__verify_values(
- expected_dict,
- actual_dict
- )
- self.assertEqual(
- True,
- running_vm_status,
- "Listed Running VM details are not as expected"
- )
- return
-
- @attr(tags=["advanced", "basic", "selfservice"])
- def test_03_list_Stopped_vm(self):
- """
- @Desc: Test List Stopped VM's
- @Steps:
- Step1: Listing all the Stopped VMs for a user
- Step2: Verifying that the size of the list is 0
- Step3: Deploying a VM
- Step4: Stopping the VM deployed in step3
- Step5: Listing all the Stopped VMs for a user again
- Step6: Verifying that the size of the list is increased by 1
- Step7: Verifying that the details of the Stopped VM listed are same as the VM stopped in Step4
- """
- # Listing all the Stopped VM's for a User
- list_stopped_vms_before = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- state="Stopped"
- )
- self.assertIsNone(
- list_stopped_vms_before,
- "Virtual Machine already exists for newly created user"
- )
- # Deploying a VM
- vm_created = VirtualMachine.create(
- self.userapiclient,
- self.services["virtual_machine"],
- accountid=self.account.name,
- domainid=self.account.domainid,
- serviceofferingid=self.service_offering.id,
- )
- self.assertIsNotNone(
- vm_created,
- "VM creation failed"
- )
- self.cleanup.append(vm_created)
- # Stopping the VM
- VirtualMachine.stop(vm_created, self.userapiclient)
- # Listing all the Stopped VM's for a User
- list_stopped_vms_after = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- state="Stopped"
- )
- status = validateList(list_stopped_vms_after)
- self.assertEquals(
- PASS,
- status[0],
- "Stopped VM is not in Stopped state"
- )
- # Verifying list size is 1
- self.assertEquals(
- 1,
- len(list_stopped_vms_after),
- "Stopped VM list count is not matching"
- )
- stopped_vm = list_stopped_vms_after[0]
- #Creating expected and actual values dictionaries
- expected_dict = {
- "id":vm_created.id,
- "name":vm_created.name,
- "displayname":vm_created.displayname,
- "state":"Stopped",
- "zoneid":vm_created.zoneid,
- "account":vm_created.account,
- "template":vm_created.templateid
- }
- actual_dict = {
- "id":stopped_vm.id,
- "name":stopped_vm.name,
- "displayname":stopped_vm.displayname,
- "state":stopped_vm.state,
- "zoneid":stopped_vm.zoneid,
- "account":stopped_vm.account,
- "template":stopped_vm.templateid
- }
- stopped_vm_status = self.__verify_values(
- expected_dict,
- actual_dict
- )
- self.assertEqual(
- True,
- stopped_vm_status,
- "Listed Stopped VM details are not as expected"
- )
- return
-
- @attr(tags=["advanced", "basic", "selfservice"])
- def test_04_list_Destroyed_vm(self):
- """
- @Desc: Test List Destroyed VM's
- @Steps:
- Step1: Listing all the Destroyed VMs for a user
- Step2: Verifying that the size of the list is 0
- Step3: Deploying a VM
- Step4: Destroyed the VM deployed in step3
- Step5: Listing all the Destroyed VMs for a user again
- Step6: Verifying that destroyed VM is not listed for User
- Step7: Listing all the destroyed VMs as admin
- Step8: Verifying that the size of the list is 1
- Step9: Verifying that the details of the Destroyed VM listed are same as the VM destroyed in Step4
- """
- # Listing all the Destroyed VM's for a User
- list_destroyed_vms_before = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- state="Destroyed"
- )
- self.assertIsNone(
- list_destroyed_vms_before,
- "Virtual Machine in Destroyed state already exists for newly created user"
- )
- # Deploying a VM
- vm_created = VirtualMachine.create(
- self.userapiclient,
- self.services["virtual_machine"],
- accountid=self.account.name,
- domainid=self.account.domainid,
- serviceofferingid=self.service_offering.id,
- )
- self.assertIsNotNone(
- vm_created,
- "VM creation failed"
- )
- # Destroying the VM
- VirtualMachine.delete(vm_created, self.userapiclient)
- # Listing all the Destroyed VM's for a User
- list_destroyed_vms_after = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- state="Destroyed"
- )
- self.assertIsNone(
- list_destroyed_vms_after,
- "Destroyed VM is not in destroyed state"
- )
- # Listing destroyed VMs as admin user
- list_destroyed_vms_admin = VirtualMachine.list(
- self.apiClient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- state="Destroyed",
- id=vm_created.id
- )
- status = validateList(list_destroyed_vms_admin)
- self.assertEquals(
- PASS,
- status[0],
- "Destroyed VM is not in Destroyed state"
- )
- # Verifying that the length of the destroyed VMs list should be 1
- self.assertEquals(
- 1,
- len(list_destroyed_vms_admin),
- "Destroyed VM list count is not matching"
- )
- destroyed_vm = list_destroyed_vms_admin[0]
- #Creating expected and actual values dictionaries
- expected_dict = {
- "id":vm_created.id,
- "name":vm_created.name,
- "displayname":vm_created.displayname,
- "state":"Destroyed",
- "zoneid":vm_created.zoneid,
- "account":vm_created.account,
- "template":vm_created.templateid
- }
- actual_dict = {
- "id":destroyed_vm.id,
- "name":destroyed_vm.name,
- "displayname":destroyed_vm.displayname,
- "state":destroyed_vm.state,
- "zoneid":destroyed_vm.zoneid,
- "account":destroyed_vm.account,
- "template":destroyed_vm.templateid
- }
- destroyed_vm_status = self.__verify_values(
- expected_dict,
- actual_dict
- )
- self.assertEqual(
- True,
- destroyed_vm_status,
- "Listed Destroyed VM details are not as expected"
- )
- return
-
- @attr(tags=["advanced", "basic", "selfservice"])
- def test_05_list_vm_by_id(self):
- """
- @Desc: Test List VM by Id
- @Steps:
- Step1: Listing all the VMs for a user
- Step2: Verifying that the size of the list is 0
- Step3: Deploying a VM
- Step4: Listing all the VMs for a user again
- Step5: Verifying that the size of the list is increased by 1
- Step6: List a VM by specifying the Id if the VM deployed in Step3
- Step7: Verifying that the details of the Listed VM are same as the VM deployed in Step3
- """
- # Listing all the VM's for a User
- list_vms_before = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- account=self.account.name
- )
- self.assertIsNone(
- list_vms_before,
- "Virtual Machine already exists for newly created user"
- )
- # Deploying a VM
- vm_created = VirtualMachine.create(
- self.userapiclient,
- self.services["virtual_machine"],
- accountid=self.account.name,
- domainid=self.account.domainid,
- serviceofferingid=self.service_offering.id,
- )
- self.assertIsNotNone(
- vm_created,
- "VM creation failed"
- )
- self.cleanup.append(vm_created)
- # Listing all the VM's for a User
- list_vms_after = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- account=self.account.name
- )
- status = validateList(list_vms_after)
- self.assertEquals(
- PASS,
- status[0],
- "Listing of VM after creation failed"
- )
- self.assertEquals(
- 1,
- len(list_vms_after),
- "VM list count is not matching"
- )
- # Listing a VM by Id
- list_vm_byid = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- id=vm_created.id
- )
- status = validateList(list_vm_byid)
- self.assertEquals(
- PASS,
- status[0],
- "Listing of VM by Id failed"
- )
- listed_vm = list_vm_byid[0]
- #Creating expected and actual values dictionaries
- expected_dict = {
- "id":vm_created.id,
- "name":vm_created.name,
- "displayname":vm_created.displayname,
- "state":vm_created.state,
- "zoneid":vm_created.zoneid,
- "account":vm_created.account,
- "template":vm_created.templateid
- }
- actual_dict = {
- "id":listed_vm.id,
- "name":listed_vm.name,
- "displayname":listed_vm.displayname,
- "state":listed_vm.state,
- "zoneid":listed_vm.zoneid,
- "account":listed_vm.account,
- "template":listed_vm.templateid
- }
- list_vm_status = self.__verify_values(
- expected_dict,
- actual_dict
- )
- self.assertEqual(
- True,
- list_vm_status,
- "Listed VM by Id details are not as expected"
- )
- return
-
- @attr(tags=["advanced", "basic", "selfservice"])
- def test_06_list_vm_by_name(self):
- """
- @Desc: Test List VM's by Name
- @Steps:
- Step1: Listing all the VMs for a user
- Step2: Verifying that the size of the list is 0
- Step3: Deploying a 2 VM's
- Step4: Listing all the VMs for a user again
- Step5: Verifying that list size is increased by 2
- Step6: Listing the VM by specifying complete name of VM-1 created in step3
- Step7: Verifying that the size of the list is 1
- Step8: Verifying that the details of the listed VM are same as the VM-1 created in step3
- Step9: Listing the VM by specifying the partial name of VM
- Step10: Verifying that the size of the list is 2
- """
- # Listing all the VM's for a User
- list_vms_before = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- )
- self.assertIsNone(
- list_vms_before,
- "Virtual Machine already exists for newly created user"
- )
- vms = {}
- for i in range(0, 2):
- # Deploying a VM
- vm_created = VirtualMachine.create(
- self.userapiclient,
- self.services["virtual_machine"],
- accountid=self.account.name,
- domainid=self.account.domainid,
- serviceofferingid=self.service_offering.id,
- )
- self.assertIsNotNone(
- vm_created,
- "VM creation failed"
- )
- self.cleanup.append(vm_created)
- vms.update({i: vm_created})
-
- # Listing all the VM's for a User
- list_vms_after = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- )
- status = validateList(list_vms_after)
- self.assertEquals(
- PASS,
- status[0],
- "VM's creation failed"
- )
- self.assertEquals(
- 2,
- len(list_vms_after),
- "VM's list count is not matching"
- )
- # Listing the VM by complete name
- list_vm_byfullname = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- name=vms[0].name
- )
- status = validateList(list_vm_byfullname)
- self.assertEquals(
- PASS,
- status[0],
- "Failed to list VM by Name"
- )
- # Verifying that the size of the list is 1
- self.assertEquals(
- 1,
- len(list_vm_byfullname),
- "VM list by full name count is not matching"
- )
- # Verifying that the details of the listed VM are same as the VM created above
- #Creating expected and actual values dictionaries
- expected_dict = {
- "id":vms[0].id,
- "name":vms[0].name,
- "displayname":vms[0].displayname,
- "state":vms[0].state,
- "zoneid":vms[0].zoneid,
- "account":vms[0].account,
- "template":vms[0].templateid
- }
- actual_dict = {
- "id":list_vm_byfullname[0].id,
- "name":list_vm_byfullname[0].name,
- "displayname":list_vm_byfullname[0].displayname,
- "state":list_vm_byfullname[0].state,
- "zoneid":list_vm_byfullname[0].zoneid,
- "account":list_vm_byfullname[0].account,
- "template":list_vm_byfullname[0].templateid
- }
- list_vm_status = self.__verify_values(
- expected_dict,
- actual_dict
- )
- self.assertEqual(
- True,
- list_vm_status,
- "Listed VM details are not as expected"
- )
- # Listing the VM by partial name
- list_vm_bypartialname = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- domainid=self.account.domainid,
- name=vms[0].name[:1]
- )
- status = validateList(list_vm_bypartialname)
- self.assertEquals(
- PASS,
- status[0],
- "Failed to list VM by Name"
- )
- # Verifying that the size of the list is 2
- self.assertEquals(
- 2,
- len(list_vm_bypartialname),
- "VM list by full name count is not matching"
- )
- return
-
- @attr(tags=["advanced", "basic", "selfservice"])
- def test_07_list_vm_by_name_state(self):
- """
- @Desc: Test List VM's by Name and State
- @Steps:
- Step1: Listing all the VMs for a user
- Step2: Verifying that the size of the list is 0
- Step3: Deploying a VM
- Step4: Listing all the VMs for a user again
- Step5: Verifying that list size is increased by 1
- Step6: Listing the VM by specifying name of VM created in step3 and state as Running (matching name and state)
- Step7: Verifying that the size of the list is 1
- Step8: Verifying that the details of the listed VM are same as the VM created in step3
- Step9: Listing the VM by specifying name of VM created in step3 and state as Stopped (non matching state)
- Step10: Verifying that the size of the list is 0
- Step11: Listing the VM by specifying non matching name and state as Running (non matching name)
- Step12: Verifying that the size of the list is 0
- """
- # Listing all the VM's for a User
- list_vms_before = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- )
- self.assertIsNone(
- list_vms_before,
- "Virtual Machine already exists for newly created user"
- )
- # Deploying a VM
- vm_created = VirtualMachine.create(
- self.userapiclient,
- self.services["virtual_machine"],
- accountid=self.account.name,
- domainid=self.account.domainid,
- serviceofferingid=self.service_offering.id,
- )
- self.assertIsNotNone(
- vm_created,
- "VM creation failed"
- )
- self.cleanup.append(vm_created)
- # Listing all the VM's for a User
- list_vms_after = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- )
- status = validateList(list_vms_after)
- self.assertEquals(
- PASS,
- status[0],
- "VM's creation failed"
- )
- self.assertEquals(
- 1,
- len(list_vms_after),
- "VM's list count is not matching"
- )
- # Listing the VM by matching Name and State
- list_running_vm = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- name=vm_created.name,
- state="Running"
- )
- status = validateList(list_running_vm)
- self.assertEquals(
- PASS,
- status[0],
- "List VM by name and state failed"
- )
- # Verifying that the size of the list is 1
- self.assertEquals(
- 1,
- len(list_running_vm),
- "Count of VM list by name and state is not matching"
- )
- # Verifying that the details of the listed VM are same as the VM created above
- #Creating expected and actual values dictionaries
- expected_dict = {
- "id":vm_created.id,
- "name":vm_created.name,
- "displayname":vm_created.displayname,
- "state":"Running",
- "zoneid":vm_created.zoneid,
- "account":vm_created.account,
- "template":vm_created.templateid
- }
- actual_dict = {
- "id":list_running_vm[0].id,
- "name":list_running_vm[0].name,
- "displayname":list_running_vm[0].displayname,
- "state":list_running_vm[0].state,
- "zoneid":list_running_vm[0].zoneid,
- "account":list_running_vm[0].account,
- "template":list_running_vm[0].templateid
- }
- list_vm_status = self.__verify_values(
- expected_dict,
- actual_dict
- )
- self.assertEqual(
- True,
- list_vm_status,
- "Listed VM details are not as expected"
- )
- # Listing the VM by matching name and non matching state
- list_running_vm = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- name=vm_created.name,
- state="Stopped"
- )
- self.assertIsNone(
- list_running_vm,
- "Listed VM with non matching state"
- )
- # Listing the VM by non matching name and matching state
- list_running_vm = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- name="name",
- state="Running"
- )
- self.assertIsNone(
- list_running_vm,
- "Listed VM with non matching name"
- )
- return
-
- @attr(tags=["advanced", "basic", "selfservice"])
- def test_08_list_vm_by_zone(self):
- """
- @Desc: Test List VM by Zone.
- This test case is applicable for a setup having multiple zones.
- @Steps:
- Step1: Listing all the zones
- Step2: Checking if there are multiple zones in the setup.
- Continuing below steps only if there are multiple zones
- Step3: Listing template for zone
- Step4: Listing all the VMs for a user
- Step5: Verifying that the size of the list is 0
- Step6: Deploying a VM
- Step7: Listing all the VMs for a user again for matching zone
- Step8: Verifying that the size of the list is 1
- Step9: Verifying that the details of the Listed VM are same as the VM deployed in Step6
- Step10: Listing all the VMs for a user again for non-matching zone
- Step11: Verifying that the size of the list is 0
- """
- # Listing all the zones available
- zones_list = Zone.list(self.apiClient)
- status = validateList(zones_list)
- self.assertEquals(
- PASS,
- status[0],
- "zones not available in the given setup"
- )
- current_zone = self.services["virtual_machine"]["zoneid"]
- current_template = self.services["virtual_machine"]["template"]
- # Checking if there are multiple zones in the setup.
- if not len(zones_list) > 1:
- self.debug("Setup is not having multiple zones")
- else:
- # Getting the template available under the zone
- template = get_template(
- self.apiClient,
- zones_list[0].id,
- self.services["ostype"]
- )
- self.assertIsNotNone(
- template,
- "Template not found for zone"
- )
- self.services["virtual_machine"]["zoneid"] = zones_list[0].id
- self.services["virtual_machine"]["template"] = template.id
- # Listing all the VM's for a User
- list_vms_before = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- zoneid=zones_list[0].id
- )
- self.assertIsNone(
- list_vms_before,
- "Virtual Machine already exists for newly created user"
- )
- # Deploying a VM
- vm_created = VirtualMachine.create(
- self.userapiclient,
- self.services["virtual_machine"],
- accountid=self.account.name,
- domainid=self.account.domainid,
- serviceofferingid=self.service_offering.id,
- )
- self.assertIsNotNone(
- vm_created,
- "VM creation failed"
- )
- self.cleanup.append(vm_created)
- # Listing all the VMs for a user again for matching zone
- list_vms_after = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- zoneid=zones_list[0].id
- )
- status = validateList(list_vms_after)
- self.assertEquals(
- PASS,
- status[0],
- "VM creation failed"
- )
- # Verifying that the size of the list is 1
- self.assertEquals(
- 1,
- len(list_vms_after),
- "VM list count is not matching"
- )
- listed_vm = list_vms_after[0]
- # Verifying that the details of the Listed VM are same as the VM deployed above
- #Creating expected and actual values dictionaries
- expected_dict = {
- "id":vm_created.id,
- "name":vm_created.name,
- "displayname":vm_created.displayname,
- "state":vm_created.state,
- "zoneid":vm_created.zoneid,
- "account":vm_created.account,
- "template":vm_created.templateid
- }
- actual_dict = {
- "id":listed_vm.id,
- "name":listed_vm.name,
- "displayname":listed_vm.displayname,
- "state":listed_vm.state,
- "zoneid":listed_vm.zoneid,
- "account":listed_vm.account,
- "template":listed_vm.templateid
- }
- list_vm_status = self.__verify_values(
- expected_dict,
- actual_dict
- )
- self.assertEqual(
- True,
- list_vm_status,
- "Listed VM by Id details are not as expected"
- )
- # Listing all the VMs for a user again for non-matching zone
- list_vms = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- zoneid=zones_list[1].id
- )
- self.assertIsNone(
- list_vms,
- "VM's listed for non matching zone"
- )
- self.services["virtual_machine"]["zoneid"] = current_zone
- self.services["virtual_machine"]["template"] = current_template
- return
-
- @attr(tags=["advanced", "basic", "selfservice"])
- def test_09_list_vm_by_zone_name(self):
- """
- @Desc: Test List VM by Zone.
- This test case is applicable for a setup having multiple zones.
- @Steps:
- Step1: Listing all the zones
- Step2: Checking if there are multiple zones in the setup.
- Continuing below steps only if there are multiple zones
- Step3: Listing template for zone
- Step4: Listing all the VMs for a user
- Step5: Verifying that the size of the list is 0
- Step6: Deploying a VM
- Step7: Listing all the VMs for a user again
- Step8: Verifying that list size is increased by 1
- Step9: Listing the VM by specifying name of VM created in step6 and matching zone (matching name and zone)
- Step10: Verifying that the size of the list is 1
- Step11: Verifying that the details of the listed VM are same as the VM created in step3
- Step12: Listing the VM by specifying name of VM created in step6 and non matching zone (non matching zone)
- Step13: Verifying that the size of the list is 0
- Step14: Listing the VM by specifying non matching name and matching zone (non matching name)
- Step15: Verifying that the size of the list is 0
- """
- # Listing all the zones available
- zones_list = Zone.list(self.apiClient)
- status = validateList(zones_list)
- self.assertEquals(
- PASS,
- status[0],
- "zones not available in the given setup"
- )
- current_zone = self.services["virtual_machine"]["zoneid"]
- current_template = self.services["virtual_machine"]["template"]
- # Checking if there are multiple zones in the setup.
- if not len(zones_list) > 1:
- self.debug("Setup is not having multiple Zones")
- else:
- # Getting the template available under the zone
- template = get_template(
- self.apiClient,
- zones_list[0].id,
- self.services["ostype"]
- )
- self.assertIsNotNone(
- template,
- "Template not found for zone"
- )
- self.services["virtual_machine"]["zoneid"] = zones_list[0].id
- self.services["virtual_machine"]["template"] = template.id
- # Listing all the VM's for a User
- list_vms_before = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- zoneid=zones_list[0].id,
- account=self.account.name
- )
- self.assertIsNone(
- list_vms_before,
- "Virtual Machine already exists for newly created user"
- )
- # Deploying a VM
- vm_created = VirtualMachine.create(
- self.userapiclient,
- self.services["virtual_machine"],
- accountid=self.account.name,
- domainid=self.account.domainid,
- serviceofferingid=self.service_offering.id,
- )
- self.assertIsNotNone(
- vm_created,
- "VM creation failed"
- )
- self.cleanup.append(vm_created)
- # Listing all the VMs for a user again for matching zone
- list_vms_after = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- zoneid=zones_list[0].id,
- account=self.account.name
- )
- status = validateList(list_vms_after)
- self.assertEquals(
- PASS,
- status[0],
- "VM creation failed"
- )
- # Verifying that the size of the list is 1
- self.assertEquals(
- 1,
- len(list_vms_after),
- "VM list count is not matching"
- )
- # Listing the VM by specifying name of VM created in above and matching zone
- list_vms = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- zoneid=zones_list[0].id,
- name=vm_created.name
- )
- status = validateList(list_vms)
- self.assertEquals(
- PASS,
- status[0],
- "Listing VM's by name and zone failed"
- )
- # Verifying Verifying that the size of the list is 1
- self.assertEquals(
- 1,
- len(list_vms),
- "Count of listed VM's by name and zone is not as expected"
- )
- listed_vm = list_vms[0]
- # Verifying that the details of the Listed VM are same as the VM deployed above
- #Creating expected and actual values dictionaries
- expected_dict = {
- "id":vm_created.id,
- "name":vm_created.name,
- "displayname":vm_created.displayname,
- "state":vm_created.state,
- "zoneid":vm_created.zoneid,
- "account":vm_created.account,
- "template":vm_created.templateid
- }
- actual_dict = {
- "id":listed_vm.id,
- "name":listed_vm.name,
- "displayname":listed_vm.displayname,
- "state":listed_vm.state,
- "zoneid":listed_vm.zoneid,
- "account":listed_vm.account,
- "template":listed_vm.templateid
- }
- list_vm_status = self.__verify_values(
- expected_dict,
- actual_dict
- )
- self.assertEqual(
- True,
- list_vm_status,
- "Listed VM by Id details are not as expected"
- )
- # Listing the VM by specifying name of VM created in step3 and non matching zone
- list_vms = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- zoneid=zones_list[1].id,
- name=vm_created.name
- )
- self.assertIsNone(
- list_vms,
- "VM's listed for non matching zone"
- )
- # Listing the VM by specifying non matching name of VM and matching zone
- list_vms = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- zoneid=zones_list[0].id,
- name="name"
- )
- self.assertIsNone(
- list_vms,
- "VM's listed for non matching zone"
- )
- self.services["virtual_machine"]["zoneid"] = current_zone
- self.services["virtual_machine"]["template"] = current_template
- return
-
- @attr(tags=["advanced", "basic", "selfservice"])
- def test_10_list_vm_by_zone_name_state(self):
- """
- @Desc: Test List VM by Zone.
- @Steps:
- Step1: Listing all the VMs for a user
- Step2: Verifying that the size of the list is 0
- Step3: Deploying a VM
- Step4: Listing all the VMs for a user again
- Step5: Verifying that list size is increased by 1
- Step6: Listing the VM by specifying name of VM created in step3 and matching zone and state as Running
- Step7: Verifying that the size of the list is 1
- Step8: Verifying that the details of the listed VM are same as the VM created in step3
- Step9: Listing the VM by specifying name of VM created in step3 and matching zone and state as Stopped
- Step10: Verifying that the size of the list is 0
- Step11: Listing the VM by name, Zone and account
- Step12: Verifying that the size of the list is 1
- Step13: Verifying that the details of the listed VM are same as the VM created in step3
- """
- # Listing all the VM's for a User
- list_vms_before = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- zoneid=self.zone.id,
- account=self.account.name
- )
- self.assertIsNone(
- list_vms_before,
- "Virtual Machine already exists for newly created user"
- )
- # Deploying a VM
- vm_created = VirtualMachine.create(
- self.userapiclient,
- self.services["virtual_machine"],
- accountid=self.account.name,
- domainid=self.account.domainid,
- serviceofferingid=self.service_offering.id,
- )
- self.assertIsNotNone(
- vm_created,
- "VM creation failed"
- )
- self.cleanup.append(vm_created)
- # Listing all the VMs for a user again for matching zone
- list_vms_after = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- zoneid=self.zone.id,
- account=self.account.name
- )
- status = validateList(list_vms_after)
- self.assertEquals(
- PASS,
- status[0],
- "VM creation failed"
- )
- # Verifying that the size of the list is 1
- self.assertEquals(
- 1,
- len(list_vms_after),
- "VM list count is not matching"
- )
- # Listing the VM by specifying name of VM created in step3 and matching zone and state as Running
- list_vms = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- zoneid=self.zone.id,
- name=vm_created.name,
- state="Running"
- )
- status = validateList(list_vms)
- self.assertEquals(
- PASS,
- status[0],
- "Listing VM's by name and zone failed"
- )
- # Verifying Verifying that the size of the list is 1
- self.assertEquals(
- 1,
- len(list_vms),
- "Count of listed VM's by name, zone and state is not as expected"
- )
- listed_vm = list_vms[0]
- # Verifying that the details of the Listed VM are same as the VM deployed above
- #Creating expected and actual values dictionaries
- expected_dict = {
- "id":vm_created.id,
- "name":vm_created.name,
- "displayname":vm_created.displayname,
- "state":vm_created.state,
- "zoneid":vm_created.zoneid,
- "account":vm_created.account,
- "template":vm_created.templateid
- }
- actual_dict = {
- "id":listed_vm.id,
- "name":listed_vm.name,
- "displayname":listed_vm.displayname,
- "state":listed_vm.state,
- "zoneid":listed_vm.zoneid,
- "account":listed_vm.account,
- "template":listed_vm.templateid
- }
- list_vm_status = self.__verify_values(
- expected_dict,
- actual_dict
- )
- self.assertEqual(
- True,
- list_vm_status,
- "Listed VM by Id details are not as expected"
- )
- # Listing the VM by specifying name of VM created in step3, zone and State as Stopped
- list_vms = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- zoneid=self.zone.id,
- name=vm_created.name,
- state="Stopped"
- )
- self.assertIsNone(
- list_vms,
- "VM's listed for non matching zone"
- )
- # Listing the VM by name, zone and account
- list_vms = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- page=1,
- pagesize=self.services["pagesize"],
- domainid=self.account.domainid,
- zoneid=self.zone.id,
- name=vm_created.name,
- account=self.account.name
- )
- status = validateList(list_vms)
- self.assertEquals(
- PASS,
- status[0],
- "Listing VM's by name, account and zone failed"
- )
- # Verifying Verifying that the size of the list is 1
- self.assertEquals(
- 1,
- len(list_vms),
- "Count of listed VM's by name, zone and account is not as expected"
- )
- listed_vm = list_vms[0]
- # Verifying that the details of the Listed VM are same as the VM deployed above
- #Creating expected and actual values dictionaries
- expected_dict = {
- "id":vm_created.id,
- "name":vm_created.name,
- "displayname":vm_created.displayname,
- "state":vm_created.state,
- "zoneid":vm_created.zoneid,
- "account":vm_created.account,
- "template":vm_created.templateid
- }
- actual_dict = {
- "id":listed_vm.id,
- "name":listed_vm.name,
- "displayname":listed_vm.displayname,
- "state":listed_vm.state,
- "zoneid":listed_vm.zoneid,
- "account":listed_vm.account,
- "template":listed_vm.templateid
- }
- list_vm_status = self.__verify_values(
- expected_dict,
- actual_dict
- )
- self.assertEqual(
- True,
- list_vm_status,
- "Listed VM by Id details are not as expected"
- )
- return
-
- @attr(tags=["advanced", "basic", "provisioning"])
- def test_11_register_reset_vm_sshkey(self):
- """
- @Desc: Test to verify registering and reset of SSH Key for VM
- @Steps:
- Step1: Deploying a VM
- Step2: Stopping the VM deployed in step1
- Step3: Listing all the SSH Key pairs
- Step4: Registering a SSH Key pair
- Step5: Listing all the SSh Key pairs again
- Step6: Verifying that the key pairs list is increased by 1
- Step7: Resetting the VM SSH Key to the key pair registered in step4
- Step8: Verifying that the registered SSH Key pair is set to the VM
- """
- # Listing all the VM's for a User
- list_vms_before = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- )
- self.assertIsNone(
- list_vms_before,
- "Virtual Machine already exists for newly created user"
- )
- # Deploying a VM
- vm_created = VirtualMachine.create(
- self.userapiclient,
- self.services["virtual_machine"],
- accountid=self.account.name,
- domainid=self.account.domainid,
- serviceofferingid=self.service_offering.id,
- )
- self.assertIsNotNone(
- vm_created,
- "VM creation failed"
- )
- self.cleanup.append(vm_created)
- # Listing all the VMs for a user again
- list_vms_after = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- )
- status = validateList(list_vms_after)
- self.assertEquals(
- PASS,
- status[0],
- "VM creation failed"
- )
- # Verifying that the size of the list is 1
- self.assertEquals(
- 1,
- len(list_vms_after),
- "VM list count is not matching"
- )
- # Stopping the VM deployed above
- vm_created.stop(
- self.userapiclient,
- forced=True
- )
- # Listing all the SSH Key pairs
- list_keypairs_before = SSHKeyPair.list(
- self.userapiclient
- )
- list_keypairs_before_size = 0
- if list_keypairs_before is not None:
- list_keypairs_before_size = len(list_keypairs_before)
-
- # Registering new Key pair
- new_keypair = SSHKeyPair.register(
- self.userapiclient,
- name="keypair1",
- publickey="ssh-rsa: e6:9a:1e:b5:98:75:88:5d:56:bc:92:7b:43:48:05:b2"
- )
- self.assertIsNotNone(
- new_keypair,
- "New Key pair generation failed"
- )
- self.assertEquals(
- "keypair1",
- new_keypair.name,
- "Key Pair not created with given name"
- )
- # Listing all the SSH Key pairs again
- list_keypairs_after = SSHKeyPair.list(
- self.userapiclient
- )
- status = validateList(list_keypairs_after)
- self.assertEquals(
- PASS,
- status[0],
- "Listing of Key pairs failed"
- )
- # Verifying that list size is increased by 1
- self.assertEquals(
- list_keypairs_before_size + 1,
- len(list_keypairs_after),
- "List count is not matching"
- )
- # Resetting the VM SSH key to the Key pair created above
- vm_created.resetSshKey(
- self.userapiclient,
- keypair=new_keypair.name
- )
- # Listing VM details again
- list_vm = VirtualMachine.list(
- self.userapiclient,
- id=vm_created.id
- )
- status = validateList(list_vm)
- self.assertEquals(
- PASS,
- status[0],
- "Listing of VM failed"
- )
- self.assertEquals(
- 1,
- len(list_vm),
- "VMs list is not as expected"
- )
- # Verifying that VM's SSH keypair is set to newly created keypair
- self.assertEquals(
- new_keypair.name,
- list_vm[0].keypair,
- "VM is not set to newly created SSH Key pair"
- )
- return
-
- @attr(tags=["advanced", "provisioning"])
- def test_12_vm_nics(self):
- """
- @Desc: Test to verify Nics for a VM
- @Steps:
- Step1: Deploying a VM
- Step2: Listing all the Networks
- Step3: Verifying that the list size is 1
- Step4: Creating 1 network
- Step5: Listing all the networks again
- Step6: Verifying that the list size is 2
- Step7: Verifying that VM deployed in step1 has only 1 nic
- and it is same as network listed in step3
- Step8: Adding the networks created in step4 to VM deployed in step1
- Step9: Verifying that VM deployed in step1 has 2 nics
- Step10: Verifying that isdefault is set to true for only 1 nic
- Step11: Verifying that isdefault is set to true for the Network created when deployed a VM
- Step12: Making the nic created in step4 as default nic
- Step13: Verifying that isdefault is set to true for only 1 nic
- Step14: Verifying that the isdefault is set to true for the nic created in step4
- Step15: Removing the non-default nic from VM
- Step16: Verifying that VM deployed in step1 has only 1 nic
- """
- # Listing all the VM's for a User
- list_vms_before = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- )
- self.assertIsNone(
- list_vms_before,
- "Virtual Machine already exists for newly created user"
- )
- # Deploying a VM
- vm_created = VirtualMachine.create(
- self.userapiclient,
- self.services["virtual_machine"],
- accountid=self.account.name,
- domainid=self.account.domainid,
- serviceofferingid=self.service_offering.id,
- )
- self.assertIsNotNone(
- vm_created,
- "VM creation failed"
- )
- self.cleanup.append(vm_created)
- # Listing all the VMs for a user again
- list_vms_after = VirtualMachine.list(
- self.userapiclient,
- listall=self.services["listall"],
- )
- status = validateList(list_vms_after)
- self.assertEquals(
- PASS,
- status[0],
- "VM creation failed"
- )
- # Verifying that the size of the list is 1
- self.assertEquals(
- 1,
- len(list_vms_after),
- "VM list count is not matching"
- )
- # Listing all the networks before
- list_network_before = Network.list(
- self.userapiclient,
- isdefault="true",
- zoneid=self.zone.id,
- account=self.account.name,
- domainid=self.domain.id
- )
- status = validateList(list_network_before)
- self.assertEquals(
- PASS,
- status[0],
- "Default Network not created when deploying a VM"
- )
- # Verifying that only 1 network is created while deploying a VM
- self.assertEquals(
- 1,
- len(list_network_before),
- "More than 1 default network exists"
- )
- network1 = list_network_before[0]
- # Listing Network Offerings
- network_offerings_list = NetworkOffering.list(
- self.apiClient,
- forvpc="false",
- guestiptype="Isolated",
- state="Enabled",
- supportedservices="SourceNat",
- zoneid=self.zone.id
- )
- self.assertIsNotNone(
- network_offerings_list,
- "Isolated Network Offerings with sourceNat enabled are not found"
- )
- # Creating one more network
- network2 = Network.create(
- self.userapiclient,
- self.services["network"],
- accountid=self.account.name,
- domainid=self.domain.id,
- networkofferingid=network_offerings_list[0].id,
- zoneid=self.zone.id
- )
- self.assertIsNotNone(
- network2,
- "Network creation failed"
- )
- self.cleanup.append(network2)
- # Listing all the networks again
- list_network_after = Network.list(
- self.userapiclient,
- zoneid=self.zone.id,
- account=self.account.name,
- domainid=self.domain.id
- )
- status = validateList(list_network_after)
- self.assertEquals(
- PASS,
- status[0],
- "List of Networks failed"
-
<TRUNCATED>