def load(self, modules, mod_paths=None, purge=False, orig_env=None): """ Load all requested modules. @param modules: list of modules to load @param mod_paths: list of module paths to activate before loading @param purge: whether or not a 'module purge' should be run before loading @param orig_env: original environment to restore after running 'module purge' """ if mod_paths is None: mod_paths = [] # purge all loaded modules if desired if purge: self.purge() # restore original environment if provided if orig_env is not None: modify_env(os.environ, orig_env) # make sure $MODULEPATH is set correctly after purging self.check_module_path() # extend $MODULEPATH if needed for mod_path in mod_paths: full_mod_path = os.path.join(install_path('mod'), build_option('suffix_modules_path'), mod_path) self.prepend_module_path(full_mod_path) for mod in modules: self.run_module('load', mod)
def build_and_install_software(module, options, orig_environ, exitOnFailure=True, silent=False): """ Build the software """ spec = module['spec'] print_msg("processing EasyBuild easyconfig %s" % spec, log=_log, silent=silent) # restore original environment _log.info("Resetting environment") filetools.errorsFoundInLog = 0 modify_env(os.environ, orig_environ) cwd = os.getcwd() # load easyblock easyblock = options.easyblock if not easyblock: # try to look in .eb file reg = re.compile(r"^\s*easyblock\s*=(.*)$") txt = read_file(spec) for line in txt.split('\n'): match = reg.search(line) if match: easyblock = eval(match.group(1)) break name = module['ec']['name'] try: app_class = get_class(easyblock, name=name) app = app_class(spec, debug=options.debug, robot_path=options.robot, silent=silent) _log.info("Obtained application instance of for %s (easyblock: %s)" % (name, easyblock)) except EasyBuildError, err: print_error("Failed to get application instance for %s (easyblock: %s): %s" % (name, easyblock, err.msg), silent=silent)
def tearDown(self): """cleanup""" os.chdir(self.cwd) os.environ['MODULEPATH'] = os.pathsep.join(self.orig_modulepaths) # reinitialize a modules tool, to trigger 'module use' on module paths modules_tool() modify_env(os.environ, self.orig_environ)
def tearDown(self): """Clean up after running testcase.""" super(EnhancedTestCase, self).tearDown() # go back to where we were before os.chdir(self.cwd) # restore original environment modify_env(os.environ, self.orig_environ) # restore original Python search path sys.path = self.orig_sys_path # remove any log handlers that were added (so that log files can be effectively removed) log = fancylogger.getLogger(fname=False) new_log_handlers = [ h for h in log.handlers if h not in self.orig_log_handlers ] for log_handler in new_log_handlers: log_handler.close() log.removeHandler(log_handler) # cleanup test tmp dir try: shutil.rmtree(self.test_prefix) except (OSError, IOError): pass # restore original 'parent' tmpdir for var in ['TMPDIR', 'TEMP', 'TMP']: os.environ[var] = self.orig_tmpdir # reset to make sure tempfile picks up new temporary directory to use tempfile.tempdir = None
def test_job(self): """Test submitting build as a job.""" # use gzip-1.4.eb easyconfig file that comes with the tests eb_file = os.path.join(os.path.dirname(__file__), 'easyconfigs', 'gzip-1.4.eb') # check log message with --job for job_args in [ # options passed are reordered, so order here matters to make tests pass ['--debug'], ['--debug', '--stop=configure', '--try-software-name=foo'], ]: # clear log file write_file(self.logfile, '') args = [ eb_file, '--job', ] + job_args outtxt = self.eb_main(args) job_msg = "INFO.* Command template for jobs: .* && eb %%\(spec\)s.* %s.*\n" % ' .*'.join( job_args) assertmsg = "Info log message with job command template when using --job (job_msg: %s, outtxt: %s)" % ( job_msg, outtxt) self.assertTrue(re.search(job_msg, outtxt), assertmsg) modify_env(os.environ, self.orig_environ) tempfile.tempdir = None
def test_avail_lists(self): """Test listing available values of certain types.""" fd, dummylogfn = tempfile.mkstemp(prefix='easybuild-dummy', suffix='.log') os.close(fd) name_items = { 'modules-tools': ['EnvironmentModulesC', 'Lmod'], 'module-naming-schemes': ['EasyBuildModuleNamingScheme'], } for (name, items) in name_items.items(): args = [ '--avail-%s' % name, '--unittest-file=%s' % self.logfile, ] outtxt = self.eb_main(args, logfile=dummylogfn) words = name.replace('-', ' ') info_msg = r"INFO List of supported %s:" % words self.assertTrue(re.search(info_msg, outtxt), "Info message with list of available %s" % words) for item in items: res = re.findall("^\s*%s" % item, outtxt, re.M) self.assertTrue(res, "%s is included in list of available %s" % (item, words)) # every item should only be mentioned once n = len(res) self.assertEqual(n, 1, "%s is only mentioned once (count: %d)" % (item, n)) modify_env(os.environ, self.orig_environ) tempfile.tempdir = None if os.path.exists(dummylogfn): os.remove(dummylogfn)
def test_job(self): """Test submitting build as a job.""" # use gzip-1.4.eb easyconfig file that comes with the tests eb_file = os.path.join(os.path.dirname(__file__), "easyconfigs", "gzip-1.4.eb") # check log message with --job for job_args in [ # options passed are reordered, so order here matters to make tests pass ["--debug"], ["--debug", "--stop=configure", "--try-software-name=foo"], ]: # clear log file outtxt = write_file(self.logfile, "") args = [eb_file, "--job"] + job_args try: main((args, self.logfile, False)) except (SystemExit, Exception), err: pass outtxt = read_file(self.logfile) job_msg = "INFO.* Command template for jobs: .* && eb %%\(spec\)s %s.*\n" % " .*".join(job_args) assertmsg = "Info log message with job command template when using --job (job_msg: %s, outtxt: %s)" % ( job_msg, outtxt, ) self.assertTrue(re.search(job_msg, outtxt), assertmsg) modify_env(os.environ, self.orig_environ) tempfile.tempdir = None
def test_quiet(self): """Test enabling quiet logging (errors only).""" for quiet_arg in ["--quiet"]: args = ["--software-name=somethingrandom", quiet_arg] try: main((args, self.logfile, False)) except (SystemExit, Exception), err: pass outtxt = read_file(self.logfile) for log_msg_type in ["ERROR"]: res = re.search(" %s " % log_msg_type, outtxt) self.assertTrue( res, "%s log messages are included when using %s (outtxt: %s)" % (log_msg_type, quiet_arg, outtxt) ) for log_msg_type in ["DEBUG", "INFO"]: res = re.search(" %s " % log_msg_type, outtxt) self.assertTrue( not res, "%s log messages are *not* included when using %s (outtxt: %s)" % (log_msg_type, quiet_arg, outtxt), ) modify_env(os.environ, self.orig_environ) tempfile.tempdir = None
def test_info(self): """Test enabling info logging.""" for info_arg in ["--info"]: args = ["--software-name=somethingrandom", info_arg] myerr = None try: main((args, self.logfile, False)) except (SystemExit, Exception), err: myerr = err outtxt = read_file(self.logfile) for log_msg_type in ["INFO", "ERROR"]: res = re.search(" %s " % log_msg_type, outtxt) self.assertTrue( res, "%s log messages are included when using %s (err: %s, out: %s)" % (log_msg_type, info_arg, myerr, outtxt), ) for log_msg_type in ["DEBUG"]: res = re.search(" %s " % log_msg_type, outtxt) self.assertTrue(not res, "%s log messages are *not* included when using %s" % (log_msg_type, info_arg)) modify_env(os.environ, self.orig_environ) tempfile.tempdir = None
def test_avail_lists(self): """Test listing available values of certain types.""" fd, dummylogfn = tempfile.mkstemp(prefix="easybuild-dummy", suffix=".log") os.close(fd) name_items = { "modules-tools": ["EnvironmentModulesC", "Lmod"], "module-naming-schemes": ["EasyBuildModuleNamingScheme"], } for (name, items) in name_items.items(): args = ["--avail-%s" % name, "--unittest-file=%s" % self.logfile] try: main((args, dummylogfn, False)) except (SystemExit, Exception), err: pass outtxt = read_file(self.logfile) words = name.replace("-", " ") info_msg = r"INFO List of supported %s:" % words self.assertTrue(re.search(info_msg, outtxt), "Info message with list of available %s" % words) for item in items: res = re.findall("^\s*%s" % item, outtxt, re.M) self.assertTrue(res, "%s is included in list of available %s" % (item, words)) # every item should only be mentioned once n = len(res) self.assertEqual(n, 1, "%s is only mentioned once (count: %d)" % (item, n)) modify_env(os.environ, self.orig_environ) tempfile.tempdir = None
def test_info(self): """Test enabling info logging.""" for info_arg in ['--info']: args = [ '--software-name=somethingrandom', info_arg, ] outtxt = self.eb_main(args) for log_msg_type in ['INFO', 'ERROR']: res = re.search(' %s ' % log_msg_type, outtxt) self.assertTrue( res, "%s log messages are included when using %s ( out: %s)" % (log_msg_type, info_arg, outtxt)) for log_msg_type in ['DEBUG']: res = re.search(' %s ' % log_msg_type, outtxt) self.assertTrue( not res, "%s log messages are *not* included when using %s" % (log_msg_type, info_arg)) modify_env(os.environ, self.orig_environ) tempfile.tempdir = None
def test_job(self): """Test submitting build as a job.""" # use gzip-1.4.eb easyconfig file that comes with the tests eb_file = os.path.join(os.path.dirname(__file__), 'easyconfigs', 'gzip-1.4.eb') # check log message with --job for job_args in [ # options passed are reordered, so order here matters to make tests pass ['--debug'], ['--debug', '--stop=configure', '--try-software-name=foo'], ]: # clear log file write_file(self.logfile, '') args = [ eb_file, '--job', ] + job_args outtxt = self.eb_main(args) job_msg = "INFO.* Command template for jobs: .* && eb %%\(spec\)s.* %s.*\n" % ' .*'.join(job_args) assertmsg = "Info log message with job command template when using --job (job_msg: %s, outtxt: %s)" % (job_msg, outtxt) self.assertTrue(re.search(job_msg, outtxt), assertmsg) modify_env(os.environ, self.orig_environ) tempfile.tempdir = None
def test_force(self): """Test forcing installation even if the module is already available.""" # use GCC-4.6.3.eb easyconfig file that comes with the tests eb_file = os.path.join(os.path.dirname(__file__), 'easyconfigs', 'GCC-4.6.3.eb') # check log message without --force args = [ eb_file, '--debug', ] outtxt, error_thrown = self.eb_main(args, return_error=True) self.assertTrue(not error_thrown, "No error is thrown if software is already installed (error_thrown: %s)" % error_thrown) already_msg = "GCC/4.6.3 is already installed" self.assertTrue(re.search(already_msg, outtxt), "Already installed message without --force, outtxt: %s" % outtxt) # clear log file, clean up environment write_file(self.logfile, '') modify_env(os.environ, self.orig_environ) tempfile.tempdir = None # check that --force works args = [ eb_file, '--force', '--debug', ] outtxt = self.eb_main(args) self.assertTrue(not re.search(already_msg, outtxt), "Already installed message not there with --force")
def test_set_tmpdir(self): """Test set_tmpdir config function.""" self.purge_environment() for tmpdir in [None, os.path.join(tempfile.gettempdir(), 'foo')]: parent = tmpdir if parent is None: parent = tempfile.gettempdir() mytmpdir = set_tmpdir(tmpdir=tmpdir) for var in ['TMPDIR', 'TEMP', 'TMP']: self.assertTrue(os.environ[var].startswith( os.path.join(parent, 'easybuild-'))) self.assertEqual(os.environ[var], mytmpdir) self.assertTrue(tempfile.gettempdir().startswith( os.path.join(parent, 'easybuild-'))) tempfile_tmpdir = tempfile.mkdtemp() self.assertTrue( tempfile_tmpdir.startswith(os.path.join(parent, 'easybuild-'))) fd, tempfile_tmpfile = tempfile.mkstemp() self.assertTrue( tempfile_tmpfile.startswith(os.path.join(parent, 'easybuild-'))) # cleanup os.close(fd) shutil.rmtree(mytmpdir) modify_env(os.environ, self.orig_environ) tempfile.tempdir = None
def test_quiet(self): """Test enabling quiet logging (errors only).""" for quiet_arg in ['--quiet']: args = [ '--software-name=somethingrandom', quiet_arg, ] outtxt = self.eb_main(args) for log_msg_type in ['ERROR']: res = re.search(' %s ' % log_msg_type, outtxt) self.assertTrue( res, "%s log messages are included when using %s (outtxt: %s)" % (log_msg_type, quiet_arg, outtxt)) for log_msg_type in ['DEBUG', 'INFO']: res = re.search(' %s ' % log_msg_type, outtxt) self.assertTrue( not res, "%s log messages are *not* included when using %s (outtxt: %s)" % (log_msg_type, quiet_arg, outtxt)) modify_env(os.environ, self.orig_environ) tempfile.tempdir = None
def tearDown(self): """Clean up after running testcase.""" super(EnhancedTestCase, self).tearDown() self.log.info("Cleaning up for test %s", self.id()) # go back to where we were before os.chdir(self.cwd) # restore original environment modify_env(os.environ, self.orig_environ, verbose=False) # restore original Python search path sys.path = self.orig_sys_path # remove any log handlers that were added (so that log files can be effectively removed) log = fancylogger.getLogger(fname=False) new_log_handlers = [h for h in log.handlers if h not in self.orig_log_handlers] for log_handler in new_log_handlers: log_handler.close() log.removeHandler(log_handler) # cleanup test tmp dir try: shutil.rmtree(self.test_prefix) except (OSError, IOError): pass # restore original 'parent' tmpdir for var in ['TMPDIR', 'TEMP', 'TMP']: os.environ[var] = self.orig_tmpdir # reset to make sure tempfile picks up new temporary directory to use tempfile.tempdir = None
def test_set_tmpdir(self): """Test set_tmpdir config function.""" self.purge_environment() for tmpdir in [None, os.path.join(tempfile.gettempdir(), 'foo')]: parent = tmpdir if parent is None: parent = tempfile.gettempdir() mytmpdir = set_tmpdir(tmpdir=tmpdir) for var in ['TMPDIR', 'TEMP', 'TMP']: self.assertTrue(os.environ[var].startswith(os.path.join(parent, 'easybuild-'))) self.assertEqual(os.environ[var], mytmpdir) self.assertTrue(tempfile.gettempdir().startswith(os.path.join(parent, 'easybuild-'))) tempfile_tmpdir = tempfile.mkdtemp() self.assertTrue(tempfile_tmpdir.startswith(os.path.join(parent, 'easybuild-'))) fd, tempfile_tmpfile = tempfile.mkstemp() self.assertTrue(tempfile_tmpfile.startswith(os.path.join(parent, 'easybuild-'))) # cleanup os.close(fd) shutil.rmtree(mytmpdir) modify_env(os.environ, self.orig_environ) tempfile.tempdir = None
def tearDown(self): """cleanup""" os.environ['MODULEPATH'] = os.pathsep.join(self.orig_modulepaths) # reinitialize a modules tool, to trigger 'module use' on module paths modules_tool() # restore (full) original environment modify_env(os.environ, self.orig_environ)
def run_test(custom=None, extra_params=[]): """Inner function to run actual test in current setting.""" fd, dummylogfn = tempfile.mkstemp(prefix='easybuild-dummy', suffix='.log') os.close(fd) for avail_arg in [ '-a', '--avail-easyconfig-params', ]: # clear log write_file(self.logfile, '') args = [ avail_arg, '--unittest-file=%s' % self.logfile, ] if custom is not None: args.extend(['-e', custom]) outtxt = self.eb_main(args, logfile=dummylogfn, verbose=True) # check whether all parameter types are listed par_types = [ BUILD, DEPENDENCIES, EXTENSIONS, FILEMANAGEMENT, LICENSE, MANDATORY, MODULES, OTHER, TOOLCHAIN ] if custom is not None: par_types.append(CUSTOM) for param_type in [x[1] for x in par_types]: self.assertTrue( re.search( "%s\n%s" % (param_type.upper(), '-' * len(param_type)), outtxt), "Parameter type %s is featured in output of eb %s (args: %s): %s" % (param_type, avail_arg, args, outtxt)) # check a couple of easyconfig parameters for param in [ "name", "version", "toolchain", "versionsuffix", "buildopts", "sources", "start_dir", "dependencies", "group", "exts_list", "moduleclass", "buildstats" ] + extra_params: self.assertTrue( re.search("%s(?:\(\*\))?:\s*\w.*" % param, outtxt), "Parameter %s is listed with help in output of eb %s (args: %s): %s" % (param, avail_arg, args, outtxt)) modify_env(os.environ, self.orig_environ) tempfile.tempdir = None if os.path.exists(dummylogfn): os.remove(dummylogfn)
def tearDown(self): """Post-test cleanup.""" os.remove(self.logfile) os.chdir(self.pwd) modify_env(os.environ, self.orig_environ) tempfile.tempdir = None # restore original Python search path sys.path = self.orig_sys_path
def tearDown(self): """Clean up after a config test.""" self.cleanup() try: shutil.rmtree(self.tmpdir) except OSError: pass modify_env(os.environ, self.orig_environ) tempfile.tempdir = None
def eb_main(self, args, do_build=False, return_error=False, logfile=None, verbose=False, raise_error=False, reset_env=True, raise_systemexit=False, testing=True, redo_init_config=True): """Helper method to call EasyBuild main function.""" cleanup() myerr = False if logfile is None: logfile = self.logfile # clear log file if logfile: with open(logfile, 'w') as fh: fh.write('') env_before = copy.deepcopy(os.environ) try: if '--fetch' in args: # The config sets modules_tool to None if --fetch is specified, # so do the same here to keep the behavior consistent modtool = None else: modtool = self.modtool main(args=args, logfile=logfile, do_build=do_build, testing=testing, modtool=modtool) except SystemExit as err: if raise_systemexit: raise err except Exception as err: myerr = err if verbose: print("err: %s" % err) if logfile and os.path.exists(logfile): logtxt = read_file(logfile) else: logtxt = None os.chdir(self.cwd) if redo_init_config: # make sure config is reinitialized init_config(with_include=False) # restore environment to what it was before running main, # changes may have been made by eb_main (e.g. $TMPDIR & co) if reset_env: modify_env(os.environ, env_before, verbose=False) tempfile.tempdir = None if myerr and raise_error: raise myerr if return_error: return logtxt, myerr else: return logtxt
def tearDown(self): """Test cleanup.""" remove_dir(self.tmpdir) sys.stdout = self.orig_sys_stdout sys.stderr = self.orig_sys_stderr # restore original environment modify_env(os.environ, self.orig_environ, verbose=False) super(EasyBlockSpecificTest, self).tearDown()
def tearDown(self): """Clean up after running testcase.""" os.chdir(self.cwd) modify_env(os.environ, self.orig_environ) tempfile.tempdir = None # restore original Python search path sys.path = self.orig_sys_path for path in [self.test_buildpath, self.test_installpath]: try: shutil.rmtree(path) except OSError, err: pass
def tearDown(self): """Clean up after running testcase.""" os.chdir(self.cwd) modify_env(os.environ, self.orig_environ) tempfile.tempdir = None # restore original Python search path sys.path = self.orig_sys_path for path in [self.test_buildpath, self.test_installpath, self.test_prefix]: try: shutil.rmtree(path) except OSError, err: pass
def eb_main(self, args, do_build=False, return_error=False, logfile=None, verbose=False, raise_error=False, reset_env=True, raise_systemexit=False, testing=True): """Helper method to call EasyBuild main function.""" cleanup() myerr = False if logfile is None: logfile = self.logfile # clear log file if logfile: f = open(logfile, 'w') f.write('') f.close() env_before = copy.deepcopy(os.environ) try: main(args=args, logfile=logfile, do_build=do_build, testing=testing, modtool=self.modtool) except SystemExit as err: if raise_systemexit: raise err except Exception as err: myerr = err if verbose: print "err: %s" % err if logfile and os.path.exists(logfile): logtxt = read_file(logfile) else: logtxt = None os.chdir(self.cwd) # make sure config is reinitialized init_config(with_include=False) # restore environment to what it was before running main, # changes may have been made by eb_main (e.g. $TMPDIR & co) if reset_env: modify_env(os.environ, env_before, verbose=False) tempfile.tempdir = None if myerr and raise_error: raise myerr if return_error: return logtxt, myerr else: return logtxt
def tearDown(self): """Cleanup.""" # remove logs os.remove(self.logfile) if os.path.exists(self.dummylogfn): os.remove(self.dummylogfn) shutil.rmtree(self.buildpath) shutil.rmtree(self.installpath) # restore original Python search path sys.path = self.orig_sys_path modify_env(os.environ, self.orig_environ) tempfile.tempdir = None
def run_test(custom=None, extra_params=[]): """Inner function to run actual test in current setting.""" fd, dummylogfn = tempfile.mkstemp(prefix='easybuild-dummy', suffix='.log') os.close(fd) for avail_arg in [ '-a', '--avail-easyconfig-params', ]: # clear log write_file(self.logfile, '') args = [ avail_arg, '--unittest-file=%s' % self.logfile, ] if custom is not None: args.extend(['-e', custom]) try: main((args, dummylogfn, False)) except (SystemExit, Exception), err: pass outtxt = read_file(self.logfile) # check whether all parameter types are listed par_types = [BUILD, DEPENDENCIES, EXTENSIONS, FILEMANAGEMENT, LICENSE, MANDATORY, MODULES, OTHER, TOOLCHAIN] if custom is not None: par_types.append(CUSTOM) for param_type in [x[1] for x in par_types]: self.assertTrue(re.search("%s\n%s" % (param_type.upper(), '-' * len(param_type)), outtxt), "Parameter type %s is featured in output of eb %s (args: %s): %s" % (param_type, avail_arg, args, outtxt)) # check a couple of easyconfig parameters for param in ["name", "version", "toolchain", "versionsuffix", "makeopts", "sources", "start_dir", "dependencies", "group", "exts_list", "moduleclass", "buildstats"] + extra_params: self.assertTrue(re.search("%s(?:\(\*\))?:\s*\w.*" % param, outtxt), "Parameter %s is listed with help in output of eb %s (args: %s): %s" % (param, avail_arg, args, outtxt) ) modify_env(os.environ, self.orig_environ) tempfile.tempdir = None
def test_debug(self): """Test enabling debug logging.""" for debug_arg in ['-d', '--debug']: args = [ '--software-name=somethingrandom', debug_arg, ] outtxt = self.eb_main(args) for log_msg_type in ['DEBUG', 'INFO', 'ERROR']: res = re.search(' %s ' % log_msg_type, outtxt) self.assertTrue(res, "%s log messages are included when using %s: %s" % (log_msg_type, debug_arg, outtxt)) modify_env(os.environ, self.orig_environ) tempfile.tempdir = None
def test_debug(self): """Test enabling debug logging.""" for debug_arg in ['-d', '--debug']: args = [ '--software-name=somethingrandom', debug_arg, ] outtxt = self.eb_main(args) for log_msg_type in ['DEBUG', 'INFO', 'ERROR']: res = re.search(' %s ' % log_msg_type, outtxt) self.assertTrue( res, "%s log messages are included when using %s: %s" % (log_msg_type, debug_arg, outtxt)) modify_env(os.environ, self.orig_environ) tempfile.tempdir = None
def test_zzz_logtostdout(self): """Testing redirecting log to stdout.""" fd, dummylogfn = tempfile.mkstemp(prefix='easybuild-dummy', suffix='.log') os.close(fd) for stdout_arg in ['--logtostdout', '-l']: _stdout = sys.stdout fd, fn = tempfile.mkstemp() fh = os.fdopen(fd, 'w') sys.stdout = fh args = [ '--software-name=somethingrandom', '--robot', '.', '--debug', stdout_arg, ] self.eb_main(args, logfile=dummylogfn) # make sure we restore sys.stdout.flush() sys.stdout = _stdout fancylogger.logToScreen(enable=False, stdout=True) outtxt = read_file(fn) self.assertTrue( len(outtxt) > 100, "Log messages are printed to stdout when %s is used (outtxt: %s)" % (stdout_arg, outtxt)) # cleanup os.remove(fn) modify_env(os.environ, self.orig_environ) tempfile.tempdir = None if os.path.exists(dummylogfn): os.remove(dummylogfn) fancylogger.logToFile(self.logfile)
def tearDown(self): """Clean up after running testcase.""" super(EnhancedTestCase, self).tearDown() os.chdir(self.cwd) modify_env(os.environ, self.orig_environ) tempfile.tempdir = None # restore original Python search path sys.path = self.orig_sys_path # cleanup for path in [self.logfile, self.test_buildpath, self.test_installpath, self.test_prefix]: try: if os.path.isdir(path): shutil.rmtree(path) else: os.remove(path) except OSError, err: pass
def test_debug(self): """Test enabling debug logging.""" for debug_arg in ["-d", "--debug"]: args = ["--software-name=somethingrandom", debug_arg] try: main((args, self.logfile, False)) except (SystemExit, Exception), err: myerr = err outtxt = read_file(self.logfile) for log_msg_type in ["DEBUG", "INFO", "ERROR"]: res = re.search(" %s " % log_msg_type, outtxt) self.assertTrue( res, "%s log messages are included when using %s: %s" % (log_msg_type, debug_arg, outtxt) ) modify_env(os.environ, self.orig_environ) tempfile.tempdir = None
def test_list_easyblocks(self): """Test listing easyblock hierarchy.""" fd, dummylogfn = tempfile.mkstemp(prefix='easybuild-dummy', suffix='.log') os.close(fd) # adjust PYTHONPATH such that test easyblocks are found orig_sys_path = sys.path[:] import easybuild sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), 'sandbox'))) easybuild = reload(easybuild) import easybuild.easyblocks reload(easybuild.easyblocks) reload(easybuild.tools.module_naming_scheme) # required to run options unit tests stand-alone # simple view for list_arg in ['--list-easyblocks', '--list-easyblocks=simple']: # clear log write_file(self.logfile, '') args = [ list_arg, '--unittest-file=%s' % self.logfile, ] try: main((args, dummylogfn, False)) except (SystemExit, Exception), err: pass outtxt = read_file(self.logfile) for pat in [ r"EasyBlock\n", r"|--\s+EB_foo\n|\s+|--\s+EB_foofoo\n", r"|--\s+bar\n", ]: self.assertTrue(re.search(pat, outtxt), "Pattern '%s' is found in output of --list-easyblocks: %s" % (pat, outtxt)) modify_env(os.environ, self.orig_environ) tempfile.tempdir = None
def test_quiet(self): """Test enabling quiet logging (errors only).""" for quiet_arg in ['--quiet']: args = [ '--software-name=somethingrandom', quiet_arg, ] outtxt = self.eb_main(args) for log_msg_type in ['ERROR']: res = re.search(' %s ' % log_msg_type, outtxt) self.assertTrue(res, "%s log messages are included when using %s (outtxt: %s)" % (log_msg_type, quiet_arg, outtxt)) for log_msg_type in ['DEBUG', 'INFO']: res = re.search(' %s ' % log_msg_type, outtxt) self.assertTrue(not res, "%s log messages are *not* included when using %s (outtxt: %s)" % (log_msg_type, quiet_arg, outtxt)) modify_env(os.environ, self.orig_environ) tempfile.tempdir = None
def test_info(self): """Test enabling info logging.""" for info_arg in ['--info']: args = [ '--software-name=somethingrandom', info_arg, ] outtxt = self.eb_main(args) for log_msg_type in ['INFO', 'ERROR']: res = re.search(' %s ' % log_msg_type, outtxt) self.assertTrue(res, "%s log messages are included when using %s ( out: %s)" % (log_msg_type, info_arg, outtxt)) for log_msg_type in ['DEBUG']: res = re.search(' %s ' % log_msg_type, outtxt) self.assertTrue(not res, "%s log messages are *not* included when using %s" % (log_msg_type, info_arg)) modify_env(os.environ, self.orig_environ) tempfile.tempdir = None
def test_force(self): """Test forcing installation even if the module is already available.""" # use GCC-4.6.3.eb easyconfig file that comes with the tests eb_file = os.path.join(os.path.dirname(__file__), 'easyconfigs', 'GCC-4.6.3.eb') # check log message without --force args = [ eb_file, '--debug', ] outtxt, error_thrown = self.eb_main(args, return_error=True) self.assertTrue( not error_thrown, "No error is thrown if software is already installed (error_thrown: %s)" % error_thrown) already_msg = "GCC/4.6.3 is already installed" self.assertTrue( re.search(already_msg, outtxt), "Already installed message without --force, outtxt: %s" % outtxt) # clear log file, clean up environment write_file(self.logfile, '') modify_env(os.environ, self.orig_environ) tempfile.tempdir = None # check that --force works args = [ eb_file, '--force', '--debug', ] outtxt = self.eb_main(args) self.assertTrue(not re.search(already_msg, outtxt), "Already installed message not there with --force")
def test_zzz_logtostdout(self): """Testing redirecting log to stdout.""" fd, dummylogfn = tempfile.mkstemp(prefix='easybuild-dummy', suffix='.log') os.close(fd) for stdout_arg in ['--logtostdout', '-l']: _stdout = sys.stdout fd, fn = tempfile.mkstemp() fh = os.fdopen(fd, 'w') sys.stdout = fh args = [ '--software-name=somethingrandom', '--robot', '.', '--debug', stdout_arg, ] self.eb_main(args, logfile=dummylogfn) # make sure we restore sys.stdout.flush() sys.stdout = _stdout fancylogger.logToScreen(enable=False, stdout=True) outtxt = read_file(fn) self.assertTrue(len(outtxt) > 100, "Log messages are printed to stdout when %s is used (outtxt: %s)" % (stdout_arg, outtxt)) # cleanup os.remove(fn) modify_env(os.environ, self.orig_environ) tempfile.tempdir = None if os.path.exists(dummylogfn): os.remove(dummylogfn) fancylogger.logToFile(self.logfile)
def tearDown(self): """Clean up after running testcase.""" super(EnhancedTestCase, self).tearDown() os.chdir(self.cwd) modify_env(os.environ, self.orig_environ) tempfile.tempdir = None # restore original Python search path sys.path = self.orig_sys_path # cleanup for path in [ self.logfile, self.test_buildpath, self.test_installpath, self.test_prefix ]: try: if os.path.isdir(path): shutil.rmtree(path) else: os.remove(path) except OSError, err: pass
def test_modify_env(self): """Test for modify_env function.""" old_env_vars = { 'TEST_ENV_VAR_TO_UNSET1': 'foobar', 'TEST_ENV_VAR_TO_UNSET2': 'value does not matter', 'TEST_COMMON_ENV_VAR_CHANGED': 'old_value', 'TEST_COMMON_ENV_VAR_SAME_VALUE': 'this_value_stays', } new_env_vars = { 'TEST_COMMON_ENV_VAR_CHANGED': 'new_value', 'TEST_NEW_ENV_VAR1': '1', 'TEST_NEW_ENV_VAR2': 'two 2 two', 'TEST_COMMON_ENV_VAR_SAME_VALUE': 'this_value_stays', } # prepare test environment first: # keys in new_env should not be set yet, keys in old_env are expected to be set for key in new_env_vars: if key in os.environ: del os.environ[key] for key in old_env_vars: os.environ[key] = old_env_vars[key] env.modify_env(os.environ, new_env_vars) self.assertEqual(os.environ.get('TEST_ENV_VAR_TO_UNSET1'), None) self.assertEqual(os.environ.get('TEST_ENV_VAR_TO_UNSET2'), None) self.assertEqual(os.environ.get('TEST_COMMON_ENV_VAR_CHANGED'), 'new_value') self.assertEqual(os.environ.get('TEST_COMMON_ENV_VAR_SAME_VALUE'), 'this_value_stays') self.assertEqual(os.environ.get('TEST_NEW_ENV_VAR1'), '1') self.assertEqual(os.environ.get('TEST_NEW_ENV_VAR2'), 'two 2 two') # extreme test case: empty entire environment (original env is restored for next tests) env.modify_env(os.environ, {})
def test_avail_lists(self): """Test listing available values of certain types.""" fd, dummylogfn = tempfile.mkstemp(prefix='easybuild-dummy', suffix='.log') os.close(fd) name_items = { 'modules-tools': ['EnvironmentModulesC', 'Lmod'], 'module-naming-schemes': ['EasyBuildModuleNamingScheme'], } for (name, items) in name_items.items(): args = [ '--avail-%s' % name, '--unittest-file=%s' % self.logfile, ] outtxt = self.eb_main(args, logfile=dummylogfn) words = name.replace('-', ' ') info_msg = r"INFO List of supported %s:" % words self.assertTrue(re.search(info_msg, outtxt), "Info message with list of available %s" % words) for item in items: res = re.findall("^\s*%s" % item, outtxt, re.M) self.assertTrue( res, "%s is included in list of available %s" % (item, words)) # every item should only be mentioned once n = len(res) self.assertEqual( n, 1, "%s is only mentioned once (count: %d)" % (item, n)) modify_env(os.environ, self.orig_environ) tempfile.tempdir = None if os.path.exists(dummylogfn): os.remove(dummylogfn)
def test_zzz_logtostdout(self): """Testing redirecting log to stdout.""" fd, dummylogfn = tempfile.mkstemp(prefix="easybuild-dummy", suffix=".log") os.close(fd) for stdout_arg in ["--logtostdout", "-l"]: _stdout = sys.stdout myerr = None fd, fn = tempfile.mkstemp() fh = os.fdopen(fd, "w") sys.stdout = fh args = ["--software-name=somethingrandom", "--robot", ".", "--debug", stdout_arg] try: main((args, dummylogfn, False)) except (SystemExit, Exception), err: myerr = err # make sure we restore sys.stdout.flush() sys.stdout = _stdout fancylogger.logToScreen(enable=False, stdout=True) outtxt = read_file(fn) self.assertTrue( len(outtxt) > 100, "Log messages are printed to stdout when %s is used (outtxt: %s)" % (stdout_arg, outtxt), ) # cleanup os.remove(fn) modify_env(os.environ, self.orig_environ) tempfile.tempdir = None
class EnhancedTestCase(_EnhancedTestCase): """Enhanced test case, provides extra functionality (e.g. an assertErrorRegex method).""" def setUp(self): """Set up testcase.""" super(EnhancedTestCase, self).setUp() # make sure option parser doesn't pick up any cmdline arguments/options while len(sys.argv) > 1: sys.argv.pop() # keep track of log handlers log = fancylogger.getLogger(fname=False) self.orig_log_handlers = log.handlers[:] log.info("setting up test %s" % self.id()) self.orig_tmpdir = tempfile.gettempdir() # use a subdirectory for this test (which we can clean up easily after the test completes) self.test_prefix = set_tmpdir() self.log = fancylogger.getLogger(self.__class__.__name__, fname=False) fd, self.logfile = tempfile.mkstemp(suffix='.log', prefix='eb-test-') os.close(fd) self.cwd = os.getcwd() # keep track of original environment to restore self.orig_environ = copy.deepcopy(os.environ) # keep track of original environment/Python search path to restore self.orig_sys_path = sys.path[:] testdir = os.path.dirname(os.path.abspath(__file__)) self.test_sourcepath = os.path.join(testdir, 'sandbox', 'sources') os.environ['EASYBUILD_SOURCEPATH'] = self.test_sourcepath os.environ['EASYBUILD_PREFIX'] = self.test_prefix self.test_buildpath = tempfile.mkdtemp() os.environ['EASYBUILD_BUILDPATH'] = self.test_buildpath self.test_installpath = tempfile.mkdtemp() os.environ['EASYBUILD_INSTALLPATH'] = self.test_installpath # make sure that the tests only pick up easyconfigs provided with the tests os.environ['EASYBUILD_ROBOT_PATHS'] = os.path.join( testdir, 'easyconfigs') # make sure no deprecated behaviour is being triggered (unless intended by the test) # trip *all* log.deprecated statements by setting deprecation version ridiculously high self.orig_current_version = eb_build_log.CURRENT_VERSION os.environ['EASYBUILD_DEPRECATED'] = '10000000' init_config() import easybuild # try to import easybuild.easyblocks(.generic) packages # it's OK if it fails here, but important to import first before fiddling with sys.path try: import easybuild.easyblocks import easybuild.easyblocks.generic except ImportError: pass # add sandbox to Python search path, update namespace packages sys.path.append(os.path.join(testdir, 'sandbox')) # workaround for bug in recent setuptools version (19.4 and newer, atleast until 20.3.1) # injecting <prefix>/easybuild is required to avoid a ValueError being thrown by fixup_namespace_packages # cfr. https://bitbucket.org/pypa/setuptools/issues/520/fixup_namespace_packages-may-trigger for path in sys.path[:]: if os.path.exists( os.path.join(path, 'easybuild', 'easyblocks', '__init__.py')): # keep track of 'easybuild' paths to inject into sys.path later sys.path.append(os.path.join(path, 'easybuild')) # required to make sure the 'easybuild' dir in the sandbox is picked up; # this relates to the other 'reload' statements below reload(easybuild) # this is strictly required to make the test modules in the sandbox available, due to declare_namespace fixup_namespace_packages(os.path.join(testdir, 'sandbox')) # remove any entries in Python search path that seem to provide easyblocks (except the sandbox) for path in sys.path[:]: if os.path.exists( os.path.join(path, 'easybuild', 'easyblocks', '__init__.py')): if not os.path.samefile(path, os.path.join(testdir, 'sandbox')): sys.path.remove(path) # hard inject location to (generic) test easyblocks into Python search path # only prepending to sys.path is not enough due to 'declare_namespace' in easybuild/easyblocks/__init__.py import easybuild.easyblocks reload(easybuild.easyblocks) test_easyblocks_path = os.path.join(testdir, 'sandbox', 'easybuild', 'easyblocks') easybuild.easyblocks.__path__.insert(0, test_easyblocks_path) import easybuild.easyblocks.generic reload(easybuild.easyblocks.generic) test_easyblocks_path = os.path.join(test_easyblocks_path, 'generic') easybuild.easyblocks.generic.__path__.insert(0, test_easyblocks_path) # save values of $PATH & $PYTHONPATH, so they can be restored later # this is important in case EasyBuild was installed as a module, since that module may be unloaded, # for example due to changes to $MODULEPATH in case EasyBuild was installed in a module hierarchy # cfr. https://github.com/hpcugent/easybuild-framework/issues/1685 self.env_path = os.environ['PATH'] self.env_pythonpath = os.environ['PYTHONPATH'] self.modtool = modules_tool() self.reset_modulepath([os.path.join(testdir, 'modules')]) reset_module_caches() def tearDown(self): """Clean up after running testcase.""" super(EnhancedTestCase, self).tearDown() self.log.info("Cleaning up for test %s", self.id()) # go back to where we were before os.chdir(self.cwd) # restore original environment modify_env(os.environ, self.orig_environ, verbose=False) # restore original Python search path sys.path = self.orig_sys_path import easybuild.easyblocks reload(easybuild.easyblocks) import easybuild.easyblocks.generic reload(easybuild.easyblocks.generic) # remove any log handlers that were added (so that log files can be effectively removed) log = fancylogger.getLogger(fname=False) new_log_handlers = [ h for h in log.handlers if h not in self.orig_log_handlers ] for log_handler in new_log_handlers: log_handler.close() log.removeHandler(log_handler) # cleanup test tmp dir try: shutil.rmtree(self.test_prefix) except (OSError, IOError): pass # restore original 'parent' tmpdir for var in ['TMPDIR', 'TEMP', 'TMP']: os.environ[var] = self.orig_tmpdir # reset to make sure tempfile picks up new temporary directory to use tempfile.tempdir = None def restore_env_path_pythonpath(self): """ Restore $PATH & $PYTHONPATH in environment using saved values. """ os.environ['PATH'] = self.env_path os.environ['PYTHONPATH'] = self.env_pythonpath def reset_modulepath(self, modpaths): """Reset $MODULEPATH with specified paths.""" for modpath in curr_module_paths(): self.modtool.remove_module_path(modpath, set_mod_paths=False) # make very sure $MODULEPATH is totally empty # some paths may be left behind, e.g. when they contain environment variables # example: "module unuse Modules/$MODULE_VERSION/modulefiles" may not yield the desired result os.environ['MODULEPATH'] = '' for modpath in modpaths: self.modtool.add_module_path(modpath, set_mod_paths=False) self.modtool.set_mod_paths() def eb_main(self, args, do_build=False, return_error=False, logfile=None, verbose=False, raise_error=False, reset_env=True, raise_systemexit=False, testing=True): """Helper method to call EasyBuild main function.""" cleanup() myerr = False if logfile is None: logfile = self.logfile # clear log file if logfile: f = open(logfile, 'w') f.write('') f.close() env_before = copy.deepcopy(os.environ) try: main(args=args, logfile=logfile, do_build=do_build, testing=testing, modtool=self.modtool) except SystemExit: if raise_systemexit: raise err except Exception, err: myerr = err if verbose: print "err: %s" % err if logfile and os.path.exists(logfile): logtxt = read_file(logfile) else: logtxt = None os.chdir(self.cwd) # make sure config is reinitialized init_config(with_include=False) # restore environment to what it was before running main, # changes may have been made by eb_main (e.g. $TMPDIR & co) if reset_env: modify_env(os.environ, env_before, verbose=False) tempfile.tempdir = None if myerr and raise_error: raise myerr if return_error: return logtxt, myerr else: return logtxt
not_found = re.search(not_found_msg, outtxt) self.assertTrue( not_found, "Module not found message there with --skip for non-existing modules: %s" % outtxt) modules_tool().purge() # restore original MODULEPATH if orig_modulepath is not None: os.environ['MODULEPATH'] = orig_modulepath else: os.environ.pop('MODULEPATH') # reinitialize modules tool with original $MODULEPATH, to avoid problems with future tests modules_tool() modify_env(os.environ, orig_environ) # cleanup shutil.rmtree(buildpath) shutil.rmtree(installpath) def test_job(self): """Test submitting build as a job.""" # set MODULEPATH to included modules orig_modulepath = os.getenv('MODULEPATH', None) os.environ['MODULEPATH'] = os.path.join(os.path.dirname(__file__), 'modules') # use gzip-1.4.eb easyconfig file that comes with the tests eb_file = os.path.join(os.path.dirname(__file__), 'easyconfigs',
def test_skip(self): """Test skipping installation of module (--skip, -k).""" # use temporary paths for build/install paths, make sure sources can be found buildpath = tempfile.mkdtemp() installpath = tempfile.mkdtemp() sourcepath = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'sandbox', 'sources') # use toy-0.0.eb easyconfig file that comes with the tests eb_file = os.path.join(os.path.dirname(__file__), 'easyconfigs', 'toy-0.0.eb') # check log message with --skip for existing module args = [ eb_file, '--sourcepath=%s' % sourcepath, '--buildpath=%s' % buildpath, '--installpath=%s' % installpath, '--force', '--debug', ] self.eb_main(args, do_build=True) modules_tool().purge() args.append('--skip') outtxt = self.eb_main(args, do_build=True, verbose=True) found_msg = "Module toy/0.0 found.\n[^\n]+Going to skip actual main build" found = re.search(found_msg, outtxt, re.M) self.assertTrue( found, "Module found message present with --skip, outtxt: %s" % outtxt) # cleanup for next test write_file(self.logfile, '') os.chdir(self.cwd) modules_tool().purge() # reinitialize modules tool with original $MODULEPATH, to avoid problems with future tests modify_env(os.environ, self.orig_environ) os.environ['MODULEPATH'] = '' modules_tool() tempfile.tempdir = None # check log message with --skip for non-existing module args = [ eb_file, '--sourcepath=%s' % sourcepath, '--buildpath=%s' % buildpath, '--installpath=%s' % installpath, '--try-software-version=1.2.3.4.5.6.7.8.9', '--try-amend=sources=toy-0.0.tar.gz,toy-0.0.tar.gz', # hackish, but fine '--force', '--debug', '--skip', ] outtxt = self.eb_main(args, do_build=True, verbose=True) found_msg = "Module toy/1.2.3.4.5.6.7.8.9 found." found = re.search(found_msg, outtxt) self.assertTrue( not found, "Module found message not there with --skip for non-existing modules: %s" % outtxt) not_found_msg = "No module toy/1.2.3.4.5.6.7.8.9 found. Not skipping anything." not_found = re.search(not_found_msg, outtxt) self.assertTrue( not_found, "Module not found message there with --skip for non-existing modules: %s" % outtxt) modules_tool().purge() # reinitialize modules tool with original $MODULEPATH, to avoid problems with future tests modify_env(os.environ, self.orig_environ) modules_tool() # cleanup shutil.rmtree(buildpath) shutil.rmtree(installpath)
class EnhancedTestCase(_EnhancedTestCase): """Enhanced test case, provides extra functionality (e.g. an assertErrorRegex method).""" def setUp(self): """Set up testcase.""" super(EnhancedTestCase, self).setUp() # keep track of log handlers log = fancylogger.getLogger(fname=False) self.orig_log_handlers = log.handlers[:] log.info("setting up test %s" % self.id()) self.orig_tmpdir = tempfile.gettempdir() # use a subdirectory for this test (which we can clean up easily after the test completes) self.test_prefix = set_tmpdir() self.log = fancylogger.getLogger(self.__class__.__name__, fname=False) fd, self.logfile = tempfile.mkstemp(suffix='.log', prefix='eb-test-') os.close(fd) self.cwd = os.getcwd() # keep track of original environment to restore self.orig_environ = copy.deepcopy(os.environ) # keep track of original environment/Python search path to restore self.orig_sys_path = sys.path[:] testdir = os.path.dirname(os.path.abspath(__file__)) self.test_sourcepath = os.path.join(testdir, 'sandbox', 'sources') os.environ['EASYBUILD_SOURCEPATH'] = self.test_sourcepath os.environ['EASYBUILD_PREFIX'] = self.test_prefix self.test_buildpath = tempfile.mkdtemp() os.environ['EASYBUILD_BUILDPATH'] = self.test_buildpath self.test_installpath = tempfile.mkdtemp() os.environ['EASYBUILD_INSTALLPATH'] = self.test_installpath # make sure that the tests only pick up easyconfigs provided with the tests os.environ['EASYBUILD_ROBOT_PATHS'] = os.path.join( testdir, 'easyconfigs') # make sure no deprecated behaviour is being triggered (unless intended by the test) # trip *all* log.deprecated statements by setting deprecation version ridiculously high self.orig_current_version = eb_build_log.CURRENT_VERSION os.environ['EASYBUILD_DEPRECATED'] = '10000000' init_config() # remove any entries in Python search path that seem to provide easyblocks for path in sys.path[:]: if os.path.exists( os.path.join(path, 'easybuild', 'easyblocks', '__init__.py')): sys.path.remove(path) # add test easyblocks to Python search path and (re)import and reload easybuild modules import easybuild sys.path.append(os.path.join(testdir, 'sandbox')) reload(easybuild) import easybuild.easyblocks reload(easybuild.easyblocks) import easybuild.easyblocks.generic reload(easybuild.easyblocks.generic) reload(easybuild.tools.module_naming_scheme ) # required to run options unit tests stand-alone modtool = modules_tool() # purge out any loaded modules with original $MODULEPATH before running each test modtool.purge() self.reset_modulepath([os.path.join(testdir, 'modules')]) def tearDown(self): """Clean up after running testcase.""" super(EnhancedTestCase, self).tearDown() self.log.info("Cleaning up for test %s", self.id()) # go back to where we were before os.chdir(self.cwd) # restore original environment modify_env(os.environ, self.orig_environ, verbose=False) # restore original Python search path sys.path = self.orig_sys_path # remove any log handlers that were added (so that log files can be effectively removed) log = fancylogger.getLogger(fname=False) new_log_handlers = [ h for h in log.handlers if h not in self.orig_log_handlers ] for log_handler in new_log_handlers: log_handler.close() log.removeHandler(log_handler) # cleanup test tmp dir try: shutil.rmtree(self.test_prefix) except (OSError, IOError): pass # restore original 'parent' tmpdir for var in ['TMPDIR', 'TEMP', 'TMP']: os.environ[var] = self.orig_tmpdir # reset to make sure tempfile picks up new temporary directory to use tempfile.tempdir = None def reset_modulepath(self, modpaths): """Reset $MODULEPATH with specified paths.""" modtool = modules_tool() for modpath in os.environ.get('MODULEPATH', '').split(os.pathsep): modtool.remove_module_path(modpath) # make very sure $MODULEPATH is totally empty # some paths may be left behind, e.g. when they contain environment variables # example: "module unuse Modules/$MODULE_VERSION/modulefiles" may not yield the desired result os.environ['MODULEPATH'] = '' for modpath in modpaths: modtool.add_module_path(modpath) def eb_main(self, args, do_build=False, return_error=False, logfile=None, verbose=False, raise_error=False, reset_env=True, raise_systemexit=False, testing=True): """Helper method to call EasyBuild main function.""" cleanup() myerr = False if logfile is None: logfile = self.logfile # clear log file if logfile: f = open(logfile, 'w') f.write('') f.close() env_before = copy.deepcopy(os.environ) try: main(args=args, logfile=logfile, do_build=do_build, testing=testing) except SystemExit: if raise_systemexit: raise err except Exception, err: myerr = err if verbose: print "err: %s" % err if logfile and os.path.exists(logfile): logtxt = read_file(logfile) else: logtxt = None os.chdir(self.cwd) # make sure config is reinitialized init_config() # restore environment to what it was before running main, # changes may have been made by eb_main (e.g. $TMPDIR & co) if reset_env: modify_env(os.environ, env_before) tempfile.tempdir = None if myerr and raise_error: raise myerr if return_error: return logtxt, myerr else: return logtxt
def test_skip(self): """Test skipping installation of module (--skip, -k).""" # use temporary paths for build/install paths, make sure sources can be found buildpath = tempfile.mkdtemp() installpath = tempfile.mkdtemp() sourcepath = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'sandbox', 'sources') # use toy-0.0.eb easyconfig file that comes with the tests eb_file = os.path.join(os.path.dirname(__file__), 'easyconfigs', 'toy-0.0.eb') # check log message with --skip for existing module args = [ eb_file, '--sourcepath=%s' % sourcepath, '--buildpath=%s' % buildpath, '--installpath=%s' % installpath, '--force', '--debug', ] self.eb_main(args, do_build=True) modules_tool().purge() args.append('--skip') outtxt = self.eb_main(args, do_build=True, verbose=True) found_msg = "Module toy/0.0 found.\n[^\n]+Going to skip actual main build" found = re.search(found_msg, outtxt, re.M) self.assertTrue(found, "Module found message present with --skip, outtxt: %s" % outtxt) # cleanup for next test write_file(self.logfile, '') os.chdir(self.cwd) modules_tool().purge() # reinitialize modules tool with original $MODULEPATH, to avoid problems with future tests modify_env(os.environ, self.orig_environ) os.environ['MODULEPATH'] = '' modules_tool() tempfile.tempdir = None # check log message with --skip for non-existing module args = [ eb_file, '--sourcepath=%s' % sourcepath, '--buildpath=%s' % buildpath, '--installpath=%s' % installpath, '--try-software-version=1.2.3.4.5.6.7.8.9', '--try-amend=sources=toy-0.0.tar.gz,toy-0.0.tar.gz', # hackish, but fine '--force', '--debug', '--skip', ] outtxt = self.eb_main(args, do_build=True, verbose=True) found_msg = "Module toy/1.2.3.4.5.6.7.8.9 found." found = re.search(found_msg, outtxt) self.assertTrue(not found, "Module found message not there with --skip for non-existing modules: %s" % outtxt) not_found_msg = "No module toy/1.2.3.4.5.6.7.8.9 found. Not skipping anything." not_found = re.search(not_found_msg, outtxt) self.assertTrue(not_found, "Module not found message there with --skip for non-existing modules: %s" % outtxt) modules_tool().purge() # reinitialize modules tool with original $MODULEPATH, to avoid problems with future tests modify_env(os.environ, self.orig_environ) modules_tool() # cleanup shutil.rmtree(buildpath) shutil.rmtree(installpath)
def modify_env(old, new): """ Compares 2 os.environ dumps. Adapts final environment. """ _log.deprecated("moved modify_env to tools.environment", "2.0") return env.modify_env(old, new)
def test_list_easyblocks(self): """Test listing easyblock hierarchy.""" fd, dummylogfn = tempfile.mkstemp(prefix='easybuild-dummy', suffix='.log') os.close(fd) # adjust PYTHONPATH such that test easyblocks are found import easybuild eb_blocks_path = os.path.abspath(os.path.join(os.path.dirname(__file__), 'sandbox')) if not eb_blocks_path in sys.path: sys.path.append(eb_blocks_path) easybuild = reload(easybuild) import easybuild.easyblocks reload(easybuild.easyblocks) reload(easybuild.tools.module_naming_scheme) # required to run options unit tests stand-alone # simple view for list_arg in ['--list-easyblocks', '--list-easyblocks=simple']: # clear log write_file(self.logfile, '') args = [ list_arg, '--unittest-file=%s' % self.logfile, ] outtxt = self.eb_main(args, logfile=dummylogfn) for pat in [ r"EasyBlock\n", r"|--\s+EB_foo\n|\s+|--\s+EB_foofoo\n", r"|--\s+bar\n", ]: self.assertTrue(re.search(pat, outtxt), "Pattern '%s' is found in output of --list-easyblocks: %s" % (pat, outtxt)) modify_env(os.environ, self.orig_environ) tempfile.tempdir = None # clear log write_file(self.logfile, '') # detailed view args = [ '--list-easyblocks=detailed', '--unittest-file=%s' % self.logfile, ] outtxt = self.eb_main(args, logfile=dummylogfn) for pat in [ r"EasyBlock\s+\(easybuild.framework.easyblock\)\n", r"|--\s+EB_foo\s+\(easybuild.easyblocks.foo\)\n|\s+|--\s+EB_foofoo\s+\(easybuild.easyblocks.foofoo\)\n", r"|--\s+bar\s+\(easybuild.easyblocks.generic.bar\)\n", ]: self.assertTrue(re.search(pat, outtxt), "Pattern '%s' is found in output of --list-easyblocks: %s" % (pat, outtxt)) if os.path.exists(dummylogfn): os.remove(dummylogfn)
def test_list_easyblocks(self): """Test listing easyblock hierarchy.""" fd, dummylogfn = tempfile.mkstemp(prefix='easybuild-dummy', suffix='.log') os.close(fd) # adjust PYTHONPATH such that test easyblocks are found import easybuild eb_blocks_path = os.path.abspath( os.path.join(os.path.dirname(__file__), 'sandbox')) if not eb_blocks_path in sys.path: sys.path.append(eb_blocks_path) easybuild = reload(easybuild) import easybuild.easyblocks reload(easybuild.easyblocks) reload(easybuild.tools.module_naming_scheme ) # required to run options unit tests stand-alone # simple view for list_arg in ['--list-easyblocks', '--list-easyblocks=simple']: # clear log write_file(self.logfile, '') args = [ list_arg, '--unittest-file=%s' % self.logfile, ] outtxt = self.eb_main(args, logfile=dummylogfn) for pat in [ r"EasyBlock\n", r"|--\s+EB_foo\n|\s+|--\s+EB_foofoo\n", r"|--\s+bar\n", ]: self.assertTrue( re.search(pat, outtxt), "Pattern '%s' is found in output of --list-easyblocks: %s" % (pat, outtxt)) modify_env(os.environ, self.orig_environ) tempfile.tempdir = None # clear log write_file(self.logfile, '') # detailed view args = [ '--list-easyblocks=detailed', '--unittest-file=%s' % self.logfile, ] outtxt = self.eb_main(args, logfile=dummylogfn) for pat in [ r"EasyBlock\s+\(easybuild.framework.easyblock\)\n", r"|--\s+EB_foo\s+\(easybuild.easyblocks.foo\)\n|\s+|--\s+EB_foofoo\s+\(easybuild.easyblocks.foofoo\)\n", r"|--\s+bar\s+\(easybuild.easyblocks.generic.bar\)\n", ]: self.assertTrue( re.search(pat, outtxt), "Pattern '%s' is found in output of --list-easyblocks: %s" % (pat, outtxt)) if os.path.exists(dummylogfn): os.remove(dummylogfn)