def __call__(self, *args, **kwargs):
"""Invoke the test.
The test is "kicked-off" by calling this. Any arguments are passed to
the test implementation (`execute` method).
"""
self._report.add_heading(self.test_name, 2)
if args or kwargs:
self._report.add_message("TESTARGUMENTS", ReprArgs(args, kwargs),
2)
self.starttime = timelib.now() # saved starttime in case initializer
# needs to create the log file.
rv = None # in case of exception
rv = self._initialize(rv)
if rv is not None: # an exception happened
return rv
# test elapsed time does not include initializer time.
teststarttime = timelib.now()
# run the execute() method and check for exceptions.
try:
rv = self.execute(*args, **kwargs)
except KeyboardInterrupt:
if self._debug:
ex, val, tb = sys.exc_info()
debugger.post_mortem(tb, ex, val)
rv = self.Incomplete("%s: aborted by user." % self.test_name)
self._finalize(rv)
raise
except TestFailError, errval:
rv = self.Failed("Caught Fail exception: %s" % (errval, ))
def _finalize(self):
"""Run the finalize phase for suite level.
Runs the user finalize and aborts the suite on error or interrupt. If
this is a sub-suite then TestSuiteAbort is raised so that the
top-level suite can handle it.
"""
try:
self.finalize()
except KeyboardInterrupt:
if self._nested:
raise TestSuiteAbort, \
"Suite '%s' aborted by user in finalize()." % (self.suite_name,)
else:
self.Info("Suite aborted by user in finalize().")
except:
ex, val, tb = sys.exc_info()
if self._debug:
print # ensure debugger prompts starts on new line.
debugger.post_mortem(tb, ex, val)
self.Info("Suite failed to finalize: %s (%s)" % (ex, val))
if self._nested:
raise TestSuiteAbort, \
"subordinate suite '%s' failed to finalize." % (self.test_name,)
self._reportSummary()
return self.result
def _lambda(*iargs, **ikwargs):
try:
return meth(*iargs, **ikwargs)
except:
ex, val, tb = sys.exc_info()
from pycopia import debugger
debugger.post_mortem(tb, ex, val)
def _finalize(self):
try:
self.finalize()
except KeyboardInterrupt:
if self._nested:
raise TestSuiteAbort(
"Suite {!r} aborted by user in finalize().".format(
self.test_name))
else:
self.info("Suite aborted by user in finalize().")
except:
ex, val, tb = sys.exc_info()
if self._debug:
print() # ensure debugger prompts starts on new line.
debugger.post_mortem(tb, ex, val)
self.info(
"Suite failed to finalize: {} ({})".format(ex.__name__, val))
if self._nested:
raise TestSuiteAbort(
"subordinate suite {!r} failed to finalize.".format(
self.test_name))
resultset = {TestResult.PASSED: 0, TestResult.FAILED: 0,
TestResult.EXPECTED_FAIL: 0, TestResult.INCOMPLETE: 0,
TestResult.NA: 0}
# Aggregate result for suite.
for entry in self._tests:
resultset[entry.result] += 1
if resultset[TestResult.FAILED] > 0:
self.result = TestResult.FAILED
elif resultset[TestResult.INCOMPLETE] > 0:
self.result = TestResult.INCOMPLETE
elif resultset[TestResult.PASSED] > 0:
self.result = TestResult.PASSED
def _lambda(*iargs, **ikwargs):
try:
return meth(*iargs, **ikwargs)
except:
ex, val, tb = sys.exc_info()
from pycopia import debugger
debugger.post_mortem(tb, ex, val)
def _initialize(self, *args, **kwargs):
"""initialize phase handler for suite-level initialization.
Handles calling the user `initialize()` method, and handling
interrupts, reporting, and invoking the debugger if the DEBUG flag is
set.
"""
self.report.add_heading(self.test_name, 1)
if self.config.flags.VERBOSE:
s = ["Tests in suite:"]
for i, entry in enumerate(self._tests):
s.append("%3d. %r" % (i + 1, entry))
self.report.info("\n".join(s), 1)
del s
try:
self.initialize(*args, **kwargs)
except KeyboardInterrupt:
self.Info("Suite aborted by user in initialize().")
raise TestSuiteAbort
except:
ex, val, tb = sys.exc_info()
if self._debug:
ex, val, tb = sys.exc_info()
debugger.post_mortem(tb, ex, val)
self.Info("Suite failed to initialize: %s (%s)" % (ex, val))
raise TestSuiteAbort, val
def handle_error(self, ex, val, tb):
if self._debug:
from pycopia import debugger
debugger.post_mortem(ex, val, tb)
else:
import traceback
traceback.print_exception(ex, val, tb)
def error_handler(self, ex, val, tb):
if ex is StopSequencer or ex is KeyboardInterrupt:
raise ex, val
if self._debug:
from pycopia import debugger
debugger.post_mortem(tb, ex, val)
else:
raise ex, val, tb
def _finalize(self):
try:
self.finalize()
except:
ex, val, tb = sys.exc_info()
self.diagnostic("{} ({})".format(ex.__name__, val))
if self._debug:
debugger.post_mortem(tb, ex, val)
raise TestSuiteAbort("Test finalize failed!")
def RunModule(self, mod):
"""Run a test module.
Prepares the configuration with module configuration, sends report
messages appropriate for modules, and reports pass or fail.
Arguments:
mod:
A module object with a run() function that takes a configuration
object as it's single parameter.
Returns:
The return value of the module's Run() function, or FAILED if the
module raised an exception.
"""
cf = self.config
# merge any test-module specific config files. The config file name is
# the same as the module name, with ".conf" appended. Located in the
# same directory as the module itself.
testconf = os.path.join(os.path.dirname(mod.__file__),
"%s.conf" % (mod.__name__.split(".")[-1], ))
cf.mergefile(testconf)
cf.evalupdate(cf.options_override)
# make the module look like a test.
mod.test_name = mod.__name__
try:
ID = mod.__version__[1:-1]
except AttributeError: # should be there, but don't worry if its not.
ID = "undefined"
cf.report.add_message("MODULEVERSION", ID)
cf.report.add_message("MODULESTARTTIME", timelib.now())
try:
rv = self.RunObject(mod)
except KeyboardInterrupt:
cf.report.add_message("MODULEENDTIME", timelib.now())
cf.report.incomplete("Module aborted by user.")
raise
except:
ex, val, tb = sys.exc_info()
if cf.flags.DEBUG:
debugger.post_mortem(tb, ex, val)
rv = constants.FAILED
cf.report.add_message("MODULEENDTIME", timelib.now())
cf.report.failed("Module exception: %s (%s)" % (ex, val))
else:
cf.report.add_message("MODULEENDTIME", timelib.now())
if rv is None:
# If module run() function returns None we take that to mean that
# it runs a TestSuite itself. Report nothing.
pass
# But if the module returns something else we take that to mean that
# it is reporting some true/false value to report as pass/fail.
elif rv:
return cf.report.passed("Return evaluates True.")
else:
return cf.report.failed("Return evaluates False.")
return rv
def debugger_hook(exc, value, tb):
if (not hasattr(sys.stderr, "isatty") or not sys.stderr.isatty()
or exc in (SyntaxError, IndentationError, KeyboardInterrupt)):
# We don't have a tty-like device, or it was a SyntaxError, so
# call the default hook.
sys.__excepthook__(exc, value, tb)
else:
from pycopia import debugger
debugger.post_mortem(tb, exc, value)
def _finalize(self, rv):
try:
self.finalize()
except:
ex, val, tb = sys.exc_info()
self.diagnostic("%s (%s)" % (ex, val))
if self._debug:
debugger.post_mortem(tb, ex, val)
rv = self.abort("Test finalize failed!")
return rv
def _finalize(self, rv):
try:
self.finalize()
except:
ex, val, tb = sys.exc_info()
self.diagnostic("%s (%s)" % (ex, val))
if self._debug:
debugger.post_mortem(tb, ex, val)
rv = self.abort("Test finalize failed!")
return rv
def accept(self):
data, addr = self._sock.recvfrom(4096)
worker = self.workerclass(self._sock, addr)
if self.debug:
try:
worker(data)
except:
ex, val, tb = sys.exc_info()
debugger.post_mortem(tb, ex, val)
else:
worker(data)
def import_module(self, modname):
if _DEBUG:
print("Doing module: %s" % modname)
try:
mod = module.get_module(modname)
do_module(mod, self.config)
except:
ex, val, tb = sys.exc_info()
if _DEBUG:
debugger.post_mortem(tb, ex, val)
else:
logging.warn("Could not import %s: %s" % ( modname, "%s: %s" % (ex, val)))
def accept(self):
conn, addr = self._sock.accept()
worker = self.workerclass(conn, addr)
if self.debug:
try:
worker()
except:
ex, val, tb = sys.exc_info()
debugger.post_mortem(tb, ex, val)
else:
self._procmanager(worker)
conn.close()
def _run_module(self, module_with_run):
try:
rv = module_with_run.run(self.config, self.environment, self._ui)
except:
if self.config.flags.DEBUG:
ex, val, tb = sys.exc_info()
debugger.post_mortem(tb, ex, val)
else:
logging.exception_error(module_with_run.__name__)
return TestResult.INCOMPLETE
else:
return rv
def _run_module_hack(self, module_with_exec):
tcinst = core.TestCase(self.config, self.environment, self._ui)
tcinst.set_test_options()
tcinst.test_name = module_with_exec.__name__
# Pull out essential functions.
execute = getattr(module_with_exec, "execute")
initialize = getattr(module_with_exec, "initialize", None)
finalize = getattr(module_with_exec, "finalize", None)
# Make functions bound methods of temporary TestCase instance.
MethodType = type(tcinst.execute)
def wrap_execute(s):
return execute()
setattr(tcinst, "execute", MethodType(wrap_execute, tcinst))
if initialize is not None:
def wrap_initialize(s):
return initialize()
setattr(tcinst, "initialize", MethodType(wrap_initialize, tcinst))
if finalize is not None:
def wrap_finalize(s):
return finalize()
setattr(tcinst, "finalize", MethodType(wrap_finalize, tcinst))
# Put TestCase instance methods into module namespace.
# This enables execute function to call disposition methods as globals.
for name in _EXPORTED_METHODS:
value = getattr(tcinst, name)
setattr(module_with_exec, name, value)
module_with_exec.config = self.config
module_with_exec.environment = self.environment
module_with_exec.UI = self._ui
module_with_exec.print = tcinst.info
module_with_exec.input = self._ui.user_input
# Run inside a TestEntry, which handles result reporting.
try:
entry = core.TestEntry(tcinst)
rv = entry.run()
except:
if self.config.flags.DEBUG:
ex, val, tb = sys.exc_info()
debugger.post_mortem(tb, ex, val)
else:
logging.exception_error(module_with_exec.__name__)
rv = TestResult.INCOMPLETE
# Clean up
del module_with_exec.config
del module_with_exec.environment
del module_with_exec.UI
del module_with_exec.print
del module_with_exec.input
for name in _EXPORTED_METHODS:
delattr(module_with_exec, name)
return rv
def debugger_hook(exc, value, tb):
if (
not hasattr(sys.stderr, "isatty")
or not sys.stderr.isatty()
or exc in (SyntaxError, IndentationError, KeyboardInterrupt)
):
# We don't have a tty-like device, or it was a SyntaxError, so
# call the default hook.
sys.__excepthook__(exc, value, tb)
else:
from pycopia import debugger
debugger.post_mortem(tb, exc, value)
def mainloop(self, debug=False):
try:
self.parser.interact()
except KeyboardInterrupt:
self.syslog.message("EXITING", "User interrupt")
return
except:
exc, val, tb = sys.exc_info()
self.syslog.message("EXCEPTION", "internal error: %s(%s)" % (exc, val))
if debug:
from pycopia import debugger
debugger.post_mortem(tb)
else:
self.syslog.message("EXITING", "User exited")
def mainloop(self, debug=False):
try:
self.parser.interact()
except KeyboardInterrupt:
self.syslog.message("EXITING", "User interrupt")
return
except:
exc, val, tb = sys.exc_info()
self.syslog.message("EXCEPTION", "internal error: %s(%s)" % (exc, val))
if debug:
from pycopia import debugger
debugger.post_mortem(tb)
else:
self.syslog.message("EXITING", "User exited")
def _initialize(self):
try:
self.initialize()
except KeyboardInterrupt:
self.info("Suite aborted by user in initialize().")
raise TestSuiteAbort("Interrupted in suite initialize.")
except:
ex, val, tb = sys.exc_info()
if self._debug:
ex, val, tb = sys.exc_info()
debugger.post_mortem(tb, ex, val)
self.info(
"Suite failed to initialize: {} ({})".format(ex.__name__, val))
raise TestSuiteAbort(val)
def run_module(self, mod):
"""Run a test module.
Prepares the configuration with module configuration, sends report
messages appropriate for modules, and reports pass or fail.
Arguments:
mod:
A module object with a run() function that takes a configuration
object as it's single parameter.
Returns:
The return value of the module's Run() function, or FAILED if the
module raised an exception.
"""
cf = self.config
# make the module look like a test.
mod.test_name = mod.__name__
ID = get_module_version(mod)
cf.report.add_message("MODULEVERSION", ID)
cf.report.add_message("USECASESTARTTIME", timelib.now())
try:
rv = self.run_object(mod)
except KeyboardInterrupt:
cf.report.add_message("MODULEENDTIME", timelib.now())
cf.report.incomplete("Module aborted by user.")
raise
except:
ex, val, tb = sys.exc_info()
if cf.flags.DEBUG:
from pycopia import debugger
debugger.post_mortem(tb, ex, val)
rv = constants.FAILED
cf.report.add_message("MODULEENDTIME", timelib.now())
cf.report.failed("Module exception: %s (%s)" % (ex, val))
else:
cf.report.add_message("MODULEENDTIME", timelib.now())
if rv is None:
# If module run() function returns None we take that to mean that
# it runs a TestSuite itself. Report PASSED value.
return 1
elif type(rv) is core.TestResult:
return bool(rv)
# If the module returns something else we take that to mean that
# it is reporting some true/false value to report as pass/fail.
elif rv:
return cf.report.passed("Return evaluates True.")
else:
return cf.report.failed("Return evaluates False.")
def run_module(self, mod):
"""Run a test module.
Prepares the configuration with module configuration, sends report
messages appropriate for modules, and reports pass or fail.
Arguments:
mod:
A module object with a run() function that takes a configuration
object as it's single parameter.
Returns:
The return value of the module's Run() function, or FAILED if the
module raised an exception.
"""
cf = self.config
# make the module look like a test.
mod.test_name = mod.__name__
ID = get_module_version(mod)
cf.report.add_message("MODULEVERSION", ID)
cf.report.add_message("USECASESTARTTIME", timelib.now())
try:
rv = self.run_object(mod)
except KeyboardInterrupt:
cf.report.add_message("MODULEENDTIME", timelib.now())
cf.report.incomplete("Module aborted by user.")
raise
except:
ex, val, tb = sys.exc_info()
if cf.flags.DEBUG:
from pycopia import debugger
debugger.post_mortem(tb, ex, val)
rv = constants.FAILED
cf.report.add_message("MODULEENDTIME", timelib.now())
cf.report.failed("Module exception: %s (%s)" % (ex, val))
else:
cf.report.add_message("MODULEENDTIME", timelib.now())
if rv is None:
# If module run() function returns None we take that to mean that
# it runs a TestSuite itself. Report PASSED value.
return 1
elif type(rv) is core.TestResult:
return bool(rv)
# If the module returns something else we take that to mean that
# it is reporting some true/false value to report as pass/fail.
elif rv:
return cf.report.passed("Return evaluates True.")
else:
return cf.report.failed("Return evaluates False.")
def _initialize(self, args, kwargs):
self.report.add_heading("Test suite: %s" % self.__class__.__name__, 1)
# initialize the suite
try:
rv = self.initialize(*args, **kwargs)
except KeyboardInterrupt:
self.info("Suite aborted by user in initialize().")
raise TestSuiteAbort
except:
ex, val, tb = sys.exc_info()
if self._debug:
ex, val, tb = sys.exc_info()
debugger.post_mortem(tb, ex, val)
self.info("Suite failed to initialize: %s (%s)" % (ex, val))
raise TestSuiteAbort, val
def _initialize(self, args, kwargs):
self.report.add_heading("Test suite: %s" % self.__class__.__name__, 1)
# initialize the suite
try:
rv = self.initialize(*args, **kwargs)
except KeyboardInterrupt:
self.info("Suite aborted by user in initialize().")
raise TestSuiteAbort
except:
ex, val, tb = sys.exc_info()
if self._debug:
ex, val, tb = sys.exc_info()
debugger.post_mortem(tb, ex, val)
self.info("Suite failed to initialize: %s (%s)" % (ex, val))
raise TestSuiteAbort, val
def _finalize(self):
# finalize the suite
try:
self.finalize()
except KeyboardInterrupt:
if self._nested:
raise TestSuiteAbort, "Suite '%s' aborted by user in finalize()." % (self.suite_name,)
else:
self.info("Suite aborted by user in finalize().")
except:
ex, val, tb = sys.exc_info()
if self._debug:
print
debugger.post_mortem(tb, ex, val)
self.info("Suite failed to finalize: %s (%s)" % (ex, val))
if self._nested:
raise TestSuiteAbort, "subordinate suite '%s' failed to finalize." % (self.test_name,)
self._report_summary()
def run(self, *args, **kwargs):
"""Invoke the test.
Handles the disposition exceptions, and optional debugging. Invokes the
``initialize`` and ``finalize`` methods.
"""
test_arguments.send(self, arguments=repr_args(args, kwargs))
self._initialize()
# test elapsed time does not include initializer time.
teststarttime = datetime.now()
test_start.send(self, name=self.test_name, time=teststarttime)
rv = None
try:
rv = self.execute(*args, **kwargs)
except KeyboardInterrupt:
if self._debug:
ex, val, tb = sys.exc_info()
debugger.post_mortem(tb, ex, val)
self.incomplete("{}: aborted by user.".format(self.test_name))
self._finalize()
raise
except TestFailError as errval:
self.failed(str(errval))
except TestIncompleteError as errval:
self.incomplete(str(errval))
# Test asserts and validation errors are based on this.
except AssertionError as errval:
self.failed("failed assertion: {}".format(errval))
except TestSuiteAbort:
raise # pass this one up to suite
except debugger.DebuggerQuit: # set_trace "leaks" BdbQuit
self.incomplete("{}: Debugger exit.".format(self.test_name))
except:
ex, val, tb = sys.exc_info()
if self._debug:
debugger.post_mortem(tb, ex, val)
tb = None
self.incomplete("{}: Exception: ({}: {})".format(
self.test_name, ex.__name__, val))
endtime = datetime.now()
test_end.send(self, time=endtime)
self._finalize()
return rv
def _initialize(self, rv):
"""initialize phase handler.
Run user-defined `initialize()` and catch exceptions. If an exception
occurs in the `initialize()` method (which establishes the
pre-conditions for a test) then alter the return value to abort()
which will abort the suite. Invokes the debugger if the debug flag is
set. If debug flag is not set then emit a diagnostic message to the
report.
"""
try:
self.initialize()
except:
ex, val, tb = sys.exc_info()
self.Diagnostic("%s (%s)" % (ex, val))
if self._debug:
debugger.post_mortem(tb, ex, val)
rv = self.Abort("Test initialization failed!")
return rv
def main(argv):
"""qashell [-dD]
Run the QA shell.
"""
from pycopia import getopt
debug = 0
try:
optlist, longopts, args = getopt.getopt(argv[1:], "?hdD")
except getopt.GetoptError:
print(main.__doc__)
return
for opt, val in optlist:
if opt in ("-?", "-h"):
print(main.__doc__)
return
elif opt == "-d":
debug += 1
elif opt == "-D":
from pycopia import autodebug
if debug:
from pycopia import logwindow
widgets.DEBUG = logwindow.DebugLogWindow(do_stderr=True)
app = TestRunnerShell()
try:
app.run()
except:
if debug:
ex, val, tb = sys.exc_info()
from pycopia import debugger
if debug > 1:
from pycopia import IOurxvt
io = IOurxvt.UrxvtIO()
else:
io = None
debugger.post_mortem(tb, ex, val, io)
widgets.DEBUG.close()
if debug > 1:
io.close()
else:
raise
def main(argv):
"""qashell [-dD]
Run the QA shell.
"""
from pycopia import getopt
debug = 0
try:
optlist, longopts, args = getopt.getopt(argv[1:], "?hdD")
except getopt.GetoptError:
print (main.__doc__)
return
for opt, val in optlist:
if opt in ("-?", "-h"):
print (main.__doc__)
return
elif opt == "-d":
debug += 1
elif opt == "-D":
from pycopia import autodebug
if debug:
from pycopia import logwindow
widgets.DEBUG = logwindow.DebugLogWindow(do_stderr=True)
app = TestRunnerShell()
try:
app.run()
except:
if debug:
ex, val, tb = sys.exc_info()
from pycopia import debugger
if debug > 1:
from pycopia import IOurxvt
io = IOurxvt.UrxvtIO()
else:
io = None
debugger.post_mortem(tb, ex, val, io)
widgets.DEBUG.close()
if debug > 1:
io.close()
else:
raise
def _finalize(self):
# finalize the suite
try:
self.finalize()
except KeyboardInterrupt:
if self._nested:
raise TestSuiteAbort, "Suite '%s' aborted by user in finalize()." % (
self.suite_name, )
else:
self.info("Suite aborted by user in finalize().")
except:
ex, val, tb = sys.exc_info()
if self._debug:
print
debugger.post_mortem(tb, ex, val)
self.info("Suite failed to finalize: %s (%s)" % (ex, val))
if self._nested:
raise TestSuiteAbort, "subordinate suite '%s' failed to finalize." % (
self.test_name, )
self._report_summary()
def main(argv):
"""dbedit [-d]
"""
debug = 0
try:
optlist, longopts, args = getopt.getopt(argv[1:], "?hdD")
except getopt.GetoptError:
print((main.__doc__))
return
for opt, val in optlist:
if opt in ("-?", "-h"):
print((main.__doc__))
return
elif opt == "-d":
debug += 1
elif opt == "-D":
from pycopia import autodebug
sess = models.get_session()
try:
app = DBEditor(sess, debug)
try:
app.run()
except:
if debug:
ex, val, tb = sys.exc_info()
from pycopia import debugger
if debug > 1:
from pycopia import IOurxvt
io = IOurxvt.UrxvtIO()
else:
io = None
debugger.post_mortem(tb, ex, val, io)
if debug > 1:
io.close()
else:
raise
finally:
sess.close()
def main(argv):
"""dbedit [-d]
"""
debug = 0
try:
optlist, longopts, args = getopt.getopt(argv[1:], "?hdD")
except getopt.GetoptError:
print (main.__doc__)
return
for opt, val in optlist:
if opt in ("-?", "-h"):
print (main.__doc__)
return
elif opt == "-d":
debug += 1
elif opt == "-D":
from pycopia import autodebug
sess = models.get_session()
try:
app = DBEditor(sess, debug)
try:
app.run()
except:
if debug:
ex, val, tb = sys.exc_info()
from pycopia import debugger
if debug > 1:
from pycopia import IOurxvt
io = IOurxvt.UrxvtIO()
else:
io = None
debugger.post_mortem(tb, ex, val, io)
if debug > 1:
io.close()
else:
raise
finally:
sess.close()
def run_class(self, cls):
"""Run a container class inside a module.
The class is run as if it were a module, using the classes containing
module. The class is just a container, and the run method should be a
static method or class method.
Arguments:
class with run method:
A class object with a run() method that takes a configuration
object as it's single parameter.
Returns:
The return value of the class's run() method, or FAILED if the
module raised an exception.
"""
rpt = self.config.report
cls.test_name = ".".join([cls.__module__, cls.__name__])
ID = get_module_version(sys.modules[cls.__module__])
rpt.add_message("MODULEVERSION", ID)
rpt.add_message("USECASESTARTTIME", timelib.now())
try:
rv = self.run_object(cls)
except KeyboardInterrupt:
rpt.add_message("MODULEENDTIME", timelib.now())
rpt.incomplete("Module aborted by user.")
raise
except:
ex, val, tb = sys.exc_info()
if self.config.flags.DEBUG:
from pycopia import debugger
debugger.post_mortem(tb, ex, val)
rpt.add_message("MODULEENDTIME", timelib.now())
rpt.incomplete("Test container exception: %s (%s)" % (ex, val))
return constants.INCOMPLETE
else:
rpt.add_message("MODULEENDTIME", timelib.now())
return rv
def run_class(self, cls):
"""Run a container class inside a module.
The class is run as if it were a module, using the classes containing
module. The class is just a container, and the run method should be a
static method or class method.
Arguments:
class with run method:
A class object with a run() method that takes a configuration
object as it's single parameter.
Returns:
The return value of the class's run() method, or FAILED if the
module raised an exception.
"""
rpt = self.config.report
cls.test_name = ".".join([cls.__module__, cls.__name__])
ID = get_module_version(sys.modules[cls.__module__])
rpt.add_message("MODULEVERSION", ID)
rpt.add_message("USECASESTARTTIME", timelib.now())
try:
rv = self.run_object(cls)
except KeyboardInterrupt:
rpt.add_message("MODULEENDTIME", timelib.now())
rpt.incomplete("Module aborted by user.")
raise
except:
ex, val, tb = sys.exc_info()
if self.config.flags.DEBUG:
from pycopia import debugger
debugger.post_mortem(tb, ex, val)
rpt.add_message("MODULEENDTIME", timelib.now())
rpt.incomplete("Test container exception: %s (%s)" % (ex, val))
return constants.INCOMPLETE
else:
rpt.add_message("MODULEENDTIME", timelib.now())
return rv
def _finalize(self, rv):
"""
Run user-defined `finalize()` and catch exceptions. If an exception
occurs in the finalize() method (which is supposed to clean up from
the test and leave the UUT in the same condition as when it was
entered) then alter the return value to abort() which will abort the
suite. Invokes the debugger if the debug flag is set.
"""
try:
self.finalize(rv)
except:
ex, val, tb = sys.exc_info()
self.Diagnostic("%s (%s)" % (ex, val))
if self._debug:
debugger.post_mortem(tb, ex, val)
rv = self.Abort("Test finalize failed!")
if self.__datapoints and rv == constants.PASSED:
self.SaveData(self.__datapoints,
DT_PICKLE,
note="datapoints: %d" % (len(self.__datapoints), ))
# the above note has special meaning to other parts of the
# framework (reporting)
return rv
def __call__(self, *args, **kw):
# this heading displays the test name just as a PREREQUISITES entry needs.
self._report.add_heading(repr_test(self.test_name, args, kw), 2)
self.starttime = timelib.now()
self.info("STARTTIME: %s" % (timelib.strftime("%a, %d %b %Y %H:%M:%S %Z", timelib.localtime(self.starttime)),))
rv = None # in case of exception
rv = self._initialize(rv)
if rv is not None: # an exception happened
return rv
# test elapsed time does not include initializer time.
teststarttime = timelib.now()
# run execute
try:
rv = apply(self.execute, args, kw)
except KeyboardInterrupt:
if self._debug:
ex, val, tb = sys.exc_info()
debugger.post_mortem(tb, ex, val)
rv = self.incomplete("%s: aborted by user." % self.test_name)
self._finalize(rv)
raise
except TestFailError, errval:
rv = self.failed("Caught Fail exception: %s" % (errval,))
def __call__(self, *args, **kw):
# this heading displays the test name just as a PREREQUISITES entry needs.
self._report.add_heading(repr_test(self.test_name, args, kw), 2)
self.starttime = timelib.now()
self.info("STARTTIME: %s" % (timelib.strftime(
"%a, %d %b %Y %H:%M:%S %Z", timelib.localtime(self.starttime)), ))
rv = None # in case of exception
rv = self._initialize(rv)
if rv is not None: # an exception happened
return rv
# test elapsed time does not include initializer time.
teststarttime = timelib.now()
# run execute
try:
rv = apply(self.execute, args, kw)
except KeyboardInterrupt:
if self._debug:
ex, val, tb = sys.exc_info()
debugger.post_mortem(tb, ex, val)
rv = self.incomplete("%s: aborted by user." % self.test_name)
self._finalize(rv)
raise
except TestFailError, errval:
rv = self.failed("Caught Fail exception: %s" % (errval, ))
def __call__(self, argv):
if not argv or not argv[0] or argv[0].startswith("_"):
return 2
argv = self._expand_aliases(argv)
# special escape characters...
if argv[0].startswith("!"): # bang-escape reads pipe
argv[0] = argv[0][1:]
argv.insert(0, "pipe")
elif argv[0].startswith("%"): # percent-escape spawns pty
argv[0] = argv[0][1:]
argv.insert(0, "spawn")
elif argv[0].startswith("#"): # comment
return 0
elif argv[0].startswith("@"): # python exec escape
argv[0] = argv[0][1:]
argv.insert(0, "pyexec")
elif argv[0].startswith("="): # python eval escape
argv[0] = argv[0][1:]
argv.insert(0, "pyeval")
# ok, now fetch the real method...
try:
meth = getattr(self, argv[0])
except AttributeError:
meth = self.default_command
# ...and exec it.
try:
rv = meth(argv) # call the method
except (NewCommand, CommandQuit, CommandExit, KeyboardInterrupt):
raise # pass these through to parser
except CLISyntaxError as err:
self._ui.printf("%RSyntax error%N: {}".format(str(err.value)))
self._ui.help_local(meth.__doc__)
except IndexError: # may have tried to get non-existent argv value.
ex, val, tb = sys.exc_info()
lev = 0
t = tb
while t.tb_next is not None:
t = t.tb_next
lev += 1
if lev == 1: # Happened inside the command method.
self._ui.printf("%RInsufficient number of arguments.%N")
self._ui.help_local(meth.__doc__)
else: # IndexError from something called by command method.
if _DEBUG:
from pycopia import debugger
debugger.post_mortem(tb, ex, val)
else:
self.except_hook(ex, val, tb)
except getopt.GetoptError as err:
self._print("option %r: %s" % (err.opt, err.msg))
except:
ex, val, tb = sys.exc_info()
if _DEBUG:
from pycopia import debugger # import here due to circular dependency
debugger.post_mortem(tb, ex, val)
else:
self.except_hook(ex, val, tb)
else:
if rv is not None:
try:
self._environ["?"] = int(rv)
except (ValueError, TypeError, AttributeError):
self._environ["?"] = 0
self._environ["_"] = rv
return rv
def exception_handler(self, ex, val, tb):
from pycopia import debugger
debugger.post_mortem(tb, ex, val)
debugger.post_mortem(tb, ex, val)
rv = self.incomplete("%s: aborted by user." % self.test_name)
self._finalize(rv)
raise
except TestFailError, errval:
rv = self.failed("Caught Fail exception: %s" % (errval,))
except TestIncompleteError, errval:
rv = self.incomplete("Caught Incomplete exception: %s" % (errval,))
except AssertionError, errval:
rv = self.failed("failed assertion: %s" % (errval,))
except TestSuiteAbort:
raise # pass this one up to suite
except:
ex, val, tb = sys.exc_info()
if self._debug:
debugger.post_mortem(tb, ex, val)
tb = None
rv = self.failed("%s: Exception occured! (%s: %s)" % (self.test_name, ex, val))
endtime = timelib.now()
minutes, seconds = divmod(endtime - teststarttime, 60.0)
hours, minutes = divmod(minutes, 60.0)
self.info("Time elapsed: %02.0f:%02.0f:%02.2f" % (hours, minutes, seconds))
return self._finalize(rv)
def _initialize(self, rv):
try:
self.initialize()
except:
ex, val, tb = sys.exc_info()
self.diagnostic("%s (%s)" % (ex, val))
if self._debug:
def __call__(self, argv):
if not argv or not argv[0] or argv[0].startswith("_"):
return 2
argv = self._expand_aliases(argv)
# special escape characters...
if argv[0].startswith("!"): # bang-escape reads pipe
argv[0] = argv[0][1:]
argv.insert(0, "pipe")
elif argv[0].startswith("%"): # percent-escape spawns pty
argv[0] = argv[0][1:]
argv.insert(0, "spawn")
elif argv[0].startswith("#"): # comment
return 0
elif argv[0].startswith("@"): # python exec escape
argv[0] = argv[0][1:]
argv.insert(0, "pyexec")
elif argv[0].startswith("="): # python eval escape
argv[0] = argv[0][1:]
argv.insert(0, "pyeval")
# ok, now fetch the real method...
try:
meth = getattr(self, argv[0])
except AttributeError:
meth = self.default_command
# ...and exec it.
try:
rv = meth(argv) # call the method
except (NewCommand, CommandQuit, CommandExit, KeyboardInterrupt):
raise # pass these through to parser
except CLISyntaxError as err:
self._ui.printf("%RSyntax error%N: {}".format(str(err.value)))
self._ui.help_local(meth.__doc__)
except IndexError: # may have tried to get non-existent argv value.
ex, val, tb = sys.exc_info()
lev = 0
t = tb
while t.tb_next is not None:
t = t.tb_next
lev += 1
if lev == 1: # Happened inside the command method.
self._ui.printf("%RInsufficient number of arguments.%N")
self._ui.help_local(meth.__doc__)
else: # IndexError from something called by command method.
if _DEBUG:
from pycopia import debugger
debugger.post_mortem(tb, ex, val)
else:
self.except_hook(ex, val, tb)
except getopt.GetoptError as err:
self._print("option %r: %s" % (err.opt, err.msg))
except:
ex, val, tb = sys.exc_info()
if _DEBUG:
from pycopia import debugger # import here due to circular dependency
debugger.post_mortem(tb, ex, val)
else:
self.except_hook(ex, val, tb)
else:
if rv is not None:
try:
self._environ["?"] = int(rv)
except (ValueError, TypeError, AttributeError):
self._environ["?"] = 0
self._environ["_"] = rv
return rv
except TestFailError, errval:
rv = self.Failed("Caught Fail exception: %s" % (errval, ))
except TestIncompleteError, errval:
rv = self.Incomplete("Caught Incomplete exception: %s" %
(errval, ))
# Test asserts and validation errors are based on this.
except AssertionError, errval:
rv = self.Failed("failed assertion: %s" % (errval, ))
except TestSuiteAbort:
raise # pass this one up to suite
except debugger.DebuggerQuit: # set_trace "leaks" BdbQuit
rv = self.Incomplete("%s: Debugger exit." % (self.test_name, ))
except:
ex, val, tb = sys.exc_info()
if self._debug:
debugger.post_mortem(tb, ex, val)
tb = None
rv = self.Incomplete("%s: Exception occured! (%s: %s)" % \
(self.test_name, ex, val))
endtime = timelib.now()
self._report.add_message("STARTTIME", teststarttime, 2)
self._report.add_message("ENDTIME", endtime, 2)
minutes, seconds = divmod(endtime - teststarttime, 60.0)
hours, minutes = divmod(minutes, 60.0)
self.Info("Time elapsed: %02.0f:%02.0f:%02.2f" %
(hours, minutes, seconds))
return self._finalize(rv)
def _initialize(self, rv):
"""initialize phase handler.