# vim: ft=python fileencoding=utf-8 sts=4 sw=4 et: # Copyright 2014-2018 Florian Bruhin (The Compiler) : # # This file is part of qutebrowser. # # qutebrowser 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. # # qutebrowser 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 qutebrowser. If not, see . """Tests for BaseKeyParser.""" from unittest import mock from PyQt5.QtCore import Qt import pytest from qutebrowser.keyinput import basekeyparser, keyutils # Alias because we need this a lot in here. def keyseq(s): return keyutils.KeySequence.parse(s) @pytest.fixture def keyparser(key_config_stub): """Fixture providing a BaseKeyParser supporting count/chains.""" kp = basekeyparser.BaseKeyParser(0, supports_count=True) kp.execute = mock.Mock() yield kp @pytest.fixture def handle_text(fake_keyevent, keyparser): """Helper function to handle multiple fake keypresses. Automatically uses the keyparser of the current test via the keyparser fixture. """ def func(*args): for enumval in args: keyparser.handle(fake_keyevent(enumval)) return func class TestDebugLog: """Make sure _debug_log only logs when do_log is set.""" def test_log(self, keyparser, caplog): keyparser._debug_log('foo') assert len(caplog.records) == 1 record = caplog.records[0] assert record.message == 'foo' def test_no_log(self, keyparser, caplog): keyparser.do_log = False keyparser._debug_log('foo') assert not caplog.records @pytest.mark.parametrize('input_key, supports_count, count, command', [ # (input_key, supports_count, expected) ('10', True, '10', ''), ('10g', True, '10', 'g'), ('10e4g', True, '4', 'g'), ('g', True, '', 'g'), ('0', True, '', ''), ('10g', False, '', 'g'), ]) def test_split_count(config_stub, key_config_stub, input_key, supports_count, count, command): kp = basekeyparser.BaseKeyParser(0, supports_count=supports_count) kp._read_config('normal') for info in keyseq(input_key): kp.handle(info.to_event()) assert kp._count == count assert kp._sequence == keyseq(command) @pytest.mark.usefixtures('keyinput_bindings') class TestReadConfig: def test_read_config_invalid(self, keyparser): """Test reading config without setting modename before.""" with pytest.raises(ValueError): keyparser._read_config() def test_read_config_modename(self, keyparser): """Test reading config with _modename set.""" keyparser._modename = 'normal' keyparser._read_config() assert keyseq('a') in keyparser.bindings def test_read_config_valid(self, keyparser): """Test reading config.""" keyparser._read_config('prompt') assert keyseq('ccc') in keyparser.bindings assert keyseq('') in keyparser.bindings keyparser._read_config('command') assert keyseq('ccc') not in keyparser.bindings assert keyseq('') not in keyparser.bindings assert keyseq('foo') in keyparser.bindings assert keyseq('') in keyparser.bindings def test_read_config_modename_none(self, keyparser): assert keyparser._modename is None # No config set so self._modename is None with pytest.raises(ValueError, match="read_config called with no mode " "given, but None defined so far!"): keyparser._read_config(None) @pytest.mark.parametrize('mode, changed_mode, expected', [ ('normal', 'normal', True), ('normal', 'command', False), ]) def test_read_config(self, keyparser, key_config_stub, mode, changed_mode, expected): keyparser._read_config(mode) # Sanity checks assert keyseq('a') in keyparser.bindings assert keyseq('new') not in keyparser.bindings key_config_stub.bind(keyseq('new'), 'message-info new', mode=changed_mode) assert keyseq('a') in keyparser.bindings assert (keyseq('new') in keyparser.bindings) == expected class TestHandle: @pytest.fixture(autouse=True) def read_config(self, keyinput_bindings, keyparser): keyparser._read_config('prompt') def test_valid_key(self, fake_keyevent, keyparser): keyparser.handle(fake_keyevent(Qt.Key_A, Qt.ControlModifier)) keyparser.handle(fake_keyevent(Qt.Key_X, Qt.ControlModifier)) keyparser.execute.assert_called_once_with('message-info ctrla', None) assert not keyparser._sequence def test_valid_key_count(self, fake_keyevent, keyparser): keyparser.handle(fake_keyevent(Qt.Key_5)) keyparser.handle(fake_keyevent(Qt.Key_A, Qt.ControlModifier)) keyparser.execute.assert_called_once_with('message-info ctrla', 5) @pytest.mark.parametrize('keys', [ [(Qt.Key_B, Qt.NoModifier), (Qt.Key_C, Qt.NoModifier)], [(Qt.Key_A, Qt.ControlModifier | Qt.AltModifier)], # Only modifier [(Qt.Key_Shift, Qt.ShiftModifier)], ]) def test_invalid_keys(self, fake_keyevent, keyparser, keys): for key, modifiers in keys: keyparser.handle(fake_keyevent(key, modifiers)) assert not keyparser.execute.called assert not keyparser._sequence def test_dry_run(self, fake_keyevent, keyparser): keyparser.handle(fake_keyevent(Qt.Key_B)) keyparser.handle(fake_keyevent(Qt.Key_A), dry_run=True) assert not keyparser.execute.called assert keyparser._sequence def test_dry_run_count(self, fake_keyevent, keyparser): keyparser.handle(fake_keyevent(Qt.Key_1), dry_run=True) assert not keyparser._count def test_invalid_key(self, fake_keyevent, keyparser): keyparser.handle(fake_keyevent(Qt.Key_B)) keyparser.handle(fake_keyevent(0x0)) assert not keyparser._sequence def test_valid_keychain(self, handle_text, keyparser): # Press 'x' which is ignored because of no match handle_text(Qt.Key_X, # Then start the real chain Qt.Key_B, Qt.Key_A) keyparser.execute.assert_called_with('message-info ba', None) assert not keyparser._sequence def test_0_press(self, handle_text, keyparser): handle_text(Qt.Key_0) keyparser.execute.assert_called_once_with('message-info 0', None) assert not keyparser._sequence def test_umlauts(self, handle_text, keyparser, config_stub): config_stub.val.bindings.commands = {'normal': {'ü': 'message-info ü'}} keyparser._read_config('normal') handle_text(Qt.Key_Udiaeresis) keyparser.execute.assert_called_once_with('message-info ü', None) def test_mapping(self, config_stub, handle_text, keyparser): handle_text(Qt.Key_X) keyparser.execute.assert_called_once_with('message-info a', None) def test_binding_and_mapping(self, config_stub, handle_text, keyparser): """with a conflicting binding/mapping, the binding should win.""" handle_text(Qt.Key_B) assert not keyparser.execute.called def test_binding_with_shift(self, keyparser, fake_keyevent): """Simulate a binding which involves shift.""" for key, modifiers in [(Qt.Key_Y, Qt.NoModifier), (Qt.Key_Shift, Qt.ShiftModifier), (Qt.Key_Y, Qt.ShiftModifier)]: keyparser.handle(fake_keyevent(key, modifiers)) keyparser.execute.assert_called_once_with('yank -s', None) def test_partial_before_full_match(self, keyparser, fake_keyevent, config_stub): """Make sure full matches always take precedence over partial ones.""" config_stub.val.bindings.commands = { 'normal': { 'ab': 'message-info bar', 'a': 'message-info foo' } } keyparser._read_config('normal') keyparser.handle(fake_keyevent(Qt.Key_A)) keyparser.execute.assert_called_once_with('message-info foo', None) class TestCount: """Test execute() with counts.""" @pytest.fixture(autouse=True) def read_keyparser_config(self, keyinput_bindings, keyparser): keyparser._read_config('prompt') def test_no_count(self, handle_text, keyparser): """Test with no count added.""" handle_text(Qt.Key_B, Qt.Key_A) keyparser.execute.assert_called_once_with('message-info ba', None) assert not keyparser._sequence def test_count_0(self, handle_text, keyparser): handle_text(Qt.Key_0, Qt.Key_B, Qt.Key_A) calls = [mock.call('message-info 0', None), mock.call('message-info ba', None)] keyparser.execute.assert_has_calls(calls) assert not keyparser._sequence def test_count_42(self, handle_text, keyparser): handle_text(Qt.Key_4, Qt.Key_2, Qt.Key_B, Qt.Key_A) keyparser.execute.assert_called_once_with('message-info ba', 42) assert not keyparser._sequence def test_count_42_invalid(self, handle_text, keyparser): # Invalid call with ccx gets ignored handle_text(Qt.Key_4, Qt.Key_2, Qt.Key_C, Qt.Key_C, Qt.Key_X) assert not keyparser.execute.called assert not keyparser._sequence # Valid call with ccc gets the correct count handle_text(Qt.Key_2, Qt.Key_3, Qt.Key_C, Qt.Key_C, Qt.Key_C) keyparser.execute.assert_called_once_with('message-info ccc', 23) assert not keyparser._sequence def test_clear_keystring(qtbot, keyparser): """Test that the keystring is cleared and the signal is emitted.""" keyparser._sequence = keyseq('test') keyparser._count = '23' with qtbot.waitSignal(keyparser.keystring_updated): keyparser.clear_keystring() assert not keyparser._sequence assert not keyparser._count def test_clear_keystring_empty(qtbot, keyparser): """Test that no signal is emitted when clearing an empty keystring..""" keyparser._sequence = keyseq('') with qtbot.assert_not_emitted(keyparser.keystring_updated): keyparser.clear_keystring()