Add --gherkin-terminal-reporter-expanded option (#222)

pauk-slon · olegpidsadnyi · commit d1eaf99270bb · 2018-04-04T15:59:29.000+02:00
diff --git a/pytest_bdd/gherkin_terminal_reporter.py b/pytest_bdd/gherkin_terminal_reporter.py
@@ -1,7 +1,11 @@
 # -*- encoding: utf-8 -*-
 
+import re
+
 from _pytest.terminal import TerminalReporter
 
+from .feature import STEP_PARAM_RE
+
 
 def add_options(parser):
     group = parser.getgroup("terminal reporting", "reporting", after="general")
@@ -14,6 +18,13 @@ def add_options(parser):
             "enable gherkin output"
         )
     )
+    group._addoption(
+        "--gherkin-terminal-reporter-expanded",
+        action="store_true",
+        dest="expand",
+        default=False,
+        help="expand scenario outlines into scenarios and fill in the step names",
+    )
 
 
 def configure(config):
@@ -89,10 +100,25 @@ def pytest_runtest_logreport(self, report):
                 self._tw.write(report.scenario['name'], **scenario_markup)
                 self._tw.write('\n')
                 for step in report.scenario['steps']:
+                    if self.config.option.expand:
+                        step_name = self._format_step_name(step['name'], **report.scenario['example_kwargs'])
+                    else:
+                        step_name = step['name']
                     self._tw.write('        {} {}\n'.format(step['keyword'],
-                                                            step['name']), **scenario_markup)
+                                                            step_name), **scenario_markup)
                 self._tw.write('    ' + word, **word_markup)
                 self._tw.write('\n\n')
             else:
                 return TerminalReporter.pytest_runtest_logreport(self, rep)
         self.stats.setdefault(cat, []).append(rep)
+
+    def _format_step_name(self, step_name, **example_kwargs):
+        while True:
+            param_match = re.search(STEP_PARAM_RE, step_name)
+            if not param_match:
+                break
+            param_token = param_match.group(0)
+            param_name = param_match.group(1)
+            param_value = example_kwargs[param_name]
+            step_name = step_name.replace(param_token, param_value)
+        return step_name
diff --git a/pytest_bdd/reporting.py b/pytest_bdd/reporting.py
@@ -6,6 +6,8 @@
 
 import time
 
+from .feature import force_unicode
+
 
 class StepReport(object):
 
@@ -60,7 +62,7 @@ def duration(self):
 
 class ScenarioReport(object):
 
-    """Scenario excecution report."""
+    """Scenario execution report."""
 
     def __init__(self, scenario, node):
         """Scenario report constructor.
@@ -81,6 +83,10 @@ def __init__(self, scenario, node):
                 self.param_index = param_values.index(node_param_values)
             elif tuple(node_param_values) in param_values:
                 self.param_index = param_values.index(tuple(node_param_values))
+        self.example_kwargs = {
+            example_param: force_unicode(node.funcargs[example_param])
+            for example_param in scenario.get_example_params()
+        }
 
     @property
     def current_step_report(self):
@@ -129,7 +135,8 @@ def serialize(self):
                     "rows": params,
                     "row_index": self.param_index,
                 }
-            ] if scenario.examples else []
+            ] if scenario.examples else [],
+            "example_kwargs": self.example_kwargs,
         }
 
     def fail(self):
diff --git a/tests/feature/gherkin_terminal_reporter.feature b/tests/feature/gherkin_terminal_reporter.feature
@@ -40,3 +40,8 @@ Feature: Gherkin terminal reporter
     Given there is gherkin scenario with broken implementation
     When tests are run with --showlocals
     Then error traceback contains local variable descriptions
+
+  Scenario: Should step parameters be replaced by their values
+    Given there is gherkin scenario outline implemented
+    When tests are run with step expanded mode
+    Then output must contain parameters values
diff --git a/tests/feature/test_gherkin_terminal_reporter.py b/tests/feature/test_gherkin_terminal_reporter.py
@@ -54,6 +54,12 @@ def test_Should_local_variables_be_displayed_when___showlocals_option_is_used():
     pass
 
 
+@scenario('gherkin_terminal_reporter.feature',
+          'Should step parameters be replaced by their values')
+def test_Should_step_parameters_be_replaced_by_their_values():
+    pass
+
+
 @pytest.fixture(params=[0, 1, 2],
                 ids=['compact mode', 'line per test', 'verbose'])
 def verbosity_mode(request):
@@ -104,6 +110,47 @@ def test_scenario_1():
     """)
 
 
+@given("there is gherkin scenario outline implemented")
+def gherkin_scenario_outline(testdir):
+    example = {
+        'start': 12,
+        'eat': 5,
+        'left': 7,
+    }
+    testdir.makefile('.feature', test="""
+    Feature: Gherkin terminal output feature
+    Scenario Outline: Scenario example 2
+        Given there are <start> cucumbers
+        When I eat <eat> cucumbers
+        Then I should have <left> cucumbers
+        
+        Examples:
+        | start | eat | left |
+        |{start}|{eat}|{left}|
+    """.format(**example))
+    testdir.makepyfile(test_gherkin="""
+        import pytest
+        from pytest_bdd import given, when, scenario, then
+
+        @given('there are <start> cucumbers')
+        def start_cucumbers(start):
+            return start
+        
+        @when('I eat <eat> cucumbers')
+        def eat_cucumbers(start_cucumbers, eat):
+            pass
+
+        @then('I should have <left> cucumbers')
+        def should_have_left_cucumbers(start_cucumbers, start, eat, left):
+            pass
+
+        @scenario('test.feature', 'Scenario example 2')
+        def test_scenario_2():
+            pass
+    """)
+    return example
+
+
 @when("tests are run")
 def tests_are_run(testdir, test_execution):
     test_execution['regular'] = testdir.runpytest()
@@ -137,6 +184,16 @@ def tests_are_run_with_very_verbose_mode(testdir, test_execution):
     test_execution['gherkin'] = testdir.runpytest('--gherkin-terminal-reporter', '-vv')
 
 
+@when("tests are run with step expanded mode")
+def tests_are_run_with_step_expanded_mode(testdir, test_execution):
+    test_execution['regular'] = testdir.runpytest('-vv')
+    test_execution['gherkin'] = testdir.runpytest(
+        '--gherkin-terminal-reporter',
+        '--gherkin-terminal-reporter-expanded',
+        '-vv',
+    )
+
+
 @then("output should contain single line feature description")
 def output_should_contain_single_line_feature_description(test_execution):
     ghe = test_execution['gherkin']
@@ -276,3 +333,14 @@ def error_traceback_contains_local_variable_descriptions(test_execution):
     assert ghe.ret
     ghe.stdout.fnmatch_lines('''request*=*<FixtureRequest for *''')
     ghe.stdout.fnmatch_lines('''local_var*=*''')
+
+
+@then("output must contain parameters values")
+def output_output_must_contain_parameters_values(test_execution, gherkin_scenario_outline):
+    ghe = test_execution['gherkin']
+    assert ghe.ret == 0
+    ghe.stdout.fnmatch_lines('*Scenario: Scenario example 2')
+    ghe.stdout.fnmatch_lines('*Given there are {start} cucumbers'.format(**gherkin_scenario_outline))
+    ghe.stdout.fnmatch_lines('*When I eat {eat} cucumbers'.format(**gherkin_scenario_outline))
+    ghe.stdout.fnmatch_lines('*Then I should have {left} cucumbers'.format(**gherkin_scenario_outline))
+    ghe.stdout.fnmatch_lines('*PASSED')
diff --git a/tests/feature/test_report.py b/tests/feature/test_report.py
@@ -109,7 +109,8 @@ def should_have_left_cucumbers(start_cucumbers, start, eat, left):
                            'name': u'some other passing step',
                            'type': 'given'}],
                 'tags': [u'scenario-passing-tag'],
-                'examples': []}
+                'examples': [],
+                'example_kwargs': {}}
 
     assert report == expected
 
@@ -135,7 +136,8 @@ def should_have_left_cucumbers(start_cucumbers, start, eat, left):
                            'name': u'a failing step',
                            'type': 'given'}],
                 'tags': [u'scenario-failing-tag'],
-                'examples': []}
+                'examples': [],
+                'example_kwargs': {}}
     assert report == expected
 
     report = result.matchreport('test_outlined[12-5.0-7]', when='call').scenario
@@ -171,6 +173,7 @@ def should_have_left_cucumbers(start_cucumbers, start, eat, left):
                               'row_index': 0,
                               'rows': [['start', 'eat', 'left'],
                                        [[12, 5.0, '7'], [5, 4.0, '1']]]}],
+                'example_kwargs': {'eat': '5.0', 'left': '7', 'start': '12'},
                 }
     assert report == expected
 
@@ -207,6 +210,7 @@ def should_have_left_cucumbers(start_cucumbers, start, eat, left):
                               'row_index': 1,
                               'rows': [['start', 'eat', 'left'],
                                        [[12, 5.0, '7'], [5, 4.0, '1']]]}],
+                'example_kwargs': {'eat': '4.0', 'left': '1', 'start': '5'},
                 }
     assert report == expected
 
