Always load steps from all the features directories

koterpillar · koterpillar · commit b00183d5409a · 2015-09-06T20:43:30.000+10:00
diff --git a/README.md b/README.md
@@ -86,6 +86,10 @@ outlines, doc strings, data tables and internationalization.
 
 Feature and scenario tags can be used, but aren't currently doing anything.
 
+If `aloe` is run without specifying the features, every file with the extension
+of `.feature` in a directory called `features` (and its subdirectories) will be
+run.
+
 Steps
 =====
 
@@ -113,21 +117,8 @@ clean-up must be done by the callbacks.
 ### Step loading
 
 Steps can and should be defined in separate modules to the main application
-code. Aloe searches for modules upwards from the directory of the feature, for
-example, given a feature of `features/calculator/basic/addition.feature`, the
-following directories will be searched for modules to import:
-
-* `features/calculator/basic`
-* `features/calculator`
-* `features`
-
-and so on (the search does not stop at the current directory).
-
-The first directory containing any Python modules stops the search, all the
-modules from it are imported and then the feature is run.
-
-If multiple features are given, steps are searched relative to all of them, but
-any given module is only imported once.
+code. Aloe searches for modules to load steps from inside the `features`
+directories found.
 
 ### Step objects
 
diff --git a/aloe/fs.py b/aloe/fs.py
@@ -30,51 +30,27 @@
 import sys
 import fnmatch
 
-from glob import glob
 from importlib import import_module
 try:
     reload
 except NameError:
     # pylint:disable=no-name-in-module,redefined-builtin
     from importlib import reload
     # pylint:enable=no-name-in-module,redefined-builtin
-from os import walk
-from os.path import abspath, join, dirname
+from os.path import join, dirname
 
 
 class FeatureLoader(object):
     """Loader class responsible for findind features and step
     definitions along a given path on filesystem"""
 
-    @classmethod
-    def find_steps_dir(cls, feature_file):
-        """
-        Find the steps directory corresponding to the feature file.
-
-        This is the first directory upwards of the feature file
-        containing any Python files.
-
-        If no steps directory can be found, return the filesystem root.
-        """
-
-        base_dir = dirname(abspath(feature_file))
-
-        while base_dir != '/':
-            files = cls.locate(base_dir, '*.py')
-            if files:
-                break
-            base_dir = abspath(join(base_dir, '..'))
-
-        return base_dir
-
     @classmethod
     def find_and_load_step_definitions(cls, steps_dir):
         """
         Load the steps from the specified directory.
         """
-        files = cls.locate(steps_dir, '*.py')
 
-        for filename in files:
+        for filename in cls.locate(steps_dir, '*.py'):
             root = dirname(filename)
             sys.path.insert(0, root)
             to_load = cls.filename(filename)
@@ -83,16 +59,11 @@ def find_and_load_step_definitions(cls, steps_dir):
             sys.path.remove(root)
 
     @staticmethod
-    def locate(root_path, match, recursive=True):
-        """Locate files recursively in a given path"""
-        if recursive:
-            return_files = []
-            for path, _, files in walk(root_path):
-                for filename in fnmatch.filter(files, match):
-                    return_files.append(join(path, filename))
-            return return_files
-        else:
-            return glob(join(root_path, match))
+    def locate(root_path, match):
+        """Locate files/directories recursively in a given path"""
+        for path, dirs, files in os.walk(root_path):
+            for filename in fnmatch.filter(dirs + files, match):
+                yield join(path, filename)
 
     @classmethod
     def filename(cls, path):
diff --git a/aloe/plugin.py b/aloe/plugin.py
@@ -50,11 +50,15 @@ class GherkinPlugin(Plugin):
 
     def begin(self):
         """
-        Start the test suite, resetting internal state.
+        Start the test suite, loading all the step definitions.
         """
 
-        self.steps_loaded = []
-        self.first_test = True
+        self.feature_dirs = [
+            os.path.abspath(dir_)
+            for dir_ in FeatureLoader.locate('.', 'features')
+        ]
+        for feature_dir in self.feature_dirs:
+            FeatureLoader.find_and_load_step_definitions(feature_dir)
 
     def options(self, parser, env=None):
         """
@@ -115,10 +119,10 @@ def wantDirectory(self, directory):
         """
 
         directory = os.path.abspath(directory)
-        while directory != '/':
-            if os.path.basename(directory) == 'features':
-                return True
-            directory = os.path.dirname(directory)
+        if any(feature_dir.startswith(directory) or
+               directory.startswith(feature_dir)
+               for feature_dir in self.feature_dirs):
+            return True
 
     def wantFile(self, file_):
         """
@@ -143,14 +147,9 @@ def loadTestsFromFile(self, file_):
         Load a feature from the feature file.
         """
 
-        # Ensure the steps corresponding to the feature file are loaded
-        steps_dir = FeatureLoader.find_steps_dir(file_)
-        if steps_dir not in self.steps_loaded:
-            FeatureLoader.find_and_load_step_definitions(steps_dir)
-            self.steps_loaded.append(steps_dir)
-
         test = self.test_class.from_file(file_)
 
+        # About to run a feature - ensure "before all" callbacks have run
         self.ensure_before_callbacks()
 
         # Filter the scenarios, if asked
@@ -164,13 +163,11 @@ def ensure_before_callbacks(self):
         Before the first test, run the "before all" callbacks.
         """
 
-        if self.first_test:
+        if not hasattr(self, 'after_hook'):
             before_all, after_all = CALLBACK_REGISTRY.before_after('all')
             before_all()
             self.after_hook = after_all
 
-            self.first_test = False
-
     def finalize(self, result):
         """
         After the last test, run the "after all" callbacks.
diff --git a/tests/functional/test_callbacks.py b/tests/functional/test_callbacks.py
@@ -215,26 +215,27 @@ def test_step_failed(self):
 
 
 @in_directory('tests/multiple_steps_app')
-class MultipleAppsCallbackTest(FeatureTest):
+class MultipleDirectoriesCallbackTest(FeatureTest):
     """
-    Test before.all callbacks when running multiple apps.
+    Test before.all callbacks when running features from multiple directories.
     """
 
     def test_single_app(self):
         """
-        Test what is loaded and called when only running a single app.
+        Test all the callbacks are called when running a single feature.
         """
 
         self.assert_feature_success('one/features/check_started.feature')
 
         self.assertEquals(world.started_callbacks_one, {
             'one': True,
-            'two': None,
+            'two': True,
         })
 
     def test_multiple_apps(self):
         """
-        Test what is loaded and called when running multiple apps.
+        Test what is loaded and called when running features from multiple
+        directories.
         """
 
         self.assert_feature_success()
diff --git a/tests/multiple_steps_app/one/features/steps.py b/tests/multiple_steps_app/one/features/steps.py
diff --git a/tests/multiple_steps_app/two/features/steps.py b/tests/multiple_steps_app/two/features/steps.py
diff --git a/tests/unit/features/steps.py b/tests/unit/features/steps.py
@@ -0,0 +1,35 @@
+# Aloe - Cucumber runner for Python based on Lettuce and Nose
+# Copyright (C) <2015> Alexey Kotlyarov <a@koterpillar.com>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+from __future__ import unicode_literals
+from __future__ import print_function
+from __future__ import division
+from __future__ import absolute_import
+from future import standard_library
+standard_library.install_aliases()
+from aloe import step
+
+
+@step(r'I do nothing')
+def trivial_step(self):  # pylint:disable=unused-argument
+    """Trivial passing step."""
+    pass
+
+
+@step(r'I fail')
+def failing_step(self):  # pylint:disable=unused-argument
+    """Trivial failing step."""
+    raise AssertionError("This step is meant to fail.")
diff --git a/tests/unit/test_testing.py b/tests/unit/test_testing.py
@@ -28,25 +28,12 @@
 import os
 import unittest
 
-from aloe import step
 from aloe.testing import (
     FeatureTest,
     in_directory,
 )
 
 
-@step(r'I do nothing')
-def trivial_step(self):  # pylint:disable=unused-argument
-    """Trivial passing step."""
-    pass
-
-
-@step(r'I fail')
-def failing_step(self):  # pylint:disable=unused-argument
-    """Trivial failing step."""
-    raise AssertionError("This step is meant to fail.")
-
-
 @in_directory('tests/unit')
 class FeatureTestTest(FeatureTest):
     """
