def main(): """Run administrative tasks.""" os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'project.settings') # MyMoney 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() covered = cov.report() if covered < 100: sys.exit(0)
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', 'app.settings') try: from django.core.management import execute_from_command_line from django.conf import settings # MyProject Customization: run coverage.py around tests automatically running_tests = (sys.argv[1] == 'test') if running_tests: from coverage import Coverage cov = Coverage() cov.erase() cov.start() if settings.DEBUG: if os.environ.get('RUN_MAIN') or os.environ.get('WERKZEUG_RUN_MAIN'): import ptvsd ptvsd.enable_attach(address = ('0.0.0.0', 3500)) print("Attached remote debugger") 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() covered = cov.report() if covered < 100: sys.exit(1)
def main(): os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'django-graphql.settings') 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() covered = cov.report() if covered < 100: sys.exit(1)
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)
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 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 handle(self, *args, **kwargs): # pragma: no cover cov = Coverage() cov.erase() cov.start() super().handle(*args, **kwargs) cov.stop() cov.save() covered = cov.report() if covered < 100: 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 handle(self, *args, **kwargs): # pragma: no cover self.stdout.write('Run test with coverage..') cov = Coverage(branch=True, ) cov.erase() cov.start() super().handle(*args, **kwargs) cov.stop() cov.save() covered = cov.report(skip_covered=True) if covered < 90: sys.exit(1)
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_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 __erase(self): """ Private slot to handle the erase context menu action. This method erases the collected coverage data that is stored in the .coverage file. """ cover = Coverage(data_file=self.cfn) cover.load() cover.erase() self.reloadButton.setEnabled(False) self.resultList.clear() self.summaryList.clear()
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 test_py3(module): futurize(module) fix_patterns(module) result, elapsed = run_destral(module) py3 = int(result == 0) cov = Coverage() try: cov.load() cov_per = cov.report() cov.erase() except Exception: cov_per = 0 update_module(module, py3, coverage=cov_per, test_time=elapsed)
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 coverage(packages, output_stream=sys.stdout, coverage_file=None, xml_enabled=None, xml_file=None): """ Context manager that activates coverage on the specified packages. Modules in the packages that are already loaded are removed and nosetest will load them again with coverage instrumentation when they are needed. :param packages: list of packages :param output_stream: the stream to write the results to :param coverage_file: the coverage file. If not specified coverage will use the default .coverage file :param xml_enabled: enable XML coverage report :param xml_file: the XML coverage report file. If not specified coverage will use the defualt coverage.xml file :return: instance of coverage.Coverage """ source = {} for module_name, module in [ (module_name, module) for module_name, module in list(sys.modules.items()) if in_any_package(module_name, packages) ]: source[module_name] = module del sys.modules[module_name] cover = Coverage(data_file=coverage_file, auto_data=False, branch=False) cover.combine() cover.erase() cover.start() yield cover for module_name, module in [ (module_name, module) for module_name, module in list(sys.modules.items()) if in_any_package(module_name, packages) ]: source[module_name] = module cover.stop() cover.combine() cover.save() cover.report(list(source.values()), file=output_stream, show_missing=True) if xml_enabled: cover.xml_report(list(source.values()), xml_file)
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)
class Testmon(object): coverage_stack = [] def __init__(self, rootdir="", testmon_labels=None, cov_plugin=None): if testmon_labels is None: testmon_labels = set(["singleprocess"]) self.rootdir = rootdir self.testmon_labels = testmon_labels self.cov = None self.setup_coverage(not ("singleprocess" in testmon_labels), cov_plugin) def setup_coverage(self, subprocess, cov_plugin=None): params = { "include": [os.path.join(self.rootdir, "*")], "omit": _get_python_lib_paths(), } self.cov = Coverage( data_file=getattr(self, "sub_cov_file", None), config_file=False, **params ) self.cov._warn_no_data = False def start(self): Testmon.coverage_stack.append(self.cov) self.cov.erase() self.cov.start() def stop(self): self.cov.stop() Testmon.coverage_stack.pop() def stop_and_save(self, testmon_data: TestmonData, rootdir, nodeid, result): self.stop() if hasattr(self, "sub_cov_file"): self.cov.combine() node_data = testmon_data.node_data_from_cov(self.cov, nodeid) testmon_data.write_node_data(nodeid, node_data, result) def close(self): if hasattr(self, "sub_cov_file"): os.remove(self.sub_cov_file + "_rc") os.environ.pop("COVERAGE_PROCESS_START", None)
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 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 main(): args = _parse_args() logging.basicConfig(level=logging.DEBUG if args.verbose else logging.ERROR) cov = None if not args.no_coverage: from coverage import Coverage cov = Coverage(cover_pylib=False) cov.start() if not args.no_defaults: load_default_plugins() dr.load_components("insights.parsers", "insights.combiners") load_packages(parse_plugins(args.plugins)) _handle_config(args.config) start_session(args.paths, args.cd, __coverage=cov, kernel=args.kernel) if cov: cov.stop() cov.erase()
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(): os.environ.setdefault("DJANGO_SETTINGS_MODULE", "SmartClassroom.settings") if ReturnedOSName == "win32": os.system("title Smart Classroom Django Server Handler") os.system("CLS") elif ReturnedOSName == "linux": pass else: exit(-1) print("Smart Classroom Django Server Handler | < Django Project Caller >") print( '02/29/2020 | By Janrey "CodexLink" Licas | http://github.com/CodexLink\n' ) print("In Collaboration with") print(" - Ronald Langaoan Jr. |> Hardware Designer and Manager") print( " - Janos Angelo Jantoc |> Hardware Designer and Assistant Programmer" ) print(" - Joshua Santos |> Hardware Manager and Builder") print(" - Johnell Casey Murillo Panotes |> Hardware Assistant\n") if sys.argv[1] == "test": print("\n - Coverage Report Activated!") from coverage import Coverage print("| - Coverage > Importing...") baseCov = Coverage() print("| - Coverage > Initializing...") baseCov.erase() print("| - Coverage > Erasing Recent Reports...") baseCov.start() print("| - Coverage > Code Coverage 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 sys.argv[1] == "test": baseCov.stop() baseCov.save() baseCovReport = baseCov.report() print("\n | - Coverage > Report Saved.") baseCov.html_report() if baseCovReport < reqCovPercentage: print( "\n | - Coverage > Code Coverage Completed But Fails To Meet Required Passing Rate of {0}%..." .format(reqCovPercentage)) else: print( "\n | - Coverage > Code Coverage Completed and Passed Above Required Passing Rate of {0}%!" .format(reqCovPercentage)) print("\n | - Coverage > Done~!\n") sys.exit(0)
#!/usr/bin/env python import os import sys from django.core import management # Point to the correct settings for testing os.environ['DJANGO_SETTINGS_MODULE'] = 'test_settings' if __name__ == "__main__": testing = 'test' in sys.argv if testing: from coverage import Coverage cov = Coverage() cov.erase() cov.start() management.execute_from_command_line() if testing: cov.stop() cov.save() cov.report()
def start(): global cov cov = Coverage(config_file=flag_file) register_handler() cov.erase() cov.start()
class Testmon(object): coverage_stack = [] def __init__(self, rootdir="", testmon_labels=None, cov_plugin=None): if testmon_labels is None: testmon_labels = {"singleprocess"} self.rootdir = rootdir self.testmon_labels = testmon_labels self.cov = None self.setup_coverage(not ("singleprocess" in testmon_labels), cov_plugin) def setup_coverage(self, subprocess, cov_plugin=None): params = { "include": [os.path.join(self.rootdir, "*")], "omit": _get_python_lib_paths(), } self.cov = Coverage( data_file=getattr(self, "sub_cov_file", None), config_file=False, **params ) self.cov._warn_no_data = False def start(self): Testmon.coverage_stack.append(self.cov) self.cov.erase() self.cov.start() def stop(self): self.cov.stop() Testmon.coverage_stack.pop() def stop_and_save(self, testmon_data: TestmonData, nodeid, result): self.stop() if hasattr(self, "sub_cov_file"): self.cov.combine() measured_files = get_measured_relfiles( self.rootdir, self.cov, home_file(nodeid) ) node_data = testmon_data.node_data_from_cov(measured_files) nodes_fingerprints = testmon_data.node_data2records(node_data) nodes_fingerprints.append( { "filename": LIBRARIES_KEY, "checksum": testmon_data.libraries, "mtime": None, "fingerprint": checksums_to_blob( encode_lines([testmon_data.libraries]) ), } ) testmon_data.db.insert_node_fingerprints( nodeid, nodes_fingerprints, result, ) def close(self): if hasattr(self, "sub_cov_file"): os.remove(self.sub_cov_file + "_rc") os.environ.pop("COVERAGE_PROCESS_START", None)
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
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() test_db_name = os.environ.get('DJSTRIPE_TEST_DB_NAME', 'djstripe') test_db_user = os.environ.get('DJSTRIPE_TEST_DB_USER', 'postgres') test_db_pass = os.environ.get('DJSTRIPE_TEST_DB_PASS', '') settings.configure( DEBUG=True, SECRET_KEY="djstripe", SITE_ID=1, TIME_ZONE="UTC", USE_TZ=True, DATABASES={ "default": { "ENGINE": "django.db.backends.postgresql_psycopg2", "NAME": test_db_name, "USER": test_db_user, "PASSWORD": test_db_pass, "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", DJSTRIPE_SUBSCRIPTION_REDIRECT="test_url_subscribe", DJSTRIPE_WEBHOOK_VALIDATION="retrieve_event", ) # 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] # Add the ability to run tests on executable files. This is important when running tests on WSL, where permissions # are dictated by Windows instead of Unix. sys.argv += ["--exe"] from django_nose import NoseTestSuiteRunner test_runner = NoseTestSuiteRunner(verbosity=1, keepdb=False, 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"]))
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"]))
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 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"]))
class CodeCoverage(object): """ Code Coverage radish extension """ OPTIONS = [ ('--with-coverage', 'enable code coverage'), ('--cover-packages=<cover_packages>', 'specify source code package'), ('--cover-append', 'append coverage data to previous collected data'), ('--cover-config-file=<cover_config_file>', 'specify coverage config file [default: .coveragerc]'), ('--cover-branches', 'include branch coverage in report'), ('--cover-erase', 'erase previously collected coverage data'), ('--cover-min-percentage=<cover_min_percentage>', 'fail if the given minimum coverage percentage is not reached'), ('--cover-html=<cover_html_dir>', 'specify a directory where to store HTML coverage report'), ('--cover-xml=<cover_xml_file>', 'specify a file where to store XML coverage report') ] 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: self.cover_packages = world.config.cover_packages.split(",") else: self.cover_packages = [] self.coverage = None self.modules_on_init = set(sys.modules.keys()) def coverage_start(self, features, marker): """ Start the coverage measurement """ # if no explicit modules are specified we just # use the ones loaded from radish's basedir. # During the plugin init the basedir modules are # not loaded yet, but they are during the start method. # Thus, we are safe to consider the difference between the # two for coverage measurement. if not self.cover_packages: source = list(set(sys.modules.keys()).difference(self.modules_on_init)) else: source = self.cover_packages self.coverage = Coverage(source=source, config_file=world.config.cover_config_file, branch=world.config.cover_branches) if world.config.cover_erase: self.coverage.combine() self.coverage.erase() if world.config.cover_append: self.coverage.load() self.coverage.start() def coverage_stop(self, features, marker): """ Stop the coverage measurement and create report """ self.coverage.stop() self.coverage.combine() self.coverage.save() self.coverage.report(file=sys.stdout) if world.config.cover_html: self.coverage.html_report(directory=world.config.cover_html) if world.config.cover_xml: self.coverage.xml_report(outfile=world.config.cover_xml) if world.config.cover_min_percentage: report = StringIO() self.coverage.report(file=report) match = re.search(r'^TOTAL\s+(.*)$', report.getvalue(), re.MULTILINE) if not match: raise RadishError('Failed to find total percentage in coverage report') total_percentage = int(match.groups()[0].split()[-1][:-1]) if total_percentage < int(world.config.cover_min_percentage): raise RadishError('Failed to reach minimum expected coverage of {0}% (reached: {1}%)'.format( world.config.cover_min_percentage, total_percentage))
def test_create_dir(self): pass def test_upload(self): pass def test_rename(self): pass def test_del_file(self): pass def test_change_plan(self): pass if __name__ == '__main__': try: unittest.main() except: pass cov.stop() cov.save() print("\n\nCoverage Report:\n") cov.report() print("HTML version: " + os.path.join(basedir, "htmlcov/coverage/index.html")) cov.html_report(directory='htmlcov/coverage') cov.erase()
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
if __name__ == "__main__": os.environ.setdefault("DJANGO_SETTINGS_MODULE", "sequoia.settings") 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 # Code coverage is handled here because of a bug with Django and nose that # hasn't been fixed after years. IS_TESTING = 'test' in sys.argv if IS_TESTING: from coverage import Coverage COV = Coverage() COV.erase() COV.start() execute_from_command_line(sys.argv) if IS_TESTING: COV.stop() COV.save() COV.report() COV.html_report(directory='htmlcov') COV.xml_report()