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)