Gecko [ goons4good.org ]

Name	Size	Permission	Date
ext	[ DIR ]	drwxr-xr-x	2021-09-16 10:54
plugins	[ DIR ]	drwxr-xr-x	2021-09-16 10:54
sphinx	[ DIR ]	drwxr-xr-x	2021-09-16 10:54
tools	[ DIR ]	drwxr-xr-x	2021-09-16 10:54
__init__.py	404 B	-rw-r--r--	2015-06-02 04:43
__init__.pyc	689 B	-rw-r--r--	2017-08-01 23:26
__init__.pyo	689 B	-rw-r--r--	2017-08-01 23:26
__main__.py	144 B	-rw-r--r--	2014-03-29 06:20
__main__.pyc	347 B	-rw-r--r--	2017-08-01 23:26
__main__.pyo	347 B	-rw-r--r--	2017-08-01 23:26
case.py	12.86 KB	-rw-r--r--	2014-08-13 05:44
case.pyc	14.23 KB	-rw-r--r--	2017-08-01 23:26
case.pyo	14.23 KB	-rw-r--r--	2017-08-01 23:26
commands.py	6.16 KB	-rw-r--r--	2015-04-04 04:52
commands.pyc	5.89 KB	-rw-r--r--	2017-08-01 23:26
commands.pyo	5.89 KB	-rw-r--r--	2017-08-01 23:26
config.py	24.65 KB	-rw-r--r--	2015-04-04 04:52
config.pyc	23.01 KB	-rw-r--r--	2017-08-01 23:26
config.pyo	23.01 KB	-rw-r--r--	2017-08-01 23:26
core.py	12.79 KB	-rw-r--r--	2015-04-04 04:52
core.pyc	12.84 KB	-rw-r--r--	2017-08-01 23:26
core.pyo	12.84 KB	-rw-r--r--	2017-08-01 23:26
exc.py	376 B	-rw-r--r--	2012-09-29 04:18
exc.pyc	576 B	-rw-r--r--	2017-08-01 23:26
exc.pyo	576 B	-rw-r--r--	2017-08-01 23:26
failure.py	1.22 KB	-rw-r--r--	2015-04-04 04:52
failure.pyc	1.87 KB	-rw-r--r--	2017-08-01 23:26
failure.pyo	1.87 KB	-rw-r--r--	2017-08-01 23:26
importer.py	5.84 KB	-rw-r--r--	2015-04-04 04:52
importer.pyc	5.45 KB	-rw-r--r--	2017-08-01 23:26
importer.pyo	5.45 KB	-rw-r--r--	2017-08-01 23:26
inspector.py	6.82 KB	-rw-r--r--	2012-09-29 04:18
inspector.pyc	5.8 KB	-rw-r--r--	2017-08-01 23:26
inspector.pyo	5.8 KB	-rw-r--r--	2017-08-01 23:26
loader.py	24.93 KB	-rw-r--r--	2015-06-01 06:53
loader.pyc	17.98 KB	-rw-r--r--	2017-08-01 23:26
loader.pyo	17.93 KB	-rw-r--r--	2017-08-01 23:26
proxy.py	6.72 KB	-rw-r--r--	2015-03-18 19:44
proxy.pyc	7.89 KB	-rw-r--r--	2017-08-01 23:26
proxy.pyo	7.69 KB	-rw-r--r--	2017-08-01 23:26
pyversion.py	7.3 KB	-rw-r--r--	2015-04-04 04:52
pyversion.pyc	8.86 KB	-rw-r--r--	2017-08-01 23:26
pyversion.pyo	8.86 KB	-rw-r--r--	2017-08-01 23:26
result.py	6.55 KB	-rw-r--r--	2015-04-04 04:52
result.pyc	6.65 KB	-rw-r--r--	2017-08-01 23:26
result.pyo	6.65 KB	-rw-r--r--	2017-08-01 23:26
selector.py	8.89 KB	-rw-r--r--	2015-04-04 04:52
selector.pyc	8.72 KB	-rw-r--r--	2017-08-01 23:26
selector.pyo	8.72 KB	-rw-r--r--	2017-08-01 23:26
suite.py	21.82 KB	-rw-r--r--	2015-04-04 04:52
suite.pyc	21.09 KB	-rw-r--r--	2017-08-01 23:26
suite.pyo	21.09 KB	-rw-r--r--	2017-08-01 23:26
twistedtools.py	5.4 KB	-rw-r--r--	2013-04-05 18:25
twistedtools.pyc	6.01 KB	-rw-r--r--	2017-08-01 23:26
twistedtools.pyo	6.01 KB	-rw-r--r--	2017-08-01 23:26
usage.txt	4.32 KB	-rw-r--r--	2015-04-04 04:52
util.py	19.83 KB	-rw-r--r--	2015-04-04 04:52
util.pyc	20.61 KB	-rw-r--r--	2017-08-01 23:26
util.pyo	20.61 KB	-rw-r--r--	2017-08-01 23:26

Rename

"""
Test Selection
--------------

Test selection is handled by a Selector. The test loader calls the
appropriate selector method for each object it encounters that it
thinks may be a test.
"""
import logging
import os
import unittest
from nose.config import Config
from nose.util import split_test_name, src, getfilename, getpackage, ispackage, is_executable

log = logging.getLogger(__name__)

__all__ = ['Selector', 'defaultSelector', 'TestAddress']

# for efficiency and easier mocking
op_join = os.path.join
op_basename = os.path.basename
op_exists = os.path.exists
op_splitext = os.path.splitext
op_isabs = os.path.isabs
op_abspath = os.path.abspath

class Selector(object):
    """Core test selector. Examines test candidates and determines whether,
    given the specified configuration, the test candidate should be selected
    as a test.
    """
    def __init__(self, config):
        if config is None:
            config = Config()
        self.configure(config)

def configure(self, config):
        self.config = config
        self.exclude = config.exclude
        self.ignoreFiles = config.ignoreFiles
        self.include = config.include
        self.plugins = config.plugins
        self.match = config.testMatch
        
    def matches(self, name):
        """Does the name match my requirements?

To match, a name must match config.testMatch OR config.include
        and it must not match config.exclude
        """
        return ((self.match.search(name)
                 or (self.include and
                     filter(None,
                            [inc.search(name) for inc in self.include])))
                and ((not self.exclude)
                     or not filter(None,
                                   [exc.search(name) for exc in self.exclude])
                 ))
    
    def wantClass(self, cls):
        """Is the class a wanted test class?

A class must be a unittest.TestCase subclass, or match test name
        requirements. Classes that start with _ are always excluded.
        """
        declared = getattr(cls, '__test__', None)
        if declared is not None:
            wanted = declared
        else:
            wanted = (not cls.__name__.startswith('_')
                      and (issubclass(cls, unittest.TestCase)
                           or self.matches(cls.__name__)))
        
        plug_wants = self.plugins.wantClass(cls)        
        if plug_wants is not None:
            log.debug("Plugin setting selection of %s to %s", cls, plug_wants)
            wanted = plug_wants
        log.debug("wantClass %s? %s", cls, wanted)
        return wanted

def wantDirectory(self, dirname):
        """Is the directory a wanted test directory?

All package directories match, so long as they do not match exclude. 
        All other directories must match test requirements.
        """
        tail = op_basename(dirname)
        if ispackage(dirname):
            wanted = (not self.exclude
                      or not filter(None,
                                    [exc.search(tail) for exc in self.exclude]
                                    ))
        else:
            wanted = (self.matches(tail)
                      or (self.config.srcDirs
                          and tail in self.config.srcDirs))
        plug_wants = self.plugins.wantDirectory(dirname)
        if plug_wants is not None:
            log.debug("Plugin setting selection of %s to %s",
                      dirname, plug_wants)
            wanted = plug_wants
        log.debug("wantDirectory %s? %s", dirname, wanted)
        return wanted
    
    def wantFile(self, file):
        """Is the file a wanted test file?

The file must be a python source file and match testMatch or
        include, and not match exclude. Files that match ignore are *never*
        wanted, regardless of plugin, testMatch, include or exclude settings.
        """
        # never, ever load files that match anything in ignore
        # (.* _* and *setup*.py by default)
        base = op_basename(file)
        ignore_matches = [ ignore_this for ignore_this in self.ignoreFiles
                           if ignore_this.search(base) ]
        if ignore_matches:
            log.debug('%s matches ignoreFiles pattern; skipped',
                      base) 
            return False
        if not self.config.includeExe and is_executable(file):
            log.info('%s is executable; skipped', file)
            return False
        dummy, ext = op_splitext(base)
        pysrc = ext == '.py'

wanted = pysrc and self.matches(base) 
        plug_wants = self.plugins.wantFile(file)
        if plug_wants is not None:
            log.debug("plugin setting want %s to %s", file, plug_wants)
            wanted = plug_wants
        log.debug("wantFile %s? %s", file, wanted)
        return wanted

def wantFunction(self, function):
        """Is the function a test function?
        """
        try:
            if hasattr(function, 'compat_func_name'):
                funcname = function.compat_func_name
            else:
                funcname = function.__name__
        except AttributeError:
            # not a function
            return False
        declared = getattr(function, '__test__', None)
        if declared is not None:
            wanted = declared
        else:
            wanted = not funcname.startswith('_') and self.matches(funcname)
        plug_wants = self.plugins.wantFunction(function)
        if plug_wants is not None:
            wanted = plug_wants
        log.debug("wantFunction %s? %s", function, wanted)
        return wanted

def wantMethod(self, method):
        """Is the method a test method?
        """
        try:
            method_name = method.__name__
        except AttributeError:
            # not a method
            return False
        if method_name.startswith('_'):
            # never collect 'private' methods
            return False
        declared = getattr(method, '__test__', None)
        if declared is not None:
            wanted = declared
        else:
            wanted = self.matches(method_name)
        plug_wants = self.plugins.wantMethod(method)
        if plug_wants is not None:
            wanted = plug_wants
        log.debug("wantMethod %s? %s", method, wanted)
        return wanted
    
    def wantModule(self, module):
        """Is the module a test module?

The tail of the module name must match test requirements. One exception:
        we always want __main__.
        """
        declared = getattr(module, '__test__', None)
        if declared is not None:
            wanted = declared
        else:
            wanted = self.matches(module.__name__.split('.')[-1]) \
                     or module.__name__ == '__main__'
        plug_wants = self.plugins.wantModule(module)
        if plug_wants is not None:
            wanted = plug_wants
        log.debug("wantModule %s? %s", module, wanted)
        return wanted
        
defaultSelector = Selector

class TestAddress(object):
    """A test address represents a user's request to run a particular
    test. The user may specify a filename or module (or neither),
    and/or a callable (a class, function, or method). The naming
    format for test addresses is:

filename_or_module:callable

Filenames that are not absolute will be made absolute relative to
    the working dir.

The filename or module part will be considered a module name if it
    doesn't look like a file, that is, if it doesn't exist on the file
    system and it doesn't contain any directory separators and it
    doesn't end in .py.

Callables may be a class name, function name, method name, or
    class.method specification.
    """
    def __init__(self, name, workingDir=None):
        if workingDir is None:
            workingDir = os.getcwd()
        self.name = name
        self.workingDir = workingDir
        self.filename, self.module, self.call = split_test_name(name)
        log.debug('Test name %s resolved to file %s, module %s, call %s',
                  name, self.filename, self.module, self.call)
        if self.filename is None:
            if self.module is not None:
                self.filename = getfilename(self.module, self.workingDir)
        if self.filename:
            self.filename = src(self.filename)
            if not op_isabs(self.filename):
                self.filename = op_abspath(op_join(workingDir,
                                                   self.filename))
            if self.module is None:
                self.module = getpackage(self.filename)
        log.debug(
            'Final resolution of test name %s: file %s module %s call %s',
            name, self.filename, self.module, self.call)

def totuple(self):
        return (self.filename, self.module, self.call)
        
    def __str__(self):
        return self.name

def __repr__(self):
        return "%s: (%s, %s, %s)" % (self.name, self.filename,
                                     self.module, self.call)