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 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.start([feature], None) step.state.should.be.equal(Step.State.PASSED) data.step_was_called.should.be.true
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 run_features(core): """ Run the parsed features :param Core core: the radish core object """ # FIXME: load dynamically import radish.extensions.argumentexpressions import radish.extensions.time_recorder import radish.extensions.syslog_writer import radish.extensions.console_writer import radish.extensions.endreport_writer import radish.extensions.failure_inspector import radish.extensions.failure_debugger import radish.extensions.bdd_xml_writer # set needed configuration world.config.expand = True # load user's custom python files loader = Loader(world.config.basedir) loader.load_all() # match feature file steps with user's step definitions Matcher.merge_steps(core.features, StepRegistry().steps) # run parsed features if world.config.marker == "time.time()": world.config.marker = int(time()) # scenario choice amount_of_scenarios = sum(len(f.scenarios) for f in core.features_to_run) if world.config.scenarios: world.config.scenarios = [int(s) for s in world.config.scenarios.split(",")] for s in world.config.scenarios: if s <= 0 or s > amount_of_scenarios: raise ScenarioNotFoundError(s, amount_of_scenarios) # tags if world.config.feature_tags: world.config.feature_tags = [t for t in world.config.feature_tags.split(",")] for tag in world.config.feature_tags: if not any(f for f in core.features if tag in [t.name for t in f.tags]): raise FeatureTagNotFoundError(tag) if world.config.scenario_tags: world.config.scenario_tags = [t for t in world.config.scenario_tags.split(",")] for tag in world.config.scenario_tags: if not any(s for f in core.features for s in f.scenarios if tag in [t.name for t in s.tags]): raise ScenarioTagNotFoundError(tag) runner = Runner(HookRegistry(), early_exit=world.config.early_exit) runner.start(core.features_to_run, marker=world.config.marker)
def show_features(core): """ Show the parsed features """ # FIXME: load dynamically import radish.extensions.console_writer # set needed configuration world.config.write_steps_once = True if not sys.stdout.isatty(): world.config.no_ansi = True runner = Runner(HookRegistry(), dry_run=True) runner.start(core.features_to_run, marker="show")
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_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_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_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_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_should_return_good_status_if_all_features_failed_in_wip_mode( hook_registry, default_config, mocker): """ The Runner should return a good status when finished if all features failed in WIP mode """ # given default_config.wip_mode = True runner = Runner(default_config, None, hook_registry) runner.run_feature = mocker.MagicMock() runner.run_feature.side_effect = [State.FAILED, State.FAILED] first_feature = mocker.MagicMock(name="First Feature", state=State.FAILED) second_feature = mocker.MagicMock(name="Second Feature", state=State.FAILED) # when status = runner.start([first_feature, second_feature]) # given assert status
def cli(**kwargs): """radish - The root from red to green. BDD tooling for Python. Use radish to run your Feature File. Provide the Feature Files to run in FEATURE_FILES. """ config = Config(kwargs) world.config = config # turn of ANSI colors if requested if config.no_ansi: cf.disable() logger.debug( "Loaded %d built-in extension modules: %s", len(loaded_built_in_extensions), ", ".join(str(e) for e in loaded_built_in_extensions), ) logger.debug("Feature Files: %s", ", ".join(str(p) for p in config.feature_files)) logger.debug("Basedirs: %s", ", ".join(str(d) for d in config.basedirs)) logger.debug("Loading extensions") loaded_extensions = extension_registry.load_extensions(config) logger.debug( "Loaded %d extensions: %s", len(loaded_extensions), ", ".join(type(e).__name__ for e in loaded_extensions), ) parser = FeatureFileParser() features = [] for feature_file in config.feature_files: logger.debug("Parsing Feature File %s", feature_file) try: feature_ast = parser.parse(feature_file) if feature_ast: features.append(feature_ast) except RadishError as exc: print("", flush=True) print( "An error occured while parsing the Feature File {}:".format( feature_file), flush=True, ) print(exc, flush=True) sys.exit(1) logger.debug("Loading all modules from the basedirs") loaded_modules = loader.load_modules(config.basedirs) logger.debug( "Loaded %d modules from the basedirs: %s", len(loaded_modules), ", ".join(str(m) for m in loaded_modules), ) exit_status = 0 try: runner = Runner(config, step_registry=step_registry, hook_registry=hook_registry) logger.debug( "Starting Runner WIP mode: %r, Dry-Run mode: %r", config.wip_mode, config.dry_run_mode, ) success = runner.start(features) logger.debug("Finished Runner with status %s", success) exit_status = 0 if success else 1 except RadishError as exc: print("", flush=True) print("An error occured while running the Feature Files:", flush=True) print(exc, flush=True) exit_status = 1 sys.exit(exit_status)