| #!/usr/bin/env python |
| # |
| # WvTest: |
| # Copyright (C)2007-2012 Versabanq Innovations Inc. and contributors. |
| # Licensed under the GNU Library General Public License, version 2. |
| # See the included file named LICENSE for license information. |
| # You can get wvtest from: http://github.com/apenwarr/wvtest |
| # |
| import atexit |
| import inspect |
| import os |
| import re |
| import sys |
| import traceback |
| |
| # NOTE |
| # Why do we do we need the "!= main" check? Because if you run |
| # wvtest.py as a main program and it imports your test files, then |
| # those test files will try to import the wvtest module recursively. |
| # That actually *works* fine, because we don't run this main program |
| # when we're imported as a module. But you end up with two separate |
| # wvtest modules, the one that gets imported, and the one that's the |
| # main program. Each of them would have duplicated global variables |
| # (most importantly, wvtest._registered), and so screwy things could |
| # happen. Thus, we make the main program module *totally* different |
| # from the imported module. Then we import wvtest (the module) into |
| # wvtest (the main program) here and make sure to refer to the right |
| # versions of global variables. |
| # |
| # All this is done just so that wvtest.py can be a single file that's |
| # easy to import into your own applications. |
| if __name__ != '__main__': # we're imported as a module |
| _registered = [] |
| _tests = 0 |
| _fails = 0 |
| |
| def wvtest(func, innerfunc=None): |
| """ Use this decorator (@wvtest) in front of any function you want to |
| run as part of the unit test suite. Then run: |
| python wvtest.py path/to/yourtest.py [other test.py files...] |
| to run all the @wvtest functions in the given file(s). |
| """ |
| _registered.append((func, innerfunc or func)) |
| return func |
| |
| |
| def _result(msg, tb, code): |
| global _tests, _fails |
| _tests += 1 |
| if code != 'ok': |
| _fails += 1 |
| (filename, line, func, text) = tb |
| filename = os.path.basename(filename) |
| msg = re.sub(r'\s+', ' ', str(msg)) |
| sys.stderr.flush() |
| print '! %-70s %s' % ('%s:%-4d %s' % (filename, line, msg), |
| code) |
| sys.stdout.flush() |
| |
| |
| def _check(cond, msg, xdepth): |
| tb = traceback.extract_stack()[-3 - xdepth] |
| if cond: |
| _result(msg, tb, 'ok') |
| else: |
| _result(msg, tb, 'FAILED') |
| return cond |
| |
| |
| def _code(xdepth): |
| (filename, line, func, text) = traceback.extract_stack()[-3 - xdepth] |
| text = re.sub(r'^[\w\.]+\((.*)\)(\s*#.*)?$', r'\1', str(text)); |
| return text |
| |
| |
| def WVPASS(cond = True, xdepth = 0): |
| ''' Counts a test failure unless cond is true. ''' |
| return _check(cond, _code(xdepth), xdepth) |
| |
| def WVFAIL(cond = True, xdepth = 0): |
| ''' Counts a test failure unless cond is false. ''' |
| return _check(not cond, 'NOT(%s)' % _code(xdepth), xdepth) |
| |
| def WVPASSIS(a, b, xdepth = 0): |
| ''' Counts a test failure unless a is b. ''' |
| return _check(a is b, '%s is %s' % (repr(a), repr(b)), xdepth) |
| |
| def WVPASSISNOT(a, b, xdepth = 0): |
| ''' Counts a test failure unless a is not b. ''' |
| return _check(a is not b, '%s is not %s' % (repr(a), repr(b)), xdepth) |
| |
| def WVPASSEQ(a, b, xdepth = 0): |
| ''' Counts a test failure unless a == b. ''' |
| return _check(a == b, '%s == %s' % (repr(a), repr(b)), xdepth) |
| |
| def WVPASSNE(a, b, xdepth = 0): |
| ''' Counts a test failure unless a != b. ''' |
| return _check(a != b, '%s != %s' % (repr(a), repr(b)), xdepth) |
| |
| def WVPASSLT(a, b, xdepth = 0): |
| ''' Counts a test failure unless a < b. ''' |
| return _check(a < b, '%s < %s' % (repr(a), repr(b)), xdepth) |
| |
| def WVPASSLE(a, b, xdepth = 0): |
| ''' Counts a test failure unless a <= b. ''' |
| return _check(a <= b, '%s <= %s' % (repr(a), repr(b)), xdepth) |
| |
| def WVPASSGT(a, b, xdepth = 0): |
| ''' Counts a test failure unless a > b. ''' |
| return _check(a > b, '%s > %s' % (repr(a), repr(b)), xdepth) |
| |
| def WVPASSGE(a, b, xdepth = 0): |
| ''' Counts a test failure unless a >= b. ''' |
| return _check(a >= b, '%s >= %s' % (repr(a), repr(b)), xdepth) |
| |
| def WVPASSNEAR(a, b, places = 7, delta = None, xdepth = 0): |
| ''' Counts a test failure unless a ~= b. ''' |
| if delta: |
| return _check(abs(a - b) <= abs(delta), |
| '%s ~= %s' % (repr(a), repr(b)), xdepth) |
| else: |
| return _check(round(a, places) == round(b, places), |
| '%s ~= %s' % (repr(a), repr(b)), xdepth) |
| |
| def WVPASSFAR(a, b, places = 7, delta = None, xdepth = 0): |
| ''' Counts a test failure unless a ~!= b. ''' |
| if delta: |
| return _check(abs(a - b) > abs(delta), |
| '%s ~= %s' % (repr(a), repr(b)), xdepth) |
| else: |
| return _check(round(a, places) != round(b, places), |
| '%s ~= %s' % (repr(a), repr(b)), xdepth) |
| |
| def _except_report(cond, code, xdepth): |
| return _check(cond, 'EXCEPT(%s)' % code, xdepth + 1) |
| |
| class _ExceptWrapper(object): |
| def __init__(self, etype, xdepth): |
| self.etype = etype |
| self.xdepth = xdepth |
| self.code = None |
| |
| def __enter__(self): |
| self.code = _code(self.xdepth) |
| |
| def __exit__(self, etype, value, traceback): |
| if etype == self.etype: |
| _except_report(True, self.code, self.xdepth) |
| return 1 # success, got the expected exception |
| elif etype is None: |
| _except_report(False, self.code, self.xdepth) |
| return 0 |
| else: |
| _except_report(False, self.code, self.xdepth) |
| |
| def _WVEXCEPT(etype, xdepth, func, *args, **kwargs): |
| if func: |
| code = _code(xdepth + 1) |
| try: |
| func(*args, **kwargs) |
| except etype, e: |
| return _except_report(True, code, xdepth + 1) |
| except: |
| _except_report(False, code, xdepth + 1) |
| raise |
| else: |
| return _except_report(False, code, xdepth + 1) |
| else: |
| return _ExceptWrapper(etype, xdepth) |
| |
| def WVEXCEPT(etype, func=None, *args, **kwargs): |
| ''' Counts a test failure unless func throws an 'etype' exception. |
| You have to spell out the function name and arguments, rather than |
| calling the function yourself, so that WVEXCEPT can run before |
| your test code throws an exception. |
| ''' |
| return _WVEXCEPT(etype, 0, func, *args, **kwargs) |
| |
| |
| def _check_unfinished(): |
| if _registered: |
| for func, innerfunc in _registered: |
| print 'WARNING: not run: %r' % (innerfunc,) |
| WVFAIL('wvtest_main() not called') |
| if _fails: |
| sys.exit(1) |
| |
| atexit.register(_check_unfinished) |
| |
| |
| def _run_in_chdir(path, func, *args, **kwargs): |
| oldwd = os.getcwd() |
| oldpath = sys.path |
| try: |
| if path: os.chdir(path) |
| sys.path += [path, os.path.split(path)[0]] |
| return func(*args, **kwargs) |
| finally: |
| os.chdir(oldwd) |
| sys.path = oldpath |
| |
| |
| def _runtest(fname, f, innerfunc): |
| import wvtest as _wvtestmod |
| mod = inspect.getmodule(innerfunc) |
| relpath = os.path.relpath(mod.__file__, os.getcwd()).replace('.pyc', '.py') |
| print |
| print 'Testing "%s" in %s:' % (fname, relpath) |
| sys.stdout.flush() |
| try: |
| _run_in_chdir(os.path.split(mod.__file__)[0], f) |
| except Exception, e: |
| print |
| print traceback.format_exc() |
| tb = sys.exc_info()[2] |
| _wvtestmod._result(repr(e), traceback.extract_tb(tb)[-1], 'EXCEPTION') |
| |
| |
| def _run_registered_tests(): |
| import wvtest as _wvtestmod |
| while _wvtestmod._registered: |
| func, innerfunc = _wvtestmod._registered.pop(0) |
| _runtest(innerfunc.func_name, func, innerfunc) |
| print |
| |
| |
| def wvtest_main(extra_testfiles=[]): |
| import wvtest as _wvtestmod |
| _run_registered_tests() |
| for modname in extra_testfiles: |
| if not os.path.exists(modname): |
| print 'Skipping: %s' % modname |
| continue |
| if modname.endswith('.py'): |
| modname = modname[:-3] |
| print 'Importing: %s' % modname |
| path, mod = os.path.split(os.path.abspath(modname)) |
| nicename = modname.replace(os.path.sep, '.') |
| while nicename.startswith('.'): |
| nicename = modname[1:] |
| _run_in_chdir(path, __import__, nicename, None, None, []) |
| _run_registered_tests() |
| print |
| print 'WvTest: %d tests, %d failures.' % (_wvtestmod._tests, |
| _wvtestmod._fails) |
| |
| |
| if __name__ == '__main__': |
| import wvtest as _wvtestmod |
| sys.modules['wvtest'] = _wvtestmod |
| sys.modules['wvtest.wvtest'] = _wvtestmod |
| wvtest_main(sys.argv[1:]) |
