Add feature_base_dir and strict_gherkin params to scenario and scenarios

Author: sliwinski-milosz

pytest_bdd/scenario.py

@@ -263,7 +263,7 @@ def decorator(_pytestbdd_function):
 
 
 def scenario(feature_name, scenario_name, encoding="utf-8", example_converters=None,
-             caller_module=None, caller_function=None):
+             caller_module=None, caller_function=None, feature_base_dir=None, strict_gherkin=None):
     """Scenario decorator.
 
     :param str feature_name: Feature file name. Absolute or relative to the configured feature base path.
@@ -277,9 +277,11 @@ def scenario(feature_name, scenario_name, encoding="utf-8", example_converters=N
     caller_function = caller_function or get_caller_function()
 
     # Get the feature
-    base_dir = get_base_dir(caller_module)
-    strict_gherkin = get_strict_gherkin()
-    feature = Feature.get_feature(base_dir, feature_name, encoding=encoding, strict_gherkin=strict_gherkin)
+    if feature_base_dir is None:
+        feature_base_dir = get_feature_base_dir(caller_module)
+    if strict_gherkin is None:
+        strict_gherkin = get_strict_gherkin()
+    feature = Feature.get_feature(feature_base_dir, feature_name, encoding=encoding, strict_gherkin=strict_gherkin)
 
     # Get the sc_enario
     try:
@@ -309,20 +311,24 @@ def scenario(feature_name, scenario_name, encoding="utf-8", example_converters=N
     )
 
 
-def get_base_dir(caller_module):
+def get_feature_base_dir(caller_module):
     default_base_dir = os.path.dirname(caller_module.__file__)
     return get_from_ini('bdd_feature_base_dir', default_base_dir)
 
 
-def get_strict_gherkin():
-    return get_from_ini('bdd_strict_gherkin', True)
-
-
 def get_from_ini(key, default):
+    """Get value from ini config. Return default if value has not been set.
+
+    Use if the default value is dynamic. Otherwise set default on addini call.
+    """
     value = pytest.config.getini(key)
     return value if value != '' else default
 
 
+def get_strict_gherkin():
+    return pytest.config.getini('bdd_strict_gherkin')
+
+
 def make_python_name(string):
     """Make python attribute name out of a given string."""
     string = re.sub(PYTHON_REPLACE_REGEX, "", string.replace(" ", "_"))
@@ -350,12 +356,19 @@ def scenarios(*feature_paths, **kwargs):
     """
     frame = inspect.stack()[1]
     module = inspect.getmodule(frame[0])
-    base_dir = get_base_dir(module)
-    strict_gherkin = get_strict_gherkin()
+
+    feature_base_dir = kwargs.get('feature_base_dir')
+    if feature_base_dir is None:
+        feature_base_dir = get_feature_base_dir(module)
+
+    strict_gherkin = kwargs.get('strict_gherkin')
+    if strict_gherkin is None:
+        strict_gherkin = get_strict_gherkin()
+
     abs_feature_paths = []
     for path in feature_paths:
         if not os.path.isabs(path):
-            path = os.path.abspath(os.path.join(base_dir, path))
+            path = os.path.abspath(os.path.join(feature_base_dir, path))
         abs_feature_paths.append(path)
     found = False
 

tests/feature/test_feature_base_dir.py

@@ -1,34 +1,58 @@
 """Test feature base dir."""
 import pytest
 
+NOT_EXISTING_FEATURE_PATHS = [
+    '.',
+    '/does/not/exist/',
+]
+
 
 @pytest.mark.parametrize(
-    'base_dir', [
-        '.',
-        '/does/not/exist/',
-    ]
+    'base_dir', NOT_EXISTING_FEATURE_PATHS
 )
 def test_feature_path_not_found(testdir, base_dir):
     """Test feature base dir."""
     prepare_testdir(testdir, base_dir)
 
-    result = testdir.runpytest('-k', 'test_not_found')
-    result.assert_outcomes(passed=1)
+    result = testdir.runpytest('-k', 'test_not_found_by_ini')
+    result.assert_outcomes(passed=2)
 
 
 def test_feature_path_ok(testdir):
     base_dir = 'features'
     prepare_testdir(testdir, base_dir)
 
-    result = testdir.runpytest('-k', 'test_ok')
-    result.assert_outcomes(passed=1)
+    result = testdir.runpytest('-k', 'test_ok_by_ini')
+    result.assert_outcomes(passed=2)
+
 
+def test_feature_path_by_param_not_found(testdir):
+    """As param takes precendence even if ini config is correct it should fail
+    if passed param is incorrect"""
+    base_dir = 'features'
+    prepare_testdir(testdir, base_dir)
 
-def prepare_testdir(testdir, base_dir):
+    result = testdir.runpytest('-k', 'test_not_found_by_param')
+    result.assert_outcomes(passed=4)
+
+
+@pytest.mark.parametrize(
+    'base_dir', NOT_EXISTING_FEATURE_PATHS
+)
+def test_feature_path_by_param_ok(testdir, base_dir):
+    """If ini config is incorrect but param path is fine it should be able
+    to find features"""
+    prepare_testdir(testdir, base_dir)
+
+    result = testdir.runpytest('-k', 'test_ok_by_param')
+    result.assert_outcomes(passed=2)
+
+
+def prepare_testdir(testdir, ini_base_dir):
     testdir.makeini("""
             [pytest]
             bdd_feature_base_dir={}
-        """.format(base_dir))
+        """.format(ini_base_dir))
 
     feature_file = testdir.mkdir('features').join('steps.feature')
     feature_file.write("""
@@ -37,24 +61,71 @@ def prepare_testdir(testdir, base_dir):
     """)
 
     testdir.makepyfile("""
-    import pytest
-    from pytest_bdd import scenario
     import os.path
 
+    import pytest
+
+    from pytest_bdd import scenario, scenarios
+
+    FEATURE = 'steps.feature'
+
+
     @pytest.fixture(params=[
         'When scenario found',
     ])
     def scenario_name(request):
         return request.param
 
-    def test_not_found(scenario_name):
-        base_dir = '{}'
-        print("BS: %s" % base_dir)
+
+    @pytest.mark.parametrize(
+        'multiple', [True, False]
+    )
+    def test_not_found_by_ini(scenario_name, multiple):
         with pytest.raises(IOError) as exc:
-            scenario('steps.feature', scenario_name)
-        assert os.path.abspath(os.path.join(base_dir, 'steps.feature')) in str(exc.value)
+            if multiple:
+                scenarios(FEATURE)
+            else:
+                scenario(FEATURE, scenario_name)
+        assert os.path.abspath(os.path.join('{}', FEATURE)) in str(exc.value)
+
 
-    def test_ok(scenario_name):
+    @pytest.mark.parametrize(
+        'multiple', [True, False]
+    )
+    def test_ok_by_ini(scenario_name, multiple):
         # Shouldn't raise any exception
-        scenario('steps.feature', scenario_name)
-    """.format(base_dir))
+        if multiple:
+            scenarios(FEATURE)
+        else:
+            scenario(FEATURE, scenario_name)
+
+
+    @pytest.mark.parametrize(
+        'multiple', [True, False]
+    )
+    @pytest.mark.parametrize(
+        'param_base_dir', [
+            '.',
+            '/does/not/exist/',
+        ]
+    )
+    def test_not_found_by_param(scenario_name, param_base_dir, multiple):
+        with pytest.raises(IOError) as exc:
+            if multiple:
+                scenarios(FEATURE, feature_base_dir=param_base_dir)
+            else:
+                scenario(FEATURE, scenario_name, feature_base_dir=param_base_dir)
+        assert os.path.abspath(os.path.join(param_base_dir, FEATURE)) in str(exc.value)
+
+
+    @pytest.mark.parametrize(
+        'multiple', [True, False]
+    )
+    def test_ok_by_param(scenario_name, multiple):
+        # Shouldn't raise any exception no matter of bdd_feature_base_dir in ini
+        if multiple:
+            scenarios(FEATURE, feature_base_dir='features')
+        else:
+            scenario(FEATURE, scenario_name, feature_base_dir='features')
+
+    """.format(ini_base_dir))

tests/feature/test_wrong.py

@@ -39,16 +39,13 @@ def then_nevermind():
 )
 @pytest.mark.parametrize('strict_gherkin', [True, False])
 @pytest.mark.parametrize('multiple', [True, False])
-@mock.patch.object(sys.modules['pytest_bdd.scenario'], 'get_strict_gherkin', return_value=True)
-def test_wrong(mocked_strict_gherkin, request, feature, scenario_name, strict_gherkin, multiple):
+def test_wrong(request, feature, scenario_name, strict_gherkin, multiple):
     """Test wrong feature scenarios."""
-    mocked_strict_gherkin.return_value = strict_gherkin
-
     def declare_scenario():
         if multiple:
-            scenarios(feature)
+            scenarios(feature, strict_gherkin=strict_gherkin)
         else:
-            @scenario(feature, scenario_name)
+            @scenario(feature, scenario_name, strict_gherkin=strict_gherkin)
             def test_scenario():
                 pass