Merge lp:~vila/selenium-simple-test/test-loader into lp:selenium-simple-test

[Vincent Ladeuil]

Simplify test loader implementation.

This simplify the new loader implementation, splitting between the part that may be upstreamed and the sst specific parts.

All existing tests have been migrated and some more added.

[Leo Arias (elopio)]

I can't find any errors. But this is huge, I've asked for another pair of eyes to double check :)

review: Approve (code review)

[Corey Goldberg (coreygoldberg)]

lgtm too

review: Approve

=== modified file 'src/sst/filters.py'
--- src/sst/filters.py	2013-05-23 10:41:04 +0000
+++ src/sst/filters.py	2013-06-05 15:07:32 +0000
@@ -46,7 +46,7 @@
     return filtered_suite
 
 
-def filter_by_regexps(regexps, suite):
+def include_regexps(regexps, suite):
     """Returns the tests that match one of ``regexps``.
 
     :param regexps: A list of test id regexps (strings, will be compiled
@@ -58,13 +58,13 @@
     if not regexps:
         return suite
 
-    def filter_test_regexps(test):
+    def matches_one_of(test):
         tid = test.id()
         for reg in regexps:
             if re.search(reg, tid) is not None:
                 return True
         return False
-    return filter_suite(filter_test_regexps, suite)
+    return filter_suite(matches_one_of, suite)
 
 
 def exclude_regexps(regexps, suite):

=== modified file 'src/sst/loader.py'
--- src/sst/loader.py	2013-05-31 11:17:32 +0000
+++ src/sst/loader.py	2013-06-05 15:07:32 +0000
@@ -28,273 +28,71 @@
 from sst import cases
 
 
-def matches_for_regexp(regexp):
-    match_re = re.compile(regexp)
-
-    def matches(path):
-        return bool(match_re.match(path))
-    return matches
-
-
-def matches_for_glob(pattern):
-    match_re = fnmatch.translate(pattern)
-    return matches_for_regexp(match_re)
-
-
 class NameMatcher(object):
+    """Defines rules to select names.
+
+    The rules are defined by two lists of regular expressions:
+    - includes: matching succeeds if one of the regular expression match.
+    - excludes: matching fails if one of the regular expression match.
+
+    Matching fails if no rules are given.
+    """
 
     def __init__(self, includes=None, excludes=None):
+        self.includes = []
         if includes is not None:
-            self.includes = includes
+            for inc in includes:
+                self.includes.append(re.compile(inc))
+        self.excludes = []
         if excludes is not None:
-            self.excludes = excludes
-
-    def includes(self, path):
-        return True
-
-    def excludes(self, path):
+            for exc in excludes:
+                self.excludes.append(re.compile(exc))
+
+    def matches(self, name):
+        for exc in self.excludes:
+            if exc.search(name):
+                return False
+        for inc in self.includes:
+            if inc.search(name):
+                return True
+        # Not explicitely included
         return False
 
-    def matches(self, name):
-        return self.includes(name) and not self.excludes(name)
-
-
-class FileLoader(object):
-    """Load tests from a file.
-
-    This is an abstract class allowing daughter classes to enforce constraints
-    including the ability to load tests from files that cannot be imported.
-    """
-
-    def __init__(self, test_loader, matcher=None):
-        """Load tests from a file."""
-        super(FileLoader, self).__init__()
-        if matcher is None:
-            self.matches = lambda name: True
-        else:
-            self.matches = matcher.matches
-        self.test_loader = test_loader
-
-    def discover(self, directory, name):
-        """Return None to represent an empty test suite.
-
-        This is mostly for documentation purposes, if a file contains material
-        that can produce tests, a specific file loader should be defined to
-        build tests from the file content.
-        """
-        return None
-
-
-class ModuleLoader(FileLoader):
-    """Load tests from a python module.
-
-    This handles base name matching and loading tests defined in an importable
-    python module.
-    """
-
-    def __init__(self, test_loader, matcher=None):
-        if matcher is None:
-            # Default to python source files, excluding private ones
-            matcher = NameMatcher(includes=matches_for_regexp('.*\.py$'),
-                                  excludes=matches_for_regexp('^_'))
-        super(ModuleLoader, self).__init__(test_loader, matcher=matcher)
-
-    def discover(self, directory, name):
-        if not self.matches(name):
-            return None
-        module = self.test_loader.importFromPath(os.path.join(directory, name))
-        return self.test_loader.loadTestsFromModule(module)
-
-
-class ScriptLoader(FileLoader):
-    """Load tests from an sst script.
-
-    This handles base name matching and loading tests defined in an sst script.
-    """
-
-    def __init__(self, test_loader, matcher=None):
-        if matcher is None:
-            # Default to python source files, excluding private ones
-            matcher = NameMatcher(includes=matches_for_regexp('.*\.py$'),
-                                  excludes=matches_for_regexp('^_'))
-        super(ScriptLoader, self).__init__(test_loader, matcher=matcher)
-
-    def discover(self, directory, name):
-        if not self.matches(name):
-            return None
-        return self.test_loader.loadTestsFromScript(directory, name)
-
-
-class DirLoader(object):
-    """Load tests from a tree.
-
-    This is an abstract class allowing daughter classes to enforce constraints
-    including the ability to load tests from files and directories that cannot
-    be imported.
-    """
-
-    def __init__(self, test_loader, matcher=None):
-        """Load tests from a directory."""
-        super(DirLoader, self).__init__()
-        if matcher is None:
-            # Accept everything
-            self.matches = lambda name: True
-        else:
-            self.matches = matcher.matches
-        self.test_loader = test_loader
-
-    def discover(self, directory, name):
-        if not self.matches(name):
-            return None
-        path = os.path.join(directory, name)
-        names = os.listdir(path)
-        names = self.test_loader.sortNames(names)
-        return self.discover_names(path, names)
-
-    def discover_names(self, directory, names):
-        suite = self.test_loader.suiteClass()
-        for name in names:
-            tests = self.discover_path(directory, name)
-            if tests is not None:
-                suite.addTests(tests)
-        return suite
-
-    def discover_path(self, directory, name):
-        loader = None
-        path = os.path.join(directory, name)
-        if os.path.isfile(path):
-            loader = self.test_loader.fileLoaderClass(self.test_loader)
-        elif os.path.isdir(path):
-            loader = self.test_loader.dirLoaderClass(self.test_loader)
-        if loader is not None:
-            return loader.discover(directory, name)
-        return None
-
-
-class ScriptDirLoader(DirLoader):
-    """Load tests for a tree containing scripts.
-
-    Scripts can be organized in a tree where directories are not python
-    packages. Since scripts are not imported, they don't require the
-    directories containing them to be packages.
-    """
-
-    def __init__(self, test_loader, matcher=None):
-        if matcher is None:
-            # Excludes the 'shared' directory and the "private" directories
-            regexp = '^shared$|^_'
-            matcher = NameMatcher(excludes=matches_for_regexp(regexp))
-        super(ScriptDirLoader, self).__init__(test_loader, matcher=matcher)
-
-    def discover_path(self, directory, name):
-        # MISSINGTEST: The behavior is unclear when a module cannot be imported
-        # because sys.path is incomplete. This makes it hard for the user to
-        # understand it should update sys.path -- vila 2013-05-05
-        path = os.path.join(directory, name)
-        if (os.path.isdir(path) and os.path.isfile(
-                os.path.join(path, '__init__.py'))):
-            # Hold on, we need to respect users wishes here (if it has some)
-            loader = PackageLoader(self.test_loader)
-            try:
-                return loader.discover(directory, name)
-            except ImportError:
-                # FIXME: Nah, didn't work, should we report it to the user ?
-                # (yes see MISSINGTEST above) How ? (By re-raising with a
-                # proper message: if there is an __init__.py file here, it
-                # should be importable, that's what we should explain to the
-                # user) vila 2013-05-04
-                pass
-        return super(ScriptDirLoader, self).discover_path(directory, name)
-
-
-class PackageLoader(DirLoader):
-    """Load tests for a package.
-
-    A package provides a way for the user to specify how tests are loaded.
-    """
-
-    def discover(self, directory, name):
-        if not self.matches(name):
-            return None
-        path = os.path.join(directory, name)
-        try:
-            package = self.test_loader.importFromPath(path)
-        except ImportError:
-            # Explicitly raise the full exception with its backtrace. This
-            # could be overwritten by daughter classes to handle them
-            # differently (swallowing included ;)
-            raise
-        # Can we delegate to the package ?
-        discover = getattr(package, 'discover', None)
-        if discover is not None:
-            # Since the user defined it, the package knows better
-            return discover(self.test_loader, package,
-                            os.path.join(directory, name))
-        # Can we use the load_tests protocol ?
-        load_tests = getattr(package, 'load_tests', None)
-        if load_tests is not None:
-            # FIXME: This swallows exceptions raised the by the user defined
-            # 'load_test'. We may want to give a way to expose them instead
-            # (with or without stopping the test loading) -- vila 2013-04-27
-            return self.test_loader.loadTestsFromModule(package)
-        # Anything else with that ?
-        # Nothing for now, thanks
-
-        names = os.listdir(path)
-        names.remove('__init__.py')
-        names = self.test_loader.sortNames(names)
-        return self.discover_names(path, names)
-
 
 @contextlib.contextmanager
-def Loaders(test_loader, file_loader_class, dir_loader_class):
+def NameMatchers(test_loader, file_matcher=None, dir_matcher=None):
     """A context manager for loading tests from a tree.
 
-    This is mainly used when walking a tree a requiring a different set of
-    loaders for a subtree.
+    This is mainly used when walking a tree and requiring a different set of
+    name matchers for a subtree.
     """
-    if file_loader_class is None:
-        file_loader_class = test_loader.fileLoaderClass
-    if dir_loader_class is None:
-        dir_loader_class = test_loader.dirLoaderClass
-    orig = (test_loader.fileLoaderClass, test_loader.dirLoaderClass)
+    if file_matcher is None:
+        file_matcher = test_loader.file_matcher
+    if dir_matcher is None:
+        dir_matcher = test_loader.dir_matcher
+    orig = (test_loader.file_matcher, test_loader.dir_matcher)
     try:
-        test_loader.fileLoaderClass = file_loader_class
-        test_loader.dirLoaderClass = dir_loader_class
-        # 'test_loader' will now use the specified file/dir loader classes
-        yield
+        test_loader.file_matcher = file_matcher
+        test_loader.dir_matcher = dir_matcher
+        # 'test_loader' will now use the specified file/dir matchers
+        yield test_loader
     finally:
-        (test_loader.fileLoaderClass, test_loader.dirLoaderClass) = orig
+        (test_loader.file_matcher, test_loader.dir_matcher) = orig
 
 
 class TestLoader(unittest.TestLoader):
-    """Load tests from an sst tree.
-
-    This loader is able to load sst scripts and create test cases with the
-    right sst specific attributes (browser, error handling, reporting).
-
-    This also allows test case based modules to be loaded when appropriate.
-
-    This also provides ways for packages to define the test loading as they see
-    fit.
+    """Load tests from an arbitrary tree.
+
+    This also provides ways for packages to define the test discovery and
+    loading as they see fit.
 
     Sorting happens on base names inside a directory while walking the tree and
     on test classes and test method names when loading a module. Those sortings
     combined provide a test suite where test ids are sorted.
     """
 
-    dirLoaderClass = PackageLoader
-    fileLoaderClass = ModuleLoader
-
-    def __init__(self,  results_directory=None, browser_factory=None,
-                 screenshots_on=False, debug_post_mortem=False,
-                 extended_report=False):
-        super(TestLoader, self).__init__()
-        self.results_directory = results_directory
-        self.browser_factory = browser_factory
-        self.screenshots_on = screenshots_on
-        self.debug_post_mortem = debug_post_mortem
-        self.extended_report = extended_report
+    file_matcher = NameMatcher(includes=[r'^test.*\.py$'])
+    dir_matcher = NameMatcher(includes=[r'.*'])
 
     def discover(self, start_dir, pattern='test*.py', top_level_dir=None):
         if top_level_dir:
@@ -303,33 +101,48 @@
             # setup properly
             sys.path.insert(0, top_level_dir)
 
-        class ModuleLoaderFromPattern(ModuleLoader):
-
-            def __init__(self, test_loader):
-                matcher = NameMatcher(includes=matches_for_glob(pattern))
-                super(ModuleLoaderFromPattern, self).__init__(
-                    test_loader, matcher=matcher)
-
-        return self.discoverTests(start_dir,
-                                  file_loader_class=ModuleLoaderFromPattern)
-
-    def discoverTests(self, start_dir, file_loader_class=None,
-                      dir_loader_class=None):
-        with Loaders(self, file_loader_class, dir_loader_class):
-            dir_loader = self.dirLoaderClass(self)
-            return dir_loader.discover(*os.path.split(start_dir))
-
-    def discoverTestsFromPackage(self, package, path, file_loader_class=None,
-                                 dir_loader_class=None):
-        suite = self.suiteClass()
-        suite.addTests(self.loadTestsFromModule(package))
-        names = os.listdir(path)
-        names.remove('__init__.py')
-        names = self.sortNames(names)
-        with Loaders(self, file_loader_class, dir_loader_class):
-            dir_loader = self.dirLoaderClass(self)
-            suite.addTests(dir_loader.discover_names(path, names))
-        return suite
+        translated = NameMatcher(includes=['^' + fnmatch.translate(pattern)])
+        with NameMatchers(self, file_matcher=translated) as tl:
+            return tl.discoverTestsFromTree(start_dir)
+
+    def discoverTestsFromTree(self, dir_path, package=None):
+        suite = self.suiteClass()
+        names = os.listdir(dir_path)
+        if package is None:
+            if os.path.isfile(os.path.join(dir_path, '__init__.py')):
+                package = self.importFromPath(dir_path)
+                names.remove('__init__.py')
+        if package is not None:
+            # Can we delegate to the package ?
+            discover = getattr(package, 'discover', None)
+            if discover is not None:
+                # Since the user defined it, the package knows better
+                suite.addTests(discover(self, package, dir_path, names))
+                return suite
+            load_tests = getattr(package, 'load_tests', None)
+            if load_tests is not None:
+                # let unittest handle the 'load_tests' protocol
+                suite.addTests(self.loadTestsFromModule(package))
+                return suite
+            # If tests are defined in the package, load them
+            suite.addTests(self.loadTestsFromModule(package))
+        suite.addTests(self.discoverTestsFromNames(dir_path, names))
+        return suite
+
+    def discoverTestsFromNames(self, dir_path, names):
+        # Walk the tree to discover the tests
+        suite = self.suiteClass()
+        for name in self.sortNames(names):
+            path = os.path.join(dir_path, name)
+            if os.path.isfile(path) and self.file_matcher.matches(name):
+                suite.addTests(self.discoverTestsFromFile(path))
+            elif os.path.isdir(path) and self.dir_matcher.matches(name):
+                suite.addTests(self.discoverTestsFromTree(path))
+        return suite
+
+    def discoverTestsFromFile(self, path):
+        module = self.importFromPath(path)
+        return self.loadTestsFromModule(module)
 
     def sortNames(self, names):
         """Return 'names' sorted as defined by sortTestMethodsUsing.
@@ -349,9 +162,45 @@
         __import__(mod_name)
         return sys.modules[mod_name]
 
-    def loadTestsFromScript(self, dir_name, script_name):
+
+class SSTestLoader(TestLoader):
+    """Load tests from an sst tree.
+
+    This loader is able to load sst scripts and create test cases with the
+    right sst specific attributes (browser, error handling, reporting).
+
+    This also allows test case based modules to be loaded when appropriate.
+
+    The main differences with unittest test loader are around different rules
+    for file names that can contain tests and importing rules (a script *should
+    not* be imported at load time).
+
+    Scripts can be organized in a tree where directories are not python
+    packages. Since scripts are not imported, they don't require the
+    directories containing them to be packages. Although as soon a test suite
+    becomes complex enough to be organized as a tree, it generally requires the
+    packages to be importable.
+    """
+
+    file_matcher = NameMatcher(includes=[r'.*\.py$'], excludes=[r'^_'])
+    dir_matcher = NameMatcher(includes=[r'.*'], excludes=[r'^_', '^shared$'])
+
+    def __init__(self, results_directory=None, browser_factory=None,
+                 screenshots_on=False, debug_post_mortem=False,
+                 extended_report=False):
+        super(SSTestLoader, self).__init__()
+        self.results_directory = results_directory
+        self.browser_factory = browser_factory
+        self.screenshots_on = screenshots_on
+        self.debug_post_mortem = debug_post_mortem
+        self.extended_report = extended_report
+
+    def discoverTestsFromFile(self, path):
+        return self.loadTestsFromScript(path)
+
+    def loadTestsFromScript(self, path):
         suite = self.suiteClass()
-        path = os.path.join(dir_name, script_name)
+        dir_name, script_name = os.path.split(path)
         if not os.path.isfile(path):
             return suite
         # script specific test parametrization
@@ -382,27 +231,23 @@
         return test
 
 
-def discoverTestScripts(test_loader, package, directory):
+def discoverTestScripts(test_loader, package, directory, names):
     """``discover`` helper to load sst scripts.
 
     This can be used in a __init__.py file while walking a regular tests tree.
     """
-    return test_loader.discoverTestsFromPackage(
-        package, directory,
-        file_loader_class=ScriptLoader, dir_loader_class=ScriptDirLoader)
-
-
-def discoverRegularTests(test_loader, package, directory):
+    return SSTestLoader().discoverTestsFromNames(directory, names)
+
+
+def discoverRegularTests(test_loader, package, directory, names):
     """``discover`` helper to load regular python files defining tests.
 
     This can be used in a __init__.py file while walking an sst tests tree.
     """
-    return test_loader.discoverTestsFromPackage(
-        package, directory,
-        file_loader_class=ModuleLoader, dir_loader_class=PackageLoader)
-
-
-def discoverNoTests(test_loader, *args, **kwargs):
+    return TestLoader().discoverTestsFromNames(directory, names)
+
+
+def discoverNoTests(test_loader, package, directory, names):
     """Returns an empty test suite.
 
     This can be used in a __init__.py file to prune the test loading for a

=== modified file 'src/sst/result.py'
--- src/sst/result.py	2013-05-10 16:10:51 +0000
+++ src/sst/result.py	2013-06-05 15:07:32 +0000
@@ -33,9 +33,6 @@
         self.timer = timer
         self.verbose = verbosity > 1
 
-    def startTestRun(self):
-        super(TextTestResult, self).startTestRun()
-
     def startTest(self, test):
         if self.verbose:
             self.stream.write(str(test))

=== modified file 'src/sst/runtests.py'
--- src/sst/runtests.py	2013-06-04 15:56:58 +0000
+++ src/sst/runtests.py	2013-06-05 15:07:32 +0000
@@ -63,29 +63,22 @@
              extended=False,
              includes=None,
              excludes=None):
-
     if not os.path.isdir(test_dir):
         raise RuntimeError('Specified directory %r does not exist'
                            % (test_dir,))
+    if browser_factory is None and collect_only is False:
+        raise RuntimeError('A browser must be specified')
     shared_directory = find_shared_directory(test_dir, shared_directory)
     config.shared_directory = shared_directory
-    sys.path.append(shared_directory)
-
-    if browser_factory is None:
-        # TODO: We could raise an error instead as providing a default value
-        # makes little sense here -- vila 2013-04-11
-        browser_factory = browsers.FirefoxFactory()
-
-    test_loader = loader.TestLoader(results_directory,
-                                    browser_factory, screenshots_on,
-                                    debug, extended)
+    if shared_directory is not None:
+        sys.path.append(shared_directory)
+
+    test_loader = loader.SSTestLoader(results_directory,
+                                      browser_factory, screenshots_on,
+                                      debug, extended)
     alltests = test_loader.suiteClass()
-    alltests.addTests(
-        test_loader.discoverTests(test_dir,
-                                  file_loader_class=loader.ScriptLoader,
-                                  dir_loader_class=loader.ScriptDirLoader))
-
-    alltests = filters.filter_by_regexps(test_regexps, alltests)
+    alltests.addTests(test_loader.discoverTestsFromTree(test_dir))
+    alltests = filters.include_regexps(test_regexps, alltests)
     alltests = filters.exclude_regexps(excludes, alltests)
 
     if not alltests.countTestCases():

=== added file 'src/sst/selftests/shared/__init__.py'
--- src/sst/selftests/shared/__init__.py	1970-01-01 00:00:00 +0000
+++ src/sst/selftests/shared/__init__.py	2013-06-05 15:07:32 +0000
@@ -0,0 +1,3 @@
+from sst import loader
+
+discover = loader.discoverNoTests

=== modified file 'src/sst/tests/test_filters.py'
--- src/sst/tests/test_filters.py	2013-05-23 10:41:04 +0000
+++ src/sst/tests/test_filters.py	2013-06-05 15:07:32 +0000
@@ -83,8 +83,7 @@
 
     def assertFiltered(self, expected, regexps, ids):
         """Check that ``regexps`` filters tests created from ``ids``."""
-        filtered = filters.filter_by_regexps(regexps,
-                                             create_tests_from_ids(ids))
+        filtered = filters.include_regexps(regexps, create_tests_from_ids(ids))
         self.assertEqual(expected,
                          [t.id() for t in testtools.iterate_tests(filtered)])
 

=== modified file 'src/sst/tests/test_loader.py'
--- src/sst/tests/test_loader.py	2013-05-14 08:48:15 +0000
+++ src/sst/tests/test_loader.py	2013-06-05 15:07:32 +0000
@@ -46,136 +46,75 @@
 )
 
 
-class TestMatchesForRegexp(testtools.TestCase):
-
-    def test_matches(self):
-        matches = loader.matches_for_regexp('foo.*')
-        # All assertions should succeed, if one of them fails, we have a bigger
-        # problem than having one test for each assertion
-        self.assertTrue(matches('foo'))
-        self.assertFalse(matches('bar'))
-        self.assertTrue(matches('foobar'))
-        self.assertFalse(matches('barfoo'))
-
-
-class TestMatchesForGlob(testtools.TestCase):
-
-    def test_matches(self):
-        matches = loader.matches_for_glob('foo*')
-        # All assertions should succeed, if one of them fails, we have a bigger
-        # problem than having one test for each assertion
-        self.assertTrue(matches('foo'))
-        self.assertFalse(matches('fo'))
-        self.assertFalse(matches('bar'))
-        self.assertTrue(matches('foobar'))
-        self.assertFalse(matches('barfoo'))
-
-
 class TestNameMatcher(testtools.TestCase):
 
-    def test_default_includes(self):
-        name_matcher = loader.NameMatcher()
-        self.assertTrue(name_matcher.includes('foo'))
-        self.assertTrue(name_matcher.matches('foo'))
-
-    def test_default_exclude(self):
-        name_matcher = loader.NameMatcher()
-        self.assertFalse(name_matcher.excludes('foo'))
-        self.assertTrue(name_matcher.matches('foo'))
-
-    def test_provided_includes(self):
-        name_matcher = loader.NameMatcher(
-            includes=loader.matches_for_regexp('^.*foo$'))
-        self.assertTrue(name_matcher.includes('foo'))
-        self.assertTrue(name_matcher.includes('barfoo'))
-        self.assertFalse(name_matcher.includes('bar'))
-        self.assertFalse(name_matcher.includes('foobar'))
-
-    def test_provided_excludes(self):
-        name_matcher = loader.NameMatcher(
-            excludes=loader.matches_for_regexp('^bar.*foo$'))
-        self.assertTrue(name_matcher.excludes('barfoo'))
-        self.assertFalse(name_matcher.excludes('foo'))
-
-
-class TestFileLoader(testtools.TestCase):
-
-    def get_test_loader(self):
-        return loader.TestLoader()
-
-    def test_discover_nothing(self):
-        tests.set_cwd_to_tmp(self)
-        with open('foo', 'w') as f:
-            f.write('bar\n')
-        file_loader = loader.FileLoader(self.get_test_loader())
-        suite = file_loader.discover('.', 'foo')
-        self.assertIs(None, suite)
-
-
-class TestModuleLoader(tests.ImportingLocalFilesTest):
-
-    def get_test_loader(self):
-        return loader.TestLoader()
-
-    def test_default_includes(self):
-        mod_loader = loader.ModuleLoader(self.get_test_loader())
-        self.assertTrue(mod_loader.matches('foo.py'))
-        # But we won't try to import a random file
-        self.assertFalse(mod_loader.matches('foopy'))
-
-    def test_discover_empty_file(self):
-        with open('foo.py', 'w') as f:
+    def test_defaults(self):
+        nm = loader.NameMatcher()
+        self.assertFalse(nm.matches(''))
+        self.assertFalse(nm.matches('foo'))
+
+    def test_simple_include(self):
+        nm = loader.NameMatcher(includes=['foo'])
+        self.assertTrue(nm.matches('foo'))
+        self.assertTrue(nm.matches('XXXfooXXX'))
+
+    def test_multiple_includes(self):
+        nm = loader.NameMatcher(includes=['foo', '^bar'])
+        self.assertTrue(nm.matches('foo'))
+        self.assertTrue(nm.matches('bar'))
+        self.assertTrue(nm.matches('barfoo'))
+        self.assertTrue(nm.matches('foobar'))
+        self.assertFalse(nm.matches('bazbar'))
+
+    def test_simple_excludes(self):
+        nm = loader.NameMatcher(includes=['.*'], excludes=['foo'])
+        self.assertTrue(nm.matches('bar'))
+        self.assertFalse(nm.matches('foo'))
+        self.assertFalse(nm.matches('foobar'))
+
+    def test_multiple_excludes(self):
+        nm = loader.NameMatcher(includes=['.*'], excludes=['foo$', '^bar'])
+        self.assertTrue(nm.matches('baz'))
+        self.assertTrue(nm.matches('footix'))
+        self.assertFalse(nm.matches('foo'))
+        self.assertFalse(nm.matches('barista'))
+
+
+class TestTestLoader(tests.ImportingLocalFilesTest):
+
+    def make_test_loader(self):
+        return loader.TestLoader()
+
+    def test_ignored_file(self):
+        with open('empty.py', 'w') as f:
             f.write('')
-        mod_loader = loader.ModuleLoader(self.get_test_loader())
-        suite = mod_loader.discover('.', 'foo.py')
+        test_loader = self.make_test_loader()
+        suite = test_loader.discoverTestsFromTree('.')
         self.assertEqual(0, suite.countTestCases())
 
-    def test_discover_invalid_file(self):
-        with open('foo.py', 'w') as f:
+    def test_invalid_file(self):
+        with open('test_foo.py', 'w') as f:
             f.write("I'm no python code")
-        mod_loader = loader.ModuleLoader(self.get_test_loader())
-        self.assertRaises(SyntaxError, mod_loader.discover, '.', 'foo.py')
-
-    def test_discover_valid_file(self):
-        with open('foo.py', 'w') as f:
-            f.write('''
-import unittest
-
-class Test(unittest.TestCase):
-
-    def test_it(self):
-        self.assertTrue(True)
-''')
-        mod_loader = loader.ModuleLoader(self.get_test_loader())
-        suite = mod_loader.discover('.', 'foo.py')
-        self.assertEqual(1, suite.countTestCases())
-
-
-class TestDirLoaderDiscoverPath(tests.ImportingLocalFilesTest):
-
-    def get_test_loader(self):
-        test_loader = loader.TestLoader()
-        # We don't use the default PackageLoader for unit testing DirLoader
-        # behavior. But we still leave ModuleLoader for the file loader.
-        test_loader.dirLoaderClass = loader.DirLoader
-        return test_loader
-
-    def test_discover_path_for_file_without_package(self):
+        test_loader = self.make_test_loader()
+        self.assertRaises(SyntaxError, test_loader.discoverTestsFromTree, '.')
+
+    def test_invalid_file_in_a_dir(self):
         tests.write_tree_from_desc('''dir: t
-file: t/foo.py
+file: t/test_foo.py
 I'm not even python code
 ''')
-        # Since 'foo' can't be imported, discover_path should not be invoked,
-        # ensure we still get some meaningful error message.
-        dir_loader = loader.DirLoader(self.get_test_loader())
+        # Since 'foo' can't be imported, discoverTestsFromTree should not be
+        # invoked, ensure we still get some meaningful error message.
+        test_loader = self.make_test_loader()
         e = self.assertRaises(ImportError,
-                              dir_loader.discover_path, 't', 'foo.py')
-        self.assertEqual('No module named t.foo', e.message)
+                              test_loader.discoverTestsFromTree, 't')
+        self.assertEqual('No module named t.test_foo', e.args[0])
 
-    def test_discover_path_for_valid_file(self):
+    def test_invalid_init_file(self):
         tests.write_tree_from_desc('''dir: t
 file: t/__init__.py
-file: t/foo.py
+I'm not even python code
+file: t/test_foo.py
 import unittest
 
 class Test(unittest.TestCase):
@@ -183,15 +122,35 @@
     def test_it(self):
         self.assertTrue(True)
 ''')
-        dir_loader = loader.DirLoader(self.get_test_loader())
-        suite = dir_loader.discover_path('t', 'foo.py')
-        self.assertEqual(1, suite.countTestCases())
-
-    def test_discover_path_for_dir(self):
+        test_loader = self.make_test_loader()
+        e = self.assertRaises(SyntaxError,
+                              test_loader.discoverTestsFromTree, 't')
+        self.assertEqual('EOL while scanning string literal', e.args[0])
+
+    def test_symlink_is_ignored(self):
+        tests.write_tree_from_desc('''dir: t
+file: t/foo
+tagada
+link: t/foo t/test_bar.py
+''')
+        test_loader = self.make_test_loader()
+        suite = test_loader.discoverTestsFromTree('.')
+        # Despite a matching name, symlink is ignored
+        self.assertEqual(0, suite.countTestCases())
+
+    def test_broken_symlink_is_ignored(self):
+        tests.write_tree_from_desc('''dir: t
+link: t/test_bar.py t/test_qux.py
+''')
+        test_loader = self.make_test_loader()
+        suite = test_loader.discoverTestsFromTree('.')
+        self.assertEqual(0, suite.countTestCases())
+
+    def test_file_in_a_dir(self):
         tests.write_tree_from_desc('''dir: t
 file: t/__init__.py
 dir: t/dir
-file: t/dir/foo.py
+file: t/dir/test_foo.py
 import unittest
 
 class Test(unittest.TestCase):
@@ -199,228 +158,214 @@
     def test_it(self):
         self.assertTrue(True)
 ''')
-        dir_loader = loader.DirLoader(self.get_test_loader())
+        test_loader = self.make_test_loader()
         e = self.assertRaises(ImportError,
-                              dir_loader.discover_path, 't', 'dir')
-        # 't' is a module but 'dir' is not, hence, 'dir.foo' is not either,
-        # blame python for the approximate message ;-/
-        self.assertEqual('No module named dir.foo', e.message)
-
-    def test_discover_path_for_not_matching_symlink(self):
-        tests.write_tree_from_desc('''dir: t
-file: t/foo
-tagada
-link: t/foo t/bar.py
-''')
-        dir_loader = loader.DirLoader(self.get_test_loader())
-        suite = dir_loader.discover_path('t', 'bar.py')
-        self.assertIs(None, suite)
-
-    def test_discover_path_for_broken_symlink(self):
-        tests.write_tree_from_desc('''dir: t
-file: t/foo
-tagada
-link: bar t/qux
-''')
-        dir_loader = loader.DirLoader(self.get_test_loader())
-        suite = dir_loader.discover_path('t', 'qux')
-        self.assertIs(None, suite)
-
-    def test_discover_simple_file_in_dir(self):
-        tests.write_tree_from_desc('''dir: t
-file: t/__init__.py
-file: t/foo.py
-import unittest
-
-class Test(unittest.TestCase):
-
-    def test_it(self):
-        self.assertTrue(True)
-''')
-        dir_loader = loader.DirLoader(self.get_test_loader())
-        suite = dir_loader.discover('.', 't')
-        # Despite using DirLoader, python triggers the 't' import so we are
-        # able to import foo.py and all is well
-        self.assertEqual(1, suite.countTestCases())
-
-
-class TestPackageLoader(tests.ImportingLocalFilesTest):
-
-    def get_test_loader(self):
-        test_loader = loader.TestLoader()
-        return test_loader
-
-    def test_discover_package_with_invalid_file(self):
-        tests.write_tree_from_desc('''dir: dir
-file: dir/__init__.py
-file: dir/foo.py
-I'm not even python code
-''')
-        pkg_loader = loader.PackageLoader(self.get_test_loader())
-        e = self.assertRaises(SyntaxError, pkg_loader.discover, '.', 'dir')
-        self.assertEqual('EOL while scanning string literal', e.args[0])
-
-    def test_discover_simple_file_in_dir(self):
-        tests.write_tree_from_desc('''dir: t
-file: t/__init__.py
-file: t/foo.py
-import unittest
-
-class Test(unittest.TestCase):
-
-    def test_it(self):
-        self.assertTrue(True)
-''')
-        dir_loader = loader.DirLoader(self.get_test_loader())
-        suite = dir_loader.discover('.', 't')
-        self.assertEqual(1, suite.countTestCases())
-
-
-class TestLoadScript(testtools.TestCase):
+                              test_loader.discoverTestsFromTree, 't/dir')
+        # 't' is a package but 'dir' is not, hence, 'dir.test_foo' is not
+        # either, blame python for the approximate message ;-/
+        self.assertEqual('No module named dir.test_foo', e.args[0])
+
+    def test_simple_file_in_a_package(self):
+        tests.write_tree_from_desc('''dir: t
+file: t/__init__.py
+file: t/test_foo.py
+import unittest
+
+class Test(unittest.TestCase):
+
+    def test_me(self):
+      self.assertTrue(True)
+''')
+        test_loader = self.make_test_loader()
+        suite = test_loader.discoverTestsFromTree('t')
+        self.assertEqual(1, suite.countTestCases())
+
+    def test_discover_changing_file_matcher(self):
+        tests.write_tree_from_desc('''dir: t
+file: t/__init__.py
+file: t/test_foo.py
+import unittest
+
+class Test(unittest.TestCase):
+
+    def test_me(self):
+      self.assertTrue(True)
+dir: t/other
+file: t/other/__init__.py
+import unittest
+from sst import loader
+
+def discover(test_loader, package, directory_path, names):
+    suite = test_loader.loadTestsFromModule(package)
+    # Change the test.*\.py rule
+    fmatcher = loader.NameMatcher(includes=['.*'])
+    with loader.NameMatchers(test_loader, fmatcher) as tl:
+        suite.addTests(tl.discoverTestsFromNames(directory_path, names))
+    return suite
+
+class Test(unittest.TestCase):
+
+    def test_in_init(self):
+      self.assertTrue(True)
+file: t/other/not_starting_with_test.py
+import unittest
+
+class Test(unittest.TestCase):
+
+    def test_me(self):
+      self.assertTrue(True)
+''')
+        test_loader = self.make_test_loader()
+        suite = test_loader.discoverTestsFromTree('t')
+        self.assertEqual(3, suite.countTestCases())
+        self.assertEqual(['t.other.Test.test_in_init',
+                          't.other.not_starting_with_test.Test.test_me',
+                          't.test_foo.Test.test_me'],
+                         [t.id() for t in testtools.iterate_tests(suite)])
+
+    def test_load_tests(self):
+        tests.write_tree_from_desc('''dir: t
+file: t/__init__.py
+import unittest
+
+def load_tests(test_loader, tests, ignore):
+    # A simple way to reveal the side effect is to add more tests
+    class TestLoadTest(unittest.TestCase):
+        def test_in_load_test(self):
+          self.assertTrue(True)
+    tests.addTests(test_loader.loadTestsFromTestCase(TestLoadTest))
+    return tests
+
+class TestInit(unittest.TestCase):
+
+    def test_in_init(self):
+      self.assertTrue(True)
+
+file: t/test_not_discovered.py
+import unittest
+
+class Test(unittest.TestCase):
+
+    def test_me(self):
+      self.assertTrue(True)
+''')
+        test_loader = self.make_test_loader()
+        suite = test_loader.discoverTestsFromTree('t')
+        self.assertEqual(2, suite.countTestCases())
+        self.assertEqual(['t.TestInit.test_in_init',
+                          't.TestLoadTest.test_in_load_test'],
+                         [t.id() for t in testtools.iterate_tests(suite)])
+
+
+class TestTestLoaderPattern(tests.ImportingLocalFilesTest):
+
+    def make_test_loader(self):
+        return loader.TestLoader()
+
+    def test_default_pattern(self):
+        tests.write_tree_from_desc('''dir: t
+file: t/__init__.py
+file: t/foo.py
+Don't look at me !
+file: t/test_foo.py
+import unittest
+
+class Test(unittest.TestCase):
+
+    def test_me(self):
+      self.assertTrue(True)
+''')
+        test_loader = self.make_test_loader()
+        suite = test_loader.discover('t')
+        self.assertEqual(1, suite.countTestCases())
+
+    def test_pattern(self):
+        tests.write_tree_from_desc('''dir: t
+file: t/__init__.py
+file: t/foo_foo.py
+import unittest
+
+class Test(unittest.TestCase):
+
+    def test_me(self):
+      self.assertTrue(True)
+file: t/test_foo.py
+Don't look at me !
+''')
+        test_loader = self.make_test_loader()
+        suite = test_loader.discover('t', pattern='foo*.py')
+        self.assertEqual(1, suite.countTestCases())
+
+
+class TestTestLoaderTopLevelDir(testtools.TestCase):
 
     def setUp(self):
-        super(TestLoadScript, self).setUp()
+        super(TestTestLoaderTopLevelDir, self).setUp()
+        # We build trees rooted in test_base_dir from which we will import
         tests.set_cwd_to_tmp(self)
-
-    def create_script(self, path, content):
-        with open(path, 'w') as f:
-            f.write(content)
-
-    def test_load_simple_script(self):
+        tests.protect_imports(self)
+        tests.write_tree_from_desc('''dir: t
+file: t/__init__.py
+file: t/foo.py
+import unittest
+
+class Test(unittest.TestCase):
+
+    def test_me(self):
+      self.assertTrue(True)
+''')
+        self.loader = loader.TestLoader()
+
+    def test_simple_file_in_a_dir(self):
+        suite = self.loader.discover('t', '*.py', self.test_base_dir)
+        self.assertEqual(1, suite.countTestCases())
+
+    def test_simple_file_in_a_dir_no_sys_path(self):
+        e = self.assertRaises(ImportError,
+                              self.loader.discover, 't', '*.py')
+        self.assertEqual('No module named t', e.args[0])
+
+
+class TestSSTestLoaderDiscoverTestsFromTree(tests.ImportingLocalFilesTest):
+
+    def discover(self, start_dir):
+        test_loader = loader.SSTestLoader()
+        return test_loader.discoverTestsFromTree(start_dir)
+
+    def test_simple_script(self):
         # A simple do nothing script with no imports
-        self.create_script('foo.py', 'pass')
-        suite = loader.TestLoader().loadTestsFromScript('.', 'foo.py')
+        tests.write_tree_from_desc('''file: foo.py
+pass
+''')
+        suite = self.discover('.')
         self.assertEqual(1, suite.countTestCases())
 
-    def test_load_simple_script_with_csv(self):
-        self.create_script('foo.py', "pass")
-        with open('foo.csv', 'w') as f:
-            f.write('''\
+    def test_simple_script_with_csv(self):
+        tests.write_tree_from_desc('''file: foo.py
+pass
+file: foo.csv
 'foo'^'bar'
 1^baz
 2^qux
 ''')
-        suite = loader.TestLoader().loadTestsFromScript('.', 'foo.py')
+        suite = self.discover('.')
         self.assertEqual(2, suite.countTestCases())
 
-    def test_load_non_existing_script(self):
-        suite = loader.TestLoader().loadTestsFromScript('.', 'foo.py')
-        self.assertEqual(0, suite.countTestCases())
-
-
-class TestScriptLoader(tests.ImportingLocalFilesTest):
-
-    def get_test_loader(self):
-        return loader.TestLoader()
-
-    def test_simple_script(self):
+    def test_simple_script_in_a_dir(self):
         tests.write_tree_from_desc('''dir: t
 # no t/__init__.py required, we don't need to import the scripts
-file: t/foo.py
-from sst.actions import *
-
+file: t/script.py
 raise AssertionError('Loading only, executing fails')
 ''')
-        script_loader = loader.ScriptLoader(self.get_test_loader())
-        suite = script_loader.discover('t', 'foo.py')
+        suite = self.discover('t')
         self.assertEqual(1, suite.countTestCases())
 
     def test_ignore_privates(self):
         tests.write_tree_from_desc('''dir: t
 file: t/_private.py
 ''')
-        script_loader = loader.ScriptLoader(self.get_test_loader())
-        suite = script_loader.discover('t', '_private.py')
-        self.assertIs(None, suite)
-
-
-class TesScriptDirLoader(tests.ImportingLocalFilesTest):
-
-    def test_shared(self):
-        tests.write_tree_from_desc('''dir: t
-# no t/__init__.py required, we don't need to import the scripts
-file: t/foo.py
-from sst.actions import *
-
-raise AssertionError('Loading only, executing fails')
-dir: t/shared
-file: t/shared/amodule.py
-Don't look at me !
-''')
-        script_dir_loader = loader.ScriptDirLoader(loader.TestLoader())
-        suite = script_dir_loader.discover('t', 'shared')
-        self.assertIs(None, suite)
-
-    def test_regular(self):
-        tests.write_tree_from_desc('''dir: t
-# no t/__init__.py required, we don't need to import the scripts
-dir: t/subdir
-file: t/subdir/foo.py
-raise AssertionError('Loading only, executing fails')
-dir: t/shared
-file: t/shared/amodule.py
-Don't look at me !
-''')
-        test_loader = loader.TestLoader()
-        suite = test_loader.discoverTests(
-            '.', file_loader_class=loader.ScriptLoader,
-            dir_loader_class=loader.ScriptDirLoader)
-        self.assertEqual(1, suite.countTestCases())
-
-
-class TestTestLoader(tests.ImportingLocalFilesTest):
-
-    def test_simple_file_in_a_dir(self):
-        tests.write_tree_from_desc('''dir: t
-file: t/__init__.py
-file: t/foo.py
-import unittest
-
-class Test(unittest.TestCase):
-
-    def test_me(self):
-      self.assertTrue(True)
-''')
-        test_loader = loader.TestLoader()
-        suite = test_loader.discoverTests('t')
-        self.assertEqual(1, suite.countTestCases())
-
-    def test_broken_file_in_a_dir(self):
-        tests.write_tree_from_desc('''dir: t
-file: t/__init__.py
-file: t/foo.py
-I'm not even python code
-''')
-        test_loader = loader.TestLoader()
-        e = self.assertRaises(SyntaxError, test_loader.discoverTests, 't')
-        self.assertEqual('EOL while scanning string literal', e.args[0])
-
-    def test_scripts_below_regular(self):
-        tests.write_tree_from_desc('''dir: t
-file: t/__init__.py
-file: t/foo.py
-import unittest
-
-class Test(unittest.TestCase):
-
-    def test_me(self):
-      self.assertTrue(True)
-dir: t/scripts
-file: t/scripts/__init__.py
-from sst import loader
-
-discover = loader.discoverTestScripts
-file: t/scripts/script.py
-raise AssertionError('Loading only, executing fails')
-''')
-        test_loader = loader.TestLoader()
-        suite = test_loader.discoverTests('t')
-        self.assertEqual(2, suite.countTestCases())
-        # Check which kind of tests have been discovered or we may miss regular
-        # test cases seen as scripts.
-        self.assertEqual(['t.foo.Test.test_me',
-                          't.scripts.script'],
-                         [t.id() for t in testtools.iterate_tests(suite)])
+        suite = self.discover('t')
+        self.assertEqual(0, suite.countTestCases())
 
     def test_regular_below_scripts(self):
         tests.write_tree_from_desc('''dir: t
@@ -428,15 +373,10 @@
 dir: t/regular
 file: t/regular/__init__.py
 from sst import loader
-import unittest
 
 discover = loader.discoverRegularTests
 
-class Test(unittest.TestCase):
-
-    def test_in_init(self):
-      self.assertTrue(True)
-file: t/regular/foo.py
+file: t/regular/test_foo.py
 import unittest
 
 class Test(unittest.TestCase):
@@ -446,15 +386,10 @@
 file: t/script.py
 raise AssertionError('Loading only, executing fails')
 ''')
-        test_loader = loader.TestLoader()
-        suite = test_loader.discoverTests(
-            't',
-            file_loader_class=loader.ScriptLoader,
-            dir_loader_class=loader.ScriptDirLoader)
+        suite = self.discover('t')
         # Check which kind of tests have been discovered or we may miss regular
         # test cases seen as scripts.
-        self.assertEqual(['t.regular.Test.test_in_init',
-                          't.regular.foo.Test.test_me',
+        self.assertEqual(['t.regular.test_foo.Test.test_me',
                           't.script'],
                          [t.id() for t in testtools.iterate_tests(suite)])
 
@@ -489,89 +424,13 @@
 file: script1.py
 file: script2.py
 file: not_a_test
-# '.p' is intentional, not a typoed '.py'
-file: test_not_a_test.p
+file: test_not_a_test.potato
 _hidden_too.py
 ''')
-        test_loader = loader.TestLoader()
-        suite = test_loader.discoverTests(
-            '.',
-            file_loader_class=loader.ScriptLoader,
-            dir_loader_class=loader.ScriptDirLoader)
+        suite = self.discover('.')
         self.assertEqual(['script1',
                           'script2',
                           'tests.test_real.Test_test_real.test_test_real',
                           'tests.test_real1.Test_test_real1.test_test_real1',
                           'tests.test_real2.Test_test_real2.test_test_real2'],
                          [t.id() for t in testtools.iterate_tests(suite)])
-
-
-class TestTestLoaderPattern(tests.ImportingLocalFilesTest):
-
-    def test_default_pattern(self):
-        tests.write_tree_from_desc('''dir: t
-file: t/__init__.py
-file: t/foo.py
-Don't look at me !
-file: t/test_foo.py
-import unittest
-
-class Test(unittest.TestCase):
-
-    def test_me(self):
-      self.assertTrue(True)
-''')
-        test_loader = loader.TestLoader()
-        suite = test_loader.discover('t')
-        self.assertEqual(1, suite.countTestCases())
-
-    def test_pattern(self):
-        tests.write_tree_from_desc('''dir: t
-file: t/__init__.py
-file: t/foo_foo.py
-import unittest
-
-class Test(unittest.TestCase):
-
-    def test_me(self):
-      self.assertTrue(True)
-file: t/test_foo.py
-Don't look at me !
-''')
-        test_loader = loader.TestLoader()
-        suite = test_loader.discover('t', pattern='foo*.py')
-        self.assertEqual(1, suite.countTestCases())
-
-
-class TestTestLoaderTopLevelDir(testtools.TestCase):
-
-    def setUp(self):
-        super(TestTestLoaderTopLevelDir, self).setUp()
-        # We build trees rooted in test_base_dir from which we will import
-        tests.set_cwd_to_tmp(self)
-        tests.protect_imports(self)
-
-    def _create_foo_in_tests(self):
-        tests.write_tree_from_desc('''dir: t
-file: t/__init__.py
-file: t/foo.py
-import unittest
-
-class Test(unittest.TestCase):
-
-    def test_me(self):
-      self.assertTrue(True)
-''')
-
-    def test_simple_file_in_a_dir(self):
-        self._create_foo_in_tests()
-        test_loader = loader.TestLoader()
-        suite = test_loader.discover('t', '*.py', self.test_base_dir)
-        self.assertEqual(1, suite.countTestCases())
-
-    def test_simple_file_in_a_dir_no_sys_path(self):
-        self._create_foo_in_tests()
-        test_loader = loader.TestLoader()
-        e = self.assertRaises(ImportError,
-                              test_loader.discover, 't', '*.py')
-        self.assertEqual(e.message, 'No module named t')

=== modified file 'src/sst/tests/test_runtests.py'
--- src/sst/tests/test_runtests.py	2013-06-04 15:56:58 +0000
+++ src/sst/tests/test_runtests.py	2013-06-05 15:07:32 +0000
@@ -19,7 +19,10 @@
 
 from cStringIO import StringIO
 
+import testtools
+
 from sst import (
+    browsers,
     runtests,
     tests,
 )
@@ -76,6 +79,51 @@
                          self.run_tests(['t.t'], excludes=['to']))
 
 
+class TestRunBrowserFactory(testtools.TestCase):
+
+    def test_browser_factory_is_mandatory(self):
+        self.assertRaises(RuntimeError, runtests.runtests,
+                          None, 'no results directory used', None,
+                          browser_factory=None)
+
+
+class TestRunTestsShared(tests.ImportingLocalFilesTest):
+
+    def run_tests(self, test_dir, shared_dir=None):
+        out = StringIO()
+        runtests.runtests(None, 'no results directory used', out,
+                          test_dir=test_dir, shared_directory=shared_dir,
+                          collect_only=True)
+        return out.getvalue().splitlines()
+
+    def test_shared_in_top(self):
+        tests.write_tree_from_desc('''dir: t
+# no t/__init__.py required, we don't need to import the scripts
+file: t/foo.py
+from sst.actions import *
+
+raise AssertionError('Loading only, executing fails')
+dir: t/shared
+file: t/shared/amodule.py
+Don't look at me !
+''')
+        test_names = self.run_tests('t', 't/shared')
+        self.assertEqual(['t.foo'], test_names)
+
+    def test_shared_in_dir(self):
+        tests.write_tree_from_desc('''dir: t
+# no t/__init__.py required, we don't need to import the scripts
+dir: t/subdir
+file: t/subdir/foo.py
+raise AssertionError('Loading only, executing fails')
+dir: t/shared
+file: t/shared/amodule.py
+Don't look at me !
+''')
+        test_names = self.run_tests('.', 't/shared')
+        self.assertEqual(['t.subdir.foo'], test_names)
+
+
 class SSTRunExitCodeTestCase(tests.ImportingLocalFilesTest):
 
     def setUp(self):
@@ -108,7 +156,8 @@
 
     def run_tests(self, args):
         out = StringIO()
-        failures = runtests.runtests(args, 'no results directory used', out)
+        failures = runtests.runtests(args, 'no results directory used', out,
+                                     browser_factory=browsers.FirefoxFactory())
         return bool(failures)
 
     def test_pass(self):

=== modified file 'test-loader.TODO'
--- test-loader.TODO	2013-05-30 13:31:51 +0000
+++ test-loader.TODO	2013-06-05 15:07:32 +0000
@@ -9,32 +9,3 @@
 * run unit tests
 
   sst-test -e tests.acceptance
-
-* some test_loader tests are too big, this screams for better helpers so
-   they can be simplified.
-
-* fix the remaining grey areas in the design
-
-There are a few points that smell funny in the current implementation
-including:
-
-- abusing sortTestMethodsUsing
-
-- having to call sortNames in several places
-
-This is probably caused by some less than ideal split of responsability
-between TestLoader and the {File|Dir}Loader classes.
-
-The key points that need to be handled are:
-
-- whether directories are packages or not and as such require to be imported
-
-- if they are imported, respect user overriding
-
-- allowing the user to specify some matching on the base names encountered
-   while walking the tree (or a sub tree). This should remain separate for
-   files and directories (the rules are different).
-   => addressed with '^test_name'
-
-- how the sub tree is iterated
-