def test_completionEmpty(self):
"An empty target generates completions for the whole directory"
cwd = os.getcwd()
tmpdir = tempfile.mkdtemp()
os.chdir(tmpdir)
os.mkdir('the_pkg')
fh = open(os.path.join('the_pkg', '__init__.py'), 'w')
fh.write('')
fh.close()
fh = open(os.path.join('the_pkg', 'test_things.py'), 'w')
fh.write(
"""
import unittest
class A(unittest.TestCase):
def testOne(self):
pass
def testTwo(self):
pass
""")
fh.close()
c = set(loader.getCompletions('').split('\n'))
self.assertIn('the_pkg', c)
self.assertIn('the_pkg.test_things', c)
self.assertIn('the_pkg.test_things.A.testOne', c)
self.assertIn('the_pkg.test_things.A.testTwo', c)
os.chdir(cwd)
shutil.rmtree(tmpdir)
def test_completionEmpty(self):
"""
An empty target generates completions for the whole directory
"""
cwd = os.getcwd()
tmpdir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, tmpdir)
os.chdir(tmpdir)
self.addCleanup(os.chdir, cwd)
os.mkdir("the_pkg")
fh = open(os.path.join("the_pkg", "__init__.py"), "w")
fh.write("")
fh.close()
fh = open(os.path.join("the_pkg", "test_things.py"), "w")
fh.write(
dedent(
"""
import unittest
class A(unittest.TestCase):
def testOne(self):
pass
def testTwo(self):
pass
"""
)
)
fh.close()
c = set(loader.getCompletions("").split("\n"))
self.assertIn("the_pkg", c)
self.assertIn("the_pkg.test_things", c)
self.assertIn("the_pkg.test_things.A.testOne", c)
self.assertIn("the_pkg.test_things.A.testTwo", c)
def test_completionDot(self):
"""
A '.' target generates completions for the whole directory
"""
cwd = os.getcwd()
tmpdir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, tmpdir)
os.chdir(tmpdir)
self.addCleanup(os.chdir, cwd)
os.mkdir('my_pkg')
fh = open(os.path.join('my_pkg', '__init__.py'), 'w')
fh.write('')
fh.close()
fh = open(os.path.join('my_pkg', 'test_things.py'), 'w')
fh.write(
dedent("""
import unittest
class A(unittest.TestCase):
def testOne(self):
pass
def testTwo(self):
pass
"""))
fh.close()
c = set(loader.getCompletions('.').split('\n'))
self.assertIn('my_pkg', c)
self.assertIn('my_pkg.test_things', c)
self.assertIn('my_pkg.test_things.A.testOne', c)
self.assertIn('my_pkg.test_things.A.testTwo', c)
def test_completionEmpty(self):
"""
An empty target generates completions for the whole directory
"""
cwd = os.getcwd()
tmpdir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, tmpdir)
os.chdir(tmpdir)
self.addCleanup(os.chdir, cwd)
os.mkdir("the_pkg")
fh = open(os.path.join("the_pkg", "__init__.py"), "w")
fh.write("")
fh.close()
fh = open(os.path.join("the_pkg", "test_things.py"), "w")
fh.write(
dedent(
"""
import unittest
class A(unittest.TestCase):
def testOne(self):
pass
def testTwo(self):
pass
"""
)
)
fh.close()
c = set(loader.getCompletions("").split("\n"))
self.assertIn("the_pkg", c)
self.assertIn("the_pkg.test_things", c)
self.assertIn("the_pkg.test_things.A.testOne", c)
self.assertIn("the_pkg.test_things.A.testTwo", c)
def test_completionDot(self):
"""
A '.' target generates completions for the whole directory
"""
cwd = os.getcwd()
tmpdir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, tmpdir)
os.chdir(tmpdir)
self.addCleanup(os.chdir, cwd)
os.mkdir('my_pkg')
fh = open(os.path.join('my_pkg', '__init__.py'), 'w')
fh.write('')
fh.close()
fh = open(os.path.join('my_pkg', 'test_things.py'), 'w')
fh.write(dedent(
"""
import unittest
class A(unittest.TestCase):
def testOne(self):
pass
def testTwo(self):
pass
"""))
fh.close()
c = set(loader.getCompletions('.').split('\n'))
self.assertIn('my_pkg', c)
self.assertIn('my_pkg.test_things', c)
self.assertIn('my_pkg.test_things.A.testOne', c)
self.assertIn('my_pkg.test_things.A.testTwo', c)
def test_completionPartial(self):
"Correct completions generated for partial match. 2nd target ignored."
c = set(loader.getCompletions(['green.te', 'green']).split('\n'))
self.assertIn('green.test', c)
self.assertIn('green.test.test_loader', c)
self.assertIn('green.test.test_loader.TestCompletions', c)
self.assertIn(
'green.test.test_loader.TestCompletions.test_completionPartial', c)
self.assertNotIn('green', c)
def test_completionExact(self):
"Correct completions are generated for an exact match."
c = set(loader.getCompletions('green').split('\n'))
self.assertIn('green', c)
self.assertIn('green.test', c)
self.assertIn('green.test.test_loader', c)
self.assertIn('green.test.test_loader.TestCompletions', c)
self.assertIn(
'green.test.test_loader.TestCompletions.test_completionExact', c)
def test_completionPartial(self):
"""
Correct completions generated for partial match. 2nd target ignored.
"""
c = set(loader.getCompletions(["green.te", "green"]).split("\n"))
self.assertIn("green.test", c)
self.assertIn("green.test.test_loader", c)
self.assertIn("green.test.test_loader.TestCompletions", c)
self.assertIn("green.test.test_loader.TestCompletions.test_completionPartial", c)
self.assertNotIn("green", c)
def test_completionExact(self):
"""
Correct completions are generated for an exact match.
"""
c = set(loader.getCompletions("green").split("\n"))
self.assertIn("green", c)
self.assertIn("green.test", c)
self.assertIn("green.test.test_loader", c)
self.assertIn("green.test.test_loader.TestCompletions", c)
self.assertIn("green.test.test_loader.TestCompletions.test_completionExact", c)
def test_completionExact(self):
"""
Correct completions are generated for an exact match.
"""
c = set(loader.getCompletions("green").split("\n"))
self.assertIn("green", c)
self.assertIn("green.test", c)
self.assertIn("green.test.test_loader", c)
self.assertIn("green.test.test_loader.TestCompletions", c)
self.assertIn("green.test.test_loader.TestCompletions.test_completionExact", c)
def test_completionExact(self):
"""
Correct completions are generated for an exact match.
"""
c = set(loader.getCompletions('green').split('\n'))
self.assertIn('green', c)
self.assertIn('green.test', c)
self.assertIn('green.test.test_loader', c)
self.assertIn('green.test.test_loader.TestCompletions', c)
self.assertIn(
'green.test.test_loader.TestCompletions.test_completionExact', c)
def test_completionPartial(self):
"""
Correct completions generated for partial match. 2nd target ignored.
"""
c = set(loader.getCompletions(['green.te', 'green']).split('\n'))
self.assertIn('green.test', c)
self.assertIn('green.test.test_loader', c)
self.assertIn('green.test.test_loader.TestCompletions', c)
self.assertIn(
'green.test.test_loader.TestCompletions.test_completionPartial', c)
self.assertNotIn('green', c)
def test_completionPartial(self):
"""
Correct completions generated for partial match. 2nd target ignored.
"""
c = set(loader.getCompletions(["green.te", "green"]).split("\n"))
self.assertIn("green.test", c)
self.assertIn("green.test.test_loader", c)
self.assertIn("green.test.test_loader.TestCompletions", c)
self.assertIn(
"green.test.test_loader.TestCompletions.test_completionPartial", c
)
self.assertNotIn("green", c)
def test_completionPartialShort(self):
"Correct completions generated for short partial match."
cwd = os.getcwd()
green_parent = dirname(dirname(dirname(os.path.abspath(__file__))))
os.chdir(green_parent)
c = set(loader.getCompletions('gre').split('\n'))
self.assertIn('green', c)
self.assertIn('green.test', c)
self.assertIn('green.test.test_loader', c)
self.assertIn('green.test.test_loader.TestCompletions', c)
self.assertIn(
'green.test.test_loader.TestCompletions.test_completionPartialShort', c)
os.chdir(cwd)
def test_completionPartialShort(self):
"""
Correct completions generated for short partial match.
"""
cwd = os.getcwd()
green_parent = dirname(dirname(dirname(os.path.abspath(__file__))))
os.chdir(green_parent)
self.addCleanup(os.chdir, cwd)
c = set(loader.getCompletions("gre").split("\n"))
self.assertIn("green", c)
self.assertIn("green.test", c)
self.assertIn("green.test.test_loader", c)
self.assertIn("green.test.test_loader.TestCompletions", c)
self.assertIn("green.test.test_loader.TestCompletions.test_completionPartialShort", c)
def test_completionPartialShort(self):
"""
Correct completions generated for short partial match.
"""
cwd = os.getcwd()
green_parent = dirname(dirname(dirname(os.path.abspath(__file__))))
os.chdir(green_parent)
self.addCleanup(os.chdir, cwd)
c = set(loader.getCompletions('gre').split('\n'))
self.assertIn('green', c)
self.assertIn('green.test', c)
self.assertIn('green.test.test_loader', c)
self.assertIn('green.test.test_loader.TestCompletions', c)
self.assertIn(
'green.test.test_loader.TestCompletions.test_completionPartialShort', c)
def test_completionIgnoresErrors(self):
"""
Errors in one module don't block the remaining completions
"""
cwd = os.getcwd()
tmpdir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, tmpdir)
os.chdir(tmpdir)
self.addCleanup(os.chdir, cwd)
os.mkdir("my_pkg2")
fh = open(os.path.join("my_pkg2", "__init__.py"), "w")
fh.write("")
fh.close()
fh = open(os.path.join("my_pkg2", "test_crash01.py"), "w")
contents = dedent(
"""
import unittest
class A(unittest.TestCase):
def testOne(self):
pass
def testTwo(self):
pass
"""
)
fh.write(contents)
fh.close()
fh = open(os.path.join("my_pkg2", "test_crash02.py"), "w")
fh.write("import moocow")
fh.close()
fh = open(os.path.join("my_pkg2", "test_crash03.py"), "w")
fh.write(contents)
fh.close()
c = set(loader.getCompletions(".").split("\n"))
self.assertIn("my_pkg2", c)
self.assertIn("my_pkg2.test_crash01", c)
self.assertIn("my_pkg2.test_crash01.A.testOne", c)
self.assertIn("my_pkg2.test_crash01.A.testTwo", c)
self.assertIn("my_pkg2.test_crash03", c)
self.assertIn("my_pkg2.test_crash03.A.testOne", c)
self.assertIn("my_pkg2.test_crash03.A.testTwo", c)
def test_completionIgnoresErrors(self):
"""
Errors in one module don't block the remaining completions
"""
cwd = os.getcwd()
tmpdir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, tmpdir)
os.chdir(tmpdir)
self.addCleanup(os.chdir, cwd)
os.mkdir("my_pkg2")
fh = open(os.path.join("my_pkg2", "__init__.py"), "w")
fh.write("")
fh.close()
fh = open(os.path.join("my_pkg2", "test_crash01.py"), "w")
contents = dedent(
"""
import unittest
class A(unittest.TestCase):
def testOne(self):
pass
def testTwo(self):
pass
"""
)
fh.write(contents)
fh.close()
fh = open(os.path.join("my_pkg2", "test_crash02.py"), "w")
fh.write("import moocow")
fh.close()
fh = open(os.path.join("my_pkg2", "test_crash03.py"), "w")
fh.write(contents)
fh.close()
c = set(loader.getCompletions(".").split("\n"))
self.assertIn("my_pkg2", c)
self.assertIn("my_pkg2.test_crash01", c)
self.assertIn("my_pkg2.test_crash01.A.testOne", c)
self.assertIn("my_pkg2.test_crash01.A.testTwo", c)
self.assertIn("my_pkg2.test_crash03", c)
self.assertIn("my_pkg2.test_crash03.A.testOne", c)
self.assertIn("my_pkg2.test_crash03.A.testTwo", c)
def test_completionIgnoresErrors(self):
"Errors in one module don't block the remaining completions"
cwd = os.getcwd()
tmpdir = tempfile.mkdtemp()
self.addCleanup(shutil.rmtree, tmpdir)
os.chdir(tmpdir)
self.addCleanup(os.chdir, cwd)
os.mkdir('my_pkg2')
fh = open(os.path.join('my_pkg2', '__init__.py'), 'w')
fh.write('')
fh.close()
fh = open(os.path.join('my_pkg2', 'test_crash01.py'), 'w')
contents = """
import unittest
class A(unittest.TestCase):
def testOne(self):
pass
def testTwo(self):
pass
"""
fh.write(contents)
fh.close()
fh = open(os.path.join('my_pkg2', 'test_crash02.py'), 'w')
fh.write("import moocow")
fh.close()
fh = open(os.path.join('my_pkg2', 'test_crash03.py'), 'w')
fh.write(contents)
fh.close()
c = set(loader.getCompletions('.').split('\n'))
self.assertIn('my_pkg2', c)
self.assertIn('my_pkg2.test_crash01', c)
self.assertIn('my_pkg2.test_crash01.A.testOne', c)
self.assertIn('my_pkg2.test_crash01.A.testTwo', c)
self.assertIn('my_pkg2.test_crash03', c)
self.assertIn('my_pkg2.test_crash03.A.testOne', c)
self.assertIn('my_pkg2.test_crash03.A.testTwo', c)
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 test_completionBad(self):
"""
Bad match generates no completions
"""
self.assertEqual("", loader.getCompletions("garbage.in"))
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()))
def test_completionBad(self):
"""
Bad match generates no completions
"""
self.assertEqual('', loader.getCompletions('garbage.in'))
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 test_completionBad(self):
"Bad match generates no completions"
self.assertEqual('', loader.getCompletions('garbage.in'))
