def test_empty_suite_call(self):
clear()
listener_ = Listener(0)
listener_.on_empty_suite = inc
count = COUNT
r_.start(listener=listener_)
self.assertEqual(count + 1, COUNT)
def _main_run(file_name_: str, p_: Dict, dry_run_: bool, filter_by_name_: str,
random_order: bool, max_fail: int, generate_report: bool):
# read the options file if exists
if is_file_exists(file_name_):
print(f"{file_name_} is found! Reading...")
params_ = read_parameters_from_file(file_name_)
if p_:
params_.get("params").update(p_)
start_with_parameters(params_)
# or walk down the folder tree recursively and find all modules with tests
else:
if file_name_ == 'options.json':
print(
f"Options file is not found! Searching for tests in all subfolders..."
)
_walk_through_and_import()
start(verbose=3,
threads=1,
params=p_,
dry_run=dry_run_,
filter_by_name=filter_by_name_,
random_order=random_order,
generate_report=generate_report)
# if options file was specified and doesn't exist, halt
else:
raise ValueError(f"{file_name_} not found! Stopping...")
def test_params_if_exists_and_use_in_test(self):
clear()
test(par_1)
start(listener=self._listener, params={'test': 'test'})
self.assertTrue(runner.common)
self.assertEqual('test', runner.common['test'])
self.assertEqual(1, runner.common['1'])
def start_with_parameters(parameters: Dict):
"""
Starts the test run using the collected parameters.
:param parameters: a dict of user specified parameters.
"""
params_ = _get_default_params()
params_.update(parameters)
check_parameters(params_)
modules = params_.get('modules')
listener_ = params_.get('listener')
try:
if listener_ and modules:
# if custom listener is specified, add it's module to the filter
if listener_ not in DEFAULT_LISTENERS:
modules.append('.'.join(listener_.split('.')[:-1]))
_walk_through_and_import(modules)
if listener_:
# if listener specified is one of the defaults, use it
if listener_ in DEFAULT_LISTENERS:
params_['listener'] = DEFAULT_LISTENERS[listener_](
params_['verbose'])
else:
# or try to import it from the filtered modules
class_ = _get_class_from_imported_modules(listener_)
# instantiate the listener object
params_['listener'] = class_(params_['verbose'])
except Exception:
print(f'Something went wrong during imports!', file=sys.stderr)
raise
start(**params_)
def test_parallel(self):
clear()
test(groups=('one', ))(half_second)
test(groups=('two', ))(half_second)
st = time()
start(listener=Listener(0), threads=2)
self.assertTrue(time() - st < 1)
def test_retries_if_fails(self):
clear()
test(retries=3)(failed)
start(listener=self._listener)
self.assertEqual(0, len(TestSuite.get_instance().success()))
self.assertEqual(3, len(TestSuite.get_instance().failed()))
self.assertEqual(3, TestSuite.get_instance().tests_count())
def test_not_run_after_suite_if_before_failed(self):
clear()
after_suite(a_suite)
test(fn)
TestSuite.get_instance().is_before_failed = True
start(listener=self._listener)
self.assertEqual('', common_str)
def test_run_after_suite_if_before_failed_and_flag_true(self):
clear()
after_suite(always_run=True)(a_suite)
test(fn)
TestSuite.get_instance().is_before_failed = True
start(listener=self._listener)
self.assertEqual('_as', common_str)
def test_raises_when_no_provider(self):
clear()
test(data_provider="missing")(valid_for_provider)
with self.assertRaises(UnknownProviderName) as e:
start(TestSuite.get_instance(), listener=Listener(0))
self.assertTrue("Could not find provider(s) named ['missing']" in
e.exception.args[0])
def test_ends_call(self):
clear()
listener_ = Listener(0)
listener_.on_suite_ends = inc
count = COUNT
test(fake)
r_.start(listener=listener_)
self.assertEqual(count + 1, COUNT)
def test_dry_run_call(self):
clear()
listener_ = Listener(0)
listener_.on_dry_run = inc
count = COUNT
test(fake)
r_.start(listener=listener_, dry_run=True)
self.assertEqual(count + 1, COUNT)
def test_ignored_by_condition_call(self):
clear()
listener_ = Listener(0)
listener_.on_ignored_by_condition = inc
count = COUNT
test(only_if=lambda: False)(fake)
r_.start(listener=listener_)
self.assertEqual(count + 1, COUNT)
def test_priorities(self):
clear()
test(priority=3)(b_suite)
test(priority=2)(a_suite)
test(priority=1)(b_group)
test(fn)
start(listener=self._listener)
self.assertEqual('testbg__asbs_', common_str)
def test_not_run_after_group_if_before_failed(self):
clear()
after_group(a_group)
test(fn)
list(TestSuite.get_instance().groups.values()
)[0].is_before_failed = True
start(listener=self._listener)
self.assertEqual('', common_str)
def test_run_after_group_if_before_failed_and_flag_true(self):
clear()
after_group(always_run=True)(a_group)
test(fn)
list(TestSuite.get_instance().groups.values()
)[0].is_before_failed = True
start(listener=self._listener)
self.assertEqual('_ag', common_str)
def test_timeout_failed_if_bigger(self):
clear()
test(timeout=1)(long)
start(listener=Listener(0))
self.assertEqual(1, len(TestSuite.get_instance().broken()))
self.assertEqual(0, len(TestSuite.get_instance().success()))
self.assertEqual(0, len(TestSuite.get_instance().failed()))
self.assertEqual(1, TestSuite.get_instance().tests_count())
def test_assert_less(self):
def _():
assert 2 < 1
test(_)
runner.start(listener=_listener)
self.assertTrue(type(a_list[0]) is AssertionError)
self.assertEqual(a_list[0].args[0], '2 is greater or equal to 1')
def test_timeout_ok_if_less(self):
clear()
test(timeout=10)(simple)
start(listener=Listener(0))
self.assertEqual(0, len(TestSuite.get_instance().broken()))
self.assertEqual(1, len(TestSuite.get_instance().success()))
self.assertEqual(0, len(TestSuite.get_instance().failed()))
self.assertEqual(1, TestSuite.get_instance().tests_count())
def test_is_run_if_only_true(self):
clear()
test(only_if=lambda: True)(sa_ok)
start(listener=Listener(0))
self.assertEqual(0, len(TestSuite.get_instance().broken()))
self.assertEqual(1, len(TestSuite.get_instance().success()))
self.assertEqual(0, len(TestSuite.get_instance().failed()))
self.assertEqual(1, TestSuite.get_instance().tests_count())
def test_soft_failed(self):
clear()
test(sa_failed)
start(listener=Listener(0))
self.assertEqual(0, len(TestSuite.get_instance().broken()))
self.assertEqual(0, len(TestSuite.get_instance().success()))
self.assertEqual(1, len(TestSuite.get_instance().failed()))
self.assertEqual(1, TestSuite.get_instance().tests_count())
def test_assert_greater(self):
def _():
assert 1 > 2
test(_)
runner.start(listener=_listener)
self.assertTrue(type(a_list[0]) is AssertionError)
self.assertEqual(a_list[0].args[0], '1 is less or equal to 2')
def test_assert_not_equal(self):
def _():
assert 1 != 1
test(_)
runner.start(listener=_listener)
self.assertTrue(type(a_list[0]) is AssertionError)
self.assertEqual(a_list[0].args[0], 'Objects are equal (1 == 1)')
def test_starts_call(self):
clear()
reload(r_)
listener_ = Listener(0)
listener_.on_test_starts = inc
count = COUNT
test(fake)
r_.start(listener=listener_)
self.assertEqual(count + 1, COUNT)
def test_provider_get_none(self):
clear()
CONTAINER([1, None], name='three')
test(data_provider="three")(_fn)
start(listener=Listener(0))
self.assertEqual(0, len(TestSuite.get_instance().broken()))
self.assertEqual(1, len(TestSuite.get_instance().success()))
self.assertEqual(1, len(TestSuite.get_instance().failed()))
self.assertEqual(2, TestSuite.get_instance().tests_count())
def test_ignored_call(self):
clear()
listener_ = Listener(0)
listener_.on_ignored = inc
count = COUNT
test(fake)
before(lambda: int('a'))
r_.start(listener=listener_)
self.assertEqual(count + 1, COUNT)
def test_timeout_failed_with_data(self):
clear()
provider(name='three')(return2)
test(timeout=1, data_provider="three")(long_data)
start(listener=Listener(0))
self.assertEqual(3, len(TestSuite.get_instance().broken()))
self.assertEqual(0, len(TestSuite.get_instance().success()))
self.assertEqual(0, len(TestSuite.get_instance().failed()))
self.assertEqual(3, TestSuite.get_instance().tests_count())
def test_before_suite_failed_call(self):
clear()
listener_ = Listener(0)
listener_.on_before_suite_failed = inc
count = COUNT
before_suite(lambda: int('a'))
test(fake)
r_.start(listener=listener_)
self.assertEqual(count + 1, COUNT)
def test_on_max_fail_not_call(self):
clear()
listener_ = Listener(0)
listener_.on_suite_stop_with_max_fail = inc
count = COUNT
test(fail)
test(fail)
r_.start(listener=listener_, max_fail=3)
self.assertEqual(count, COUNT)
def test_assert_simple_not(self):
def _():
assert not True
test(_)
runner.start(listener=_listener)
self.assertTrue(type(a_list[0]) is AssertionError)
self.assertEqual(a_list[0].args[0],
'"not True" is False but True was expected')
def test_assert_with_message(self):
def _():
assert bool(0), 'test'
test(_)
runner.start(listener=_listener)
self.assertTrue(type(a_list[0]) is AssertionError)
self.assertEqual(a_list[0].args[0],
'test\n"bool(0)" is False but True was expected')
