def test_emit_loadenv_failure(user_runtime):
snap = rt.snapshot()
environ = env.Environment('test', modules=['testmod_foo', 'testmod_xxx'])
# Suppress the module load error and verify that the original environment
# is preserved
with contextlib.suppress(EnvironError):
rt.emit_loadenv_commands(environ)
assert rt.snapshot() == snap
def find_modules(substr, environ_mapping=None):
'''Return all modules in the current system that contain ``substr`` in
their name.
This function is a generator and will yield tuples of partition,
environment and module combinations for each partition of the current
system and for each environment of a partition.
The ``environ_mapping`` argument allows you to map module name patterns to
ReFrame environments. This is useful for flat module name schemes, in
order to avoid incompatible combinations of modules and environments.
You can use this function to parametrize regression tests over the
available environment modules. The following example will generate tests
for all the available ``netcdf`` packages in the system:
.. code:: python
@rfm.simple_test
class MyTest(rfm.RegressionTest):
module_info = parameter(find_modules('netcdf'))
@rfm.run_after('init')
def apply_module_info(self):
s, e, m = self.module_info
self.valid_systems = [s]
self.valid_prog_environs = [e]
self.modules = [m]
...
The following example shows the use of ``environ_mapping`` with flat
module name schemes. In this example, the toolchain for which the package
was built is encoded in the module's name. Using the ``environ_mapping``
argument we can map module name patterns to ReFrame environments, so that
invalid combinations are pruned:
.. code:: python
my_find_modules = functools.partial(find_modules, environ_mapping={
r'.*CrayGNU.*': 'PrgEnv-gnu',
r'.*CrayIntel.*': 'PrgEnv-intel',
r'.*CrayCCE.*': 'PrgEnv-cray'
})
@rfm.simple_test
class MyTest(rfm.RegressionTest):
module_info = parameter(my_find_modules('GROMACS'))
@rfm.run_after('init')
def apply_module_info(self):
s, e, m = self.module_info
self.valid_systems = [s]
self.valid_prog_environs = [e]
self.modules = [m]
...
:arg substr: A substring that the returned module names must contain.
:arg environ_mapping: A dictionary mapping regular expressions to
environment names.
:returns: An iterator that iterates over tuples of the module, partition
and environment name combinations that were found.
'''
import reframe.core.runtime as rt
if not isinstance(substr, str):
raise TypeError("'substr' argument must be a string")
if (environ_mapping is not None
and not isinstance(environ_mapping, typ.Dict[str, str])):
raise TypeError(
"'environ_mapping' argument must be of type Dict[str,str]")
def _is_valid_for_env(m, e):
if environ_mapping is None:
return True
for patt, env in environ_mapping.items():
if re.match(patt, m) and e == env:
return True
return False
ms = rt.runtime().modules_system
current_system = rt.runtime().system
snap0 = rt.snapshot()
for p in current_system.partitions:
for e in p.environs:
rt.loadenv(p.local_env, e)
modules = OrderedSet(ms.available_modules(substr))
snap0.restore()
for m in modules:
if _is_valid_for_env(m, e.name):
yield (p.fullname, e.name, m)