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)