def run_command_inline(argv, funct, *args, **kwargs):
# Save current execution context
argv_save = sys.argv
environ_save = env.snapshot()
sys.argv = argv
exitcode = None
captured_stdout = StringIO()
captured_stderr = StringIO()
print(*sys.argv)
with redirect_stdout(captured_stdout):
with redirect_stderr(captured_stderr):
try:
with rt.temp_runtime(None):
exitcode = funct(*args, **kwargs)
except SystemExit as e:
exitcode = e.code
finally:
# Restore execution context
environ_save.restore()
sys.argv = argv_save
return (exitcode,
captured_stdout.getvalue(),
captured_stderr.getvalue())
def loadenv(*environs):
'''Load environments in the current Python context.
:arg environs: A list of environments to load.
:type environs: List[Environment]
:returns: A tuple containing snapshot of the current environment upon
entry to this function and a list of shell commands required to load
the environments.
:rtype: Tuple[_EnvironmentSnapshot, List[str]]
'''
modules_system = runtime().modules_system
env_snapshot = snapshot()
commands = []
for env in environs:
for m in env.modules:
conflicted = modules_system.load_module(m, force=True)
for c in conflicted:
commands += modules_system.emit_unload_commands(c)
commands += modules_system.emit_load_commands(m)
for k, v in env.variables.items():
os.environ[k] = os_ext.expandvars(v)
commands.append('export %s=%s' % (k, v))
return env_snapshot, commands
def modules_system(modules_system_nopath):
m = modules_system_nopath
environ_save = env.snapshot()
with m.change_module_path(test_util.TEST_MODULES):
yield m
environ_save.restore()
def __init__(self, policy, printer=None, max_retries=0):
self._policy = policy
self._printer = printer or PrettyPrinter()
self._max_retries = max_retries
self._stats = TestStats()
self._policy.stats = self._stats
self._policy.printer = self._printer
self._environ_snapshot = env.snapshot()
def emit_loadenv_commands(*environs):
env_snapshot = snapshot()
try:
_, commands = loadenv(*environs)
finally:
env_snapshot.restore()
return commands
def modules_system(request):
args = [request.param] if request.param != 'nomod' else []
try:
m = modules.ModulesSystem.create(*args)
except ConfigError:
pytest.skip('{requst.param} not supported')
environ_save = env.snapshot()
m.searchpath_add(fixtures.TEST_MODULES)
yield m
environ_save.restore()
def setUp(self):
self.modules_system = None
os.environ['_var0'] = 'val0'
os.environ['_var1'] = 'val1'
self.environ_save = env.snapshot()
self.environ = env.Environment(name='TestEnv1',
modules=['testmod_foo'],
variables=[('_var0', 'val1'),
('_var2', '$_var0'),
('_var3', '${_var1}')])
self.environ_other = env.Environment(name='TestEnv2',
modules=['testmod_boo'],
variables={'_var4': 'val4'})
def modules_system_nopath(request, monkeypatch):
# Always pretend to be on a clean modules environment
monkeypatch.setenv('MODULEPATH', '')
monkeypatch.setenv('LOADEDMODULES', '')
monkeypatch.setenv('_LMFILES_', '')
args = [request.param] if request.param != 'nomod' else []
try:
m = modules.ModulesSystem.create(*args)
except ConfigError:
pytest.skip(f'{request.param} not supported')
environ_save = env.snapshot()
yield m
environ_save.restore()
def test_load_restore(self):
snapshot, _ = env.load(self.environ)
os.environ['_var0'] == 'val1'
os.environ['_var1'] == 'val1'
os.environ['_var2'] == 'val1'
os.environ['_var3'] == 'val1'
if fixtures.has_sane_modules_system():
self.assertModulesLoaded(self.environ.modules)
assert self.environ.is_loaded
snapshot.restore()
self.environ_save == env.snapshot()
os.environ['_var0'], 'val0'
if fixtures.has_sane_modules_system():
assert not self.modules_system.is_module_loaded('testmod_foo')
assert not self.environ.is_loaded
def test_env_load_restore(base_environ, env0):
snapshot, _ = rt.loadenv(env0)
assert os.environ['_var0'] == 'val1'
assert os.environ['_var1'] == 'val1'
assert os.environ['_var2'] == 'val1'
assert os.environ['_var3'] == 'val1'
if test_util.has_sane_modules_system():
assert_modules_loaded(env0.modules)
assert rt.is_env_loaded(env0)
snapshot.restore()
base_environ == env.snapshot()
assert os.environ['_var0'] == 'val0'
if test_util.has_sane_modules_system():
assert not rt.runtime().modules_system.is_module_loaded('testmod_foo')
assert not rt.is_env_loaded(env0)
def loadenv(*environs):
'''Load environments in the current Python context.
:arg environs: A list of environments to load.
:type environs: List[Environment]
:returns: A tuple containing snapshot of the current environment upon
entry to this function and a list of shell commands required to load
the environments.
:rtype: Tuple[_EnvironmentSnapshot, List[str]]
'''
def _load_cmds_tracked(**module):
commands = []
load_seq = modules_system.load_module(**module, force=True)
for m, conflicted in load_seq:
for c in conflicted:
commands += modules_system.emit_unload_commands(c)
if 'path' not in mod.keys():
mod['path'] = None
commands += modules_system.emit_load_commands(
m, module['collection'], module['path'],
)
return commands
modules_system = runtime().modules_system
env_snapshot = snapshot()
commands = []
for env in environs:
for mod in env.modules_detailed:
if runtime().get_option('general/0/resolve_module_conflicts'):
commands += _load_cmds_tracked(**mod)
else:
commands += modules_system.emit_load_commands(**mod)
for k, v in env.variables.items():
os.environ[k] = osext.expandvars(v)
commands.append(f'export {k}={v}')
return env_snapshot, commands
def loadenv(*environs):
'''Load environments in the current Python context.
Returns a tuple containing a snapshot of the environment at entry to this
function and a list of shell commands required to load ``environs``.
'''
modules_system = runtime().modules_system
env_snapshot = snapshot()
commands = []
for env in environs:
for m in env.modules:
conflicted = modules_system.load_module(m, force=True)
for c in conflicted:
commands += modules_system.emit_unload_commands(c)
commands += modules_system.emit_load_commands(m)
for k, v in env.variables.items():
os.environ[k] = os_ext.expandvars(v)
commands.append('export %s=%s' % (k, v))
return env_snapshot, commands
def setUp(self):
self.environ_save = env.snapshot()
self.modules_system.searchpath_add(TEST_MODULES)
def test_env_snapshot(base_environ, env0, env1):
rt.loadenv(env0, env1)
base_environ.restore()
assert base_environ == env.snapshot()
assert not rt.is_env_loaded(env0)
assert not rt.is_env_loaded(env1)
def base_environ(monkeypatch):
monkeypatch.setenv('_var0', 'val0')
monkeypatch.setenv('_var1', 'val1')
environ_save = env.snapshot()
yield environ_save
environ_save.restore()
def test_environ_snapshot(self):
env.load(self.environ, self.environ_other)
self.environ_save.restore()
assert self.environ_save == env.snapshot()
assert not self.environ.is_loaded
assert not self.environ_other.is_loaded
def setup(self, *args, **kwargs):
self._safe_call(self.check.setup, *args, **kwargs)
self._environ = env.snapshot()
def test_environ_snapshot(self):
rt.loadenv(self.environ, self.environ_other)
self.environ_save.restore()
assert self.environ_save == env.snapshot()
assert not rt.is_env_loaded(self.environ)
assert not rt.is_env_loaded(self.environ_other)
