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)])