cleanup some smoke tests

test/integration/smoke/test_deploy_vm.py

@@ -0,0 +1,264 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+""" BVT tests for Virtual Machine Life Cycle
+"""
+# Import Local Modules
+from marvin.cloudstackTestCase import cloudstackTestCase
+from marvin.cloudstackAPI import (recoverVirtualMachine,
+                                  destroyVirtualMachine,
+                                  attachIso,
+                                  detachIso,
+                                  provisionCertificate,
+                                  updateConfiguration,
+                                  migrateVirtualMachine,
+                                  migrateVirtualMachineWithVolume,
+                                  listNics,
+                                  listVolumes)
+from marvin.lib.utils import *
+
+from marvin.lib.base import (Account,
+                             ServiceOffering,
+                             VirtualMachine,
+                             Host,
+                             Iso,
+                             Router,
+                             Configurations,
+                             StoragePool,
+                             Volume,
+                             DiskOffering,
+                             NetworkOffering,
+                             Network)
+from marvin.lib.common import (get_domain,
+                               get_zone,
+                               get_suitable_test_template,
+                               get_test_ovf_templates,
+                               list_hosts,
+                               get_vm_vapp_configs)
+from marvin.codes import FAILED, PASS
+from nose.plugins.attrib import attr
+from marvin.lib.decoratorGenerators import skipTestIf
+# Import System modules
+import time
+import json
+from operator import itemgetter
+
+_multiprocess_shared_ = True
+
+class TestDeployVM(cloudstackTestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        testClient = super(TestDeployVM, cls).getClsTestClient()
+        cls.apiclient = testClient.getApiClient()
+        cls.services = testClient.getParsedTestDataConfig()
+
+        # Get Zone, Domain and templates
+        cls.domain = get_domain(cls.apiclient)
+        cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests())
+        cls.services['mode'] = cls.zone.networktype
+        cls.hypervisor = testClient.getHypervisorInfo()
+
+        # If local storage is enabled, alter the offerings to use localstorage
+        # this step is needed for devcloud
+        if cls.zone.localstorageenabled == True:
+            cls.services["service_offerings"]["tiny"]["storagetype"] = 'local'
+            cls.services["service_offerings"]["small"]["storagetype"] = 'local'
+            cls.services["service_offerings"]["medium"]["storagetype"] = 'local'
+
+        template = get_suitable_test_template(
+            cls.apiclient,
+            cls.zone.id,
+            cls.services["ostype"],
+            cls.hypervisor
+        )
+        if template == FAILED:
+            assert False, "get_suitable_test_template() failed to return template with description %s" % cls.services["ostype"]
+
+        # Set Zones and disk offerings
+        cls.services["small"]["zoneid"] = cls.zone.id
+        cls.services["small"]["template"] = template.id
+
+        cls.services["iso1"]["zoneid"] = cls.zone.id
+
+        cls._cleanup = []
+
+        cls.account = Account.create(
+            cls.apiclient,
+            cls.services["account"],
+            domainid=cls.domain.id
+        )
+        cls._cleanup.append(cls.account)
+        cls.debug(cls.account.id)
+
+        cls.service_offering = ServiceOffering.create(
+            cls.apiclient,
+            cls.services["service_offerings"]["tiny"]
+        )
+        cls._cleanup.append(cls.service_offering)
+
+        cls.virtual_machine = VirtualMachine.create(
+            cls.apiclient,
+            cls.services["small"],
+            accountid=cls.account.name,
+            domainid=cls.account.domainid,
+            serviceofferingid=cls.service_offering.id,
+            mode=cls.services['mode']
+        )
+        cls._cleanup.append(cls.virtual_machine)
+
+    @classmethod
+    def tearDownClass(cls):
+        super(TestDeployVM, cls).tearDownClass()
+
+    def setUp(self):
+        self.apiclient = self.testClient.getApiClient()
+        self.dbclient = self.testClient.getDbConnection()
+        self.cleanup = []
+
+    def tearDown(self):
+        super(TestDeployVM, self).tearDown()
+
+    @attr(tags=["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="false")
+    def test_deploy_vm(self):
+        """Test Deploy Virtual Machine
+        """
+        # Validate the following:
+        # 1. Virtual Machine is accessible via SSH
+        # 2. listVirtualMachines returns accurate information
+        list_vm_response = VirtualMachine.list(
+            self.apiclient,
+            id=self.virtual_machine.id
+        )
+
+        self.debug(
+            "Verify listVirtualMachines response for virtual machine: %s" \
+            % self.virtual_machine.id
+        )
+        self.assertEqual(
+            isinstance(list_vm_response, list),
+            True,
+            "Check list response returns a valid list"
+        )
+        self.assertNotEqual(
+            len(list_vm_response),
+            0,
+            "Check VM available in List Virtual Machines"
+        )
+        vm_response = list_vm_response[0]
+        self.assertEqual(
+
+            vm_response.id,
+            self.virtual_machine.id,
+            "Check virtual machine id in listVirtualMachines"
+        )
+        self.assertEqual(
+            vm_response.name,
+            self.virtual_machine.name,
+            "Check virtual machine name in listVirtualMachines"
+        )
+        self.assertEqual(
+            vm_response.state,
+            'Running',
+            msg="VM is not in Running state"
+        )
+        return
+
+    @attr(tags=["advanced"], required_hardware="false")
+    def test_advZoneVirtualRouter(self):
+        # TODO: SIMENH: duplicate test, remove it
+        """
+        Test advanced zone virtual router
+        1. Is Running
+        2. is in the account the VM was deployed in
+        3. Has a linklocalip, publicip and a guestip
+        @return:
+        """
+        routers = Router.list(self.apiclient, account=self.account.name)
+        self.assertTrue(len(routers) > 0, msg="No virtual router found")
+        router = routers[0]
+
+        self.assertEqual(router.state, 'Running', msg="Router is not in running state")
+        self.assertEqual(router.account, self.account.name, msg="Router does not belong to the account")
+
+        # Has linklocal, public and guest ips
+        self.assertIsNotNone(router.linklocalip, msg="Router has no linklocal ip")
+        self.assertIsNotNone(router.publicip, msg="Router has no public ip")
+        self.assertIsNotNone(router.guestipaddress, msg="Router has no guest ip")
+
+    @attr(mode=["basic"], required_hardware="false")
+    def test_basicZoneVirtualRouter(self):
+        # TODO: SIMENH: duplicate test, remove it
+        """
+        Tests for basic zone virtual router
+        1. Is Running
+        2. is in the account the VM was deployed in
+        @return:
+        """
+        routers = Router.list(self.apiclient, account=self.account.name)
+        self.assertTrue(len(routers) > 0, msg="No virtual router found")
+        router = routers[0]
+
+        self.assertEqual(router.state, 'Running', msg="Router is not in running state")
+        self.assertEqual(router.account, self.account.name, msg="Router does not belong to the account")
+
+    @attr(tags=['advanced', 'basic', 'sg'], required_hardware="false")
+    def test_deploy_vm_multiple(self):
+        """Test Multiple Deploy Virtual Machine
+
+        # Validate the following:
+        # 1. deploy 2 virtual machines
+        # 2. listVirtualMachines using 'ids' parameter returns accurate information
+        """
+        account = Account.create(
+            self.apiclient,
+            self.services["account"],
+            domainid=self.domain.id
+        )
+        self.cleanup.append(account)
+
+        virtual_machine1 = VirtualMachine.create(
+            self.apiclient,
+            self.services["small"],
+            accountid=account.name,
+            domainid=account.domainid,
+            serviceofferingid=self.service_offering.id
+        )
+        self.cleanup.append(virtual_machine1)
+        virtual_machine2 = VirtualMachine.create(
+            self.apiclient,
+            self.services["small"],
+            accountid=account.name,
+            domainid=account.domainid,
+            serviceofferingid=self.service_offering.id
+        )
+        self.cleanup.append(virtual_machine2)
+
+        list_vms = VirtualMachine.list(self.apiclient, ids=[virtual_machine1.id, virtual_machine2.id], listAll=True)
+        self.debug(
+            "Verify listVirtualMachines response for virtual machines: %s, %s" % (
+                virtual_machine1.id, virtual_machine2.id)
+        )
+        self.assertEqual(
+            isinstance(list_vms, list),
+            True,
+            "List VM response was not a valid list"
+        )
+        self.assertEqual(
+            len(list_vms),
+            2,
+            "List VM response was empty, expected 2 VMs"
+        )

test/integration/smoke/test_hostha_kvm.py

@@ -79,6 +79,7 @@ def setUp(self):
             self.apiclient,
             self.services["service_offerings"]["hasmall"]
         )
+        self.cleanup = [self.service_offering]
 
         self.template = get_test_template(
             self.apiclient,
@@ -87,7 +88,6 @@ def setUp(self):
         )
 
         self.configureAndDisableHostHa()
-        self.cleanup = [self.service_offering]
 
     def updateConfiguration(self, name, value):
         cmd = updateConfiguration.updateConfigurationCmd()
@@ -116,9 +116,10 @@ def tearDown(self):
             self.dbclient.execute("delete from mshost where runid=%s" % self.getFakeMsRunId())
             self.dbclient.execute("delete from cluster_details where name='outOfBandManagementEnabled'")
             self.dbclient.execute("delete from data_center_details where name='outOfBandManagementEnabled'")
-            cleanup_resources(self.apiclient, self.cleanup)
         except Exception as e:
             raise Exception("Warning: Exception during cleanup : %s" % e)
+        finally:
+            super(TestHAKVM, self).tearDown()
 
     def getHostHaEnableCmd(self):
         cmd = enableHAForHost.enableHAForHostCmd()
@@ -292,7 +293,6 @@ def test_hostha_enable_ha_when_host_in_maintenance(self):
         # Enable HA
         self.configureAndEnableHostHa()
 
-
         # Prepare for maintenance Host
         self.setHostToMaintanance(self.host.id)
 
@@ -341,7 +341,6 @@ def test_remove_ha_provider_not_possible(self):
         """
         self.logger.debug("Starting test_remove_ha_provider_not_possible")
 
-
         # Enable HA
         self.apiclient.configureHAForHost(self.getHostHaConfigCmd())
         cmd = self.getHostHaEnableCmd()
@@ -393,7 +392,6 @@ def test_hostha_kvm_host_degraded(self):
         self.startAgent()
         self.waitUntilHostInState("Available")
 
-
     @attr(tags=["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
     def test_hostha_kvm_host_recovering(self):
         """
@@ -581,7 +579,6 @@ def getIpmiServerIp(self):
         return s.getsockname()[0]
 
     def get_non_configured_ha_host(self):
-
         response = list_hosts(
             self.apiclient,
             type='Routing'