293 lines
10 KiB
Python
293 lines
10 KiB
Python
# SPDX-FileCopyrightText: Florian Bruhin (The Compiler) <mail@qutebrowser.org>
|
|
#
|
|
# SPDX-License-Identifier: GPL-3.0-or-later
|
|
|
|
import logging
|
|
|
|
from qutebrowser.qt.core import Qt, QSize
|
|
from qutebrowser.qt.widgets import QWidget
|
|
import pytest
|
|
|
|
from qutebrowser.misc import miscwidgets
|
|
from qutebrowser.browser import inspector
|
|
|
|
|
|
class TestCommandLineEdit:
|
|
|
|
"""Tests for CommandLineEdit widget."""
|
|
|
|
@pytest.fixture
|
|
def cmd_edit(self, qtbot):
|
|
"""Fixture to initialize a CommandLineEdit."""
|
|
cmd_edit = miscwidgets.CommandLineEdit()
|
|
cmd_edit.set_prompt(':')
|
|
qtbot.add_widget(cmd_edit)
|
|
assert cmd_edit.text() == ''
|
|
return cmd_edit
|
|
|
|
def test_position(self, qtbot, cmd_edit):
|
|
"""Test cursor position based on the prompt."""
|
|
qtbot.keyClicks(cmd_edit, ':hello')
|
|
assert cmd_edit.text() == ':hello'
|
|
assert cmd_edit.cursorPosition() == len(':hello')
|
|
|
|
cmd_edit.home(True)
|
|
assert cmd_edit.cursorPosition() == len(':')
|
|
qtbot.keyClick(cmd_edit, Qt.Key.Key_Delete)
|
|
assert cmd_edit.text() == ':'
|
|
qtbot.keyClick(cmd_edit, Qt.Key.Key_Backspace)
|
|
assert cmd_edit.text() == ':'
|
|
|
|
qtbot.keyClicks(cmd_edit, 'hey again')
|
|
assert cmd_edit.text() == ':hey again'
|
|
|
|
def test_invalid_prompt(self, qtbot, cmd_edit):
|
|
"""Test preventing of an invalid prompt being entered."""
|
|
qtbot.keyClicks(cmd_edit, '$hello')
|
|
assert cmd_edit.text() == ''
|
|
|
|
def test_selection_home(self, qtbot, cmd_edit):
|
|
"""Test selection persisting when pressing home."""
|
|
qtbot.keyClicks(cmd_edit, ':hello')
|
|
assert cmd_edit.text() == ':hello'
|
|
assert cmd_edit.cursorPosition() == len(':hello')
|
|
cmd_edit.home(True)
|
|
assert cmd_edit.cursorPosition() == len(':')
|
|
assert cmd_edit.selectionStart() == len(':')
|
|
|
|
def test_selection_cursor_left(self, qtbot, cmd_edit):
|
|
"""Test selection persisting when moving to the first char."""
|
|
qtbot.keyClicks(cmd_edit, ':hello')
|
|
assert cmd_edit.text() == ':hello'
|
|
assert cmd_edit.cursorPosition() == len(':hello')
|
|
for _ in ':hello':
|
|
qtbot.keyClick(cmd_edit, Qt.Key.Key_Left, modifier=Qt.KeyboardModifier.ShiftModifier)
|
|
assert cmd_edit.cursorPosition() == len(':')
|
|
assert cmd_edit.selectionStart() == len(':')
|
|
|
|
|
|
class WrappedWidget(QWidget):
|
|
|
|
def sizeHint(self):
|
|
return QSize(23, 42)
|
|
|
|
|
|
class TestWrapperLayout:
|
|
|
|
@pytest.fixture
|
|
def container(self, qtbot):
|
|
wrapped = WrappedWidget()
|
|
parent = QWidget()
|
|
qtbot.add_widget(wrapped)
|
|
qtbot.add_widget(parent)
|
|
layout = miscwidgets.WrapperLayout(parent)
|
|
layout.wrap(parent, wrapped)
|
|
parent.wrapped = wrapped
|
|
return parent
|
|
|
|
def test_size_hint(self, container):
|
|
assert container.sizeHint() == QSize(23, 42)
|
|
|
|
def test_wrapped(self, container):
|
|
assert container.wrapped.parent() is container
|
|
assert container.focusProxy() is container.wrapped
|
|
|
|
|
|
class TestFullscreenNotification:
|
|
|
|
@pytest.fixture
|
|
def widget_factory(self, qtbot, key_config_stub, blue_widget):
|
|
# We need to pass a visible parent widget, so that
|
|
# FullscreenNotification.__init__ can access
|
|
# self.window().windowHandle() to get the screen.
|
|
with qtbot.wait_exposed(blue_widget):
|
|
blue_widget.show()
|
|
|
|
def create():
|
|
w = miscwidgets.FullscreenNotification(blue_widget)
|
|
qtbot.add_widget(w)
|
|
return w
|
|
|
|
return create
|
|
|
|
@pytest.mark.parametrize('bindings, text', [
|
|
({'<escape>': 'fullscreen --leave'},
|
|
"Press <Escape> to exit fullscreen."),
|
|
({'<escape>': 'fullscreen'}, "Page is now fullscreen."),
|
|
({'a': 'fullscreen --leave'}, "Press a to exit fullscreen."),
|
|
({}, "Page is now fullscreen."),
|
|
])
|
|
def test_text(self, widget_factory, config_stub, bindings, text):
|
|
config_stub.val.bindings.default = {}
|
|
config_stub.val.bindings.commands = {'normal': bindings}
|
|
widget = widget_factory()
|
|
assert widget.text() == text
|
|
|
|
def test_timeout(self, qtbot, widget_factory):
|
|
widget = widget_factory()
|
|
with qtbot.wait_signal(widget.destroyed):
|
|
widget.set_timeout(1)
|
|
|
|
|
|
@pytest.mark.usefixtures('state_config')
|
|
class TestInspectorSplitter:
|
|
|
|
@pytest.fixture
|
|
def fake_webview(self, blue_widget):
|
|
return blue_widget
|
|
|
|
@pytest.fixture
|
|
def fake_inspector(self, red_widget):
|
|
return red_widget
|
|
|
|
@pytest.fixture
|
|
def splitter(self, qtbot, fake_webview):
|
|
inspector_splitter = miscwidgets.InspectorSplitter(
|
|
win_id=0, main_webview=fake_webview)
|
|
qtbot.add_widget(inspector_splitter)
|
|
return inspector_splitter
|
|
|
|
def test_no_inspector(self, splitter, fake_webview):
|
|
assert splitter.count() == 1
|
|
assert splitter.widget(0) is fake_webview
|
|
assert splitter.focusProxy() is fake_webview
|
|
|
|
def test_no_inspector_resize(self, splitter):
|
|
splitter.show()
|
|
splitter.resize(800, 600)
|
|
|
|
def test_cycle_focus_no_inspector(self, splitter):
|
|
with pytest.raises(inspector.Error,
|
|
match='No inspector inside main window'):
|
|
splitter.cycle_focus()
|
|
|
|
@pytest.mark.parametrize(
|
|
'position, orientation, inspector_idx, webview_idx', [
|
|
(inspector.Position.left, Qt.Orientation.Horizontal, 0, 1),
|
|
(inspector.Position.right, Qt.Orientation.Horizontal, 1, 0),
|
|
(inspector.Position.top, Qt.Orientation.Vertical, 0, 1),
|
|
(inspector.Position.bottom, Qt.Orientation.Vertical, 1, 0),
|
|
]
|
|
)
|
|
def test_set_inspector(self, position, orientation,
|
|
inspector_idx, webview_idx,
|
|
splitter, fake_inspector, fake_webview):
|
|
splitter.set_inspector(fake_inspector, position)
|
|
|
|
assert splitter.indexOf(fake_inspector) == inspector_idx
|
|
assert splitter._inspector_idx == inspector_idx
|
|
|
|
assert splitter.indexOf(fake_webview) == webview_idx
|
|
assert splitter._main_idx == webview_idx
|
|
|
|
assert splitter.orientation() == orientation
|
|
|
|
def test_cycle_focus_hidden_inspector(self, splitter, fake_inspector):
|
|
splitter.set_inspector(fake_inspector, inspector.Position.right)
|
|
splitter.show()
|
|
fake_inspector.hide()
|
|
with pytest.raises(inspector.Error,
|
|
match='No inspector inside main window'):
|
|
splitter.cycle_focus()
|
|
|
|
@pytest.mark.parametrize(
|
|
'config, width, height, position, expected_size', [
|
|
# No config but enough big window
|
|
(None, 1024, 768, inspector.Position.left, 512),
|
|
(None, 1024, 768, inspector.Position.top, 384),
|
|
# No config and small window
|
|
(None, 320, 240, inspector.Position.left, 300),
|
|
(None, 320, 240, inspector.Position.top, 300),
|
|
# Invalid config
|
|
('verybig', 1024, 768, inspector.Position.left, 512),
|
|
# Value from config
|
|
('666', 1024, 768, inspector.Position.left, 666),
|
|
]
|
|
)
|
|
def test_read_size(self, config, width, height, position, expected_size,
|
|
state_config, splitter, fake_inspector, caplog):
|
|
if config is not None:
|
|
state_config['inspector'] = {position.name: config}
|
|
|
|
splitter.resize(width, height)
|
|
assert splitter.size() == QSize(width, height)
|
|
|
|
with caplog.at_level(logging.ERROR):
|
|
splitter.set_inspector(fake_inspector, position)
|
|
|
|
assert splitter._preferred_size == expected_size
|
|
|
|
if config == {'left': 'verybig'}:
|
|
assert caplog.messages == ["Could not read inspector size: "
|
|
"invalid literal for int() with "
|
|
"base 10: 'verybig'"]
|
|
|
|
@pytest.mark.parametrize('position', [
|
|
inspector.Position.left,
|
|
inspector.Position.right,
|
|
inspector.Position.top,
|
|
inspector.Position.bottom,
|
|
])
|
|
def test_save_size(self, position, state_config, splitter, fake_inspector):
|
|
splitter.set_inspector(fake_inspector, position)
|
|
splitter._preferred_size = 1337
|
|
splitter._save_preferred_size()
|
|
assert state_config['inspector'][position.name] == '1337'
|
|
|
|
@pytest.mark.parametrize(
|
|
'old_window_size, preferred_size, new_window_size, '
|
|
'exp_inspector_size', [
|
|
# Plenty of space -> Keep inspector at configured absolute size
|
|
(600, 300, # 1/2 of window
|
|
500, 300), # 300px of 600px -> 300px of 500px
|
|
|
|
# Slowly running out of space -> Reserve space for website
|
|
(600, 450, # 3/4 of window
|
|
500, 350), # 450px of 600px -> 350px of 500px
|
|
# (so website has 150px)
|
|
|
|
# Very small window -> Keep ratio distribution
|
|
(600, 300, # 1/2 of window
|
|
200, 100), # 300px of 600px -> 100px of 200px (1/2)
|
|
]
|
|
)
|
|
@pytest.mark.parametrize('position', [
|
|
inspector.Position.left, inspector.Position.right,
|
|
inspector.Position.top, inspector.Position.bottom])
|
|
def test_adjust_size(self, old_window_size, preferred_size,
|
|
new_window_size, exp_inspector_size,
|
|
position, splitter, fake_inspector, qtbot):
|
|
def resize(dim):
|
|
size = (QSize(dim, 666) if splitter.orientation() == Qt.Orientation.Horizontal
|
|
else QSize(666, dim))
|
|
splitter.resize(size)
|
|
if splitter.size() != size:
|
|
pytest.skip("Resizing window failed")
|
|
|
|
splitter.set_inspector(fake_inspector, position)
|
|
splitter.show()
|
|
resize(old_window_size)
|
|
|
|
handle_width = 4
|
|
splitter.setHandleWidth(handle_width)
|
|
|
|
splitter_idx = 1
|
|
if position in [inspector.Position.left, inspector.Position.top]:
|
|
splitter_pos = preferred_size - handle_width//2
|
|
else:
|
|
splitter_pos = old_window_size - preferred_size - handle_width//2
|
|
splitter.moveSplitter(splitter_pos, splitter_idx)
|
|
|
|
resize(new_window_size)
|
|
|
|
sizes = splitter.sizes()
|
|
inspector_size = sizes[splitter._inspector_idx]
|
|
main_size = sizes[splitter._main_idx]
|
|
exp_main_size = new_window_size - exp_inspector_size
|
|
|
|
exp_main_size -= handle_width // 2
|
|
exp_inspector_size -= handle_width // 2
|
|
|
|
assert (inspector_size, main_size) == (exp_inspector_size,
|
|
exp_main_size)
|