python/helpers/pycharm/lettuce_runner.py

# coding=utf-8
"""
BDD lettuce framework runner
TODO: Support other params (like tags) as well.
Supports only 2 params now: folder to search "features" for or file and "-s scenario_index"
"""
import argparse
import os
import _bdd_utils

__author__ = 'Ilya.Kazakevich'
from lettuce.exceptions import ReasonToFail
import lettuce
from lettuce import core


class _LettuceRunner(_bdd_utils.BddRunner):
    """
    Lettuce runner (BddRunner for lettuce)
    """

    def __init__(self, base_dir, what_to_run, scenarios):
        """

        :param scenarios scenario numbers to run
        :type scenarios list
        :param base_dir base directory to run tests in
        :type base_dir: str
        :param what_to_run folder or file to run
        :type what_to_run str

        """
        super(_LettuceRunner, self).__init__(base_dir)
        self.__runner = lettuce.Runner(what_to_run, ",".join(scenarios))

    def _get_features_to_run(self):
        super(_LettuceRunner, self)._get_features_to_run()
        features = []
        if self.__runner.single_feature:  # We need to run one and only one feature
            features = [core.Feature.from_file(self.__runner.single_feature)]
        else:
            # Find all features in dir
            for feature_file in self.__runner.loader.find_feature_files():
                feature = core.Feature.from_file(feature_file)
                assert isinstance(feature, core.Feature), feature
                # TODO: cut out due to https://github.com/gabrielfalcao/lettuce/issues/451  Fix when this issue fixed
                feature.scenarios = filter(lambda s: not s.outlines, feature.scenarios)
                if feature.scenarios:
                    features.append(feature)

        # Choose only selected scenarios
        if self.__runner.scenarios:
            for feature in features:
                filtered_feature_scenarios = []
                for index in [i - 1 for i in self.__runner.scenarios]:  # decrease index by 1
                    if index < len(feature.scenarios):
                        filtered_feature_scenarios.append(feature.scenarios[index])
                feature.scenarios = filtered_feature_scenarios
        return features

    def _run_tests(self):
        super(_LettuceRunner, self)._run_tests()
        self.__install_hooks()
        self.__runner.run()

    def __step(self, is_started, step):
        """
        Reports step start / stop
        :type step core.Step
        :param step: step
        """
        test_name = step.sentence
        if is_started:
            self._test_started(test_name, step.described_at)
        elif step.passed:
            self._test_passed(test_name)
        elif step.failed:
            reason = step.why
            assert isinstance(reason, ReasonToFail), reason
            self._test_failed(test_name, message=reason.exception, details=reason.traceback)
        elif step.has_definition:
            self._test_skipped(test_name, "In lettuce, we do know the reason", step.described_at)
        else:
            self._test_undefined(test_name, step.described_at)

    def __install_hooks(self):
        """
        Installs required hooks
        """

        # Install hooks
        lettuce.before.each_feature(
            lambda f: self._feature_or_scenario(True, f.name, f.described_at))
        lettuce.after.each_feature(
            lambda f: self._feature_or_scenario(False, f.name, f.described_at))

        lettuce.before.each_scenario(
            lambda s: self.__scenario(True, s))
        lettuce.after.each_scenario(
            lambda s: self.__scenario(False, s))

        lettuce.before.each_background(
            lambda b, *args: self._background(True, b.feature.described_at))
        lettuce.after.each_background(
            lambda b, *args: self._background(False, b.feature.described_at))

        lettuce.before.each_step(lambda s: self.__step(True, s))
        lettuce.after.each_step(lambda s: self.__step(False, s))

    def __scenario(self, is_started, scenario):
        """
        Reports scenario launched
        :type scenario core.Scenario
        :param scenario: scenario
        """
        if scenario.outlines:
            scenario.steps = []  # Clear to prevent running. TODO: Fix when this issue fixed
            scenario.background = None  # TODO: undocumented
            return
        self._feature_or_scenario(is_started, scenario.name, scenario.described_at)


if __name__ == "__main__":
    (base_dir, scenarios, what_to_run) = _bdd_utils.get_what_to_run_by_env(os.environ)
    if len(what_to_run) > 1:
        raise Exception("Lettuce can't run more than one file now")
    _bdd_utils.fix_win_drive(what_to_run[0])
    _LettuceRunner(base_dir, what_to_run[0], scenarios).run()