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

tests: Use match= for pytest.raises

Browse Source
This commit is contained in:
Florian Bruhin 2017-05-23 09:36:00 +02:00
parent af7923de4d
commit ea2fbc427a
15 changed files with 99 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
tests/end2end/fixtures/test_quteprocess.py
View File

@ -113,7 +113,7 @@ def test_quteproc_error_message_did_fail(qtbot, quteproc, request_mock):
def test_quteproc_skip_via_js(qtbot, quteproc):
with pytest.raises(pytest.skip.Exception) as excinfo:
with pytest.raises(pytest.skip.Exception, match='test'):
quteproc.send_cmd(':jseval console.log("[SKIP] test");')
quteproc.wait_for_js('[SKIP] test')
@ -121,8 +121,6 @@ def test_quteproc_skip_via_js(qtbot, quteproc):
# the error to occur during the test rather than at teardown time.
quteproc.after_test()
assert str(excinfo.value) == 'test'
def test_quteproc_skip_and_wait_for(qtbot, quteproc):
"""This test will skip *again* during teardown, but we don't care."""
@ -312,14 +310,12 @@ class TestClickElementByText:
quteproc.wait_for_js('click_element special chars')
def test_duplicate(self, quteproc):
with pytest.raises(ValueError) as excinfo:
with pytest.raises(ValueError, match='not unique'):
quteproc.click_element_by_text('Duplicate')
assert 'not unique' in str(excinfo.value)
def test_nonexistent(self, quteproc):
with pytest.raises(ValueError) as excinfo:
with pytest.raises(ValueError, match='No element'):
quteproc.click_element_by_text('no element exists with this text')
assert 'No element' in str(excinfo.value)
@pytest.mark.parametrize('string, expected', [

10
tests/unit/browser/webkit/test_mhtml.py
View File

@ -104,9 +104,8 @@ def test_refuses_non_ascii_header_value(checker, header, value):
}
defaults[header] = value
writer = mhtml.MHTMLWriter(**defaults)
with pytest.raises(UnicodeEncodeError) as excinfo:
with pytest.raises(UnicodeEncodeError, match="'ascii' codec can't encode"):
writer.write_to(checker.fp)
assert "'ascii' codec can't encode" in str(excinfo.value)
def test_file_encoded_as_base64(checker):
@ -325,9 +324,8 @@ class TestNoCloseBytesIO:
fp = mhtml._NoCloseBytesIO()
fp.write(b'Value')
fp.actual_close()
with pytest.raises(ValueError) as excinfo:
with pytest.raises(ValueError, match="I/O operation on closed file."):
fp.getvalue()
with pytest.raises(ValueError, match="I/O operation on closed file."):
fp.getvalue()
assert str(excinfo.value) == 'I/O operation on closed file.'
with pytest.raises(ValueError) as excinfo:
fp.write(b'Closed')
assert str(excinfo.value) == 'I/O operation on closed file.'

3
tests/unit/browser/webkit/test_webkitelem.py
View File

@ -239,9 +239,8 @@ class TestWebKitElement:
def test_double_wrap(self, elem):
"""Test wrapping a WebKitElement."""
with pytest.raises(TypeError) as excinfo:
with pytest.raises(TypeError, match="Trying to wrap a wrapper!"):
webkitelem.WebKitElement(elem, tab=None)
assert str(excinfo.value) == "Trying to wrap a wrapper!"
@pytest.mark.parametrize('code', [
pytest.param(str, id='str'),

28
tests/unit/commands/test_argparser.py
View File

@ -65,9 +65,9 @@ class TestArgumentParser:
assert excinfo.value.status == 0
def test_error(self, parser):
with pytest.raises(argparser.ArgumentParserError) as excinfo:
with pytest.raises(argparser.ArgumentParserError,
match="Unrecognized arguments: --foo"):
parser.parse_args(['--foo'])
assert str(excinfo.value) == "Unrecognized arguments: --foo"
def test_help(self, parser, tabbed_browser):
parser.add_argument('--help', action=argparser.HelpAction, nargs=0)
@ -106,12 +106,6 @@ def test_type_conv_valid(types, value, expected, multi):
def test_type_conv_invalid(typ, value, multi):
param = inspect.Parameter('foo', inspect.Parameter.POSITIONAL_ONLY)
with pytest.raises(cmdexc.ArgumentTypeError) as excinfo:
if multi:
argparser.multitype_conv(param, [typ], value)
else:
argparser.type_conv(param, typ, value)
if multi:
msg = 'foo: Invalid value {}'.format(value)
elif typ is Enum:
@ -119,15 +113,19 @@ def test_type_conv_invalid(typ, value, multi):
'foo-bar'.format(value))
else:
msg = 'foo: Invalid {} value {}'.format(typ.__name__, value)
assert str(excinfo.value) == msg
with pytest.raises(cmdexc.ArgumentTypeError, match=msg):
if multi:
argparser.multitype_conv(param, [typ], value)
else:
argparser.type_conv(param, typ, value)
def test_multitype_conv_invalid_type():
"""Test using an invalid type with a multitype converter."""
param = inspect.Parameter('foo', inspect.Parameter.POSITIONAL_ONLY)
with pytest.raises(ValueError) as excinfo:
with pytest.raises(ValueError, match="foo: Unknown type None!"):
argparser.multitype_conv(param, [None], '')
assert str(excinfo.value) == "foo: Unknown type None!"
@pytest.mark.parametrize('value, typ', [(None, None), (42, int)])
@ -146,9 +144,8 @@ def test_conv_str_type():
no string annotations are there anymore.
"""
param = inspect.Parameter('foo', inspect.Parameter.POSITIONAL_ONLY)
with pytest.raises(TypeError) as excinfo:
with pytest.raises(TypeError, match='foo: Legacy string type!'):
argparser.type_conv(param, 'val', None)
assert str(excinfo.value) == 'foo: Legacy string type!'
def test_conv_str_choices_valid():
@ -162,7 +159,6 @@ def test_conv_str_choices_valid():
def test_conv_str_choices_invalid():
"""Calling str type with str_choices and invalid value."""
param = inspect.Parameter('foo', inspect.Parameter.POSITIONAL_ONLY)
with pytest.raises(cmdexc.ArgumentTypeError) as excinfo:
with pytest.raises(cmdexc.ArgumentTypeError, match='foo: Invalid value '
'val3 - expected one of: val1, val2'):
argparser.type_conv(param, str, 'val3', str_choices=['val1', 'val2'])
msg = 'foo: Invalid value val3 - expected one of: val1, val2'
assert str(excinfo.value) == msg

56
tests/unit/commands/test_cmdutils.py
View File

@ -59,14 +59,10 @@ class TestCheckOverflow:
def test_bad(self):
int32_max = 2 ** 31 - 1
with pytest.raises(cmdexc.CommandError) as excinfo:
with pytest.raises(cmdexc.CommandError, match="Numeric argument is "
"too large for internal int representation."):
cmdutils.check_overflow(int32_max + 1, 'int')
expected_str = ("Numeric argument is too large for internal int "
"representation.")
assert str(excinfo.value) == expected_str
class TestCheckExclusive:
@ -75,11 +71,10 @@ class TestCheckExclusive:
cmdutils.check_exclusive(flags, [])
def test_bad(self):
with pytest.raises(cmdexc.CommandError) as excinfo:
with pytest.raises(cmdexc.CommandError,
match="Only one of -x/-y/-z can be given!"):
cmdutils.check_exclusive([True, True], 'xyz')
assert str(excinfo.value) == "Only one of -x/-y/-z can be given!"
class TestRegister:
@ -241,16 +236,14 @@ class TestRegister:
assert cmdutils.cmd_dict['fun']._get_call_args(42) == ([0], {})
def test_count_without_default(self):
with pytest.raises(TypeError) as excinfo:
with pytest.raises(TypeError, match="fun: handler has count parameter "
"without default!"):
@cmdutils.register()
@cmdutils.argument('count', count=True)
def fun(count):
"""Blah."""
pass
expected = "fun: handler has count parameter without default!"
assert str(excinfo.value) == expected
@pytest.mark.parametrize('hide', [True, False])
def test_pos_args(self, hide):
@cmdutils.register()
@ -355,38 +348,31 @@ class TestRegister:
"""Blah."""
pass
with pytest.raises(TypeError) as excinfo:
with pytest.raises(TypeError, match="fun: handler has keyword only "
"argument 'target' without default!"):
fun = cmdutils.register()(fun)
expected = ("fun: handler has keyword only argument 'target' without "
"default!")
assert str(excinfo.value) == expected
def test_typed_keyword_only_without_default(self):
# https://github.com/qutebrowser/qutebrowser/issues/1872
def fun(*, target: int):
"""Blah."""
pass
with pytest.raises(TypeError) as excinfo:
with pytest.raises(TypeError, match="fun: handler has keyword only "
"argument 'target' without default!"):
fun = cmdutils.register()(fun)
expected = ("fun: handler has keyword only argument 'target' without "
"default!")
assert str(excinfo.value) == expected
class TestArgument:
"""Test the @cmdutils.argument decorator."""
def test_invalid_argument(self):
with pytest.raises(ValueError) as excinfo:
with pytest.raises(ValueError, match="fun has no argument foo!"):
@cmdutils.argument('foo')
def fun(bar):
"""Blah."""
pass
assert str(excinfo.value) == "fun has no argument foo!"
def test_storage(self):
@cmdutils.argument('foo', flag='x')
@ -402,27 +388,22 @@ class TestArgument:
def test_wrong_order(self):
"""When @cmdutils.argument is used above (after) @register, fail."""
with pytest.raises(ValueError) as excinfo:
with pytest.raises(ValueError, match=r"@cmdutils.argument got called "
"above \(after\) @cmdutils.register for fun!"):
@cmdutils.argument('bar', flag='y')
@cmdutils.register()
def fun(bar):
"""Blah."""
pass
text = ("@cmdutils.argument got called above (after) "
"@cmdutils.register for fun!")
assert str(excinfo.value) == text
def test_count_and_win_id_same_arg(self):
with pytest.raises(TypeError) as excinfo:
with pytest.raises(TypeError,
match="Argument marked as both count/win_id!"):
@cmdutils.argument('arg', count=True, win_id=True)
def fun(arg=0):
"""Blah."""
pass
assert str(excinfo.value) == "Argument marked as both count/win_id!"
def test_no_docstring(self, caplog):
with caplog.at_level(logging.WARNING):
@cmdutils.register()
@ -464,9 +445,9 @@ class TestRun:
if ok:
cmd.run(win_id=0)
else:
with pytest.raises(cmdexc.PrerequisitesError) as excinfo:
with pytest.raises(cmdexc.PrerequisitesError,
match=r'.* backend\.'):
cmd.run(win_id=0)
assert str(excinfo.value).endswith(' backend.')
def test_no_args(self):
cmd = _get_cmd()
@ -488,6 +469,5 @@ class TestRun:
monkeypatch.setattr(command.objects, 'backend',
usertypes.Backend.QtWebKit)
cmd = cmdutils.cmd_dict['fun']
with pytest.raises(cmdexc.PrerequisitesError) as excinfo:
with pytest.raises(cmdexc.PrerequisitesError, match=r'.* backend\.'):
cmd.run(win_id=0)
assert str(excinfo.value).endswith(' backend.')

5
tests/unit/commands/test_userscripts.py
View File

@ -247,7 +247,6 @@ def test_unicode_error(caplog, qtbot, py_proc, runner):
def test_unsupported(monkeypatch, tabbed_browser_stubs):
monkeypatch.setattr(userscripts.os, 'name', 'toaster')
with pytest.raises(userscripts.UnsupportedError) as excinfo:
with pytest.raises(userscripts.UnsupportedError, match="Userscripts are "
"not supported on this platform!"):
userscripts.run_async(tab=None, cmd=None, win_id=0, env=None)
expected = "Userscripts are not supported on this platform!"
assert str(excinfo.value) == expected

4
tests/unit/config/test_configdata.py
View File

@ -39,6 +39,6 @@ def test_data():
def test_readonly_data():
"""Make sure DATA is readonly."""
with pytest.raises(ValueError) as excinfo:
with pytest.raises(ValueError, match="Trying to modify a read-only "
"config!"):
configdata.DATA['general'].setv('temp', 'ignore-case', 'true', 'true')
assert str(excinfo.value) == "Trying to modify a read-only config!"

6
tests/unit/keyinput/test_basekeyparser.py
View File

@ -128,12 +128,10 @@ class TestReadConfig:
assert keyparser._modename is None
# No config set so self._modename is None
with pytest.raises(AssertionError) as excinfo:
with pytest.raises(AssertionError, match="on_keyconfig_changed called "
"but no section defined!"):
keyparser.on_keyconfig_changed('normal')
expected_text = "on_keyconfig_changed called but no section defined!"
assert str(excinfo.value) == expected_text
@pytest.mark.parametrize('mode,changed_mode, expected', [
('normal', 'normal', True), ('normal', 'normal2', False),
])

13
tests/unit/misc/test_cmdhistory.py
View File

@ -90,21 +90,20 @@ def test_getitem(hist):
def test_setitem(hist):
"""Test __setitem__."""
with pytest.raises(TypeError) as excinfo:
with pytest.raises(TypeError, match="'History' object does not support "
"item assignment"):
hist[0] = 'foo'
expected = "'History' object does not support item assignment"
assert str(excinfo.value) == expected
def test_not_browsing_error(hist):
"""Test that next/previtem throws a ValueError."""
with pytest.raises(ValueError) as error1:
with pytest.raises(ValueError, match="Currently not browsing "
"history"):
hist.nextitem()
assert str(error1.value) == "Currently not browsing history"
with pytest.raises(ValueError) as error2:
with pytest.raises(ValueError, match="Currently not browsing "
"history"):
hist.previtem()
assert str(error2.value) == "Currently not browsing history"
def test_nextitem_single(hist, monkeypatch):

29
tests/unit/misc/test_ipc.py
View File

@ -269,9 +269,9 @@ class TestListen:
def test_remove_error(self, ipc_server, monkeypatch):
"""Simulate an error in _remove_server."""
monkeypatch.setattr(ipc_server, '_socketname', None)
with pytest.raises(ipc.Error) as excinfo:
with pytest.raises(ipc.Error,
match="Error while removing server None!"):
ipc_server.listen()
assert str(excinfo.value) == "Error while removing server None!"
def test_error(self, ipc_server, monkeypatch):
"""Simulate an error while listening."""
@ -369,13 +369,10 @@ class TestOnError:
lambda: "Connection refused")
socket.setErrorString("Connection refused.")
with pytest.raises(ipc.Error) as excinfo:
with pytest.raises(ipc.Error, match=r"Error while handling IPC "
r"connection: Connection refused \(error 0\)"):
ipc_server.on_error(QLocalSocket.ConnectionRefusedError)
expected = ("Error while handling IPC connection: Connection refused "
"(error 0)")
assert str(excinfo.value) == expected
class TestHandleConnection:
@ -409,11 +406,10 @@ class TestHandleConnection:
socket = FakeSocket(error=QLocalSocket.ConnectionError)
ipc_server._server = FakeServer(socket)
with pytest.raises(ipc.Error) as excinfo:
with pytest.raises(ipc.Error, match=r"Error while handling IPC "
r"connection: Error string \(error 7\)"):
ipc_server.handle_connection()
exc_msg = 'Error while handling IPC connection: Error string (error 7)'
assert str(excinfo.value) == exc_msg
msg = "We got an error immediately."
all_msgs = [r.message for r in caplog.records]
assert msg in all_msgs
@ -550,12 +546,10 @@ class TestSendToRunningInstance:
def test_socket_error(self):
socket = FakeSocket(error=QLocalSocket.ConnectionError)
with pytest.raises(ipc.Error) as excinfo:
with pytest.raises(ipc.Error, match=r"Error while writing to running "
r"instance: Error string \(error 7\)"):
ipc.send_to_running_instance('qute-test', [], None, socket=socket)
msg = "Error while writing to running instance: Error string (error 7)"
assert str(excinfo.value) == msg
def test_not_disconnected_immediately(self):
socket = FakeSocket()
ipc.send_to_running_instance('qute-test', [], None, socket=socket)
@ -563,13 +557,10 @@ class TestSendToRunningInstance:
def test_socket_error_no_server(self):
socket = FakeSocket(error=QLocalSocket.ConnectionError,
connect_successful=False)
with pytest.raises(ipc.Error) as excinfo:
with pytest.raises(ipc.Error, match=r"Error while connecting to "
r"running instance: Error string \(error 7\)"):
ipc.send_to_running_instance('qute-test', [], None, socket=socket)
msg = ("Error while connecting to running instance: Error string "
"(error 7)")
assert str(excinfo.value) == msg
@pytest.mark.not_osx(reason="https://github.com/qutebrowser/qutebrowser/"
"issues/975")

4
tests/unit/misc/test_lineparser.py
View File

@ -58,10 +58,10 @@ class TestBaseLineParser:
mocker.patch('builtins.open', mock.mock_open())
with lineparser._open('r'):
with pytest.raises(IOError) as excinf:
with pytest.raises(IOError, match="Refusing to double-open "
"AppendLineParser."):
with lineparser._open('r'):
pass
assert str(excinf.value) == 'Refusing to double-open AppendLineParser.'
def test_binary(self, mocker):
"""Test if _open and _write correctly handle binary files."""

3
tests/unit/misc/test_sessions.py
View File

@ -263,10 +263,9 @@ class TestSave:
mocker.patch('qutebrowser.misc.sessions.yaml.dump',
side_effect=exception)
with pytest.raises(sessions.SessionError) as excinfo:
with pytest.raises(sessions.SessionError, match=str(exception)):
sess_man.save(str(tmpdir / 'foo.yml'))
assert str(excinfo.value) == str(exception)
assert not tmpdir.listdir()
def test_load_next_time(self, tmpdir, state_config, sess_man):

18
tests/unit/misc/test_utilcmds.py
View File

@ -41,9 +41,8 @@ def _trapped_segv(handler):
def test_debug_crash_exception():
"""Verify that debug_crash crashes as intended."""
with pytest.raises(Exception) as excinfo:
with pytest.raises(Exception, match="Forced crash"):
utilcmds.debug_crash(typ='exception')
assert str(excinfo.value) == 'Forced crash'
@pytest.mark.skipif(os.name == 'nt',
@ -60,11 +59,10 @@ def test_debug_crash_segfault():
with _trapped_segv(_handler):
# since we handle the segfault, execution will continue and run into
# the "Segfault failed (wat.)" Exception
with pytest.raises(Exception) as excinfo:
with pytest.raises(Exception, match="Segfault failed"):
utilcmds.debug_crash(typ='segfault')
time.sleep(0.001)
assert caught
assert 'Segfault failed' in str(excinfo.value)
def test_debug_trace(mocker):
@ -84,18 +82,16 @@ def test_debug_trace_exception(mocker):
hunter_mock = mocker.patch('qutebrowser.misc.utilcmds.hunter')
hunter_mock.trace.side_effect = _mock_exception
with pytest.raises(cmdexc.CommandError) as excinfo:
with pytest.raises(cmdexc.CommandError, match='Exception: message'):
utilcmds.debug_trace()
assert str(excinfo.value) == 'Exception: message'
def test_debug_trace_no_hunter(monkeypatch):
"""Test that an error is shown if debug_trace is called without hunter."""
monkeypatch.setattr(utilcmds, 'hunter', None)
with pytest.raises(cmdexc.CommandError) as excinfo:
with pytest.raises(cmdexc.CommandError, match="You need to install "
"'hunter' to use this command!"):
utilcmds.debug_trace()
assert str(excinfo.value) == "You need to install 'hunter' to use this " \
"command!"
def test_repeat_command_initial(mocker, mode_manager):
@ -106,9 +102,9 @@ def test_repeat_command_initial(mocker, mode_manager):
"""
objreg_mock = mocker.patch('qutebrowser.misc.utilcmds.objreg')
objreg_mock.get.return_value = mode_manager
with pytest.raises(cmdexc.CommandError) as excinfo:
with pytest.raises(cmdexc.CommandError,
match="You didn't do anything yet."):
utilcmds.repeat_command(win_id=0)
assert str(excinfo.value) == "You didn't do anything yet."
def test_debug_log_level(mocker):

69
tests/unit/utils/test_qtutils.py
View File

@ -258,9 +258,8 @@ def test_check_qdatastream(status, raising, message):
stream = QDataStream()
stream.setStatus(status)
if raising:
with pytest.raises(OSError) as excinfo:
with pytest.raises(OSError, match=message):
qtutils.check_qdatastream(stream)
assert str(excinfo.value) == message
else:
qtutils.check_qdatastream(stream)
@ -306,11 +305,11 @@ class TestSerializeStream:
"""Test serialize_stream with an error already set."""
stream_mock.status.return_value = QDataStream.ReadCorruptData
with pytest.raises(OSError) as excinfo:
with pytest.raises(OSError, match="The data stream has read corrupt "
"data."):
qtutils.serialize_stream(stream_mock, QPoint())
assert not stream_mock.__lshift__.called
assert str(excinfo.value) == "The data stream has read corrupt data."
def test_serialize_post_error_mock(self, stream_mock):
"""Test serialize_stream with an error while serializing."""
@ -318,21 +317,21 @@ class TestSerializeStream:
stream_mock.__lshift__.side_effect = lambda _other: self._set_status(
stream_mock, QDataStream.ReadCorruptData)
with pytest.raises(OSError) as excinfo:
with pytest.raises(OSError, match="The data stream has read corrupt "
"data."):
qtutils.serialize_stream(stream_mock, obj)
assert stream_mock.__lshift__.called_once_with(obj)
assert str(excinfo.value) == "The data stream has read corrupt data."
def test_deserialize_pre_error_mock(self, stream_mock):
"""Test deserialize_stream with an error already set."""
stream_mock.status.return_value = QDataStream.ReadCorruptData
with pytest.raises(OSError) as excinfo:
with pytest.raises(OSError, match="The data stream has read corrupt "
"data."):
qtutils.deserialize_stream(stream_mock, QPoint())
assert not stream_mock.__rshift__.called
assert str(excinfo.value) == "The data stream has read corrupt data."
def test_deserialize_post_error_mock(self, stream_mock):
"""Test deserialize_stream with an error while deserializing."""
@ -340,11 +339,11 @@ class TestSerializeStream:
stream_mock.__rshift__.side_effect = lambda _other: self._set_status(
stream_mock, QDataStream.ReadCorruptData)
with pytest.raises(OSError) as excinfo:
with pytest.raises(OSError, match="The data stream has read corrupt "
"data."):
qtutils.deserialize_stream(stream_mock, obj)
assert stream_mock.__rshift__.called_once_with(obj)
assert str(excinfo.value) == "The data stream has read corrupt data."
def test_round_trip_real_stream(self):
"""Test a round trip with a real QDataStream."""
@ -365,10 +364,9 @@ class TestSerializeStream:
"""Test serialize_stream with a read-only stream."""
data = QByteArray()
stream = QDataStream(data, QIODevice.ReadOnly)
with pytest.raises(OSError) as excinfo:
with pytest.raises(OSError, match="The data stream cannot write to "
"the underlying device."):
qtutils.serialize_stream(stream, QPoint())
assert str(excinfo.value) == ("The data stream cannot write to the "
"underlying device.")
@pytest.mark.qt_log_ignore('QIODevice::read.*: WriteOnly device')
def test_deserialize_writeonly_stream(self):
@ -376,10 +374,9 @@ class TestSerializeStream:
data = QByteArray()
obj = QPoint()
stream = QDataStream(data, QIODevice.WriteOnly)
with pytest.raises(OSError) as excinfo:
with pytest.raises(OSError, match="The data stream has read past the "
"end of the data in the underlying device."):
qtutils.deserialize_stream(stream, obj)
assert str(excinfo.value) == ("The data stream has read past the end "
"of the data in the underlying device.")
class SavefileTestException(Exception):
@ -409,13 +406,12 @@ class TestSavefileOpen:
qsavefile_mock.open.return_value = False
qsavefile_mock.errorString.return_value = "Hello World"
with pytest.raises(OSError) as excinfo:
with pytest.raises(OSError, match="Hello World"):
with qtutils.savefile_open('filename'):
pass
qsavefile_mock.open.assert_called_once_with(QIODevice.WriteOnly)
qsavefile_mock.cancelWriting.assert_called_once_with()
assert str(excinfo.value) == "Hello World"
def test_mock_exception(self, qsavefile_mock):
"""Test with a mock and an exception in the block."""
@ -433,14 +429,13 @@ class TestSavefileOpen:
qsavefile_mock.open.return_value = True
qsavefile_mock.commit.return_value = False
with pytest.raises(OSError) as excinfo:
with pytest.raises(OSError, match="Commit failed!"):
with qtutils.savefile_open('filename'):
pass
qsavefile_mock.open.assert_called_once_with(QIODevice.WriteOnly)
assert not qsavefile_mock.cancelWriting.called
assert not qsavefile_mock.errorString.called
assert str(excinfo.value) == "Commit failed!"
def test_mock_successful(self, qsavefile_mock):
"""Test with a mock and a successful write."""
@ -503,23 +498,21 @@ class TestSavefileOpen:
def test_failing_flush(self, tmpdir):
"""Test with the file being closed before flushing."""
filename = tmpdir / 'foo'
with pytest.raises(ValueError) as excinfo:
with pytest.raises(ValueError, match="IO operation on closed device!"):
with qtutils.savefile_open(str(filename), binary=True) as f:
f.write(b'Hello')
f.dev.commit() # provoke failing flush
assert str(excinfo.value) == "IO operation on closed device!"
assert tmpdir.listdir() == [filename]
def test_failing_commit(self, tmpdir):
"""Test with the file being closed before committing."""
filename = tmpdir / 'foo'
with pytest.raises(OSError) as excinfo:
with pytest.raises(OSError, match='Commit failed!'):
with qtutils.savefile_open(str(filename), binary=True) as f:
f.write(b'Hello')
f.dev.cancelWriting() # provoke failing commit
assert str(excinfo.value) == "Commit failed!"
assert tmpdir.listdir() == []
def test_line_endings(self, tmpdir):
@ -694,9 +687,8 @@ class TestPyQIODevice:
args: The arguments to pass.
"""
func = getattr(pyqiodev, method)
with pytest.raises(ValueError) as excinfo:
with pytest.raises(ValueError, match="IO operation on closed device!"):
func(*args)
assert str(excinfo.value) == "IO operation on closed device!"
@pytest.mark.parametrize('method', ['readline', 'read'])
def test_unreadable(self, pyqiodev, method):
@ -707,16 +699,15 @@ class TestPyQIODevice:
"""
pyqiodev.open(QIODevice.WriteOnly)
func = getattr(pyqiodev, method)
with pytest.raises(OSError) as excinfo:
with pytest.raises(OSError, match="Trying to read unreadable file!"):
func()
assert str(excinfo.value) == "Trying to read unreadable file!"
def test_unwritable(self, pyqiodev):
"""Test writing with a read-only device."""
pyqiodev.open(QIODevice.ReadOnly)
with pytest.raises(OSError) as excinfo:
with pytest.raises(OSError, match="Trying to write to unwritable "
"file!"):
pyqiodev.write(b'')
assert str(excinfo.value) == "Trying to write to unwritable file!"
@pytest.mark.parametrize('data', [b'12345', b''])
def test_len(self, pyqiodev, data):
@ -769,9 +760,8 @@ class TestPyQIODevice:
f.write(b'1234567890')
pyqiodev.open(QIODevice.ReadOnly)
if raising:
with pytest.raises(OSError) as excinfo:
with pytest.raises(OSError, match="seek failed!"):
pyqiodev.seek(offset, whence)
assert str(excinfo.value) == "seek failed!"
else:
pyqiodev.seek(offset, whence)
assert pyqiodev.tell() == pos
@ -800,12 +790,10 @@ class TestPyQIODevice:
proc.start(*py_proc('print("Hello World")'))
dev = qtutils.PyQIODevice(proc)
assert not dev.closed
with pytest.raises(OSError) as excinfo:
with pytest.raises(OSError, match='Random access not allowed!'):
dev.seek(0)
assert str(excinfo.value) == 'Random access not allowed!'
with pytest.raises(OSError) as excinfo:
with pytest.raises(OSError, match='Random access not allowed!'):
dev.tell()
assert str(excinfo.value) == 'Random access not allowed!'
proc.waitForFinished(1000)
proc.kill()
assert bytes(dev.read()).rstrip() == b'Hello World'
@ -900,9 +888,8 @@ class TestPyQIODevice:
def test_write_error(self, pyqiodev_failing):
"""Test writing with FailingQIODevice."""
with pytest.raises(OSError) as excinfo:
with pytest.raises(OSError, match="Writing failed"):
pyqiodev_failing.write(b'x')
assert str(excinfo.value) == 'Writing failed'
@pytest.mark.posix
@pytest.mark.skipif(not os.path.exists('/dev/full'),
@ -912,10 +899,9 @@ class TestPyQIODevice:
qf = QFile('/dev/full')
qf.open(QIODevice.WriteOnly | QIODevice.Unbuffered)
dev = qtutils.PyQIODevice(qf)
with pytest.raises(OSError) as excinfo:
with pytest.raises(OSError, match='No space left on device'):
dev.write(b'foo')
qf.close()
assert str(excinfo.value) == 'No space left on device'
@pytest.mark.parametrize('size, chunks', [
(-1, [b'1234567890']),
@ -951,9 +937,8 @@ class TestPyQIODevice:
args: A list of arguments to pass.
"""
func = getattr(pyqiodev_failing, method)
with pytest.raises(OSError) as excinfo:
with pytest.raises(OSError, match='Reading failed'):
func(*args)
assert str(excinfo.value) == 'Reading failed'
@pytest.mark.usefixtures('qapp')

5
tests/unit/utils/test_urlutils.py
View File

@ -471,13 +471,12 @@ def test_raise_cmdexc_if_invalid(url, valid, has_err_string):
urlutils.raise_cmdexc_if_invalid(qurl)
else:
assert bool(qurl.errorString()) == has_err_string
with pytest.raises(cmdexc.CommandError) as excinfo:
urlutils.raise_cmdexc_if_invalid(qurl)
if has_err_string:
expected_text = "Invalid URL - " + qurl.errorString()
else:
expected_text = "Invalid URL"
assert str(excinfo.value) == expected_text
with pytest.raises(cmdexc.CommandError, match=expected_text):
urlutils.raise_cmdexc_if_invalid(qurl)
@pytest.mark.parametrize('qurl, output', [