FM / nose

/opt/alt/python27/lib/python2.7/site-packages/nose/

/opt/alt/python27/lib/python2.7/site-packages/nose

Name	Size	Mode	Actions
ext/	-	0755	rm
plugins/	-	0755	rm
sphinx/	-	0755	rm
tools/	-	0755	rm
case.py	13171	0644	edit dl rm
case.pyc	15095	0644	edit dl rm
case.pyo	15095	0644	edit dl rm
commands.py	6310	0644	edit dl rm
commands.pyc	6150	0644	edit dl rm
commands.pyo	6150	0644	edit dl rm
config.py	25236	0644	edit dl rm
config.pyc	24257	0644	edit dl rm
config.pyo	24257	0644	edit dl rm
core.py	13093	0644	edit dl rm
core.pyc	13469	0644	edit dl rm
core.pyo	13469	0644	edit dl rm
exc.py	376	0644	edit dl rm
exc.pyc	589	0644	edit dl rm
exc.pyo	589	0644	edit dl rm
failure.py	1249	0644	edit dl rm
failure.pyc	2000	0644	edit dl rm
failure.pyo	2000	0644	edit dl rm
importer.py	5978	0644	edit dl rm
importer.pyc	5762	0644	edit dl rm
importer.pyo	5762	0644	edit dl rm
inspector.py	6986	0644	edit dl rm
inspector.pyc	6092	0644	edit dl rm
inspector.pyo	6092	0644	edit dl rm
loader.py	25491	0644	edit dl rm
loader.pyc	18942	0644	edit dl rm
loader.pyo	18895	0644	edit dl rm
proxy.py	6879	0644	edit dl rm
proxy.pyc	8395	0644	edit dl rm
proxy.pyo	8191	0644	edit dl rm
pyversion.py	7424	0644	edit dl rm
pyversion.pyc	9537	0644	edit dl rm
pyversion.pyo	9537	0644	edit dl rm
result.py	6711	0644	edit dl rm
result.pyc	7075	0644	edit dl rm
result.pyo	7075	0644	edit dl rm
selector.py	9090	0644	edit dl rm
selector.pyc	9267	0644	edit dl rm
selector.pyo	9267	0644	edit dl rm
suite.py	22341	0644	edit dl rm
suite.pyc	22462	0644	edit dl rm
suite.pyo	22462	0644	edit dl rm
twistedtools.py	5525	0644	edit dl rm
twistedtools.pyc	6319	0644	edit dl rm
twistedtools.pyo	6319	0644	edit dl rm
usage.txt	4425	0644	edit dl rm
util.py	20137	0644	edit dl rm
util.pyc	21616	0644	edit dl rm
util.pyo	21616	0644	edit dl rm
__init__.py	404	0644	edit dl rm
__init__.pyc	702	0644	edit dl rm
__init__.pyo	702	0644	edit dl rm
__main__.py	144	0644	edit dl rm
__main__.pyc	362	0644	edit dl rm
__main__.pyo	362	0644	edit dl rm

Edit: /opt/alt/python27/lib/python2.7/site-packages/nose/proxy.py (6879B)

"""
Result Proxy
------------

The result proxy wraps the result instance given to each test. It
performs two functions: enabling extended error/failure reporting
and calling plugins.

As each result event is fired, plugins are called with the same event;
however, plugins are called with the nose.case.Test instance that
wraps the actual test. So when a test fails and calls
result.addFailure(self, err), the result proxy calls
addFailure(self.test, err) for each plugin. This allows plugins to
have a single stable interface for all test types, and also to
manipulate the test object itself by setting the `test` attribute of
the nose.case.Test that they receive.
"""
import logging
from nose.config import Config

log = logging.getLogger(__name__)

def proxied_attribute(local_attr, proxied_attr, doc):
    """Create a property that proxies attribute ``proxied_attr`` through
    the local attribute ``local_attr``.
    """
    def fget(self):
        return getattr(getattr(self, local_attr), proxied_attr)
    def fset(self, value):
        setattr(getattr(self, local_attr), proxied_attr, value)
    def fdel(self):
        delattr(getattr(self, local_attr), proxied_attr)
    return property(fget, fset, fdel, doc)

class ResultProxyFactory(object):
    """Factory for result proxies. Generates a ResultProxy bound to each test
    and the result passed to the test.
    """
    def __init__(self, config=None):
        if config is None:
            config = Config()
        self.config = config
        self.__prepared = False
        self.__result = None

def __call__(self, result, test):
        """Return a ResultProxy for the current test.

On first call, plugins are given a chance to replace the
        result used for the remaining tests. If a plugin returns a
        value from prepareTestResult, that object will be used as the
        result for all tests.
        """
        if not self.__prepared:
            self.__prepared = True
            plug_result = self.config.plugins.prepareTestResult(result)
            if plug_result is not None:
                self.__result = result = plug_result
        if self.__result is not None:
            result = self.__result
        return ResultProxy(result, test, config=self.config)

class ResultProxy(object):
    """Proxy to TestResults (or other results handler).

One ResultProxy is created for each nose.case.Test. The result
    proxy calls plugins with the nose.case.Test instance (instead of
    the wrapped test case) as each result call is made. Finally, the
    real result method is called, also with the nose.case.Test
    instance as the test parameter.

"""
    def __init__(self, result, test, config=None):
        if config is None:
            config = Config()
        self.config = config
        self.plugins = config.plugins
        self.result = result
        self.test = test

def __repr__(self):
        return repr(self.result)

def _prepareErr(self, err):
        if not isinstance(err[1], Exception) and isinstance(err[0], type):
            # Turn value back into an Exception (required in Python 3.x).
            # Plugins do all sorts of crazy things with exception values.
            # Convert it to a custom subclass of Exception with the same
            # name as the actual exception to make it print correctly.
            value = type(err[0].__name__, (Exception,), {})(err[1])
            err = (err[0], value, err[2])
        return err

def assertMyTest(self, test):
        # The test I was called with must be my .test or my
        # .test's .test. or my .test.test's .case

case = getattr(self.test, 'test', None)
        assert (test is self.test
                or test is case
                or test is getattr(case, '_nose_case', None)), (
                "ResultProxy for %r (%s) was called with test %r (%s)"
                % (self.test, id(self.test), test, id(test)))

def afterTest(self, test):
        self.assertMyTest(test)
        self.plugins.afterTest(self.test)
        if hasattr(self.result, "afterTest"):
            self.result.afterTest(self.test)

def beforeTest(self, test):
        self.assertMyTest(test)
        self.plugins.beforeTest(self.test)
        if hasattr(self.result, "beforeTest"):
            self.result.beforeTest(self.test)

def addError(self, test, err):
        self.assertMyTest(test)
        plugins = self.plugins
        plugin_handled = plugins.handleError(self.test, err)
        if plugin_handled:
            return
        # test.passed is set in result, to account for error classes
        formatted = plugins.formatError(self.test, err)
        if formatted is not None:
            err = formatted
        plugins.addError(self.test, err)
        self.result.addError(self.test, self._prepareErr(err))
        if not self.result.wasSuccessful() and self.config.stopOnError:
            self.shouldStop = True

def addFailure(self, test, err):
        self.assertMyTest(test)
        plugins = self.plugins
        plugin_handled = plugins.handleFailure(self.test, err)
        if plugin_handled:
            return
        self.test.passed = False
        formatted = plugins.formatFailure(self.test, err)
        if formatted is not None:
            err = formatted
        plugins.addFailure(self.test, err)
        self.result.addFailure(self.test, self._prepareErr(err))
        if self.config.stopOnError:
            self.shouldStop = True

def addSkip(self, test, reason):
        # 2.7 compat shim
        from nose.plugins.skip import SkipTest
        self.assertMyTest(test)
        plugins = self.plugins
        if not isinstance(reason, Exception):
            # for Python 3.2+
            reason = Exception(reason)
        plugins.addError(self.test, (SkipTest, reason, None))
        self.result.addSkip(self.test, reason)

def addSuccess(self, test):
        self.assertMyTest(test)
        self.plugins.addSuccess(self.test)
        self.result.addSuccess(self.test)

def startTest(self, test):
        self.assertMyTest(test)
        self.plugins.startTest(self.test)
        self.result.startTest(self.test)

def stop(self):
        self.result.stop()

def stopTest(self, test):
        self.assertMyTest(test)
        self.plugins.stopTest(self.test)
        self.result.stopTest(self.test)

# proxied attributes
    shouldStop = proxied_attribute('result', 'shouldStop',
                                    """Should the test run stop?""")
    errors = proxied_attribute('result', 'errors',
                               """Tests that raised an exception""")
    failures = proxied_attribute('result', 'failures',
                                 """Tests that failed""")
    testsRun = proxied_attribute('result', 'testsRun',
                                 """Number of tests run""")

cmd: