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