def test_load_restore(self):
self.environ.load()
self.assertEnvironmentVariable(name='_fookey1', value='value3')
self.assertEnvironmentVariable(name='_fookey2', value='value2')
self.assertEnvironmentVariable(name='_fookey3b', value='foovalue1')
self.assertEnvironmentVariable(name='_fookey4b', value='foovalue2')
self.assertTrue(self.environ.is_loaded)
if fixtures.has_sane_modules_system():
self.assertModulesLoaded(self.environ.modules)
self.environ.unload()
self.assertEqual(self.environ_save, renv.EnvironmentSnapshot())
self.assertEnvironmentVariable(name='_fookey1', value='origfoo')
if fixtures.has_sane_modules_system():
self.assertFalse(
get_modules_system().is_module_loaded('testmod_foo'))
def test_setup(self):
if fixtures.has_sane_modules_system():
self.assertEqual(len(self.environ.modules), 1)
self.assertIn('testmod_foo', self.environ.modules)
self.assertEqual(len(self.environ.variables.keys()), 4)
self.assertEqual(self.environ.variables['_fookey1'], 'value3')
self.assertEqual(self.environ.variables['_fookey2'], 'value2')
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 fixtures.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 fixtures.has_sane_modules_system():
assert not rt.runtime().modules_system.is_module_loaded('testmod_foo')
assert not rt.is_env_loaded(env0)
def test_load_restore(self):
self.environ.load()
self.assertEqual(os.environ['_var0'], 'val1')
self.assertEqual(os.environ['_var1'], 'val1')
self.assertEqual(os.environ['_var2'], 'val1')
self.assertEqual(os.environ['_var3'], 'val1')
if fixtures.has_sane_modules_system():
self.assertModulesLoaded(self.environ.modules)
self.assertTrue(self.environ.is_loaded)
self.environ.unload()
self.assertEqual(self.environ_save, renv.EnvironmentSnapshot())
self.assertEqual(os.environ['_var0'], 'val0')
if fixtures.has_sane_modules_system():
self.assertFalse(
self.modules_system.is_module_loaded('testmod_foo'))
self.assertFalse(self.environ.is_loaded)
def test_setup(self):
if fixtures.has_sane_modules_system():
assert len(self.environ.modules) == 1
assert 'testmod_foo' in self.environ.modules
assert len(self.environ.variables.keys()) == 3
assert self.environ.variables['_var0'] == 'val1'
# No variable expansion, if environment is not loaded
self.environ.variables['_var2'] == '$_var0'
self.environ.variables['_var3'] == '${_var1}'
def test_setup(self):
if fixtures.has_sane_modules_system():
self.assertEqual(len(self.environ.modules), 1)
self.assertIn('testmod_foo', self.environ.modules)
self.assertEqual(len(self.environ.variables.keys()), 3)
self.assertEqual(self.environ.variables['_var0'], 'val1')
# No variable expansion, if environment is not loaded
self.assertEqual(self.environ.variables['_var2'], '$_var0')
self.assertEqual(self.environ.variables['_var3'], '${_var1}')
def setup_modules_system(self):
if not fixtures.has_sane_modules_system():
self.skipTest('no modules system configured')
self.modules_system = runtime().modules_system
self.modules_system.searchpath_add(fixtures.TEST_MODULES)
# Always add a base module; this is a workaround for the modules
# environment's inconsistent behaviour, that starts with an empty
# LOADEDMODULES variable and ends up removing it completely if all
# present modules are removed.
self.modules_system.load_module('testmod_base')
def modules_system():
if not fixtures.has_sane_modules_system():
pytest.skip('no modules system configured')
modsys = rt.runtime().modules_system
modsys.searchpath_add(fixtures.TEST_MODULES)
# Always add a base module; this is a workaround for the modules
# environment's inconsistent behaviour, that starts with an empty
# LOADEDMODULES variable and ends up removing it completely if all
# present modules are removed.
modsys.load_module('testmod_base')
yield modsys
modsys.searchpath_remove(fixtures.TEST_MODULES)
def test_use_module_path(run_reframe, user_exec_ctx):
ms = rt.runtime().modules_system
if not fixtures.has_sane_modules_system():
pytest.skip('no modules system found')
module_path = 'unittests/modules'
returncode, stdout, stderr = run_reframe(
more_options=[f'--module-path=+{module_path}', '--module=testmod_foo'],
config_file=fixtures.USER_CONFIG_FILE,
action='run',
system=rt.runtime().system.name)
assert 'Traceback' not in stdout
assert 'Traceback' not in stderr
assert "could not load module 'testmod_foo' correctly" not in stdout
assert returncode == 0
def test_overwrite_module_path(run_reframe, user_exec_ctx):
ms = rt.runtime().modules_system
if not fixtures.has_sane_modules_system():
pytest.skip('no modules system found')
module_path = 'unittests/modules'
with contextlib.suppress(KeyError):
module_path += f':{os.environ["MODULEPATH"]}'
returncode, stdout, stderr = run_reframe(
more_options=[f'--module-path={module_path}', '--module=testmod_foo'],
config_file=fixtures.USER_CONFIG_FILE,
action='run',
system=rt.runtime().system.name)
assert 'Traceback' not in stdout
assert 'Traceback' not in stderr
assert "could not load module 'testmod_foo' correctly" not in stdout
assert returncode == 0
def test_unload_module(run_reframe, user_exec_ctx):
# This test is mostly for ensuring coverage. `run_reframe()` restores
# the current environment, so it is not easy to verify that the modules
# are indeed unloaded. However, this functionality is tested elsewhere
# more exhaustively.
ms = rt.runtime().modules_system
if not fixtures.has_sane_modules_system():
pytest.skip('no modules system found')
with rt.module_use('unittests/modules'):
ms.load_module('testmod_foo')
returncode, stdout, stderr = run_reframe(
more_options=['-u testmod_foo'], action='list')
ms.unload_module('testmod_foo')
assert stdout != ''
assert 'Traceback' not in stdout
assert 'Traceback' not in stderr
assert returncode == 0
class TestEnvironment(unittest.TestCase):
def assertEnvironmentVariable(self, name, value):
if name not in os.environ:
self.fail('environment variable %s not set' % name)
self.assertEqual(os.environ[name], value)
def assertModulesLoaded(self, modules):
for m in modules:
self.assertTrue(get_modules_system().is_module_loaded(m))
def assertModulesNotLoaded(self, modules):
for m in modules:
self.assertFalse(get_modules_system().is_module_loaded(m))
def setUp(self):
get_modules_system().searchpath_add(fixtures.TEST_MODULES)
# Always add a base module; this is a workaround for the modules
# environment's inconsistent behaviour, that starts with an empty
# LOADEDMODULES variable and ends up removing it completely if all
# present modules are removed.
get_modules_system().load_module('testmod_base')
os.environ['_fookey1'] = 'origfoo'
os.environ['_fookey1b'] = 'foovalue1'
os.environ['_fookey2b'] = 'foovalue2'
self.environ_save = renv.EnvironmentSnapshot()
self.environ = renv.Environment(name='TestEnv1',
modules=['testmod_foo'])
self.environ.set_variable(name='_fookey1', value='value1')
self.environ.set_variable(name='_fookey2', value='value2')
self.environ.set_variable(name='_fookey1', value='value3')
self.environ.set_variable(name='_fookey3b', value='$_fookey1b')
self.environ.set_variable(name='_fookey4b', value='${_fookey2b}')
self.environ_other = renv.Environment(name='TestEnv2',
modules=['testmod_boo'])
self.environ_other.set_variable(name='_fookey11', value='value11')
def tearDown(self):
get_modules_system().searchpath_remove(fixtures.TEST_MODULES)
self.environ_save.load()
def test_setup(self):
if fixtures.has_sane_modules_system():
self.assertEqual(len(self.environ.modules), 1)
self.assertIn('testmod_foo', self.environ.modules)
self.assertEqual(len(self.environ.variables.keys()), 4)
self.assertEqual(self.environ.variables['_fookey1'], 'value3')
self.assertEqual(self.environ.variables['_fookey2'], 'value2')
def test_environ_snapshot(self):
self.assertRaises(EnvironError, self.environ_save.add_module,
'testmod_foo')
self.assertRaises(EnvironError, self.environ_save.set_variable, 'foo',
'bar')
self.assertRaises(EnvironError, self.environ_save.unload)
self.environ.load()
self.environ_other.load()
self.environ_save.load()
self.assertEqual(self.environ_save, renv.EnvironmentSnapshot())
def test_environ_snapshot_context_mgr(self):
with renv.save_environment() as env:
self.assertIsInstance(env, renv.EnvironmentSnapshot)
del os.environ['_fookey1']
os.environ['_fookey1b'] = 'FOOVALUEX'
os.environ['_fookey3'] = 'foovalue3'
self.assertEqual('origfoo', os.environ['_fookey1'])
self.assertEqual('foovalue1', os.environ['_fookey1b'])
self.assertNotIn('_fookey3', os.environ)
def test_load_restore(self):
self.environ.load()
self.assertEnvironmentVariable(name='_fookey1', value='value3')
self.assertEnvironmentVariable(name='_fookey2', value='value2')
self.assertEnvironmentVariable(name='_fookey3b', value='foovalue1')
self.assertEnvironmentVariable(name='_fookey4b', value='foovalue2')
self.assertTrue(self.environ.is_loaded)
if fixtures.has_sane_modules_system():
self.assertModulesLoaded(self.environ.modules)
self.environ.unload()
self.assertEqual(self.environ_save, renv.EnvironmentSnapshot())
self.assertEnvironmentVariable(name='_fookey1', value='origfoo')
if fixtures.has_sane_modules_system():
self.assertFalse(
get_modules_system().is_module_loaded('testmod_foo'))
@unittest.skipIf(not fixtures.has_sane_modules_system(),
'no modules systems supported')
def test_load_already_present(self):
get_modules_system().load_module('testmod_boo')
self.environ.load()
self.environ.unload()
self.assertTrue(get_modules_system().is_module_loaded('testmod_boo'))
def test_equal(self):
env1 = renv.Environment('env1', modules=['foo', 'bar'])
env2 = renv.Environment('env1', modules=['bar', 'foo'])
self.assertEqual(env1, env2)
def test_not_equal(self):
env1 = renv.Environment('env1', modules=['foo', 'bar'])
env2 = renv.Environment('env2', modules=['foo', 'bar'])
self.assertNotEqual(env1, env2)
@unittest.skipIf(not fixtures.has_sane_modules_system(),
'no modules systems supported')
def test_conflicting_environments(self):
envfoo = renv.Environment(name='envfoo',
modules=['testmod_foo', 'testmod_boo'])
envbar = renv.Environment(name='envbar', modules=['testmod_bar'])
envfoo.load()
envbar.load()
for m in envbar.modules:
self.assertTrue(get_modules_system().is_module_loaded(m))
for m in envfoo.modules:
self.assertFalse(get_modules_system().is_module_loaded(m))
@unittest.skipIf(not fixtures.has_sane_modules_system(),
'no modules systems supported')
def test_conflict_environ_after_module_load(self):
get_modules_system().load_module('testmod_foo')
envfoo = renv.Environment(name='envfoo', modules=['testmod_foo'])
envfoo.load()
envfoo.unload()
self.assertTrue(get_modules_system().is_module_loaded('testmod_foo'))
@unittest.skipIf(not fixtures.has_sane_modules_system(),
'no modules systems supported')
def test_conflict_environ_after_module_force_load(self):
get_modules_system().load_module('testmod_foo')
envbar = renv.Environment(name='envbar', modules=['testmod_bar'])
envbar.load()
envbar.unload()
self.assertTrue(get_modules_system().is_module_loaded('testmod_foo'))
def test_swap(self):
from reframe.core.environments import swap_environments
self.environ.load()
swap_environments(self.environ, self.environ_other)
self.assertFalse(self.environ.is_loaded)
self.assertTrue(self.environ_other.is_loaded)
