#!/usr/bin/python3 # # The Qubes OS Project, https://www.qubes-os.org/ # # Copyright (C) 2016 Marta Marczykowska-Górecka # # # 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 asyncio import contextlib import logging.handlers import sys import unittest import unittest.mock import gc import subprocess import datetime import time import quamash from PyQt4 import QtGui, QtTest, QtCore from qubesadmin import Qubes, events, exc import qubesmanager.qube_manager as qube_manager class QubeManagerTest(unittest.TestCase): def setUp(self): super(QubeManagerTest, self).setUp() self.mock_qprogress = unittest.mock.patch('PyQt4.QtGui.QProgressDialog') self.mock_qprogress.start() self.addCleanup(self.mock_qprogress.stop) self.qapp = Qubes() self.qtapp = QtGui.QApplication(["test", "-style", "cleanlooks"]) self.dispatcher = events.EventsDispatcher(self.qapp) self.loop = quamash.QEventLoop(self.qtapp) self.dialog = qube_manager.VmManagerWindow( self.qtapp, self.qapp, self.dispatcher) 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(QubeManagerTest, self).tearDown() def test_000_window_loads(self): self.assertTrue(self.dialog.table is not None, "Window did not load") def test_001_correct_vms_listed(self): vms_in_table = [] for row in range(self.dialog.table.rowCount()): vm = self._get_table_item(row, "Name").vm self.assertIsNotNone(vm) vms_in_table.append(vm.name) # check that name is listed correctly name_item = self._get_table_item(row, "Name") self.assertEqual(name_item.text(), vm.name, "Incorrect VM name for {}".format(vm.name)) actual_vms = [vm.name for vm in self.qapp.domains] self.assertEqual(len(vms_in_table), len(actual_vms), "Incorrect number of VMs loaded") self.assertListEqual(sorted(vms_in_table), sorted(actual_vms), "Incorrect VMs loaded") def test_002_correct_template_listed(self): for row in range(self.dialog.table.rowCount()): vm = self._get_table_item(row, "Name").vm # check that template is listed correctly template_item = self._get_table_item(row, "Template") if getattr(vm, "template", None): self.assertEqual(vm.template, template_item.text(), "Incorrect template for {}".format(vm.name)) else: self.assertEqual(vm.klass, template_item.text(), "Incorrect class for {}".format(vm.name)) def test_003_correct_netvm_listed(self): for row in range(self.dialog.table.rowCount()): vm = self._get_table_item(row, "Name").vm # check that netvm is listed correctly netvm_item = self._get_table_item(row, "NetVM") netvm_value = getattr(vm, "netvm", None) netvm_value = "n/a" if not netvm_value else netvm_value if netvm_value and hasattr(vm, "netvm") \ and vm.property_is_default("netvm"): netvm_value = "default ({})".format(netvm_value) self.assertEqual(netvm_value, netvm_item.text(), "Incorrect netvm for {}".format(vm.name)) def test_004_correct_disk_usage_listed(self): for row in range(self.dialog.table.rowCount()): vm = self._get_table_item(row, "Name").vm size_item = self._get_table_item(row, "Size") if vm.klass == 'AdminVM': size_value = "n/a" else: size_value = round(vm.get_disk_utilization() / (1024 * 1024), 2) size_value = str(size_value) + " MiB" self.assertEqual(size_value, size_item.text(), "Incorrect size for {}".format(vm.name)) def test_005_correct_internal_listed(self): for row in range(self.dialog.table.rowCount()): vm = self._get_table_item(row, "Name").vm internal_item = self._get_table_item(row, "Internal") internal_value = "Yes" if vm.features.get('internal', False) else "" self.assertEqual(internal_item.text(), internal_value, "Incorrect internal value for {}".format(vm.name)) def test_006_correct_ip_listed(self): for row in range(self.dialog.table.rowCount()): vm = self._get_table_item(row, "Name").vm ip_item = self._get_table_item(row, "IP") if hasattr(vm, 'ip'): ip_value = getattr(vm, 'ip') ip_value = "" if ip_value is None else ip_value else: ip_value = "n/a" self.assertEqual(ip_value, ip_item.text(), "Incorrect ip value for {}".format(vm.name)) def test_007_incl_in_backups_listed(self): for row in range(self.dialog.table.rowCount()): vm = self._get_table_item(row, "Name").vm incl_backups_item = self._get_table_item(row, "Include in backups") incl_backups_value = getattr(vm, 'include_in_backups', False) incl_backups_value = "Yes" if incl_backups_value else "" self.assertEqual( incl_backups_value, incl_backups_item.text(), "Incorrect include in backups value for {}".format(vm.name)) def test_008_last_backup_listed(self): for row in range(self.dialog.table.rowCount()): vm = self._get_table_item(row, "Name").vm last_backup_item = self._get_table_item(row, "Last backup") last_backup_value = getattr(vm, 'backup_timestamp', None) if last_backup_value: last_backup_value = str( datetime.datetime.fromtimestamp(last_backup_value)) else: last_backup_value = "" self.assertEqual( last_backup_value, last_backup_item.text(), "Incorrect last backup value for {}".format(vm.name)) def test_009_def_dispvm_listed(self): for row in range(self.dialog.table.rowCount()): vm = self._get_table_item(row, "Name").vm def_dispvm_item = self._get_table_item(row, "Default DispVM") def_dispvm_value = getattr(vm, "default_dispvm", None) self.assertEqual( str(def_dispvm_value), def_dispvm_item.text(), "Incorrect default dispvm value for {}".format(vm.name)) def test_010_is_dvm_template_listed(self): for row in range(self.dialog.table.rowCount()): vm = self._get_table_item(row, "Name").vm is_dvm_template_item = self._get_table_item(row, "Is DVM Template") is_dvm_template_value = "Yes" if \ getattr(vm, "template_for_dispvms", False) else "" self.assertEqual( is_dvm_template_value, is_dvm_template_item.text(), "Incorrect is DVM template value for {}".format(vm.name)) def test_011_is_label_correct(self): for row in range(self.dialog.table.rowCount()): vm = self._get_table_item(row, "Name").vm label_item = self._get_table_item(row, "Label") self.assertEqual(label_item.icon_path, vm.label.icon) def test_012_is_state_correct(self): for row in range(self.dialog.table.rowCount()): vm = self._get_table_item(row, "Name").vm state_item = self._get_table_item(row, "State") # this should not be done like that in table_widgets displayed_power_state = state_item.on_icon.status if vm.is_running(): correct_power_state = 3 else: correct_power_state = 0 self.assertEqual( displayed_power_state, correct_power_state, "Wrong power state displayed for {}".format(vm.name)) def test_013_incorrect_settings_file(self): mock_settings = unittest.mock.MagicMock(spec=QtCore.QSettings) settings_result_dict = {"view/sort_column": "Cthulhu", "view/sort_order": "Fhtagn", "view/menubar_visible": "R'lyeh" } mock_settings.side_effect = ( lambda x, *args, **kwargs: settings_result_dict.get(x)) with unittest.mock.patch('PyQt4.QtCore.QSettings.value', mock_settings),\ unittest.mock.patch('PyQt4.QtGui.QMessageBox.warning')\ as mock_warning: self.dialog = qube_manager.VmManagerWindow( self.qtapp, self.qapp, self.dispatcher) self.assertEqual(mock_warning.call_count, 1) def test_100_sorting(self): self.dialog.table.sortByColumn(self.dialog.columns_indices["Template"]) self.__check_sorting("Template") self.dialog.table.sortByColumn(self.dialog.columns_indices["Name"]) self.__check_sorting("Name") @unittest.mock.patch('qubesmanager.qube_manager.QtCore.QSettings.setValue') @unittest.mock.patch('qubesmanager.qube_manager.QtCore.QSettings.sync') def test_101_hide_column(self, mock_sync, mock_settings): self.dialog.action_is_dvm_template.trigger() mock_settings.assert_called_with('columns/Is DVM Template', False) self.assertEqual(mock_sync.call_count, 1, "Hidden column not synced") self.dialog.action_is_dvm_template.trigger() mock_settings.assert_called_with('columns/Is DVM Template', True) self.assertEqual(mock_sync.call_count, 2, "Hidden column not synced") @unittest.mock.patch('qubesmanager.settings.VMSettingsWindow') def test_200_vm_open_settings(self, mock_window): selected_vm = self._select_non_admin_vm() self.assertIsNotNone(selected_vm, "No valid non-admin VM found") widget = self.dialog.toolbar.widgetForAction( self.dialog.action_settings) QtTest.QTest.mouseClick(widget, QtCore.Qt.LeftButton) mock_window.assert_called_once_with( selected_vm, self.qtapp, "basic") def test_201_vm_open_settings_admin(self): self._select_admin_vm() self.assertFalse(self.dialog.action_settings.isEnabled(), "Settings not disabled for admin VM") self.assertFalse(self.dialog.action_editfwrules.isEnabled(), "Settings not disabled for admin VM") self.assertFalse(self.dialog.action_appmenus.isEnabled(), "Settings not disabled for admin VM") @unittest.mock.patch('qubesmanager.settings.VMSettingsWindow') def test_202_vm_open_firewall(self, mock_window): selected_vm = self._select_non_admin_vm() self.assertIsNotNone(selected_vm, "No valid non-admin VM found") widget = self.dialog.toolbar.widgetForAction( self.dialog.action_editfwrules) QtTest.QTest.mouseClick(widget, QtCore.Qt.LeftButton) mock_window.assert_called_once_with( selected_vm, self.qtapp, "firewall") @unittest.mock.patch('qubesmanager.settings.VMSettingsWindow') def test_203_vm_open_apps(self, mock_window): selected_vm = self._select_non_admin_vm() self.assertIsNotNone(selected_vm, "No valid non-admin VM found") widget = self.dialog.toolbar.widgetForAction( self.dialog.action_appmenus) QtTest.QTest.mouseClick(widget, QtCore.Qt.LeftButton) mock_window.assert_called_once_with( selected_vm, self.qtapp, "applications") def test_204_vm_keyboard(self): selected_vm = self._select_non_admin_vm(running=True) self.assertIsNotNone(selected_vm, "No valid non-admin VM found") widget = self.dialog.toolbar.widgetForAction( self.dialog.action_set_keyboard_layout) with unittest.mock.patch.object(selected_vm, 'run') as mock_run: QtTest.QTest.mouseClick(widget, QtCore.Qt.LeftButton) mock_run.assert_called_once_with("qubes-change-keyboard-layout") def test_205_vm_keyboard_not_running(self): selected_vm = self._select_non_admin_vm(running=False) self.assertIsNotNone(selected_vm, "No valid non-admin VM found") widget = self.dialog.toolbar.widgetForAction( self.dialog.action_set_keyboard_layout) with unittest.mock.patch.object(selected_vm, 'run') as mock_run: QtTest.QTest.mouseClick(widget, QtCore.Qt.LeftButton) self.assertEqual(mock_run.call_count, 0, "Keyboard change called on a halted VM") def test_206_dom0_keyboard(self): self._select_admin_vm() self.assertFalse(self.dialog.action_set_keyboard_layout.isEnabled()) @unittest.mock.patch("PyQt4.QtGui.QMessageBox.question", return_value=QtGui.QMessageBox.Yes) def test_207_update_vm_not_running(self, _): selected_vm = self._select_templatevm(running=False) self.assertIsNotNone(selected_vm, "No valid template VM found") widget = self.dialog.toolbar.widgetForAction( self.dialog.action_updatevm) with unittest.mock.patch('qubesmanager.qube_manager.UpdateVMThread') \ as mock_update: QtTest.QTest.mouseClick(widget, QtCore.Qt.LeftButton) mock_update.assert_called_once_with(selected_vm) mock_update().start.assert_called_once_with() def test_208_update_vm_admin(self): selected_vm = self._select_admin_vm() self.assertIsNotNone(selected_vm, "No valid admin VM found") widget = self.dialog.toolbar.widgetForAction( self.dialog.action_updatevm) with unittest.mock.patch('qubesmanager.qube_manager.UpdateVMThread') \ as mock_update: QtTest.QTest.mouseClick(widget, QtCore.Qt.LeftButton) mock_update.assert_called_once_with(selected_vm) mock_update().start.assert_called_once_with() @unittest.mock.patch("PyQt4.QtGui.QInputDialog.getText", return_value=("command to run", True)) def test_209_run_command_in_vm(self, _): selected_vm = self._select_non_admin_vm() self.assertIsNotNone(selected_vm, "No valid non-admin VM found") with unittest.mock.patch('qubesmanager.qube_manager.RunCommandThread') \ as mock_thread: self.dialog.action_run_command_in_vm.trigger() mock_thread.assert_called_once_with(selected_vm, "command to run") mock_thread().finished.connect.assert_called_once_with( self.dialog.clear_threads) mock_thread().start.assert_called_once_with() def test_210_run_command_in_adminvm(self): self._select_admin_vm() self.assertFalse(self.dialog.action_run_command_in_vm.isEnabled(), "Should not be able to run commands for dom0") @unittest.mock.patch("PyQt4.QtGui.QMessageBox.warning") def test_211_pausevm(self, mock_warn): selected_vm = self._select_non_admin_vm(running=True) self.assertTrue(self.dialog.action_pausevm.isEnabled(), "Pause not enabled for a running VM") with unittest.mock.patch.object(selected_vm, 'pause') as mock_pause: self.dialog.action_pausevm.trigger() mock_pause.assert_called_once_with() mock_pause.side_effect = exc.QubesException('Error') self.dialog.action_pausevm.trigger() self.assertEqual(mock_warn.call_count, 1) def test_212_resumevm(self): selected_vm = self._select_non_admin_vm(running=False) with unittest.mock.patch.object(selected_vm, 'get_power_state')\ as mock_state, \ unittest.mock.patch.object(selected_vm, 'unpause')\ as mock_unpause: mock_state.return_value = 'Paused' self.dialog.action_resumevm.trigger() mock_unpause.assert_called_once_with() with unittest.mock.patch('qubesmanager.qube_manager.StartVMThread') \ as mock_thread: self.dialog.action_resumevm.trigger() mock_thread.assert_called_once_with(selected_vm) mock_thread().finished.connect.assert_called_once_with( self.dialog.clear_threads) mock_thread().start.assert_called_once_with() def test_213_resume_running_vm(self): self._select_non_admin_vm(running=True) self.assertFalse(self.dialog.action_resumevm.isEnabled()) @unittest.mock.patch("PyQt4.QtGui.QMessageBox.question", return_value=QtGui.QMessageBox.Yes) @unittest.mock.patch('PyQt4.QtCore.QTimer.singleShot') @unittest.mock.patch('qubesmanager.qube_manager.VmShutdownMonitor') def test_214_shutdownvm(self, mock_monitor, mock_timer, _): selected_vm = self._select_non_admin_vm(running=True) with unittest.mock.patch.object(selected_vm, 'shutdown')\ as mock_shutdown: self.dialog.action_shutdownvm.trigger() mock_shutdown.assert_called_once_with() mock_monitor.assert_called_once_with( selected_vm, unittest.mock.ANY, unittest.mock.ANY, unittest.mock.ANY, unittest.mock.ANY) mock_timer.assert_called_once_with(unittest.mock.ANY, unittest.mock.ANY) def test_215_shutdown_halted_vm(self): self._select_non_admin_vm(running=False) self.assertFalse(self.dialog.action_shutdownvm.isEnabled()) @unittest.mock.patch('qubesmanager.create_new_vm.NewVmDlg') def test_216_create_vm(self, mock_new_vm): action = self.dialog.action_createvm self.assertTrue(action.isEnabled()) action.trigger() self.assertEqual(mock_new_vm.call_count, 1, "Create New VM window did not appear") def test_217_remove_admin_vm(self): self._select_admin_vm() self.assertFalse(self.dialog.action_removevm.isEnabled()) @unittest.mock.patch("PyQt4.QtGui.QMessageBox") @unittest.mock.patch('qubesadmin.utils.vm_dependencies') def test_218_remove_vm_dependencies(self, mock_dependencies, mock_msgbox): action = self.dialog.action_removevm mock_vm = unittest.mock.Mock(spec=['name'], **{'name.return_value': 'testvm'}) mock_dependencies.return_value = [(mock_vm, "test_prop")] action.trigger() mock_msgbox().show.assert_called_with() @unittest.mock.patch('PyQt4.QtGui.QMessageBox.warning') @unittest.mock.patch("PyQt4.QtGui.QInputDialog.getText") @unittest.mock.patch('qubesadmin.utils.vm_dependencies') def test_219_remove_vm_no_depencies( self, mock_dependencies, mock_input, mock_warning): action = self.dialog.action_removevm selected_vm = self._select_non_admin_vm(running=False) # test with no dependencies mock_dependencies.return_value = None with unittest.mock.patch('qubesmanager.common_threads.RemoveVMThread')\ as mock_thread: mock_input.return_value = (selected_vm.name, False) action.trigger() self.assertEqual(mock_thread.call_count, 0, "VM removed despite user clicking 'cancel") mock_input.return_value = ("wrong_name", True) action.trigger() self.assertEqual(mock_warning.call_count, 1) self.assertEqual(mock_thread.call_count, 0, "VM removed despite user not confirming the name") mock_input.return_value = (selected_vm.name, True) action.trigger() mock_thread.assert_called_once_with(selected_vm) mock_thread().finished.connect.assert_called_once_with( self.dialog.clear_threads) mock_thread().start.assert_called_once_with() def test_220_restartvm_halted_vm(self): self._select_non_admin_vm(running=False) self.assertFalse(self.dialog.action_restartvm.isEnabled()) @unittest.mock.patch('PyQt4.QtCore.QTimer.singleShot') @unittest.mock.patch('qubesmanager.qube_manager.VmShutdownMonitor') @unittest.mock.patch("PyQt4.QtGui.QMessageBox.question", return_value=QtGui.QMessageBox.Yes) def test_221_restartvm_running_vm(self, _msgbox, mock_monitor, _qtimer): selected_vm = self._select_non_admin_vm(running=True) action = self.dialog.action_restartvm # currently the VM is running with unittest.mock.patch.object(selected_vm, 'shutdown')\ as mock_shutdown: action.trigger() mock_shutdown.assert_called_once_with() mock_monitor.assert_called_once_with( selected_vm, unittest.mock.ANY, unittest.mock.ANY, True, unittest.mock.ANY) @unittest.mock.patch('qubesmanager.qube_manager.StartVMThread') @unittest.mock.patch("PyQt4.QtGui.QMessageBox.question", return_value=QtGui.QMessageBox.Yes) def test_222_restartvm_shutdown_meantime(self, _, mock_thread): selected_vm = self._select_non_admin_vm(running=True) action = self.dialog.action_restartvm # it was shutdown in the meantime with unittest.mock.patch.object( selected_vm, 'is_running', **{'return_value': False}): action.trigger() mock_thread.assert_called_once_with(selected_vm) mock_thread().finished.connect.assert_called_once_with( self.dialog.clear_threads) mock_thread().start.assert_called_once_with() @unittest.mock.patch('qubesmanager.qube_manager.UpdateVMThread') def test_223_updatevm_running(self, mock_thread): selected_vm = self._select_non_admin_vm(running=True) self.dialog.action_updatevm.trigger() mock_thread.assert_called_once_with(selected_vm) mock_thread().finished.connect.assert_called_once_with( self.dialog.clear_threads) mock_thread().start.assert_called_once_with() @unittest.mock.patch("PyQt4.QtGui.QMessageBox.question", return_value=QtGui.QMessageBox.Yes) @unittest.mock.patch('qubesmanager.qube_manager.UpdateVMThread') def test_224_updatevm_halted(self, mock_thread, _): selected_vm = self._select_non_admin_vm(running=False) self.dialog.action_updatevm.trigger() mock_thread.assert_called_once_with(selected_vm) mock_thread().finished.connect.assert_called_once_with( self.dialog.clear_threads) mock_thread().start.assert_called_once_with() @unittest.mock.patch("PyQt4.QtGui.QMessageBox.question", return_value=QtGui.QMessageBox.Yes) def test_224_killvm(self, _): selected_vm = self._select_non_admin_vm(running=True) action = self.dialog.action_killvm with unittest.mock.patch.object(selected_vm, 'kill') as mock_kill: action.trigger() mock_kill.assert_called_once_with() @unittest.mock.patch("PyQt4.QtGui.QMessageBox.question", return_value=QtGui.QMessageBox.Cancel) def test_225_killvm_cancel(self, _): selected_vm = self._select_non_admin_vm(running=True) action = self.dialog.action_killvm with unittest.mock.patch.object(selected_vm, 'kill') as mock_kill: action.trigger() self.assertEqual(mock_kill.call_count, 0, "Ignored Cancel on kill VM") @unittest.mock.patch('qubesmanager.global_settings.GlobalSettingsWindow') def test_226_global_settings(self, mock_settings): self._select_non_admin_vm() self.dialog.action_global_settings.trigger() self.assertEqual(mock_settings.call_count, 1, "Global Settings not opened") self._select_admin_vm() self.dialog.action_global_settings.trigger() self.assertEqual(mock_settings.call_count, 2, "Global Settings not opened for the second time") @unittest.mock.patch('qubesmanager.backup.BackupVMsWindow') def test_227_backup(self, mock_backup): self.dialog.action_backup.trigger() self.assertTrue(self.dialog.action_backup.isEnabled()) self.assertEqual(mock_backup.call_count, 1, "Backup window does not appear") @unittest.mock.patch('qubesmanager.restore.RestoreVMsWindow') def test_228_restore(self, mock_restore): self.dialog.action_restore.trigger() self.assertTrue(self.dialog.action_restore.isEnabled()) self.assertEqual(mock_restore.call_count, 1, "Backup window does not appear") @unittest.mock.patch('qubesmanager.qube_manager.AboutDialog') def test_229_about_qubes(self, mock_about): self.assertTrue(self.dialog.action_about_qubes.isEnabled()) self.dialog.action_about_qubes.trigger() self.assertEqual( mock_about.call_count, 1, "About window does not appear") def test_230_exit_action(self): self.assertTrue(self.dialog.action_exit.isEnabled()) with unittest.mock.patch.object(self.dialog, 'close') as mock_close: self.dialog.action_exit.trigger() mock_close.assert_called_once_with() @unittest.mock.patch('subprocess.check_call') def test_231_template_manager(self, mock_subprocess): self.assertTrue(self.dialog.action_manage_templates.isEnabled()) self.dialog.action_manage_templates.trigger() mock_subprocess.assert_called_once_with('qubes-template-manager') @unittest.mock.patch('qubesmanager.common_threads.CloneVMThread') @unittest.mock.patch('PyQt4.QtGui.QInputDialog.getText') def test_232_clonevm(self, mock_input, mock_thread): action = self.dialog.action_clonevm self._select_admin_vm() self.assertFalse(action.isEnabled()) selected_vm = self._select_non_admin_vm() self.assertTrue(action.isEnabled()) mock_input.return_value = (selected_vm.name + "clone1", False) action.trigger() self.assertEqual(mock_thread.call_count, 0, "Ignores cancelling clone VM") mock_input.return_value = (selected_vm.name + "clone1", True) action.trigger() mock_thread.assert_called_once_with(selected_vm, selected_vm.name + "clone1") mock_thread().finished.connect.assert_called_once_with( self.dialog.clear_threads) mock_thread().start.assert_called_once_with() def test_233_search_action(self): self.qtapp.setActiveWindow(self.dialog.searchbox) self.dialog.action_search.trigger() self.assertTrue(self.dialog.searchbox.hasFocus()) # input text self.dialog.searchbox.setText("sys") # click outside the widget QtTest.QTest.mouseClick(self.dialog.table, QtCore.Qt.LeftButton) # click the widget, check if it is correctly activated and the whole # text was selected QtTest.QTest.mouseClick(self.dialog.searchbox, QtCore.Qt.LeftButton) self.assertTrue(self.dialog.searchbox.hasFocus()) self.assertEqual(self.dialog.searchbox.selectedText(), "sys") def test_234_searchbox(self): # look for sys self.dialog.searchbox.setText("sys") expected_number = \ len([vm for vm in self.qapp.domains if "sys" in vm.name]) actual_number = self._count_visible_table_rows() self.assertEqual(expected_number, actual_number, "Incorrect number of vms shown for 'sys'") # clear search self.dialog.searchbox.setText("") expected_number = len([vm for vm in self.qapp.domains]) actual_number = self._count_visible_table_rows() self.assertEqual(expected_number, actual_number, "Incorrect number of vms shown for cleared search box") def test_235_hide_show_toolbars(self): with unittest.mock.patch('PyQt4.QtCore.QSettings.setValue')\ as mock_setvalue: self.dialog.action_menubar.trigger() mock_setvalue.assert_called_with('view/menubar_visible', False) self.dialog.action_toolbar.trigger() mock_setvalue.assert_called_with('view/toolbar_visible', False) self.assertFalse(self.dialog.menubar.isVisible(), "Menubar not hidden correctly") self.assertFalse(self.dialog.toolbar.isVisible(), "Toolbar not hidden correctly") def test_236_clear_searchbox(self): self.dialog.searchbox.setText("text") self.assertEqual(self.dialog.searchbox.text(), "text") QtTest.QTest.keyPress(self.dialog, QtCore.Qt.Key_Escape) self.assertEqual(self.dialog.searchbox.text(), "", "Escape failed to clear searchbox") expected_number = len([vm for vm in self.qapp.domains]) actual_number = self._count_visible_table_rows() self.assertEqual(expected_number, actual_number, "Incorrect number of vms shown for cleared search box") @unittest.mock.patch('PyQt4.QtGui.QMessageBox.information') @unittest.mock.patch('PyQt4.QtGui.QMessageBox.warning') def test_300_clear_threads(self, mock_warning, mock_info): mock_thread_finished_ok = unittest.mock.Mock( spec=['isFinished', 'msg', 'msg_is_success'], msg=None, msg_is_success=False, **{'isFinished.return_value': True}) mock_thread_not_finished = unittest.mock.Mock( spec=['isFinished', 'msg', 'msg_is_success'], msg=None, msg_is_success=False, **{'isFinished.return_value': False}) mock_thread_finished_error = unittest.mock.Mock( spec=['isFinished', 'msg', 'msg_is_success'], msg=("Error", "Error"), msg_is_success=False, **{'isFinished.return_value': True}) mock_thread_fin_error_success = unittest.mock.Mock( spec=['isFinished', 'msg', 'msg_is_success'], msg=("Done", "Done"), msg_is_success=True, **{'isFinished.return_value': True}) # single finished thread self.dialog.threads_list = [mock_thread_not_finished, mock_thread_finished_ok] self.dialog.clear_threads() self.assertEqual(mock_warning.call_count, 0) self.assertEqual(mock_info.call_count, 0) self.assertEqual(len(self.dialog.threads_list), 1) # an error thread and some in-progress ones self.dialog.threads_list = [mock_thread_not_finished, mock_thread_not_finished, mock_thread_finished_error] self.dialog.clear_threads() self.assertEqual(mock_warning.call_count, 1) self.assertEqual(mock_info.call_count, 0) self.assertEqual(len(self.dialog.threads_list), 2) # an error-success thread and some in-progress ones self.dialog.threads_list = [mock_thread_not_finished, mock_thread_not_finished, mock_thread_fin_error_success, mock_thread_finished_error] self.dialog.clear_threads() self.assertEqual(mock_warning.call_count, 1) self.assertEqual(mock_info.call_count, 1) self.assertEqual(len(self.dialog.threads_list), 3) def test_400_event_domain_added(self): number_of_vms = self.dialog.table.rowCount() self.addCleanup(subprocess.call, ["qvm-remove", "-f", "testvm"]) self._run_command_and_process_events( ["qvm-create", "--label", "red", "testvm"]) # a single row was added to the table self.assertEqual(self.dialog.table.rowCount(), number_of_vms + 1) # table contains the correct vms vms_in_table = self._create_set_of_current_vms() vms_in_system = set([vm.name for vm in self.qapp.domains]) self.assertEqual(vms_in_table, vms_in_system, "Table not updated " "correctly after add") # check if sorting works self.dialog.table.sortItems(self.dialog.columns_indices["Name"], QtCore.Qt.AscendingOrder) self.__check_sorting("Name") # try opening settings for the added vm for row in range(self.dialog.table.rowCount()): name = self._get_table_item(row, "Name") if name.text() == "testvm": self.dialog.table.setCurrentItem(name) break with unittest.mock.patch('qubesmanager.settings.VMSettingsWindow')\ as mock_settings: self.dialog.action_settings.trigger() mock_settings.assert_called_once_with( self.qapp.domains["testvm"], self.qtapp, "basic") def test_401_event_domain_removed(self): initial_vms = self._create_set_of_current_vms() self._run_command_and_process_events( ["qvm-create", "--label", "red", "testvm"]) current_vms = self._create_set_of_current_vms() self.assertEqual(len(initial_vms) + 1, len(current_vms)) self._run_command_and_process_events( ["qvm-remove", "--force", "testvm"]) current_vms = self._create_set_of_current_vms() self.assertEqual(initial_vms, current_vms) # check if sorting works self.dialog.table.sortItems(self.dialog.columns_indices["Name"], QtCore.Qt.AscendingOrder) self.__check_sorting("Name") def test_403_event_dispvm_added(self): initial_vms = self._create_set_of_current_vms() dispvm_template = None for vm in self.qapp.domains: if getattr(vm, "template_for_dispvms", False): dispvm_template = vm.name break self.assertIsNotNone(dispvm_template, "Cannot find a template for dispVMs") # this requires very long timeout, because it takes time for the # dispvm to vanish self._run_command_and_process_events( ["qvm-run", "--dispvm", dispvm_template, "true"], timeout=60) final_vms = self._create_set_of_current_vms() self.assertEqual(initial_vms, final_vms, "Failed handling of a created-and-removed dispvm") def test_404_crashing_dispvm(self): initial_vms = self._create_set_of_current_vms() dispvm_template = None for vm in self.qapp.domains: if getattr(vm, "template_for_dispvms", False): dispvm_template = vm.name break self.assertIsNotNone(dispvm_template, "Cannot find a template for dispVMs") current_memory = getattr(self.qapp.domains[dispvm_template], "memory") self.addCleanup( subprocess.call, ["qvm-prefs", dispvm_template, "memory", str(current_memory)]) subprocess.check_call( ["qvm-prefs", dispvm_template, "memory", "600000"]) self._run_command_and_process_events( ["qvm-run", "--dispvm", dispvm_template, "true"], timeout=30) final_vms = self._create_set_of_current_vms() self.assertEqual(initial_vms, final_vms, "Failed handling of dispvm that crashed on start") def test_405_prop_change_label(self): target_vm_name = "work" vm_row = self._find_vm_row(target_vm_name) current_label_path = self._get_table_item(vm_row, "Label").icon_path self.addCleanup( subprocess.call, ["qvm-prefs", target_vm_name, "label", "blue"]) self._run_command_and_process_events( ["qvm-prefs", target_vm_name, "label", "red"]) new_label_path = self._get_table_item(vm_row, "Label").icon_path self.assertNotEqual(current_label_path, new_label_path, "Label path did not change") self.assertEqual( new_label_path, self.qapp.domains[target_vm_name].label.icon, "Incorrect label") def test_406_prop_change_template(self): target_vm_name = "work" vm_row = self._find_vm_row(target_vm_name) old_template = self._get_table_item(vm_row, "Template").text() new_template = None for vm in self.qapp.domains: if vm.klass == 'TemplateVM' and vm.name != old_template: new_template = vm.name break self.addCleanup( subprocess.call, ["qvm-prefs", target_vm_name, "template", old_template]) self._run_command_and_process_events( ["qvm-prefs", target_vm_name, "template", new_template]) self.assertNotEqual(old_template, self._get_table_item(vm_row, "Template").text(), "Template did not change") self.assertEqual( self._get_table_item(vm_row, "Template").text(), self.qapp.domains[target_vm_name].template.name, "Incorrect template") def test_407_prop_change_netvm(self): target_vm_name = "work" vm_row = self._find_vm_row(target_vm_name) old_netvm = self._get_table_item(vm_row, "NetVM").text() new_netvm = None for vm in self.qapp.domains: if getattr(vm, "provides_network", False) and vm.name != old_netvm: new_netvm = vm.name break self.addCleanup( subprocess.call, ["qvm-prefs", target_vm_name, "netvm", old_netvm]) self._run_command_and_process_events( ["qvm-prefs", target_vm_name, "netvm", new_netvm]) self.assertNotEqual(old_netvm, self._get_table_item(vm_row, "NetVM").text(), "NetVM did not change") self.assertEqual( self._get_table_item(vm_row, "NetVM").text(), self.qapp.domains[target_vm_name].netvm.name, "Incorrect NetVM") @unittest.expectedFailure def test_408_prop_change_internal(self): target_vm_name = "work" vm_row = self._find_vm_row(target_vm_name) self.addCleanup(subprocess.call, ["qvm-features", "--unset", "work", "interal"]) self._run_command_and_process_events( ["qvm-features", "work", "interal", "1"]) self.assertEqual( self._get_table_item(vm_row, "Internal").text(), "Yes", "Incorrect value for internal VM") self._run_command_and_process_events( ["qvm-features", "--unset", "work", "interal"]) self.assertEqual( self._get_table_item(vm_row, "Internal").text(), "", "Incorrect value for non-internal VM") def test_409_prop_change_ip(self): target_vm_name = "work" vm_row = self._find_vm_row(target_vm_name) old_ip = self._get_table_item(vm_row, "IP").text() new_ip = old_ip.replace(".0.", ".5.") self.addCleanup( subprocess.call, ["qvm-prefs", target_vm_name, "ip", old_ip]) self._run_command_and_process_events( ["qvm-prefs", target_vm_name, "ip", new_ip]) self.assertNotEqual(old_ip, self._get_table_item(vm_row, "IP").text(), "IP did not change") self.assertEqual( self._get_table_item(vm_row, "IP").text(), self.qapp.domains[target_vm_name].ip, "Incorrect IP") def test_410_prop_change_in_backups(self): target_vm_name = "work" vm_row = self._find_vm_row(target_vm_name) old_value = self.qapp.domains[target_vm_name].include_in_backups new_value = not old_value self.addCleanup( subprocess.call, ["qvm-prefs", target_vm_name, "include_in_backups", str(old_value)]) self._run_command_and_process_events( ["qvm-prefs", target_vm_name, "include_in_backups", str(new_value)]) self.assertEqual( self._get_table_item(vm_row, "Internal").text(), "Yes" if new_value else "", "Incorrect value for include_in_backups") def test_411_prop_change_last_backup(self): target_vm_name = "work" target_timestamp = "2015-01-01 17:00:00" vm_row = self._find_vm_row(target_vm_name) old_value = self._get_table_item(vm_row, "Last backup").text() new_value = datetime.datetime.strptime( target_timestamp, "%Y-%m-%d %H:%M:%S") self.addCleanup( subprocess.call, ["qvm-prefs", '-D', target_vm_name, "backup_timestamp"]) self._run_command_and_process_events( ["qvm-prefs", target_vm_name, "backup_timestamp", str(int(new_value.timestamp()))]) self.assertNotEqual(old_value, self._get_table_item(vm_row, "Last backup").text(), "Last backup date did not change") self.assertEqual( self._get_table_item(vm_row, "Last backup").text(), target_timestamp, "Incorrect Last backup date") def test_412_prop_change_defdispvm(self): target_vm_name = "work" vm_row = self._find_vm_row(target_vm_name) old_default_dispvm =\ self._get_table_item(vm_row, "Default DispVM").text() new_default_dispvm = None for vm in self.qapp.domains: if getattr(vm, "template_for_dispvms", False) and vm.name !=\ old_default_dispvm: new_default_dispvm = vm.name break self.addCleanup( subprocess.call, ["qvm-prefs", target_vm_name, "default_dispvm", old_default_dispvm]) self._run_command_and_process_events( ["qvm-prefs", target_vm_name, "default_dispvm", new_default_dispvm]) self.assertNotEqual( old_default_dispvm, self._get_table_item(vm_row, "Default DispVM").text(), "Default DispVM did not change") self.assertEqual( self._get_table_item(vm_row, "Default DispVM").text(), self.qapp.domains[target_vm_name].default_dispvm.name, "Incorrect Default DispVM") def test_413_prop_change_templ_disp(self): target_vm_name = "work" vm_row = self._find_vm_row(target_vm_name) self.addCleanup( subprocess.call, ["qvm-prefs", "--default", target_vm_name, "template_for_dispvms"]) self._run_command_and_process_events( ["qvm-prefs", target_vm_name, "template_for_dispvms", "True"]) self.assertEqual( self._get_table_item(vm_row, "Is DVM Template").text(), "Yes", "Incorrect value for DVM Template") self._run_command_and_process_events( ["qvm-prefs", "--default", target_vm_name, "template_for_dispvms"]) self.assertEqual( self._get_table_item(vm_row, "Is DVM Template").text(), "", "Incorrect value for not DVM Template") def test_414_vm_state_change(self): target_vm_name = "work" vm_row = self._find_vm_row(target_vm_name) self.assertFalse(self.qapp.domains[target_vm_name].is_running()) self.addCleanup( subprocess.call, ["qvm-shutdown", target_vm_name]) self._run_command_and_process_events( ["qvm-start", target_vm_name], timeout=20) status_item = self._get_table_item(vm_row, "State") displayed_power_state = status_item.on_icon.status self.assertEqual(displayed_power_state, 3, "Power state failed to update on start") self._run_command_and_process_events( ["qvm-shutdown", target_vm_name], timeout=20) displayed_power_state = status_item.on_icon.status self.assertEqual(displayed_power_state, 0, "Power state failed to update on shutdown") def test_415_template_vm_started(self): # check whether changing state of a template_vm causes all other # vms depending on it to check theirs target_vm_name = None for vm in self.qapp.domains: if vm.klass == 'TemplateVM': for vm2 in self.qapp.domains: if getattr(vm2, 'template', None) == vm.name: target_vm_name = vm.name break if target_vm_name: break for i in range(self.dialog.table.rowCount()): self._get_table_item(i, "State").update_vm_state =\ unittest.mock.Mock() self.addCleanup( subprocess.call, ["qvm-shutdown", target_vm_name]) self._run_command_and_process_events( ["qvm-start", target_vm_name], timeout=20) for i in range(self.dialog.table.rowCount()): call_count = self._get_table_item( i, "State").update_vm_state.call_count if self._get_table_item(i, "Template").text() == target_vm_name: self.assertGreater(call_count, 0) elif self._get_table_item(i, "Name").text() == target_vm_name: self.assertGreater(call_count, 0) else: self.assertEqual(call_count, 0) def test_500_logs(self): self._select_admin_vm() self.assertTrue(self.dialog.logs_menu.isEnabled()) dom0_logs = set() for c in self.dialog.logs_menu.actions(): dom0_logs.add(c.text()) self.assertIsNotNone( c.data(), "Empty log file found: {}".format(c.text())) self.assertIn("hypervisor", c.text(), "Log for dom0 does not contain 'hypervisor'") selected_vm = self._select_non_admin_vm().name self.assertTrue(self.dialog.logs_menu.isEnabled()) vm_logs = set() for c in self.dialog.logs_menu.actions(): vm_logs.add(c.text()) self.assertIsNotNone( c.data(), "Empty log file found: {}".format(c.text())) self.assertIn( selected_vm, c.text(), "Log for {} does not contain its name".format(selected_vm)) self.assertNotEqual(dom0_logs, vm_logs, "Same logs found for dom0 and non-adminVM") def _find_vm_row(self, vm_name): for row in range(self.dialog.table.rowCount()): name = self._get_table_item(row, "Name") if name.text() == vm_name: return row return None def _count_visible_table_rows(self): result = 0 for i in range(self.dialog.table.rowCount()): if not self.dialog.table.isRowHidden(i): result += 1 return result def _run_command_and_process_events(self, command, timeout=5): """ helper function to run a given command and process eventsDispatcher events :param command: list of strings, containing the command and all its parameters :param timeout: default 20 seconds :return: """ asyncio.set_event_loop(self.loop) future1 = asyncio.ensure_future(self.dispatcher.listen_for_events()) future2 = asyncio.create_subprocess_exec(*command, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL) (done, pending) = self.loop.run_until_complete( asyncio.wait({future1, future2}, timeout=timeout)) for task in pending: with contextlib.suppress(asyncio.CancelledError): task.cancel() self.loop.call_soon(self.loop.stop) self.loop.run_forever() def _create_set_of_current_vms(self): result = set() for i in range(self.dialog.table.rowCount()): result.add(self._get_table_item(i, "Name").vm.name) return result def _select_admin_vm(self): for row in range(self.dialog.table.rowCount()): template = self.dialog.table.item( row, self.dialog.columns_indices["Template"]) if template.text() == 'AdminVM': self.dialog.table.setCurrentItem(template) return template.vm return None def _select_non_admin_vm(self, running=None): for row in range(self.dialog.table.rowCount()): template = self.dialog.table.item( row, self.dialog.columns_indices["Template"]) status = self.dialog.table.item( row, self.dialog.columns_indices["State"]) if template.text() != 'AdminVM' and \ (running is None or (running and status.on_icon.status == 3) or (not running and status.on_icon.status != 3)): self.dialog.table.setCurrentItem(template) return template.vm return None def _select_templatevm(self, running=None): for row in range(self.dialog.table.rowCount()): template = self.dialog.table.item( row, self.dialog.columns_indices["Template"]) status = self.dialog.table.item( row, self.dialog.columns_indices["State"]) if template.text() == 'TemplateVM' and \ (running is None or (running and status.on_icon.status == 3) or (not running and status.on_icon.status != 3)): self.dialog.table.setCurrentItem(template) return template.vm return None def __check_sorting(self, column_name): last_text = None last_vm = None for row in range(self.dialog.table.rowCount()): vm = self._get_table_item(row, "Name").vm.name text = self._get_table_item(row, column_name).text().lower() if row == 0: self.assertEqual(vm, "dom0", "dom0 is not sorted first") elif last_text is None: last_text = text last_vm = vm else: if last_text == text: self.assertGreater( vm, last_vm, "Incorrect sorting for {}".format(column_name)) else: self.assertGreater( text, last_text, "Incorrect sorting for {}".format(column_name)) last_text = text last_vm = vm def _get_table_item(self, row, column_name): value = self.dialog.table.cellWidget( row, self.dialog.columns_indices[column_name]) if not value: value = self.dialog.table.item( row, self.dialog.columns_indices[column_name]) return value class QubeManagerThreadTest(unittest.TestCase): def test_01_startvm_thread(self): vm = unittest.mock.Mock(spec=['start']) thread = qube_manager.StartVMThread(vm) thread.run() vm.start.assert_called_once_with() def test_02_startvm_thread_error(self): vm = unittest.mock.Mock( spec=['start'], **{'start.side_effect': exc.QubesException('Error')}) thread = qube_manager.StartVMThread(vm) thread.run() self.assertIsNotNone(thread.msg) def test_10_run_command_thread(self): vm = unittest.mock.Mock(spec=['run']) thread = qube_manager.RunCommandThread(vm, "test_command") thread.run() vm.run.assert_called_once_with("test_command") def test_11_run_command_thread_error(self): vm = unittest.mock.Mock(spec=['run'], **{'run.side_effect': ChildProcessError}) thread = qube_manager.RunCommandThread(vm, "test_command") thread.run() self.assertIsNotNone(thread.msg) @unittest.mock.patch('subprocess.check_call') def test_20_update_vm_thread_dom0(self, check_call): vm = unittest.mock.Mock(spec=['qid']) vm.qid = 0 thread = qube_manager.UpdateVMThread(vm) thread.run() check_call.assert_called_once_with( ["/usr/bin/qubes-dom0-update", "--clean", "--gui"]) @unittest.mock.patch('builtins.open') @unittest.mock.patch('subprocess.call') def test_21_update_vm_thread_running(self, mock_call, mock_open): vm = unittest.mock.Mock( spec=['qid', 'is_running', 'run_service_for_stdio', 'run_service'], **{'is_running.return_value': True}) vm.qid = 1 vm.run_service_for_stdio.return_value = (b'changed=no\n', None) thread = qube_manager.UpdateVMThread(vm) thread.run() mock_open.assert_called_with( '/usr/libexec/qubes-manager/dsa-4371-update', 'rb') vm.run_service_for_stdio.assert_called_once_with( "qubes.VMShell", user='root', input=unittest.mock.ANY) vm.run_service.assert_called_once_with( "qubes.InstallUpdatesGUI", user="root", wait=False) self.assertEqual(mock_call.call_count, 0) @unittest.mock.patch('builtins.open') @unittest.mock.patch('subprocess.call') def test_22_update_vm_thread_not_running(self, mock_call, mock_open): vm = unittest.mock.Mock( spec=['qid', 'is_running', 'run_service_for_stdio', 'run_service', 'start', 'name'], **{'is_running.return_value': False}) vm.qid = 1 vm.run_service_for_stdio.return_value = (b'changed=yes\n', None) thread = qube_manager.UpdateVMThread(vm) thread.run() mock_open.assert_called_with( '/usr/libexec/qubes-manager/dsa-4371-update', 'rb') vm.start.assert_called_once_with() vm.run_service_for_stdio.assert_called_once_with( "qubes.VMShell", user='root', input=unittest.mock.ANY) vm.run_service.assert_called_once_with( "qubes.InstallUpdatesGUI", user="root", wait=False) self.assertEqual(mock_call.call_count, 1) @unittest.mock.patch('builtins.open') @unittest.mock.patch('subprocess.check_call') def test_23_update_vm_thread_error(self, *_args): vm = unittest.mock.Mock( spec=['qid', 'is_running'], **{'is_running.side_effect': ChildProcessError}) vm.qid = 1 thread = qube_manager.UpdateVMThread(vm) thread.run() self.assertIsNotNone(thread.msg) class VMShutdownMonitorTest(unittest.TestCase): @unittest.mock.patch('PyQt4.QtGui.QMessageBox.question') @unittest.mock.patch('PyQt4.QtCore.QTimer') def test_01_vm_shutdown_correct(self, mock_timer, mock_question): mock_vm = unittest.mock.Mock() mock_vm.is_running.return_value = False monitor = qube_manager.VmShutdownMonitor(mock_vm) monitor.restart_vm_if_needed = unittest.mock.Mock() monitor.check_if_vm_has_shutdown() self.assertEqual(mock_question.call_count, 0) self.assertEqual(mock_timer.call_count, 0) monitor.restart_vm_if_needed.assert_called_once_with() @unittest.mock.patch('PyQt4.QtGui.QMessageBox.question', return_value=1) @unittest.mock.patch('PyQt4.QtCore.QTimer.singleShot') def test_02_vm_not_shutdown_wait(self, mock_timer, mock_question): mock_vm = unittest.mock.Mock() mock_vm.is_running.return_value = True mock_vm.start_time = datetime.datetime.now().timestamp() - 3000 monitor = qube_manager.VmShutdownMonitor(mock_vm, shutdown_time=1) time.sleep(3) monitor.check_if_vm_has_shutdown() self.assertEqual(mock_question.call_count, 1) self.assertEqual(mock_timer.call_count, 1) @unittest.mock.patch('PyQt4.QtGui.QMessageBox.question', return_value=0) @unittest.mock.patch('PyQt4.QtCore.QTimer.singleShot') def test_03_vm_kill(self, mock_timer, mock_question): mock_vm = unittest.mock.Mock() mock_vm.is_running.return_value = True mock_vm.start_time = datetime.datetime.now().timestamp() - 3000 monitor = qube_manager.VmShutdownMonitor(mock_vm, shutdown_time=1) time.sleep(3) monitor.restart_vm_if_needed = unittest.mock.Mock() monitor.check_if_vm_has_shutdown() self.assertEqual(mock_question.call_count, 1) self.assertEqual(mock_timer.call_count, 0) mock_vm.kill.assert_called_once_with() monitor.restart_vm_if_needed.assert_called_once_with() @unittest.mock.patch('PyQt4.QtGui.QMessageBox.question', return_value=0) @unittest.mock.patch('PyQt4.QtCore.QTimer.singleShot') def test_04_check_later(self, mock_timer, mock_question): mock_vm = unittest.mock.Mock() mock_vm.is_running.return_value = True mock_vm.start_time = datetime.datetime.now().timestamp() - 3000 monitor = qube_manager.VmShutdownMonitor(mock_vm, shutdown_time=3000) time.sleep(1) monitor.check_if_vm_has_shutdown() self.assertEqual(mock_question.call_count, 0) self.assertEqual(mock_timer.call_count, 1) 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()