def step_module_filename(self, module_name):
"""The file name corresponding to the steps module."""
Importer().importFromDir('.', module_name)
module = getsourcefile(sys.modules[module_name])
del sys.modules[module_name]
return module
def setUp(self):
self.dir = os.path.normpath(os.path.join(os.path.dirname(__file__),
'support'))
self.imp = Importer()
self._mods = sys.modules.copy()
self._path = sys.path[:]
sys.modules.pop('mod', None)
sys.modules.pop('pak', None)
sys.modules.pop('pak.mod', None)
sys.modules.pop('pak.sub', None)
class FeatureLoader(object):
"""Loader class responsible for findind features and step
definitions along a given path on filesystem"""
importer = Importer()
@classmethod
def find_and_load_step_definitions(cls, dir_):
"""
Load the steps from the specified directory.
"""
for path, _, files in os.walk(dir_):
for filename in fnmatch.filter(files, '*.py'):
# Import the module using its fully qualified name
filename = os.path.relpath(os.path.join(path, filename))
module_name = path_to_module_name(filename)
try:
cls.importer.importFromPath(filename, module_name)
except ImportError as exc:
raise_from(
StepDiscoveryError(
"Cannot load step definition file: '%s'" %
filename), exc)
@classmethod
def find_feature_directories(cls, dir_):
"""
Locate directories to load features from.
The directories must be named 'features'; they must either reside
directly in the specified directory, or otherwise all their parents
must be packages (have __init__.py files).
"""
# A set of package directories discovered
packages = set()
for path, dirs, files in os.walk(dir_, followlinks=True):
# Is this a package?
if '__init__.py' in files:
packages.add(path)
if path == dir_ or path in packages:
# Does this package have a feature directory?
if 'features' in dirs:
yield os.path.join(path, 'features')
else:
# This is not a package, prune search
dirs[:] = []
def setUp(self):
self.dir = os.path.normpath(
os.path.join(os.path.dirname(__file__), 'support'))
self.imp = Importer()
self._mods = sys.modules.copy()
self._path = sys.path[:]
sys.modules.pop('mod', None)
sys.modules.pop('pak', None)
sys.modules.pop('pak.mod', None)
sys.modules.pop('pak.sub', None)
try:
os.symlink(os.path.abspath(os.path.join(self.dir, 'dir1', 'pak')),
os.path.join(self.dir, 'dir3', 'pak'))
except (AttributeError, NotImplementedError):
self.has_symlinks = False
else:
self.has_symlinks = True
def __init__(self,
config=None,
importer=None,
workingDir=None,
selector=None):
"""Initialize a test loader.
Parameters (all optional):
* config: provide a `nose.config.Config`_ or other config class
instance; if not provided a `nose.config.Config`_ with
default values is used.
* importer: provide an importer instance that implements
`importFromPath`. If not provided, a
`nose.importer.Importer`_ is used.
* workingDir: the directory to which file and module names are
relative. If not provided, assumed to be the current working
directory.
* selector: a selector class or instance. If a class is
provided, it will be instantiated with one argument, the
current config. If not provided, a `nose.selector.Selector`_
is used.
"""
if config is None:
config = Config()
if importer is None:
importer = Importer(config=config)
if workingDir is None:
workingDir = config.workingDir
if selector is None:
selector = defaultSelector(config)
elif isclass(selector):
selector = selector(config)
self.config = config
self.importer = importer
self.workingDir = op_normpath(op_abspath(workingDir))
self.selector = selector
if config.addPaths:
add_path(workingDir, config)
self.suiteClass = ContextSuiteFactory(config=config)
self._visitedPaths = set([])
unittest.TestLoader.__init__(self)
import os from os.path import dirname from nose.importer import Importer bin_dir = os.path.split(__file__)[0] component_dir = os.path.join(bin_dir, "..", "..", "..") importer = Importer() # Load the 'core' module as though this script were being run from # the parent component (either circulation or metadata). importer.importFromDir(component_dir, 'core')
