adding initial smoke test

Author: nathanejohnson

test/integration/smoke/test_deploy_virtio_scsi_vm.py

@@ -0,0 +1,216 @@
+# 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.
+
+# Test from the Marvin - Testing in Python wiki
+
+# All tests inherit from cloudstackTestCase
+from marvin.cloudstackTestCase import cloudstackTestCase
+
+# Import Integration Libraries
+
+# base - contains all resources as entities and defines create, delete,
+# list operations on them
+from marvin.lib.base import (Account,
+                            VirtualMachine,
+                            ServiceOffering,
+                            NetworkOffering,
+                            Network,
+                            Template,
+                            DiskOffering,
+                            StoragePool,
+                            Volume)
+
+# utils - utility classes for common cleanup, external library wrappers etc
+from marvin.lib.utils import cleanup_resources, get_hypervisor_type, validateList
+
+# common - commonly used methods for all tests are listed here
+from marvin.lib.common import get_zone, get_domain, get_template, list_hosts, get_pod
+
+from marvin.sshClient import SshClient
+
+from marvin.codes import FAILED, PASS
+
+from nose.plugins.attrib import attr
+
+import xml.etree.ElementTree as ET
+
+class Templates:
+    """Test data for templates
+    """
+
+    def __init__(self):
+        self.templates = {
+            "kvmvirtioscsi": {
+                "kvm": {
+                    "name": "tiny-kvm-scsi",
+                    "displaytext": "virtio-scsi kvm",
+                    "format": "qcow2",
+                    "hypervisor": "kvm",
+                    "ostype": "Other PV Virtio-SCSI (64-bit)",
+                    "url": "http://dl.openvm.eu/cloudstack/ubuntu/vanilla/16.04/x86_64/ubuntu-16.04-server-cloudimg-amd64-disk1-kvm.qcow2.bz2",
+                    "requireshvm": "True",
+                    "ispublic": "True",
+                }
+            }
+        }
+
+class TestDeployVirtioSCSIVM(cloudstackTestCase):
+
+    """
+    Test deploy a vGPU enabled VM into a user account
+    """
+    @classmethod
+    def setUpClass(cls):
+        testClient = super(TestDeployVirtioSCSIVM, cls).getClsTestClient()
+        cls.apiclient = testClient.getApiClient()
+        cls.services = cls.testClient.getParsedTestDataConfig()
+        cls.hostConfig = cls.config.__dict__["zones"][0].__dict__["pods"][0].__dict__["clusters"][0].__dict__["hosts"][0].__dict__
+        cls.hypervisorNotSupported = False
+        cls.hypervisor = testClient.getHypervisorInfo()
+
+        # Get Zone, Domain and templates
+        cls.domain = get_domain(cls.apiclient)
+        cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests())
+        cls.pod = get_pod(cls.apiclient, cls.zone.id)
+        cls.services['mode'] = cls.zone.networktype
+        if cls.hypervisor.lower() not in ['kvm']:
+            cls.hypervisorNotSupported = True
+
+        cls._cleanup = []
+        if not cls.hypervisorNotSupported:
+            kvmvirtioscsi = Templates().templates["kvmvirtioscsi"]
+            cls.template = Template.register(cls.apiclient, kvmvirtioscsi[cls.hypervisor.lower()],
+                        cls.zone.id, hypervisor=cls.hypervisor.lower(), domainid=cls.domain.id)
+            cls.template.download(cls.apiclient)
+
+            if cls.template == FAILED:
+                assert False, "get_template() failed to return template"
+
+            # Create VMs, NAT Rules etc
+            cls.account = Account.create(
+                cls.apiclient,
+                cls.services["account"],
+                domainid=cls.domain.id
+            )
+            cls.service_offering = ServiceOffering.create(
+                cls.apiclient,
+                cls.services["service_offerings"]["tiny"]
+            )
+            cls.virtual_machine = VirtualMachine.create(
+                cls.apiclient,
+                cls.services["small"],
+                templateid=cls.template.id,
+                accountid=cls.account.name,
+                domainid=cls.account.domainid,
+                zoneid=cls.zone.id,
+                serviceofferingid=cls.service_offering.id,
+                mode=cls.services["mode"]
+            )
+
+            cls.sparse_disk_offering = DiskOffering.create(
+                cls.apiclient,
+                cls.services["sparse_disk_offering"]
+            )
+
+            cls.volume = Volume.create(
+                cls.apiclient,
+                cls.services,
+                zoneid=cls.zone.id,
+                account=cls.account.name,
+                domainid=cls.account.domainid,
+                diskofferingid=cls.sparse_disk_offering.id
+            )
+
+            cls.virtual_machine.attach_volume(
+                cls.apiclient,
+                cls.volume
+            )
+
+            cls._cleanup.append(cls.template)
+            cls._cleanup.append(cls.service_offering)
+            cls._cleanup.append(cls.sparse_disk_offering)
+            cls._cleanup.append(cls.account)
+
+            host = cls.virtual_machine.hostname
+            instancename = cls.virtual_machine.instancename
+
+            sshClient = SshClient(
+                host=host,
+                port=cls.services['configurableData']['host']["publicport"],
+                user=cls.hostConfig['username'],
+                passwd=cls.hostConfig['password'])
+            cls.virshxml = "\n".join(sshClient.execute("virsh dumpxml "+ instancename))
+
+    @classmethod
+    def tearDownClass(cls):
+        try:
+            # Cleanup resources used
+            cleanup_resources(cls.apiclient, cls._cleanup)
+        except Exception as e:
+            raise Exception("Warning: Exception during cleanup : %s" % e)
+        return
+
+    def setUp(self):
+        self.apiclient = self.testClient.getApiClient()
+        self.dbclient = self.testClient.getDbConnection()
+        self.cleanup = []
+        return
+
+    def tearDown(self):
+        try:
+            # Clean up, terminate the created instance, volumes and snapshots
+            cleanup_resources(self.apiclient, self.cleanup)
+        except Exception as e:
+            raise Exception("Warning: Exception during cleanup : %s" % e)
+        return
+
+
+
+    @attr(tags=["advanced", "advancedns", "smoke"], required_hardware="true")
+    def test_01_verify_libvirt(self):
+        """Test that libvirt properly created domain with scsi controller
+        """
+
+        # Validate virsh dumpxml
+        if self.hypervisorNotSupported:
+            self.skipTest
+
+        root = ET.fromstring(self.virshxml)
+
+        scsis = root.findall("./devices/controller[@type='scsi']/alias[@name='scsi0']/..")
+
+        self.assertEqual(len(scsis), 1, "SCSI controller not found")
+
+        scsiindex = scsis[0].get('index')
+        self.assertNotEqual(scsiindex, None, "Could not find index of SCSI controller")
+
+        # find all scsi disks
+        disks = root.findall("./devices/disk[@device='disk']/target[@bus='scsi']/..")
+
+        self.assertEqual(len(disks), 2, "Could not find two disks")
+
+        for disk in disks:
+            for child in disk:
+                if child.tag.lower() == "target":
+                    dev = child.get("dev")
+                    self.assert_(dev != None and dev.startswith("sd"), "disk dev is invalid")
+                elif child.tag.lower() == "address":
+                    con = child.get("controller")
+                    self.assertEqual(con, scsiindex, "disk controller not equal to SCSI " \
+                                     "controller index")
+
+