def test_extensions_step(self):
"""Test the extensions_step"""
self.contents = '\n'.join([
'easyblock = "ConfigureMake"',
'name = "pi"',
'version = "3.14"',
'homepage = "http://example.com"',
'description = "test easyconfig"',
'toolchain = {"name": "dummy", "version": "dummy"}',
'exts_list = ["ext1"]',
])
self.writeEC()
"""Testcase for extensions"""
# test for proper error message without the exts_defaultclass set
eb = EasyBlock(EasyConfig(self.eb_file))
eb.installdir = config.install_path()
self.assertRaises(EasyBuildError, eb.extensions_step, fetch=True)
self.assertErrorRegex(EasyBuildError, "No default extension class set", eb.extensions_step, fetch=True)
# test if everything works fine if set
self.contents += "\nexts_defaultclass = 'DummyExtension'"
self.writeEC()
eb = EasyBlock(EasyConfig(self.eb_file))
eb.builddir = config.build_path()
eb.installdir = config.install_path()
eb.extensions_step(fetch=True)
# test for proper error message when skip is set, but no exts_filter is set
self.assertRaises(EasyBuildError, eb.skip_extensions)
self.assertErrorRegex(EasyBuildError, "no exts_filter set", eb.skip_extensions)
# cleanup
eb.close_log()
os.remove(eb.logfile)
def test_extensions_step(self):
"""Test the extensions_step"""
self.contents = '\n'.join([
'easyblock = "ConfigureMake"',
'name = "pi"',
'version = "3.14"',
'homepage = "http://example.com"',
'description = "test easyconfig"',
'toolchain = {"name": "dummy", "version": "dummy"}',
'exts_list = ["ext1"]',
])
self.writeEC()
"""Testcase for extensions"""
# test for proper error message without the exts_defaultclass set
eb = EasyBlock(EasyConfig(self.eb_file))
eb.installdir = config.install_path()
self.assertRaises(EasyBuildError, eb.extensions_step, fetch=True)
self.assertErrorRegex(EasyBuildError, "No default extension class set", eb.extensions_step, fetch=True)
# test if everything works fine if set
self.contents += "\nexts_defaultclass = 'DummyExtension'"
self.writeEC()
eb = EasyBlock(EasyConfig(self.eb_file))
eb.builddir = config.build_path()
eb.installdir = config.install_path()
eb.extensions_step(fetch=True)
# test for proper error message when skip is set, but no exts_filter is set
self.assertRaises(EasyBuildError, eb.skip_extensions)
self.assertErrorRegex(EasyBuildError, "no exts_filter set", eb.skip_extensions)
# cleanup
eb.close_log()
os.remove(eb.logfile)
def test_extensions_step(self):
"""Test the extensions_step"""
self.contents = """
name = "pi"
version = "3.14"
homepage = "http://google.com"
description = "test easyconfig"
toolchain = {"name":"dummy", "version": "dummy"}
exts_list = ['ext1']
"""
self.writeEC()
"""Testcase for extensions"""
# test for proper error message without the exts_defaultclass set
eb = EasyBlock(self.eb_file)
eb.installdir = config.variables['installpath']
self.assertRaises(EasyBuildError, eb.extensions_step)
self.assertErrorRegex(EasyBuildError, "No default extension class set",
eb.extensions_step)
# test if everything works fine if set
self.contents += "\nexts_defaultclass = ['easybuild.framework.extension', 'Extension']"
self.writeEC()
eb = EasyBlock(self.eb_file)
eb.builddir = config.variables['buildpath']
eb.installdir = config.variables['installpath']
eb.extensions_step()
# test for proper error message when skip is set, but no exts_filter is set
self.assertRaises(EasyBuildError, eb.skip_extensions)
self.assertErrorRegex(EasyBuildError, "no exts_filter set",
eb.skip_extensions)
# cleanup
eb.close_log()
os.remove(eb.logfile)
def test_extensions_step(self):
"""Test the extensions_step"""
self.contents = """
name = "pi"
version = "3.14"
homepage = "http://example.com"
description = "test easyconfig"
toolchain = {"name":"dummy", "version": "dummy"}
exts_list = ['ext1']
"""
self.writeEC()
"""Testcase for extensions"""
# test for proper error message without the exts_defaultclass set
eb = EasyBlock(self.eb_file)
eb.installdir = config.variables['installpath']
self.assertRaises(EasyBuildError, eb.extensions_step)
self.assertErrorRegex(EasyBuildError, "No default extension class set", eb.extensions_step)
# test if everything works fine if set
self.contents += "\nexts_defaultclass = ['easybuild.framework.extension', 'Extension']"
self.writeEC()
eb = EasyBlock(self.eb_file)
eb.builddir = config.variables['buildpath']
eb.installdir = config.variables['installpath']
eb.extensions_step()
# test for proper error message when skip is set, but no exts_filter is set
self.assertRaises(EasyBuildError, eb.skip_extensions)
self.assertErrorRegex(EasyBuildError, "no exts_filter set", eb.skip_extensions)
# cleanup
eb.close_log()
os.remove(eb.logfile)
def test_make_module_extend_modpath(self):
"""Test for make_module_extend_modpath"""
self.contents = '\n'.join([
'easyblock = "ConfigureMake"',
'name = "pi"',
'version = "3.14"',
'homepage = "http://example.com"',
'description = "test easyconfig"',
'toolchain = {"name":"dummy", "version": "dummy"}',
'moduleclass = "compiler"',
])
self.writeEC()
eb = EasyBlock(EasyConfig(self.eb_file))
eb.installdir = config.install_path()
# no $MODULEPATH extensions for default module naming scheme (EasyBuildMNS)
self.assertEqual(eb.make_module_extend_modpath(), '')
usermodsdir = 'my/own/modules'
modclasses = ['compiler', 'tools']
os.environ['EASYBUILD_MODULE_NAMING_SCHEME'] = 'CategorizedHMNS'
build_options = {
'subdir_user_modules': usermodsdir,
'valid_module_classes': modclasses,
}
init_config(build_options=build_options)
eb = EasyBlock(EasyConfig(self.eb_file))
eb.installdir = config.install_path()
txt = eb.make_module_extend_modpath()
if get_module_syntax() == 'Tcl':
regexs = [r'^module use ".*/modules/all/Compiler/pi/3.14/%s"$' % c for c in modclasses]
home = r'\$env\(HOME\)'
regexs.extend([
# extension for user modules is guarded
r'if { \[ file isdirectory \[ file join %s "%s/Compiler/pi/3.14" \] \] } {$' % (home, usermodsdir),
# no per-moduleclass extension for user modules
r'^\s+module use \[ file join %s "%s/Compiler/pi/3.14"\ ]$' % (home, usermodsdir),
])
elif get_module_syntax() == 'Lua':
regexs = [r'^prepend_path\("MODULEPATH", ".*/modules/all/Compiler/pi/3.14/%s"\)$' % c for c in modclasses]
home = r'os.getenv\("HOME"\)'
regexs.extend([
# extension for user modules is guarded
r'if isDir\(pathJoin\(%s, "%s/Compiler/pi/3.14"\)\) then' % (home, usermodsdir),
# no per-moduleclass extension for user modules
r'\s+prepend_path\("MODULEPATH", pathJoin\(%s, "%s/Compiler/pi/3.14"\)\)' % (home, usermodsdir),
])
else:
self.assertTrue(False, "Unknown module syntax: %s" % get_module_syntax())
for regex in regexs:
regex = re.compile(regex, re.M)
self.assertTrue(regex.search(txt), "Pattern '%s' found in: %s" % (regex.pattern, txt))
def test_make_module_extend_modpath(self):
"""Test for make_module_extend_modpath"""
self.contents = '\n'.join([
'easyblock = "ConfigureMake"',
'name = "pi"',
'version = "3.14"',
'homepage = "http://example.com"',
'description = "test easyconfig"',
'toolchain = {"name":"dummy", "version": "dummy"}',
'moduleclass = "compiler"',
])
self.writeEC()
eb = EasyBlock(EasyConfig(self.eb_file))
eb.installdir = config.install_path()
# no $MODULEPATH extensions for default module naming scheme (EasyBuildMNS)
self.assertEqual(eb.make_module_extend_modpath(), '')
usermodsdir = 'my/own/modules'
modclasses = ['compiler', 'tools']
os.environ['EASYBUILD_MODULE_NAMING_SCHEME'] = 'CategorizedHMNS'
build_options = {
'subdir_user_modules': usermodsdir,
'valid_module_classes': modclasses,
}
init_config(build_options=build_options)
eb = EasyBlock(EasyConfig(self.eb_file))
eb.installdir = config.install_path()
txt = eb.make_module_extend_modpath()
if get_module_syntax() == 'Tcl':
regexs = [r'^module use ".*/modules/all/Compiler/pi/3.14/%s"$' % c for c in modclasses]
home = r'\$env\(HOME\)'
regexs.extend([
# extension for user modules is guarded
r'if { \[ file isdirectory \[ file join %s "%s/Compiler/pi/3.14" \] \] } {$' % (home, usermodsdir),
# no per-moduleclass extension for user modules
r'^\s+module use \[ file join %s "%s/Compiler/pi/3.14"\ ]$' % (home, usermodsdir),
])
elif get_module_syntax() == 'Lua':
regexs = [r'^prepend_path\("MODULEPATH", ".*/modules/all/Compiler/pi/3.14/%s"\)$' % c for c in modclasses]
home = r'os.getenv\("HOME"\)'
regexs.extend([
# extension for user modules is guarded
r'if isDir\(pathJoin\(%s, "%s/Compiler/pi/3.14"\)\) then' % (home, usermodsdir),
# no per-moduleclass extension for user modules
r'\s+prepend_path\("MODULEPATH", pathJoin\(%s, "%s/Compiler/pi/3.14"\)\)' % (home, usermodsdir),
])
else:
self.assertTrue(False, "Unknown module syntax: %s" % get_module_syntax())
for regex in regexs:
regex = re.compile(regex, re.M)
self.assertTrue(regex.search(txt), "Pattern '%s' found in: %s" % (regex.pattern, txt))
def test_skip_extensions_step(self):
"""Test the skip_extensions_step"""
self.contents = """
name = "pi"
version = "3.14"
homepage = "http://google.com"
description = "test easyconfig"
toolchain = {"name":"dummy", "version": "dummy"}
exts_list = ['ext1', 'ext2']
exts_filter = ("if [ %(name)s == 'ext2' ]; then exit 0; else exit 1; fi", '')
exts_defaultclass = ['easybuild.framework.extension', 'Extension']
"""
# check if skip skips correct extensions
self.writeEC()
eb = EasyBlock(self.eb_file)
#self.assertTrue('ext1' in eb.exts.keys() and 'ext2' in eb.exts.keys())
eb.builddir = config.variables['buildpath']
eb.installdir = config.variables['installpath']
eb.skip = True
eb.extensions_step()
# 'ext1' should be in eb.exts
self.assertTrue('ext1' in [y for x in eb.exts for y in x.values()])
# 'ext2' should not
self.assertFalse('ext2' in [y for x in eb.exts for y in x.values()])
# cleanup
eb.close_log()
os.remove(eb.logfile)
def test_skip_extensions_step(self):
"""Test the skip_extensions_step"""
self.contents = '\n'.join([
'easyblock = "ConfigureMake"',
'name = "pi"',
'version = "3.14"',
'homepage = "http://example.com"',
'description = "test easyconfig"',
'toolchain = {"name": "dummy", "version": "dummy"}',
'exts_list = ["ext1", "ext2"]',
'exts_filter = ("if [ %(ext_name)s == \'ext2\' ]; then exit 0; else exit 1; fi", "")',
'exts_defaultclass = "DummyExtension"',
])
# check if skip skips correct extensions
self.writeEC()
eb = EasyBlock(EasyConfig(self.eb_file))
eb.builddir = config.build_path()
eb.installdir = config.install_path()
eb.skip = True
eb.extensions_step(fetch=True)
# 'ext1' should be in eb.exts
self.assertTrue('ext1' in [y for x in eb.exts for y in x.values()])
# 'ext2' should not
self.assertFalse('ext2' in [y for x in eb.exts for y in x.values()])
# cleanup
eb.close_log()
os.remove(eb.logfile)
def test_skip_extensions_step(self):
"""Test the skip_extensions_step"""
self.contents = '\n'.join([
'easyblock = "ConfigureMake"',
'name = "pi"',
'version = "3.14"',
'homepage = "http://example.com"',
'description = "test easyconfig"',
'toolchain = {"name": "dummy", "version": "dummy"}',
'exts_list = ["ext1", "ext2"]',
'exts_filter = ("if [ %(ext_name)s == \'ext2\' ]; then exit 0; else exit 1; fi", "")',
'exts_defaultclass = "DummyExtension"',
])
# check if skip skips correct extensions
self.writeEC()
eb = EasyBlock(EasyConfig(self.eb_file))
eb.builddir = config.build_path()
eb.installdir = config.install_path()
eb.skip = True
eb.extensions_step(fetch=True)
# 'ext1' should be in eb.exts
self.assertTrue('ext1' in [y for x in eb.exts for y in x.values()])
# 'ext2' should not
self.assertFalse('ext2' in [y for x in eb.exts for y in x.values()])
# cleanup
eb.close_log()
os.remove(eb.logfile)
def test_skip_extensions_step(self):
"""Test the skip_extensions_step"""
self.contents = """
name = "pi"
version = "3.14"
homepage = "http://example.com"
description = "test easyconfig"
toolchain = {"name":"dummy", "version": "dummy"}
exts_list = ['ext1', 'ext2']
exts_filter = ("if [ %(name)s == 'ext2' ]; then exit 0; else exit 1; fi", '')
exts_defaultclass = ['easybuild.framework.extension', 'Extension']
"""
# check if skip skips correct extensions
self.writeEC()
eb = EasyBlock(self.eb_file)
#self.assertTrue('ext1' in eb.exts.keys() and 'ext2' in eb.exts.keys())
eb.builddir = config.variables['buildpath']
eb.installdir = config.variables['installpath']
eb.skip = True
eb.extensions_step()
# 'ext1' should be in eb.exts
self.assertTrue('ext1' in [y for x in eb.exts for y in x.values()])
# 'ext2' should not
self.assertFalse('ext2' in [y for x in eb.exts for y in x.values()])
# cleanup
eb.close_log()
os.remove(eb.logfile)
def test_make_module_req(self):
"""Testcase for make_module_req"""
self.contents = '\n'.join([
'name = "pi"',
'version = "3.14"',
'homepage = "http://example.com"',
'description = "test easyconfig"',
'toolchain = {"name":"dummy", "version": "dummy"}',
])
self.writeEC()
eb = EasyBlock(EasyConfig(self.eb_file))
eb.installdir = config.install_path()
# create fake directories and files that should be guessed
os.makedirs(eb.installdir)
open(os.path.join(eb.installdir, 'foo.jar'), 'w').write('foo.jar')
open(os.path.join(eb.installdir, 'bla.jar'), 'w').write('bla.jar')
os.mkdir(os.path.join(eb.installdir, 'bin'))
os.mkdir(os.path.join(eb.installdir, 'share'))
os.mkdir(os.path.join(eb.installdir, 'share', 'man'))
# this is not a path that should be picked up
os.mkdir(os.path.join(eb.installdir, 'CPATH'))
guess = eb.make_module_req()
self.assertTrue(re.search("^prepend-path\s+CLASSPATH\s+\$root/bla.jar$", guess, re.M))
self.assertTrue(re.search("^prepend-path\s+CLASSPATH\s+\$root/foo.jar$", guess, re.M))
self.assertTrue(re.search("^prepend-path\s+MANPATH\s+\$root/share/man$", guess, re.M))
self.assertTrue(re.search("^prepend-path\s+PATH\s+\$root/bin$", guess, re.M))
self.assertFalse(re.search("^prepend-path\s+CPATH\s+.*$", guess, re.M))
# cleanup
eb.close_log()
os.remove(eb.logfile)
def test_make_module_req(self):
"""Testcase for make_module_req"""
self.contents = '\n'.join([
'name = "pi"',
'version = "3.14"',
'homepage = "http://example.com"',
'description = "test easyconfig"',
'toolchain = {"name":"dummy", "version": "dummy"}',
])
self.writeEC()
eb = EasyBlock(EasyConfig(self.eb_file))
eb.installdir = config.install_path()
# create fake directories and files that should be guessed
os.makedirs(eb.installdir)
open(os.path.join(eb.installdir, 'foo.jar'), 'w').write('foo.jar')
open(os.path.join(eb.installdir, 'bla.jar'), 'w').write('bla.jar')
os.mkdir(os.path.join(eb.installdir, 'bin'))
os.mkdir(os.path.join(eb.installdir, 'share'))
os.mkdir(os.path.join(eb.installdir, 'share', 'man'))
# this is not a path that should be picked up
os.mkdir(os.path.join(eb.installdir, 'CPATH'))
guess = eb.make_module_req()
self.assertTrue(re.search("^prepend-path\s+CLASSPATH\s+\$root/bla.jar$", guess, re.M))
self.assertTrue(re.search("^prepend-path\s+CLASSPATH\s+\$root/foo.jar$", guess, re.M))
self.assertTrue(re.search("^prepend-path\s+MANPATH\s+\$root/share/man$", guess, re.M))
self.assertTrue(re.search("^prepend-path\s+PATH\s+\$root/bin$", guess, re.M))
self.assertFalse(re.search("^prepend-path\s+CPATH\s+.*$", guess, re.M))
# cleanup
eb.close_log()
os.remove(eb.logfile)
def test_make_module_step(self):
"""Test the make_module_step"""
name = "pi"
version = "3.14"
deps = [("GCC", "4.6.4")]
hiddendeps = [("toy", "0.0-deps")]
alldeps = deps + hiddendeps # hidden deps must be included in list of deps
modextravars = {"PI": "3.1415", "FOO": "bar"}
modextrapaths = {"PATH": "pibin", "CPATH": "pi/include"}
self.contents = "\n".join(
[
'name = "%s"' % name,
'version = "%s"' % version,
'homepage = "http://example.com"',
'description = "test easyconfig"',
"toolchain = {'name': 'dummy', 'version': 'dummy'}",
"dependencies = %s" % str(alldeps),
"hiddendependencies = %s" % str(hiddendeps),
"builddependencies = [('OpenMPI', '1.6.4-GCC-4.6.4')]",
"modextravars = %s" % str(modextravars),
"modextrapaths = %s" % str(modextrapaths),
]
)
test_dir = os.path.dirname(os.path.abspath(__file__))
os.environ["MODULEPATH"] = os.path.join(test_dir, "modules")
# test if module is generated correctly
self.writeEC()
ec = EasyConfig(self.eb_file)
eb = EasyBlock(ec)
# eb.builddir = self.test_buildpath
eb.installdir = os.path.join(config.install_path(), "pi", "3.14")
eb.check_readiness_step()
modpath = os.path.join(eb.make_module_step(), name, version)
self.assertTrue(os.path.exists(modpath), "%s exists" % modpath)
# verify contents of module
f = open(modpath, "r")
txt = f.read()
f.close()
self.assertTrue(re.search("^#%Module", txt.split("\n")[0]))
self.assertTrue(re.search("^conflict\s+%s$" % name, txt, re.M))
self.assertTrue(re.search("^set\s+root\s+%s$" % eb.installdir, txt, re.M))
self.assertTrue(re.search('^setenv\s+EBROOT%s\s+".root"\s*$' % name.upper(), txt, re.M))
self.assertTrue(re.search('^setenv\s+EBVERSION%s\s+"%s"$' % (name.upper(), version), txt, re.M))
for (key, val) in modextravars.items():
regex = re.compile('^setenv\s+%s\s+"%s"$' % (key, val), re.M)
self.assertTrue(regex.search(txt), "Pattern %s found in %s" % (regex.pattern, txt))
for (key, val) in modextrapaths.items():
regex = re.compile("^prepend-path\s+%s\s+\$root/%s$" % (key, val), re.M)
self.assertTrue(regex.search(txt), "Pattern %s found in %s" % (regex.pattern, txt))
for (name, ver) in deps:
regex = re.compile("^\s*module load %s\s*$" % os.path.join(name, ver), re.M)
self.assertTrue(regex.search(txt), "Pattern %s found in %s" % (regex.pattern, txt))
for (name, ver) in hiddendeps:
regex = re.compile("^\s*module load %s/.%s\s*$" % (name, ver), re.M)
self.assertTrue(regex.search(txt), "Pattern %s found in %s" % (regex.pattern, txt))
def test_make_module_step(self):
"""Test the make_module_step"""
name = "pi"
version = "3.14"
modextravars = {'PI': '3.1415', 'FOO': 'bar'}
modextrapaths = {'PATH': 'pibin', 'CPATH': 'pi/include'}
self.contents = '\n'.join([
'name = "%s"' % name,
'version = "%s"' % version,
'homepage = "http://google.com"',
'description = "test easyconfig"',
"toolchain = {'name': 'dummy', 'version': 'dummy'}",
"dependencies = [('foo', '1.2.3')]",
"builddependencies = [('bar', '9.8.7')]",
"modextravars = %s" % str(modextravars),
"modextrapaths = %s" % str(modextrapaths),
])
# overwrite installpath config setting
orig_installpath = config.variables['installpath']
installpath = tempfile.mkdtemp()
config.variables['installpath'] = installpath
# test if module is generated correctly
self.writeEC()
eb = EasyBlock(self.eb_file)
eb.installdir = os.path.join(config.variables['installpath'],
config.variables['subdir_software'], 'pi',
'3.14')
modpath = os.path.join(eb.make_module_step(), name, version)
self.assertTrue(os.path.exists(modpath))
# verify contents of module
f = open(modpath, 'r')
txt = f.read()
f.close()
self.assertTrue(re.search("^#%Module", txt.split('\n')[0]))
self.assertTrue(re.search("^conflict\s+%s$" % name, txt, re.M))
self.assertTrue(
re.search("^set\s+root\s+%s$" % eb.installdir, txt, re.M))
self.assertTrue(
re.search('^setenv\s+EBROOT%s\s+".root"\s*$' % name.upper(), txt,
re.M))
self.assertTrue(
re.search(
'^setenv\s+EBVERSION%s\s+"%s"$' % (name.upper(), version), txt,
re.M))
for (key, val) in modextravars.items():
self.assertTrue(
re.search('^setenv\s+%s\s+"%s"$' % (key, val), txt, re.M))
for (key, val) in modextrapaths.items():
self.assertTrue(
re.search('^prepend-path\s+%s\s+\$root/%s$' % (key, val), txt,
re.M))
# restore original settings
config.variables['installpath'] = orig_installpath
def test_make_module_step(self):
"""Test the make_module_step"""
name = "pi"
version = "3.14"
deps = [('GCC', '4.6.4')]
hiddendeps = [('toy', '0.0-deps')]
alldeps = deps + hiddendeps # hidden deps must be included in list of deps
modextravars = {'PI': '3.1415', 'FOO': 'bar'}
modextrapaths = {'PATH': 'pibin', 'CPATH': 'pi/include'}
self.contents = '\n'.join([
'easyblock = "ConfigureMake"',
'name = "%s"' % name,
'version = "%s"' % version,
'homepage = "http://example.com"',
'description = "test easyconfig"',
"toolchain = {'name': 'dummy', 'version': 'dummy'}",
"dependencies = %s" % str(alldeps),
"hiddendependencies = %s" % str(hiddendeps),
"builddependencies = [('OpenMPI', '1.6.4-GCC-4.6.4')]",
"modextravars = %s" % str(modextravars),
"modextrapaths = %s" % str(modextrapaths),
])
test_dir = os.path.dirname(os.path.abspath(__file__))
os.environ['MODULEPATH'] = os.path.join(test_dir, 'modules')
# test if module is generated correctly
self.writeEC()
ec = EasyConfig(self.eb_file)
eb = EasyBlock(ec)
eb.installdir = os.path.join(config.install_path(), 'pi', '3.14')
eb.check_readiness_step()
modpath = os.path.join(eb.make_module_step(), name, version)
self.assertTrue(os.path.exists(modpath), "%s exists" % modpath)
# verify contents of module
f = open(modpath, 'r')
txt = f.read()
f.close()
self.assertTrue(re.search("^#%Module", txt.split('\n')[0]))
self.assertTrue(re.search("^conflict\s+%s$" % name, txt, re.M))
self.assertTrue(re.search("^set\s+root\s+%s$" % eb.installdir, txt, re.M))
self.assertTrue(re.search('^setenv\s+EBROOT%s\s+".root"\s*$' % name.upper(), txt, re.M))
self.assertTrue(re.search('^setenv\s+EBVERSION%s\s+"%s"$' % (name.upper(), version), txt, re.M))
for (key, val) in modextravars.items():
regex = re.compile('^setenv\s+%s\s+"%s"$' % (key, val), re.M)
self.assertTrue(regex.search(txt), "Pattern %s found in %s" % (regex.pattern, txt))
for (key, val) in modextrapaths.items():
regex = re.compile('^prepend-path\s+%s\s+\$root/%s$' % (key, val), re.M)
self.assertTrue(regex.search(txt), "Pattern %s found in %s" % (regex.pattern, txt))
for (name, ver) in deps:
regex = re.compile('^\s*module load %s\s*$' % os.path.join(name, ver), re.M)
self.assertTrue(regex.search(txt), "Pattern %s found in %s" % (regex.pattern, txt))
for (name, ver) in hiddendeps:
regex = re.compile('^\s*module load %s/.%s\s*$' % (name, ver), re.M)
self.assertTrue(regex.search(txt), "Pattern %s found in %s" % (regex.pattern, txt))
def test_make_module_extra(self):
"""Test for make_module_extra."""
self.contents = '\n'.join([
'easyblock = "ConfigureMake"',
'name = "pi"',
'version = "3.14"',
'homepage = "http://example.com"',
'description = "test easyconfig"',
"toolchain = {'name': 'gompi', 'version': '1.1.0-no-OFED'}",
'dependencies = [',
" ('FFTW', '3.3.1'),",
" ('LAPACK', '3.4.0'),",
']',
])
self.writeEC()
eb = EasyBlock(EasyConfig(self.eb_file))
eb.installdir = os.path.join(config.install_path(), 'pi', '3.14')
if get_module_syntax() == 'Tcl':
expected_default = re.compile(r'\n'.join([
r'setenv\s+EBROOTPI\s+\"\$root"',
r'setenv\s+EBVERSIONPI\s+"3.14"',
r'setenv\s+EBDEVELPI\s+"\$root/easybuild/pi-3.14-gompi-1.1.0-no-OFED-easybuild-devel"',
]))
expected_alt = re.compile(r'\n'.join([
r'setenv\s+EBROOTPI\s+"/opt/software/tau/6.28"',
r'setenv\s+EBVERSIONPI\s+"6.28"',
r'setenv\s+EBDEVELPI\s+"\$root/easybuild/pi-3.14-gompi-1.1.0-no-OFED-easybuild-devel"',
]))
elif get_module_syntax() == 'Lua':
expected_default = re.compile(r'\n'.join([
r'setenv\("EBROOTPI", root\)',
r'setenv\("EBVERSIONPI", "3.14"\)',
r'setenv\("EBDEVELPI", pathJoin\(root, "easybuild/pi-3.14-gompi-1.1.0-no-OFED-easybuild-devel"\)\)',
]))
expected_alt = re.compile(r'\n'.join([
r'setenv\("EBROOTPI", "/opt/software/tau/6.28"\)',
r'setenv\("EBVERSIONPI", "6.28"\)',
r'setenv\("EBDEVELPI", pathJoin\(root, "easybuild/pi-3.14-gompi-1.1.0-no-OFED-easybuild-devel"\)\)',
]))
else:
self.assertTrue(False,
"Unknown module syntax: %s" % get_module_syntax())
defaulttxt = eb.make_module_extra().strip()
self.assertTrue(
expected_default.match(defaulttxt),
"Pattern %s found in %s" % (expected_default.pattern, defaulttxt))
alttxt = eb.make_module_extra(altroot='/opt/software/tau/6.28',
altversion='6.28').strip()
self.assertTrue(
expected_alt.match(alttxt),
"Pattern %s found in %s" % (expected_alt.pattern, alttxt))
def test_fake_module_load(self):
"""Testcase for fake module load"""
self.contents = """
name = "pi"
version = "3.14"
homepage = "http://google.com"
description = "test easyconfig"
toolchain = {"name":"dummy", "version": "dummy"}
"""
self.writeEC()
eb = EasyBlock(self.eb_file)
eb.installdir = config.variables['install_path']
eb.load_fake_module()
def test_make_module_extra(self):
"""Test for make_module_extra."""
self.contents = '\n'.join([
'easyblock = "ConfigureMake"',
'name = "pi"',
'version = "3.14"',
'homepage = "http://example.com"',
'description = "test easyconfig"',
"toolchain = {'name': 'gompi', 'version': '1.1.0-no-OFED'}",
'dependencies = [',
" ('FFTW', '3.3.1'),",
" ('LAPACK', '3.4.0'),",
']',
])
self.writeEC()
eb = EasyBlock(EasyConfig(self.eb_file))
eb.installdir = os.path.join(config.install_path(), 'pi', '3.14')
if get_module_syntax() == 'Tcl':
expected_default = re.compile(r'\n'.join([
r'setenv\s+EBROOTPI\s+\"\$root"',
r'setenv\s+EBVERSIONPI\s+"3.14"',
r'setenv\s+EBDEVELPI\s+"\$root/easybuild/pi-3.14-gompi-1.1.0-no-OFED-easybuild-devel"',
]))
expected_alt = re.compile(r'\n'.join([
r'setenv\s+EBROOTPI\s+"/opt/software/tau/6.28"',
r'setenv\s+EBVERSIONPI\s+"6.28"',
r'setenv\s+EBDEVELPI\s+"\$root/easybuild/pi-3.14-gompi-1.1.0-no-OFED-easybuild-devel"',
]))
elif get_module_syntax() == 'Lua':
expected_default = re.compile(r'\n'.join([
r'setenv\("EBROOTPI", root\)',
r'setenv\("EBVERSIONPI", "3.14"\)',
r'setenv\("EBDEVELPI", pathJoin\(root, "easybuild/pi-3.14-gompi-1.1.0-no-OFED-easybuild-devel"\)\)',
]))
expected_alt = re.compile(r'\n'.join([
r'setenv\("EBROOTPI", "/opt/software/tau/6.28"\)',
r'setenv\("EBVERSIONPI", "6.28"\)',
r'setenv\("EBDEVELPI", pathJoin\(root, "easybuild/pi-3.14-gompi-1.1.0-no-OFED-easybuild-devel"\)\)',
]))
else:
self.assertTrue(False, "Unknown module syntax: %s" % get_module_syntax())
defaulttxt = eb.make_module_extra().strip()
self.assertTrue(expected_default.match(defaulttxt),
"Pattern %s found in %s" % (expected_default.pattern, defaulttxt))
alttxt = eb.make_module_extra(altroot='/opt/software/tau/6.28', altversion='6.28').strip()
self.assertTrue(expected_alt.match(alttxt),
"Pattern %s found in %s" % (expected_alt.pattern, alttxt))
def test_make_module_dep_hmns(self):
"""Test for make_module_dep under HMNS"""
test_ecs_path = os.path.join(
os.path.dirname(os.path.abspath(__file__)), 'easyconfigs',
'test_ecs')
all_stops = [x[0] for x in EasyBlock.get_steps()]
build_options = {
'check_osdeps': False,
'robot_path': [test_ecs_path],
'valid_stops': all_stops,
'validate': False,
}
os.environ['EASYBUILD_MODULE_NAMING_SCHEME'] = 'HierarchicalMNS'
init_config(build_options=build_options)
self.setup_hierarchical_modules()
self.contents = '\n'.join([
'easyblock = "ConfigureMake"',
'name = "pi"',
'version = "3.14"',
'homepage = "http://example.com"',
'description = "test easyconfig"',
"toolchain = {'name': 'gompi', 'version': '1.4.10'}",
'dependencies = [',
" ('FFTW', '3.3.3'),",
']',
])
self.writeEC()
eb = EasyBlock(EasyConfig(self.eb_file))
eb.installdir = os.path.join(config.install_path(), 'pi', '3.14')
eb.check_readiness_step()
eb.make_builddir()
eb.prepare_step()
# GCC, OpenMPI and hwloc modules should *not* be included in loads for dependencies
mod_dep_txt = eb.make_module_dep()
for mod in ['GCC/4.7.2', 'OpenMPI/1.6.4']:
regex = re.compile('load.*%s' % mod)
self.assertFalse(
regex.search(mod_dep_txt),
"Pattern '%s' found in: %s" % (regex.pattern, mod_dep_txt))
regex = re.compile('load.*FFTW/3.3.3')
self.assertTrue(
regex.search(mod_dep_txt),
"Pattern '%s' found in: %s" % (regex.pattern, mod_dep_txt))
def test_make_module_step(self):
"""Test the make_module_step"""
name = "pi"
version = "3.14"
modextravars = {'PI': '3.1415', 'FOO': 'bar'}
modextrapaths = {'PATH': 'pibin', 'CPATH': 'pi/include'}
self.contents = '\n'.join([
'name = "%s"' % name,
'version = "%s"' % version,
'homepage = "http://example.com"',
'description = "test easyconfig"',
"toolchain = {'name': 'dummy', 'version': 'dummy'}",
"dependencies = [('foo', '1.2.3')]",
"builddependencies = [('bar', '9.8.7')]",
"modextravars = %s" % str(modextravars),
"modextrapaths = %s" % str(modextrapaths),
])
# overwrite installpath config setting
orig_installpath = config.variables['installpath']
installpath = tempfile.mkdtemp()
config.variables['installpath'] = installpath
# test if module is generated correctly
self.writeEC()
eb = EasyBlock(self.eb_file)
eb.installdir = os.path.join(config.variables['installpath'], config.variables['subdir_software'], 'pi', '3.14')
modpath = os.path.join(eb.make_module_step(), name, version)
self.assertTrue(os.path.exists(modpath))
# verify contents of module
f = open(modpath, 'r')
txt = f.read()
f.close()
self.assertTrue(re.search("^#%Module", txt.split('\n')[0]))
self.assertTrue(re.search("^conflict\s+%s$" % name, txt, re.M))
self.assertTrue(re.search("^set\s+root\s+%s$" % eb.installdir, txt, re.M))
self.assertTrue(re.search('^setenv\s+EBROOT%s\s+".root"\s*$' % name.upper(), txt, re.M))
self.assertTrue(re.search('^setenv\s+EBVERSION%s\s+"%s"$' % (name.upper(), version), txt, re.M))
for (key, val) in modextravars.items():
self.assertTrue(re.search('^setenv\s+%s\s+"%s"$' % (key, val), txt, re.M))
for (key, val) in modextrapaths.items():
self.assertTrue(re.search('^prepend-path\s+%s\s+\$root/%s$' % (key, val), txt, re.M))
# restore original settings
config.variables['installpath'] = orig_installpath
def test_fake_module_load(self):
"""Testcase for fake module load"""
self.contents = """
name = "pi"
version = "3.14"
homepage = "http://google.com"
description = "test easyconfig"
toolchain = {"name":"dummy", "version": "dummy"}
"""
self.writeEC()
eb = EasyBlock(self.eb_file)
eb.installdir = config.variables['installpath']
fake_mod_data = eb.load_fake_module()
eb.clean_up_fake_module(fake_mod_data)
# cleanup
eb.close_log()
os.remove(eb.logfile)
def test_fake_module_load(self):
"""Testcase for fake module load"""
self.contents = """
name = "pi"
version = "3.14"
homepage = "http://example.com"
description = "test easyconfig"
toolchain = {"name":"dummy", "version": "dummy"}
"""
self.writeEC()
eb = EasyBlock(self.eb_file)
eb.installdir = config.variables['installpath']
fake_mod_data = eb.load_fake_module()
eb.clean_up_fake_module(fake_mod_data)
# cleanup
eb.close_log()
os.remove(eb.logfile)
def test_fake_module_load(self):
"""Testcase for fake module load"""
self.contents = '\n'.join([
'name = "pi"',
'version = "3.14"',
'homepage = "http://example.com"',
'description = "test easyconfig"',
'toolchain = {"name": "dummy", "version": "dummy"}',
])
self.writeEC()
eb = EasyBlock(EasyConfig(self.eb_file))
eb.installdir = config.build_path()
fake_mod_data = eb.load_fake_module()
eb.clean_up_fake_module(fake_mod_data)
# cleanup
eb.close_log()
os.remove(eb.logfile)
def test_fake_module_load(self):
"""Testcase for fake module load"""
self.contents = '\n'.join([
'name = "pi"',
'version = "3.14"',
'homepage = "http://example.com"',
'description = "test easyconfig"',
'toolchain = {"name": "dummy", "version": "dummy"}',
])
self.writeEC()
eb = EasyBlock(EasyConfig(self.eb_file))
eb.installdir = config.build_path()
fake_mod_data = eb.load_fake_module()
eb.clean_up_fake_module(fake_mod_data)
# cleanup
eb.close_log()
os.remove(eb.logfile)
def test_make_module_req(self):
"""Testcase for make_module_req"""
self.contents = '\n'.join([
'easyblock = "ConfigureMake"',
'name = "pi"',
'version = "3.14"',
'homepage = "http://example.com"',
'description = "test easyconfig"',
'toolchain = {"name":"dummy", "version": "dummy"}',
])
self.writeEC()
eb = EasyBlock(EasyConfig(self.eb_file))
eb.installdir = config.install_path()
# create fake directories and files that should be guessed
os.makedirs(eb.installdir)
open(os.path.join(eb.installdir, 'foo.jar'), 'w').write('foo.jar')
open(os.path.join(eb.installdir, 'bla.jar'), 'w').write('bla.jar')
os.mkdir(os.path.join(eb.installdir, 'bin'))
os.mkdir(os.path.join(eb.installdir, 'share'))
os.mkdir(os.path.join(eb.installdir, 'share', 'man'))
# this is not a path that should be picked up
os.mkdir(os.path.join(eb.installdir, 'CPATH'))
guess = eb.make_module_req()
if get_module_syntax() == 'Tcl':
self.assertTrue(re.search(r"^prepend-path\s+CLASSPATH\s+\$root/bla.jar$", guess, re.M))
self.assertTrue(re.search(r"^prepend-path\s+CLASSPATH\s+\$root/foo.jar$", guess, re.M))
self.assertTrue(re.search(r"^prepend-path\s+MANPATH\s+\$root/share/man$", guess, re.M))
self.assertTrue(re.search(r"^prepend-path\s+PATH\s+\$root/bin$", guess, re.M))
self.assertFalse(re.search(r"^prepend-path\s+CPATH\s+.*$", guess, re.M))
elif get_module_syntax() == 'Lua':
self.assertTrue(re.search(r'^prepend_path\("CLASSPATH", pathJoin\(root, "bla.jar"\)\)$', guess, re.M))
self.assertTrue(re.search(r'^prepend_path\("CLASSPATH", pathJoin\(root, "foo.jar"\)\)$', guess, re.M))
self.assertTrue(re.search(r'^prepend_path\("MANPATH", pathJoin\(root, "share/man"\)\)$', guess, re.M))
self.assertTrue(re.search(r'^prepend_path\("PATH", pathJoin\(root, "bin"\)\)$', guess, re.M))
self.assertFalse(re.search(r'^prepend_path\("CPATH", .*\)$', guess, re.M))
else:
self.assertTrue(False, "Unknown module syntax: %s" % get_module_syntax())
# cleanup
eb.close_log()
os.remove(eb.logfile)
def test_make_module_dep_hmns(self):
"""Test for make_module_dep under HMNS"""
test_ecs_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'easyconfigs', 'test_ecs')
all_stops = [x[0] for x in EasyBlock.get_steps()]
build_options = {
'check_osdeps': False,
'robot_path': [test_ecs_path],
'valid_stops': all_stops,
'validate': False,
}
os.environ['EASYBUILD_MODULE_NAMING_SCHEME'] = 'HierarchicalMNS'
init_config(build_options=build_options)
self.setup_hierarchical_modules()
self.contents = '\n'.join([
'easyblock = "ConfigureMake"',
'name = "pi"',
'version = "3.14"',
'homepage = "http://example.com"',
'description = "test easyconfig"',
"toolchain = {'name': 'gompi', 'version': '1.4.10'}",
'dependencies = [',
" ('FFTW', '3.3.3'),",
']',
])
self.writeEC()
eb = EasyBlock(EasyConfig(self.eb_file))
eb.installdir = os.path.join(config.install_path(), 'pi', '3.14')
eb.check_readiness_step()
eb.make_builddir()
eb.prepare_step()
# GCC, OpenMPI and hwloc modules should *not* be included in loads for dependencies
mod_dep_txt = eb.make_module_dep()
for mod in ['GCC/4.7.2', 'OpenMPI/1.6.4']:
regex = re.compile('load.*%s' % mod)
self.assertFalse(regex.search(mod_dep_txt), "Pattern '%s' found in: %s" % (regex.pattern, mod_dep_txt))
regex = re.compile('load.*FFTW/3.3.3')
self.assertTrue(regex.search(mod_dep_txt), "Pattern '%s' found in: %s" % (regex.pattern, mod_dep_txt))
def test_make_module_step(self):
"""Test the make_module_step"""
name = "pi"
version = "3.14"
deps = [('GCC', '4.6.4')]
modextravars = {'PI': '3.1415', 'FOO': 'bar'}
modextrapaths = {'PATH': 'pibin', 'CPATH': 'pi/include'}
self.contents = '\n'.join([
'easyblock = "ConfigureMake"',
'name = "%s"' % name,
'version = "%s"' % version,
'homepage = "http://example.com"',
'description = "test easyconfig"',
"toolchain = {'name': 'dummy', 'version': 'dummy'}",
"dependencies = [('GCC', '4.6.4'), ('toy', '0.0-deps')]",
"builddependencies = [('OpenMPI', '1.6.4-GCC-4.6.4')]",
# hidden deps must be included in list of (build)deps
"hiddendependencies = [('toy', '0.0-deps'), ('OpenMPI', '1.6.4-GCC-4.6.4')]",
"modextravars = %s" % str(modextravars),
"modextrapaths = %s" % str(modextrapaths),
])
test_dir = os.path.dirname(os.path.abspath(__file__))
os.environ['MODULEPATH'] = os.path.join(test_dir, 'modules')
# test if module is generated correctly
self.writeEC()
ec = EasyConfig(self.eb_file)
eb = EasyBlock(ec)
eb.installdir = os.path.join(config.install_path(), 'pi', '3.14')
eb.check_readiness_step()
modpath = os.path.join(eb.make_module_step(), name, version)
if get_module_syntax() == 'Lua':
modpath += '.lua'
self.assertTrue(os.path.exists(modpath), "%s exists" % modpath)
# verify contents of module
txt = read_file(modpath)
if get_module_syntax() == 'Tcl':
self.assertTrue(re.search(r"^#%Module", txt.split('\n')[0]))
self.assertTrue(re.search(r"^conflict\s+%s$" % name, txt, re.M))
self.assertTrue(re.search(r"^set\s+root\s+%s$" % eb.installdir, txt, re.M))
ebroot_regex = re.compile(r'^setenv\s+EBROOT%s\s+"\$root"\s*$' % name.upper(), re.M)
self.assertTrue(ebroot_regex.search(txt), "%s in %s" % (ebroot_regex.pattern, txt))
self.assertTrue(re.search(r'^setenv\s+EBVERSION%s\s+"%s"$' % (name.upper(), version), txt, re.M))
elif get_module_syntax() == 'Lua':
ebroot_regex = re.compile(r'^setenv\("EBROOT%s", root\)$' % name.upper(), re.M)
self.assertTrue(ebroot_regex.search(txt), "%s in %s" % (ebroot_regex.pattern, txt))
self.assertTrue(re.search(r'^setenv\("EBVERSION%s", "%s"\)$' % (name.upper(), version), txt, re.M))
else:
self.assertTrue(False, "Unknown module syntax: %s" % get_module_syntax())
for (key, val) in modextravars.items():
if get_module_syntax() == 'Tcl':
regex = re.compile(r'^setenv\s+%s\s+"%s"$' % (key, val), re.M)
elif get_module_syntax() == 'Lua':
regex = re.compile(r'^setenv\("%s", "%s"\)$' % (key, val), re.M)
else:
self.assertTrue(False, "Unknown module syntax: %s" % get_module_syntax())
self.assertTrue(regex.search(txt), "Pattern %s found in %s" % (regex.pattern, txt))
for (key, val) in modextrapaths.items():
if get_module_syntax() == 'Tcl':
regex = re.compile(r'^prepend-path\s+%s\s+\$root/%s$' % (key, val), re.M)
elif get_module_syntax() == 'Lua':
regex = re.compile(r'^prepend_path\("%s", pathJoin\(root, "%s"\)\)$' % (key, val), re.M)
else:
self.assertTrue(False, "Unknown module syntax: %s" % get_module_syntax())
self.assertTrue(regex.search(txt), "Pattern %s found in %s" % (regex.pattern, txt))
for (name, ver) in [('GCC', '4.6.4')]:
if get_module_syntax() == 'Tcl':
regex = re.compile(r'^\s*module load %s\s*$' % os.path.join(name, ver), re.M)
elif get_module_syntax() == 'Lua':
regex = re.compile(r'^\s*load\("%s"\)$' % os.path.join(name, ver), re.M)
else:
self.assertTrue(False, "Unknown module syntax: %s" % get_module_syntax())
self.assertTrue(regex.search(txt), "Pattern %s found in %s" % (regex.pattern, txt))
for (name, ver) in [('toy', '0.0-deps')]:
if get_module_syntax() == 'Tcl':
regex = re.compile(r'^\s*module load %s/.%s\s*$' % (name, ver), re.M)
elif get_module_syntax() == 'Lua':
regex = re.compile(r'^\s*load\("%s/.%s"\)$' % (name, ver), re.M)
else:
self.assertTrue(False, "Unknown module syntax: %s" % get_module_syntax())
self.assertTrue(regex.search(txt), "Pattern %s found in %s" % (regex.pattern, txt))
for (name, ver) in [('OpenMPI', '1.6.4-GCC-4.6.4')]:
if get_module_syntax() == 'Tcl':
regex = re.compile(r'^\s*module load %s/.?%s\s*$' % (name, ver), re.M)
elif get_module_syntax() == 'Lua':
regex = re.compile(r'^\s*load\("%s/.?%s"\)$' % (name, ver), re.M)
else:
self.assertTrue(False, "Unknown module syntax: %s" % get_module_syntax())
self.assertFalse(regex.search(txt), "Pattern '%s' *not* found in %s" % (regex.pattern, txt))
def test_make_module_step(self):
"""Test the make_module_step"""
name = "pi"
version = "3.14"
deps = [('GCC', '4.6.4')]
modextravars = {'PI': '3.1415', 'FOO': 'bar'}
modextrapaths = {'PATH': 'pibin', 'CPATH': 'pi/include'}
self.contents = '\n'.join([
'easyblock = "ConfigureMake"',
'name = "%s"' % name,
'version = "%s"' % version,
'homepage = "http://example.com"',
'description = "test easyconfig"',
"toolchain = {'name': 'dummy', 'version': 'dummy'}",
"dependencies = [('GCC', '4.6.4'), ('toy', '0.0-deps')]",
"builddependencies = [('OpenMPI', '1.6.4-GCC-4.6.4')]",
# hidden deps must be included in list of (build)deps
"hiddendependencies = [('toy', '0.0-deps'), ('OpenMPI', '1.6.4-GCC-4.6.4')]",
"modextravars = %s" % str(modextravars),
"modextrapaths = %s" % str(modextrapaths),
])
test_dir = os.path.dirname(os.path.abspath(__file__))
os.environ['MODULEPATH'] = os.path.join(test_dir, 'modules')
# test if module is generated correctly
self.writeEC()
ec = EasyConfig(self.eb_file)
eb = EasyBlock(ec)
eb.installdir = os.path.join(config.install_path(), 'pi', '3.14')
eb.check_readiness_step()
modpath = os.path.join(eb.make_module_step(), name, version)
if get_module_syntax() == 'Lua':
modpath += '.lua'
self.assertTrue(os.path.exists(modpath), "%s exists" % modpath)
# verify contents of module
txt = read_file(modpath)
if get_module_syntax() == 'Tcl':
self.assertTrue(re.search(r"^#%Module", txt.split('\n')[0]))
self.assertTrue(re.search(r"^conflict\s+%s$" % name, txt, re.M))
self.assertTrue(
re.search(r"^set\s+root\s+%s$" % eb.installdir, txt, re.M))
ebroot_regex = re.compile(
r'^setenv\s+EBROOT%s\s+"\$root"\s*$' % name.upper(), re.M)
self.assertTrue(ebroot_regex.search(txt),
"%s in %s" % (ebroot_regex.pattern, txt))
self.assertTrue(
re.search(
r'^setenv\s+EBVERSION%s\s+"%s"$' % (name.upper(), version),
txt, re.M))
elif get_module_syntax() == 'Lua':
ebroot_regex = re.compile(
r'^setenv\("EBROOT%s", root\)$' % name.upper(), re.M)
self.assertTrue(ebroot_regex.search(txt),
"%s in %s" % (ebroot_regex.pattern, txt))
self.assertTrue(
re.search(
r'^setenv\("EBVERSION%s", "%s"\)$' %
(name.upper(), version), txt, re.M))
else:
self.assertTrue(False,
"Unknown module syntax: %s" % get_module_syntax())
for (key, val) in modextravars.items():
if get_module_syntax() == 'Tcl':
regex = re.compile(r'^setenv\s+%s\s+"%s"$' % (key, val), re.M)
elif get_module_syntax() == 'Lua':
regex = re.compile(r'^setenv\("%s", "%s"\)$' % (key, val),
re.M)
else:
self.assertTrue(
False, "Unknown module syntax: %s" % get_module_syntax())
self.assertTrue(regex.search(txt),
"Pattern %s found in %s" % (regex.pattern, txt))
for (key, val) in modextrapaths.items():
if get_module_syntax() == 'Tcl':
regex = re.compile(
r'^prepend-path\s+%s\s+\$root/%s$' % (key, val), re.M)
elif get_module_syntax() == 'Lua':
regex = re.compile(
r'^prepend_path\("%s", pathJoin\(root, "%s"\)\)$' %
(key, val), re.M)
else:
self.assertTrue(
False, "Unknown module syntax: %s" % get_module_syntax())
self.assertTrue(regex.search(txt),
"Pattern %s found in %s" % (regex.pattern, txt))
for (name, ver) in [('GCC', '4.6.4')]:
if get_module_syntax() == 'Tcl':
regex = re.compile(
r'^\s*module load %s\s*$' % os.path.join(name, ver), re.M)
elif get_module_syntax() == 'Lua':
regex = re.compile(
r'^\s*load\("%s"\)$' % os.path.join(name, ver), re.M)
else:
self.assertTrue(
False, "Unknown module syntax: %s" % get_module_syntax())
self.assertTrue(regex.search(txt),
"Pattern %s found in %s" % (regex.pattern, txt))
for (name, ver) in [('toy', '0.0-deps')]:
if get_module_syntax() == 'Tcl':
regex = re.compile(r'^\s*module load %s/.%s\s*$' % (name, ver),
re.M)
elif get_module_syntax() == 'Lua':
regex = re.compile(r'^\s*load\("%s/.%s"\)$' % (name, ver),
re.M)
else:
self.assertTrue(
False, "Unknown module syntax: %s" % get_module_syntax())
self.assertTrue(regex.search(txt),
"Pattern %s found in %s" % (regex.pattern, txt))
for (name, ver) in [('OpenMPI', '1.6.4-GCC-4.6.4')]:
if get_module_syntax() == 'Tcl':
regex = re.compile(
r'^\s*module load %s/.?%s\s*$' % (name, ver), re.M)
elif get_module_syntax() == 'Lua':
regex = re.compile(r'^\s*load\("%s/.?%s"\)$' % (name, ver),
re.M)
else:
self.assertTrue(
False, "Unknown module syntax: %s" % get_module_syntax())
self.assertFalse(
regex.search(txt),
"Pattern '%s' *not* found in %s" % (regex.pattern, txt))
def test_make_module_dep(self):
"""Test for make_module_dep"""
self.contents = '\n'.join([
'easyblock = "ConfigureMake"',
'name = "pi"',
'version = "3.14"',
'homepage = "http://example.com"',
'description = "test easyconfig"',
"toolchain = {'name': 'gompi', 'version': '1.1.0-no-OFED'}",
'dependencies = [',
" ('FFTW', '3.3.1'),",
" ('LAPACK', '3.4.0'),",
']',
])
self.writeEC()
eb = EasyBlock(EasyConfig(self.eb_file))
eb.installdir = os.path.join(config.install_path(), 'pi', '3.14')
eb.check_readiness_step()
if get_module_syntax() == 'Tcl':
tc_load = '\n'.join([
"if { ![ is-loaded gompi/1.1.0-no-OFED ] } {",
" module load gompi/1.1.0-no-OFED",
"}",
])
fftw_load = '\n'.join([
"if { ![ is-loaded FFTW/3.3.1-gompi-1.1.0-no-OFED ] } {",
" module load FFTW/3.3.1-gompi-1.1.0-no-OFED",
"}",
])
lapack_load = '\n'.join([
"if { ![ is-loaded LAPACK/3.4.0-gompi-1.1.0-no-OFED ] } {",
" module load LAPACK/3.4.0-gompi-1.1.0-no-OFED",
"}",
])
elif get_module_syntax() == 'Lua':
tc_load = '\n'.join([
'if not isloaded("gompi/1.1.0-no-OFED") then',
' load("gompi/1.1.0-no-OFED")',
'end',
])
fftw_load = '\n'.join([
'if not isloaded("FFTW/3.3.1-gompi-1.1.0-no-OFED") then',
' load("FFTW/3.3.1-gompi-1.1.0-no-OFED")',
'end',
])
lapack_load = '\n'.join([
'if not isloaded("LAPACK/3.4.0-gompi-1.1.0-no-OFED") then',
' load("LAPACK/3.4.0-gompi-1.1.0-no-OFED")',
'end',
])
else:
self.assertTrue(False, "Unknown module syntax: %s" % get_module_syntax())
expected = tc_load + '\n\n' + fftw_load + '\n\n' + lapack_load
self.assertEqual(eb.make_module_dep().strip(), expected)
# provide swap info for FFTW to trigger an extra 'unload FFTW'
unload_info = {
'FFTW/3.3.1-gompi-1.1.0-no-OFED': 'FFTW',
}
if get_module_syntax() == 'Tcl':
fftw_load = '\n'.join([
"if { ![ is-loaded FFTW/3.3.1-gompi-1.1.0-no-OFED ] } {",
" module unload FFTW",
" module load FFTW/3.3.1-gompi-1.1.0-no-OFED",
"}",
])
elif get_module_syntax() == 'Lua':
fftw_load = '\n'.join([
'if not isloaded("FFTW/3.3.1-gompi-1.1.0-no-OFED") then',
' unload("FFTW")',
' load("FFTW/3.3.1-gompi-1.1.0-no-OFED")',
'end',
])
else:
self.assertTrue(False, "Unknown module syntax: %s" % get_module_syntax())
expected = tc_load + '\n\n' + fftw_load + '\n\n' + lapack_load
self.assertEqual(eb.make_module_dep(unload_info=unload_info).strip(), expected)
def test_make_module_req(self):
"""Testcase for make_module_req"""
self.contents = '\n'.join([
'easyblock = "ConfigureMake"',
'name = "pi"',
'version = "3.14"',
'homepage = "http://example.com"',
'description = "test easyconfig"',
'toolchain = {"name":"dummy", "version": "dummy"}',
])
self.writeEC()
eb = EasyBlock(EasyConfig(self.eb_file))
eb.installdir = config.install_path()
# create fake directories and files that should be guessed
os.makedirs(eb.installdir)
open(os.path.join(eb.installdir, 'foo.jar'), 'w').write('foo.jar')
open(os.path.join(eb.installdir, 'bla.jar'), 'w').write('bla.jar')
os.mkdir(os.path.join(eb.installdir, 'bin'))
os.mkdir(os.path.join(eb.installdir, 'share'))
os.mkdir(os.path.join(eb.installdir, 'share', 'man'))
# this is not a path that should be picked up
os.mkdir(os.path.join(eb.installdir, 'CPATH'))
guess = eb.make_module_req()
if get_module_syntax() == 'Tcl':
self.assertTrue(
re.search(r"^prepend-path\s+CLASSPATH\s+\$root/bla.jar$",
guess, re.M))
self.assertTrue(
re.search(r"^prepend-path\s+CLASSPATH\s+\$root/foo.jar$",
guess, re.M))
self.assertTrue(
re.search(r"^prepend-path\s+MANPATH\s+\$root/share/man$",
guess, re.M))
self.assertTrue(
re.search(r"^prepend-path\s+PATH\s+\$root/bin$", guess, re.M))
self.assertFalse(
re.search(r"^prepend-path\s+CPATH\s+.*$", guess, re.M))
elif get_module_syntax() == 'Lua':
self.assertTrue(
re.search(
r'^prepend_path\("CLASSPATH", pathJoin\(root, "bla.jar"\)\)$',
guess, re.M))
self.assertTrue(
re.search(
r'^prepend_path\("CLASSPATH", pathJoin\(root, "foo.jar"\)\)$',
guess, re.M))
self.assertTrue(
re.search(
r'^prepend_path\("MANPATH", pathJoin\(root, "share/man"\)\)$',
guess, re.M))
self.assertTrue(
re.search(r'^prepend_path\("PATH", pathJoin\(root, "bin"\)\)$',
guess, re.M))
self.assertFalse(
re.search(r'^prepend_path\("CPATH", .*\)$', guess, re.M))
else:
self.assertTrue(False,
"Unknown module syntax: %s" % get_module_syntax())
# check for behavior when a string value is used as dict value by make_module_req_guesses
eb.make_module_req_guess = lambda: {'PATH': 'bin'}
txt = eb.make_module_req()
if get_module_syntax() == 'Tcl':
self.assertTrue(
re.match(r"^\nprepend-path\s+PATH\s+\$root/bin\n$", txt, re.M))
elif get_module_syntax() == 'Lua':
self.assertTrue(
re.match(
r'^\nprepend_path\("PATH", pathJoin\(root, "bin"\)\)\n$',
txt, re.M))
else:
self.assertTrue(False,
"Unknown module syntax: %s" % get_module_syntax())
# check for correct behaviour if empty string is specified as one of the values
# prepend-path statements should be included for both the 'bin' subdir and the install root
eb.make_module_req_guess = lambda: {'PATH': ['bin', '']}
txt = eb.make_module_req()
if get_module_syntax() == 'Tcl':
self.assertTrue(
re.search(r"\nprepend-path\s+PATH\s+\$root/bin\n", txt, re.M))
self.assertTrue(
re.search(r"\nprepend-path\s+PATH\s+\$root\n", txt, re.M))
elif get_module_syntax() == 'Lua':
self.assertTrue(
re.search(
r'\nprepend_path\("PATH", pathJoin\(root, "bin"\)\)\n',
txt, re.M))
self.assertTrue(
re.search(r'\nprepend_path\("PATH", root\)\n', txt, re.M))
else:
self.assertTrue(False,
"Unknown module syntax: %s" % get_module_syntax())
# cleanup
eb.close_log()
os.remove(eb.logfile)
def test_make_module_req(self):
"""Testcase for make_module_req"""
self.contents = '\n'.join([
'easyblock = "ConfigureMake"',
'name = "pi"',
'version = "3.14"',
'homepage = "http://example.com"',
'description = "test easyconfig"',
'toolchain = {"name":"dummy", "version": "dummy"}',
])
self.writeEC()
eb = EasyBlock(EasyConfig(self.eb_file))
eb.installdir = config.install_path()
# create fake directories and files that should be guessed
os.makedirs(eb.installdir)
open(os.path.join(eb.installdir, 'foo.jar'), 'w').write('foo.jar')
open(os.path.join(eb.installdir, 'bla.jar'), 'w').write('bla.jar')
os.mkdir(os.path.join(eb.installdir, 'bin'))
os.mkdir(os.path.join(eb.installdir, 'share'))
os.mkdir(os.path.join(eb.installdir, 'share', 'man'))
# this is not a path that should be picked up
os.mkdir(os.path.join(eb.installdir, 'CPATH'))
guess = eb.make_module_req()
if get_module_syntax() == 'Tcl':
self.assertTrue(re.search(r"^prepend-path\s+CLASSPATH\s+\$root/bla.jar$", guess, re.M))
self.assertTrue(re.search(r"^prepend-path\s+CLASSPATH\s+\$root/foo.jar$", guess, re.M))
self.assertTrue(re.search(r"^prepend-path\s+MANPATH\s+\$root/share/man$", guess, re.M))
self.assertTrue(re.search(r"^prepend-path\s+PATH\s+\$root/bin$", guess, re.M))
self.assertFalse(re.search(r"^prepend-path\s+CPATH\s+.*$", guess, re.M))
elif get_module_syntax() == 'Lua':
self.assertTrue(re.search(r'^prepend_path\("CLASSPATH", pathJoin\(root, "bla.jar"\)\)$', guess, re.M))
self.assertTrue(re.search(r'^prepend_path\("CLASSPATH", pathJoin\(root, "foo.jar"\)\)$', guess, re.M))
self.assertTrue(re.search(r'^prepend_path\("MANPATH", pathJoin\(root, "share/man"\)\)$', guess, re.M))
self.assertTrue(re.search(r'^prepend_path\("PATH", pathJoin\(root, "bin"\)\)$', guess, re.M))
self.assertFalse(re.search(r'^prepend_path\("CPATH", .*\)$', guess, re.M))
else:
self.assertTrue(False, "Unknown module syntax: %s" % get_module_syntax())
# check for behavior when a string value is used as dict value by make_module_req_guesses
eb.make_module_req_guess = lambda: {'PATH': 'bin'}
txt = eb.make_module_req()
if get_module_syntax() == 'Tcl':
self.assertTrue(re.match(r"^\nprepend-path\s+PATH\s+\$root/bin\n$", txt, re.M))
elif get_module_syntax() == 'Lua':
self.assertTrue(re.match(r'^\nprepend_path\("PATH", pathJoin\(root, "bin"\)\)\n$', txt, re.M))
else:
self.assertTrue(False, "Unknown module syntax: %s" % get_module_syntax())
# check for correct behaviour if empty string is specified as one of the values
# prepend-path statements should be included for both the 'bin' subdir and the install root
eb.make_module_req_guess = lambda: {'PATH': ['bin', '']}
txt = eb.make_module_req()
if get_module_syntax() == 'Tcl':
self.assertTrue(re.search(r"\nprepend-path\s+PATH\s+\$root/bin\n", txt, re.M))
self.assertTrue(re.search(r"\nprepend-path\s+PATH\s+\$root\n", txt, re.M))
elif get_module_syntax() == 'Lua':
self.assertTrue(re.search(r'\nprepend_path\("PATH", pathJoin\(root, "bin"\)\)\n', txt, re.M))
self.assertTrue(re.search(r'\nprepend_path\("PATH", root\)\n', txt, re.M))
else:
self.assertTrue(False, "Unknown module syntax: %s" % get_module_syntax())
# cleanup
eb.close_log()
os.remove(eb.logfile)
def test_make_module_dep(self):
"""Test for make_module_dep"""
self.contents = '\n'.join([
'easyblock = "ConfigureMake"',
'name = "pi"',
'version = "3.14"',
'homepage = "http://example.com"',
'description = "test easyconfig"',
"toolchain = {'name': 'gompi', 'version': '1.1.0-no-OFED'}",
'dependencies = [',
" ('FFTW', '3.3.1'),",
" ('LAPACK', '3.4.0'),",
']',
])
self.writeEC()
eb = EasyBlock(EasyConfig(self.eb_file))
eb.installdir = os.path.join(config.install_path(), 'pi', '3.14')
eb.check_readiness_step()
if get_module_syntax() == 'Tcl':
tc_load = '\n'.join([
"if { ![ is-loaded gompi/1.1.0-no-OFED ] } {",
" module load gompi/1.1.0-no-OFED",
"}",
])
fftw_load = '\n'.join([
"if { ![ is-loaded FFTW/3.3.1-gompi-1.1.0-no-OFED ] } {",
" module load FFTW/3.3.1-gompi-1.1.0-no-OFED",
"}",
])
lapack_load = '\n'.join([
"if { ![ is-loaded LAPACK/3.4.0-gompi-1.1.0-no-OFED ] } {",
" module load LAPACK/3.4.0-gompi-1.1.0-no-OFED",
"}",
])
elif get_module_syntax() == 'Lua':
tc_load = '\n'.join([
'if not isloaded("gompi/1.1.0-no-OFED") then',
' load("gompi/1.1.0-no-OFED")',
'end',
])
fftw_load = '\n'.join([
'if not isloaded("FFTW/3.3.1-gompi-1.1.0-no-OFED") then',
' load("FFTW/3.3.1-gompi-1.1.0-no-OFED")',
'end',
])
lapack_load = '\n'.join([
'if not isloaded("LAPACK/3.4.0-gompi-1.1.0-no-OFED") then',
' load("LAPACK/3.4.0-gompi-1.1.0-no-OFED")',
'end',
])
else:
self.assertTrue(False,
"Unknown module syntax: %s" % get_module_syntax())
expected = tc_load + '\n\n' + fftw_load + '\n\n' + lapack_load
self.assertEqual(eb.make_module_dep().strip(), expected)
# provide swap info for FFTW to trigger an extra 'unload FFTW'
unload_info = {
'FFTW/3.3.1-gompi-1.1.0-no-OFED': 'FFTW',
}
if get_module_syntax() == 'Tcl':
fftw_load = '\n'.join([
"if { ![ is-loaded FFTW/3.3.1-gompi-1.1.0-no-OFED ] } {",
" module unload FFTW",
" module load FFTW/3.3.1-gompi-1.1.0-no-OFED",
"}",
])
elif get_module_syntax() == 'Lua':
fftw_load = '\n'.join([
'if not isloaded("FFTW/3.3.1-gompi-1.1.0-no-OFED") then',
' unload("FFTW")',
' load("FFTW/3.3.1-gompi-1.1.0-no-OFED")',
'end',
])
else:
self.assertTrue(False,
"Unknown module syntax: %s" % get_module_syntax())
expected = tc_load + '\n\n' + fftw_load + '\n\n' + lapack_load
self.assertEqual(
eb.make_module_dep(unload_info=unload_info).strip(), expected)
