Do not call fixtures directly. bdd_feature_base_dir and bdd_strict_gherkin ini configs added. Pytest-bdd fixtures removed

Author: sliwinski-milosz

pytest_bdd/fixtures.py

@@ -8,8 +8,6 @@
 from . import reporting
 from . import gherkin_terminal_reporter
 
-from .fixtures import *
-
 
 def pytest_addhooks(pluginmanager):
     """Register plugin hooks."""
@@ -32,11 +30,20 @@ def trace():
 
 def pytest_addoption(parser):
     """Add pytest-bdd options."""
+    add_bdd_ini(parser)
     cucumber_json.add_options(parser)
     generation.add_options(parser)
     gherkin_terminal_reporter.add_options(parser)
 
 
+def add_bdd_ini(parser):
+    parser.addini('bdd_feature_base_dir',
+                  'Base feature directory.')
+    parser.addini('bdd_strict_gherkin',
+                  'Parse features to be strict gherkin.',
+                  type='bool', default=True)
+
+
 @pytest.mark.trylast
 def pytest_configure(config):
     """Configure all subplugins."""

pytest_bdd/plugin.py

@@ -23,7 +23,6 @@
 import six
 
 from . import exceptions
-from . import fixtures
 from .feature import (
     Feature,
     force_encode,
@@ -204,31 +203,6 @@ def _execute_scenario(feature, scenario, request, encoding):
 FakeRequest = collections.namedtuple("FakeRequest", ["module"])
 
 
-def get_fixture(caller_module, fixture, path=None):
-    """Get first conftest module from given one."""
-    def call_fixture(function):
-        args = []
-        if "request" in get_args(function):
-            args = [FakeRequest(module=caller_module)]
-        return function(*args)
-
-    if path is None:
-        if hasattr(caller_module, fixture):
-            return call_fixture(getattr(caller_module, fixture))
-        path = os.path.dirname(caller_module.__file__)
-
-    if os.path.exists(os.path.join(path, "__init__.py")):
-        file_path = os.path.join(path, "conftest.py")
-        if os.path.exists(file_path):
-            globs = {}
-            execfile(file_path, globs)
-            if fixture in globs:
-                return call_fixture(globs[fixture])
-    else:
-        return call_fixture(getattr(fixtures, fixture))
-    return get_fixture(caller_module, fixture, path=os.path.dirname(path))
-
-
 def _get_scenario_decorator(feature, feature_name, scenario, scenario_name, caller_module, caller_function, encoding):
     """Get scenario decorator."""
     g = locals()
@@ -298,9 +272,9 @@ def scenario(feature_name, scenario_name, encoding="utf-8", example_converters=N
     caller_function = caller_function or get_caller_function()
 
     # Get the feature
-    base_path = get_fixture(caller_module, "pytestbdd_feature_base_dir")
-    strict_gherkin = get_fixture(caller_module, "pytestbdd_strict_gherkin")
-    feature = Feature.get_feature(base_path, feature_name, encoding=encoding, strict_gherkin=strict_gherkin)
+    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)
 
     # Get the sc_enario
     try:
@@ -330,6 +304,20 @@ def scenario(feature_name, scenario_name, encoding="utf-8", example_converters=N
     )
 
 
+def get_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):
+    value = pytest.config.getini(key)
+    return value if value != '' else default
+
+
 def make_python_name(string):
     """Make python attribute name out of a given string."""
     string = re.sub(PYTHON_REPLACE_REGEX, "", string.replace(" ", "_"))
@@ -357,12 +345,12 @@ def scenarios(*feature_paths, **kwargs):
     """
     frame = inspect.stack()[1]
     module = inspect.getmodule(frame[0])
-    base_path = get_fixture(module, "pytestbdd_feature_base_dir")
-    strict_gherkin = get_fixture(module, "pytestbdd_strict_gherkin")
+    base_dir = get_base_dir(module)
+    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_path, path))
+            path = os.path.abspath(os.path.join(base_dir, path))
         abs_feature_paths.append(path)
     found = False
 

pytest_bdd/scenario.py

@@ -1,7 +1,6 @@
 """Configuration for pytest runner."""
 
 from pytest_bdd import given, when
-from pytest_bdd.fixtures import *
 
 pytest_plugins = "pytester"
 

tests/conftest.py

@@ -1,25 +1,60 @@
 """Test feature base dir."""
-import os.path
-
 import pytest
 
-from pytest_bdd import scenario
 
+@pytest.mark.parametrize(
+    'base_dir', [
+        '.',
+        '/does/not/exist/',
+    ]
+)
+def test_feature_path_not_found(testdir, base_dir):
+    """Test feature base dir."""
+    prepare_testdir(testdir, base_dir)
 
-@pytest.fixture(params=[
-    'When step can be the first',
-])
-def scenario_name(request):
-    return request.param
+    result = testdir.runpytest('-k', 'test_not_found')
+    result.assert_outcomes(passed=1)
 
 
-@pytest.fixture
-def pytestbdd_feature_base_dir():
-    return '/does/not/exist'
+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)
 
-def test_feature_path(request, scenario_name):
-    """Test feature base dir."""
-    with pytest.raises(IOError) as exc:
+
+def prepare_testdir(testdir, base_dir):
+    testdir.makeini("""
+            [pytest]
+            bdd_feature_base_dir={}
+        """.format(base_dir))
+
+    feature_file = testdir.mkdir('features').join('steps.feature')
+    feature_file.write("""
+    Scenario: When scenario found
+        Given found
+    """)
+
+    testdir.makepyfile("""
+    import pytest
+    from pytest_bdd import scenario
+    import os.path
+
+    @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)
+        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)
+
+    def test_ok(scenario_name):
+        # Shouldn't raise any exception
         scenario('steps.feature', scenario_name)
-    assert os.path.join('/does/not/exist/', 'steps.feature') in str(exc.value)
+    """.format(base_dir))

tests/feature/no_sctrict_gherkin_background.feature

@@ -1,58 +1,96 @@
 """Test no strict gherkin for sections."""
 
-import pytest
 
-from pytest_bdd import (
-    when,
-    scenario,
-)
+def test_background_no_strict_gherkin(testdir):
+    """Test background no strict gherkin."""
+    prepare_test_dir(testdir)
 
+    testdir.makefile('.feature', no_strict_gherkin_background="""
+    Feature: No strict Gherkin Background support
 
-@pytest.fixture
-def pytestbdd_strict_gherkin():
-    return False
+        Background:
+            When foo has a value "bar"
+            And foo is not boolean
+            And foo has not a value "baz"
 
+        Scenario: Test background
 
-def test_background_no_strict_gherkin(request):
-    """Test background no strict gherkin."""
-    @scenario(
-        "no_sctrict_gherkin_background.feature",
-        "Test background",
-    )
-    def test():
-        pass
+    """)
 
-    test(request)
+    result = testdir.runpytest('-k', 'test_background_ok')
+    result.assert_outcomes(passed=1)
 
 
-def test_scenario_no_strict_gherkin(request):
+def test_scenario_no_strict_gherkin(testdir):
     """Test scenario no strict gherkin."""
-    @scenario(
-        "no_sctrict_gherkin_scenario.feature",
-        "Test scenario",
-    )
-    def test():
-        pass
-
-    test(request)
+    prepare_test_dir(testdir)
 
+    testdir.makefile('.feature', no_strict_gherkin_scenario="""
+    Feature: No strict Gherkin Scenario support
 
-@pytest.fixture
-def foo():
-    return {}
+        Scenario: Test scenario
+            When foo has a value "bar"
+            And foo is not boolean
+            And foo has not a value "baz"
 
+    """)
 
-@when('foo has a value "bar"')
-def bar(foo):
-    foo["bar"] = "bar"
-    return foo["bar"]
+    result = testdir.runpytest('-k', 'test_scenario_ok')
+    result.assert_outcomes(passed=1)
 
 
-@when('foo is not boolean')
-def not_boolean(foo):
-    assert foo is not bool
-
-
-@when('foo has not a value "baz"')
-def has_not_baz(foo):
-    assert "baz" not in foo
+def prepare_test_dir(testdir):
+    """Test scenario no strict gherkin."""
+    testdir.makeini("""
+            [pytest]
+            bdd_strict_gherkin=false
+        """
+                    )
+
+    testdir.makepyfile(test_gherkin="""
+        import pytest
+
+        from pytest_bdd import (
+            when,
+            scenario,
+        )
+
+        def test_scenario_ok(request):
+            @scenario(
+                "no_strict_gherkin_scenario.feature",
+                "Test scenario",
+            )
+            def test():
+                pass
+
+            test(request)
+
+        def test_background_ok(request):
+            @scenario(
+                "no_strict_gherkin_background.feature",
+                "Test background",
+            )
+            def test():
+                pass
+
+            test(request)
+
+        @pytest.fixture
+        def foo():
+            return {}
+
+        @when('foo has a value "bar"')
+        def bar(foo):
+            foo["bar"] = "bar"
+            return foo["bar"]
+
+
+        @when('foo is not boolean')
+        def not_boolean(foo):
+            assert foo is not bool
+
+
+        @when('foo has not a value "baz"')
+        def has_not_baz(foo):
+            assert "baz" not in foo
+    """)

tests/feature/no_sctrict_gherkin_scenario.feature

@@ -1,6 +1,7 @@
 """Test wrong feature syntax."""
 import os.path
 import re
+import sys
 
 import mock
 
@@ -38,7 +39,7 @@ def then_nevermind():
 )
 @pytest.mark.parametrize('strict_gherkin', [True, False])
 @pytest.mark.parametrize('multiple', [True, False])
-@mock.patch('pytest_bdd.fixtures.pytestbdd_strict_gherkin', autospec=True)
+@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):
     """Test wrong feature scenarios."""
     mocked_strict_gherkin.return_value = strict_gherkin