input-remapper/tests/unit/test_control.py
jonasBoss 3637204bff
Frontend Refactor (#375)
* Tests for the GuiEventHandler

* Implement GuiEventHandler

* tests for data manager

* Implemented data_manager

* Remove Ellipsis from type hint

* workaround for old pydantic version

* workaround for old pydantic version

* some more tests for data_manager

* Updated Data Manager

* move DeviceSelection to its own class

* Data Manager no longer listens for events

* Moved PresetSelection to its own class

* MappingListBox and SelectionLable Listen to the EventHandler

* DataManager no longer creates its own data objects in the init

* removed global reader object

* Changed UI startup

* created backend Interface

* event_handler debug logs show function which emit a event

* some cleanup

* added target selector to components

* created code editor component

* adapted autocompletion & some cleanup

* black

* connected some buttons to the event_handler

* tests for data_manager newest_preset and group

* cleanup presets and test_presets

* migrated confirm delete dialog

* backend tests

* controller tests

* add python3-gi to ci

* more dependencies

* and more ...

* Github-Actions workaround

remove this commit

* not so many permission denyed errors in test.yml

* Fix #404 (hopefully)

* revert Github-Actions workaround

* More tests

* event_handler allows for event supression

* more tests

* WIP Implement Key recording

* Start and Stop Injection

* context no longer stores preset

* restructured the RelToBtnHandler

* Simplified read_loop

* Implement async iterator for ipc.pipe

* multiple event actions

* helper now implements mapping handlers to read inputs all with async

* updated and simplified reader 

the helper uses the mapping handlers, so the reader now can be much simpler

* Fixed race condition in tests

* implemented DataBus

* Fixed a UIMapping bug where the last_error would not be deleted

* added a immutable variant of the UIMapping

* updated data_manager to use data_bus

* Uptdated tests to use the DataBus

* Gui uses DataBus

* removed EventHandler

* Renamed controller methods

* Implemented recording toggle

* implemented StatusBar

* Sending validation errors to status bar

* sending injection status to status bar

* proper preset renaming

* implemented copy preset in the data manager

* implemented copy_preset in controller

* fixed a bug where a wron selection lable would update

* no longer send invalid data over the bus, if the preset or group changes

* Implement create and delete mapping

* Allow for frontend specific mapping defaults

* implemented autoload toggle

* cleanup user_interface

* removed editor

* Docstings renaming and ordering of methods

* more simplifications to user_interface

* integrated backend into data_manager

* removed active preset

* transformation tests

* controller tests

* fix missing uinputs in gui

* moved some tests and implemented basic tests for mapping handlers

* docstring reformatting

Co-authored-by: Tobi <proxima@sezanzeb.de>

* allow for empty groups

* docstring

* fixed TestGroupFromHelper

* some work on integration tests

* test for annoying import error in tests

* testing if test_user_interface works

* I feel lucky

* not so lucky

* some more tests

* fixed but where the group_key was used as folder name

* Fixed a bug where state=NO_GRAB would never be read from the injector

* allow to stop the recorder

* working on integration tests

* integration tests

* fixed more integration tests

* updated coveragerc

* no longer attempt to record keys when injecting

* event_reader cleans up not finished tasks

* More integration tests

* All tests pass

* renamed data_bus

* WIP fixing typing issues

* more typing fixes

* added keyboard+mouse device to tests

* cleanup imports

* new read loop because the evdev async read loop can not be cancelled

* Added field to modify mapping name

* created tests for components

* even more component tests

* do component tests need a screen?

* apparently they do :_(

* created release_input switch

* Don't record relative axis when movement is slow

* show delete dialog above main window

* wip basic dialog to edit combination

* some gui changes to the combination-editor

* Simple implementation of CombinationListbox

* renamed attach_to_events method and mark as private

* shorter str() for UInputsData

* moved logic to generate readable event string from combination to event

* new mapping parameter force release timeout

this helps with the helper when recording multiple relative axis at once

* make it possible to rearange the event_combination

* more work on the combination editor

* tests for DataManager.load_event

* simplyfied test_controller

* more controller tests

* Implement input threshold in gui

* greater range for time dependent unit test

* implemented a output-axis selector

* data_manager now provides injector state

* black

* mypy

* Updated confirm cancel dialog

* created release timeout input

* implemented transformation graph

* Added sliders for gain, expo and deadzone

* fix bug where the system_mapping was overridden in each injector thread

* updated slider settings

* removed debug statement

* explicitly checking output code against None (0 is a valid code)

* usage

* Allow for multiple axis to be activated by same button

* readme

* only warn about not implemented mapping-handler

don't fail to create event-pipelines

* More accurate event names

* Allow removal of single events from the input-combination

* rename callback to notify_callback

* rename event message to selected_event

* made read_continuisly private

* typing for autocompletion

* docstrings for message_broker messages

* make components methods and propreties private

* gui spacings

* removed eval

* make some controller functions private

* move status message generation from data_manager to controller

* parse mapping errors in controller for more helpful messages

* remove system_mapping from code editor

* More component tests

* more tests

* mypy

* make grab_devices less greedy (partial mitigation for #435)

only grab one device if there are multiple which can satisfy the same mapping

* accumulate more values in test

* docstrings

* Updated status messages

* comments, docstrings, imports

Co-authored-by: Tobi <proxima@sezanzeb.de>
2022-07-23 10:53:41 +02:00

316 lines
12 KiB
Python

#!/usr/bin/python3
# -*- coding: utf-8 -*-
# input-remapper - GUI for device specific keyboard mappings
# Copyright (C) 2022 sezanzeb <proxima@sezanzeb.de>
#
# This file is part of input-remapper.
#
# input-remapper 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 3 of the License, or
# (at your option) any later version.
#
# input-remapper 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 input-remapper. If not, see <https://www.gnu.org/licenses/>.
"""Testing the input-remapper-control command"""
from tests.test import quick_cleanup, tmp
import os
import time
import unittest
from unittest import mock
import collections
from importlib.util import spec_from_loader, module_from_spec
from importlib.machinery import SourceFileLoader
from inputremapper.configs.global_config import global_config
from inputremapper.daemon import Daemon
from inputremapper.configs.preset import Preset
from inputremapper.configs.paths import get_preset_path
from inputremapper.groups import groups
def import_control():
"""Import the core function of the input-remapper-control command."""
bin_path = os.path.join(os.getcwd(), "bin", "input-remapper-control")
loader = SourceFileLoader("__not_main_idk__", bin_path)
spec = spec_from_loader("__not_main_idk__", loader)
module = module_from_spec(spec)
spec.loader.exec_module(module)
return module.communicate, module.utils, module.internals
communicate, utils, internals = import_control()
options = collections.namedtuple(
"options",
["command", "config_dir", "preset", "device", "list_devices", "key_names", "debug"],
)
class TestControl(unittest.TestCase):
def tearDown(self):
quick_cleanup()
def test_autoload(self):
device_keys = ["Foo Device 2", "Bar Device"]
groups_ = [groups.find(key=key) for key in device_keys]
presets = ["bar0", "bar", "bar2"]
paths = [
get_preset_path(groups_[0].name, presets[0]),
get_preset_path(groups_[1].name, presets[1]),
get_preset_path(groups_[1].name, presets[2]),
]
Preset(paths[0]).save()
Preset(paths[1]).save()
Preset(paths[2]).save()
daemon = Daemon()
start_history = []
stop_counter = 0
# using an actual injector is not within the scope of this test
class Injector:
def stop_injecting(self, *args, **kwargs):
nonlocal stop_counter
stop_counter += 1
def start_injecting(device, preset):
print(f'\033[90mstart_injecting "{device}" "{preset}"\033[0m')
start_history.append((device, preset))
daemon.injectors[device] = Injector()
daemon.start_injecting = start_injecting
global_config.set_autoload_preset(groups_[0].key, presets[0])
global_config.set_autoload_preset(groups_[1].key, presets[1])
communicate(options("autoload", None, None, None, False, False, False), daemon)
self.assertEqual(len(start_history), 2)
self.assertEqual(start_history[0], (groups_[0].key, presets[0]))
self.assertEqual(start_history[1], (groups_[1].key, presets[1]))
self.assertIn(groups_[0].key, daemon.injectors)
self.assertIn(groups_[1].key, daemon.injectors)
self.assertFalse(
daemon.autoload_history.may_autoload(groups_[0].key, presets[0])
)
self.assertFalse(
daemon.autoload_history.may_autoload(groups_[1].key, presets[1])
)
# calling autoload again doesn't load redundantly
communicate(options("autoload", None, None, None, False, False, False), daemon)
self.assertEqual(len(start_history), 2)
self.assertEqual(stop_counter, 0)
self.assertFalse(
daemon.autoload_history.may_autoload(groups_[0].key, presets[0])
)
self.assertFalse(
daemon.autoload_history.may_autoload(groups_[1].key, presets[1])
)
# unless the injection in question ist stopped
communicate(
options("stop", None, None, groups_[0].key, False, False, False),
daemon,
)
self.assertEqual(stop_counter, 1)
self.assertTrue(
daemon.autoload_history.may_autoload(groups_[0].key, presets[0])
)
self.assertFalse(
daemon.autoload_history.may_autoload(groups_[1].key, presets[1])
)
communicate(options("autoload", None, None, None, False, False, False), daemon)
self.assertEqual(len(start_history), 3)
self.assertEqual(start_history[2], (groups_[0].key, presets[0]))
self.assertFalse(
daemon.autoload_history.may_autoload(groups_[0].key, presets[0])
)
self.assertFalse(
daemon.autoload_history.may_autoload(groups_[1].key, presets[1])
)
# if a device name is passed, will only start injecting for that one
communicate(options("stop-all", None, None, None, False, False, False), daemon)
self.assertTrue(
daemon.autoload_history.may_autoload(groups_[0].key, presets[0])
)
self.assertTrue(
daemon.autoload_history.may_autoload(groups_[1].key, presets[1])
)
self.assertEqual(stop_counter, 3)
global_config.set_autoload_preset(groups_[1].key, presets[2])
communicate(
options("autoload", None, None, groups_[1].key, False, False, False),
daemon,
)
self.assertEqual(len(start_history), 4)
self.assertEqual(start_history[3], (groups_[1].key, presets[2]))
self.assertTrue(
daemon.autoload_history.may_autoload(groups_[0].key, presets[0])
)
self.assertFalse(
daemon.autoload_history.may_autoload(groups_[1].key, presets[2])
)
# autoloading for the same device again redundantly will not autoload
# again
communicate(
options("autoload", None, None, groups_[1].key, False, False, False),
daemon,
)
self.assertEqual(len(start_history), 4)
self.assertEqual(stop_counter, 3)
self.assertFalse(
daemon.autoload_history.may_autoload(groups_[1].key, presets[2])
)
# any other arbitrary preset may be autoloaded
self.assertTrue(daemon.autoload_history.may_autoload(groups_[1].key, "quuuux"))
# after 15 seconds it may be autoloaded again
daemon.autoload_history._autoload_history[groups_[1].key] = (
time.time() - 16,
presets[2],
)
self.assertTrue(
daemon.autoload_history.may_autoload(groups_[1].key, presets[2])
)
def test_autoload_other_path(self):
device_names = ["Foo Device", "Bar Device"]
groups_ = [groups.find(name=name) for name in device_names]
presets = ["bar123", "bar2"]
config_dir = os.path.join(tmp, "qux", "quux")
paths = [
os.path.join(config_dir, "presets", device_names[0], presets[0] + ".json"),
os.path.join(config_dir, "presets", device_names[1], presets[1] + ".json"),
]
Preset(paths[0]).save()
Preset(paths[1]).save()
daemon = Daemon()
start_history = []
daemon.start_injecting = lambda *args: start_history.append(args)
global_config.path = os.path.join(config_dir, "config.json")
global_config.load_config()
global_config.set_autoload_preset(device_names[0], presets[0])
global_config.set_autoload_preset(device_names[1], presets[1])
communicate(
options("autoload", config_dir, None, None, False, False, False),
daemon,
)
self.assertEqual(len(start_history), 2)
self.assertEqual(start_history[0], (groups_[0].key, presets[0]))
self.assertEqual(start_history[1], (groups_[1].key, presets[1]))
def test_start_stop(self):
group = groups.find(key="Foo Device 2")
preset = "preset9"
daemon = Daemon()
start_history = []
stop_history = []
stop_all_history = []
daemon.start_injecting = lambda *args: start_history.append(args)
daemon.stop_injecting = lambda *args: stop_history.append(args)
daemon.stop_all = lambda *args: stop_all_history.append(args)
communicate(
options("start", None, preset, group.paths[0], False, False, False),
daemon,
)
self.assertEqual(len(start_history), 1)
self.assertEqual(start_history[0], (group.key, preset))
communicate(
options("stop", None, None, group.paths[1], False, False, False),
daemon,
)
self.assertEqual(len(stop_history), 1)
# provided any of the groups paths as --device argument, figures out
# the correct group.key to use here
self.assertEqual(stop_history[0], (group.key,))
communicate(options("stop-all", None, None, None, False, False, False), daemon)
self.assertEqual(len(stop_all_history), 1)
self.assertEqual(stop_all_history[0], ())
def test_config_not_found(self):
key = "Foo Device 2"
path = "~/a/preset.json"
config_dir = "/foo/bar"
daemon = Daemon()
start_history = []
stop_history = []
daemon.start_injecting = lambda *args: start_history.append(args)
daemon.stop_injecting = lambda *args: stop_history.append(args)
options_1 = options("start", config_dir, path, key, False, False, False)
self.assertRaises(SystemExit, lambda: communicate(options_1, daemon))
options_2 = options("stop", config_dir, None, key, False, False, False)
self.assertRaises(SystemExit, lambda: communicate(options_2, daemon))
def test_autoload_config_dir(self):
daemon = Daemon()
path = os.path.join(tmp, "foo")
os.makedirs(path)
with open(os.path.join(path, "config.json"), "w") as file:
file.write('{"foo":"bar"}')
self.assertIsNone(global_config.get("foo"))
daemon.set_config_dir(path)
# since daemon and this test share the same memory, the global_config
# object that this test can access will be modified
self.assertEqual(global_config.get("foo"), "bar")
# passing a path that doesn't exist or a path that doesn't contain
# a config.json file won't do anything
os.makedirs(os.path.join(tmp, "bar"))
daemon.set_config_dir(os.path.join(tmp, "bar"))
self.assertEqual(global_config.get("foo"), "bar")
daemon.set_config_dir(os.path.join(tmp, "qux"))
self.assertEqual(global_config.get("foo"), "bar")
def test_internals(self):
with mock.patch("os.system") as os_system_patch:
internals(options("helper", None, None, None, False, False, False))
os_system_patch.assert_called_once()
self.assertIn("input-remapper-helper", os_system_patch.call_args.args[0])
self.assertNotIn("-d", os_system_patch.call_args.args[0])
with mock.patch("os.system") as os_system_patch:
internals(options("start-daemon", None, None, None, False, False, True))
os_system_patch.assert_called_once()
self.assertIn("input-remapper-service", os_system_patch.call_args.args[0])
self.assertIn("-d", os_system_patch.call_args.args[0])
if __name__ == "__main__":
unittest.main()