# pylint: disable=invalid-name

#
# The Qubes OS Project, https://www.qubes-os.org/
#
# Copyright (C) 2014-2015
#                   Marek Marczykowski-Górecki <marmarek@invisiblethingslab.com>
# Copyright (C) 2015  Wojtek Porczyk <woju@invisiblethingslab.com>
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, see <https://www.gnu.org/licenses/>.
#

from distutils import spawn

import asyncio
import os
import subprocess
import tempfile
import time
import unittest

import collections

import pkg_resources
import shutil

import sys

import qubes
import qubes.firewall
import qubes.tests
import qubes.storage
import qubes.vm.appvm
import qubes.vm.qubesvm
import qubes.vm.standalonevm
import qubes.vm.templatevm

import libvirt  # pylint: disable=import-error


class TC_00_Basic(qubes.tests.SystemTestCase):
    def setUp(self):
        super(TC_00_Basic, self).setUp()
        self.init_default_template()

    def test_000_qubes_create(self):
        self.assertIsInstance(self.app, qubes.Qubes)

    def test_100_qvm_create(self):
        vmname = self.make_vm_name('appvm')

        vm = self.app.add_new_vm(qubes.vm.appvm.AppVM,
            name=vmname, template=self.app.default_template,
            label='red')

        self.assertIsNotNone(vm)
        self.assertEqual(vm.name, vmname)
        self.assertEqual(vm.template, self.app.default_template)
        self.loop.run_until_complete(vm.create_on_disk())

        with self.assertNotRaises(qubes.exc.QubesException):
            self.loop.run_until_complete(vm.storage.verify())

    def test_040_qdb_watch(self):
        flag = set()

        def handler(vm, event, path):
            if path == '/test-watch-path':
                flag.add(True)

        vm = self.app.domains[0]
        vm.watch_qdb_path('/test-watch-path')
        vm.add_handler('domain-qdb-change:/test-watch-path', handler)
        self.assertFalse(flag)
        vm.untrusted_qdb.write('/test-watch-path', 'test-value')
        self.loop.run_until_complete(asyncio.sleep(0.1))
        self.assertTrue(flag)

    @unittest.skipUnless(
        spawn.find_executable('xdotool'), "xdotool not installed")
    def test_120_start_standalone_with_cdrom_dom0(self):
        vmname = self.make_vm_name('appvm')
        self.vm = self.app.add_new_vm('StandaloneVM', label='red', name=vmname)
        self.loop.run_until_complete(self.vm.create_on_disk())
        self.vm.kernel = None
        self.vm.virt_mode = 'hvm'

        iso_path = self.create_bootable_iso()
        # start the VM using qvm-start tool, to test --cdrom option there
        p = self.loop.run_until_complete(asyncio.create_subprocess_exec(
            'qvm-start', '--cdrom=dom0:' + iso_path, self.vm.name,
            stdout=subprocess.PIPE, stderr=subprocess.STDOUT))
        (stdout, _) = self.loop.run_until_complete(p.communicate())
        self.assertEqual(p.returncode, 0, stdout)
        # check if VM do not crash instantly
        self.loop.run_until_complete(asyncio.sleep(5))
        self.assertTrue(self.vm.is_running())
        # Type 'poweroff'
        subprocess.check_call(['xdotool', 'search', '--name', self.vm.name,
                               'type', '--window', '%1', 'poweroff\r'])
        for _ in range(10):
            if not self.vm.is_running():
                break
            self.loop.run_until_complete(asyncio.sleep(1))
        self.assertFalse(self.vm.is_running())

    def test_130_autostart_disable_on_remove(self):
        vm = self.app.add_new_vm(qubes.vm.appvm.AppVM,
            name=self.make_vm_name('vm'),
            template=self.app.default_template,
            label='red')

        self.assertIsNotNone(vm)
        self.loop.run_until_complete(vm.create_on_disk())
        vm.autostart = True
        self.assertTrue(os.path.exists(
            '/etc/systemd/system/multi-user.target.wants/'
            'qubes-vm@{}.service'.format(vm.name)),
            "systemd service not enabled by autostart=True")
        del self.app.domains[vm]
        self.loop.run_until_complete(vm.remove_from_disk())
        self.assertFalse(os.path.exists(
            '/etc/systemd/system/multi-user.target.wants/'
            'qubes-vm@{}.service'.format(vm.name)),
            "systemd service not disabled on domain remove")

    def _test_200_on_domain_start(self, vm, event, **_kwargs):
        '''Simulate domain crash just after startup'''
        vm.libvirt_domain.destroy()

    def test_200_shutdown_event_race(self):
        '''Regression test for 3164'''
        vmname = self.make_vm_name('appvm')

        self.vm = self.app.add_new_vm(qubes.vm.appvm.AppVM,
            name=vmname, template=self.app.default_template,
            label='red')
        # help the luck a little - don't wait for qrexec to easier win the race
        self.vm.features['qrexec'] = False
        self.loop.run_until_complete(self.vm.create_on_disk())
        # another way to help the luck a little - make sure the private
        # volume is first in (normally unordered) dict - this way if any
        # volume action fails, it will be at or after private volume - not
        # before (preventing private volume action)
        old_volumes = self.vm.volumes
        self.vm.volumes = collections.OrderedDict()
        self.vm.volumes['private'] = old_volumes.pop('private')
        self.vm.volumes.update(old_volumes.items())
        del old_volumes

        self.loop.run_until_complete(self.vm.start())

        # kill it the way it does not give a chance for domain-shutdown it
        # execute
        self.vm.libvirt_domain.destroy()

        # now, lets try to start the VM again, before domain-shutdown event
        # got handled (#3164), and immediately trigger second domain-shutdown
        self.vm.add_handler('domain-start', self._test_200_on_domain_start)
        self.loop.run_until_complete(self.vm.start())

        # and give a chance for both domain-shutdown handlers to execute
        self.loop.run_until_complete(asyncio.sleep(1))
        with self.assertNotRaises(qubes.exc.QubesException):
            # if the above caused two domain-shutdown handlers being called
            # one after another, private volume is gone
            self.loop.run_until_complete(self.vm.storage.verify())

    def _test_201_on_domain_pre_start(self, vm, event, **_kwargs):
        '''Simulate domain crash just after startup'''
        if not self.domain_shutdown_handled and not self.test_failure_reason:
            self.test_failure_reason = \
                'domain-shutdown event was not dispatched before subsequent ' \
                'start'
        self.domain_shutdown_handled = False

    def _test_201_domain_shutdown_handler(self, vm, event, **kwargs):
        if self.domain_shutdown_handled and not self.test_failure_reason:
            self.test_failure_reason = 'domain-shutdown event received twice'
        self.domain_shutdown_handled = True

    def test_201_shutdown_event_race(self):
        '''Regression test for 3164 - pure events edition'''
        vmname = self.make_vm_name('appvm')

        self.vm = self.app.add_new_vm(qubes.vm.appvm.AppVM,
            name=vmname, template=self.app.default_template,
            label='red')
        # help the luck a little - don't wait for qrexec to easier win the race
        self.vm.features['qrexec'] = False
        self.loop.run_until_complete(self.vm.create_on_disk())

        # do not throw exception from inside event handler - test framework
        # will not recover from it (various objects leaks)
        self.test_failure_reason = None
        self.domain_shutdown_handled = False
        self.vm.add_handler('domain-shutdown',
            self._test_201_domain_shutdown_handler)

        self.loop.run_until_complete(self.vm.start())

        if self.test_failure_reason:
            self.fail(self.test_failure_reason)

        self.vm.add_handler('domain-pre-start',
            self._test_201_on_domain_pre_start)

        # kill it the way it does not give a chance for domain-shutdown it
        # execute
        self.vm.libvirt_domain.destroy()

        # now, lets try to start the VM again, before domain-shutdown event
        # got handled (#3164), and immediately trigger second domain-shutdown
        self.vm.add_handler('domain-start', self._test_200_on_domain_start)
        self.loop.run_until_complete(self.vm.start())

        if self.test_failure_reason:
            self.fail(self.test_failure_reason)

        while self.vm.get_power_state() != 'Halted':
            self.loop.run_until_complete(asyncio.sleep(1))
        # and give a chance for both domain-shutdown handlers to execute
        self.loop.run_until_complete(asyncio.sleep(3))
        # wait for running shutdown handler to complete
        self.loop.run_until_complete(self.vm._domain_stopped_lock.acquire())
        self.vm._domain_stopped_lock.release()

        if self.test_failure_reason:
            self.fail(self.test_failure_reason)

        self.assertTrue(self.domain_shutdown_handled,
            'second domain-shutdown event was not dispatched after domain '
            'shutdown')

    def _check_udev_for_uuid(self, uuid_value):
        udev_data_path = '/run/udev/data'
        for udev_item in os.listdir(udev_data_path):
            # check only block devices
            if not udev_item.startswith('b'):
                continue
            with open(os.path.join(udev_data_path, udev_item)) as udev_file:
                self.assertNotIn(uuid_value, udev_file.read(),
                    'udev parsed filesystem UUID! ' + udev_item)

    def assertVolumesExcludedFromUdev(self, vm):
        try:
            # first boot, mkfs private volume
            self.loop.run_until_complete(vm.start())
            self.loop.run_until_complete(self.wait_for_session(vm))
            # get private volume UUID
            private_uuid, _ = self.loop.run_until_complete(
                vm.run_for_stdio('blkid -o value /dev/xvdb', user='root'))
            private_uuid = private_uuid.decode().splitlines()[0]

            # now check if dom0 udev know about it - it shouldn't
            self._check_udev_for_uuid(private_uuid)

            # now restart the VM and check again
            self.loop.run_until_complete(vm.shutdown(wait=True))
            self.loop.run_until_complete(vm.start())

            self._check_udev_for_uuid(private_uuid)
        finally:
            del vm

    def _test_140_on_domain_paused(self, vm, event, **kwargs):
        self.domain_paused_received = True

    def test_140_libvirt_events_reconnect(self):
        vmname = self.make_vm_name('vm')

        self.vm = self.app.add_new_vm(qubes.vm.appvm.AppVM,
            name=vmname, template=self.app.default_template,
            label='red')
        self.loop.run_until_complete(self.vm.create_on_disk())
        self.loop.run_until_complete(self.vm.start())
        p = self.loop.run_until_complete(asyncio.create_subprocess_exec(
            'systemctl', 'restart', 'libvirtd'))
        self.loop.run_until_complete(p.communicate())
        # check if events still works
        self.domain_paused_received = False
        self.vm.add_handler('domain-paused', self._test_140_on_domain_paused)
        self.loop.run_until_complete(self.vm.pause())
        self.loop.run_until_complete(self.vm.kill())
        self.loop.run_until_complete(asyncio.sleep(1))
        self.assertTrue(self.domain_paused_received,
            'event not received after libvirt restart')

    def test_141_libvirt_objects_reconnect(self):
        vmname = self.make_vm_name('vm')

        # make sure libvirt object is cached
        self.app.domains[0].libvirt_domain.isActive()
        p = self.loop.run_until_complete(asyncio.create_subprocess_exec(
            'systemctl', 'restart', 'libvirtd'))
        self.loop.run_until_complete(p.communicate())
        # trigger reconnect
        with self.assertNotRaises(libvirt.libvirtError):
            self.app.vmm.libvirt_conn.getHostname()

        # check if vm object still works
        with self.assertNotRaises(libvirt.libvirtError):
            self.app.domains[0].libvirt_domain.isActive()

    def test_202_udev_block_exclude_default(self):
        '''Check if VM images are excluded from udev parsing -
        default volume pool'''
        vmname = self.make_vm_name('appvm')

        self.vm = self.app.add_new_vm(qubes.vm.appvm.AppVM,
            name=vmname, template=self.app.default_template,
            label='red')
        self.loop.run_until_complete(self.vm.create_on_disk())
        self.assertVolumesExcludedFromUdev(self.vm)

    def test_203_udev_block_exclude_varlibqubes(self):
        '''Check if VM images are excluded from udev parsing -
        varlibqubes pool'''
        vmname = self.make_vm_name('appvm')

        self.vm = self.app.add_new_vm(qubes.vm.appvm.AppVM,
            name=vmname, template=self.app.default_template,
            label='red')
        self.loop.run_until_complete(self.vm.create_on_disk(
            pool=self.app.pools['varlibqubes']))
        self.assertVolumesExcludedFromUdev(self.vm)

    def test_204_udev_block_exclude_custom_file(self):
        '''Check if VM images are excluded from udev parsing -
        custom file pool'''
        vmname = self.make_vm_name('appvm')

        pool_path = tempfile.mkdtemp(
            prefix='qubes-pool-', dir='/var/tmp')
        self.addCleanup(shutil.rmtree, pool_path)
        pool = self.loop.run_until_complete(
            self.app.add_pool('test-filep', dir_path=pool_path, driver='file'))

        self.vm = self.app.add_new_vm(qubes.vm.appvm.AppVM,
            name=vmname, template=self.app.default_template,
            label='red')
        self.loop.run_until_complete(self.vm.create_on_disk(
            pool=pool))
        self.assertVolumesExcludedFromUdev(self.vm)


class TC_01_Properties(qubes.tests.SystemTestCase):
    # pylint: disable=attribute-defined-outside-init
    def setUp(self):
        super(TC_01_Properties, self).setUp()
        self.init_default_template()
        self.vmname = self.make_vm_name('appvm')
        self.vm = self.app.add_new_vm(qubes.vm.appvm.AppVM, name=self.vmname,
                                      template=self.app.default_template,
                                      label='red')
        self.loop.run_until_complete(self.vm.create_on_disk())
        self.addCleanup(self.cleanup_props)

    def cleanup_props(self):
        del self.vm

    def test_030_clone(self):
        try:
            testvm1 = self.app.add_new_vm(
                qubes.vm.appvm.AppVM,
                name=self.make_vm_name("vm"),
                template=self.app.default_template,
                label='red')
            self.loop.run_until_complete(testvm1.create_on_disk())
            testvm2 = self.app.add_new_vm(testvm1.__class__,
                                        name=self.make_vm_name("clone"),
                                        template=testvm1.template,
                                        label='red')
            testvm2.clone_properties(testvm1)
            testvm2.firewall.clone(testvm1.firewall)
            self.loop.run_until_complete(testvm2.clone_disk_files(testvm1))
            self.assertTrue(self.loop.run_until_complete(testvm1.storage.verify()))
            self.assertIn('source', testvm1.volumes['root'].config)
            self.assertNotEquals(testvm2, None)
            self.assertNotEquals(testvm2.volumes, {})
            self.assertIn('source', testvm2.volumes['root'].config)

            # qubes.xml reload
            self.app.save()
            testvm1 = self.app.domains[testvm1.qid]
            testvm2 = self.app.domains[testvm2.qid]

            self.assertEqual(testvm1.label, testvm2.label)
            self.assertEqual(testvm1.netvm, testvm2.netvm)
            self.assertEqual(testvm1.property_is_default('netvm'),
                            testvm2.property_is_default('netvm'))
            self.assertEqual(testvm1.kernel, testvm2.kernel)
            self.assertEqual(testvm1.kernelopts, testvm2.kernelopts)
            self.assertEqual(testvm1.property_is_default('kernel'),
                            testvm2.property_is_default('kernel'))
            self.assertEqual(testvm1.property_is_default('kernelopts'),
                            testvm2.property_is_default('kernelopts'))
            self.assertEqual(testvm1.memory, testvm2.memory)
            self.assertEqual(testvm1.maxmem, testvm2.maxmem)
            self.assertEqual(testvm1.devices, testvm2.devices)
            self.assertEqual(testvm1.include_in_backups,
                            testvm2.include_in_backups)
            self.assertEqual(testvm1.default_user, testvm2.default_user)
            self.assertEqual(testvm1.features, testvm2.features)
            self.assertEqual(testvm1.firewall.rules,
                            testvm2.firewall.rules)

            # now some non-default values
            testvm1.netvm = None
            testvm1.label = 'orange'
            testvm1.memory = 512
            firewall = testvm1.firewall
            firewall.rules = [
                qubes.firewall.Rule(None, action='accept', dsthost='1.2.3.0/24',
                    proto='tcp', dstports=22)]
            firewall.save()

            testvm3 = self.app.add_new_vm(testvm1.__class__,
                                        name=self.make_vm_name("clone2"),
                                        template=testvm1.template,
                                        label='red',)
            testvm3.clone_properties(testvm1)
            testvm3.firewall.clone(testvm1.firewall)
            self.loop.run_until_complete(testvm3.clone_disk_files(testvm1))

            # qubes.xml reload
            self.app.save()
            testvm1 = self.app.domains[testvm1.qid]
            testvm3 = self.app.domains[testvm3.qid]

            self.assertEqual(testvm1.label, testvm3.label)
            self.assertEqual(testvm1.netvm, testvm3.netvm)
            self.assertEqual(testvm1.property_is_default('netvm'),
                            testvm3.property_is_default('netvm'))
            self.assertEqual(testvm1.kernel, testvm3.kernel)
            self.assertEqual(testvm1.kernelopts, testvm3.kernelopts)
            self.assertEqual(testvm1.property_is_default('kernel'),
                            testvm3.property_is_default('kernel'))
            self.assertEqual(testvm1.property_is_default('kernelopts'),
                            testvm3.property_is_default('kernelopts'))
            self.assertEqual(testvm1.memory, testvm3.memory)
            self.assertEqual(testvm1.maxmem, testvm3.maxmem)
            self.assertEqual(testvm1.devices, testvm3.devices)
            self.assertEqual(testvm1.include_in_backups,
                            testvm3.include_in_backups)
            self.assertEqual(testvm1.default_user, testvm3.default_user)
            self.assertEqual(testvm1.features, testvm3.features)
            self.assertEqual(testvm1.firewall.rules,
                            testvm3.firewall.rules)
        finally:
            try:
                del firewall
            except NameError:
                pass
            try:
                del testvm1
            except NameError:
                pass
            try:
                del testvm2
            except NameError:
                pass
            try:
                del testvm3
            except NameError:
                pass

    def test_020_name_conflict_app(self):
        # TODO decide what exception should be here
        with self.assertRaises((qubes.exc.QubesException, ValueError)):
            self.vm2 = self.app.add_new_vm(qubes.vm.appvm.AppVM,
                name=self.vmname, template=self.app.default_template,
                label='red')
            self.loop.run_until_complete(self.vm2.create_on_disk())

    def test_021_name_conflict_template(self):
        # TODO decide what exception should be here
        with self.assertRaises((qubes.exc.QubesException, ValueError)):
            self.vm2 = self.app.add_new_vm(qubes.vm.templatevm.TemplateVM,
                name=self.vmname, label='red')
            self.loop.run_until_complete(self.vm2.create_on_disk())


class TC_03_QvmRevertTemplateChanges(qubes.tests.SystemTestCase):
    # pylint: disable=attribute-defined-outside-init

    def setUp(self):
        super(TC_03_QvmRevertTemplateChanges, self).setUp()
        self.init_default_template()

    def cleanup_template(self):
        del self.test_template

    def setup_template(self):
        self.test_template = self.app.add_new_vm(
            qubes.vm.templatevm.TemplateVM,
            name=self.make_vm_name("pv-clone"),
            label='red'
        )
        self.addCleanup(self.cleanup_template)
        self.test_template.clone_properties(self.app.default_template)
        self.test_template.features.update(self.app.default_template.features)
        self.test_template.tags.update(self.app.default_template.tags)
        self.loop.run_until_complete(
            self.test_template.clone_disk_files(self.app.default_template))
        self.test_template.volumes['root'].revisions_to_keep = 3
        self.app.save()

    def get_rootimg_checksum(self):
        return subprocess.check_output(
            ['sha1sum', self.test_template.volumes['root'].export()]).\
            decode().split(' ')[0]

    def _do_test(self):
        checksum_before = self.get_rootimg_checksum()
        self.loop.run_until_complete(self.test_template.start())
        self.loop.run_until_complete(self.wait_for_session(self.test_template))
        self.shutdown_and_wait(self.test_template)
        checksum_changed = self.get_rootimg_checksum()
        if checksum_before == checksum_changed:
            self.log.warning("template not modified, test result will be "
                             "unreliable")
        self.assertNotEqual(self.test_template.volumes['root'].revisions, {})
        revert_cmd = ['qvm-volume', 'revert', self.test_template.name + ':root']
        p = self.loop.run_until_complete(asyncio.create_subprocess_exec(
            *revert_cmd))
        self.loop.run_until_complete(p.wait())
        self.assertEqual(p.returncode, 0)
        del p

        checksum_after = self.get_rootimg_checksum()
        self.assertEqual(checksum_before, checksum_after)

    def test_000_revert_linux(self):
        """
        Test qvm-revert-template-changes for PV template
        """
        self.setup_template()
        self._do_test()

    @unittest.skip('TODO: some non-linux system')
    def test_001_revert_non_linux(self):
        """
        Test qvm-revert-template-changes for HVM template
        """
        # TODO: have some system there, so the root.img will get modified
        self.setup_template()
        self._do_test()

class TC_30_Gui_daemon(qubes.tests.SystemTestCase):
    def setUp(self):
        super(TC_30_Gui_daemon, self).setUp()
        self.init_default_template()

    @unittest.skipUnless(
        spawn.find_executable('xdotool'),
                         "xdotool not installed")
    def test_000_clipboard(self):
        testvm1 = self.app.add_new_vm(qubes.vm.appvm.AppVM,
                                     name=self.make_vm_name('vm1'), label='red')
        self.loop.run_until_complete(testvm1.create_on_disk())
        testvm2 = self.app.add_new_vm(qubes.vm.appvm.AppVM,
                                     name=self.make_vm_name('vm2'), label='red')
        self.loop.run_until_complete(testvm2.create_on_disk())
        self.app.save()

        self.loop.run_until_complete(asyncio.wait([
            testvm1.start(),
            testvm2.start()]))
        self.loop.run_until_complete(asyncio.wait([
            self.wait_for_session(testvm1),
            self.wait_for_session(testvm2)]))
        window_title = 'user@{}'.format(testvm1.name)
        self.loop.run_until_complete(testvm1.run(
            'zenity --text-info --editable --title={}'.format(window_title)))

        self.wait_for_window(window_title)
        time.sleep(0.5)
        test_string = "test{}".format(testvm1.xid)

        # Type and copy some text
        subprocess.check_call(['xdotool', 'search', '--name', window_title,
                               'windowactivate', '--sync',
                               'type', test_string])
        # second xdotool call because type --terminator do not work (SEGV)
        # additionally do not use search here, so window stack will be empty
        # and xdotool will use XTEST instead of generating events manually -
        # this will be much better - at least because events will have
        # correct timestamp (so gui-daemon would not drop the copy request)
        subprocess.check_call(['xdotool',
                               'key', 'ctrl+a', 'ctrl+c', 'ctrl+shift+c',
                               'Escape'])

        clipboard_content = \
            open('/var/run/qubes/qubes-clipboard.bin', 'r').read().strip()
        self.assertEqual(clipboard_content, test_string,
                          "Clipboard copy operation failed - content")
        clipboard_source = \
            open('/var/run/qubes/qubes-clipboard.bin.source',
                 'r').read().strip()
        self.assertEqual(clipboard_source, testvm1.name,
                          "Clipboard copy operation failed - owner")

        # Then paste it to the other window
        window_title = 'user@{}'.format(testvm2.name)
        p = self.loop.run_until_complete(testvm2.run(
            'zenity --entry --title={} > /tmp/test.txt'.format(window_title)))
        self.wait_for_window(window_title)

        subprocess.check_call(['xdotool', 'key', '--delay', '100',
                               'ctrl+shift+v', 'ctrl+v', 'Return'])
        self.loop.run_until_complete(p.wait())

        # And compare the result
        (test_output, _) = self.loop.run_until_complete(
            testvm2.run_for_stdio('cat /tmp/test.txt'))
        self.assertEqual(test_string, test_output.strip().decode('ascii'))

        clipboard_content = \
            open('/var/run/qubes/qubes-clipboard.bin', 'r').read().strip()
        self.assertEqual(clipboard_content, "",
                          "Clipboard not wiped after paste - content")
        clipboard_source = \
            open('/var/run/qubes/qubes-clipboard.bin.source', 'r').\
            read().strip()
        self.assertEqual(clipboard_source, "",
                          "Clipboard not wiped after paste - owner")

class TC_05_StandaloneVMMixin(object):
    def setUp(self):
        super(TC_05_StandaloneVMMixin, self).setUp()
        self.init_default_template(self.template)

    def test_000_create_start(self):
        self.testvm1 = self.app.add_new_vm(qubes.vm.standalonevm.StandaloneVM,
                                     name=self.make_vm_name('vm1'), label='red')
        self.testvm1.features.update(self.app.default_template.features)
        self.loop.run_until_complete(
            self.testvm1.clone_disk_files(self.app.default_template))
        self.app.save()
        self.loop.run_until_complete(self.testvm1.start())
        self.assertEqual(self.testvm1.get_power_state(), "Running")

    def test_100_resize_root_img(self):
        self.testvm1 = self.app.add_new_vm(qubes.vm.standalonevm.StandaloneVM,
                                     name=self.make_vm_name('vm1'), label='red')
        self.testvm1.features.update(self.app.default_template.features)
        self.loop.run_until_complete(
            self.testvm1.clone_disk_files(self.app.default_template))
        self.app.save()
        try:
            self.loop.run_until_complete(
                self.testvm1.storage.resize(self.testvm1.volumes['root'],
                    20 * 1024 ** 3))
        except (subprocess.CalledProcessError,
                qubes.storage.StoragePoolException) as e:
            # exception object would leak VM reference
            self.fail(str(e))
        self.assertEqual(self.testvm1.volumes['root'].size, 20 * 1024 ** 3)
        self.loop.run_until_complete(self.testvm1.start())
        # new_size in 1k-blocks
        (new_size, _) = self.loop.run_until_complete(
            self.testvm1.run_for_stdio('df --output=size /|tail -n 1'))
        # some safety margin for FS metadata
        self.assertGreater(int(new_size.strip()), 19 * 1024 ** 2)

    def test_101_resize_root_img_online(self):
        self.testvm1 = self.app.add_new_vm(qubes.vm.standalonevm.StandaloneVM,
                                     name=self.make_vm_name('vm1'), label='red')
        self.testvm1.features['qrexec'] = True
        self.loop.run_until_complete(
            self.testvm1.clone_disk_files(self.app.default_template))
        self.testvm1.features.update(self.app.default_template.features)
        self.app.save()
        self.loop.run_until_complete(self.testvm1.start())
        try:
            self.loop.run_until_complete(
                self.testvm1.storage.resize(self.testvm1.volumes['root'],
                    20 * 1024 ** 3))
        except (subprocess.CalledProcessError,
                qubes.storage.StoragePoolException) as e:
            # exception object would leak VM reference
            self.fail(str(e))
        self.assertEqual(self.testvm1.volumes['root'].size, 20 * 1024 ** 3)
        # new_size in 1k-blocks
        (new_size, _) = self.loop.run_until_complete(
            self.testvm1.run_for_stdio('df --output=size /|tail -n 1'))
        # some safety margin for FS metadata
        self.assertGreater(int(new_size.strip()), 19 * 1024 ** 2)

class TC_06_AppVMMixin(object):
    template = None

    def setUp(self):
        super(TC_06_AppVMMixin, self).setUp()
        self.init_default_template(self.template)

    @unittest.skipUnless(
        spawn.find_executable('xdotool'), "xdotool not installed")
    def test_121_start_standalone_with_cdrom_vm(self):
        cdrom_vmname = self.make_vm_name('cdrom')
        self.cdrom_vm = self.app.add_new_vm('AppVM', label='red',
            name=cdrom_vmname)
        self.loop.run_until_complete(self.cdrom_vm.create_on_disk())
        self.loop.run_until_complete(self.cdrom_vm.start())
        iso_path = self.create_bootable_iso()
        with open(iso_path, 'rb') as iso_f:
            self.loop.run_until_complete(
                self.cdrom_vm.run_for_stdio('cat > /home/user/boot.iso',
                stdin=iso_f))

        vmname = self.make_vm_name('appvm')
        self.vm = self.app.add_new_vm('StandaloneVM', label='red', name=vmname)
        self.loop.run_until_complete(self.vm.create_on_disk())
        self.vm.kernel = None
        self.vm.virt_mode = 'hvm'

        # start the VM using qvm-start tool, to test --cdrom option there
        p = self.loop.run_until_complete(asyncio.create_subprocess_exec(
            'qvm-start', '--cdrom=' + cdrom_vmname + ':/home/user/boot.iso',
            self.vm.name,
            stdout=subprocess.PIPE, stderr=subprocess.STDOUT))
        (stdout, _) = self.loop.run_until_complete(p.communicate())
        self.assertEqual(p.returncode, 0, stdout)
        # check if VM do not crash instantly
        self.loop.run_until_complete(asyncio.sleep(5))
        self.assertTrue(self.vm.is_running())
        # Type 'poweroff'
        subprocess.check_call(['xdotool', 'search', '--name', self.vm.name,
                               'type', '--window', '%1', 'poweroff\r'])
        for _ in range(10):
            if not self.vm.is_running():
                break
            self.loop.run_until_complete(asyncio.sleep(1))
        self.assertFalse(self.vm.is_running())

def create_testcases_for_templates():
    yield from qubes.tests.create_testcases_for_templates('TC_05_StandaloneVM',
            TC_05_StandaloneVMMixin, qubes.tests.SystemTestCase,
            module=sys.modules[__name__])
    yield from qubes.tests.create_testcases_for_templates('TC_06_AppVM',
            TC_06_AppVMMixin, qubes.tests.SystemTestCase,
            module=sys.modules[__name__])

def load_tests(loader, tests, pattern):
    tests.addTests(loader.loadTestsFromNames(
        create_testcases_for_templates()))

    return tests

qubes.tests.maybe_create_testcases_on_import(create_testcases_for_templates)

# vim: ts=4 sw=4 et