Merge branch 'master' into master

Author: guillego

CHANGES.rst

@@ -1,6 +1,18 @@
 Changelog
 =========
 
+Unreleased
+----------
+
+This release introduces breaking changes in order to be more in line with the official gherkin specification.
+
+- Cleanup of the documentation and tests related to parametrization (elchupanebrej)
+- Removed feature level examples for the gherkin compatibility (olegpidsadnyi)
+- Removed vertical examples for the gherkin compatibility (olegpidsadnyi)
+- Step arguments are no longer fixtures (olegpidsadnyi)
+
+
+
 5.0.0
 -----
 This release introduces breaking changes, please refer to the :ref:`Migration from 4.x.x`.

README.rst

@@ -210,9 +210,9 @@ for `cfparse` parser
     @given(
         parsers.cfparse("there are {start:Number} cucumbers",
         extra_types=dict(Number=int)),
-        target_fixture="start_cucumbers",
+        target_fixture="cucumbers",
     )
-    def start_cucumbers(start):
+    def given_cucumbers(start):
         return dict(start=start, eat=0)
 
 for `re` parser
@@ -224,9 +224,9 @@ for `re` parser
     @given(
         parsers.re(r"there are (?P<start>\d+) cucumbers"),
         converters=dict(start=int),
-        target_fixture="start_cucumbers",
+        target_fixture="cucumbers",
     )
-    def start_cucumbers(start):
+    def given_cucumbers(start):
         return dict(start=start, eat=0)
 
 
@@ -257,20 +257,19 @@ The code will look like:
         pass
 
 
-    @given(parsers.parse("there are {start:d} cucumbers"), target_fixture="start_cucumbers")
-    def start_cucumbers(start):
+    @given(parsers.parse("there are {start:d} cucumbers"), target_fixture="cucumbers")
+    def given_cucumbers(start):
         return dict(start=start, eat=0)
 
 
     @when(parsers.parse("I eat {eat:d} cucumbers"))
-    def eat_cucumbers(start_cucumbers, eat):
+    def eat_cucumbers(cucumbers, eat):
         start_cucumbers["eat"] += eat
 
 
     @then(parsers.parse("I should have {left:d} cucumbers"))
-    def should_have_left_cucumbers(start_cucumbers, start, left):
-        assert start_cucumbers['start'] == start
-        assert start - start_cucumbers['eat'] == left
+    def should_have_left_cucumbers(cucumbers, left):
+        assert cucumbers['start'] - cucumbers['eat'] == left
 
 Example code also shows possibility to pass argument converters which may be useful if you need to postprocess step
 arguments after the parser.
@@ -303,21 +302,11 @@ You can implement your own step parser. It's interface is quite simple. The code
             return bool(self.regex.match(name))
 
 
-    @given(parsers.parse("there are %start% cucumbers"), target_fixture="start_cucumbers")
-    def start_cucumbers(start):
+    @given(parsers.parse("there are %start% cucumbers"), target_fixture="cucumbers")
+    def given_cucumbers(start):
         return dict(start=start, eat=0)
 
 
-Step arguments are fixtures as well!
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Step arguments are injected into pytest `request` context as normal fixtures with the names equal to the names of the
-arguments. This opens a number of possibilities:
-
-* you can access step's argument as a fixture in other step function just by mentioning it as an argument (just like any other pytest fixture)
-* if the name of the step argument clashes with existing fixture, it will be overridden by step's argument value; this way you can set/override the value for some fixture deeply inside of the fixture tree in a ad-hoc way by just choosing the proper name for the step argument.
-
-
 Override fixtures via given steps
 ---------------------------------
 
@@ -506,7 +495,7 @@ Scenario outlines
 Scenarios can be parametrized to cover few cases. In Gherkin the variable
 templates are written using corner braces as ``<somevalue>``.
 `Gherkin scenario outlines <http://behat.org/en/v3.0/user_guide/writing_scenarios.html#scenario-outlines>`_ are supported by pytest-bdd
-exactly as it's described in be behave_ docs.
+exactly as it's described in the behave_ docs.
 
 Example:
 
@@ -522,121 +511,6 @@ Example:
             | start | eat | left |
             |  12   |  5  |  7   |
 
-pytest-bdd feature file format also supports example tables in different way:
-
-
-.. code-block:: gherkin
-
-    Feature: Scenario outlines
-        Scenario Outline: Outlined given, when, then
-            Given there are <start> cucumbers
-            When I eat <eat> cucumbers
-            Then I should have <left> cucumbers
-
-            Examples: Vertical
-            | start | 12 | 2 |
-            | eat   | 5  | 1 |
-            | left  | 7  | 1 |
-
-This form allows to have tables with lots of columns keeping the maximum text width predictable without significant
-readability change.
-
-The code will look like:
-
-.. code-block:: python
-
-    from pytest_bdd import given, when, then, scenario, parsers
-
-
-    @scenario(
-        "outline.feature",
-        "Outlined given, when, then",
-    )
-    def test_outlined():
-        pass
-
-
-    @given(parsers.parse("there are {start:d} cucumbers", target_fixture="start_cucumbers"))
-    def start_cucumbers(start):
-        assert isinstance(start, int)
-        return dict(start=start)
-
-
-    @when(parsers.parse("I eat {eat:g} cucumbers"))
-    def eat_cucumbers(start_cucumbers, eat):
-        assert isinstance(eat, float)
-        start_cucumbers["eat"] = eat
-
-
-    @then(parsers.parse("I should have {left} cucumbers"))
-    def should_have_left_cucumbers(start_cucumbers, start, eat, left):
-        assert isinstance(left, str)
-        assert start - eat == int(left)
-        assert start_cucumbers["start"] == start
-        assert start_cucumbers["eat"] == eat
-
-Example code also shows possibility to pass example converters which may be useful if you need parameter types
-different than strings.
-
-
-Feature examples
-^^^^^^^^^^^^^^^^
-
-It's possible to declare example table once for the whole feature, and it will be shared
-among all the scenarios of that feature:
-
-.. code-block:: gherkin
-
-    Feature: Outline
-
-        Examples:
-        | start | eat | left |
-        |  12   |  5  |  7   |
-        |  5    |  4  |  1   |
-
-        Scenario Outline: Eat cucumbers
-            Given there are <start> cucumbers
-            When I eat <eat> cucumbers
-            Then I should have <left> cucumbers
-
-        Scenario Outline: Eat apples
-            Given there are <start> apples
-            When I eat <eat> apples
-            Then I should have <left> apples
-
-For some more complex case, you might want to parametrize on both levels: feature and scenario.
-This is allowed as long as parameter names do not clash:
-
-
-.. code-block:: gherkin
-
-    Feature: Outline
-
-        Examples:
-        | start | eat | left |
-        |  12   |  5  |  7   |
-        |  5    |  4  |  1   |
-
-        Scenario Outline: Eat fruits
-            Given there are <start> <fruits>
-            When I eat <eat> <fruits>
-            Then I should have <left> <fruits>
-
-            Examples:
-            | fruits  |
-            | oranges |
-            | apples  |
-
-        Scenario Outline: Eat vegetables
-            Given there are <start> <vegetables>
-            When I eat <eat> <vegetables>
-            Then I should have <left> <vegetables>
-
-            Examples:
-            | vegetables |
-            | carrots    |
-            | tomatoes   |
-
 
 Organizing your scenarios
 -------------------------
@@ -1114,6 +988,36 @@ As as side effect, the tool will validate the files for format errors, also some
 ordering of the types of the steps.
 
 
+.. _Migration from 5.x.x:
+
+Migration of your tests from versions 5.x.x
+-------------------------------------------
+
+The primary focus of the pytest-bdd is the compatibility with the latest gherkin developments
+e.g. multiple scenario outline example tables with tags support etc.
+
+In order to provide the best compatibility it is best to support the features described in the official
+gherkin reference. This means deprecation of some non-standard features that were implemented in pytest-bdd.
+
+
+Removal of the feature examples
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+The example tables on the feature level are no longer supported. The tests should be parametrized with the example tables
+on the scenario level.
+
+
+Removal of the vertical examples
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Vertical example tables are no longer supported since the official gherkin doesn't support them.
+The example tables should have horizontal orientation.
+
+
+Step arguments are no longer fixtures
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+Step parsed arguments conflicted with the fixtures. Now they no longer define fixture.
+If the fixture has to be defined by the step the target_fixture param should be used.
+
+
 .. _Migration from 4.x.x:
 
 Migration of your tests from versions 4.x.x

pytest_bdd/__init__.py

@@ -3,6 +3,6 @@
 from pytest_bdd.scenario import scenario, scenarios
 from pytest_bdd.steps import given, then, when
 
-__version__ = "5.0.0"
+__version__ = "6.0.0"
 
 __all__ = [given.__name__, when.__name__, then.__name__, scenario.__name__, scenarios.__name__]

pytest_bdd/parser.py

@@ -12,7 +12,6 @@
 STEP_PREFIXES = [
     ("Feature: ", types.FEATURE),
     ("Scenario Outline: ", types.SCENARIO_OUTLINE),
-    ("Examples: Vertical", types.EXAMPLES_VERTICAL),
     ("Examples:", types.EXAMPLES),
     ("Scenario: ", types.SCENARIO),
     ("Background:", types.BACKGROUND),
@@ -90,7 +89,6 @@ def parse_feature(basedir: str, filename: str, encoding: str = "utf-8") -> "Feat
         line_number=1,
         name=None,
         tags=set(),
-        examples=Examples(),
         background=None,
         description="",
     )
@@ -157,34 +155,12 @@ def parse_feature(basedir: str, filename: str, encoding: str = "utf-8") -> "Feat
             feature.background = Background(feature=feature, line_number=line_number)
         elif mode == types.EXAMPLES:
             mode = types.EXAMPLES_HEADERS
-            (scenario or feature).examples.line_number = line_number
-        elif mode == types.EXAMPLES_VERTICAL:
-            mode = types.EXAMPLE_LINE_VERTICAL
-            (scenario or feature).examples.line_number = line_number
+            scenario.examples.line_number = line_number
         elif mode == types.EXAMPLES_HEADERS:
-            (scenario or feature).examples.set_param_names([l for l in split_line(parsed_line) if l])
+            scenario.examples.set_param_names([l for l in split_line(parsed_line) if l])
             mode = types.EXAMPLE_LINE
         elif mode == types.EXAMPLE_LINE:
-            (scenario or feature).examples.add_example([l for l in split_line(stripped_line)])
-        elif mode == types.EXAMPLE_LINE_VERTICAL:
-            param_line_parts = [l for l in split_line(stripped_line)]
-            try:
-                (scenario or feature).examples.add_example_row(param_line_parts[0], param_line_parts[1:])
-            except exceptions.ExamplesNotValidError as exc:
-                if scenario:
-                    raise exceptions.FeatureError(
-                        f"Scenario has not valid examples. {exc.args[0]}",
-                        line_number,
-                        clean_line,
-                        filename,
-                    )
-                else:
-                    raise exceptions.FeatureError(
-                        f"Feature has not valid examples. {exc.args[0]}",
-                        line_number,
-                        clean_line,
-                        filename,
-                    )
+            scenario.examples.add_example([l for l in split_line(stripped_line)])
         elif mode and mode not in (types.FEATURE, types.TAG):
             step = Step(name=parsed_line, type=mode, indent=line_indent, line_number=line_number, keyword=keyword)
             if feature.background and not scenario:
@@ -201,12 +177,11 @@ def parse_feature(basedir: str, filename: str, encoding: str = "utf-8") -> "Feat
 class Feature:
     """Feature."""
 
-    def __init__(self, scenarios, filename, rel_filename, name, tags, examples, background, line_number, description):
+    def __init__(self, scenarios, filename, rel_filename, name, tags, background, line_number, description):
         self.scenarios: typing.Dict[str, ScenarioTemplate] = scenarios
         self.rel_filename = rel_filename
         self.filename = filename
         self.tags = tags
-        self.examples = examples
         self.name = name
         self.line_number = line_number
         self.description = description
@@ -264,7 +239,7 @@ def validate(self):
         :raises ScenarioValidationError: when scenario is not valid
         """
         params = frozenset(sum((list(step.params) for step in self.steps), []))
-        example_params = set(self.examples.example_params + self.feature.examples.example_params)
+        example_params = set(self.examples.example_params)
         if params and example_params and params != example_params:
             raise exceptions.ScenarioExamplesNotValidError(
                 """Scenario "{}" in the feature "{}" has not valid examples. """
@@ -392,7 +367,6 @@ def __init__(self):
         """Initialize examples instance."""
         self.example_params = []
         self.examples = []
-        self.vertical_examples = []
         self.line_number = None
         self.name = None
 
@@ -421,30 +395,20 @@ def add_example_row(self, param, values):
                 f"""Example rows should contain unique parameters. "{param}" appeared more than once"""
             )
         self.example_params.append(param)
-        self.vertical_examples.append(values)
 
     def as_contexts(self) -> typing.Iterable[typing.Dict[str, typing.Any]]:
-        param_count = len(self.example_params)
-        if self.vertical_examples and not self.examples:
-            for value_index in range(len(self.vertical_examples[0])):
-                example = []
-                for param_index in range(param_count):
-                    example.append(self.vertical_examples[param_index][value_index])
-                self.examples.append(example)
-
         if not self.examples:
             return
 
         header, rows = self.example_params, self.examples
 
         for row in rows:
             assert len(header) == len(row)
-
             yield dict(zip(header, row))
 
     def __bool__(self):
         """Bool comparison."""
-        return bool(self.vertical_examples or self.examples)
+        return bool(self.examples)
 
 
 def get_tags(line):