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)