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(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 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 _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 __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
