192 lines
6.2 KiB
Python
192 lines
6.2 KiB
Python
# Created By: Virgil Dupras
|
|
# Created On: 2010-11-14
|
|
# Copyright 2015 Hardcoded Software (http://www.hardcoded.net)
|
|
#
|
|
# This software is licensed under the "GPLv3" License as described in the "LICENSE" file,
|
|
# which should be included with this package. The terms are also available at
|
|
# http://www.gnu.org/licenses/gpl-3.0.html
|
|
|
|
import pytest
|
|
|
|
|
|
def eq_(a, b, msg=None):
|
|
__tracebackhide__ = True
|
|
assert a == b, msg or "{!r} != {!r}".format(a, b)
|
|
|
|
|
|
def callcounter():
|
|
def f(*args, **kwargs):
|
|
f.callcount += 1
|
|
|
|
f.callcount = 0
|
|
return f
|
|
|
|
|
|
class CallLogger:
|
|
"""This is a dummy object that logs all calls made to it.
|
|
|
|
It is used to simulate the GUI layer.
|
|
"""
|
|
|
|
def __init__(self):
|
|
self.calls = []
|
|
|
|
def __getattr__(self, func_name):
|
|
def func(*args, **kw):
|
|
self.calls.append(func_name)
|
|
|
|
return func
|
|
|
|
def clear_calls(self):
|
|
del self.calls[:]
|
|
|
|
def check_gui_calls(self, expected, verify_order=False):
|
|
"""Checks that the expected calls have been made to 'self', then clears the log.
|
|
|
|
`expected` is an iterable of strings representing method names.
|
|
If `verify_order` is True, the order of the calls matters.
|
|
"""
|
|
__tracebackhide__ = True
|
|
if verify_order:
|
|
eq_(self.calls, expected)
|
|
else:
|
|
eq_(set(self.calls), set(expected))
|
|
self.clear_calls()
|
|
|
|
def check_gui_calls_partial(self, expected=None, not_expected=None, verify_order=False):
|
|
"""Checks that the expected calls have been made to 'self', then clears the log.
|
|
|
|
`expected` is an iterable of strings representing method names. Order doesn't matter.
|
|
Moreover, if calls have been made that are not in expected, no failure occur.
|
|
`not_expected` can be used for a more explicit check (rather than calling `check_gui_calls`
|
|
with an empty `expected`) to assert that calls have *not* been made.
|
|
"""
|
|
__tracebackhide__ = True
|
|
if expected is not None:
|
|
not_called = set(expected) - set(self.calls)
|
|
assert not not_called, f"These calls haven't been made: {not_called}"
|
|
if verify_order:
|
|
max_index = 0
|
|
for call in expected:
|
|
index = self.calls.index(call)
|
|
if index < max_index:
|
|
raise AssertionError(f"The call {call} hasn't been made in the correct order")
|
|
max_index = index
|
|
if not_expected is not None:
|
|
called = set(not_expected) & set(self.calls)
|
|
assert not called, f"These calls shouldn't have been made: {called}"
|
|
self.clear_calls()
|
|
|
|
|
|
class TestApp:
|
|
def __init__(self):
|
|
self._call_loggers = []
|
|
|
|
def clear_gui_calls(self):
|
|
for logger in self._call_loggers:
|
|
logger.clear_calls()
|
|
|
|
def make_logger(self, logger=None):
|
|
if logger is None:
|
|
logger = CallLogger()
|
|
self._call_loggers.append(logger)
|
|
return logger
|
|
|
|
def make_gui(self, name, class_, view=None, parent=None, holder=None):
|
|
if view is None:
|
|
view = self.make_logger()
|
|
if parent is None:
|
|
# The attribute "default_parent" has to be set for this to work correctly
|
|
parent = self.default_parent
|
|
if holder is None:
|
|
holder = self
|
|
setattr(holder, f"{name}_gui", view)
|
|
gui = class_(parent)
|
|
gui.view = view
|
|
setattr(holder, name, gui)
|
|
return gui
|
|
|
|
|
|
# To use @with_app, you have to import app in your conftest.py file.
|
|
def with_app(setupfunc):
|
|
def decorator(func):
|
|
func.setupfunc = setupfunc
|
|
return func
|
|
|
|
return decorator
|
|
|
|
|
|
@pytest.fixture
|
|
def app(request):
|
|
setupfunc = request.function.setupfunc
|
|
if hasattr(setupfunc, "__code__"):
|
|
argnames = setupfunc.__code__.co_varnames[: setupfunc.__code__.co_argcount]
|
|
|
|
def getarg(name):
|
|
if name == "self":
|
|
return request.function.__self__
|
|
else:
|
|
return request.getfixturevalue(name)
|
|
|
|
args = [getarg(argname) for argname in argnames]
|
|
else:
|
|
args = []
|
|
app = setupfunc(*args)
|
|
return app
|
|
|
|
|
|
def _unify_args(func, args, kwargs, args_to_ignore=None):
|
|
"""Unify args and kwargs in the same dictionary.
|
|
|
|
The result is kwargs with args added to it. func.func_code.co_varnames is used to determine
|
|
under what key each elements of arg will be mapped in kwargs.
|
|
|
|
if you want some arguments not to be in the results, supply a list of arg names in
|
|
args_to_ignore.
|
|
|
|
if f is a function that takes *args, func_code.co_varnames is empty, so args will be put
|
|
under 'args' in kwargs.
|
|
|
|
def foo(bar, baz)
|
|
_unifyArgs(foo, (42,), {'baz': 23}) --> {'bar': 42, 'baz': 23}
|
|
_unifyArgs(foo, (42,), {'baz': 23}, ['bar']) --> {'baz': 23}
|
|
"""
|
|
result = kwargs.copy()
|
|
if hasattr(func, "__code__"): # built-in functions don't have func_code
|
|
args = list(args)
|
|
if getattr(func, "__self__", None) is not None: # bound method, we have to add self to args list
|
|
args = [func.__self__] + args
|
|
defaults = list(func.__defaults__) if func.__defaults__ is not None else []
|
|
arg_count = func.__code__.co_argcount
|
|
arg_names = list(func.__code__.co_varnames)
|
|
if len(args) < arg_count: # We have default values
|
|
required_arg_count = arg_count - len(args)
|
|
args = args + defaults[-required_arg_count:]
|
|
for arg_name, arg in zip(arg_names, args):
|
|
# setdefault is used because if the arg is already in kwargs, we don't want to use default values
|
|
result.setdefault(arg_name, arg)
|
|
else:
|
|
# 'func' has a *args argument
|
|
result["args"] = args
|
|
if args_to_ignore:
|
|
for kw in args_to_ignore:
|
|
del result[kw]
|
|
return result
|
|
|
|
|
|
def log_calls(func):
|
|
"""Logs all func calls' arguments under func.calls.
|
|
|
|
func.calls is a list of _unify_args() result (dict).
|
|
|
|
Mostly used for unit testing.
|
|
"""
|
|
|
|
def wrapper(*args, **kwargs):
|
|
unified_args = _unify_args(func, args, kwargs)
|
|
wrapper.calls.append(unified_args)
|
|
return func(*args, **kwargs)
|
|
|
|
wrapper.calls = []
|
|
return wrapper
|