class my_test(unittest.TestCase): def setUp(self): if not os.path.exists(self._testMethodName): os.system('mkdir %s' % self._testMethodName) # 这里依赖于命名规范,include指定要测试的文件 if self._testMethodName.startswith("test_"): include_name = self._testMethodName[5:] self.cov = Coverage(include=['comm.py', '%s.py' % include_name]) self.cov.start() return super().setUp() def test_add(self): cases = deal_case(read_file("add_test.txt", is_line=True)) for case in cases: result = add(case[0], case[1]) if 0 == result['code']: result = result['result'] self.assertEqual(result, float(case[2])) elif 1 == result['code']: result = result['msg'] self.assertEqual(result, case[2]) def tearDown(self): self.cov.stop() self.cov.save() self.cov.html_report(directory='%s' % self._testMethodName) self.cov.erase() return super().tearDown()
def run_tests(): config = utils.get_config() cov_conf_file = config.get('file_locations', 'coverage_in_conf', fallback='config/.coveragerc') cov_out_file = config.get('file_locations', 'coverage_out_dir', fallback='coverage') cov = Coverage(config_file=cov_conf_file) cov.start() result = grab_test_results() if not result.wasSuccessful(): print("Error running unit tests ...") exit(1) cov.stop() cov.save() print('Coverage Summary:') cov.report() cov.html_report(directory=cov_out_file) print('HTML version: file://{0}/{1}/index.html'.format( os.getcwd(), cov_out_file)) cov.erase() exit(0)
def generate_coverage_reports(reports_dir=COVERAGE_DIR, report="all"): ''' This task combines all the coverage data files generated during all the tests and generates the coverage reports. :param report: type of the coverage report to be generated. Options: text|html|xml. Defaults to 'html' :param reports_dir: directory under which all coverage files to be found and reports to be generated. Defaults to reports/coverage ''' print("\nInitiating code coverage analysis ...") coverage_obj = Coverage(data_file="%s/coverage" % reports_dir) coverage_obj.combine() coverage_obj.save() if report == "all": with open("%s/coverage.txt" % reports_dir, "w") as cov_rep: coverage_obj.report(file=cov_rep, show_missing=True) print("Generated Code-Coverage text report at %s/coverage.txt\n" % reports_dir) coverage_obj.html_report(directory=reports_dir) print("Generated Code-Coverage HTML report at %s\n" % reports_dir) coverage_obj.xml_report(outfile='%s/coverage.xml' % reports_dir) print("Generated Code-Coverage XML report at %s/coverage.xml\n" % reports_dir) elif report == "text": with open("%s/coverage.txt" % reports_dir, "w") as cov_rep: coverage_obj.report(file=cov_rep, show_missing=True) print("Generated Code-Coverage text report at %s/coverage.txt\n" % reports_dir) elif report == "html": coverage_obj.html_report(directory=reports_dir) print("Generated Code-Coverage HTML report at %s\n" % reports_dir) elif report == "xml": coverage_obj.xml_report(outfile='%s/coverage.xml' % reports_dir) print("Generated Code-Coverage XML report at %s/coverage.xml\n" % reports_dir)
def main(): options = parse_args() test_directory = os.path.dirname(os.path.abspath(__file__)) selected_tests = get_selected_tests(options) if options.verbose: print_to_stderr('Selected tests: {}'.format(', '.join(selected_tests))) if options.coverage and not PYTORCH_COLLECT_COVERAGE: shell(['coverage', 'erase']) if options.jit: selected_tests = filter(lambda test_name: "jit" in test_name, TESTS) if options.determine_from is not None and os.path.exists(options.determine_from): with open(options.determine_from, 'r') as fh: touched_files = [ os.path.normpath(name.strip()) for name in fh.read().split('\n') if len(name.strip()) > 0 ] # HACK: Ensure the 'test' paths can be traversed by Modulefinder sys.path.append('test') selected_tests = [ test for test in selected_tests if determine_target(test, touched_files, options) ] sys.path.remove('test') has_failed = False failure_messages = [] try: for test in selected_tests: options_clone = copy.deepcopy(options) if test in USE_PYTEST_LIST: options_clone.pytest = True err_message = run_test_module(test, test_directory, options_clone) if err_message is None: continue has_failed = True failure_messages.append(err_message) if not options_clone.continue_through_error: raise RuntimeError(err_message) print_to_stderr(err_message) finally: if options.coverage: from coverage import Coverage test_dir = os.path.dirname(os.path.abspath(__file__)) with set_cwd(test_dir): cov = Coverage() if PYTORCH_COLLECT_COVERAGE: cov.load() cov.combine(strict=False) cov.save() if not PYTORCH_COLLECT_COVERAGE: cov.html_report() if options.continue_through_error and has_failed: for err in failure_messages: print_to_stderr(err) sys.exit(1)
class TestsSuite: CONFIG_FILE = ".coveragerc" is_tests_suite_run: bool = False console_log_level: LogLevelEnum = LogLevelEnum.INFO file_log_level: LogLevelEnum = LogLevelEnum.DEBUG log_file_path: str = None __coverage: Coverage = None __is_coverage: bool def __init__(self, is_coverage: bool = False): self.__coverage = Coverage(config_file=self.CONFIG_FILE) self.__is_coverage = is_coverage TestsSuite.is_tests_suite_run = True init_logger(self.console_log_level, self.file_log_level) def run_tests(self): if self.__is_coverage: self.__coverage.start() tests = unittest.TestLoader().discover(start_dir='.', pattern='*_test.py') unittest.TextTestRunner(verbosity=2).run(tests) if self.__is_coverage: self.__coverage.stop() def create_report(self): self.__coverage.report() self.__coverage.json_report() self.__coverage.html_report() def erase_data(self): self.__coverage.erase()
def main(): os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'webshop_drf.settings') # run coverage.py around tests automatically try: command = sys.argv[1] except IndexError: command = "help" running_tests = (command == 'test') if running_tests: from coverage import Coverage cov = Coverage() cov.erase() cov.start() try: from django.core.management import execute_from_command_line except ImportError as exc: raise ImportError( "Couldn't import Django. Are you sure it's installed and " "available on your PYTHONPATH environment variable? Did you " "forget to activate a virtual environment?") from exc execute_from_command_line(sys.argv) if running_tests: cov.stop() cov.save() cov.html_report() covered = cov.report() if covered < 100: sys.exit(1)
def coverage(): from coverage import Coverage cover = Coverage() cover.start() failures = run() cover.stop() cover.save() cover.html_report() return failures
def main(): """ The main function, mainly functioning to do the main functional work (thanks pylint) """ if len(sys.argv) > 1 and sys.argv[1] == 'cover': # FIXME - there are enough args now to need an arg parser cover = Coverage( branch=True, auto_data=True, omit=[ "/usr/share/pyshared/*", "/usr/lib/python3/dist-packages/*", ], ) min_percent = 0 if len(sys.argv) > 2: min_percent = float(sys.argv[2]) else: cover = False loader = unittest.defaultTestLoader runner = unittest.TextTestRunner(verbosity=2) if cover: cover.erase() cover.start() tests = loader.discover('.') # If we ever drop libraries into the 'lib' subdir defined in the above # sys.path.insert then we will need to discover their tests and add # them separately with the following: tests_lib = loader.discover('lib', top_level_dir='lib') tests.addTests(tests_lib) result = runner.run(tests) if cover: cover.stop() # the debian coverage package didnt include jquery.debounce.min.js # (and additionally, that thing is not packaged for debian elsewhere) try: cover.html_report() except Exception: pass percent = cover.report(show_missing=True) if min_percent > percent: err_fmt = "The coverage ({:.1f}% reached) fails to reach the minimum required ({}%)\n" # noqa sys.stderr.write(err_fmt.format(percent, min_percent)) exit(1) if not result.wasSuccessful(): exit(1)
def run(self): from coverage import Coverage cov = Coverage(source=self.distribution.packages) cov.start() super().run() cov.stop() cov.xml_report() cov.html_report()
def run(self): from coverage import Coverage cov = Coverage(source=self.distribution.packages) cov.start() super().run() cov.stop() cov.xml_report() cov.html_report()
def coverage(): if "--coverage" in sys.argv: cover = Coverage(source=["ls.joyous"]) cover.start() failures = run() cover.stop() cover.save() cover.html_report() else: failures = run() return failures
def main(): options = parse_args() test_directory = str(REPO_ROOT / "test") selected_tests = get_selected_tests(options) if options.verbose: print_to_stderr("Selected tests:\n {}".format( "\n ".join(selected_tests))) if options.dry_run: return if options.coverage and not PYTORCH_COLLECT_COVERAGE: shell(["coverage", "erase"]) if IS_CI: selected_tests = get_reordered_tests(selected_tests) # downloading test cases configuration to local environment get_test_case_configs(dirpath=test_directory) has_failed = False failure_messages = [] try: for test in selected_tests: options_clone = copy.deepcopy(options) if test in USE_PYTEST_LIST: options_clone.pytest = True err_message = run_test_module(test, test_directory, options_clone) if err_message is None: continue has_failed = True failure_messages.append(err_message) if not options_clone.continue_through_error: raise RuntimeError(err_message) print_to_stderr(err_message) finally: if options.coverage: from coverage import Coverage with set_cwd(test_directory): cov = Coverage() if PYTORCH_COLLECT_COVERAGE: cov.load() cov.combine(strict=False) cov.save() if not PYTORCH_COLLECT_COVERAGE: cov.html_report() if options.continue_through_error and has_failed: for err in failure_messages: print_to_stderr(err) sys.exit(1)
def run(self): import pytest cov = Coverage() cov.erase() cov.start() result = pytest.main() cov.stop() cov.save() cov.html_report(directory="covhtml") sys.exit(int(bool(len(result.failures) > 0 or len(result.errors) > 0)))
def run(self): import pytest cov = Coverage() cov.erase() cov.start() result = pytest.main() cov.stop() cov.save() cov.html_report(directory="covhtml") sys.exit(int(bool(len(result.failures) > 0 or len(result.errors) > 0)))
def run_test_suite(): cov = Coverage(config_file=True) cov.erase() cov.start() # Announce the test suite sys.stdout.write(colored(text="\nWelcome to the ", color="magenta", attrs=["bold"])) sys.stdout.write(colored(text="python-doc-inherit", color="green", attrs=["bold"])) sys.stdout.write(colored(text=" test suite.\n\n", color="magenta", attrs=["bold"])) # Announce test run print(colored(text="Step 1: Running unit tests.\n", color="yellow", attrs=["bold"])) test_suite = TestLoader().discover(str(Path("tests").absolute())) result = TextTestRunner(verbosity=1).run(test_suite) if not result.wasSuccessful(): sys.exit(len(result.failures) + len(result.errors)) # Announce coverage run print(colored(text="\nStep 2: Generating coverage results.\n", color="yellow", attrs=["bold"])) cov.stop() percentage = round(cov.report(show_missing=True), 2) cov.html_report(directory='cover') cov.save() if percentage < TESTS_THRESHOLD: print(colored(text="YOUR CHANGES HAVE CAUSED TEST COVERAGE TO DROP. " + "WAS {old}%, IS NOW {new}%.\n".format(old=TESTS_THRESHOLD, new=percentage), color="red", attrs=["bold"])) sys.exit(1) # Announce flake8 run sys.stdout.write(colored(text="\nStep 3: Checking for pep8 errors.\n\n", color="yellow", attrs=["bold"])) print("pep8 errors:") print("----------------------------------------------------------------------") from subprocess import call flake_result = call(["flake8", ".", "--count"]) if flake_result != 0: print("pep8 errors detected.") print(colored(text="\nYOUR CHANGES HAVE INTRODUCED PEP8 ERRORS!\n", color="red", attrs=["bold"])) sys.exit(flake_result) else: print("None") # Announce success print(colored(text="\nTests completed successfully with no errors. Congrats!", color="green", attrs=["bold"]))
def run_test_suite(): cov = Coverage(config_file=True) cov.erase() cov.start() # Announce the test suite sys.stdout.write(colored(text="\nWelcome to the ", color="magenta", attrs=["bold"])) sys.stdout.write(colored(text="python-xirsys", color="green", attrs=["bold"])) sys.stdout.write(colored(text=" test suite.\n\n", color="magenta", attrs=["bold"])) # Announce test run print(colored(text="Step 1: Running unit tests.\n", color="yellow", attrs=["bold"])) test_suite = TestLoader().discover(str(Path("tests").absolute())) result = TextTestRunner(verbosity=1).run(test_suite) if not result.wasSuccessful(): sys.exit(len(result.failures) + len(result.errors)) # Announce coverage run print(colored(text="\nStep 2: Generating coverage results.\n", color="yellow", attrs=["bold"])) cov.stop() percentage = round(cov.report(show_missing=True), 2) cov.html_report(directory='cover') cov.save() if percentage < TESTS_THRESHOLD: print(colored(text="YOUR CHANGES HAVE CAUSED TEST COVERAGE TO DROP. " + "WAS {old}%, IS NOW {new}%.\n".format(old=TESTS_THRESHOLD, new=percentage), color="red", attrs=["bold"])) sys.exit(1) # Announce flake8 run sys.stdout.write(colored(text="\nStep 3: Checking for pep8 errors.\n\n", color="yellow", attrs=["bold"])) print("pep8 errors:") print("----------------------------------------------------------------------") from subprocess import call flake_result = call(["flake8", ".", "--count"]) if flake_result != 0: print("pep8 errors detected.") print(colored(text="\nYOUR CHANGES HAVE INTRODUCED PEP8 ERRORS!\n", color="red", attrs=["bold"])) sys.exit(flake_result) else: print("None") # Announce success print(colored(text="\nTests completed successfully with no errors. Congrats!", color="green", attrs=["bold"]))
def run(self): tests = unittest.TestLoader().discover("tests", pattern="*[t|T]est*.py") runner = unittest.TextTestRunner(verbosity=1) cov = Coverage() cov.erase() cov.start() result = runner.run(tests) cov.stop() cov.save() cov.html_report(directory="covhtml") sys.exit(int(bool(len(result.failures) > 0 or len(result.errors) > 0)))
def with_coverage(f, source, *, report=True, data=False): cov = Coverage(source=[source]) cov.start() try: exit_code = f() finally: cov.stop() if not exit_code: if report: print() # Print blank line. cov.report(show_missing=False) cov.html_report() if data: cov.save() return exit_code
def generate_coverage_report(): """ Runs all tests in a Code Coverage context and generates a report. """ cov = Coverage() cov.start() from unittest import TestLoader, TextTestRunner test_all() cov.stop() cov.save() cov.html_report(directory="htmlcov")
def coverage(ctx, html): """输出覆盖率测试""" cov = Coverage(source=["app", "commands", "routes/", "models"], omit=["*__init__*"]) cov.start() # 触发测试命令 ctx.invoke(test) cov.stop() cov.save() click.echo('Coverage summary:') cov.report() if html: cov.html_report(directory="reports/coverage/") cov.erase()
def coverageReportHelper(config, dataPaths): """ Small utility function to generate coverage reports. This was created to side-step the difficulties in submitting multi-line python commands on-the-fly. This combines data paths and then makes html and xml reports for the fully-combined result. """ from coverage import Coverage import coverage try: cov = Coverage(config_file=config) if dataPaths: # fun fact: if you combine when there's only one file, it gets deleted. cov.combine(data_paths=dataPaths) cov.save() else: cov.load() cov.html_report() cov.xml_report() except PermissionError: # Albert has some issues with filename that start with a '.', such as the # .coverage files. If a permissions error is raised, it likely has something to # do with that. We changed the COVERAGE_RESULTS_FILE in cases.py for this reason. # # We print here, since this is used to run a one-off command, so runLog isn't # really appropriate. print( "There was an issue in generating coverage reports. Probably related to " "Albert hidden file issues." ) # disabled until we figure out the problem. # raise except coverage.misc.CoverageException as e: # This is happening when forming the unit test coverage report. This may be # caused by the TestFixture coverage report gobbling up all of the coverage # files before the UnitTests.cov_report task gets a chance to see them. It may # simply be that we dont want a coverage report generated for the TestFixture. # Something to think about. Either way, we do not want to fail the job just # because of this print( "There was an issue generating coverage reports " "({}):\n{}".format(type(e), e.args) )
def main(): """ The main function, mainly functioning to do the main functional work (thanks pylint) """ if len(sys.argv) > 1 and sys.argv[1] == 'cover': # FIXME - there are enough args now to need an arg parser cover = Coverage(branch=True, auto_data=True) min_percent = 0 if len(sys.argv) > 2: min_percent = float(sys.argv[2]) else: cover = False loader = unittest.defaultTestLoader runner = unittest.TextTestRunner(verbosity=2) if cover: cover.erase() cover.start() tests = loader.discover('.') tests_lib = loader.discover('lib', top_level_dir='lib') tests.addTests(tests_lib) result = runner.run(tests) if cover: cover.stop() # the debian coverage package didnt include jquery.debounce.min.js # (and additionally, that thing is not packaged for debian elsewhere) try: cover.html_report() except: # noqa pylint: disable=bare-except pass # TODO - reconfirm that this packaging issue is still the case # if it is not, remove the try..except # if it is, add the specific exception percent = cover.report(show_missing=True) if min_percent > percent: print("The coverage ({:.1f}% reached) fails to reach the " "minimum required ({}%)\n".format(percent, min_percent)) exit(1) if not result.wasSuccessful(): exit(1)
def coverage(): """Check coverage and generate reports""" # coverage run --source=./app/main -m unittest discover -s ./app try: cov = Coverage() print("Starte Ueberpruefung der Coverage") cov.start() test() cov.stop() print("Tests erfolgreich ausgefuehrt und gespeichert.") cov.save() print("Erstelle HTML Report") cov.html_report() return 0 except Exception as e: print(f"Error beim erstellen der Coverage: {e}") return 1
def test_with_coverage(): """ Runs the Unit Tests with Coverage. """ # Configure Code Coverage Reports if app.config.get('FLASK_COVERAGE'): from coverage import Coverage # Start coverage engine, enable branch coverage analytics # Limit analysis to files inside application package. cov = Coverage(branch=True, include='myapp/*') cov.start() import unittest tests = unittest.TestLoader().discover('tests') unittest.TextTestRunner(verbosity=2).run(tests) cov.stop() cov.save() print('Coverage Summary') cov.report() cov.html_report(directory='covhtml') cov.erase()
def produce_coverage_reports(coverdir): cov = Coverage(data_file='coverage') cov.combine(data_paths=[os.path.join(coverdir, 'data')]) pydirs = [os.path.join(ROOT, d) for d in PYTHON_COVERAGE_DIRS] omit = [os.path.join(ROOT, d) for d in COVERAGE_OMIT] # Ensure all .py files show up in coverage report. for d in pydirs: for root, dirs, files in os.walk(d): for f in files: if f.endswith('.py'): cov.data.touch_file(os.path.join(root, f)) cov.html_report(directory=os.path.join(coverdir, 'html'), ignore_errors=True, omit=omit) cov.xml_report(outfile=os.path.join(coverdir, 'coverage.xml'), ignore_errors=True, omit=omit)
def run(self) -> None: from coverage import Coverage cov = Coverage() failed_message: Optional[str] = None cov.start() try: self.run_command('test') except DistutilsError as exc: failed_message = str(exc) finally: cov.save() cov.report() cov.html_report() if failed_message: raise DistutilsError(f'tests failed: {failed_message}')
class AutotestConfig(AppConfig): name = 'autotest' def __init__(self, *args, **kwargs): super(AutotestConfig, self).__init__(*args, **kwargs) self.coverage = None def coverage_start(self): if coverage and not self.coverage: self.coverage = Coverage() self.coverage.start() return self.coverage def coverage_report(self): if coverage and self.coverage: self.coverage.stop() coverage.stop() self.coverage.get_data().update(coverage.get_data()) self.coverage.html_report()
def main(): """ The main function, mainly functioning to do the main functional work (thanks pylint) """ if len(sys.argv) > 1 and sys.argv[1] == 'cover': # FIXME - there are enough args now to need an arg parser cover = Coverage(branch=True, auto_data=True) min_percent = 0 if len(sys.argv) > 2: min_percent = float(sys.argv[2]) else: cover = False loader = unittest.defaultTestLoader runner = unittest.TextTestRunner(verbosity=2) if cover: cover.erase() cover.start() tests = loader.discover('.') tests_lib = loader.discover('lib', top_level_dir='lib') tests.addTests(tests_lib) result = runner.run(tests) if cover: cover.stop() # the debian coverage package didnt include jquery.debounce.min.js # (and additionally, that thing is not packaged for debian elsewhere) try: cover.html_report() except: pass percent = cover.report(show_missing=True) if min_percent > percent: print("The coverage ({:.1f}% reached) fails to reach the " "minimum required ({}%)\n".format(percent, min_percent)) exit(1) if not result.wasSuccessful(): exit(1)
class AutotestConfig(AppConfig): name = 'autotest' def __init__(self, *args, **kwargs): super(AutotestConfig, self).__init__(*args, **kwargs) self.coverage = None def coverage_start(self): if coverage and not self.coverage: self.coverage = Coverage() self.coverage.start() return self.coverage def coverage_report(self): if coverage and self.coverage: self.coverage.stop() coverage.stop() self.coverage.get_data().update(coverage.get_data()) self.coverage.html_report()
def unittest(_dir, verbose, _coverage): import os import unittest if _coverage: from coverage import Coverage cov = Coverage() cov.start() if os.path.isdir(_dir): testsuite = unittest.TestLoader().discover(".") else: testsuite = unittest.TestLoader().loadTestsFromName(_dir) unittest.TextTestRunner(verbosity=verbose).run(testsuite) if _coverage: cov.stop() cov.html_report(directory="coverage_html") click.echo("Open coverage_html/index.html")
def run_tests(self, *args, **kwargs): suite_result = super().run_tests(*args, **kwargs) cov = getattr(process_startup, "coverage") cov.stop() cov.save() print() print("Generating Coverage Report...") combined_cov = Coverage() combined_cov.load() combined_cov.combine() combined_cov.report() combined_cov.html_report() print() print("Linting files...") subprocess.call(["flake8"]) return suite_result
def main(): """Run administrative tasks.""" os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'config.settings') # ******* CREDIT *********** # https://adamj.eu/tech/2019/04/30/getting-a-django-application-to-100-percent-coverage/ # MyProject Customization: run coverage.py around tests automatically try: command = sys.argv[1] except IndexError: command = "help" running_tests = (command == 'test') if running_tests: from coverage import Coverage cov = Coverage() cov.erase() cov.start() # ************************** try: from django.core.management import execute_from_command_line except ImportError as exc: raise ImportError( "Couldn't import Django. Are you sure it's installed and " "available on your PYTHONPATH environment variable? Did you " "forget to activate a virtual environment?") from exc execute_from_command_line(sys.argv) # **************************** if running_tests: cov.stop() cov.save() # see credits in README.md for the next line cov.html_report(directory='covhtml') covered = cov.report() if covered < 100: sys.exit(1)
def main(): options = parse_args() # TODO: move this export & download function in tools/ folder test_times_filename = options.export_past_test_times if test_times_filename: print( f"Exporting past test times from S3 to {test_times_filename}, no tests will be run." ) export_S3_test_times(test_times_filename) return specified_test_cases_filename = options.run_specified_test_cases if specified_test_cases_filename: print( f"Loading specified test cases to run from {specified_test_cases_filename}." ) global SPECIFIED_TEST_CASES_DICT SPECIFIED_TEST_CASES_DICT = get_specified_test_cases( specified_test_cases_filename, TESTS ) test_directory = str(REPO_ROOT / "test") selected_tests = get_selected_tests(options) if options.verbose: print_to_stderr("Selected tests:\n {}".format("\n ".join(selected_tests))) if options.dry_run: return if options.coverage and not PYTORCH_COLLECT_COVERAGE: shell(["coverage", "erase"]) # NS: Disable target determination until it can be made more reliable # if options.determine_from is not None and os.path.exists(options.determine_from): # slow_tests = get_slow_tests_based_on_S3( # TESTS, TARGET_DET_LIST, SLOW_TEST_THRESHOLD # ) # print_to_stderr( # "Added the following tests to target_det tests as calculated based on S3:" # ) # print_to_stderr(slow_tests) # with open(options.determine_from, "r") as fh: # touched_files = [ # os.path.normpath(name.strip()) # for name in fh.read().split("\n") # if len(name.strip()) > 0 # ] # # HACK: Ensure the 'test' paths can be traversed by Modulefinder # sys.path.append(test_directory) # selected_tests = [ # test # for test in selected_tests # if should_run_test( # TARGET_DET_LIST + slow_tests, test, touched_files, options # ) # ] # sys.path.remove(test_directory) if IS_IN_CI: selected_tests = get_reordered_tests( selected_tests, ENABLE_PR_HISTORY_REORDERING ) # downloading test cases configuration to local environment get_test_case_configs(dirpath=test_directory) has_failed = False failure_messages = [] try: for test in selected_tests: options_clone = copy.deepcopy(options) if test in USE_PYTEST_LIST: options_clone.pytest = True err_message = run_test_module(test, test_directory, options_clone) if err_message is None: continue has_failed = True failure_messages.append(err_message) if not options_clone.continue_through_error: raise RuntimeError(err_message) print_to_stderr(err_message) finally: if options.coverage: from coverage import Coverage with set_cwd(test_directory): cov = Coverage() if PYTORCH_COLLECT_COVERAGE: cov.load() cov.combine(strict=False) cov.save() if not PYTORCH_COLLECT_COVERAGE: cov.html_report() if options.continue_through_error and has_failed: for err in failure_messages: print_to_stderr(err) sys.exit(1)
class CoverageScript(object): """The command-line interface to coverage.py.""" def __init__(self): self.global_option = False self.coverage = None def command_line(self, argv): """The bulk of the command line interface to coverage.py. `argv` is the argument list to process. Returns 0 if all is well, 1 if something went wrong. """ # Collect the command-line options. if not argv: show_help(topic='minimum_help') return OK # The command syntax we parse depends on the first argument. Global # switch syntax always starts with an option. self.global_option = argv[0].startswith('-') if self.global_option: parser = GlobalOptionParser() else: parser = CMDS.get(argv[0]) if not parser: show_help("Unknown command: '%s'" % argv[0]) return ERR argv = argv[1:] ok, options, args = parser.parse_args_ok(argv) if not ok: return ERR # Handle help and version. if self.do_help(options, args, parser): return OK # Listify the list options. source = unshell_list(options.source) omit = unshell_list(options.omit) include = unshell_list(options.include) debug = unshell_list(options.debug) contexts = unshell_list(options.contexts) # Do something. self.coverage = Coverage( data_suffix=options.parallel_mode, cover_pylib=options.pylib, timid=options.timid, branch=options.branch, config_file=options.rcfile, source=source, omit=omit, include=include, debug=debug, concurrency=options.concurrency, check_preimported=True, context=options.context, ) if options.action == "debug": return self.do_debug(args) elif options.action == "erase": self.coverage.erase() return OK elif options.action == "run": return self.do_run(options, args) elif options.action == "combine": if options.append: self.coverage.load() data_dirs = args or None self.coverage.combine(data_dirs, strict=True) self.coverage.save() return OK # Remaining actions are reporting, with some common options. report_args = dict( morfs=unglob_args(args), ignore_errors=options.ignore_errors, omit=omit, include=include, contexts=contexts, ) # We need to be able to import from the current directory, because # plugins may try to, for example, to read Django settings. sys.path.insert(0, '') self.coverage.load() total = None if options.action == "report": total = self.coverage.report(show_missing=options.show_missing, skip_covered=options.skip_covered, **report_args) elif options.action == "annotate": self.coverage.annotate(directory=options.directory, **report_args) elif options.action == "html": total = self.coverage.html_report( directory=options.directory, title=options.title, skip_covered=options.skip_covered, show_contexts=options.show_contexts, **report_args) elif options.action == "xml": outfile = options.outfile total = self.coverage.xml_report(outfile=outfile, **report_args) if total is not None: # Apply the command line fail-under options, and then use the config # value, so we can get fail_under from the config file. if options.fail_under is not None: self.coverage.set_option("report:fail_under", options.fail_under) fail_under = self.coverage.get_option("report:fail_under") precision = self.coverage.get_option("report:precision") if should_fail_under(total, fail_under, precision): return FAIL_UNDER return OK def do_help(self, options, args, parser): """Deal with help requests. Return True if it handled the request, False if not. """ # Handle help. if options.help: if self.global_option: show_help(topic='help') else: show_help(parser=parser) return True if options.action == "help": if args: for a in args: parser = CMDS.get(a) if parser: show_help(parser=parser) else: show_help(topic=a) else: show_help(topic='help') return True # Handle version. if options.version: show_help(topic='version') return True return False def do_run(self, options, args): """Implementation of 'coverage run'.""" if not args: if options.module: # Specified -m with nothing else. show_help("No module specified for -m") return ERR command_line = self.coverage.get_option("run:command_line") if command_line is not None: args = shlex.split(command_line) if args and args[0] == "-m": options.module = True args = args[1:] if not args: show_help("Nothing to do.") return ERR if options.append and self.coverage.get_option("run:parallel"): show_help("Can't append to data files in parallel mode.") return ERR if options.concurrency == "multiprocessing": # Can't set other run-affecting command line options with # multiprocessing. for opt_name in [ 'branch', 'include', 'omit', 'pylib', 'source', 'timid' ]: # As it happens, all of these options have no default, meaning # they will be None if they have not been specified. if getattr(options, opt_name) is not None: show_help( "Options affecting multiprocessing must only be specified " "in a configuration file.\n" "Remove --{} from the command line.".format(opt_name)) return ERR runner = PyRunner(args, as_module=bool(options.module)) runner.prepare() if options.append: self.coverage.load() # Run the script. self.coverage.start() code_ran = True try: runner.run() except NoSource: code_ran = False raise finally: self.coverage.stop() if code_ran: self.coverage.save() return OK def do_debug(self, args): """Implementation of 'coverage debug'.""" if not args: show_help("What information would you like: config, data, sys?") return ERR for info in args: if info == 'sys': sys_info = self.coverage.sys_info() print(info_header("sys")) for line in info_formatter(sys_info): print(" %s" % line) elif info == 'data': self.coverage.load() data = self.coverage.get_data() print(info_header("data")) print("path: %s" % self.coverage.get_data().data_filename()) if data: print("has_arcs: %r" % data.has_arcs()) summary = line_counts(data, fullpath=True) filenames = sorted(summary.keys()) print("\n%d files:" % len(filenames)) for f in filenames: line = "%s: %d lines" % (f, summary[f]) plugin = data.file_tracer(f) if plugin: line += " [%s]" % plugin print(line) else: print("No data collected") elif info == 'config': print(info_header("config")) config_info = self.coverage.config.__dict__.items() for line in info_formatter(config_info): print(" %s" % line) else: show_help("Don't know what you mean by %r" % info) return ERR return OK
mod = __import__(t, globals(), locals(), ['suite']) suitefn = getattr(mod, 'suite') suite.addTest(suitefn()) except (ImportError, AttributeError): # else, just load all the test cases from the module. suite.addTest(unittest.defaultTestLoader.loadTestsFromName(t)) runner = unittest.TextTestRunner() cov.start() result = runner.run(suite) cov.stop() if not result.wasSuccessful(): exit(3) percent = round(cov.report(), 4) cov.html_report() if os.path.isfile('min_cov.txt'): file = open('min_cov.txt', 'r') min_coverage = float(file.read()) file.close() if percent < min_coverage: exit(2) else: file = open('min_cov.txt', 'w') file.write(str(percent)) file.close() else: file = open('min_cov.txt', 'w') file.write(str(percent)) file.close()
def run_test_suite(args): enable_coverage = not args.no_coverage tests = args.tests if enable_coverage: cov = Coverage(config_file=True) cov.erase() cov.start() settings.configure( DEBUG=True, USE_TZ=True, TIME_ZONE="UTC", SITE_ID=1, DATABASES={ "default": { "ENGINE": "django.db.backends.postgresql_psycopg2", "NAME": "djstripe", "USER": "******", "PASSWORD": "", "HOST": "localhost", "PORT": "", }, }, TEMPLATES=[ { 'BACKEND': 'django.template.backends.django.DjangoTemplates', 'DIRS': [], 'APP_DIRS': True, 'OPTIONS': { 'context_processors': [ 'django.contrib.auth.context_processors.auth', ], }, }, ], ROOT_URLCONF="tests.test_urls", INSTALLED_APPS=[ "django.contrib.admin", "django.contrib.auth", "django.contrib.contenttypes", "django.contrib.sessions", "django.contrib.sites", "jsonfield", "djstripe", "tests", "tests.apps.testapp" ], MIDDLEWARE=( "django.contrib.sessions.middleware.SessionMiddleware", "django.contrib.auth.middleware.AuthenticationMiddleware", "django.contrib.messages.middleware.MessageMiddleware" ), STRIPE_PUBLIC_KEY=os.environ.get("STRIPE_PUBLIC_KEY", ""), STRIPE_SECRET_KEY=os.environ.get("STRIPE_SECRET_KEY", ""), DJSTRIPE_PLANS={ "test0": { "stripe_plan_id": "test_id_0", "name": "Test Plan 0", "description": "A test plan", "price": 1000, # $10.00 "currency": "usd", "interval": "month" }, "test": { "stripe_plan_id": "test_id", "name": "Test Plan 1", "description": "Another test plan", "price": 2500, # $25.00 "currency": "usd", "interval": "month" }, "test2": { "stripe_plan_id": "test_id_2", "name": "Test Plan 2", "description": "Yet Another test plan", "price": 5000, # $50.00 "currency": "usd", "interval": "month" }, "test_deletion": { "stripe_plan_id": "test_id_3", "name": "Test Plan 3", "description": "Test plan for deletion.", "price": 5000, # $50.00 "currency": "usd", "interval": "month" }, "test_trial": { "stripe_plan_id": "test_id_4", "name": "Test Plan 4", "description": "Test plan for trails.", "price": 7000, # $70.00 "currency": "usd", "interval": "month", "trial_period_days": 7 }, "unidentified_test_plan": { "name": "Unidentified Test Plan", "description": "A test plan with no ID.", "price": 2500, # $25.00 "currency": "usd", "interval": "month" } }, DJSTRIPE_SUBSCRIPTION_REQUIRED_EXCEPTION_URLS=( "(admin)", "test_url_name", "testapp_namespaced:test_url_namespaced", "fn:/test_fnmatch*" ), DJSTRIPE_USE_NATIVE_JSONFIELD=os.environ.get("USE_NATIVE_JSONFIELD", "") == "1", ) # Avoid AppRegistryNotReady exception # http://stackoverflow.com/questions/24793351/django-appregistrynotready if hasattr(django, "setup"): django.setup() # Announce the test suite sys.stdout.write(colored(text="\nWelcome to the ", color="magenta", attrs=["bold"])) sys.stdout.write(colored(text="dj-stripe", color="green", attrs=["bold"])) sys.stdout.write(colored(text=" test suite.\n\n", color="magenta", attrs=["bold"])) # Announce test run sys.stdout.write(colored(text="Step 1: Running unit tests.\n\n", color="yellow", attrs=["bold"])) # Hack to reset the global argv before nose has a chance to grab it # http://stackoverflow.com/a/1718407/1834570 args = sys.argv[1:] sys.argv = sys.argv[0:1] from django_nose import NoseTestSuiteRunner test_runner = NoseTestSuiteRunner(verbosity=1, keepdb=True, failfast=True) failures = test_runner.run_tests(tests) if failures: sys.exit(failures) if enable_coverage: # Announce coverage run sys.stdout.write(colored(text="\nStep 2: Generating coverage results.\n\n", color="yellow", attrs=["bold"])) cov.stop() percentage = round(cov.report(show_missing=True), 2) cov.html_report(directory='cover') cov.save() if percentage < TESTS_THRESHOLD: sys.stderr.write(colored(text="YOUR CHANGES HAVE CAUSED TEST COVERAGE TO DROP. " + "WAS {old}%, IS NOW {new}%.\n\n".format(old=TESTS_THRESHOLD, new=percentage), color="red", attrs=["bold"])) sys.exit(1) else: # Announce disabled coverage run sys.stdout.write(colored(text="\nStep 2: Generating coverage results [SKIPPED].", color="yellow", attrs=["bold"])) # Announce success if enable_coverage: sys.stdout.write(colored(text="\nTests completed successfully with no errors. Congrats!\n", color="green", attrs=["bold"])) else: sys.stdout.write(colored(text="\nTests completed successfully, but some step(s) were skipped!\n", color="green", attrs=["bold"])) sys.stdout.write(colored(text="Don't push without running the skipped step(s).\n", color="red", attrs=["bold"]))
smach.StateMachine.add('Timeout3',Timeout(), transitions={'outcome1':'Discard'}) #Decide what to do smach.StateMachine.add('Decide', Decide(), transitions={'outcome1':'Release','outcome2':'Discard'}) #Release piece smach.StateMachine.add('Release', Release(), transitions={'outcome1':'Receive1','outcome2':'tableDone'}) #Discard piece smach.StateMachine.add('Discard', Discard(), transitions={'outcome1':'Receive1','outcome2':'tableDone'}) # Execute SMACH plan outcome = sm.execute() #--------------------------------------------------------------------------------------------------- if __name__ == '__main__': cov = Coverage() cov.start() try: main(sys.argv[1]) cov.stop() cov.html_report(directory='covhtml') except rospy.ROSInterruptException: #to stop the code when pressing Ctr+c cov.stop() cov.save() cov.report_html() pass
def main(): options = parse_args() # TODO: move this export & download function in tools/ folder test_times_filename = options.export_past_test_times if test_times_filename: print( f'Exporting past test times from S3 to {test_times_filename}, no tests will be run.' ) export_S3_test_times(test_times_filename) return specified_test_cases_filename = options.run_specified_test_cases if specified_test_cases_filename: print( f'Loading specified test cases to run from {specified_test_cases_filename}.' ) global SPECIFIED_TEST_CASES_DICT SPECIFIED_TEST_CASES_DICT = get_specified_test_cases( specified_test_cases_filename, TESTS) test_directory = os.path.dirname(os.path.abspath(__file__)) selected_tests = get_selected_tests(options) if options.verbose: print_to_stderr('Selected tests: {}'.format(', '.join(selected_tests))) if options.coverage and not PYTORCH_COLLECT_COVERAGE: shell(['coverage', 'erase']) if options.jit: selected_tests = filter(lambda test_name: "jit" in test_name, TESTS) if options.determine_from is not None and os.path.exists( options.determine_from): slow_tests = get_slow_tests_based_on_S3(TESTS, TARGET_DET_LIST, SLOW_TEST_THRESHOLD) print( 'Added the following tests to target_det tests as calculated based on S3:' ) print(slow_tests) with open(options.determine_from, 'r') as fh: touched_files = [ os.path.normpath(name.strip()) for name in fh.read().split('\n') if len(name.strip()) > 0 ] # HACK: Ensure the 'test' paths can be traversed by Modulefinder sys.path.append('test') selected_tests = [ test for test in selected_tests if determine_target(TARGET_DET_LIST + slow_tests, test, touched_files, options) ] sys.path.remove('test') if IS_IN_CI: selected_tests = get_reordered_tests(selected_tests, ENABLE_PR_HISTORY_REORDERING) # downloading test cases configuration to local environment get_test_case_configs( dirpath=os.path.dirname(os.path.abspath(__file__))) has_failed = False failure_messages = [] try: for test in selected_tests: options_clone = copy.deepcopy(options) if test in USE_PYTEST_LIST: options_clone.pytest = True err_message = run_test_module(test, test_directory, options_clone) if err_message is None: continue has_failed = True failure_messages.append(err_message) if not options_clone.continue_through_error: raise RuntimeError(err_message) print_to_stderr(err_message) finally: if options.coverage: from coverage import Coverage test_dir = os.path.dirname(os.path.abspath(__file__)) with set_cwd(test_dir): cov = Coverage() if PYTORCH_COLLECT_COVERAGE: cov.load() cov.combine(strict=False) cov.save() if not PYTORCH_COLLECT_COVERAGE: cov.html_report() if options.continue_through_error and has_failed: for err in failure_messages: print_to_stderr(err) sys.exit(1)
def run_test_suite(args): skip_utc = args.skip_utc enable_coverage = not args.no_coverage enable_pep8 = not args.no_pep8 if enable_coverage: cov = Coverage(config_file=True) cov.erase() cov.start() settings.configure( DJSTRIPE_TESTS_SKIP_UTC=skip_utc, TIME_ZONE='America/Los_Angeles', DEBUG=True, USE_TZ=True, DATABASES={ "default": { "ENGINE": "django.db.backends.postgresql_psycopg2", "NAME": "djstripe", "USER": "", "PASSWORD": "", "HOST": "", "PORT": "", }, }, ROOT_URLCONF="tests.test_urls", INSTALLED_APPS=[ "django.contrib.admin", "django.contrib.auth", "django.contrib.contenttypes", "django.contrib.sessions", "django.contrib.sites", "jsonfield", "djstripe", "tests", "tests.apps.testapp" ], MIDDLEWARE_CLASSES=( "django.contrib.sessions.middleware.SessionMiddleware", "django.contrib.auth.middleware.AuthenticationMiddleware", "django.contrib.messages.middleware.MessageMiddleware" ), SITE_ID=1, STRIPE_PUBLIC_KEY=os.environ.get("STRIPE_PUBLIC_KEY", ""), STRIPE_SECRET_KEY=os.environ.get("STRIPE_SECRET_KEY", ""), DJSTRIPE_PLANS={ "test0": { "stripe_plan_id": "test_id_0", "name": "Test Plan 0", "description": "A test plan", "price": 1000, # $10.00 "currency": "usd", "interval": "month" }, "test": { "stripe_plan_id": "test_id", "name": "Test Plan 1", "description": "Another test plan", "price": 2500, # $25.00 "currency": "usd", "interval": "month" }, "test2": { "stripe_plan_id": "test_id_2", "name": "Test Plan 2", "description": "Yet Another test plan", "price": 5000, # $50.00 "currency": "usd", "interval": "month" }, "test_deletion": { "stripe_plan_id": "test_id_3", "name": "Test Plan 3", "description": "Test plan for deletion.", "price": 5000, # $50.00 "currency": "usd", "interval": "month" }, "test_trial": { "stripe_plan_id": "test_id_4", "name": "Test Plan 4", "description": "Test plan for trails.", "price": 7000, # $70.00 "currency": "usd", "interval": "month", "trial_period_days": 7 }, "unidentified_test_plan": { "name": "Unidentified Test Plan", "description": "A test plan with no ID.", "price": 2500, # $25.00 "currency": "usd", "interval": "month" } }, DJSTRIPE_PLAN_HIERARCHY = { "bronze": { "level": 1, "plans": [ "test0", "test", ] }, "silver": { "level": 2, "plans": [ "test2", "test_deletion", ] }, "gold": { "level": 3, "plans": [ "test_trial", "unidentified_test_plan", ] }, }, DJSTRIPE_SUBSCRIPTION_REQUIRED_EXCEPTION_URLS=( "(admin)", "test_url_name", "testapp_namespaced:test_url_namespaced", ), ) # Avoid AppRegistryNotReady exception # http://stackoverflow.com/questions/24793351/django-appregistrynotready if hasattr(django, "setup"): django.setup() # Announce the test suite sys.stdout.write(colored(text="\nWelcome to the ", color="magenta", attrs=["bold"])) sys.stdout.write(colored(text="dj-stripe", color="green", attrs=["bold"])) sys.stdout.write(colored(text=" test suite.\n\n", color="magenta", attrs=["bold"])) # Announce test run sys.stdout.write(colored(text="Step 1: Running unit tests.\n\n", color="yellow", attrs=["bold"])) # Hack to reset the global argv before nose has a chance to grab it # http://stackoverflow.com/a/1718407/1834570 args = sys.argv[1:] sys.argv = sys.argv[0:1] from django_nose import NoseTestSuiteRunner test_runner = NoseTestSuiteRunner(verbosity=1) failures = test_runner.run_tests(["."]) if failures: sys.exit(failures) if enable_coverage: # Announce coverage run sys.stdout.write(colored(text="\nStep 2: Generating coverage results.\n\n", color="yellow", attrs=["bold"])) cov.stop() percentage = round(cov.report(show_missing=True), 2) cov.html_report(directory='cover') cov.save() if percentage < TESTS_THRESHOLD: sys.stderr.write(colored(text="YOUR CHANGES HAVE CAUSED TEST COVERAGE TO DROP. " + "WAS {old}%, IS NOW {new}%.\n\n".format(old=TESTS_THRESHOLD, new=percentage), color="red", attrs=["bold"])) sys.exit(1) else: # Announce disabled coverage run sys.stdout.write(colored(text="\nStep 2: Generating coverage results [SKIPPED].", color="yellow", attrs=["bold"])) if enable_pep8: # Announce flake8 run sys.stdout.write(colored(text="\nStep 3: Checking for pep8 errors.\n\n", color="yellow", attrs=["bold"])) print("pep8 errors:") print("----------------------------------------------------------------------") from subprocess import call flake_result = call(["flake8", ".", "--count"]) if flake_result != 0: sys.stderr.write("pep8 errors detected.\n") sys.stderr.write(colored(text="\nYOUR CHANGES HAVE INTRODUCED PEP8 ERRORS!\n\n", color="red", attrs=["bold"])) sys.exit(flake_result) else: print("None") else: # Announce disabled coverage run sys.stdout.write(colored(text="\nStep 3: Checking for pep8 errors [SKIPPED].\n", color="yellow", attrs=["bold"])) # Announce success if enable_coverage and enable_pep8: sys.stdout.write(colored(text="\nTests completed successfully with no errors. Congrats!\n", color="green", attrs=["bold"])) else: sys.stdout.write(colored(text="\nTests completed successfully, but some step(s) were skipped!\n", color="green", attrs=["bold"])) sys.stdout.write(colored(text="Don't push without running the skipped step(s).\n", color="red", attrs=["bold"]))
def coverage_combine(data_files, output_path, source, process=None, absolute_path=True): """ Merges multiples reports. @param data_files report files (``.coverage``) @param output_path output path @param source source directory @param process function which processes the coverage report @param absolute_path relocate sources with absolute paths @return coverage report The function *process* should have the signature: :: def process(content): # ... return content """ def raise_exc(exc, content, ex, ex2, outfile, destcov, source, dests, inter, cov): from coverage.data import CoverageData def shorten(t): if len(t) > 2000: return t[:2000] + "\n..." else: return t if len(content) > 2000: content = content[:2000] + '\n...' ex = "\n-\n".join(shorten(_) for _ in ex) ex2 = "\n-\n".join(shorten(_) for _ in ex2) rows = ["destcov='{0}'".format(destcov), "outfile='{0}'".format(outfile), "source='{0}'".format(source), "cov.source={0}".format(cov.source), "dests='{0}'".format(';'.join(dests)), "inter={0}".format(inter)] if cov is not None and cov.data is not None and cov.data._lines is not None: rows.append("----- LINES") end = min(5, len(cov.data._lines)) for k, v in list(sorted(cov.data._lines.items()))[:end]: rows.append(' {0}:{1}'.format(k, v)) rows.append("----- RUNS") end = min(5, len(cov.data._runs)) for k in cov.data._runs[:end]: rows.append(' {0}'.format(k)) rows.append("----- END") for d in dests: dd = CoverageData() dd.read_file(d + "~") rows.append("------- LINES - '{0}'".format(d)) end = min(5, len(dd._lines)) for k, v in list(sorted(dd._lines.items()))[:end]: rows.append(' {0}:{1}'.format(k, v)) rows.append("------- RUNS - '{0}'".format(d)) end = min(5, len(dd._runs)) for k in dd._runs[:end]: rows.append(' {0}'.format(k)) rows.append("------- END") mes = "{5}. In '{0}'.\n{1}\n{2}\n---AFTER---\n{3}\n---BEGIN---\n{4}" raise RuntimeError(mes.format(output_path, "\n".join( rows), content, ex, ex2, exc, cov)) from exc # We copy the origin coverage if the report is produced # in a folder part of the merge. destcov = os.path.join(output_path, '.coverage') if os.path.exists(destcov): destcov2 = destcov + '_old' shutil.copy(destcov, destcov2) # Starts merging coverage. from coverage import Coverage cov = Coverage(data_file=destcov, source=[source]) # Module coverage may modify the folder, # we take the one it considers. # On Windows, it has to have the right case. # If not, coverage reports an empty coverage and # raises an exception. cov._init() cov.get_data() if cov.source is None or len(cov.source) == 0: raise_exc(FileNotFoundError("Probably unable to find '{0}'".format(source)), "", [], [], "", destcov, source, [], [], cov) source = cov.source[0] inter = [] reg = re.compile(',\\"(.*?[.]py)\\"') def copy_replace(source, dest, root_source): with open(source, "r") as f: content = f.read() if process is not None: content = process(content) cf = reg.findall(content) co = Counter([_.split('src')[0] for _ in cf]) mx = max((v, k) for k, v in co.items()) root = mx[1].rstrip('\\/') if absolute_path: if '\\\\' in root: s2 = root_source.replace('\\', '\\\\').replace('/', '\\\\') s2 += "\\\\" root += "\\\\" elif '\\' in root: s2 = root_source s2 += "\\\\" root += "\\" else: s2 = root_source s2 += "/" root += "/" else: s2 = "" if '\\\\' in root: root += "\\\\" elif '\\' in root: root += "\\" else: root += "/" inter.append((root, root_source, s2)) content = content.replace(root, s2) with open(dest, "w") as f: f.write(content) # We modify the root in every coverage file. dests = [os.path.join(output_path, '.coverage{0}'.format( i)) for i in range(len(data_files))] for fi, de in zip(data_files, dests): copy_replace(fi, de, source) shutil.copy(de, de + "~") # Keeping information (for exception). ex = [] for d in dests: with open(d, "r") as f: ex.append(f.read()) ex2 = [] for d in data_files: with open(d, "r") as f: ex2.append(f.read()) # We replace destcov by destcov2 if found in dests. if destcov in dests: ind = dests.index(destcov) dests[ind] = destcov2 # Let's combine. cov.combine(dests) from coverage.misc import NoSource try: cov.html_report(directory=output_path) except NoSource as e: raise_exc(e, "", ex, ex2, "", destcov, source, dests, inter, cov) outfile = os.path.join(output_path, "coverage_report.xml") cov.xml_report(outfile=outfile) cov.save() # Verifications with open(outfile, "r", encoding="utf-8") as f: content = f.read() if 'line hits="1"' not in content: raise_exc(Exception("Coverage is empty"), content, ex, ex2, outfile, destcov, source, dests, inter, cov) return cov
class CoverageScript(object): """The command-line interface to coverage.py.""" def __init__(self): self.global_option = False self.coverage = None def command_line(self, argv): """The bulk of the command line interface to coverage.py. `argv` is the argument list to process. Returns 0 if all is well, 1 if something went wrong. """ # Collect the command-line options. if not argv: show_help(topic='minimum_help') return OK # The command syntax we parse depends on the first argument. Global # switch syntax always starts with an option. self.global_option = argv[0].startswith('-') if self.global_option: parser = GlobalOptionParser() else: parser = CMDS.get(argv[0]) if not parser: show_help("Unknown command: '%s'" % argv[0]) return ERR argv = argv[1:] ok, options, args = parser.parse_args_ok(argv) if not ok: return ERR # Handle help and version. if self.do_help(options, args, parser): return OK # Listify the list options. source = unshell_list(options.source) omit = unshell_list(options.omit) include = unshell_list(options.include) debug = unshell_list(options.debug) # Do something. self.coverage = Coverage( data_suffix=options.parallel_mode, cover_pylib=options.pylib, timid=options.timid, branch=options.branch, config_file=options.rcfile, source=source, omit=omit, include=include, debug=debug, concurrency=options.concurrency, check_preimported=True, context=options.context, ) if options.action == "debug": return self.do_debug(args) elif options.action == "erase": self.coverage.erase() return OK elif options.action == "run": return self.do_run(options, args) elif options.action == "combine": if options.append: self.coverage.load() data_dirs = args or None self.coverage.combine(data_dirs, strict=True) self.coverage.save() return OK # Remaining actions are reporting, with some common options. report_args = dict( morfs=unglob_args(args), ignore_errors=options.ignore_errors, omit=omit, include=include, ) # We need to be able to import from the current directory, because # plugins may try to, for example, to read Django settings. sys.path.insert(0, '') self.coverage.load() total = None if options.action == "report": total = self.coverage.report( show_missing=options.show_missing, skip_covered=options.skip_covered, **report_args ) elif options.action == "annotate": self.coverage.annotate(directory=options.directory, **report_args) elif options.action == "html": total = self.coverage.html_report( directory=options.directory, title=options.title, skip_covered=options.skip_covered, **report_args ) elif options.action == "xml": outfile = options.outfile total = self.coverage.xml_report(outfile=outfile, **report_args) if total is not None: # Apply the command line fail-under options, and then use the config # value, so we can get fail_under from the config file. if options.fail_under is not None: self.coverage.set_option("report:fail_under", options.fail_under) fail_under = self.coverage.get_option("report:fail_under") precision = self.coverage.get_option("report:precision") if should_fail_under(total, fail_under, precision): return FAIL_UNDER return OK def do_help(self, options, args, parser): """Deal with help requests. Return True if it handled the request, False if not. """ # Handle help. if options.help: if self.global_option: show_help(topic='help') else: show_help(parser=parser) return True if options.action == "help": if args: for a in args: parser = CMDS.get(a) if parser: show_help(parser=parser) else: show_help(topic=a) else: show_help(topic='help') return True # Handle version. if options.version: show_help(topic='version') return True return False def do_run(self, options, args): """Implementation of 'coverage run'.""" if not args: if options.module: # Specified -m with nothing else. show_help("No module specified for -m") return ERR command_line = self.coverage.get_option("run:command_line") if command_line is not None: args = shlex.split(command_line) if args and args[0] == "-m": options.module = True args = args[1:] if not args: show_help("Nothing to do.") return ERR if options.append and self.coverage.get_option("run:parallel"): show_help("Can't append to data files in parallel mode.") return ERR if options.concurrency == "multiprocessing": # Can't set other run-affecting command line options with # multiprocessing. for opt_name in ['branch', 'include', 'omit', 'pylib', 'source', 'timid']: # As it happens, all of these options have no default, meaning # they will be None if they have not been specified. if getattr(options, opt_name) is not None: show_help( "Options affecting multiprocessing must only be specified " "in a configuration file.\n" "Remove --{} from the command line.".format(opt_name) ) return ERR runner = PyRunner(args, as_module=bool(options.module)) runner.prepare() if options.append: self.coverage.load() # Run the script. self.coverage.start() code_ran = True try: runner.run() except NoSource: code_ran = False raise finally: self.coverage.stop() if code_ran: self.coverage.save() return OK def do_debug(self, args): """Implementation of 'coverage debug'.""" if not args: show_help("What information would you like: config, data, sys?") return ERR for info in args: if info == 'sys': sys_info = self.coverage.sys_info() print(info_header("sys")) for line in info_formatter(sys_info): print(" %s" % line) elif info == 'data': self.coverage.load() data = self.coverage.get_data() print(info_header("data")) print("path: %s" % self.coverage.get_data().data_filename()) if data: print("has_arcs: %r" % data.has_arcs()) summary = line_counts(data, fullpath=True) filenames = sorted(summary.keys()) print("\n%d files:" % len(filenames)) for f in filenames: line = "%s: %d lines" % (f, summary[f]) plugin = data.file_tracer(f) if plugin: line += " [%s]" % plugin print(line) else: print("No data collected") elif info == 'config': print(info_header("config")) config_info = self.coverage.config.__dict__.items() for line in info_formatter(config_info): print(" %s" % line) else: show_help("Don't know what you mean by %r" % info) return ERR return OK