| | import os |
| | import operator |
| | import sys |
| | import contextlib |
| | import itertools |
| | import unittest |
| | from distutils.errors import DistutilsError, DistutilsOptionError |
| | from distutils import log |
| | from unittest import TestLoader |
| |
|
| | from pkg_resources import ( |
| | resource_listdir, |
| | resource_exists, |
| | normalize_path, |
| | working_set, |
| | evaluate_marker, |
| | add_activation_listener, |
| | require, |
| | ) |
| | from .._importlib import metadata |
| | from setuptools import Command |
| | from setuptools.extern.more_itertools import unique_everseen |
| | from setuptools.extern.jaraco.functools import pass_none |
| |
|
| |
|
| | class ScanningLoader(TestLoader): |
| | def __init__(self): |
| | TestLoader.__init__(self) |
| | self._visited = set() |
| |
|
| | def loadTestsFromModule(self, module, pattern=None): |
| | """Return a suite of all tests cases contained in the given module |
| | |
| | If the module is a package, load tests from all the modules in it. |
| | If the module has an ``additional_tests`` function, call it and add |
| | the return value to the tests. |
| | """ |
| | if module in self._visited: |
| | return None |
| | self._visited.add(module) |
| |
|
| | tests = [] |
| | tests.append(TestLoader.loadTestsFromModule(self, module)) |
| |
|
| | if hasattr(module, "additional_tests"): |
| | tests.append(module.additional_tests()) |
| |
|
| | if hasattr(module, '__path__'): |
| | for file in resource_listdir(module.__name__, ''): |
| | if file.endswith('.py') and file != '__init__.py': |
| | submodule = module.__name__ + '.' + file[:-3] |
| | else: |
| | if resource_exists(module.__name__, file + '/__init__.py'): |
| | submodule = module.__name__ + '.' + file |
| | else: |
| | continue |
| | tests.append(self.loadTestsFromName(submodule)) |
| |
|
| | if len(tests) != 1: |
| | return self.suiteClass(tests) |
| | else: |
| | return tests[0] |
| |
|
| |
|
| | |
| | class NonDataProperty: |
| | def __init__(self, fget): |
| | self.fget = fget |
| |
|
| | def __get__(self, obj, objtype=None): |
| | if obj is None: |
| | return self |
| | return self.fget(obj) |
| |
|
| |
|
| | class test(Command): |
| | """Command to run unit tests after in-place build""" |
| |
|
| | description = "run unit tests after in-place build (deprecated)" |
| |
|
| | user_options = [ |
| | ('test-module=', 'm', "Run 'test_suite' in specified module"), |
| | ( |
| | 'test-suite=', |
| | 's', |
| | "Run single test, case or suite (e.g. 'module.test_suite')", |
| | ), |
| | ('test-runner=', 'r', "Test runner to use"), |
| | ] |
| |
|
| | def initialize_options(self): |
| | self.test_suite = None |
| | self.test_module = None |
| | self.test_loader = None |
| | self.test_runner = None |
| |
|
| | def finalize_options(self): |
| |
|
| | if self.test_suite and self.test_module: |
| | msg = "You may specify a module or a suite, but not both" |
| | raise DistutilsOptionError(msg) |
| |
|
| | if self.test_suite is None: |
| | if self.test_module is None: |
| | self.test_suite = self.distribution.test_suite |
| | else: |
| | self.test_suite = self.test_module + ".test_suite" |
| |
|
| | if self.test_loader is None: |
| | self.test_loader = getattr(self.distribution, 'test_loader', None) |
| | if self.test_loader is None: |
| | self.test_loader = "setuptools.command.test:ScanningLoader" |
| | if self.test_runner is None: |
| | self.test_runner = getattr(self.distribution, 'test_runner', None) |
| |
|
| | @NonDataProperty |
| | def test_args(self): |
| | return list(self._test_args()) |
| |
|
| | def _test_args(self): |
| | if not self.test_suite: |
| | yield 'discover' |
| | if self.verbose: |
| | yield '--verbose' |
| | if self.test_suite: |
| | yield self.test_suite |
| |
|
| | def with_project_on_sys_path(self, func): |
| | """ |
| | Backward compatibility for project_on_sys_path context. |
| | """ |
| | with self.project_on_sys_path(): |
| | func() |
| |
|
| | @contextlib.contextmanager |
| | def project_on_sys_path(self, include_dists=[]): |
| | self.run_command('egg_info') |
| |
|
| | |
| | self.reinitialize_command('build_ext', inplace=1) |
| | self.run_command('build_ext') |
| |
|
| | ei_cmd = self.get_finalized_command("egg_info") |
| |
|
| | old_path = sys.path[:] |
| | old_modules = sys.modules.copy() |
| |
|
| | try: |
| | project_path = normalize_path(ei_cmd.egg_base) |
| | sys.path.insert(0, project_path) |
| | working_set.__init__() |
| | add_activation_listener(lambda dist: dist.activate()) |
| | require('%s==%s' % (ei_cmd.egg_name, ei_cmd.egg_version)) |
| | with self.paths_on_pythonpath([project_path]): |
| | yield |
| | finally: |
| | sys.path[:] = old_path |
| | sys.modules.clear() |
| | sys.modules.update(old_modules) |
| | working_set.__init__() |
| |
|
| | @staticmethod |
| | @contextlib.contextmanager |
| | def paths_on_pythonpath(paths): |
| | """ |
| | Add the indicated paths to the head of the PYTHONPATH environment |
| | variable so that subprocesses will also see the packages at |
| | these paths. |
| | |
| | Do this in a context that restores the value on exit. |
| | """ |
| | nothing = object() |
| | orig_pythonpath = os.environ.get('PYTHONPATH', nothing) |
| | current_pythonpath = os.environ.get('PYTHONPATH', '') |
| | try: |
| | prefix = os.pathsep.join(unique_everseen(paths)) |
| | to_join = filter(None, [prefix, current_pythonpath]) |
| | new_path = os.pathsep.join(to_join) |
| | if new_path: |
| | os.environ['PYTHONPATH'] = new_path |
| | yield |
| | finally: |
| | if orig_pythonpath is nothing: |
| | os.environ.pop('PYTHONPATH', None) |
| | else: |
| | os.environ['PYTHONPATH'] = orig_pythonpath |
| |
|
| | @staticmethod |
| | def install_dists(dist): |
| | """ |
| | Install the requirements indicated by self.distribution and |
| | return an iterable of the dists that were built. |
| | """ |
| | ir_d = dist.fetch_build_eggs(dist.install_requires) |
| | tr_d = dist.fetch_build_eggs(dist.tests_require or []) |
| | er_d = dist.fetch_build_eggs( |
| | v |
| | for k, v in dist.extras_require.items() |
| | if k.startswith(':') and evaluate_marker(k[1:]) |
| | ) |
| | return itertools.chain(ir_d, tr_d, er_d) |
| |
|
| | def run(self): |
| | self.announce( |
| | "WARNING: Testing via this command is deprecated and will be " |
| | "removed in a future version. Users looking for a generic test " |
| | "entry point independent of test runner are encouraged to use " |
| | "tox.", |
| | log.WARN, |
| | ) |
| |
|
| | installed_dists = self.install_dists(self.distribution) |
| |
|
| | cmd = ' '.join(self._argv) |
| | if self.dry_run: |
| | self.announce('skipping "%s" (dry run)' % cmd) |
| | return |
| |
|
| | self.announce('running "%s"' % cmd) |
| |
|
| | paths = map(operator.attrgetter('location'), installed_dists) |
| | with self.paths_on_pythonpath(paths): |
| | with self.project_on_sys_path(): |
| | self.run_tests() |
| |
|
| | def run_tests(self): |
| | test = unittest.main( |
| | None, |
| | None, |
| | self._argv, |
| | testLoader=self._resolve_as_ep(self.test_loader), |
| | testRunner=self._resolve_as_ep(self.test_runner), |
| | exit=False, |
| | ) |
| | if not test.result.wasSuccessful(): |
| | msg = 'Test failed: %s' % test.result |
| | self.announce(msg, log.ERROR) |
| | raise DistutilsError(msg) |
| |
|
| | @property |
| | def _argv(self): |
| | return ['unittest'] + self.test_args |
| |
|
| | @staticmethod |
| | @pass_none |
| | def _resolve_as_ep(val): |
| | """ |
| | Load the indicated attribute value, called, as a as if it were |
| | specified as an entry point. |
| | """ |
| | return metadata.EntryPoint(value=val, name=None, group=None).load()() |
| |
|
