rnhmjoj/qutebrowser
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

tests: Get rid of duplicate key config stubs

Browse Source
This commit is contained in:
Florian Bruhin 2017-10-05 11:09:07 +02:00
parent 012f79b244
commit c63d16e2ea
3 changed files with 43 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
tests/unit/config/conftest.py
View File

@ -1,29 +0,0 @@
# vim: ft=python fileencoding=utf-8 sts=4 sw=4 et:
# Copyright 2017 Florian Bruhin (The Compiler) <mail@qutebrowser.org>
# 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 <http://www.gnu.org/licenses/>.
"""Fixtures needed in various config test files."""
import pytest
from qutebrowser.config import config
@pytest.fixture
def keyconf(config_stub):
config_stub.val.aliases = {}
return config.KeyConfig(config_stub)

63
tests/unit/config/test_config.py
View File

@ -93,11 +93,6 @@ class TestChangeFilter:
class TestKeyConfig:
@pytest.fixture
def keyconf(self, config_stub):
config_stub.val.aliases = {}
return config.KeyConfig(config_stub)
@pytest.fixture
def no_bindings(self):
"""Get a dict with no bindings."""
@ -107,14 +102,14 @@ class TestKeyConfig:
('A', 'A'),
('<Ctrl-X>', '<ctrl+x>'),
])
def test_prepare_valid(self, keyconf, key, expected):
def test_prepare_valid(self, key_config_stub, key, expected):
"""Make sure prepare normalizes the key."""
assert keyconf._prepare(key, 'normal') == expected
assert key_config_stub._prepare(key, 'normal') == expected
def test_prepare_invalid(self, keyconf):
def test_prepare_invalid(self, key_config_stub):
"""Make sure prepare checks the mode."""
with pytest.raises(configexc.KeybindingError):
assert keyconf._prepare('x', 'abnormal')
assert key_config_stub._prepare('x', 'abnormal')
@pytest.mark.parametrize('commands, expected', [
# Unbinding default key
@ -126,7 +121,8 @@ class TestKeyConfig:
# Unbinding unknown key
({'x': None}, {'a': 'message-info foo', 'b': 'message-info bar'}),
])
def test_get_bindings_for_and_get_command(self, keyconf, config_stub,
def test_get_bindings_for_and_get_command(self, key_config_stub,
config_stub,
commands, expected):
orig_default_bindings = {'normal': {'a': 'message-info foo',
'b': 'message-info bar'},
@ -139,18 +135,19 @@ class TestKeyConfig:
'register': {}}
config_stub.val.bindings.default = copy.deepcopy(orig_default_bindings)
config_stub.val.bindings.commands = {'normal': commands}
bindings = keyconf.get_bindings_for('normal')
bindings = key_config_stub.get_bindings_for('normal')
# Make sure the code creates a copy and doesn't modify the setting
assert config_stub.val.bindings.default == orig_default_bindings
assert bindings == expected
for key, command in expected.items():
assert keyconf.get_command(key, 'normal') == command
assert key_config_stub.get_command(key, 'normal') == command
def test_get_command_unbound(self, keyconf, config_stub, no_bindings):
def test_get_command_unbound(self, key_config_stub, config_stub,
no_bindings):
config_stub.val.bindings.default = no_bindings
config_stub.val.bindings.commands = no_bindings
assert keyconf.get_command('foobar', 'normal') is None
assert key_config_stub.get_command('foobar', 'normal') is None
@pytest.mark.parametrize('bindings, expected', [
# Simple
@ -166,46 +163,47 @@ class TestKeyConfig:
({'a': 'message-info foo ;; message-info bar'},
{'message-info foo': ['a'], 'message-info bar': ['a']}),
])
def test_get_reverse_bindings_for(self, keyconf, config_stub, no_bindings,
bindings, expected):
def test_get_reverse_bindings_for(self, key_config_stub, config_stub,
no_bindings, bindings, expected):
config_stub.val.bindings.default = no_bindings
config_stub.val.bindings.commands = {'normal': bindings}
assert keyconf.get_reverse_bindings_for('normal') == expected
assert key_config_stub.get_reverse_bindings_for('normal') == expected
@pytest.mark.parametrize('key', ['a', '<Ctrl-X>', 'b'])
def test_bind_duplicate(self, keyconf, config_stub, key):
def test_bind_duplicate(self, key_config_stub, config_stub, key):
config_stub.val.bindings.default = {'normal': {'a': 'nop',
'<Ctrl+x>': 'nop'}}
config_stub.val.bindings.commands = {'normal': {'b': 'nop'}}
keyconf.bind(key, 'message-info foo', mode='normal')
assert keyconf.get_command(key, 'normal') == 'message-info foo'
key_config_stub.bind(key, 'message-info foo', mode='normal')
assert key_config_stub.get_command(key, 'normal') == 'message-info foo'
@pytest.mark.parametrize('mode', ['normal', 'caret'])
@pytest.mark.parametrize('command', [
'message-info foo',
'nop ;; wq', # https://github.com/qutebrowser/qutebrowser/issues/3002
])
def test_bind(self, keyconf, config_stub, qtbot, no_bindings,
def test_bind(self, key_config_stub, config_stub, qtbot, no_bindings,
mode, command):
config_stub.val.bindings.default = no_bindings
config_stub.val.bindings.commands = no_bindings
with qtbot.wait_signal(config_stub.changed):
keyconf.bind('a', command, mode=mode)
key_config_stub.bind('a', command, mode=mode)
assert config_stub.val.bindings.commands[mode]['a'] == command
assert keyconf.get_bindings_for(mode)['a'] == command
assert keyconf.get_command('a', mode) == command
assert key_config_stub.get_bindings_for(mode)['a'] == command
assert key_config_stub.get_command('a', mode) == command
def test_bind_mode_changing(self, keyconf, config_stub, no_bindings):
def test_bind_mode_changing(self, key_config_stub, config_stub,
no_bindings):
"""Make sure we can bind to a command which changes the mode.
https://github.com/qutebrowser/qutebrowser/issues/2989
"""
config_stub.val.bindings.default = no_bindings
config_stub.val.bindings.commands = no_bindings
keyconf.bind('a', 'set-cmd-text :nop ;; rl-beginning-of-line',
mode='normal')
key_config_stub.bind('a', 'set-cmd-text :nop ;; rl-beginning-of-line',
mode='normal')
@pytest.mark.parametrize('key, normalized', [
('a', 'a'), # default bindings
@ -213,7 +211,8 @@ class TestKeyConfig:
('<Ctrl-X>', '<ctrl+x>')
])
@pytest.mark.parametrize('mode', ['normal', 'caret', 'prompt'])
def test_unbind(self, keyconf, config_stub, qtbot, key, normalized, mode):
def test_unbind(self, key_config_stub, config_stub, qtbot,
key, normalized, mode):
default_bindings = {
'normal': {'a': 'nop', '<ctrl+x>': 'nop'},
'caret': {'a': 'nop', '<ctrl+x>': 'nop'},
@ -228,9 +227,9 @@ class TestKeyConfig:
}
with qtbot.wait_signal(config_stub.changed):
keyconf.unbind(key, mode=mode)
key_config_stub.unbind(key, mode=mode)
assert keyconf.get_command(key, mode) is None
assert key_config_stub.get_command(key, mode) is None
mode_bindings = config_stub.val.bindings.commands[mode]
if key == 'b' and mode != 'prompt':
@ -241,13 +240,13 @@ class TestKeyConfig:
assert default_bindings[mode] == old_default_bindings[mode]
assert mode_bindings[normalized] is None
def test_unbind_unbound(self, keyconf, config_stub, no_bindings):
def test_unbind_unbound(self, key_config_stub, config_stub, no_bindings):
"""Try unbinding a key which is not bound."""
config_stub.val.bindings.default = no_bindings
config_stub.val.bindings.commands = no_bindings
with pytest.raises(configexc.KeybindingError,
match="Can't find binding 'foobar' in normal mode"):
keyconf.unbind('foobar', mode='normal')
key_config_stub.unbind('foobar', mode='normal')
class TestConfig:

22
tests/unit/config/test_configcommands.py
View File

@ -31,8 +31,8 @@ from qutebrowser.misc import objects
@pytest.fixture
def commands(config_stub, keyconf):
return configcommands.ConfigCommands(config_stub, keyconf)
def commands(config_stub, key_config_stub):
return configcommands.ConfigCommands(config_stub, key_config_stub)
class TestSet:
@ -353,10 +353,10 @@ class TestWritePy:
"""Tests for :config-write-py."""
def test_custom(self, commands, config_stub, keyconf, tmpdir):
def test_custom(self, commands, config_stub, key_config_stub, tmpdir):
confpy = tmpdir / 'config.py'
config_stub.val.content.javascript.enabled = True
keyconf.bind(',x', 'message-info foo', mode='normal')
key_config_stub.bind(',x', 'message-info foo', mode='normal')
commands.config_write_py(str(confpy))
@ -408,14 +408,15 @@ class TestBind:
return {'normal': {}}
@pytest.mark.parametrize('command', ['nop', 'nope'])
def test_bind(self, commands, config_stub, no_bindings, keyconf, command):
def test_bind(self, commands, config_stub, no_bindings, key_config_stub,
command):
"""Simple :bind test (and aliases)."""
config_stub.val.aliases = {'nope': 'nop'}
config_stub.val.bindings.default = no_bindings
config_stub.val.bindings.commands = no_bindings
commands.bind('a', command)
assert keyconf.get_command('a', 'normal') == command
assert key_config_stub.get_command('a', 'normal') == command
yaml_bindings = config_stub._yaml['bindings.commands']['normal']
assert yaml_bindings['a'] == command
@ -466,7 +467,7 @@ class TestBind:
commands.bind('a', 'nop', mode='wrongmode')
@pytest.mark.parametrize('key', ['a', 'b', '<Ctrl-X>'])
def test_bind_duplicate(self, commands, config_stub, keyconf, key):
def test_bind_duplicate(self, commands, config_stub, key_config_stub, key):
"""Run ':bind' with a key which already has been bound.'.
Also tests for https://github.com/qutebrowser/qutebrowser/issues/1544
@ -479,7 +480,7 @@ class TestBind:
}
commands.bind(key, 'message-info foo', mode='normal')
assert keyconf.get_command(key, 'normal') == 'message-info foo'
assert key_config_stub.get_command(key, 'normal') == 'message-info foo'
def test_bind_none(self, commands, config_stub):
config_stub.val.bindings.commands = None
@ -495,7 +496,8 @@ class TestBind:
('c', 'c'), # :bind then :unbind
('<Ctrl-X>', '<ctrl+x>') # normalized special binding
])
def test_unbind(self, commands, keyconf, config_stub, key, normalized):
def test_unbind(self, commands, key_config_stub, config_stub,
key, normalized):
config_stub.val.bindings.default = {
'normal': {'a': 'nop', '<ctrl+x>': 'nop'},
'caret': {'a': 'nop', '<ctrl+x>': 'nop'},
@ -509,7 +511,7 @@ class TestBind:
commands.bind(key, 'nop')
commands.unbind(key)
assert keyconf.get_command(key, 'normal') is None
assert key_config_stub.get_command(key, 'normal') is None
yaml_bindings = config_stub._yaml['bindings.commands']['normal']
if key in 'bc':