manager/qubesmanager/tests/test_global_settings.py

#!/usr/bin/python3
#
# The Qubes OS Project, https://www.qubes-os.org/
#
# Copyright (C) 2016 Marta Marczykowska-Górecka
#                                       <marmarta@invisiblethingslab.com>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License along
# with this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
#
import logging.handlers
import quamash
import asyncio
import unittest
import unittest.mock
import gc

from PyQt4 import QtGui, QtTest, QtCore
from qubesadmin import Qubes
import qubesmanager.global_settings as global_settings


class GlobalSettingsTest(unittest.TestCase):
    def setUp(self):
        super(GlobalSettingsTest, self).setUp()

        self.qapp = Qubes()
        self.qtapp = QtGui.QApplication(["test", "-style", "cleanlooks"])
        self.loop = quamash.QEventLoop(self.qtapp)
        self.dialog = global_settings.GlobalSettingsWindow(self.qtapp,
                                                           self.qapp)

        self.setattr_patcher = unittest.mock.patch.object(
            type(self.dialog.qvm_collection), "__setattr__")
        self.setattr_mock = self.setattr_patcher.start()
        self.addCleanup(self.setattr_patcher.stop)

    def tearDown(self):
        # process any pending events before destroying the object
        self.qtapp.processEvents()

        # queue destroying the QApplication object, do that for any other QT
        # related objects here too
        self.qtapp.deleteLater()
        self.dialog.deleteLater()

        # process any pending events (other than just queued destroy),
        # just in case
        self.qtapp.processEvents()

        # execute main loop, which will process all events, _
        # including just queued destroy_
        self.loop.run_until_complete(asyncio.sleep(0))

        # at this point it QT objects are destroyed, cleanup all remaining
        # references;
        # del other QT object here too
        self.loop.close()
        del self.dialog
        del self.qtapp
        del self.loop
        gc.collect()
        super(GlobalSettingsTest, self).tearDown()

    def test_00_settings_started(self):
        # non-empty drop-downs
        self.assertNotEqual(
            self.dialog.default_kernel_combo.currentText(), "",
            "Default kernel not listed")
        self.assertNotEqual(
            self.dialog.default_netvm_combo.currentText(), "",
            "Default netVM not listed")
        self.assertNotEqual(
            self.dialog.default_template_combo.currentText(),
            "", "Default template not listed")
        self.assertNotEqual(
            self.dialog.clock_vm_combo.currentText(), "",
            "ClockVM not listed")
        self.assertNotEqual(
            self.dialog.update_vm_combo.currentText(), "",
            "UpdateVM for dom0 not listed")
        self.assertNotEqual(
            self.dialog.default_dispvm_combo.currentText(), "",
            "Default DispVM not listed")

        # not empty memory settings
        self.assertTrue(len(self.dialog.min_vm_mem.text()) > 4,
                        "Too short min mem value")
        self.assertTrue(len(self.dialog.dom0_mem_boost.text()) > 4,
                        "Too short dom0 mem boost value")

    def test_01_load_correct_defs(self):
        # correctly selected default template
        selected_default_template = \
            self.dialog.default_template_combo.currentText()
        self.assertTrue(
            selected_default_template.startswith(
                str(getattr(self.qapp, 'default_template', '(none)'))),
            "Incorrect default template loaded")

        # correctly selected default NetVM
        selected_default_netvm = self.dialog.default_netvm_combo.currentText()
        self.assertTrue(selected_default_netvm.startswith(
            str(getattr(self.qapp, 'default_netvm', '(none)'))),
            "Incorrect default netVM loaded")

        # correctly selected default kernel
        selected_default_kernel = self.dialog.default_kernel_combo.currentText()
        self.assertTrue(selected_default_kernel.startswith(
            str(getattr(self.qapp, 'default_kernel', '(none)'))),
            "Incorrect default kernel loaded")

        # correct ClockVM
        selected_clockvm = self.dialog.clock_vm_combo.currentText()
        correct_clockvm = str(getattr(self.qapp, 'clockvm', "(none)"))
        self.assertTrue(selected_clockvm.startswith(correct_clockvm),
                        "Incorrect clockVM loaded")

        # correct updateVM
        selected_updatevm = self.dialog.update_vm_combo.currentText()
        correct_updatevm = str(getattr(self.qapp, 'updatevm', "(none)"))
        self.assertTrue(selected_updatevm.startswith(correct_updatevm),
                        "Incorrect updateVm loaded")

        # correct defaultDispVM
        selected_default_dispvm = self.dialog.default_dispvm_combo.currentText()
        correct_default_dispvm = \
            str(getattr(self.qapp, 'default_dispvm', "(none)"))
        self.assertTrue(
            selected_default_dispvm.startswith(correct_default_dispvm),
            "Incorrect defaultDispVM loaded")

        # update vm status
        self.assertEqual(self.qapp.check_updates_vm,
                         self.dialog.updates_vm.isChecked(),
                         "Incorrect check qube updates value loaded")

    def test_02_dom0_updates_load(self):
        # check dom0 updates
        try:
            dom0_updates = self.qapp.domains[
                'dom0'].features['service.qubes-update-check']
        except KeyError:
            self.skipTest("check_updates_dom0 property not implemented")
            return

        self.assertEqual(bool(dom0_updates),
                         self.dialog.updates_dom0.isChecked(),
                         "Incorrect dom0 updates value")

    def __set_noncurrent(self, widget):
        if widget.count() < 2:
            self.skipTest("not enough choices for " + widget.objectName())

        widget.setCurrentIndex(0)
        while widget.currentText().endswith("(current)") \
                or widget.currentText().startswith("(none)"):
            widget.setCurrentIndex(widget.currentIndex() + 1)

        return widget.currentText()

    def __set_none(self, widget):
        widget.setCurrentIndex(0)
        while not widget.currentText().startswith("(none)"):
            if widget.currentIndex() == widget.count():
                self.skipTest("none not available for " + widget.objectName())
            widget.setCurrentIndex(widget.currentIndex() + 1)

    def __click_ok(self):
        okwidget = self.dialog.buttonBox.button(
                    self.dialog.buttonBox.Ok)

        QtTest.QTest.mouseClick(okwidget, QtCore.Qt.LeftButton)

    def __click_cancel(self):
        cancelwidget = self.dialog.buttonBox.button(
            self.dialog.buttonBox.Cancel)

        QtTest.QTest.mouseClick(cancelwidget, QtCore.Qt.LeftButton)

    def test_03_nothing_changed_ok(self):
        self.__click_ok()

        self.assertEqual(self.setattr_mock.call_count, 0,
                         "Changes occurred despite no changes being made")

    def test_04_nothing_changed_cancel(self):
        self.__click_cancel()

        self.assertEqual(self.setattr_mock.call_count, 0,
                         "Changes occurred despite no changes being made")

    def test_10_set_update_vm(self):
        new_updatevm_name = self.__set_noncurrent(self.dialog.update_vm_combo)

        self.__click_ok()

        self.setattr_mock.assert_called_once_with('updatevm', new_updatevm_name)

    def test_11_set_update_vm_to_none(self):
        self.__set_none(self.dialog.update_vm_combo)

        self.__click_ok()

        self.setattr_mock.assert_called_once_with('updatevm', None)

    def test_20_set_clock_vm(self):
        new_clockvm_name = self.__set_noncurrent(self.dialog.clock_vm_combo)

        self.__click_ok()

        self.setattr_mock.assert_called_once_with('clockvm', new_clockvm_name)

    def test_21_set_clock_vm_to_none(self):
        self.__set_none(self.dialog.clock_vm_combo)

        self.__click_ok()

        self.setattr_mock.assert_called_once_with('clockvm', None)

    def test_30_set_default_netvm(self):
        new_netvm_name = self.__set_noncurrent(self.dialog.default_netvm_combo)

        self.__click_ok()

        self.setattr_mock.assert_called_once_with('default_netvm',
                                                  new_netvm_name)

    def test_31_set_default_netvm_to_none(self):
        self.__set_none(self.dialog.default_netvm_combo)

        self.__click_ok()

        self.setattr_mock.assert_called_once_with('default_netvm', None)

    def test_40_set_default_template(self):
        new_def_template_name = self.__set_noncurrent(
            self.dialog.default_template_combo)

        self.__click_ok()

        self.setattr_mock.assert_called_once_with('default_template',
                                                  new_def_template_name)

    def test_50_set_default_kernel(self):
        new_def_kernel_name = self.__set_noncurrent(
            self.dialog.default_kernel_combo)

        self.__click_ok()

        self.setattr_mock.assert_called_once_with('default_kernel',
                                                  new_def_kernel_name)

    def test_51_set_default_kernel_to_none(self):
        self.__set_none(self.dialog.default_kernel_combo)

        self.__click_ok()

        self.setattr_mock.assert_called_once_with('default_kernel',
                                                  None)

    def test_60_set_dom0_updates_true(self):
        current_state = self.dialog.updates_dom0.isChecked()
        self.dialog.updates_dom0.setChecked(not current_state)

        with unittest.mock.patch.object(
                type(self.dialog.qvm_collection.domains['dom0'].features),
                '__setitem__') as mock_features:
            self.__click_ok()
            mock_features.assert_called_once_with('service.qubes-update-check',
                                                  not current_state)

    def test_70_change_vm_updates(self):
        current_state = self.dialog.updates_vm.isChecked()
        self.dialog.updates_vm.setChecked(not current_state)

        self.__click_ok()

        self.setattr_mock.assert_called_once_with('check_updates_vm',
                                                  not current_state)

    @unittest.mock.patch("PyQt4.QtGui.QMessageBox.question",
                         return_value=QtGui.QMessageBox.Yes)
    @unittest.mock.patch('qubesadmin.features.Features.__setitem__')
    def test_72_set_all_vms_true(self, mock_features, msgbox):

        QtTest.QTest.mouseClick(self.dialog.enable_updates_all,
                                QtCore.Qt.LeftButton)

        self.assertEqual(msgbox.call_count, 1,
                         "Wrong number of confirmation window calls")

        call_list_expected = \
            [unittest.mock.call('service.qubes-update-check', True) for vm
             in self.qapp.domains if vm.klass != 'AdminVM']

        self.assertListEqual(call_list_expected,
                             mock_features.call_args_list)

    @unittest.mock.patch("PyQt4.QtGui.QMessageBox.question",
                         return_value=QtGui.QMessageBox.Yes)
    @unittest.mock.patch('qubesadmin.features.Features.__setitem__')
    def test_73_set_all_vms_false(self, mock_features, msgbox):

        QtTest.QTest.mouseClick(self.dialog.disable_updates_all,
                                QtCore.Qt.LeftButton)

        self.assertEqual(msgbox.call_count, 1,
                         "Wrong number of confirmation window calls")

        call_list_expected = \
            [unittest.mock.call('service.qubes-update-check', False) for vm
             in self.qapp.domains if vm.klass != 'AdminVM']

        self.assertListEqual(call_list_expected,
                             mock_features.call_args_list)

    def test_80_set_default_dispvm(self):
        new_dispvm_name = self.__set_noncurrent(
            self.dialog.default_dispvm_combo)

        self.__click_ok()

        self.setattr_mock.assert_called_once_with('default_dispvm',
                                                  new_dispvm_name)

    def test_81_set_default_dispvm_to_none(self):
        self.__set_none(self.dialog.default_dispvm_combo)

        self.__click_ok()

        self.setattr_mock.assert_called_once_with('default_dispvm', None)

    @unittest.mock.patch.object(
        type(Qubes()), '__getattr__',
        side_effect=(lambda x: False if x == 'check_updates_vm' else None))
    def test_90_test_all_set_none(self, mock_qubes):
        mock_qubes.configure_mock()
        self.dialog = global_settings.GlobalSettingsWindow(
            self.qtapp, self.qapp)

        self.assertEqual(self.dialog.update_vm_combo.currentText(),
                         "(none) (current)",
                         "UpdateVM displays as none incorrectly")
        self.assertEqual(self.dialog.clock_vm_combo.currentText(),
                         "(none) (current)",
                         "ClockVM displays as none incorrectly")
        self.assertEqual(self.dialog.default_netvm_combo.currentText(),
                         "(none) (current)",
                         "Default NetVM displays as none incorrectly")
        self.assertEqual(self.dialog.default_template_combo.currentText(),
                         "(none) (current)",
                         "Default template displays as none incorrectly")
        self.assertEqual(self.dialog.default_kernel_combo.currentText(),
                         "(none) (current)",
                         "Defautl kernel displays as none incorrectly")
        self.assertEqual(self.dialog.default_dispvm_combo.currentText(),
                         "(none) (current)",
                         "Default DispVM displays as none incorrectly")


if __name__ == "__main__":
    ha_syslog = logging.handlers.SysLogHandler('/dev/log')
    ha_syslog.setFormatter(
        logging.Formatter('%(name)s[%(process)d]: %(message)s'))
    logging.root.addHandler(ha_syslog)
    unittest.main()

# TODO: add tests for memory settings once memory is handled better