def setUp(self):
super(VMSettingsTest, 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.loop = quamash.QEventLoop(self.qtapp)
def setUp(self):
super(VMSettingsTest, self).setUp()
self.qtapp, self.loop = init_qtapp()
self.mock_qprogress = unittest.mock.patch(
'PyQt5.QtWidgets.QProgressDialog')
self.mock_qprogress.start()
self.addCleanup(self.mock_qprogress.stop)
self.qapp = Qubes()
if "test-vm" in self.qapp.domains:
del self.qapp.domains["test-vm"]
def setUp(self):
super(BackupTest, self).setUp()
# mock up nonexistence of saved backup settings
self.patcher_open = unittest.mock.patch('builtins.open')
self.mock_open = self.patcher_open.start()
self.mock_open.side_effect = FileNotFoundError()
self.addCleanup(self.patcher_open.stop)
# mock up the Backup Thread to avoid accidentally changing system state
self.patcher_thread = unittest.mock.patch(
'qubesmanager.backup.BackupThread')
self.mock_thread = self.patcher_thread.start()
self.addCleanup(self.patcher_thread.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 = backup.BackupVMsWindow(self.qtapp, self.qapp,
self.dispatcher)
self.dialog.show()
def main():
qt_app = QtWidgets.QApplication(sys.argv)
qt_app.setOrganizationName("The Qubes Project")
qt_app.setOrganizationDomain("http://qubes-os.org")
qt_app.setApplicationName("Qube Manager")
qt_app.setWindowIcon(QtGui.QIcon.fromTheme("qubes-manager"))
qt_app.lastWindowClosed.connect(loop_shutdown)
qubes_app = Qubes()
loop = quamash.QEventLoop(qt_app)
asyncio.set_event_loop(loop)
dispatcher = events.EventsDispatcher(qubes_app)
manager_window = TemplateManagerWindow(qt_app, qubes_app, dispatcher)
manager_window.show()
try:
loop.run_until_complete(
asyncio.ensure_future(dispatcher.listen_for_events()))
except asyncio.CancelledError:
pass
except Exception: # pylint: disable=broad-except
loop_shutdown()
exc_type, exc_value, exc_traceback = sys.exc_info()[:3]
handle_exception(exc_type, exc_value, exc_traceback)
def setUp(self):
super(DomainsWidgetTest, self).setUp()
self.widget = domains_widget.DomainTray('org.qubes.ui.tray.Domains')
self.widget.initialize_menu()
self.qapp = Qubes()
def setUp(self):
super(CloneVMTest, self).setUp()
self.qtapp, self.loop = init_qtapp()
self.qapp = Qubes()
# mock up the Create VM Thread to avoid changing system state
self.patcher_thread = unittest.mock.patch(
'qubesmanager.common_threads.CloneVMThread')
self.mock_thread = self.patcher_thread.start()
self.addCleanup(self.patcher_thread.stop)
# mock the progress dialog to speed testing up
self.patcher_progress = unittest.mock.patch(
'PyQt5.QtWidgets.QProgressDialog')
self.mock_progress = self.patcher_progress.start()
self.addCleanup(self.patcher_progress.stop)
# mock the progress dialog to speed testing up
self.patcher_warning = unittest.mock.patch(
'PyQt5.QtWidgets.QMessageBox.warning')
self.mock_warning = self.patcher_warning.start()
self.addCleanup(self.patcher_warning.stop)
self.dialog = clone_vm.CloneVMDlg(self.qtapp, self.qapp)
def validate_existing_size(self):
"""This method checks for existing private volume size and new
values in the config.json"""
assert "vmsizes" in self.config
assert "sd_app" in self.config["vmsizes"]
assert "sd_log" in self.config["vmsizes"]
assert isinstance(self.config["vmsizes"]["sd_app"], int), \
"Private volume size of sd-app must be an integer value."
assert isinstance(self.config["vmsizes"]["sd_log"], int), \
"Private volume size of sd-log must be an integer value."
app = Qubes()
if "sd-app" in app.domains:
vm = app.domains["sd-app"]
vol = vm.volumes["private"]
assert (
vol.size <=
self.config["vmsizes"]["sd_app"] * 1024 * 1024 * 1024
), "sd-app private volume is already bigger than configuration."
if "sd-log" in app.domains:
vm = app.domains["sd-log"]
vol = vm.volumes["private"]
assert (
vol.size <=
self.config["vmsizes"]["sd_log"] * 1024 * 1024 * 1024
), "sd-log private volume is already bigger than configuration."
def main():
parser = ArgumentParser()
parser.add_argument('--profile-interceptors',
action='store_true',
default=False)
args = parser.parse_args()
profile_if_requested = profile if args.profile_interceptors else identity
with Popen([
"i3status", "-c",
os.path.join(os.path.dirname(sys.argv[0]), "i3status.conf")
],
stdout=PIPE) as proc:
qubes = Qubes()
restarted = os.environ.get('RESTARTED') == '1'
potentially_add_skipped_statuses = identity # not supported in the sync script
modify = potentially_add_skipped_statuses(
create_modify_specific_fields(
interceptors_by_instance=profile_if_requested({
'holder_disk_info':
DiskInterceptor(qubes), #LatencyInterceptor(100, 5000, ),
'holder_running_qubes':
RunningQubesInterceptor(qubes),
}),
interceptors_by_name=profile_if_requested(
{'battery': BatteryInterceptor()})))
intercept_i3status(proc, restarted, modify)
def setUp(self):
self.app = Qubes()
self.vm = self.app.domains[self.vm_name]
# self._reboot()
if self.vm.is_running():
pass
else:
self.vm.start()
def __init__(self):
self.qubes_app = Qubes()
self.pools = []
self.total_size = 0
self.used_size = 0
self.warning_message = []
self.__populate_pools()
def main():
qubes_app = Qubes()
qt_app = QtGui.QApplication(sys.argv)
log_window = LogDialog(qubes_app, sys.argv[1])
log_window.show()
qt_app.exec_()
qt_app.exit()
def parse_args():
app = Qubes()
names = [x.name for x in app.domains if x.klass != 'AdminVM']
ap = ArgumentParser()
ap.add_argument('vm', choices=names)
ap.add_argument('--rules', default=DEFAULT_RULES, nargs='*')
args = ap.parse_args()
args.vm = next(x for x in app.domains if x.name == args.vm)
return args
def setUp(self):
self.app = Qubes()
with open("config.json") as c:
config = json.load(c)
if 'environment' not in config:
config['environment'] = 'dev'
if config['environment'] == 'prod':
self.apt_url = FPF_APT_SOURCES_BUSTER
else:
self.apt_url = FPF_APT_SOURCES_BUSTER_DEV
def setUp(self):
self.app = Qubes()
with open("config.json") as c:
config = json.load(c)
if "environment" not in config:
config["environment"] = "dev"
if config["environment"] == "prod":
self.apt_url = FPF_APT_SOURCES_BUSTER
else:
self.apt_url = FPF_APT_SOURCES_BUSTER_DEV
def setUp(self):
super(BackupTest, self).setUp()
# mock up nonexistence of saved backup settings
self.patcher = unittest.mock.patch('builtins.open')
self.mock_open = self.patcher.start()
self.mock_open.side_effect = FileNotFoundError()
self.addCleanup(self.patcher.stop)
self.qapp = Qubes()
self.qtapp = QtGui.QApplication(sys.argv)
self.dialog = backup_gui.BackupVMsWindow(self.qtapp, self.qapp)
def setUp(self):
super(GlobalSettingsTest, self).setUp()
self.qtapp, self.loop = init_qtapp()
self.qapp = Qubes()
self.dialog = global_settings.GlobalSettingsWindow(
self.qtapp, self.qapp)
self.setattr_patcher = unittest.mock.patch.object(
type(self.dialog.qubes_app), "__setattr__")
self.setattr_mock = self.setattr_patcher.start()
self.addCleanup(self.setattr_patcher.stop)
def setUp(self):
super(QubeManagerTest, self).setUp()
# # todo: mockup no settings file
# self.patcher = unittest.mock.patch('builtins.open')
# self.mock_open = self.patcher.start()
# self.mock_open.side_effect = FileNotFoundError()
# self.addCleanup(self.patcher.stop)
self.qapp = Qubes()
self.qtapp = QtGui.QApplication(sys.argv)
self.dialog = qube_manager.VmManagerWindow(self.qtapp, self.qapp)
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 setUpClass(cls):
qapp = Qubes()
cls.dom0_name = "dom0"
cls.vms = []
cls.running_vm = None
for vm in qapp.domains:
if vm.klass != "AdminVM" and vm.is_running():
cls.running_vm = vm.name
if vm.klass != "AdminVM" and vm.get_disk_utilization() > 0:
cls.vms.append(vm.name)
if cls.running_vm and len(cls.vms) >= 3:
break
def main():
qt_app = QtGui.QApplication(sys.argv)
qt_app.setOrganizationName("The Qubes Project")
qt_app.setOrganizationDomain("http://qubes-os.org")
qt_app.setApplicationName("Qube Manager")
qt_app.setWindowIcon(QtGui.QIcon.fromTheme("qubes-manager"))
sys.excepthook = handle_exception
qubes_app = Qubes()
manager_window = VmManagerWindow(qubes_app, qt_app)
manager_window.show()
manager_window.update_table()
qt_app.exec_()
def main():
qtapp = QtGui.QApplication(sys.argv)
qtapp.setOrganizationName("The Qubes Project")
qtapp.setOrganizationDomain("http://qubes-os.org")
qtapp.setApplicationName("Qubes Global Settings")
sys.excepthook = handle_exception
app = Qubes()
global_window = GlobalSettingsWindow(qtapp, app)
global_window.show()
qtapp.exec_()
qtapp.exit()
def main():
qt_app = QtWidgets.QApplication(sys.argv)
qt_app.setOrganizationName("The Qubes Project")
qt_app.setOrganizationDomain("http://qubes-os.org")
qt_app.setApplicationName("Qubes Restore VMs")
sys.excepthook = handle_exception
qubes_app = Qubes()
restore_window = RestoreVMsWindow(qt_app, qubes_app)
restore_window.show()
qt_app.exec_()
qt_app.exit()
def main():
qt_app = QtGui.QApplication(sys.argv)
qt_app.setOrganizationName("The Qubes Project")
qt_app.setOrganizationDomain("http://qubes-os.org")
qt_app.setApplicationName("Qubes Backup VMs")
sys.excepthook = handle_exception
app = Qubes()
backup_window = BackupVMsWindow(qt_app, app)
backup_window.show()
qt_app.exec_()
qt_app.exit()
def setUp(self):
super(NewVmTest, self).setUp()
self.qtapp, self.loop = init_qtapp()
self.qapp = Qubes()
# mock up the Create VM Thread to avoid changing system state
self.patcher_thread = unittest.mock.patch(
'qubesmanager.create_new_vm.CreateVMThread')
self.mock_thread = self.patcher_thread.start()
self.addCleanup(self.patcher_thread.stop)
# mock the progress dialog to speed testing up
self.patcher_progress = unittest.mock.patch(
'PyQt5.QtWidgets.QProgressDialog')
self.mock_progress = self.patcher_progress.start()
self.addCleanup(self.patcher_progress.stop)
self.dialog = create_new_vm.NewVmDlg(self.qtapp, self.qapp)
def __init__(self, **properties):
super().__init__(**properties)
self.pool_warned = False
self.vms_warned = set()
self.qubes_app = Qubes()
self.set_application_id("org.qubes.qui.tray.DiskSpace")
self.register()
prefs_action = Gio.SimpleAction.new("prefs", GLib.VariantType.new("s"))
prefs_action.connect("activate", launch_preferences_dialog)
self.add_action(prefs_action)
self.icon = Gtk.StatusIcon()
self.icon.connect('button-press-event', self.make_menu)
self.refresh_icon()
GObject.timeout_add_seconds(120, self.refresh_icon)
Gtk.main()
def __init__(self, **properties):
super().__init__(**properties)
self.qubes_app: Qubes = Qubes()
self.set_application_id("org.qubes.qui.tray.RemoteSupport")
self.register()
# load objects
self.builder: Gtk.Builder = Gtk.Builder()
self.builder.add_from_file(pkg_resources.resource_filename(
__name__, 'remote_gui.glade'))
# ask window
self.ask_window: AskWindow = AskWindow(
self.builder, self.qubes_app, self)
self.ask_window.ok_button.connect("clicked", self.start_remote)
self.ask_window.cancel_button.connect("clicked", self.exit_app)
# progress window
self.progress_window: ProgressWindow = ProgressWindow(
self.builder, self.qubes_app, self)
self.progress_window.abort_button.connect("clicked", self.exit_app)
# status icon
self.status_icon: RemoteSupportIcon = RemoteSupportIcon(
self.qubes_app, self.exit_app)
self.start_process: typing.Optional[subprocess.Popen] = None
self.current_window: typing.Optional[Gtk.Dialog] = None
self.ask_window.ask_dialog.show()
self.vm_name: typing.Optional[str] = None
self.aborted = False
Gtk.main()
class VMSettingsTest(unittest.TestCase):
def setUp(self):
super(VMSettingsTest, self).setUp()
self.qtapp, self.loop = init_qtapp()
self.mock_qprogress = unittest.mock.patch(
'PyQt5.QtWidgets.QProgressDialog')
self.mock_qprogress.start()
self.addCleanup(self.mock_qprogress.stop)
self.qapp = Qubes()
if "test-vm" in self.qapp.domains:
del self.qapp.domains["test-vm"]
def tearDown(self):
if "test-vm" in self.qapp.domains:
del self.qapp.domains["test-vm"]
super(VMSettingsTest, self).tearDown()
def test_00_load_correct_tab(self):
self.vm = self.qapp.add_new_vm("AppVM", "test-vm", "red")
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="basic")
self.assertTrue(
self.dialog.tabWidget.currentWidget() is self.dialog.basic_tab)
self.dialog.deleteLater()
self.qtapp.processEvents()
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="advanced")
self.assertTrue(
self.dialog.tabWidget.currentWidget() is self.dialog.advanced_tab)
self.dialog.deleteLater()
self.qtapp.processEvents()
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="firewall")
self.assertTrue(
self.dialog.tabWidget.currentWidget() is self.dialog.firewall_tab)
self.dialog.deleteLater()
self.qtapp.processEvents()
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="devices")
self.assertTrue(
self.dialog.tabWidget.currentWidget() is self.dialog.devices_tab)
self.dialog.deleteLater()
self.qtapp.processEvents()
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="applications")
self.assertTrue(
self.dialog.tabWidget.currentWidget() is self.dialog.apps_tab)
self.dialog.deleteLater()
self.qtapp.processEvents()
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="services")
self.assertTrue(
self.dialog.tabWidget.currentWidget() is self.dialog.services_tab)
self.dialog.deleteLater()
self.qtapp.processEvents()
def test_01_basic_tab_default(self):
self.vm = self.qapp.add_new_vm("AppVM", "test-vm", "blue")
# set the vm to have a default template and netvm
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="basic")
self.assertEqual(self.dialog.vmname.text(), "test-vm",
"Name displayed incorrectly")
self.assertTrue("blue" in self.dialog.vmlabel.currentText(),
"Incorrect label displayed")
displayed_template = self.dialog.template_name.currentText()
correct_template = self.vm.template.name
self.assertTrue("current" in displayed_template,
"Template incorrectly not shown as current")
self.assertTrue(correct_template in displayed_template,
"Template not displayed correctly")
displayed_netvm = self.dialog.netVM.currentText()
correct_netvm = self.vm.netvm.name
self.assertTrue("current" in displayed_netvm,
"NetVM incorrectly not shown as current")
self.assertTrue(correct_netvm in displayed_netvm,
"NetVM not displayed correctly")
self.assertEqual(self.dialog.include_in_backups.isChecked(),
self.vm.include_in_backups,
"Incorrect 'include in backups' state")
self.assertEqual(self.dialog.autostart_vm.isChecked(),
self.vm.autostart, "Incorrect 'autostart' state")
self.assertEqual(self.dialog.type_label.text(), self.vm.klass,
"Incorrect class displayed")
self.assertEqual(self.dialog.ip_label.text(), self.vm.ip,
"Incorrect IP displayed")
self.assertEqual(self.dialog.netmask_label.text(),
self.vm.visible_netmask,
"Incorrect netmask displayed")
self.assertEqual(self.dialog.gateway_label.text(),
self.vm.visible_gateway,
"Incorrect gateway displayed")
self.assertEqual(self.dialog.max_priv_storage.value(),
self.vm.volumes['private'].size // 1024**2,
"Incorrect max private storage size")
self.assertEqual(self.dialog.root_resize.value(),
self.vm.volumes['root'].size // 1024**2,
"Incorrect max private root size")
def test_02_basic_tab_nones(self):
self.vm = self.qapp.add_new_vm("StandaloneVM", "test-vm", "blue")
# set the vm to have a default template and netvm
self.vm.netvm = None
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="basic")
self.assertEqual("", self.dialog.template_name.currentText(),
"No template incorrectly displayed")
displayed_netvm = self.dialog.netVM.currentText()
self.assertTrue("current" in displayed_netvm,
"None NetVM incorrectly not shown as current")
self.assertTrue("none" in displayed_netvm,
"None NetVM not displayed correctly")
self.assertEqual(self.dialog.type_label.text(), "StandaloneVM",
"Type displayed incorrectly for standaloneVM")
self.assertEqual(self.dialog.ip_label.text(), "---",
"Incorrect IP displayed")
self.assertEqual(self.dialog.netmask_label.text(), "---",
"Incorrect netmask displayed")
self.assertEqual(self.dialog.gateway_label.text(), "---",
"Incorrect gateway displayed")
def test_03_change_label(self):
self.vm = self.qapp.add_new_vm("AppVM", "test-vm", "blue")
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="basic")
self.dialog.show()
new_label = self._set_noncurrent(self.dialog.vmlabel)
self._click_ok()
self.assertEqual(str(self.vm.label), new_label,
"Label is not set correctly")
def test_04_change_template(self):
self.vm = self.qapp.add_new_vm("AppVM", "test-vm", "blue")
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="basic")
new_template = self._set_noncurrent(self.dialog.template_name)
self._click_ok()
self.assertEqual(self.vm.template.name, new_template,
"Template is not set correctly")
def test_05_change_networking(self):
self.vm = self.qapp.add_new_vm("AppVM", "test-vm", "blue")
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="basic")
new_netvm = self._set_noncurrent(self.dialog.netVM)
self._click_ok()
self.assertEqual(self.vm.netvm.name, new_netvm,
"NetVM is not set correctly")
def test_06_change_networking_none(self):
self.vm = self.qapp.add_new_vm("AppVM", "test-vm", "blue")
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="basic")
self._set_none(self.dialog.netVM)
self._click_ok()
self.assertIsNone(self.vm.netvm, "None netVM is not set correctly")
def test_07_change_networking_to_default(self):
self.vm = self.qapp.add_new_vm("AppVM", "test-vm", "blue")
for vm in self.qapp.domains:
if getattr(vm, 'provides_network', False)\
and vm != self.qapp.default_netvm:
self.vm.netvm = vm
break
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="basic")
new_netvm = self._set_default(self.dialog.netVM)
self._click_ok()
self.assertTrue(self.vm.netvm.name in new_netvm,
"NetVM is not set correctly")
self.assertTrue(self.vm.property_is_default('netvm'))
def test_08_basic_checkboxes_true(self):
self.vm = self.qapp.add_new_vm("AppVM", "test-vm", "blue")
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="basic")
self.dialog.show()
self.dialog.include_in_backups.setChecked(True)
self.dialog.autostart_vm.setChecked(True)
self._click_ok()
self.assertTrue(self.vm.include_in_backups,
"Include in backups not set to true")
self.assertTrue(self.vm.autostart, "Autostart not set to true")
def test_09_basic_checkboxes_false(self):
self.vm = self.qapp.add_new_vm("AppVM", "test-vm", "blue")
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="basic")
self.dialog.show()
self.dialog.include_in_backups.setChecked(False)
self.dialog.autostart_vm.setChecked(False)
self._click_ok()
self.assertFalse(self.vm.include_in_backups,
"Include in backups not set to false")
self.assertFalse(self.vm.autostart, "Autostart not set to false")
def test_10_increase_private_storage(self):
self.vm = self.qapp.add_new_vm("AppVM", "test-vm", "blue")
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="basic")
current_storage = self.vm.volumes['private'].size // 1024**2
new_storage = current_storage + 512
self.dialog.max_priv_storage.setValue(new_storage)
self._click_ok()
self.assertEqual(self.vm.volumes['private'].size // 1024**2,
new_storage)
# TODO are dependencies correctly processed
@unittest.mock.patch('PyQt5.QtWidgets.QProgressDialog')
@unittest.mock.patch('PyQt5.QtWidgets.QInputDialog.getText')
@unittest.mock.patch('qubesmanager.settings.RenameVMThread')
def test_11_rename_vm(self, mock_thread, mock_input, _):
self.vm = self.qapp.add_new_vm("AppVM", "test-vm", "blue")
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="basic")
self.assertTrue(self.dialog.rename_vm_button.isEnabled())
mock_input.return_value = ("test-vm2", True)
self.dialog.rename_vm_button.click()
mock_thread.assert_called_with(self.vm, "test-vm2", unittest.mock.ANY)
mock_thread().start.assert_called_with()
@unittest.mock.patch('qubesmanager.clone_vm.CloneVMDlg')
def test_12_clone_vm(self, mock_clone):
self.vm = self.qapp.add_new_vm("AppVM", "test-vm", "blue")
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="basic")
self.assertTrue(self.dialog.clone_vm_button.isEnabled())
self.dialog.clone_vm_button.click()
mock_clone.assert_called_once_with(self.qtapp,
self.qapp,
src_vm=self.vm)
@unittest.mock.patch('PyQt5.QtWidgets.QMessageBox.warning')
@unittest.mock.patch('PyQt5.QtWidgets.QProgressDialog')
@unittest.mock.patch('PyQt5.QtWidgets.QInputDialog.getText')
@unittest.mock.patch('qubesmanager.common_threads.RemoveVMThread')
def test_13_remove_vm(self, mock_thread, mock_input, _, mock_warning):
self.vm = self.qapp.add_new_vm("AppVM", "test-vm", "blue")
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="basic")
self.assertTrue(self.dialog.delete_vm_button.isEnabled())
# try with a wrong name
mock_input.return_value = ("test-vm2", True)
self.dialog.delete_vm_button.click()
self.assertEqual(mock_warning.call_count, 1)
# and now correct one
mock_input.return_value = ("test-vm", True)
self.dialog.delete_vm_button.click()
mock_thread.assert_called_with(self.vm)
mock_thread().start.assert_called_with()
# Advanced Tab
def test_20_advanced_loads(self):
self.vm = self.qapp.add_new_vm("AppVM", "test-vm", "blue")
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="advanced")
self.assertEqual(self.dialog.init_mem.value(), self.vm.memory,
"Incorrect initial memory")
# default maxmem
self.assertEqual(self.dialog.max_mem_size.value(),
self.vm.property_get_default('maxmem'),
"Maxmem incorrectly displayed for default value")
self.assertEqual(self.dialog.vcpus.value(), self.vm.vcpus,
"Incorrect number of VCPUs")
self.assertTrue(self.dialog.include_in_balancing.isChecked(),
"Include in memory balancing incorrectly not checked")
# debug mode
self.assertEqual(self.dialog.run_in_debug_mode.isChecked(),
self.vm.debug, "Incorrect 'run in debug mode' state")
# kernel
self.assertTrue(self.vm.kernel in self.dialog.kernel.currentText(),
"Kernel displayed incorrectly")
# default dispvm
self.assertTrue(
str(self.vm.default_dispvm)
in self.dialog.default_dispvm.currentText(),
"Default dispVM incorrectly displayed")
self.assertEqual(self.vm.template_for_dispvms,
self.dialog.dvm_template_checkbox.isChecked(),
"Incorrectly shown to be template for dispvms")
# virtmode
self.assertTrue("default" in self.dialog.virt_mode.currentText())
self.assertTrue("PVH" in self.dialog.virt_mode.currentText())
def test_21_nondefaultmaxmem(self):
self.vm = self.qapp.add_new_vm("AppVM", "test-vm", "blue")
self.vm.maxmem = 3500
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="advanced")
self.assertEqual(self.dialog.max_mem_size.value(), 3500)
self.dialog.include_in_balancing.setChecked(False)
self._click_ok()
self.assertEqual(self.vm.maxmem, 0)
self.dialog.deleteLater()
self.qtapp.processEvents()
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="advanced")
self.assertFalse(self.dialog.include_in_balancing.isChecked())
self.dialog.include_in_balancing.setChecked(True)
self.assertEqual(self.dialog.max_mem_size.value(), 3500)
self._click_ok()
self.assertEqual(self.vm.maxmem, 3500)
def test_22_initmem(self):
self.vm = self.qapp.add_new_vm("AppVM", "test-vm", "blue")
self.vm.memory = 500
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="advanced")
self.assertEqual(self.dialog.init_mem.value(), 500,
"Incorrect initial memory")
self.dialog.init_mem.setValue(600)
self._click_ok()
self.assertEqual(self.vm.memory, 600, "Setting initial memory failed")
def test_23_vcpus(self):
self.vm = self.qapp.add_new_vm("AppVM", "test-vm", "blue")
self.vm.vcpus = 1
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="advanced")
self.assertEqual(self.dialog.vcpus.value(), 1,
"Incorrect number of VCPUs")
self.dialog.vcpus.setValue(2)
self._click_ok()
self.assertEqual(self.vm.vcpus, 2, "Incorrect number of VCPUs")
def test_24_kernel(self):
self.vm = self.qapp.add_new_vm("AppVM", "test-vm", "blue")
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="advanced")
self.dialog.show()
new_kernel = self._set_noncurrent(self.dialog.kernel)
self._click_ok()
self.assertEqual(self.vm.kernel, new_kernel)
self.dialog.deleteLater()
self.qtapp.processEvents()
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="advanced")
self.dialog.show()
self._set_default(self.dialog.kernel)
self._click_ok()
self.assertTrue(self.vm.property_is_default('kernel'))
def test_25_virtmode_change(self):
self.vm = self.qapp.add_new_vm("AppVM", "test-vm", "blue")
modes = ["HVM", "PVH", "PV"]
for mode in modes:
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="advanced")
self._set_value(self.dialog.virt_mode, mode)
self._click_ok()
self.assertEqual(self.vm.virt_mode.upper(), mode)
self.dialog.deleteLater()
self.qtapp.processEvents()
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="advanced")
self._set_default(self.dialog.virt_mode)
self._click_ok()
self.assertTrue(self.vm.property_is_default('virt_mode'))
def test_26_default_dispvm(self):
self.vm = self.qapp.add_new_vm("AppVM", "test-vm", "blue")
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="advanced")
new_dvm = self._set_noncurrent(self.dialog.default_dispvm)
self._click_ok()
self.assertEqual(self.vm.default_dispvm.name, new_dvm)
self.dialog.deleteLater()
self.qtapp.processEvents()
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="advanced")
self._set_default(self.dialog.default_dispvm)
self._click_ok()
self.assertTrue(self.vm.property_is_default('default_dispvm'))
@unittest.mock.patch('subprocess.check_call')
def test_27_boot_cdrom(self, mock_call):
self.vm = self.qapp.add_new_vm("AppVM", "test-vm", "blue")
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="advanced")
self.dialog.boot_from_device_button.click()
mock_call.assert_called_with(['qubes-vm-boot-from-device', "test-vm"])
def test_28_advanced_debug_false(self):
self.vm = self.qapp.add_new_vm("AppVM", "test-vm", "blue")
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="advanced")
self.dialog.show()
self.dialog.run_in_debug_mode.setChecked(False)
self._click_ok()
self.assertFalse(self.vm.debug, "Debug mode not set to false")
def test_28_advanced_debug_true(self):
self.vm = self.qapp.add_new_vm("AppVM", "test-vm", "blue")
self.dialog = vm_settings.VMSettingsWindow(self.vm,
qapp=self.qtapp,
qubesapp=self.qapp,
init_page="advanced")
self.dialog.show()
self.dialog.run_in_debug_mode.setChecked(True)
self._click_ok()
self.assertTrue(self.vm.debug, "Debug mode not set to true")
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 _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_default(self, widget):
if widget.count() < 2:
self.skipTest("not enough choices for " + widget.objectName())
widget.setCurrentIndex(0)
while "default" not in widget.currentText():
widget.setCurrentIndex(widget.currentIndex() + 1)
return widget.currentText()
def _set_none(self, widget):
if widget.count() < 2:
self.skipTest("not enough choices for " + widget.objectName())
widget.setCurrentIndex(0)
while "none" not in widget.currentText():
widget.setCurrentIndex(widget.currentIndex() + 1)
return widget.currentText()
def _set_value(self, widget, value):
if widget.count() < 2:
self.skipTest("not enough choices for " + widget.objectName())
widget.setCurrentIndex(0)
while value != widget.currentText():
widget.setCurrentIndex(widget.currentIndex() + 1)
return widget.currentText()
def setUp(self):
self.app = Qubes()
with open("config.json") as c:
self.config = json.load(c)
def setUp(self):
super(BackupUtilsTest, self).setUp()
self.qapp = Qubes()
self.qtapp = QtGui.QApplication(["test", "-style", "cleanlooks"])
self.loop = quamash.QEventLoop(self.qtapp)
def setUp(self):
self.app = Qubes()
