def test_runner_should_continue_running_steps_when_step_is_skipped_or_pending(
hook_registry, default_config, mocker):
"""The Runner should continue running Steps after a Step is skipped"""
# given
runner = Runner(default_config, None, hook_registry)
runner.run_step = mocker.MagicMock()
runner.run_step.side_effect = [
State.PASSED,
State.SKIPPED,
State.PENDING,
State.PASSED,
]
scenario_mock = mocker.MagicMock(name="Scenario")
scenario_mock.background = None
first_step = mocker.MagicMock(name="First Step")
second_step = mocker.MagicMock(name="Second Step")
third_step = mocker.MagicMock(name="Third Step")
fourth_step = mocker.MagicMock(name="Fourth Step")
scenario_mock.steps = [first_step, second_step, third_step, fourth_step]
# when
runner.run_scenario(scenario_mock)
# then
runner.run_step.assert_has_calls([
call(first_step),
call(second_step),
call(third_step),
call(fourth_step)
])
def test_runner_should_call_hooks_when_runner_a_scenario(
hook_registry, default_config, mocker):
"""The Runner should call the ``each_scenario`` hooks when running a Scenario"""
# given
runner = Runner(default_config, None, hook_registry)
scenario_mock = mocker.MagicMock(name="Scenario")
# when
runner.run_scenario(scenario_mock)
# then
hook_registry.call.assert_has_calls([
call("each_scenario", "before", False, scenario_mock),
call("each_scenario", "after", False, scenario_mock),
])
def test_running_a_scenario(self):
"""
Test running a scenario
"""
data = threading.local()
data.step_was_called = False
def some_step(step):
data.step_was_called = True
step = Step(1, "Some step", "somefile.feature", 3, None, True)
step.definition_func = some_step
argument_match_mock = Mock()
argument_match_mock.evaluate.return_value = (tuple(), {})
step.argument_match = argument_match_mock
scenario = Scenario(1, 1, "Scenario", "Some scenario",
"somefile.feature", 2, None)
scenario.steps.append(step)
hook_mock = Mock()
hook_mock.call.return_value = True
runner = Runner(hook_mock)
returncode = runner.run_scenario(scenario)
returncode.should.be.equal(0)
step.state.should.be.equal(Step.State.PASSED)
data.step_was_called.should.be.true
def test_running_a_scenario(self):
"""
Test running a scenario
"""
data = threading.local()
data.step_was_called = False
def some_step(step):
data.step_was_called = True
step = Step(1, "Some step", "somefile.feature", 3, None, True)
step.definition_func = some_step
step.arguments = tuple()
step.keyword_arguments = {}
scenario = Scenario(1, 1, "Scenario", "Some scenario", "somefile.feature", 2, None)
scenario.steps.append(step)
hook_mock = Mock()
hook_mock.call.return_value = True
runner = Runner(hook_mock)
returncode = runner.run_scenario(scenario)
returncode.should.be.equal(0)
step.state.should.be.equal(Step.State.PASSED)
data.step_was_called.should.be.true
def test_runner_should_shuffle_scenarios_in_a_scenario_container_if_shuffle_scenarios_flag_set(
hook_registry, default_config, mocker):
"""
The Runner should shuffle the Scenarios within a Scenario Container before
running them if the shuffle Scenarios flag is set
"""
# given
default_config.shuffle_scenarios = True
runner = Runner(default_config, None, hook_registry)
runner.run_scenario = mocker.MagicMock()
scenario_container_mock = mocker.MagicMock(name="Rule")
scenario = mocker.MagicMock(name="Scenario")
scenario_container_mock.examples = [scenario]
mocker.patch("random.sample")
# when
runner.run_scenario_container(scenario_container_mock)
# then
import random
random.sample.assert_called_once_with(
scenario_container_mock.examples,
len(scenario_container_mock.examples))
def test_runner_should_exit_for_failed_scenario_in_scenario_container_if_early_exit_flag_is_set(
hook_registry, default_config, mocker):
"""
The Runner should exit for a failed Scenario in
Scenario Container if the early exit flag is set
"""
# given
default_config.early_exit = True
runner = Runner(default_config, None, hook_registry)
runner.run_scenario = mocker.MagicMock()
runner.run_scenario.side_effect = [
State.PASSED, State.FAILED, State.PASSED
]
scenario_container_mock = mocker.MagicMock(name="Scenario Container")
first_scenario = mocker.MagicMock(name="First Scenario")
second_scenario = mocker.MagicMock(name="Second Scenario")
third_scenario = mocker.MagicMock(name="Third Scenario")
scenario_container_mock.examples = [
first_scenario, second_scenario, third_scenario
]
# when
runner.run_scenario_container(scenario_container_mock)
# then
runner.run_scenario.assert_has_calls(
[call(first_scenario), call(second_scenario)])
def test_runner_should_stop_running_steps_after_first_failed(
hook_registry, default_config, mocker):
"""The Runner should stop running Steps after the first Step failed in normal mode"""
# given
runner = Runner(default_config, None, hook_registry)
runner.run_step = mocker.MagicMock()
runner.run_step.side_effect = [State.PASSED, State.FAILED]
scenario_mock = mocker.MagicMock(name="Scenario")
scenario_mock.background = None
first_step = mocker.MagicMock(name="First Step")
second_step = mocker.MagicMock(name="Second Step")
scenario_mock.steps = [first_step, second_step]
# when
runner.run_scenario(scenario_mock)
# then
runner.run_step.assert_has_calls([call(first_step)])
def test_runner_should_iterate_all_steps_in_a_scenario(hook_registry,
default_config, mocker):
"""The Runner should iterate all Steps in a Scenario"""
# given
runner = Runner(default_config, None, hook_registry)
runner.run_step = mocker.MagicMock()
runner.run_step.return_value = State.PASSED
scenario_mock = mocker.MagicMock(name="Scenario")
scenario_mock.background = None
first_step = mocker.MagicMock(name="First Step")
second_step = mocker.MagicMock(name="Second Step")
scenario_mock.steps = [first_step, second_step]
# when
runner.run_scenario(scenario_mock)
# then
runner.run_step.assert_has_calls([call(first_step), call(second_step)])
def test_runner_should_run_all_steps_even_when_failed_in_dry_run_mode(
hook_registry, default_config, mocker):
"""The Runner should runn all Steps even when one failed in the dry run mode"""
# given
default_config.dry_run_mode = True
runner = Runner(default_config, None, hook_registry)
runner.run_step = mocker.MagicMock()
runner.run_step.side_effect = [State.FAILED, State.UNTESTED]
scenario_mock = mocker.MagicMock(name="Scenario")
scenario_mock.background = None
first_step = mocker.MagicMock(name="First Step")
second_step = mocker.MagicMock(name="Second Step")
scenario_mock.steps = [first_step, second_step]
# when
runner.run_scenario(scenario_mock)
# then
runner.run_step.assert_has_calls([call(first_step), call(second_step)])
def test_runner_should_only_not_run_steps_in_a_scenario_if_background_not_passed(
hook_registry, default_config, mocker):
"""
The Runner should not run Steps in a Scenario
if the Background is available and did not pass.
"""
# given
runner = Runner(default_config, None, hook_registry)
runner.run_step = mocker.MagicMock()
runner.run_step.return_value = State.PASSED
scenario_mock = mocker.MagicMock(name="Scenario")
scenario_mock.background.state = State.FAILED
first_step = mocker.MagicMock(name="First Step")
scenario_mock.steps = [first_step]
# when
runner.run_scenario(scenario_mock)
# then
runner.run_step.assert_not_called()
def test_runner_should_abort_if_step_is_still_running_after_running_it(
hook_registry, default_config, mocker):
"""The Runner should abort if a Steps State is still running after its ran"""
# given
runner = Runner(default_config, None, hook_registry)
runner.run_step = mocker.MagicMock()
runner.run_step.side_effect = [State.PASSED, State.RUNNING, State.PASSED]
scenario_mock = mocker.MagicMock(name="Scenario")
scenario_mock.background = None
first_step = mocker.MagicMock(name="First Step")
second_step = mocker.MagicMock(name="Second Step")
third_step = mocker.MagicMock(name="Third Step")
scenario_mock.steps = [first_step, second_step, third_step]
# then
with pytest.raises(RadishError):
# when
runner.run_scenario(scenario_mock)
# then
runner.run_step.assert_has_calls([call(first_step), call(second_step)])
def test_runner_should_run_steps_from_a_background(hook_registry,
default_config, mocker):
"""The Runner should run all Steps from a Background before running the Scenario steps"""
# given
default_config.dry_run_mode = True
runner = Runner(default_config, None, hook_registry)
runner.run_step = mocker.MagicMock()
runner.run_step.side_effect = [
State.PASSED,
State.PASSED,
State.PASSED,
State.PASSED,
]
scenario_mock = mocker.MagicMock(name="Scenario")
first_background_step = mocker.MagicMock(name="First Background Step")
second_background_step = mocker.MagicMock(name="Second Background Step")
scenario_mock.background.steps = [
first_background_step, second_background_step
]
scenario_mock.background.state = State.PASSED
first_step = mocker.MagicMock(name="First Step")
second_step = mocker.MagicMock(name="Second Step")
scenario_mock.steps = [first_step, second_step]
# when
runner.run_scenario(scenario_mock)
# then
runner.run_step.assert_has_calls([
call(first_background_step),
call(second_background_step),
call(first_step),
call(second_step),
])
def test_runner_should_iterate_all_scenarios_when_running_a_scenario_container(
hook_registry, default_config, mocker):
"""The Runner should iterate all Scenarios when running a Scenario Container"""
# given
runner = Runner(default_config, None, hook_registry)
runner.run_scenario = mocker.MagicMock()
scenario_container_mock = mocker.MagicMock(name="Scenario Container")
first_scenario = mocker.MagicMock(name="First Scenario")
second_scenario = mocker.MagicMock(name="Second Scenario")
scenario_container_mock.examples = [first_scenario, second_scenario]
# when
runner.run_scenario_container(scenario_container_mock)
# then
runner.run_scenario.assert_has_calls(
[call(first_scenario), call(second_scenario)])
def test_runner_should_only_run_scenario_which_need_to_be_run(
hook_registry, default_config, mocker):
"""The Runner should only run Scenarios which need to be run"""
# given
runner = Runner(default_config, None, hook_registry)
runner.run_scenario = mocker.MagicMock()
rule_mock = mocker.MagicMock(name="Rule")
first_scenario = mocker.MagicMock(name="First Scenario")
first_scenario.has_to_run.return_value = True
second_scenario = mocker.MagicMock(name="Second Scenario")
second_scenario.has_to_run.return_value = False
third_scenario = mocker.MagicMock(name="Third Scenario")
third_scenario.has_to_run.return_value = True
rule_mock.scenarios = [first_scenario, second_scenario, third_scenario]
# when
runner.run_rule(rule_mock)
# then
runner.run_scenario.assert_has_calls(
[call(first_scenario), call(third_scenario)])
def test_runner_should_not_exit_for_failed_scenario_if_early_exit_flag_is_not_set(
hook_registry, default_config, mocker):
"""The Runner should not exit for a failed Scenario if the early exit flag is not set"""
# given
runner = Runner(default_config, None, hook_registry)
runner.run_scenario = mocker.MagicMock()
runner.run_scenario.side_effect = [
State.PASSED, State.FAILED, State.PASSED
]
rule_mock = mocker.MagicMock(name="Rule")
first_scenario = mocker.MagicMock(name="First Scenario")
second_scenario = mocker.MagicMock(name="Second Scenario")
third_scenario = mocker.MagicMock(name="Third Scenario")
rule_mock.scenarios = [first_scenario, second_scenario, third_scenario]
# when
runner.run_rule(rule_mock)
# then
runner.run_scenario.assert_has_calls(
[call(first_scenario),
call(second_scenario),
call(third_scenario)])
