def test_ignore_warnings(emitter, catch, can_test_negative):
catch()
with slash.Session() as session:
emitter()
assert list(session.warnings) == []
if can_test_negative:
with slash.Session() as session:
warnings.warn('uncaught', category=DeprecationWarning)
caught = list(session.warnings)
assert len(caught) == 1
assert caught[0].message == 'uncaught'
def test_fake_traceback(self):
with slash.Session(), pytest.raises(ZeroDivisionError):
with exception_handling.handling_exceptions(fake_traceback=False):
self._expected_line_number = inspect.currentframe(
).f_lineno + 1
a = 1 / 0
return a
with slash.Session(), pytest.raises(ZeroDivisionError):
with exception_handling.handling_exceptions():
self._expected_line_number = inspect.currentframe(
).f_lineno + 1
a = 1 / 0
return a
def test_abstract_tests(self):
@slash.abstract_test_class
class Abstract(slash.Test):
def test1(self):
pass
def test2(self):
pass
def test3(self):
pass
with slash.Session():
self.assertEqual(list(make_runnable_tests(Abstract)), [])
class Derived(Abstract):
pass
with slash.Session():
self.assertEqual(len(list(make_runnable_tests(Derived))), 3)
def test_add_test_cleanup_from_session_scope_forbidden(checkpoint):
with slash.Session():
with pytest.raises(IncorrectScope):
slash.add_cleanup(checkpoint, scope='test')
assert not checkpoint.called
def test_assert_raises(exc_types, message):
raised = CustomException()
with slash.Session():
with slash.assert_raises(exc_types, msg=message) as caught:
raise raised
assert sys.exc_info() == exception_handling.NO_EXC_INFO
assert caught.exception is raised
def test_debugger_called_on_hooks(hook_exception, request, forge,
config_override, checkpoint, debug_enabled):
hook_name, exception_type, should_raise = hook_exception
@gossip.register(hook_name)
def raise_exc():
raise exception_type()
config_override("debug.enabled", debug_enabled)
def test_something():
pass
forge.replace_with(slash.utils.debug, 'launch_debugger', checkpoint)
with ExitStack() as exception_stack:
if should_raise:
exception_stack.enter_context(pytest.raises(exception_type))
with slash.Session() as s:
with s.get_started_context():
slash.runner.run_tests(make_runnable_tests(test_something))
assert checkpoint.called == debug_enabled
if debug_enabled:
assert checkpoint.args[0][0] is exception_type
assert type(checkpoint.args[0][1]) is exception_type # pylint: disable=unidiomatic-typecheck
def test_result_test_garbage_collected(gc_marker):
class SomeTest(slash.Test):
def test_something(self):
pass
# we have to run another test at the end to make sure Slash's internal _last_test
# doesn't refer to our test
class OtherTest(slash.Test):
def test_something(self):
pass
marks = []
runnable_tests = []
test_funcs = [SomeTest, OtherTest]
@slash.hooks.register
def tests_loaded(tests): # pylint: disable=unused-variable
runnable_tests.extend(tests)
marks.extend(list(gc_marker.mark(t) for t in runnable_tests[:-1]))
with slash.Session() as s: # pylint: disable=unused-variable
session = run_tests_assert_success(test_funcs) # pylint: disable=unused-variable
del runnable_tests[:]
gc.collect()
for mark in marks:
assert mark.destroyed
def test_fixture_exclusion_multiple():
with slash.Session() as s:
@s.fixture_store.add_fixture
@slash.parametrize('param', [1, 2])
@slash.fixture
def fixture1(param):
return param * 10
@s.fixture_store.add_fixture
@slash.parametrize('param', [3, 4])
@slash.fixture
def fixture2(param):
return param * 10
@slash.exclude(('fixture1.param', 'fixture2.param'), [(2, 3)])
def test_something(fixture1, fixture2):
slash.context.result.data['values'] = fixture1, fixture2
results = resolve_and_run(test_something)
assert len(results) == 4
value_pairs = [result.data.get('values') for result in results]
for result, value_pair in zip(results, value_pairs):
if value_pair is None:
assert not result.is_started()
else:
assert result.is_success()
assert value_pairs == [(10, 30), (10, 40), None, (20, 40)]
def test_add_failure_error_object_marked_as_failure():
with slash.Session() as s:
with s.get_started_context():
slash.add_failure('msg')
[failure] = slash.context.result.get_failures() # pylint: disable=unbalanced-tuple-unpacking
assert failure.is_failure()
def test_fixture_parameters(store):
@store.add_fixture
@slash.fixture
def value(x, a):
assert a == 'a', 'Fixture got unexpectedly overriden by parameter'
return x
@store.add_fixture
@slash.fixture
def a():
return 'a'
@store.add_fixture
@slash.fixture
@slash.parametrize('a', [1, 2, 3])
def x(a, b):
return (a, b)
@store.add_fixture
@slash.parametrize('b', [4, 5, 6])
@slash.fixture
def b(b):
return b
store.resolve()
with slash.Session():
variations = list(_get_all_values(store, 'value'))
assert set(variations) == set(itertools.product([1, 2, 3], [4, 5, 6]))
def test_yield_fixture(yield_fixture_decorator):
iterations = [uuid4() for i in range(3)]
start_checkpoints, end_checkpoints = [{
iteration: Checkpoint()
for iteration in iterations
} for i in range(2)]
value = uuid4()
inner_fixture_value = uuid4()
with slash.Session() as s:
@s.fixture_store.add_fixture
@slash.fixture
def other_fixture():
return inner_fixture_value
@s.fixture_store.add_fixture
@slash.parametrize('iteration', list(iterations))
@yield_fixture_decorator
def fixture(iteration, other_fixture):
assert other_fixture == inner_fixture_value
start_checkpoints[iteration]()
yield value
end_checkpoints[iteration]()
def test_something(fixture):
assert fixture == value
s.fixture_store.resolve()
with s.get_started_context():
slash.runner.run_tests(make_runnable_tests(test_something))
assert s.results.is_success(allow_skips=False)
def test_add_error_for_error_log_level(tmpdir, should_consider_error,
config_override, test_handler):
message = 'Hello'
non_capture_message = 'Do not capture as error'
test_handler.level = logbook.ERROR
config_override('log.root', str(tmpdir))
config_override('run.capture.error_logs_as_errors', should_consider_error)
def test_with_log_error():
logger = logbook.Logger('some-logger')
logger.error(message)
logger.error(non_capture_message, extra={'capture': False})
with slash.Session() as session:
with session.get_started_context():
slash.runner.run_tests(make_runnable_tests(test_with_log_error))
[result] = [
res for res in session.results.iter_all_results()
if not res.is_global_result()
]
expected_error_messages = [message] if should_consider_error else []
assert [res.message
for res in result.get_errors()] == expected_error_messages
assert [rec.message
for rec in test_handler.records] == [message, non_capture_message]
def error(get_error_adder, use_exception):
def f1():
obj = ExampleObject()
try:
obj.method1()
except ZeroDivisionError:
assert use_exception
get_error_adder()()
class ExampleObject(object):
def __init__(self):
self.a = 1
self.b = 2
def method1(self):
g1()
def g1():
h1()
def h1():
if use_exception:
1 / 0
else:
get_error_adder()("error message")
with slash.Session() as s:
f1()
[err] = s.results.global_result.get_errors()
return err
def test_pdb_filtering_with_disabled_debug(replaced_checkpoint, exc_info,
config_override):
config_override('debug.enabled', False)
config_override('debug.filter_strings', ['ZeroDivisionError'])
with slash.Session():
debug.debug_if_needed(exc_info)
assert not replaced_checkpoint.called
def test_requirements_on_class_with_fixture_and_autouse_fixture(
filename_test_fixture):
with slash.Session():
[test] = make_runnable_tests( # pylint: disable=unbalanced-tuple-unpacking
filename_test_fixture)
assert sorted([str(r)
for r in test.get_requirements()]) == ["msg1", "msg2"]
def test_pdb_filtering(filter_strings, should_pdb, replaced_checkpoint,
exc_info, config_override):
config_override('debug.enabled', True)
config_override('debug.filter_strings', filter_strings)
with slash.Session():
debug.debug_if_needed(exc_info)
assert replaced_checkpoint.called == should_pdb
def get_tests_from_dirs(dirs):
tests = {}
with slash.Session():
runnables = Loader().get_runnables(dirs)
for r in runnables:
rel_path = os.path.relpath(r.__slash__.address, '.')
full_name = rel_path.split('\\')[-1]
if not ('(' in full_name):
full_name += '()'
p = re.compile(r'(.*):(.*)(\(.*\))')
items = p.findall(full_name)
filename = items[0][0]
filepath = os.path.dirname(rel_path) + '\\' + filename
testname = items[0][1]
opt = items[0][2]
if filepath in tests:
if testname in tests[filepath]:
tests[filepath][testname] += ' ' + opt
else:
tests[filepath][testname] = opt
else:
tests[filepath] = {testname: opt}
return tests
def test_test_class(self):
events = []
class Test(slash.Test):
def before(self):
events.append("before")
def after(self):
events.append("after")
def test_1(self):
events.append("test_1")
def test_2(self):
events.append("test_2")
with slash.Session():
tests = make_runnable_tests(Test)
for test in tests:
self.assertIsInstance(test, Test)
self.assertEqual(len(tests), 2)
tests.sort(key=lambda test: test._test_method_name) # pylint: disable=protected-access
for test in tests:
test.run()
self.assertEqual(
events, ["before", "test_1", "after", "before", "test_2", "after"])
def test_hook_calling_order(self):
# pylint: disable=no-member
# expect:
with self.forge.any_order():
self.plugin1.activate()
self.plugin2.activate()
with self.forge.any_order():
self.plugin1.before_session_start()
self.plugin2.before_session_start()
with self.forge.any_order():
self.plugin1.session_start()
self.plugin2.session_start()
with self.forge.any_order():
self.plugin1.after_session_start()
self.plugin2.after_session_start()
self.plugin1.session_end()
self.plugin1.after_session_end()
self.forge.replay()
# get:
plugins.manager.install(self.plugin1, activate=True)
plugins.manager.install(self.plugin2, activate=True)
with slash.Session() as s:
with s.get_started_context():
pass
def test_parameters(self):
variations = []
a_values = [1, 2]
b_values = [3, 4]
c_values = [5, 6]
d_values = [7, 8]
class Parameterized(slash.Test):
@slash.parameters.iterate(a=a_values)
def before(self, a): # pylint: disable=arguments-differ
variations.append([a])
@slash.parameters.iterate(b=b_values, c=c_values)
def test(self, b, c):
variations[-1].extend([b, c])
@slash.parameters.iterate(d=d_values)
def after(self, d): # pylint: disable=arguments-differ
variations[-1].append(d)
with slash.Session():
for test in make_runnable_tests(Parameterized):
test.run()
self.assertEqual(
set(tuple(x) for x in variations),
set(itertools.product(a_values, b_values, c_values, d_values)))
def slash_list(args, report_stream=sys.stdout):
_print = partial(print, file=report_stream)
_report_error = partial(print, file=sys.stderr)
parser = _get_parser()
parsed_args = parser.parse_args(args)
if not parsed_args.paths and not parsed_args.suite_files:
parser.error('Neither test paths nor suite files were specified')
with slash.Session() as session:
slash.site.load()
loader = slash.loader.Loader()
runnables = loader.get_runnables(
itertools.chain(parsed_args.paths,
iter_suite_file_paths(parsed_args.suite_files)))
used_fixtures = set()
for test in runnables:
used_fixtures.update(test.get_required_fixture_objects())
if parsed_args.only in (None, 'fixtures'):
_report_fixtures(parsed_args, session, _print, used_fixtures)
if parsed_args.only in (None, 'tests'):
_report_tests(parsed_args, runnables, _print)
if len(runnables):
return 0
_report_error('No tests were found!')
return not int(parsed_args.allow_empty)
def test_parametrization_info_availabe_on_test_start(checkpoint):
param_value = str(uuid4())
@gossip.register('slash.test_start')
def test_start_hook():
assert slash.context.test.__slash__.variation.values['param'] == param_value
assert 'fixture' not in slash.context.test.__slash__.variation.values
checkpoint()
@slash.parametrize('param', [param_value])
def test_something(param, fixture):
pass
with slash.Session() as s:
@s.fixture_store.add_fixture
@slash.fixture
def fixture():
pass
s.fixture_store.resolve()
with s.get_started_context():
slash.runner.run_tests(make_runnable_tests(test_something))
assert s.results.is_success(allow_skips=False)
assert checkpoint.called
def results():
tests = []
def include(f):
tests.append(f)
return f
@include
def test_no_params():
pass
@include
def test_single_param_fixture(fixture):
_capture_arguments()
@include
def test_nested_fixture(outer_fixture):
_capture_arguments()
@include
@slash.parametrize(('x', 'y'), [(1, 2)])
def test_parametrization_tuple(x, y):
_capture_arguments()
@include
@slash.parameters.toggle('toggle')
def test_fixture_and_toggle(fixture, toggle):
_capture_arguments()
with slash.Session() as s:
@s.fixture_store.add_fixture
@slash.fixture
def fixture():
return _object1
@s.fixture_store.add_fixture
@slash.fixture
@slash.parametrize('x', [1, 2, 3])
def inner_fixture(x):
return 'inner{}'.format(x)
@s.fixture_store.add_fixture
@slash.fixture
@slash.parametrize('outer_param', [666])
def outer_fixture(inner_fixture, outer_param):
return 'outer_{}'.format(inner_fixture)
s.fixture_store.resolve()
with s.get_started_context():
slash.runner.run_tests(make_runnable_tests(tests))
assert s.results.is_success(allow_skips=False)
returned = collections.defaultdict(list)
for res in s.results.iter_test_results():
returned[res.test_metadata.function_name].append(res)
return Munch(returned)
def test_reraise_after_exc_info_reset():
@gossip.register('slash.exception_caught_before_debugger')
def exception_hook(): # pylint: disable=unused-variable
sys.exc_clear() # pylint: disable=no-member
with slash.Session(), pytest.raises(CustomException):
with exception_handling.handling_exceptions():
raise CustomException()
def test_allowing_exceptions(exc_types, message):
raised = CustomException()
with slash.Session():
with slash.allowing_exceptions(exc_types, msg=message) as caught:
with logbook.TestHandler() as handler:
raise raised
assert sys.exc_info() == exception_handling.NO_EXC_INFO
assert caught.exception is raised
assert len(handler.records) == 0 # pylint: disable=len-as-condition
def _assert_skips(thing, reason=None):
with slash.Session():
if isinstance(thing, type) and issubclass(thing, slash.Test):
[thing] = make_runnable_tests(thing)
thing = thing.run
with pytest.raises(slash.exceptions.SkipTest) as caught:
thing()
assert caught.value.reason == reason
def test_setting_getting_tags_on_metadata(taggable):
slash.tag('tagname')(taggable)
with slash.Session() as s: # pylint: disable=unused-variable
tests = Loader().get_runnables(taggable)
assert tests
for t in tests:
assert 'tagname' in t.__slash__.tags
def test_handling_exceptions_skip_test_would_not_return_skip_test():
with pytest.raises(SkipTest) as caught:
with slash.Session():
with exception_handling.handling_exceptions() as handled:
raise SkipTest('Unittest')
assert isinstance(caught.value, SkipTest)
assert handled.exception is caught.value
assert exception_handling.is_exception_handled(caught.value)
def active_slash_session(request):
returned = slash.Session()
returned.__enter__()
@request.addfinalizer
def finalize(): # pylint: disable=unused-variable
returned.__exit__(None, None, None)
return returned
def test_swallow_types():
value = CustomException()
with slash.Session():
with exception_handling.handling_exceptions(
swallow_types=(CustomException, )) as handled:
raise value
assert sys.exc_info() == exception_handling.NO_EXC_INFO
assert handled.exception is value
