def test_running_a_feature(self): """ Test running a feature """ data = threading.local() data.step_was_called = False def some_step(step): data.step_was_called = True feature = Feature(1, "Feature", "Some feature", "somefile.feature", 1) scenario = Scenario(1, 1, "Scenario", "Some scenario", "somefile.feature", 2, feature) feature.scenarios.append(scenario) step = Step(1, "Some step", "somefile.feature", 3, scenario, True) step.definition_func = some_step argument_match_mock = Mock() argument_match_mock.evaluate.return_value = (tuple(), {}) step.argument_match = argument_match_mock scenario.steps.append(step) hook_mock = Mock() hook_mock.call.return_value = True runner = Runner(hook_mock) runner.run_feature(feature) 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_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_running_all(self): """ Test running a all features """ data = threading.local() data.step_was_called = False def some_step(step): data.step_was_called = True feature = Feature(1, "Feature", "Some feature", "somefile.feature", 1) scenario = Scenario(1, 1, "Scenario", "Some scenario", "somefile.feature", 2, feature) feature.scenarios.append(scenario) step = Step(1, "Some step", "somefile.feature", 3, scenario, True) step.definition_func = some_step step.arguments = tuple() step.keyword_arguments = {} scenario.steps.append(step) hook_mock = Mock() hook_mock.call.return_value = True runner = Runner(hook_mock) runner.start([feature], None) 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_start_run_without_features(hook_registry, default_config): """When starting the Runner without any Features it should pass and call the ``all`` hooks""" # given runner = Runner(default_config, None, hook_registry) # when status = runner.start([]) # then assert status hook_registry.call.assert_has_calls( [call("all", "before", False, []), call("all", "after", False, [])])
def test_skip_single_step(hookregistry, mocker): """ Test skipping a single Step """ # given runner = Runner(hookregistry) step = mocker.MagicMock() step.skip.return_value = None # when runner.skip_step(step) # then assert step.skip.call_count == 1
def test_runner_should_call_hooks_when_running_a_feature( hook_registry, default_config, mocker): """The Runner should call the ``each_feature`` hooks when running a Feature""" # given runner = Runner(default_config, None, hook_registry) feature_mock = mocker.MagicMock(name="Feature") # when runner.run_feature(feature_mock) # then hook_registry.call.assert_has_calls([ call("each_feature", "before", False, feature_mock), call("each_feature", "after", False, feature_mock), ])
def test_runner_should_call_hooks_when_running_a_step(hook_registry, default_config, mocker): """The Runner should call the ``each_step`` hooks when running a Step""" # given runner = Runner(default_config, None, hook_registry) step_mock = mocker.MagicMock(name="Step") # when runner.run_step(step_mock) # then hook_registry.call.assert_has_calls([ call("each_step", "before", False, step_mock), call("each_step", "after", False, step_mock), ])
def test_run_single_step(run_state, expected_returncode, hookregistry, mocker): """ Test running a single Step """ # given runner = Runner(hookregistry) step = mocker.MagicMock() step.run.return_value = run_state # when returncode = runner.run_step(step) # then assert returncode == expected_returncode assert step.run.call_count == 1
def test_run_single_step_show_only(hookregistry, mocker): """ Test running single step when show only mode is on """ # given runner = Runner(hookregistry, show_only=True) step = mocker.MagicMock() step.run.return_value = Step.State.FAILED # when returncode = runner.run_step(step) # then assert returncode == 0 assert step.run.call_count == 0
def test_runner_should_fail_step_when_it_cannot_be_matched( hook_registry, default_config, mocker): """The Runner should fail a Step when it cannot be matched with any Step Implementation""" runner = Runner(default_config, None, hook_registry) step_mock = mocker.MagicMock(name="Step") matcher_mock = mocker.patch("radish.runner.matcher") match_exc = RadishError("buuh!") matcher_mock.match_step.side_effect = match_exc # when runner.run_step(step_mock) # then step_mock.fail.assert_called_once_with(match_exc)
def test_runner_should_run_each_rule_in_a_feature(hook_registry, default_config, mocker): """The Runner should run each Rule from a Feature""" # given runner = Runner(default_config, None, hook_registry) feature_mock = mocker.MagicMock(name="Feature") first_rule = mocker.MagicMock(name="First Rule") second_rule = mocker.MagicMock(name="Second Rule") feature_mock.rules = [first_rule, second_rule] runner.run_rule = mocker.MagicMock() # when runner.run_feature(feature_mock) # then runner.run_rule.assert_has_calls([call(first_rule), call(second_rule)])
def test_start_run_should_iterate_all_given_features(hook_registry, default_config, mocker): """All Features given to run should be iterated""" # given runner = Runner(default_config, None, hook_registry) runner.run_feature = mocker.MagicMock() first_feature = mocker.MagicMock(name="First Feature") second_feature = mocker.MagicMock(name="Second Feature") # when runner.start([first_feature, second_feature]) # given runner.run_feature.assert_has_calls( [call(first_feature), call(second_feature)])
def test_runner_should_run_scenario_loop_and_outline_as_scenario_container( scenario_container_type, hook_registry, default_config, mocker): """The Runner should run a ScenarioLoop and ScenarioOutline as a Scenario Container""" # given runner = Runner(default_config, None, hook_registry) runner.run_scenario_container = mocker.MagicMock() rule_mock = mocker.MagicMock(name="Rule") scenario = mocker.MagicMock(name=scenario_container_type.__name__, spec=scenario_container_type) rule_mock.scenarios = [scenario] # when runner.run_rule(rule_mock) # then runner.run_scenario_container.assert_has_calls([call(scenario)])
def test_runner_should_run_step_after_being_matched_in_normal_mode( hook_registry, default_config, mocker): """ The Runner should run a Step after it's being successfully matched with a Step Implementation in the normal mode. """ # given runner = Runner(default_config, None, hook_registry) step_mock = mocker.MagicMock(name="Step") mocker.patch("radish.runner.matcher") # when runner.run_step(step_mock) # then step_mock.run.assert_called_once_with(ANY)
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_should_return_good_status_if_all_features_passed( hook_registry, default_config, mocker): """ The Runner should return a good status when finished if all features passed in normal mode """ # given runner = Runner(default_config, None, hook_registry) runner.run_feature = mocker.MagicMock() runner.run_feature.side_effect = [State.PASSED, State.PASSED] first_feature = mocker.MagicMock(name="First Feature", state=State.PASSED) second_feature = mocker.MagicMock(name="Second Feature", state=State.PASSED) # when status = runner.start([first_feature, second_feature]) # given assert status
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_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_debug_single_step(debug_state, expected_returncode, world_config, hookregistry, mocker): """ Test debugging a single Step """ # given runner = Runner(hookregistry) step = mocker.MagicMock() step.debug.return_value = debug_state # set debug mode world_config.debug_steps = True # when returncode = runner.run_step(step) # then assert returncode == expected_returncode assert step.debug.call_count == 1
def test_returncode_of_runner(self): """ Test returncode of run functions in Runner """ def some_passed_step(step): pass def some_failed_step(step): raise AttributeError( "I expect this error to test the behavior of a failed step") feature = Feature(1, "Feature", "Some feature", "somefile.feature", 1) scenario = Scenario(1, 1, "Scenario", "Some scenario", "somefile.feature", 2, feature) feature.scenarios.append(scenario) step1 = Step(1, "Some passed step", "somefile.feature", 3, scenario, True) step1.definition_func = some_passed_step argument_match_mock = Mock() argument_match_mock.evaluate.return_value = (tuple(), {}) step1.argument_match = argument_match_mock scenario.steps.append(step1) step2 = Step(2, "Some failed step", "somefile.feature", 4, scenario, True) step2.definition_func = some_failed_step argument_match_mock = Mock() argument_match_mock.evaluate.return_value = (tuple(), {}) step2.argument_match = argument_match_mock scenario.steps.append(step2) hook_mock = Mock() hook_mock.call.return_value = True runner = Runner(hook_mock) returncode = runner.run_feature(feature) returncode.should.be.equal(1) step1.state.should.be.equal(Step.State.PASSED) step2.state.should.be.equal(Step.State.FAILED) scenario.state.should.be.equal(Step.State.FAILED) feature.state.should.be.equal(Step.State.FAILED)
def test_should_exit_for_failed_feature_if_early_exit_set( hook_registry, default_config, mocker): """The Runner should exit early if a Feature failes if the early exit flag is set""" # given default_config.early_exit = True runner = Runner(default_config, None, hook_registry) runner.run_feature = mocker.MagicMock() runner.run_feature.side_effect = [State.PASSED, State.FAILED, State.PASSED] first_feature = mocker.MagicMock(name="First Feature") second_feature = mocker.MagicMock(name="Second Feature") third_feature = mocker.MagicMock(name="Third Feature") # when runner.start([first_feature, second_feature, third_feature]) # given runner.run_feature.assert_has_calls( [call(first_feature), call(second_feature)])
def test_should_only_run_feature_which_have_to_run(hook_registry, default_config, mocker): """The Runner should only run features which need to be run""" # given runner = Runner(default_config, None, hook_registry) runner.run_feature = mocker.MagicMock() first_feature = mocker.MagicMock(name="First Feature") first_feature.has_to_run.return_value = True second_feature = mocker.MagicMock(name="Second Feature") second_feature.has_to_run.return_value = False third_feature = mocker.MagicMock(name="Third Feature") third_feature.has_to_run.return_value = True # when runner.start([first_feature, second_feature, third_feature]) # given runner.run_feature.assert_has_calls( [call(first_feature), call(third_feature)])
def test_runner_should_not_run_nor_debug_step_after_being_matched_in_dry_run_mode( hook_registry, default_config, mocker): """ The Runner should not run nor debug a Step after it's being successfully matched with a Step Implementation in the dry run mode. """ # given default_config.dry_run_mode = True runner = Runner(default_config, None, hook_registry) step_mock = mocker.MagicMock(name="Step") mocker.patch("radish.runner.matcher") # when runner.run_step(step_mock) # then step_mock.run.assert_not_called() step_mock.debug.assert_not_called()
def test_runner_should_only_run_rule_which_need_to_be_run( hook_registry, default_config, mocker): """The Runner should run only the Rules which need to be run""" # given runner = Runner(default_config, None, hook_registry) runner.run_rule = mocker.MagicMock() feature_mock = mocker.MagicMock(name="Feature") first_rule = mocker.MagicMock(name="First Rule") first_rule.has_to_run.return_value = True second_rule = mocker.MagicMock(name="Second Rule") second_rule.has_to_run.return_value = False third_rule = mocker.MagicMock(name="Third Rule") third_rule.has_to_run.return_value = True feature_mock.rules = [first_rule, second_rule, third_rule] # when runner.run_feature(feature_mock) # then runner.run_rule.assert_has_calls([call(first_rule), call(third_rule)])
def test_runner_should_exit_for_failed_rule_if_early_exit_flag_is_set( hook_registry, default_config, mocker): """The Runner should exit for a failed Rule if the early exit flag is set""" # given default_config.early_exit = True runner = Runner(default_config, None, hook_registry) runner.run_rule = mocker.MagicMock() runner.run_rule.side_effect = [State.PASSED, State.FAILED, State.PASSED] feature_mock = mocker.MagicMock(name="Feature") first_rule = mocker.MagicMock(name="First Rule") second_rule = mocker.MagicMock(name="Second Rule") third_rule = mocker.MagicMock(name="Third Rule") feature_mock.rules = [first_rule, second_rule, third_rule] # when runner.run_feature(feature_mock) # then runner.run_rule.assert_has_calls([call(first_rule), call(second_rule)])
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_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)])