def test_overwrite(self):
"""
Non-default command-line argument values overwrite config values.
"""
# This config environment should set the values we look at to False and
# a filename in omit-patterns
s = StringIO()
gs = GreenStream(s)
saved_stdout = config.sys.stdout
config.sys.stdout = gs
self.addCleanup(setattr, config.sys, 'stdout', saved_stdout)
with ModifiedEnvironment(GREEN_CONFIG=self.env_filename,
HOME=self.tmpd):
new_args = copy.deepcopy(config.default_args)
new_args.omit_patterns = 'omitstuff'
new_args.run_coverage = True
new_args.logging = True
new_args.no_skip_report = True
new_args.version = True
new_args.config = self.cmd_filename
computed_args = config.mergeConfig(new_args, testing=True)
self.assertEqual(computed_args.omit_patterns, 'omitstuff')
self.assertEqual(computed_args.run_coverage, new_args.run_coverage)
self.assertEqual(computed_args.logging, new_args.logging)
self.assertEqual(computed_args.no_skip_report, new_args.no_skip_report)
self.assertEqual(computed_args.version, new_args.version)
def test_targets(self):
"The targets passed in make it through mergeConfig"
"The specified target gets parsed"
config.sys.argv = ['', 'target1', 'target2']
args = config.parseArguments()
args = config.mergeConfig(args)
self.assertEqual(args.targets, ['target1', 'target2'])
def run_tests(self, test_labels, extra_tests=None, **kwargs):
"""
Run the unit tests for all the test labels in the provided list.
Test labels should be dotted Python paths to test modules, test
classes, or test methods.
A list of 'extra' tests may also be provided; these tests
will be added to the test suite.
Returns the number of tests that failed.
"""
# Django setup
self.setup_test_environment()
django_db = self.setup_databases()
# Green
if type(test_labels) == tuple:
test_labels = list(test_labels)
else:
raise ValueError("test_labels should be a tuple of strings")
if not test_labels:
test_labels = ['.']
args = mergeConfig(default_args, default_args)
args.targets = test_labels
stream = GreenStream(sys.stdout)
suite = loadTargets(args.targets)
result = run(suite, stream, args)
# Django teardown
self.teardown_databases(django_db)
self.teardown_test_environment()
return self.suite_result(suite, result)
def test_targets(self):
"""
The targets passed in make it through mergeConfig, and the specified
target gets parsed
"""
config.sys.argv = ['', 'target1', 'target2']
args = config.parseArguments()
args = config.mergeConfig(args)
self.assertEqual(args.targets, ['target1', 'target2'])
def test_no_overwrite(self):
"""
Default command-line arguments do not overwrite config values.
"""
# This config environment should set logging to True
with ModifiedEnvironment(GREEN_CONFIG=self.env_filename, HOME=""):
# The default for logging in arguments is False
da = config.default_args
computed_args = config.mergeConfig(da, da)
self.assertEqual(computed_args.logging, True)
def test_no_overwrite(self):
"""
Default unspecified command-line args do not overwrite config values.
"""
# This config environment should set logging to True
with ModifiedEnvironment(GREEN_CONFIG=self.env_filename, HOME=""):
# The default for logging in arguments is False
da = copy.deepcopy(config.default_args)
del(da.logging)
computed_args = config.mergeConfig(da, testing=True)
self.assertEqual(computed_args.logging, True)
def run_test(path):
args = config.parseArguments()
args = config.mergeConfig(args)
args.verbose = 3
args.targets = path
stream = GreenStream(sys.stdout)
loader = GreenTestLoader()
test_suite = loader.loadTargets(args.targets)
result = run(test_suite, stream, args)
return result
def test_specified_command_line(self):
"""
Specified command-line arguments always overwrite config file values
"""
with ModifiedEnvironment(HOME=self.tmpd):
new_args = copy.deepcopy(config.default_args)
new_args.failfast = True # same as config, for sanity
new_args.logging = True # different than config, not default
del(new_args.version) # Not in arguments, should get config value
new_args.termcolor = False # override config, set back to default
computed_args = config.mergeConfig(new_args, testing=True)
self.assertEqual(computed_args.failfast, True)
self.assertEqual(computed_args.logging, True)
self.assertEqual(computed_args.version, False)
self.assertEqual(computed_args.termcolor, False)
def test_run_coverage(self, mock_loadTargets, mock_run, mock_GreenTestSuite, mock_mergeConfig):
"""
If no tests are found, we create an empty test suite and run it.
"""
args = mergeConfig(Namespace())
args.run_coverage = True
args.cov = MagicMock()
mock_mergeConfig.return_value = args
dr = djangorunner.DjangoRunner()
dr.setup_test_environment = MagicMock()
dr.setup_databases = MagicMock()
dr.teardown_databases = MagicMock()
dr.teardown_test_environment = MagicMock()
mock_loadTargets.return_value = None
mock_GreenTestSuite.return_value = 123
dr.run_tests((), testing=True)
self.assertEqual(mock_run.call_args[0][0], 123)
def test_run_coverage(self, mock_loadTargets, mock_run,
mock_GreenTestSuite, mock_mergeConfig):
"""
If no tests are found, we create an empty test suite and run it.
"""
args = mergeConfig(Namespace())
args.run_coverage = True
args.cov = MagicMock()
mock_mergeConfig.return_value = args
dr = djangorunner.DjangoRunner()
dr.setup_test_environment = MagicMock()
dr.setup_databases = MagicMock()
dr.teardown_databases = MagicMock()
dr.teardown_test_environment = MagicMock()
mock_loadTargets.return_value = None
mock_GreenTestSuite.return_value = 123
dr.run_tests((), testing=True)
self.assertEqual(mock_run.call_args[0][0], 123)
def run_tests(self, test_labels, extra_tests=None, **kwargs):
"""
Run the unit tests for all the test labels in the provided list.
Test labels should be dotted Python paths to test modules, test
classes, or test methods.
A list of 'extra' tests may also be provided; these tests
will be added to the test suite.
Returns the number of tests that failed.
"""
# Django setup
self.setup_test_environment()
django_db = self.setup_databases()
# Green
if type(test_labels) == tuple:
test_labels = list(test_labels)
else:
raise ValueError("test_labels should be a tuple of strings")
if not test_labels:
test_labels = ["."]
args = mergeConfig(Namespace())
if self.verbose != -1:
args.verbose = self.verbose
args.targets = test_labels
stream = GreenStream(sys.stdout)
suite = self.loader.loadTargets(args.targets)
if not suite:
suite = GreenTestSuite()
result = run(suite, stream, args)
# Django teardown
self.teardown_databases(django_db)
self.teardown_test_environment()
return self.suite_result(suite, result)
def _main(argv, testing):
args = config.parseArguments(argv)
args = config.mergeConfig(args, testing)
if args.shouldExit:
return args.exitCode
# 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]
# Set up our various main objects
from green.loader import GreenTestLoader, getCompletions
from green.runner import run
from green.output import GreenStream, debug
import green.output
from green.suite import GreenTestSuite
GreenTestSuite.args = args
if args.debug:
green.output.debug_level = args.debug
stream = GreenStream(sys.stdout, disable_windows=args.disable_windows)
# Location of shell completion file
if args.completion_file:
print(os.path.join(os.path.dirname(__file__), "shell_completion.sh"))
return 0
# Argument-completion for bash and zsh (for test-target completion)
if args.completions:
print(getCompletions(args.targets))
return 0
# Option-completion for bash and zsh
if args.options:
print("\n".join(sorted(args.store_opt.options)))
return 0
# Add debug logging for stuff that happened before this point here
if config.files_loaded:
debug("Loaded config file(s): {}".format(", ".join(
config.files_loaded)))
# Discover/Load the test suite
if testing:
test_suite = None
else: # pragma: no cover
loader = GreenTestLoader()
test_suite = loader.loadTargets(args.targets,
file_pattern=args.file_pattern)
# We didn't even load 0 tests...
if not test_suite:
debug(
"No test loading attempts succeeded. Created an empty test suite."
)
test_suite = GreenTestSuite()
# Actually run the test_suite
result = run(test_suite, stream, args, testing)
# Generate a test report if required
if args.junit_report:
from green.junit import JUnitXML
adapter = JUnitXML()
with open(args.junit_report, "w") as report_file:
adapter.save_as(result, report_file)
return int(not result.wasSuccessful())
def main(testing=False, coverage_testing=False):
args = config.parseArguments()
args = config.mergeConfig(args, testing, coverage_testing)
if getattr(args, 'html', False): # pragma: no cover
print("""
The --html flag is scheduled to be removed in version 2.0 due to it being a pain
to maintain and no one using it. If you actually use it, please open an issue
stating so! https://github.com/CleanCut/green/issues/new Unless some people
request it, it will be removed in 2.0
""")
import time
time.sleep(2)
if args.shouldExit:
return args.exitCode
# 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]
# Set up our various main objects
from green.loader import loadTargets
from green.runner import run
from green.output import GreenStream, debug
import green.output
from green.suite import GreenTestSuite
GreenTestSuite.args = args
if args.debug:
green.output.debug_level = args.debug
stream = GreenStream(sys.stdout, html = args.html)
# Location of shell completion file
if args.completion_file:
print(os.path.join(os.path.dirname(__file__), 'shell_completion.sh'))
return 0
# Argument-completion for bash and zsh (for test-target completion)
if args.completions:
from green.loader import getCompletions
print(getCompletions(args.targets))
return 0
# Option-completion for bash and zsh
if args.options:
print('\n'.join(sorted(args.store_opt.options)))
return 0
# Add debug logging for stuff that happened before this point here
if config.files_loaded:
debug("Loaded config file(s): {}".format(
', '.join(config.files_loaded)))
# Discover/Load the test suite
if testing:
test_suite = None
else:
test_suite = loadTargets(args.targets, file_pattern = args.file_pattern)
# We didn't even load 0 tests...
if not test_suite:
debug(
"No test loading attempts succeeded. Created an empty test suite.")
test_suite = GreenTestSuite()
# Actually run the test_suite
if testing:
result = lambda: None
result.wasSuccessful = lambda: 0
else:
result = run(test_suite, stream, args) # pragma: no cover
if args.run_coverage and ((not testing) or coverage_testing):
stream.writeln()
args.cov.stop()
args.cov.save()
args.cov.combine()
args.cov.save()
args.cov.report(file=stream, omit=args.omit_patterns)
return(int(not result.wasSuccessful()))
def main(testing=False):
args = config.parseArguments()
args = config.mergeConfig(args, testing)
if args.shouldExit:
return args.exitCode
# 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]
# Set up our various main objects
from green.loader import loadTargets
from green.runner import run
from green.output import GreenStream, debug
import green.output
from green.suite import GreenTestSuite
GreenTestSuite.args = args
if args.debug:
green.output.debug_level = args.debug
stream = GreenStream(sys.stdout, disable_windows=args.disable_windows)
# Location of shell completion file
if args.completion_file:
print(os.path.join(os.path.dirname(__file__), 'shell_completion.sh'))
return 0
# Argument-completion for bash and zsh (for test-target completion)
if args.completions:
from green.loader import getCompletions
print(getCompletions(args.targets))
return 0
# Option-completion for bash and zsh
if args.options:
print('\n'.join(sorted(args.store_opt.options)))
return 0
# Add debug logging for stuff that happened before this point here
if config.files_loaded:
debug("Loaded config file(s): {}".format(
', '.join(config.files_loaded)))
# Discover/Load the test suite
if testing:
test_suite = None
else: # pragma: no cover
test_suite = loadTargets(args.targets, file_pattern=args.file_pattern)
# We didn't even load 0 tests...
if not test_suite:
debug(
"No test loading attempts succeeded. Created an empty test suite.")
test_suite = GreenTestSuite()
# Actually run the test_suite
result = run(test_suite, stream, args, testing)
return(int(not result.wasSuccessful()))
def main(testing=False, coverage_testing=False):
args = config.parseArguments()
args = config.mergeConfig(args, testing, coverage_testing)
if args.shouldExit:
return args.exitCode
# 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]
# Set up our various main objects
from green.loader import loadTargets
from green.runner import GreenTestRunner
from green.output import GreenStream, debug
import green.output
if args.debug:
green.output.debug_level = args.debug
stream = GreenStream(sys.stdout, html = args.html)
runner = GreenTestRunner(verbosity = args.verbose, stream = stream,
termcolor=args.termcolor, subprocesses=args.subprocesses,
run_coverage=args.run_coverage, omit=args.omit)
# Location of shell completion file
if args.completion_file:
print(os.path.join(os.path.dirname(__file__), 'shell_completion.sh'))
return 0
# Argument-completion for bash and zsh (for test-target completion)
if args.completions:
from green.loader import getCompletions
print(getCompletions(args.targets))
return 0
# Option-completion for bash and zsh
if args.options:
print('\n'.join(sorted(args.store_opt.options)))
return 0
# Add debug logging for stuff that happened before this point here
if config.files_loaded:
debug("Loaded config file(s): {}".format(
', '.join(config.files_loaded)))
# Discover/Load the TestSuite
if testing:
test_suite = None
else:
test_suite = loadTargets(args.targets)
# We didn't even load 0 tests...
if not test_suite:
debug(
"No test loading attempts succeeded. Created an empty test suite.")
test_suite = unittest.suite.TestSuite()
# Actually run the test_suite
if testing:
result = lambda: None
result.wasSuccessful = lambda: 0
else:
result = runner.run(test_suite) # pragma: no cover
if args.run_coverage and ((not testing) or coverage_testing):
stream.writeln()
args.cov.stop()
args.cov.save()
args.cov.combine()
args.cov.save()
args.cov.report(file=stream, omit=args.omit)
return(int(not result.wasSuccessful()))
