Viewing file:  TestSuite.py (11.39 KB) -rw-r--r--
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
########################################################################
# $Header: /var/local/cvsroot/4Suite/Ft/Lib/TestSuite/TestSuite.py,v 1.12 2002/12/19 20:31:13 jkloth Exp $
"""
Provides the TestSuite class, which represents the package(s) to test.
Copyright 2002 Fourthought, Inc. (USA).
Detailed license and copyright information: http://4suite.org/COPYRIGHT
Project home, documentation, distributions: http://4suite.org/
"""
__revision__ = "$Id: TestSuite.py,v 1.12 2002/12/19 20:31:13 jkloth Exp $"
import getopt, sys, os, imp
from types import *
import TestModule, Tester
from Errors import *
USAGE = """\
Usage:
%(script)s [options] [test] [...]
%(script)s --help-tests
%(script)s --help
%(script)s --help [test]
Examples:
%(script)s run default set of tests
%(script)s directory run all tests in 'directory'
%(script)s directory%(sep)sfile run just 'file' from 'directory'
"""
class TestSuite:
"""
A command-line program that runs a set of tests; this is primarily
for making test modules conveniently executable.
"""
options = [
('help', 'h', 'Show detailed help message'),
('help-tests', 't', 'List all available tests'),
('verbose', 'v', 'Increase display verbosity'),
('quiet', 'q', 'Decrease display verbosity'),
('mode=', 'm', 'Add mode to default modes to run'),
('skip=', 'k', 'Remove a mode from the modes to run'),
('full', 'f', 'Use all modes'),
('stop', 's', 'Stop on errors'),
('nocolor', 'n', 'Disable ANSI color sequences'),
('noreport', 'r', 'Disable report generation'),
('outfile=', 'o', 'Specify an output file for all results'),
('offline', 'l', 'Skip tests requiring internet connection')
]
negative_opts = {'quiet' : 'verbose',
'nocolor' : 'color',
'noreport' : 'report',
}
# options that can only be true or false
boolean_opts = ('full', 'stop', 'nocolor', 'noreport', 'offline',
'help', 'help-tests')
def __init__(self, attrs):
# Default values for command-line options
self.verbose = 2 # counter
self.mode = [] # string list
self.skip = [] # string list
self.full = 0 # boolean
self.stop = 0 # boolean
self.color = 1 # boolean
self.report = 1 # boolean
self.outfile = '' # string
self.offline = 0 # boolean
self.help = 0 # boolean
self.help_tests = 0 # boolean
# 'script_name' and 'script_args' are usually set to sys.argv[0]
# and sys.argv[1:], but they can be overridden when the caller is
# not necessarily a setup script run from the command-line.
self.script_name = None
self.script_args = None
self.name = None
self.packages = None
# Now we'll use the attrs dictionary (ultimately, keyword args from
# the setup script) to possibly override any or all of these
# distribution options.
for key, value in attrs.items():
if hasattr(self, key):
setattr(self, key, value)
else:
raise TestSuiteSetupError('invalid test option %r' % key)
return
def _grokOptions(self):
long_opts = []
short_opts = []
short2long = {}
for option in self.options:
try:
(long, short, help) = option
except ValueError:
raise TestSuiteInternalError, \
'invalid option tuple %r' % option
# Type and value check the option names
if not isinstance(long, StringType) or len(long) < 2:
raise TestSuiteInternalError, \
'invalid long option %r' % long
if short and not isinstance(short, StringType) and len(short) > 1:
raise TestSuiteInternalError, \
'invalid short option %r' % short
long_opts.append(long)
if short:
if long.endswith('='):
short = short + ':'
long = long[:-1]
short2long[short[0]] = long
short_opts.append(short)
return (''.join(short_opts), long_opts, short2long)
def _getopt(self, args):
short_opts, long_opts, short2long = self._grokOptions()
parsed_args = []
parsed_opts = []
while args:
try:
opts, args = getopt.getopt(args, short_opts, long_opts)
except getopt.error, error:
raise TestSuiteArgumentError(str(error))
# Convert all options to their long form
for opt, value in opts:
if len(opt) == 2 and opt[0] == '-':
# a short option
opt = short2long[opt[1]]
else:
# a long option
opt = opt[2:]
parsed_opts.append((opt, value))
# Scan the arguments for any remaining options
while args and args[0][0] != '-':
path = args.pop(0)
# If the arg is an existing file/directory, convert it to a
# Python package path, otherwise assume a valid package.
if os.path.exists(path):
# Convert path to pkg.mod notation
path = os.path.normpath(path)
dirname = os.path.dirname(path)
modname = TestModule.GetModuleName(path)
if dirname:
names = dirname.split(os.sep)
names.append(modname)
path = '.'.join(names)
else:
path = modname
# Add Python package path to the parsed arguments
parsed_args.append(path)
# Handle the options now
for (name, value) in parsed_opts:
if name in self.boolean_opts:
# If specified it must be true
value = 1
alias = self.negative_opts.get(name)
if alias:
attr = alias.replace('-', '_')
else:
attr = name.replace('-', '_')
if not hasattr(self, attr):
raise TestSuiteInternalError, \
"missing attribute for option %r" % name
current = getattr(self, attr)
if name in self.boolean_opts:
# boolean
if alias:
setattr(self, attr, 0)
else:
setattr(self, attr, 1)
elif isinstance(current, IntType):
# counter
if alias:
setattr(self, attr, current - 1)
else:
setattr(self, attr, current + 1)
elif isinstance(current, ListType):
# string list
if alias:
while value in current:
current.remove(value)
else:
current.append(value)
elif isinstance(current, StringType):
# string
setattr(self, attr, value)
else:
raise TestSuiteInternalError, \
"unknown type for option %r" % name
return parsed_args
def addTests(self, packages):
for package in packages:
testobj = self.test
for step in package.split('.'):
# See if this step has already been added
for test in testobj.tests:
if test.name == step:
# Found an existing test, reuse it
testobj = test
break
else:
# Create a new test
testobj = testobj.addTest(step)
return
def parseCommandLine(self):
"""
Parse the test script's command line, taken from the 'script_args'
instance attribute (which defaults to 'sys.argv[1:]'). This is
first processed for options that set attributes of the TestSuite
instance. Then, it is scanned for test arguments.
"""
packages = self._getopt(self.script_args)
self.test = TestModule.TestModule(self.name, None,
self.mode, self.skip, self.full)
if self.help_tests:
# ignore any supplied arguments
print self.generateUsage()
print 'Available tests:'
self.showTests()
return 0 # done
if self.help:
# display usage and if there are tests specified info about them
self.showHelp(packages)
return 0 # done
self.addTests(packages or self.packages)
# Signal caller that is OK to continue
return 1
def showTests(self):
indent = ' '*2
self.addTests(self.packages)
for test in self.test.getTests():
test.showTests(indent)
return
def generateUsage(self):
usage = USAGE % {'script' : os.path.basename(self.script_name),
'sep' : os.sep}
return usage
def showHelp(self, tests):
print self.generateUsage()
# Display the options
print 'Options:'
display_opts = []
max_opt = 0
for opt in self.options:
long = opt[0]
if long[-1] == '=':
long = '%s<%s>' % (long, long[:-1])
display = '-%s, --%s' % (opt[1], long)
display_opts.append((display, opt[2]))
if len(display) > max_opt:
max_opt = len(display)
for display, help in display_opts:
print ' %-*s %s' % (max_opt, display, help)
print
# Display detailed help for the given tests
for path in tests:
modes = []
testobj = self.test
for step in path.split('.'):
testobj = testobj.loadTest(step)
for mode in testobj.getModes([], [], 1):
if mode.name:
modes.append((mode.name, testobj.path))
if modes:
print 'Modes for %r:' % testobj.path
for (name, path) in modes:
if path != testobj.path:
print " %s (declared in %s)" % (name, path)
else:
print " %s" % name
print
subtests = [ test for test in testobj.getTests()
if isinstance(test, TestModule.TestModule) ]
if subtests:
print 'Sub-tests for %r:' % testobj.path
for test in subtests:
print " %s" % test.name
print
return
def runTests(self):
tester = Tester.Tester(self.stop, self.color, self.verbose)
tester.offline = self.offline
try:
for test in self.test.getTests():
test.run(tester)
except KeyboardInterrupt:
sys.stderr.write('\n%s\n' % ('='*72))
sys.stderr.write('\nTesting interrupted\n')
if self.report:
tester.report()
return
|