def test_pretty_version(self):
"pretty_version() has the content we expect"
pv = pretty_version()
self.assertTrue('Green' in pv)
self.assertTrue('Python' in pv)
if green.version.coverage:
self.assertTrue('Coverage' in pv)
def startTestRun(self):
"""
Called once before any tests run
"""
self.startTime = time.time()
# Really verbose information
if self.verbose > 2:
self.stream.writeln(self.colors.bold(pretty_version() + "\n"))
def startTestRun(self):
"""
Called once before any tests run
"""
self.startTime = time.time()
# Really verbose information
if self.verbose > 2:
self.stream.writeln(self.colors.bold(pretty_version() + "\n"))
def test_pretty_version(self):
"""
pretty_version() has the content we expect
"""
pv = pretty_version()
self.assertTrue('Green' in pv)
self.assertTrue('Python' in pv)
self.assertTrue('Coverage' in pv)
def test_pretty_version(self):
"""
pretty_version() has the content we expect
"""
pv = pretty_version()
self.assertTrue("Green" in pv)
self.assertTrue("Python" in pv)
self.assertTrue("Coverage" in pv)
def startTestRun(self):
"Called once before any tests run"
self.startTime = time.time()
# Really verbose information
if self.colors.html:
self.stream.write(
'<div style="font-family: Monaco, \'Courier New\', monospace; color: rgb(170,170,170); background: rgb(0,0,0); padding: 14px;">')
if self.verbose > 2:
self.stream.writeln(self.colors.bold(pretty_version() + "\n"))
def mergeConfig(args, testing=False): # pragma: no cover
"""
I take in a namespace created by the ArgumentParser in cmdline.main() and
merge in options from configuration files. The config items only replace
argument items that are set to default value.
Returns: I return a new argparse.Namespace, adding members:
shouldExit = default False
exitCode = default 0
include patterns = include-patterns setting converted to list.
omit_patterns = omit-patterns settings converted to list and
extended, taking clear-omit into account.
cov = coverage object default None
"""
config = getConfig(getattr(args, 'config', default_args.config))
new_args = copy.deepcopy(default_args) # Default by default!
for name, default_value in dict(default_args._get_kwargs()).items():
# Config options overwrite default options
config_getter = None
if name in ['termcolor', 'notermcolor', 'allow_stdout', 'quiet_stdout',
'help', 'logging', 'version', 'disable_unidecode', 'failfast',
'run_coverage', 'options', 'completions', 'completion_file',
'clear_omit', 'no_skip_report', 'no_tracebacks',
'disable_windows', 'quiet_coverage', 'junit_report']:
config_getter = config.getboolean
elif name in ['processes', 'debug', 'verbose', 'minimum_coverage']:
config_getter = config.getint
elif name in ['file_pattern', 'finalizer', 'initializer',
'cov_config_file', 'include_patterns', 'omit_patterns',
'warnings', 'test_pattern']:
config_getter = config.get
elif name in ['targets', 'help', 'config']:
pass # Some options only make sense coming on the command-line.
elif name in ['store_opt', 'parser']:
pass # These are convenience objects, not actual settings
else:
raise NotImplementedError(name)
if config_getter:
try:
config_value = config_getter('green', name.replace('_', '-'))
setattr(new_args, name, config_value)
except (configparser.NoSectionError, configparser.NoOptionError):
pass
# Command-line values overwrite defaults and config values when
# specified
args_value = getattr(args, name, 'unspecified')
if args_value != 'unspecified':
setattr(new_args, name, args_value)
new_args.shouldExit = False
new_args.exitCode = 0
new_args.cov = None
# Help?
if new_args.help: # pragma: no cover
new_args.parser.print_help()
new_args.shouldExit = True
return new_args
# Did we just print the version?
if new_args.version:
from green.version import pretty_version
sys.stdout.write(pretty_version()+'\n')
new_args.shouldExit = True
return new_args
# Handle logging options
if new_args.debug:
logging.basicConfig(
level=logging.DEBUG,
format="%(asctime)s %(levelname)9s %(message)s",
datefmt="%Y-%m-%d %H:%M:%S")
elif not new_args.logging:
logging.basicConfig(filename=os.devnull)
# Disable termcolor?
if new_args.notermcolor:
new_args.termcolor = False
# Coverage. We must enable it here because we cannot cover module-level
# code after it is imported, and this is the earliest place we can turn on
# coverage.
omit_patterns = [
'*/argparse*',
'*/colorama*',
'*/django/*',
'*/distutils*', # Gets pulled in on Travis-CI CPython
'*/extras*', # pulled in by testtools
'*/linecache2*', # pulled in by testtools
'*/mimeparse*', # pulled in by testtools
'*/mock*',
'*/pbr*', # pulled in by testtools
'*/pkg_resources*', # pulled in by django
'*/pypy*',
'*/pytz*', # pulled in by django
'*/six*', # pulled in by testtools
'*/termstyle*',
'*/test*',
'*/traceback2*', # pulled in by testtools
'*/unittest2*', # pulled in by testtools
'*Python.framework*', # OS X system python
'*site-packages*', # System python for other OS's
tempfile.gettempdir() + '*',
]
if new_args.clear_omit:
omit_patterns = []
if new_args.omit_patterns:
omit_patterns.extend(new_args.omit_patterns.split(','))
new_args.omit_patterns = omit_patterns
if new_args.include_patterns:
new_args.include_patterns = new_args.include_patterns.split(',')
else:
new_args.include_patterns = []
if new_args.quiet_coverage or (type(new_args.cov_config_file) == str):
new_args.run_coverage = True
if new_args.minimum_coverage != None:
new_args.run_coverage = True
if new_args.run_coverage:
if not testing:
cov = coverage.coverage(data_file='.coverage', omit=omit_patterns,
include=new_args.include_patterns,
config_file = new_args.cov_config_file)
cov.start()
new_args.cov = cov
return new_args
def mergeConfig(args, testing=False, coverage_testing=False): # pragma: no cover
"""
I take in a namespace created by the ArgumentParser in cmdline.main() and
merge in options from configuration files. The config items only replace
argument items that are set to default value.
Returns: I return a new argparse.Namespace, adding members:
shouldExit = default False
exitCode = default 0
omit = omit settings converted to list and extended
cov = coverage object default None
"""
config = getConfig(args.config)
new_args = copy.deepcopy(default_args) # Default by default!
for name, args_value in dict(args._get_kwargs()).items():
# Config options overwrite default options
config_getter = None
if name in ['html', 'termcolor', 'notermcolor', 'help', 'logging',
'version', 'run_coverage', 'options', 'completions',
'completion_file']:
config_getter = config.getboolean
elif name in ['subprocesses', 'debug', 'verbose']:
config_getter = config.getint
elif name in ['omit']:
config_getter = config.get
elif name in ['targets', 'help', 'config']:
pass # Some options only make sense coming on the command-line.
elif name in ['store_opt', 'parser']:
pass # These are convenience objects, not actual settings
else:
raise NotImplementedError(name)
if config_getter:
try:
config_value = config_getter('green', name.replace('_','-'))
setattr(new_args, name, config_value)
except (configparser.NoSectionError, configparser.NoOptionError):
pass
# Command-line values overwrite defaults and config values
if args_value != getattr(default_args, name):
setattr(new_args, name, args_value)
new_args.shouldExit = False
new_args.exitCode = 0
new_args.cov = None
# Help?
if new_args.help: # pragma: no cover
new_args.parser.print_help()
new_args.shouldExit = True
return new_args
# Did we just print the version?
if new_args.version:
from green.version import pretty_version
sys.stdout.write(pretty_version()+'\n')
new_args.shouldExit = True
return new_args
# Handle logging options
if new_args.debug:
logging.basicConfig(
level=logging.DEBUG,
format="%(asctime)s %(levelname)9s %(message)s",
datefmt="%Y-%m-%d %H:%M:%S")
elif not new_args.logging:
logging.basicConfig(filename=os.devnull)
# These options both disable termcolor
if new_args.html or new_args.notermcolor:
new_args.termcolor = False
# Coverage. We must enable it here because we cannot cover module-level
# code after it is imported, and this is the earliest place we can turn on
# coverage.
omit = []
if new_args.omit:
omit = new_args.omit.split(',')
else:
omit = [
'*/test*',
'*/termstyle*',
'*/colorama*',
'*/mock*',
'*/django/*',
'*/pytz*', # pulled in by django
'*/pkg_resources*', # pulled in by django
'*/pypy*',
tempfile.gettempdir() + '*']
if 'green' not in new_args.targets and (
False in [t.startswith('green.') for t in new_args.targets]):
omit.extend([
'*Python.framework*',
'*site-packages*'])
new_args.omit = omit
if new_args.run_coverage:
if not coverage:
print(
"Fatal: The 'coverage' module is not installed. Have you "
"run 'pip install coverage' ???")
args.shouldExit = True
args.exitCode = 3
return args
if (not testing) or coverage_testing:
cov = coverage.coverage(data_file='.coverage', omit=omit)
cov.start()
new_args.cov = cov
return new_args
def mergeConfig(args, testing=False): # pragma: no cover
"""
I take in a namespace created by the ArgumentParser in cmdline.main() and
merge in options from configuration files. The config items only replace
argument items that are set to default value.
Returns: I return a new argparse.Namespace, adding members:
shouldExit = default False
exitCode = default 0
include patterns = include-patterns setting converted to list.
omit_patterns = omit-patterns settings converted to list and
extended, taking clear-omit into account.
cov = coverage object default None
"""
config = getConfig(getattr(args, 'config', default_args.config))
new_args = copy.deepcopy(default_args) # Default by default!
for name, default_value in dict(default_args._get_kwargs()).items():
# Config options overwrite default options
config_getter = None
if name in ['termcolor', 'notermcolor', 'allow_stdout', 'quiet_stdout',
'help', 'logging', 'version', 'failfast', 'run_coverage',
'options', 'completions', 'completion_file', 'clear_omit',
'no_skip_report', 'disable_windows']:
config_getter = config.getboolean
elif name in ['processes', 'debug', 'verbose']:
config_getter = config.getint
elif name in ['file_pattern', 'finalizer', 'initializer',
'include_patterns', 'omit_patterns', 'warnings', 'test_pattern']:
config_getter = config.get
elif name in ['targets', 'help', 'config']:
pass # Some options only make sense coming on the command-line.
elif name in ['store_opt', 'parser']:
pass # These are convenience objects, not actual settings
else:
raise NotImplementedError(name)
if config_getter:
try:
config_value = config_getter('green', name.replace('_','-'))
setattr(new_args, name, config_value)
except (configparser.NoSectionError, configparser.NoOptionError):
pass
# Command-line values overwrite defaults and config values when
# specified
args_value = getattr(args, name, 'unspecified')
if args_value != 'unspecified':
setattr(new_args, name, args_value)
new_args.shouldExit = False
new_args.exitCode = 0
new_args.cov = None
# Help?
if new_args.help: # pragma: no cover
new_args.parser.print_help()
new_args.shouldExit = True
return new_args
# Did we just print the version?
if new_args.version:
from green.version import pretty_version
sys.stdout.write(pretty_version()+'\n')
new_args.shouldExit = True
return new_args
# Handle logging options
if new_args.debug:
logging.basicConfig(
level=logging.DEBUG,
format="%(asctime)s %(levelname)9s %(message)s",
datefmt="%Y-%m-%d %H:%M:%S")
elif not new_args.logging:
logging.basicConfig(filename=os.devnull)
# Disable termcolor?
if new_args.notermcolor:
new_args.termcolor = False
# Coverage. We must enable it here because we cannot cover module-level
# code after it is imported, and this is the earliest place we can turn on
# coverage.
omit_patterns = [
'*/argparse*',
'*/colorama*',
'*/django/*',
'*/distutils*', # Gets pulled in on Travis-CI CPython
'*/extras*', # pulled in by testtools
'*/linecache2*', # pulled in by testtools
'*/mimeparse*', # pulled in by testtools
'*/mock*',
'*/pbr*', # pulled in by testtools
'*/pkg_resources*', # pulled in by django
'*/pypy*',
'*/pytz*', # pulled in by django
'*/six*', # pulled in by testtools
'*/termstyle*',
'*/test*',
'*/traceback2*', # pulled in by testtools
'*/unittest2*', # pulled in by testtools
'*Python.framework*', # OS X system python
'*site-packages*', # System python for other OS's
tempfile.gettempdir() + '*',
]
if new_args.clear_omit:
omit_patterns = []
if new_args.omit_patterns:
omit_patterns.extend(new_args.omit_patterns.split(','))
new_args.omit_patterns = omit_patterns
if new_args.include_patterns:
new_args.include_patterns = new_args.include_patterns.split(',')
else:
new_args.include_patterns = []
if new_args.run_coverage:
if not coverage:
print(
"Fatal: The 'coverage' module is not installed. Have you "
"run 'pip install coverage' ???")
args.shouldExit = True
args.exitCode = 3
return args
if not testing:
cov = coverage.coverage(data_file='.coverage', omit=omit_patterns,
include=new_args.include_patterns)
cov.start()
new_args.cov = cov
return new_args
def main(testing=False, coverage_testing=False):
parser = argparse.ArgumentParser(
add_help=False,
description="Green is a clean, colorful test runner for Python unit tests.")
target_args = parser.add_argument_group("Target Specification")
target_args.add_argument('targets', action='store', nargs='*', default=['.'],
help=("""Targets to test. If blank, then discover all testcases in the
current directory tree. Can be a directory (or package), file (or
module), or fully-qualified 'dotted name' like
proj.tests.test_things.TestStuff. If a directory (or package)
is specified, then we will attempt to discover all tests under the
directory (even if the directory is a package and the tests would not
be accessible through the package's scope). In all other cases,
only tests accessible from introspection of the object will be
loaded."""))
concurrency_args = parser.add_argument_group("Concurrency Options")
concurrency_args.add_argument('-s', '--subprocesses', action='store',
type=int, default=1, metavar='NUM',
help="Number of subprocesses to use to run tests. Note that your "
"tests need to be written to avoid using the same resources (temp "
"files, sockets, ports, etc.) for the multi-process mode to work "
"well. Default is 1, meaning try to autodetect the number of CPUs "
"in the system. 1 will disable using subprocesses. Note that for "
"trivial tests (tests that take < 1ms), running everything in a "
"single process may be faster.")
format_args = parser.add_argument_group("Format Options")
format_args.add_argument('-m', '--html', action='store_true', default=False,
help="HTML5 format. Overrides terminal color options if specified.")
format_args.add_argument('-t', '--termcolor', action='store_true',
default=None,
help="Force terminal colors on. Default is to autodetect.")
format_args.add_argument('-T', '--notermcolor', action='store_true',
default=None,
help="Force terminal colors off. Default is to autodetect.")
out_args = parser.add_argument_group("Output Options")
out_args.add_argument('-d', '--debug', action='count', default=0,
help=("Enable internal debugging statements. Implies --logging. Can "
"be specified up to three times for more debug output."))
out_args.add_argument('-h', '--help', action='store_true', default=False,
help="Show this help message and exit.")
out_args.add_argument('-l', '--logging', action='store_true', default=False,
help="Don't configure the root logger to redirect to /dev/null")
out_args.add_argument('-V', '--version', action='store_true', default=False,
help="Print the version of Green and Python and exit.")
out_args.add_argument('-v', '--verbose', action='count', default=1,
help=("Verbose. Can be specified up to three times for more verbosity. "
"Recommended levels are -v and -vv."))
cov_args = parser.add_argument_group(
"Coverage Options ({})".format(coverage_version))
cov_args.add_argument('-r', '--run-coverage', action='store_true',
default=False,
help=("Produce coverage output."))
cov_args.add_argument('-o', '--omit', action='store', default=None,
metavar='PATTERN',
help=("Comma-separated file-patterns to omit from coverage. Default "
"is something like '*/test*,*/termstyle*,*/mock*,*(temp "
"dir)*,*(python system packages)*'"))
args = parser.parse_args()
# Clear out all the passed-in-options just in case someone tries to run a
# test that assumes sys.argv is clean. I can't guess at the script name
# that they want, though, so we'll just leave ours.
sys.argv = sys.argv[:1]
# Help?
if args.help: # pragma: no cover
parser.print_help()
return 0
# Just print version and exit?
if args.version:
from green.version import pretty_version
sys.stdout.write(pretty_version()+'\n')
return 0
# Handle logging options
if args.debug:
logging.basicConfig(
level=logging.DEBUG,
format="%(asctime)s %(levelname)9s %(message)s")
elif not args.logging:
logging.basicConfig(filename=os.devnull)
# These options both disable termcolor
if args.html or args.notermcolor:
args.termcolor = False
# Coverage?
omit = []
if args.run_coverage:
if args.omit:
omit = args.omit.split(',')
else:
omit = [
'*/test*',
'*/termstyle*',
'*/mock*',
tempfile.gettempdir() + '*']
if 'green' not in args.targets and (False in [t.startswith('green.') for t in args.targets]):
omit.extend([
'*Python.framework*',
'*site-packages*'])
if not coverage:
sys.stderr.write(
"Fatal: The 'coverage' module is not installed. Have you "
"run 'pip install coverage'???")
return 3
if (not testing) or coverage_testing:
cov = coverage.coverage(data_file='.coverage', omit=omit)
cov.start()
# Set up our various main objects
from green.loader import getTests
from green.runner import GreenTestRunner
from green.output import GreenStream
import green.output
if args.debug:
green.output.debug_level = args.debug
stream = GreenStream(sys.stderr, html = args.html)
runner = GreenTestRunner(verbosity = args.verbose, stream = stream,
termcolor=args.termcolor, subprocesses=args.subprocesses,
run_coverage=args.run_coverage, omit=omit)
# Discover/Load the TestSuite
tests = getTests(args.targets)
# We didn't even load 0 tests...
if not tests:
logging.debug(
"No test loading attempts succeeded. Created an empty test suite.")
tests = unittest.suite.TestSuite()
# Actually run the tests
if testing:
result = lambda: None
result.wasSuccessful = lambda: 0
else:
result = runner.run(tests) # pragma: no cover
if args.run_coverage and ((not testing) or coverage_testing):
stream.writeln()
cov.stop()
cov.save()
cov.combine()
cov.save()
cov.report(file=stream, omit=omit)
return(int(not result.wasSuccessful()))
def mergeConfig(args, testing=False): # pragma: no cover
"""
I take in a namespace created by the ArgumentParser in cmdline.main() and
merge in options from configuration files. The config items only replace
argument items that are set to default value.
Returns: I return a new argparse.Namespace, adding members:
shouldExit = default False
exitCode = default 0
omit_patterns = omit-patterns settings converted to list and extended,
taking clear-omit into account.
cov = coverage object default None
"""
config = getConfig(getattr(args, "config", default_args.config))
new_args = copy.deepcopy(default_args) # Default by default!
for name, default_value in dict(default_args._get_kwargs()).items():
# Config options overwrite default options
config_getter = None
if name in [
"termcolor",
"notermcolor",
"allow_stdout",
"help",
"logging",
"version",
"failfast",
"run_coverage",
"options",
"completions",
"completion_file",
"clear_omit",
"no_skip_report",
]:
config_getter = config.getboolean
elif name in ["processes", "debug", "verbose"]:
config_getter = config.getint
elif name in ["file_pattern", "finalizer", "initializer", "omit_patterns", "warnings", "test_pattern"]:
config_getter = config.get
elif name in ["targets", "help", "config"]:
pass # Some options only make sense coming on the command-line.
elif name in ["store_opt", "parser"]:
pass # These are convenience objects, not actual settings
else:
raise NotImplementedError(name)
if config_getter:
try:
config_value = config_getter("green", name.replace("_", "-"))
setattr(new_args, name, config_value)
except (configparser.NoSectionError, configparser.NoOptionError):
pass
# Command-line values overwrite defaults and config values when
# specified
args_value = getattr(args, name, "unspecified")
if args_value != "unspecified":
setattr(new_args, name, args_value)
new_args.shouldExit = False
new_args.exitCode = 0
new_args.cov = None
# Help?
if new_args.help: # pragma: no cover
new_args.parser.print_help()
new_args.shouldExit = True
return new_args
# Did we just print the version?
if new_args.version:
from green.version import pretty_version
sys.stdout.write(pretty_version() + "\n")
new_args.shouldExit = True
return new_args
# Handle logging options
if new_args.debug:
logging.basicConfig(
level=logging.DEBUG, format="%(asctime)s %(levelname)9s %(message)s", datefmt="%Y-%m-%d %H:%M:%S"
)
elif not new_args.logging:
logging.basicConfig(filename=os.devnull)
# Disable termcolor?
if new_args.notermcolor:
new_args.termcolor = False
# Coverage. We must enable it here because we cannot cover module-level
# code after it is imported, and this is the earliest place we can turn on
# coverage.
omit_patterns = [
"*/argparse*",
"*/colorama*",
"*/django/*",
"*/distutils*", # Gets pulled in on Travis-CI CPython
"*/extras*", # pulled in by testtools
"*/linecache2*", # pulled in by testtools
"*/mimeparse*", # pulled in by testtools
"*/mock*",
"*/pbr*", # pulled in by testtools
"*/pkg_resources*", # pulled in by django
"*/pypy*",
"*/pytz*", # pulled in by django
"*/six*", # pulled in by testtools
"*/termstyle*",
"*/test*",
"*/traceback2*", # pulled in by testtools
"*/unittest2*", # pulled in by testtools
"*Python.framework*", # OS X system python
"*site-packages*", # System python for other OS's
tempfile.gettempdir() + "*",
]
if new_args.clear_omit:
omit_patterns = []
if new_args.omit_patterns:
omit_patterns.extend(new_args.omit_patterns.split(","))
new_args.omit_patterns = omit_patterns
if new_args.run_coverage:
if not coverage:
print("Fatal: The 'coverage' module is not installed. Have you " "run 'pip install coverage' ???")
args.shouldExit = True
args.exitCode = 3
return args
if not testing:
cov = coverage.coverage(data_file=".coverage", omit=omit_patterns)
cov.start()
new_args.cov = cov
return new_args
def mergeConfig(args, testing=False): # pragma: no cover
"""
I take in a namespace created by the ArgumentParser in cmdline.main() and
merge in options from configuration files. The config items only replace
argument items that are set to default value.
Returns: I return a new argparse.Namespace, adding members:
shouldExit = default False
exitCode = default 0
include patterns = include-patterns setting converted to list.
omit_patterns = omit-patterns settings converted to list and
extended, taking clear-omit into account.
cov = coverage object default None
"""
config = getConfig(getattr(args, "config", default_args.config))
new_args = copy.deepcopy(default_args) # Default by default!
for name, default_value in dict(default_args._get_kwargs()).items():
# Config options overwrite default options
config_getter = None
if name in [
"termcolor",
"notermcolor",
"allow_stdout",
"quiet_stdout",
"help",
"logging",
"version",
"disable_unidecode",
"failfast",
"run_coverage",
"options",
"completions",
"completion_file",
"clear_omit",
"no_skip_report",
"no_tracebacks",
"disable_windows",
"quiet_coverage",
]:
config_getter = config.getboolean
elif name in ["processes", "debug", "verbose", "minimum_coverage"]:
config_getter = config.getint
elif name in [
"file_pattern",
"finalizer",
"initializer",
"cov_config_file",
"include_patterns",
"omit_patterns",
"warnings",
"test_pattern",
"junit_report",
]:
config_getter = config.get
elif name in ["targets", "help", "config"]:
pass # Some options only make sense coming on the command-line.
elif name in ["store_opt", "parser"]:
pass # These are convenience objects, not actual settings
else:
raise NotImplementedError(name)
if config_getter:
try:
config_value = config_getter("green", name.replace("_", "-"))
setattr(new_args, name, config_value)
except (configparser.NoSectionError, configparser.NoOptionError):
pass
# Command-line values overwrite defaults and config values when
# specified
args_value = getattr(args, name, "unspecified")
if args_value != "unspecified":
setattr(new_args, name, args_value)
new_args.shouldExit = False
new_args.exitCode = 0
new_args.cov = None
# Help?
if new_args.help: # pragma: no cover
new_args.parser.print_help()
new_args.shouldExit = True
return new_args
# Did we just print the version?
if new_args.version:
from green.version import pretty_version
sys.stdout.write(pretty_version() + "\n")
new_args.shouldExit = True
return new_args
# Handle logging options
if new_args.debug:
logging.basicConfig(
level=logging.DEBUG,
format="%(asctime)s %(levelname)9s %(message)s",
datefmt="%Y-%m-%d %H:%M:%S",
)
elif not new_args.logging:
logging.basicConfig(filename=os.devnull)
# Disable termcolor?
if new_args.notermcolor:
new_args.termcolor = False
# Coverage. We must enable it here because we cannot cover module-level
# code after it is imported, and this is the earliest place we can turn on
# coverage.
omit_patterns = [
"*/argparse*",
"*/colorama*",
"*/django/*",
"*/distutils*", # Gets pulled in on Travis-CI CPython
"*/extras*", # pulled in by testtools
"*/linecache2*", # pulled in by testtools
"*/mimeparse*", # pulled in by testtools
"*/mock*",
"*/pbr*", # pulled in by testtools
"*/pkg_resources*", # pulled in by django
"*/pypy*",
"*/pytz*", # pulled in by django
"*/six*", # pulled in by testtools
"*/termstyle*",
"*/test*",
"*/traceback2*", # pulled in by testtools
"*/unittest2*", # pulled in by testtools
"*Python.framework*", # OS X system python
"*site-packages*", # System python for other OS's
tempfile.gettempdir() + "*",
]
if new_args.clear_omit:
omit_patterns = []
if new_args.omit_patterns:
omit_patterns.extend(new_args.omit_patterns.split(","))
new_args.omit_patterns = omit_patterns
if new_args.include_patterns:
new_args.include_patterns = new_args.include_patterns.split(",")
else:
new_args.include_patterns = []
if new_args.quiet_coverage or (type(new_args.cov_config_file) == str):
new_args.run_coverage = True
if new_args.minimum_coverage != None:
new_args.run_coverage = True
if new_args.run_coverage:
if not testing:
cov = coverage.coverage(
data_file=".coverage",
omit=omit_patterns,
include=new_args.include_patterns,
config_file=new_args.cov_config_file,
)
cov.start()
new_args.cov = cov
return new_args
