def build_suite(self, test_labels=None, extra_tests=None, **kwargs):
suite = super(TestSuiteRunner,
self).build_suite(test_labels, extra_tests, **kwargs)
if self.run_tags is not None:
suite = self.run_tags.filter_suite(suite)
suite, self.full_suite = filter_suite(suite, self.database)
return reorder_suite(suite, self.reorder_by, self.reverse)
def build_suite(self, test_labels, extra_tests=None, **kwargs):
# build standard Django test suite
suite = unittest.TestSuite()
#
# Run Normal Django Test Suite
#
std_test_suite = super(DjangoBehaveTestSuiteRunner,
self).build_suite(test_labels, **kwargs)
suite.addTest(std_test_suite)
#
# Add BDD tests to it
#
# always get all features for given apps (for convenience)
for label in test_labels:
if '.' in label:
print "Ignoring label with dot in: " % label
continue
app = get_app(label)
# Check to see if a separate 'features' module exists,
# parallel to the models module
features_dir = get_features(app)
if features_dir is not None:
# build a test suite for this directory
suite.addTest(self.make_bdd_test_suite(features_dir))
return reorder_suite(suite, (LiveServerTestCase, ))
def build_suite(self, test_labels=None, extra_tests=None, **kwargs):
suite = super(TestSuiteRunner, self).build_suite(
test_labels, extra_tests, **kwargs)
if self.run_tags is not None:
suite = self.run_tags.filter_suite(suite)
suite, self.full_suite = filter_suite(suite, self.database)
return reorder_suite(suite, self.reorder_by, self.reverse)
def startTestRun(self, event):
"""Nose2 hook for the beginning of test running.
Init the django environ and re-order the tests according to
the django documented test runner behaviour.
"""
try:
# Django >= 1.6
from django.test.runner import reorder_suite
except ImportError:
# Django < 1.6
from django.test.simple import reorder_suite
from django.test.simple import DjangoTestSuiteRunner
from django.test.utils import setup_test_environment
# Init the django default runner so we can call it's functions as needed
self.dtsr = DjangoTestSuiteRunner()
setup_test_environment()
event.suite = reorder_suite(event.suite, (unittest.TestCase,))
self.old_config = self.dtsr.setup_databases()
if self.session.verbosity > 1:
# ensure that deprecation warnings are displayed during testing
# the following state is assumed:
# logging.capturewarnings is true
# a "default" level warnings filter has been added for
# DeprecationWarning. See django.conf.LazySettings._configure_logging
self.logger = logging.getLogger('py.warnings')
handler = logging.StreamHandler()
self.logger.addHandler(handler)
def build_suite(self, options, extra_tests=None, **kwargs):
tests = []
discovery_root = settings.TEST_DISCOVERY_ROOT
test_labels = [x[0][6:] for x in os.walk(discovery_root) if x[0].count('/') == 1]
if '__pycache__' in test_labels:
test_labels.remove('__pycache__')
test_labels = ['tests.' + label for label in test_labels]
for label in test_labels:
test_root = import_module(label).__path__[0]
tests.extend(make_test_case(defaultTestLoader.discover(
test_root,
top_level_dir=settings.BASE_PATH,
pattern='*.py'
)))
include = [re.compile(x, re.I) for x in options if not x.startswith('no')]
exclude = [re.compile(x[2:], re.I) for x in options if x.startswith('no')]
tests = [(str(type(test))[14:-2], test) for test in tests]
if include:
tests = [t for t in tests if any([p.search(t[0]) for p in include])]
for pattern in exclude:
tests = [t for t in tests if not pattern.search(t[0])]
suite = TestSuite([x[1] for x in tests])
if extra_tests:
for test in extra_tests:
suite.addTest(test)
return reorder_suite(suite, (TestCase,))
def build_suite(self, test_labels, extra_tests=None, **kwargs):
suite = unittest.TestSuite()
for features_dir in self.get_features_dirs(test_labels):
suite.addTest(self.make_bdd_test_suite(features_dir))
return reorder_suite(suite, (unittest.TestCase, ))
def build_suite(self, test_labels, extra_tests=None, **kwargs):
suite = unittest.TestSuite()
for features_dir in self.get_feathers_dirs(test_labels):
suite.addTest(self.make_bdd_test_suite(features_dir))
return reorder_suite(suite, (unittest.TestCase,))
def build_suite(self, test_labels, extra_tests=None, **kwargs):
# build standard Django test suite
suite = unittest.TestSuite()
#
# Run Normal Django Test Suite
#
std_test_suite = make_test_suite(test_labels, extra_tests, **kwargs)
suite.addTest(std_test_suite)
#
# Add BDD tests to it
#
# always get all features for given apps (for convenience)
for label in test_labels:
if '.' in label:
print ("Ignoring label with dot in: ", label)
continue
app = get_app(label)
# Check to see if a separate 'features' module exists,
# parallel to the models module
features_dir = get_features(app)
if features_dir is not None:
# build a test suite for this directory
suite.addTest(self.make_bdd_test_suite(features_dir))
return reorder_suite(suite, (LiveServerTestCase,))
def build_suite(self, test_labels, extra_tests=None, **kwargs):
shortcut_labels = []
full_labels = []
for label in test_labels:
if label.startswith('='):
shortcut_labels.append(label)
else:
full_labels.append(label)
shortcut_tests = []
if shortcut_labels:
suite = super(WRunner, self).build_suite([], extra_tests, **kwargs)
shortcut_tests = find_shortcut_tests(suite, shortcut_labels)
if full_labels:
suite = super(WRunner, self).build_suite(full_labels, extra_tests,
**kwargs)
suite.addTests(shortcut_tests)
elif shortcut_tests:
# only have shortcut labels
suite = TestSuite(shortcut_tests)
else:
# no labels at all, do the default
suite = super(WRunner, self).build_suite([], extra_tests, **kwargs)
# parent implementation reorders, so we'll do it too
return reorder_suite(suite, self.reorder_by)
def build_suite(self, test_labels, extra_tests=None, **kwargs):
suite = unittest.TestSuite()
for label in test_labels:
if '.' in label:
print("Ignoring label with dot in: %s" % label)
continue
app = get_app(label)
features_dir = get_features(app)
if features_dir is not None:
suite.addTest(self.make_bdd_test_suite(features_dir))
return reorder_suite(suite, (unittest.TestCase, ))
def build_suite(self, test_labels, extra_tests=None, **kwargs):
suite = unittest.TestSuite()
for label in test_labels:
if '.' in label:
print("Ignoring label with dot in: %s" % label)
continue
app = get_app(label)
features_dir = get_features(app)
if features_dir is not None:
suite.addTest(self.make_bdd_test_suite(features_dir))
return reorder_suite(suite, (unittest.TestCase,))
def test_reorder_suite_reverse_with_duplicates(self):
class Tests1(unittest.TestCase):
def test1(self):
pass
class Tests2(unittest.TestCase):
def test2(self):
pass
def test3(self):
pass
suite = self.build_test_suite((Tests1, Tests2))
subsuite = list(suite)[0]
suite.addTest(subsuite)
self.assertTestNames(iter_test_cases(suite),
expected=[
'Tests1.test1',
'Tests2.test2',
'Tests2.test3',
'Tests1.test1',
])
reordered_suite = reorder_suite(suite, classes=[])
self.assertTestNames(reordered_suite,
expected=[
'Tests1.test1',
'Tests2.test2',
'Tests2.test3',
])
reordered_suite = reorder_suite(suite, classes=[], reverse=True)
self.assertTestNames(reordered_suite,
expected=[
'Tests2.test3',
'Tests2.test2',
'Tests1.test1',
])
def build_suite(self, test_labels, extra_tests=None, **kwargs):
suite = unittest.TestSuite()
for label in test_labels:
if '.' in label:
short_label = label.split('.')[-1]
else:
short_label = None
app = get_app(short_label or label)
features_dir = get_features(app)
if features_dir is not None:
suite.addTest(self.make_bdd_test_suite(features_dir))
return reorder_suite(suite, (unittest.TestCase,))
def build_suite(self, test_labels, extra_tests=None, **kwargs):
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
for app in get_apps():
suite.addTest(build_suite(app))
if extra_tests:
for test in extra_tests:
suite.addTest(test)
return runner.reorder_suite(suite, (unittest.TestCase,))
def build_suite(self, test_labels=None, extra_tests=None, **kwargs):
extra_tests = extra_tests or []
test_labels, methods = self._parse_labels_and_methods(test_labels)
discover_kwargs = {}
if self.pattern is not None:
discover_kwargs['pattern'] = self.pattern
if self.top_level is not None:
discover_kwargs['top_level_dir'] = self.top_level
suite = self._get_suite(test_labels, discover_kwargs, extra_tests, methods)
if self.tags or self.exclude_tags:
suite = filter_tests_by_tags(suite, self.tags, self.exclude_tags)
suite = reorder_suite(suite, self.reorder_by, self.reverse)
total_tests = len(suite._tests)
suite = self._get_parallel_suite(suite)
suite.total_tests = total_tests
return suite
def build_suite(self, test_labels, extra_tests=None, **kwargs):
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app_config = apps.get_app_config(label)
suite.addTest(build_suite(app_config))
else:
for app_config in apps.get_app_configs():
suite.addTest(build_suite(app_config))
if extra_tests:
for test in extra_tests:
suite.addTest(test)
return runner.reorder_suite(suite, (unittest.TestCase,))
def build_suite(self, test_labels, *args, **kwargs):
suite = unittest.TestSuite()
if not self.selenium_only:
suite = super(SeleniumTestRunner, self).build_suite(test_labels, *args, **kwargs)
if self.selenium:
# Hack to exclude doctests from selenium-only, they are already present
from django.db.models import get_app
if test_labels:
for label in test_labels:
if not '.' in label:
app = get_app(label)
setattr(app, 'suite', unittest.TestSuite)
sel_suite = self._get_seltests(test_labels, *args, **kwargs)
suite.addTest(sel_suite)
return reorder_suite(suite, (TestCase,))
def build_suite(self, test_labels, extra_tests=None, **kwargs):
from django.apps import apps
from django.test.runner import reorder_suite
suite = self.test_suite()
if test_labels:
apps_to_test = [apps.get_app(label) for label in test_labels]
else:
apps_to_test = apps.get_apps()
# always get all features for given apps (for convenience)
for app in apps_to_test:
# Check to see if a separate 'features' module exists,
# parallel to the models module
features_dir = get_features(app)
if features_dir is not None:
# build a test suite for this directory
suite.addTest(self.make_bdd_test_suite(features_dir))
return reorder_suite(suite, self.reorder_by)
def build_suite(self, test_labels=None, extra_tests=None, **kwargs):
extra_tests = extra_tests or []
methods = self.methods.split(',') if self.methods else []
if methods:
self.use_log_files = False
discover_kwargs = {}
if self.pattern is not None:
discover_kwargs['pattern'] = self.pattern
if self.top_level is not None:
discover_kwargs['top_level_dir'] = self.top_level
suite = self._get_suite(test_labels, discover_kwargs, extra_tests,
methods)
if self.tags or self.exclude_tags:
suite = filter_tests_by_tags(suite, self.tags, self.exclude_tags)
suite = reorder_suite(suite, self.reorder_by, self.reverse)
total_tests = len(suite._tests)
suite = self._get_parallel_suite(suite)
suite.total_tests = total_tests
return suite
def build_suite(self, test_labels, extra_tests=None, **kwargs):
suite = None
discovery_root = settings.TEST_DISCOVERY_ROOT
if test_labels:
suite = defaultTestLoader.loadTestsFromNames(test_labels)
# if single named module has no tests, do discovery within it
if not suite.countTestCases() and len(test_labels) == 1:
suite = None
discovery_root = import_module(test_labels[0]).__path__[0]
if suite is None:
suite = defaultTestLoader.discover(
discovery_root,
top_level_dir=settings.BASE_PATH,
)
if extra_tests:
for test in extra_tests:
suite.addTest(test)
return reorder_suite(suite, (
TestCase,
TransactionTestCase,
))
def build_suite(self, test_labels, extra_tests=None, **kwargs):
real_parallel = self.parallel
self.parallel = 1
labels_for_suite = []
for label in test_labels:
if re.findall(r'(^[\w\d_]+(?:\.[\w\d_]+)*$)', label) == [label]:
labels_for_suite.append(label)
else:
while label:
label = '.'.join(label.split('.')[:-1])
if re.findall(r'(^[\w\d_]+(?:\.[\w\d_]+)*$)', label) == [label]:
labels_for_suite.append(label)
break
full_suite = super(RegexpTestSuiteRunner, self).build_suite(labels_for_suite, extra_tests=None, **kwargs)
my_suite = unittest.TestSuite()
labels_for_suite = []
if test_labels:
full_re = []
for label in test_labels:
if re.findall(r'(^[\w\d_]+(?:\.[\w\d_]+)*$)', label) == [label]:
labels_for_suite.append(label)
continue
text_for_re = label.replace('.', '\.').replace('*', '[^\.]+?')
if 'DiscoverRunner' in self.mro_names:
if len(label.split('.')) > 3:
text_for_re += '$'
else:
text_for_re += '\..+$'
full_re.append(text_for_re)
full_re = '(^' + ')|(^'.join(full_re) + ')' if full_re else ''
for el in full_suite._tests:
module_name = el.__module__
full_name = [module_name, el.__class__.__name__, el._testMethodName]
full_name = '.'.join(full_name)
if (full_re and re.findall(r'%s' % full_re, full_name)):
my_suite.addTest(el)
if labels_for_suite:
my_suite.addTests(ParentRunner.build_suite(self, labels_for_suite, extra_tests=None, **kwargs))
if getattr(settings, 'TEST_SKIP_SILENT', False):
my_suite = filter_suite_by_decorators(my_suite, self.verbosity)
suite = reorder_suite(my_suite, (unittest.TestCase,))
self.parallel = real_parallel
if self.parallel > 1:
parallel_suite = self.parallel_test_suite(suite, self.parallel, self.failfast)
# Since tests are distributed across processes on a per-TestCase
# basis, there's no need for more processes than TestCases.
parallel_units = len(parallel_suite.subsuites)
if self.parallel > parallel_units:
self.parallel = parallel_units
# If there's only one TestCase, parallelization isn't needed.
if self.parallel > 1:
suite = parallel_suite
return suite
def run_tests(test_labels, verbosity=1, interactive=True, extra_tests=[]):
"""
worsk exactly as per normal test
but only creates the test_db if it doesn't yet exist
and does not destroy it when done
tables are flushed and fixtures loaded between tests as per usual
but if your schema has not changed then this saves significant amounts of time
and speeds up the test cycle
Run the unit tests for all the test labels in the provided list.
Labels must be of the form:
- app.TestClass.test_method
Run a single specific test method
- app.TestClass
Run all the test methods in a given class
- app
Search for doctests and unittests in the named application.
When looking for tests, the test runner will look in the models and
tests modules for the application.
A list of 'extra' tests may also be provided; these tests
will be added to the test suite.
Returns the number of tests that failed.
"""
setup_test_environment()
settings.DEBUG = False
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
for app in get_apps():
suite.addTest(build_suite(app))
for test in extra_tests:
suite.addTest(test)
suite = reorder_suite(suite, (TestCase, ))
old_name = settings.DATABASES['default']['NAME']
###Everything up to here is from django.test.simple
from django.db.backends import creation
from django.db import connection, DatabaseError
if settings.DATABASES['default']['TEST_NAME']:
settings.DATABASES['default']['NAME'] = settings.DATABASES['default'][
'TEST_NAME']
else:
settings.DATABASES['default'][
'NAME'] = creation.TEST_DATABASE_PREFIX + settings.DATABASES[
'default']['NAME']
connection.settings_dict["DATABASE_NAME"] = settings.DATABASES['default'][
'NAME']
# does test db exist already ?
try:
if settings.DATABASES['default']['ENGINE'] == 'sqlite3':
if not os.path.exists(settings.DATABASES['default']['NAME']):
raise DatabaseError
cursor = connection.cursor()
except Exception:
# db does not exist
# juggling ! create_test_db switches the DATABASE_NAME to the TEST_DATABASE_NAME
settings.DATABASES['default']['NAME'] = old_name
connection.settings_dict["DATABASE_NAME"] = old_name
connection.creation.create_test_db(verbosity, autoclobber=True)
else:
connection.close()
settings.DATABASES['default'][
'SUPPORTS_TRANSACTIONS'] = connections_support_transactions()
result = unittest.TextTestRunner(verbosity=verbosity).run(suite)
#Since we don't call destory_test_db, we need to set the db name back.
settings.DATABASES['default']['NAME'] = old_name
connection.settings_dict["DATABASE_NAME"] = old_name
teardown_test_environment()
return len(result.failures) + len(result.errors)
def run_tests(test_labels, verbosity=1, interactive=True, extra_tests=[]):
"""
worsk exactly as per normal test
but only creates the test_db if it doesn't yet exist
and does not destroy it when done
tables are flushed and fixtures loaded between tests as per usual
but if your schema has not changed then this saves significant amounts of time
and speeds up the test cycle
Run the unit tests for all the test labels in the provided list.
Labels must be of the form:
- app.TestClass.test_method
Run a single specific test method
- app.TestClass
Run all the test methods in a given class
- app
Search for doctests and unittests in the named application.
When looking for tests, the test runner will look in the models and
tests modules for the application.
A list of 'extra' tests may also be provided; these tests
will be added to the test suite.
Returns the number of tests that failed.
"""
setup_test_environment()
settings.DEBUG = False
suite = unittest.TestSuite()
if test_labels:
for label in test_labels:
if '.' in label:
suite.addTest(build_test(label))
else:
app = get_app(label)
suite.addTest(build_suite(app))
else:
for app in get_apps():
suite.addTest(build_suite(app))
for test in extra_tests:
suite.addTest(test)
suite = reorder_suite(suite, (TestCase,))
old_name = settings.DATABASES['default']['NAME']
###Everything up to here is from django.test.simple
from django.db.backends import creation
from django.db import connection, DatabaseError
if settings.DATABASES['default']['TEST_NAME']:
settings.DATABASES['default']['NAME'] = settings.DATABASES['default']['TEST_NAME']
else:
settings.DATABASES['default']['NAME'] = creation.TEST_DATABASE_PREFIX + settings.DATABASES['default']['NAME']
connection.settings_dict["DATABASE_NAME"] = settings.DATABASES['default']['NAME']
# does test db exist already ?
try:
if settings.DATABASES['default']['ENGINE'] == 'sqlite3':
if not os.path.exists(settings.DATABASES['default']['NAME']):
raise DatabaseError
cursor = connection.cursor()
except Exception:
# db does not exist
# juggling ! create_test_db switches the DATABASE_NAME to the TEST_DATABASE_NAME
settings.DATABASES['default']['NAME'] = old_name
connection.settings_dict["DATABASE_NAME"] = old_name
connection.creation.create_test_db(verbosity, autoclobber=True)
else:
connection.close()
settings.DATABASES['default']['SUPPORTS_TRANSACTIONS'] = connections_support_transactions()
result = unittest.TextTestRunner(verbosity=verbosity).run(suite)
#Since we don't call destory_test_db, we need to set the db name back.
settings.DATABASES['default']['NAME'] = old_name
connection.settings_dict["DATABASE_NAME"] = old_name
teardown_test_environment()
return len(result.failures) + len(result.errors)
def build_suite(self, test_labels, extra_tests=None, **kwargs):
suite = super(MongoEngineTestSuiteRunner, self).build_suite(test_labels, extra_tests=None, **kwargs)
suite = self._filter_suite(suite)
return reorder_suite(suite, (testcases.TestCase,))
def build_suite(self, test_labels=None, extra_tests=None, **kwargs):
suite = self.test_suite()
test_labels = test_labels or ['.']
extra_tests = extra_tests or []
discover_kwargs = {}
if self.pattern is not None:
discover_kwargs['pattern'] = self.pattern
if self.top_level is not None:
discover_kwargs['top_level_dir'] = self.top_level
for label in test_labels:
kwargs = discover_kwargs.copy()
tests = None
label_as_path = os.path.abspath(label)
if not os.path.exists(label_as_path):
tests = self.test_loader.loadTestsFromName(label)
elif os.path.isdir(label_as_path) and not self.top_level:
top_level = label_as_path
while True:
init_py = os.path.join(top_level, '__init__.py')
if os.path.exists(init_py):
try_next = os.path.dirname(top_level)
if try_next == top_level:
break
top_level = try_next
continue
break
kwargs['top_level_dir'] = top_level
if not (tests and tests.countTestCases()) and is_discoverable(label):
tests = self.test_loader.discover(start_dir=label, **kwargs)
self.test_loader._top_level_dir = None
suite.addTests(tests)
for test in extra_tests:
suite.addTest(test)
if self.tags or self.exclude_tags:
if self.verbosity >= 2:
if self.tags:
print('Including test tag(s): %s.' % ', '.join(sorted(self.tags)))
if self.exclude_tags:
print('Excluding test tag(s): %s.' % ', '.join(sorted(self.exclude_tags)))
suite = filter_tests_by_tags(suite, self.tags, self.exclude_tags, self.require_all)
suite = reorder_suite(suite, self.reorder_by, self.reverse)
if self.parallel > 1:
parallel_suite = self.parallel_test_suite(suite, self.parallel, self.failfast)
parallel_units = len(parallel_suite.subsuites)
self.parallel = min(self.parallel, parallel_units)
if self.parallel > 1:
suite = parallel_suite
return suite
def build_suite(self, test_labels=None, extra_tests=None, **kwargs):
suite = TestSuite()
test_labels = test_labels or ['.']
extra_tests = extra_tests or []
input_test_labels = ','.join(test_labels).split(':', 1)
if len(input_test_labels) == 2:
test_labels, methods = map(lambda vals: [val for val in vals.split(',') if val], input_test_labels)
else:
test_labels, methods = input_test_labels[0].split(','), []
discover_kwargs = {}
if self.pattern is not None:
discover_kwargs['pattern'] = self.pattern
if self.top_level is not None:
discover_kwargs['top_level_dir'] = self.top_level
for label in test_labels:
kwargs = discover_kwargs.copy()
tests = None
label_as_path = os.path.abspath(label)
# if a module, or "module.ClassName[.method_name]", just run those
if not os.path.exists(label_as_path):
tests = self.test_loader.loadTestsFromName(label)
elif os.path.isdir(label_as_path) and not self.top_level:
# Try to be a bit smarter than unittest about finding the
# default top-level for a given directory path, to avoid
# breaking relative imports. (Unittest's default is to set
# top-level equal to the path, which means relative imports
# will result in "Attempted relative import in non-package.").
# We'd be happy to skip this and require dotted module paths
# (which don't cause this problem) instead of file paths (which
# do), but in the case of a directory in the cwd, which would
# be equally valid if considered as a top-level module or as a
# directory path, unittest unfortunately prefers the latter.
top_level = label_as_path
while True:
init_py = os.path.join(top_level, '__init__.py')
if os.path.exists(init_py):
try_next = os.path.dirname(top_level)
if try_next == top_level:
# __init__.py all the way down? give up.
break
top_level = try_next
continue
break
kwargs['top_level_dir'] = top_level
if not (tests and tests.countTestCases()):
# if no tests found, it's probably a package; try discovery
tests = self.test_loader.discover(start_dir=label, **kwargs)
# make unittest forget the top-level dir it calculated from this
# run, to support running tests from two different top-levels.
self.test_loader._top_level_dir = None
tests = self.get_tests_defined_in_methods_or_none(tests, methods)
if tests:
suite.addTests(tests)
for test in extra_tests:
suite.addTest(test)
return reorder_suite(suite, self.reorder_by)
def build_suite(self, test_labels=None, extra_tests=None, **kwargs):
suite = TestSuite()
test_labels = test_labels or ['.']
extra_tests = extra_tests or []
input_test_labels = ','.join(test_labels).split(':', 1)
if len(input_test_labels) == 2:
test_labels, methods = map(
lambda vals: [val for val in vals.split(',') if val],
input_test_labels)
else:
test_labels, methods = input_test_labels[0].split(','), []
discover_kwargs = {}
if self.pattern is not None:
discover_kwargs['pattern'] = self.pattern
if self.top_level is not None:
discover_kwargs['top_level_dir'] = self.top_level
for label in test_labels:
kwargs = discover_kwargs.copy()
tests = None
label_as_path = os.path.abspath(label)
# if a module, or "module.ClassName[.method_name]", just run those
if not os.path.exists(label_as_path):
tests = self.test_loader.loadTestsFromName(label)
elif os.path.isdir(label_as_path) and not self.top_level:
# Try to be a bit smarter than unittest about finding the
# default top-level for a given directory path, to avoid
# breaking relative imports. (Unittest's default is to set
# top-level equal to the path, which means relative imports
# will result in "Attempted relative import in non-package.").
# We'd be happy to skip this and require dotted module paths
# (which don't cause this problem) instead of file paths (which
# do), but in the case of a directory in the cwd, which would
# be equally valid if considered as a top-level module or as a
# directory path, unittest unfortunately prefers the latter.
top_level = label_as_path
while True:
init_py = os.path.join(top_level, '__init__.py')
if os.path.exists(init_py):
try_next = os.path.dirname(top_level)
if try_next == top_level:
# __init__.py all the way down? give up.
break
top_level = try_next
continue
break
kwargs['top_level_dir'] = top_level
if not (tests and tests.countTestCases()):
# if no tests found, it's probably a package; try discovery
tests = self.test_loader.discover(start_dir=label, **kwargs)
# make unittest forget the top-level dir it calculated from this
# run, to support running tests from two different top-levels.
self.test_loader._top_level_dir = None
tests = self.get_tests_defined_in_methods_or_none(tests, methods)
if tests:
suite.addTests(tests)
for test in extra_tests:
suite.addTest(test)
return reorder_suite(suite, self.reorder_by)
