def __init__(self): from coverage import Coverage self._cov = Coverage(cover_pylib=False) self._cov.start()
def run(self, edit): view = self.view view.erase_regions('SublimePythonCoverage') fname = view.file_name() if not fname or not fname.endswith('.py'): return cov_file = find(fname, '.coverage') if not cov_file: print('No .coverage file found near %s' % fname) return else: print('Reading coverage data from %s' % cov_file) config_file = os.path.join(os.path.dirname(cov_file), '.coveragerc') if find(fname, '.coverage-noisy'): flags = sublime.DRAW_EMPTY | sublime.DRAW_OUTLINED else: flags = sublime.HIDDEN # run analysis and find uncovered lines cov = Coverage(data_file=cov_file, config_file=config_file) outlines = [] cov.load() if not cov.omit or not FnmatchMatcher(cov.omit).match(fname): f, s, excluded, missing, m = cov.analysis2(fname) for line in missing: outlines.append(view.full_line(view.text_point(line - 1, 0))) # update highlighted regions view.add_regions('SublimePythonCoverage', outlines, 'coverage.missing', 'bookmark', flags)
def run_tests(self): " Run coverage on unit test " # need to import here cause we are in a venv import six from coverage import Coverage coverage = Coverage() coverage.start() # Purge modules under test from sys.modules. The test loader will # re-import them from the build location. Required when 2to3 is used # with namespace packages. if six.PY3 and getattr(self.distribution, 'use_2to3', False): module = self.test_suite.split('.')[0] if module in _namespace_packages: del_modules = [] if module in sys.modules: del_modules.append(module) module += '.' for name in sys.modules: if name.startswith(module): del_modules.append(name) list(map(sys.modules.__delitem__, del_modules)) unittest_main( None, None, self._argv, testLoader=self._resolve_as_ep(self.test_loader), testRunner=self._resolve_as_ep(self.test_runner), exit=False, ) coverage.stop() coverage.save() coverage.report(show_missing=False)
class CoverageContext(object): def __init__(self): from coverage import Coverage self._cov = Coverage(cover_pylib=False) self._cov.start() def __enter__(self): return self def __exit__(self, exc_type, exc_val, exc_tb): self._cov.stop()
class CodeCoverage(): def __init__(self, with_coverage, app): self.with_coverage = with_coverage self.app = app or 'frappe' def __enter__(self): if self.with_coverage: import os from coverage import Coverage from frappe.utils import get_bench_path # Generate coverage report only for app that is being tested source_path = os.path.join(get_bench_path(), 'apps', self.app) omit = STANDARD_EXCLUSIONS[:] if self.app == 'frappe': omit.extend(FRAPPE_EXCLUSIONS) self.coverage = Coverage(source=[source_path], omit=omit, include=STANDARD_INCLUSIONS) self.coverage.start() def __exit__(self, exc_type, exc_value, traceback): if self.with_coverage: self.coverage.stop() self.coverage.save() self.coverage.xml_report()
def test(package, coverage=True, tests=(), verbose=False, fail_fast=False): cwd = os.getcwd() where = os.path.join(cwd, package.replace('.', os.sep)) top_level_dir = cwd coverage = coverage and not tests verbosity = 2 if verbose else 1 if coverage: from coverage import Coverage cover = Coverage(branch=True, source=[where]) cover.start() loader = unittest.TestLoader() if tests: suite = loader.loadTestsFromNames(tests) else: suite = loader.discover(where, top_level_dir=top_level_dir) runner = unittest.TextTestRunner(verbosity=verbosity, failfast=fail_fast) runner.run(suite) if coverage: cover.stop() cover.report()
def run(self) -> int: coverage = Coverage() coverage.start() exit_code = main(['-v', 'tests']) coverage.stop() # Early exit if pytest failed if exit_code != 0: return 0 # Generate xml report in StringIO file coverage.get_data() coverage.config.from_args( ignore_errors=None, report_omit=None, report_include=None, xml_output=None, ) data = StringIO() reporter = XmlReporter(coverage, coverage.config) reporter.report(None, data) data.seek(0) # Check diff cover compared to origin/master using xml score = generate_coverage_report(coverage_xml=[data], compare_branch='origin/master', exclude=self.exclude_paths) return score
def run_tests(context, app=None, module=None, doctype=None, test=(), driver=None, profile=False, coverage=False, junit_xml_output=False, ui_tests = False, doctype_list_path=None, skip_test_records=False, skip_before_tests=False, failfast=False): "Run tests" import frappe.test_runner tests = test site = get_site(context) frappe.init(site=site) frappe.flags.skip_before_tests = skip_before_tests frappe.flags.skip_test_records = skip_test_records if coverage: # Generate coverage report only for app that is being tested source_path = os.path.join(get_bench_path(), 'apps', app or 'frappe') cov = Coverage(source=[source_path], omit=['*.html', '*.js', '*.css']) cov.start() ret = frappe.test_runner.main(app, module, doctype, context.verbose, tests=tests, force=context.force, profile=profile, junit_xml_output=junit_xml_output, ui_tests = ui_tests, doctype_list_path = doctype_list_path, failfast=failfast) if coverage: cov.stop() cov.save() if len(ret.failures) == 0 and len(ret.errors) == 0: ret = 0 if os.environ.get('CI'): sys.exit(ret)
def report(testSuite): cov = Coverage(branch=True) cov.start() for test_case in testSuite: TriangleApp.TriangleTester(test_case[1][0], test_case[1][1], test_case[1][2]) cov.stop() cov.report(file=open('./tmp/results.txt', 'w'), show_missing=True) f = open('./tmp/results.txt', 'r') lines = f.readlines() imp_elm = [] br_not_cover = 0 elements = lines[2].split(' ') for e in elements: if e != '' and e[0].isdigit(): e = e.strip(',') e = e.strip('\n') e = e.strip('%') imp_elm.append(e) for i in range(5, len(imp_elm)): if imp_elm[i].find('->') != -1: br_not_cover = br_not_cover + 1 coverage_report = {'stmt': int(imp_elm[0]), 'miss': int(imp_elm[1]), 'branch': int(imp_elm[2]), 'br_par': int(imp_elm[3]), 'cover': int(imp_elm[4]), 'br_not_cover': br_not_cover} return coverage_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 run_unit_tests() -> int: cov = Coverage(include="app_google_groups/*") cov.start() loader = unittest.TestLoader() suite = loader.discover(start_dir=".", pattern="test_*.py") res = unittest.TextTestRunner().run(suite) cov.stop() try: cov.save() cov.report() except CoverageException as ce: print(str(ce)) print("Don't forget to add some unit tests!") num_test_fails = len(res.failures) + len(res.errors) return num_test_fails
def __enter__(self): if self.with_coverage: import os from coverage import Coverage from frappe.utils import get_bench_path # Generate coverage report only for app that is being tested source_path = os.path.join(get_bench_path(), 'apps', self.app) omit = STANDARD_EXCLUSIONS[:] if self.app == 'frappe': omit.extend(FRAPPE_EXCLUSIONS) self.coverage = Coverage(source=[source_path], omit=omit, include=STANDARD_INCLUSIONS) self.coverage.start()
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 _run_avocado(runnable, queue): try: # This assumes that a proper resolution (see resolver module) # was performed, and that a URI contains: # 1) path to python module # 2) class # 3) method # # To be defined: if the resolution uri should be composed like # this, or broken down and stored into other data fields module_path, klass_method = runnable.uri.split(":", 1) klass, method = klass_method.split(".", 1) params = AvocadoInstrumentedTestRunner._create_params(runnable) result_dir = runnable.output_dir or tempfile.mkdtemp(prefix=".avocado-task") test_factory = [ klass, { "name": TestID(1, runnable.uri, runnable.variant), "methodName": method, "config": runnable.config, "modulePath": module_path, "params": params, "tags": runnable.tags, "run.results_dir": result_dir, }, ] messages.start_logging(runnable.config, queue) if "COVERAGE_RUN" in os.environ: from coverage import Coverage coverage = Coverage() coverage.start() instance = loader.load_test(test_factory) early_state = instance.get_state() early_state["type"] = "early_state" queue.put(early_state) instance.run_avocado() if "COVERAGE_RUN" in os.environ: coverage.stop() coverage.save() state = instance.get_state() fail_reason = state.get("fail_reason") queue.put(messages.WhiteboardMessage.get(state["whiteboard"])) queue.put( messages.FinishedMessage.get( state["status"].lower(), fail_reason=fail_reason ) ) except Exception as e: queue.put(messages.StderrMessage.get(traceback.format_exc())) queue.put(messages.FinishedMessage.get("error", fail_reason=str(e)))
def main(argv=None): """Application entry-point. This will read the given coverage data file and prints a JSON object with the following fields to stdout: ``covered`` An array of line numbers that are covered. ``excluded`` An array of line numbers that have been excluded from being subject to coverage checks. ``missing`` An array of line numbers that have not been covered. """ args = parse_args(argv) coverage = Coverage(data_file=str(args.coverage[0])) coverage.load() _, covered, excluded, missing, _ = coverage.analysis2(str(args.file[0])) print( json.dumps({ "covered": covered, "excluded": excluded, "missing": missing, })) return 0
def __init__(self, vw): self.cov = Coverage() self.comments = Comments() self.running = True self.cmt_changes = {} self.cmt_lock = Lock() self.stackvar_changes = {} self.stackvar_lock = Lock() self.syms = get_syms(vw) self.syms_lock = Lock() self.structs = {} # get_structs(vw) self.structs_lock = Lock() self.filedata_by_sha = {} self.filedata_by_fname = {} for fname in vw.getFiles(): sha256 = vw.getFileMeta(fname, 'sha256') mdict = dict(vw.getFileMetaDict(fname)) mdict['name'] = fname mdict['maps'] = [ mmap for mmap in vw.getMemoryMaps() if mmap[MAP_FNAME] == fname ] mdict['sha256'] = sha256 self.filedata_by_sha[sha256] = mdict self.filedata_by_fname[fname] = mdict
def _bootstrap(self): from coverage import Coverage cov = Coverage(data_suffix=True) cov.start() try: return original_bootstrap(self) finally: cov.stop() cov.save()
def _bootstrap(self): """Wrapper around _bootstrap to start coverage.""" from coverage import Coverage coverage_config = getattr(multiprocessing, PATCHED_MARKER) coverage_config.parallel = True cov = Coverage() cov.config = coverage_config cov.start() try: return original_bootstrap(self) finally: cov.stop() cov.save()
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 create_coverage(): """ Create Coverage instance :return: """ include = config.get('tests', 'include', fallback='./*, impl/*, src/*') include = [_.strip() for line in include.splitlines() for _ in line.split(',') if line and _] exclude = config.get('tests', 'exclude', fallback='tests/*, test/*, .venv/*, venv/*') exclude = [_.strip() for line in exclude.splitlines() for _ in line.split(',') if line and _] concurrency = config.get('tests', 'concurrency', fallback='gevent') concurrency = [_.strip() for line in concurrency.splitlines() for _ in line.split(',') if line and _] cov = Coverage(include=include, omit=exclude, concurrency=concurrency) cov.start() return cov
def _stop_coverage(): if "coverage" in sys.modules: # If Coverage is running then it ends here from coverage import Coverage cov = Coverage.current() cov.stop() cov.save()
def run_tests(complete: bool = True, strict: bool = True, dry_run: bool = False) -> (unittest.TestResult, Coverage, unittest.TestSuite): """ Run integration tests :param complete: When true ibllib unit tests are run in addition to the integration tests. :param strict: When true asserts that all gathered tests were successfully imported. This means that a module not found error in any test module will raise an exception. :param dry_run: When true the tests are gathered but not run. :return Test results and coverage objects, and test suite. """ # Coverage recorded for all code within the source directory; otherwise just omit some # common pyCharm files options = {'omit': ['*pydevd_file_utils.py', 'test_*'], 'source': []} # Gather tests test_dir = str(Path(ci.tests.__file__).parent) logger.info(f'Loading integration tests from {test_dir}') ci_tests = unittest.TestLoader().discover(test_dir, pattern='test_*') if complete: # include ibllib and brainbox unit tests root = Path(ibllib.__file__).parents[1] # Search relative to our imported ibllib package test_dirs = [root.joinpath(x) for x in ('brainbox', 'oneibl', 'ibllib', 'alf')] for tdir in test_dirs: logger.info(f'Loading unit tests from folders: {tdir}') assert tdir.exists(), f'Failed to find unit test folders in {tdir}' unit_tests = unittest.TestLoader().discover(str(tdir), pattern='test_*', top_level_dir=root) logger.info(f"Found {unit_tests.countTestCases()}, appending to the test suite") ci_tests = unittest.TestSuite((ci_tests, *unit_tests)) # for coverage, append the path of the test modules to the source key options['source'].append(str(tdir)) logger.info(f'Complete suite contains {ci_tests.countTestCases()} tests') # Check all tests loaded successfully not_loaded = [x[12:] for x in list_tests(ci_tests) if x.startswith('_Failed')] if len(not_loaded) != 0: err_msg = 'Failed to import the following tests:\n\t' + '\n\t'.join(not_loaded) assert not strict, err_msg logger.warning(err_msg) if dry_run: return unittest.TestResult(), Coverage(**options), ci_tests # Run tests with coverage cov = Coverage(**options) cov.start() result = unittest.TextTestRunner(verbosity=2).run(ci_tests) cov.stop() cov.save() return result, cov, ci_tests
def cal_coverage(collection_yaml, model_yaml, output_root): index_path = get_index_path(collection_yaml) this_output_root = os.path.join(output_root, collection_yaml['name']) Coverage(index_path).cal_coverage( model_yaml, os.path.join(collection_yaml['anserini_root'], collection_yaml['qrels_root'], collection_yaml['qrel']), this_output_root )
def _run_avocado(runnable, queue): try: # This assumes that a proper resolution (see resolver module) # was performed, and that a URI contains: # 1) path to python module # 2) class # 3) method # # To be defined: if the resolution uri should be composed like # this, or broken down and stored into other data fields module_path, klass_method = runnable.uri.split(':', 1) klass, method = klass_method.split('.', 1) params = AvocadoInstrumentedTestRunner._create_params(runnable) result_dir = (runnable.output_dir or tempfile.mkdtemp(prefix=".avocado-task")) test_factory = [ klass, { 'name': TestID(1, runnable.uri), 'methodName': method, 'config': runnable.config, 'modulePath': module_path, 'params': params, 'tags': runnable.tags, 'run.results_dir': result_dir, } ] messages.start_logging(runnable.config, queue) if 'COVERAGE_RUN' in os.environ: from coverage import Coverage coverage = Coverage() coverage.start() instance = loader.load_test(test_factory) early_state = instance.get_state() early_state['type'] = "early_state" queue.put(early_state) instance.run_avocado() if 'COVERAGE_RUN' in os.environ: coverage.stop() coverage.save() state = instance.get_state() fail_reason = state.get('fail_reason') queue.put(messages.WhiteboardMessage.get(state['whiteboard'])) queue.put( messages.FinishedMessage.get(state['status'].lower(), fail_reason=fail_reason)) except Exception as e: queue.put(messages.StderrMessage.get(traceback.format_exc())) queue.put(messages.FinishedMessage.get('error', fail_reason=str(e)))
def _bootstrap(self): """Wrapper around _bootstrap to start coverage.""" from coverage import Coverage cov = Coverage(data_suffix=True) cov.start() try: return original_bootstrap(self) finally: cov.stop() cov.save()
def run_tests(self): from illume import config from coverage import Coverage config.setenv("test") from pytest import main from illume.util import remove_or_ignore_dir from logging import basicConfig, DEBUG basicConfig(level=DEBUG, filename="illume-test.log") project_root = config.get("PROJECT_ROOT") data_dir = config.get("DATA_DIR") cov_config_dir = os.path.join(project_root, '.coveagerc') cov = Coverage(config_file=cov_config_dir) # Remvoe data directory in case tests failed to complete last time. remove_or_ignore_dir(data_dir) cov.start() exit_code = main(shlex.split(self.pytest_args or "")) cov.stop() cov.xml_report() # Remove data directory if tests passed successfully. Keep it around # if tests failed so the developer can troubleshoot the problem. if exit_code == 0: remove_or_ignore_dir(data_dir) sys.exit(exit_code)
def initData(): """Load data and mappings from Raw data files and mapping files""" Patient.load() VitalSigns.load() Lab.load() Procedure.load() Immunization.load() FamilyHistory.load() SocialHistory.load() Condition.load() Med.load() Refill.load() Document.load() Allergy.load() ClinicalNote.load() Practitioner.load() Coverage.load() ExplanationOfBenefit.load()
def __init__(self): before.all(self.coverage_start) after.all(self.coverage_stop) if world.config.cover_packages: cover_packages = world.config.cover_packages.split(",") else: cover_packages = [] self.coverage = Coverage(source=cover_packages)
def read_coverage_data(): """ :rtype: CoverageData or None """ try: # noinspection PyPackageRequirements,PyUnresolvedReferences from coverage import Coverage except ImportError as e: raise ImportError( 'The --use-coverage feature requires the coverage library. Run "pip install --force-reinstall mutmut[coverage]"' ) from e cov = Coverage('.coverage') cov.load() data = cov.get_data() return { filepath: data.lines(filepath) for filepath in data.measured_files() }
def generateCoverage(func, X, y, outfile_name): file_list = [] result_list = [] for i in range(len(X)): try: cov = Coverage() cov.start() if (func(X[i]) == y[i]): result_list.append(1) else: result_list.append(0) cov.stop() cov.save() cov.json_report(outfile=outfile_name + "_" + str(i) + ".json") file_list.append(outfile_name + "_" + str(i) + ".json") except ValueError: print("ValueError is happened") return file_list, result_list
def code_coverage(): from coverage import Coverage cov = Coverage(data_suffix="blender") cov.start() print("Code coverage started") try: yield finally: cov.stop() cov.save() print("Code coverage stopped and saved")
def run_tests(context, app=None, module=None, doctype=None, test=(), profile=False, coverage=False, junit_xml_output=False, ui_tests = False, doctype_list_path=None, skip_test_records=False, skip_before_tests=False, failfast=False): "Run tests" import frappe.test_runner tests = test site = get_site(context) allow_tests = frappe.get_conf(site).allow_tests if not (allow_tests or os.environ.get('CI')): click.secho('Testing is disabled for the site!', bold=True) click.secho('You can enable tests by entering following command:') click.secho('bench --site {0} set-config allow_tests true'.format(site), fg='green') return frappe.init(site=site) frappe.flags.skip_before_tests = skip_before_tests frappe.flags.skip_test_records = skip_test_records if coverage: from coverage import Coverage # Generate coverage report only for app that is being tested source_path = os.path.join(get_bench_path(), 'apps', app or 'frappe') cov = Coverage(source=[source_path], omit=[ '*.html', '*.js', '*.xml', '*.css', '*.less', '*.scss', '*.vue', '*/doctype/*/*_dashboard.py', '*/patches/*' ]) cov.start() ret = frappe.test_runner.main(app, module, doctype, context.verbose, tests=tests, force=context.force, profile=profile, junit_xml_output=junit_xml_output, ui_tests=ui_tests, doctype_list_path=doctype_list_path, failfast=failfast) if coverage: cov.stop() cov.save() if len(ret.failures) == 0 and len(ret.errors) == 0: ret = 0 if os.environ.get('CI'): sys.exit(ret)
def run_tests(*here): if Coverage is None: for x in here: _run_tests(x) else: coverage = Coverage() coverage.start() for x in here: _run_tests(x) coverage.stop() coverage.save()
def _bootstrap(self): """Wrapper around _bootstrap to start coverage.""" from coverage import Coverage # avoid circular import rcfile = os.environ[COVERAGE_RCFILE_ENV] cov = Coverage(data_suffix=True, config_file=rcfile) cov.start() try: return original_bootstrap(self) finally: cov.stop() cov.save()
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)
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}')
def __init__(self, index: int = 1, port_count: int = 5, state_file_loc=None): print(state_file_loc) self._id = index self.port_count = port_count # Coverage self.cov = Coverage(self._id) # Switch ports = [f"veth_{self._id}_{x}" for x in range(port_count)] self.interfaces = ports self.create_veth(ports) ports_cmd = [] for k, i in enumerate(ports): ports_cmd.append("--interface") ports_cmd.append(f"{k}@{i}") self.thrift_port = self._id * 1000 state_info = ["--restore-state", str(state_file_loc)] if state_file_loc else [] self.process = Popen([ INSTRUMENTED_SWITCH_PATH, *ports_cmd, "--device-id", str(self._id), "--thrift-port", str(self.thrift_port), *state_info, COMPILED_JSON_PROGRAM ], stdout=sys.stdout, stderr=sys.stderr, stdin=PIPE, env=os.environ) time.sleep(0.5) self.cov.post_boot() # Start Control Plane self.control_plane = CONTROL_PLANE_OBJ(self.thrift_port) # Connect to Thrift Instance self.api = SimpleSwitchAPI(self.thrift_port) print("Init Completed!")
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 run_with_coverage(run): from coverage import Coverage coverage = Coverage() coverage.start() apply(run) coverage.end() coverage.result(['../core/%s' % prefix,])
def test_to_file_and_from_file(): cov = Coverage() cov['foo'].extend(range(1, 11)) cov['bar'].extend(range(1, 3)) cov['baz'] temp_write_fh = NamedTemporaryFile() cov.to_file(temp_write_fh.file) temp_write_fh.file.flush() temp_read_fh = open(temp_write_fh.name) loaded = Coverage() loaded.from_file(temp_read_fh) x = array('L') x.extend(range(1, 11)) eq_(loaded['foo'], x) x = array('L') x.extend(range(1, 3)) eq_(loaded['bar'], x) x = array('L') eq_(loaded['baz'], x)
def run_coverage(self, test_name): cov = Coverage(source=self.config.source, omit=self.config.omit) cov.start() self.map_test(test_name) cov.stop() return cov.get_data()
def run(): print "running all tests for core" from coverage import Coverage coverage = Coverage() coverage.start() #run() sys.stdout.write("Test of Server... control-c to continue other tests.\n") sys.stdout.flush() from test.redfoot.server import all from test.redfoot.rdf.syntax import test from test.redfoot.rdf.syntax import test2 from test.redfoot.rdf.store import test sys.settrace(None)#coverage.end() import os contains = os.path.normpath('redfoot') print "CONTAINS" + contains coverage.result([contains,], open('coverage.html', 'w'))
def _bootstrap(self): """Wrapper around _bootstrap to start coverage.""" from coverage import Coverage rcfile = getattr(multiprocessing, PATCHED_MARKER) cov = Coverage(data_suffix=True, config_file=rcfile) cov.start() try: return original_bootstrap(self) finally: cov.stop() cov.save()
class CodeCoverage(object): """ Code Coverage radish extension """ OPTIONS = [ ("--with-coverage", "enable code coverage"), ("--cover-packages=<cover_packages>", "specify source code package") ] LOAD_IF = staticmethod(lambda config: config.with_coverage) LOAD_PRIORITY = 70 def __init__(self): before.all(self.coverage_start) after.all(self.coverage_stop) if world.config.cover_packages: cover_packages = world.config.cover_packages.split(",") else: cover_packages = [] self.coverage = Coverage(source=cover_packages) def coverage_start(self, features, marker): """ Start the coverage measurement """ self.coverage.load() self.coverage.start() def coverage_stop(self, features, marker): """ Stop the coverage measurement and create report """ self.coverage.stop() self.coverage.save() self.coverage.report(file=sys.stdout)
def _bootstrap(self): """Wrapper around _bootstrap to start coverage.""" from coverage import Coverage # avoid circular import cov = Coverage(data_suffix=True) cov._warn_preimported_source = False cov.start() debug = cov._debug try: if debug.should("multiproc"): debug.write("Calling multiprocessing bootstrap") return original_bootstrap(self) finally: if debug.should("multiproc"): debug.write("Finished multiprocessing bootstrap") cov.stop() cov.save() if debug.should("multiproc"): debug.write("Saved multiprocessing data")
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(): cov = Coverage( omit=[ "*passlib*", "*test*", "*tornado*", "*backports_abc*", "*singledispatch*", "*six*", "*certifi*", "*daemon*", "*funcsigs*", "*mock*", "*pbr*", "*pkg_resources*", "*tablib*", ] ) cov.start() from app_test import ApplicationTest from database_test import DatabaseTest from http_test import HTTPTestCase from procinfo_test import ProcInfoTest from user_test import UserTest from token_test import TokenTest from ws_test import WebSocketTestCase from unittest import TestLoader, TextTestRunner, TestSuite loader = TestLoader() suite = TestSuite( ( loader.loadTestsFromTestCase(ProcInfoTest), loader.loadTestsFromTestCase(DatabaseTest), loader.loadTestsFromTestCase(UserTest), loader.loadTestsFromTestCase(TokenTest), loader.loadTestsFromTestCase(HTTPTestCase), loader.loadTestsFromTestCase(WebSocketTestCase), loader.loadTestsFromTestCase(ApplicationTest), ) ) runner = TextTestRunner(verbosity=2) runner.run(suite) cov.stop() cov.save()
def test_does_not_trace_files_outside_inclusion(tmpdir, branch, timid): @given(st.booleans()) def test(a): rnd() cov = Coverage( config_file=False, data_file=str(tmpdir.join('.coverage')), branch=branch, timid=timid, include=[__file__], ) cov._warn = escalate_warning cov.start() test() cov.stop() data = cov.get_data() assert len(list(data.measured_files())) == 1
def test_achieves_full_coverage(tmpdir, branch, timid): @given(st.booleans(), st.booleans(), st.booleans()) def test(a, b, c): some_function_to_test(a, b, c) cov = Coverage( config_file=False, data_file=str(tmpdir.join('.coverage')), branch=branch, timid=timid, ) cov._warn = escalate_warning cov.start() test() cov.stop() data = cov.get_data() lines = data.lines(__file__) for i in hrange(LINE_START + 1, LINE_END + 1): assert i in lines
def _bootstrap(self): """Wrapper around _bootstrap to start coverage.""" from coverage import Coverage # avoid circular import rcfile = os.environ[COVERAGE_RCFILE_ENV] cov = Coverage(data_suffix=True, config_file=rcfile) cov.start() debug = cov.debug try: if debug.should("multiproc"): debug.write("Calling multiprocessing bootstrap") return original_bootstrap(self) finally: if debug.should("multiproc"): debug.write("Finished multiprocessing bootstrap") cov.stop() cov.save() if debug.should("multiproc"): debug.write("Saved multiprocessing data")
def run_unit_tests(): from datetime import datetime from coverage import Coverage from io import StringIO import unittest from tests import testModels w = StringIO() cov = Coverage(omit=["/usr/*", "*/venv/*", "*-packages*"]) cov.start() runner = unittest.TextTestRunner(stream=w) runner.run(unittest.makeSuite(testModels)) cov.stop() cov.report(file=w) output = w.getvalue() db.app = app return ("You ran the tests on: " + datetime.now().strftime("%I:%M%p on %B %d, %Y") + " GMT\n" + output)
def stmtCovered(code, test) : # Replace input lines with values code = feedInput(code, test) # Initialize the coverage object cov = Coverage() # Create a temporary file with the code fname = "tmp"+str(int(random()*100000)) f = open(fname, 'w') f.write("\n".join(code)) f.close() # Capture statement coverage print("Test case is: "+str(test)) cov.start() out = execfile(fname) cov.stop() # Obtain the report of coverage and remove the temporary file report = cov.analysis(fname) os.remove(fname) # Return the executed line numbers return set(range(1, len(code)+1)) - set(report[2])
#!/usr/bin/env python # -*- coding: UTF-8 -*- from flask_script import Manager, Shell, Server from flask_migrate import Migrate, MigrateCommand from unittest import TestLoader, TextTestRunner from coverage import Coverage from datetime import datetime import os import sys cov = None if os.environ.get('FLASK_COVERAGE'): cov = Coverage(branch=True, include=['app/*']) cov.start() from app import create_app, db app = create_app() manager = Manager(app) migrate = Migrate(app, db) def make_shell_context(): return dict(app=app, db=db) class GeventServer(Server): help = description = 'Runs the Flask development gevent server.'
from django.apps import AppConfig try: from coverage import Coverage coverage = Coverage() coverage.start() except ImportError: coverage = None 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 coverage_start(self): if coverage and not self.coverage: self.coverage = Coverage() self.coverage.start() return self.coverage