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_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_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_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_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_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_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_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_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_gen_dirs(self):
"""Test methods that generate/set build/install directory names."""
self.contents = '\n'.join([
"name = 'pi'",
"version = '3.14'",
"homepage = 'http://example.com'",
"description = 'test easyconfig'",
"toolchain = {'name': 'dummy', 'version': 'dummy'}",
])
self.writeEC()
stdoutorig = sys.stdout
sys.stdout = open("/dev/null", 'w')
eb = EasyBlock(EasyConfig(self.eb_file))
resb = eb.gen_builddir()
eb.mod_name = det_full_module_name(
eb.cfg) # required by gen_installdir()
resi = eb.gen_installdir()
eb.make_builddir()
eb.make_installdir()
# doesn't return anything
self.assertEqual(resb, None)
self.assertEqual(resi, None)
# directories are set, and exist
self.assertTrue(os.path.isdir(eb.builddir))
self.assertTrue(os.path.isdir(eb.installdir))
# make sure cleaning up old build dir is default
self.assertTrue(eb.cfg['cleanupoldbuild']
or eb.cfg.get('cleanupoldbuild', True))
builddir = eb.builddir
eb.gen_builddir()
self.assertEqual(builddir, eb.builddir)
eb.cfg['cleanupoldbuild'] = True
eb.gen_builddir()
self.assertEqual(builddir, eb.builddir)
# make sure build dir is unique
eb.cfg['cleanupoldbuild'] = False
builddir = eb.builddir
for i in range(3):
eb.gen_builddir()
self.assertEqual(eb.builddir, "%s.%d" % (builddir, i))
eb.make_builddir()
# cleanup
sys.stdout.close()
sys.stdout = stdoutorig
eb.close_log()
def test_gen_dirs(self):
"""Test methods that generate/set build/install directory names."""
self.contents = "\n".join(
[
"name = 'pi'",
"version = '3.14'",
"homepage = 'http://example.com'",
"description = 'test easyconfig'",
"toolchain = {'name': 'dummy', 'version': 'dummy'}",
]
)
self.writeEC()
stdoutorig = sys.stdout
sys.stdout = open("/dev/null", "w")
eb = EasyBlock(EasyConfig(self.eb_file))
resb = eb.gen_builddir()
resi = eb.gen_installdir()
eb.make_builddir()
eb.make_installdir()
# doesn't return anything
self.assertEqual(resb, None)
self.assertEqual(resi, None)
# directories are set, and exist
self.assertTrue(os.path.isdir(eb.builddir))
self.assertTrue(os.path.isdir(eb.installdir))
# make sure cleaning up old build dir is default
self.assertTrue(eb.cfg["cleanupoldbuild"] or eb.cfg.get("cleanupoldbuild", True))
builddir = eb.builddir
eb.gen_builddir()
self.assertEqual(builddir, eb.builddir)
eb.cfg["cleanupoldbuild"] = True
eb.gen_builddir()
self.assertEqual(builddir, eb.builddir)
# make sure build dir is unique
eb.cfg["cleanupoldbuild"] = False
builddir = eb.builddir
for i in range(3):
eb.gen_builddir()
self.assertEqual(eb.builddir, "%s.%d" % (builddir, i))
eb.make_builddir()
# cleanup
sys.stdout.close()
sys.stdout = stdoutorig
eb.close_log()
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 = """
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 = """
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_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_easyblock(self):
""" make sure easyconfigs defining extensions work"""
self.contents = """
name = "pi"
version = "3.14"
homepage = "http://google.com"
description = "test easyconfig"
toolchain = {"name":"dummy", "version": "dummy"}
exts_list = ['ext1']
"""
self.writeEC()
stdoutorig = sys.stdout
sys.stdout = open("/dev/null", 'w')
eb = EasyBlock(self.eb_file)
self.assertRaises(NotImplementedError, eb.run_all_steps, True, False)
sys.stdout.close()
sys.stdout = stdoutorig
# cleanup
eb.close_log()
os.remove(eb.logfile)
def test_easyblock(self):
""" make sure easyconfigs defining extensions work"""
self.contents = """
name = "pi"
version = "3.14"
homepage = "http://example.com"
description = "test easyconfig"
toolchain = {"name":"dummy", "version": "dummy"}
exts_list = ['ext1']
"""
self.writeEC()
stdoutorig = sys.stdout
sys.stdout = open("/dev/null", 'w')
eb = EasyBlock(self.eb_file)
self.assertRaises(NotImplementedError, eb.run_all_steps, True, False)
sys.stdout.close()
sys.stdout = stdoutorig
# cleanup
eb.close_log()
os.remove(eb.logfile)
def test_gen_dirs(self):
"""Test methods that generate/set build/install directory names."""
self.contents = '\n'.join([
"name = 'pi'",
"version = '3.14'",
"homepage = 'http://example.com'",
"description = 'test easyconfig'",
"toolchain = {'name': 'dummy', 'version': 'dummy'}",
])
self.writeEC()
stdoutorig = sys.stdout
sys.stdout = open("/dev/null", 'w')
eb = EasyBlock(self.eb_file)
resb = eb.gen_builddir()
eb.mod_name = det_full_module_name(eb.cfg) # required by gen_installdir()
resi = eb.gen_installdir()
eb.make_builddir()
eb.make_installdir()
# doesn't return anything
self.assertEqual(resb, None)
self.assertEqual(resi, None)
# directories are set, and exist
self.assertTrue(os.path.isdir(eb.builddir))
self.assertTrue(os.path.isdir(eb.installdir))
# make sure build dir is unique
builddir = eb.builddir
for i in range(0,3):
eb.gen_builddir()
self.assertEqual(eb.builddir, "%s.%d" % (builddir, i))
eb.make_builddir()
# cleanup
sys.stdout.close()
sys.stdout = stdoutorig
eb.close_log()
def test_easyblock(self):
""" make sure easyconfigs defining extensions work"""
def check_extra_options_format(extra_options):
"""Make sure extra_options value is of correct format."""
# EasyBuild v2.0: dict with <string> keys and <list> values
# (breaks backward compatibility compared to v1.x)
self.assertTrue(isinstance(extra_options, dict)) # conversion to a dict works
extra_options.items()
extra_options.keys()
extra_options.values()
for key in extra_options.keys():
self.assertTrue(isinstance(extra_options[key], list))
self.assertTrue(len(extra_options[key]), 3)
name = "pi"
version = "3.14"
self.contents = '\n'.join([
'easyblock = "ConfigureMake"',
'name = "%s"' % name,
'version = "%s"' % version,
'homepage = "http://example.com"',
'description = "test easyconfig"',
'toolchain = {"name":"dummy", "version": "dummy"}',
'exts_list = ["ext1"]',
])
self.writeEC()
stdoutorig = sys.stdout
sys.stdout = open("/dev/null", 'w')
ec = EasyConfig(self.eb_file)
eb = EasyBlock(ec)
self.assertEqual(eb.cfg['name'], name)
self.assertEqual(eb.cfg['version'], version)
self.assertRaises(NotImplementedError, eb.run_all_steps, True)
check_extra_options_format(eb.extra_options())
sys.stdout.close()
sys.stdout = stdoutorig
# check whether 'This is easyblock' log message is there
tup = ('EasyBlock', 'easybuild.framework.easyblock', '.*easybuild/framework/easyblock.pyc*')
eb_log_msg_re = re.compile(r"INFO This is easyblock %s from module %s (%s)" % tup, re.M)
logtxt = read_file(eb.logfile)
self.assertTrue(eb_log_msg_re.search(logtxt), "Pattern '%s' found in: %s" % (eb_log_msg_re.pattern, logtxt))
# test extensioneasyblock, as extension
exeb1 = ExtensionEasyBlock(eb, {'name': 'foo', 'version': '0.0'})
self.assertEqual(exeb1.cfg['name'], 'foo')
extra_options = exeb1.extra_options()
check_extra_options_format(extra_options)
self.assertTrue('options' in extra_options)
# test extensioneasyblock, as easyblock
exeb2 = ExtensionEasyBlock(ec)
self.assertEqual(exeb2.cfg['name'], 'pi')
self.assertEqual(exeb2.cfg['version'], '3.14')
extra_options = exeb2.extra_options()
check_extra_options_format(extra_options)
self.assertTrue('options' in extra_options)
class TestExtension(ExtensionEasyBlock):
@staticmethod
def extra_options():
return ExtensionEasyBlock.extra_options({'extra_param': [None, "help", CUSTOM]})
texeb = TestExtension(eb, {'name': 'bar'})
self.assertEqual(texeb.cfg['name'], 'bar')
extra_options = texeb.extra_options()
check_extra_options_format(extra_options)
self.assertTrue('options' in extra_options)
self.assertEqual(extra_options['extra_param'], [None, "help", CUSTOM])
# cleanup
eb.close_log()
os.remove(eb.logfile)
def test_easyblock(self):
""" make sure easyconfigs defining extensions work"""
def check_extra_options_format(extra_options):
"""Make sure extra_options value is of correct format."""
# EasyBuild v1.x: list of (<string>, <list>) tuples
self.assertTrue(isinstance(list(extra_options), list)) # conversion to a list works
for extra_option in extra_options:
self.assertTrue(isinstance(extra_option, tuple))
self.assertEqual(len(extra_option), 2)
self.assertTrue(isinstance(extra_option[0], basestring))
self.assertTrue(isinstance(extra_option[1], list))
self.assertEqual(len(extra_option[1]), 3)
# EasyBuild v2.0: dict with <string> keys and <list> values
# (breaks backward compatibility compared to v1.x)
self.assertTrue(isinstance(dict(extra_options), dict)) # conversion to a dict works
extra_options.items()
extra_options.keys()
extra_options.values()
for key in extra_options.keys():
self.assertTrue(isinstance(extra_options[key], list))
self.assertTrue(len(extra_options[key]), 3)
name = "pi"
version = "3.14"
self.contents = "\n".join(
[
'name = "%s"' % name,
'version = "%s"' % version,
'homepage = "http://example.com"',
'description = "test easyconfig"',
'toolchain = {"name":"dummy", "version": "dummy"}',
'exts_list = ["ext1"]',
]
)
self.writeEC()
stdoutorig = sys.stdout
sys.stdout = open("/dev/null", "w")
ec = EasyConfig(self.eb_file)
eb = EasyBlock(ec)
self.assertEqual(eb.cfg["name"], name)
self.assertEqual(eb.cfg["version"], version)
self.assertRaises(NotImplementedError, eb.run_all_steps, True)
check_extra_options_format(eb.extra_options())
sys.stdout.close()
sys.stdout = stdoutorig
# check whether 'This is easyblock' log message is there
tup = ("EasyBlock", "easybuild.framework.easyblock", ".*easybuild/framework/easyblock.pyc*")
eb_log_msg_re = re.compile(r"INFO This is easyblock %s from module %s (%s)" % tup, re.M)
logtxt = read_file(eb.logfile)
self.assertTrue(eb_log_msg_re.search(logtxt), "Pattern '%s' found in: %s" % (eb_log_msg_re.pattern, logtxt))
# test extensioneasyblock, as extension
exeb1 = ExtensionEasyBlock(eb, {"name": "foo", "version": "0.0"})
self.assertEqual(exeb1.cfg["name"], "foo")
extra_options = exeb1.extra_options()
check_extra_options_format(extra_options)
self.assertTrue("options" in [key for (key, _) in extra_options])
# test extensioneasyblock, as easyblock
exeb2 = ExtensionEasyBlock(ec)
self.assertEqual(exeb2.cfg["name"], "pi")
self.assertEqual(exeb2.cfg["version"], "3.14")
extra_options = exeb2.extra_options()
check_extra_options_format(extra_options)
self.assertTrue("options" in [key for (key, _) in extra_options])
class TestExtension(ExtensionEasyBlock):
@staticmethod
def extra_options():
return ExtensionEasyBlock.extra_options([("extra_param", [None, "help", CUSTOM])])
texeb = TestExtension(eb, {"name": "bar"})
self.assertEqual(texeb.cfg["name"], "bar")
extra_options = texeb.extra_options()
check_extra_options_format(extra_options)
self.assertTrue("options" in [key for (key, _) in extra_options])
self.assertEqual([val for (key, val) in extra_options if key == "extra_param"][0], [None, "help", CUSTOM])
# cleanup
eb.close_log()
os.remove(eb.logfile)
def test_easyblock(self):
""" make sure easyconfigs defining extensions work"""
def check_extra_options_format(extra_options):
"""Make sure extra_options value is of correct format."""
# EasyBuild v1.x
self.assertTrue(isinstance(extra_options, list))
for extra_option in extra_options:
self.assertTrue(isinstance(extra_option, tuple))
self.assertEqual(len(extra_option), 2)
self.assertTrue(isinstance(extra_option[0], basestring))
self.assertTrue(isinstance(extra_option[1], list))
self.assertEqual(len(extra_option[1]), 3)
# EasyBuild v2.0 (breaks backward compatibility compared to v1.x)
#self.assertTrue(isinstance(extra_options, dict))
#for key in extra_options:
# self.assertTrue(isinstance(extra_options[key], list))
# self.assertTrue(len(extra_options[key]), 3)
name = "pi"
version = "3.14"
self.contents = '\n'.join([
'name = "%s"' % name,
'version = "%s"' % version,
'homepage = "http://example.com"',
'description = "test easyconfig"',
'toolchain = {"name":"dummy", "version": "dummy"}',
'exts_list = ["ext1"]',
])
self.writeEC()
stdoutorig = sys.stdout
sys.stdout = open("/dev/null", 'w')
ec = EasyConfig(self.eb_file)
eb = EasyBlock(ec)
self.assertEqual(eb.cfg['name'], name)
self.assertEqual(eb.cfg['version'], version)
self.assertRaises(NotImplementedError, eb.run_all_steps, True)
check_extra_options_format(eb.extra_options())
sys.stdout.close()
sys.stdout = stdoutorig
# test extensioneasyblock, as extension
exeb1 = ExtensionEasyBlock(eb, {'name': 'foo', 'version': '0.0'})
self.assertEqual(exeb1.cfg['name'], 'foo')
extra_options = exeb1.extra_options()
check_extra_options_format(extra_options)
self.assertTrue('options' in [key for (key, _) in extra_options])
# test extensioneasyblock, as easyblock
exeb2 = ExtensionEasyBlock(ec)
self.assertEqual(exeb2.cfg['name'], 'pi')
self.assertEqual(exeb2.cfg['version'], '3.14')
extra_options = exeb2.extra_options()
check_extra_options_format(extra_options)
self.assertTrue('options' in [key for (key, _) in extra_options])
class TestExtension(ExtensionEasyBlock):
@staticmethod
def extra_options():
return ExtensionEasyBlock.extra_options([('extra_param', [None, "help", CUSTOM])])
texeb = TestExtension(eb, {'name': 'bar'})
self.assertEqual(texeb.cfg['name'], 'bar')
extra_options = texeb.extra_options()
check_extra_options_format(extra_options)
self.assertTrue('options' in [key for (key, _) in extra_options])
self.assertEqual([val for (key, val) in extra_options if key == 'extra_param'][0], [None, "help", CUSTOM])
# 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_easyblock(self):
""" make sure easyconfigs defining extensions work"""
def check_extra_options_format(extra_options):
"""Make sure extra_options value is of correct format."""
# EasyBuild v2.0: dict with <string> keys and <list> values
# (breaks backward compatibility compared to v1.x)
self.assertTrue(isinstance(extra_options,
dict)) # conversion to a dict works
extra_options.items()
extra_options.keys()
extra_options.values()
for key in extra_options.keys():
self.assertTrue(isinstance(extra_options[key], list))
self.assertTrue(len(extra_options[key]), 3)
name = "pi"
version = "3.14"
self.contents = '\n'.join([
'easyblock = "ConfigureMake"',
'name = "%s"' % name,
'version = "%s"' % version,
'homepage = "http://example.com"',
'description = "test easyconfig"',
'toolchain = {"name":"dummy", "version": "dummy"}',
'exts_list = ["ext1"]',
])
self.writeEC()
stdoutorig = sys.stdout
sys.stdout = open("/dev/null", 'w')
ec = EasyConfig(self.eb_file)
eb = EasyBlock(ec)
self.assertEqual(eb.cfg['name'], name)
self.assertEqual(eb.cfg['version'], version)
self.assertRaises(NotImplementedError, eb.run_all_steps, True)
check_extra_options_format(eb.extra_options())
sys.stdout.close()
sys.stdout = stdoutorig
# check whether 'This is easyblock' log message is there
tup = ('EasyBlock', 'easybuild.framework.easyblock',
'.*easybuild/framework/easyblock.pyc*')
eb_log_msg_re = re.compile(
r"INFO This is easyblock %s from module %s (%s)" % tup, re.M)
logtxt = read_file(eb.logfile)
self.assertTrue(
eb_log_msg_re.search(logtxt),
"Pattern '%s' found in: %s" % (eb_log_msg_re.pattern, logtxt))
# test extensioneasyblock, as extension
exeb1 = ExtensionEasyBlock(eb, {'name': 'foo', 'version': '0.0'})
self.assertEqual(exeb1.cfg['name'], 'foo')
extra_options = exeb1.extra_options()
check_extra_options_format(extra_options)
self.assertTrue('options' in extra_options)
# test extensioneasyblock, as easyblock
exeb2 = ExtensionEasyBlock(ec)
self.assertEqual(exeb2.cfg['name'], 'pi')
self.assertEqual(exeb2.cfg['version'], '3.14')
extra_options = exeb2.extra_options()
check_extra_options_format(extra_options)
self.assertTrue('options' in extra_options)
class TestExtension(ExtensionEasyBlock):
@staticmethod
def extra_options():
return ExtensionEasyBlock.extra_options(
{'extra_param': [None, "help", CUSTOM]})
texeb = TestExtension(eb, {'name': 'bar'})
self.assertEqual(texeb.cfg['name'], 'bar')
extra_options = texeb.extra_options()
check_extra_options_format(extra_options)
self.assertTrue('options' in extra_options)
self.assertEqual(extra_options['extra_param'], [None, "help", CUSTOM])
# 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_easyblock(self):
""" make sure easyconfigs defining extensions work"""
def check_extra_options_format(extra_options):
"""Make sure extra_options value is of correct format."""
# EasyBuild v1.x
self.assertTrue(isinstance(extra_options, list))
for extra_option in extra_options:
self.assertTrue(isinstance(extra_option, tuple))
self.assertEqual(len(extra_option), 2)
self.assertTrue(isinstance(extra_option[0], basestring))
self.assertTrue(isinstance(extra_option[1], list))
self.assertEqual(len(extra_option[1]), 3)
# EasyBuild v2.0 (breaks backward compatibility compared to v1.x)
#self.assertTrue(isinstance(extra_options, dict))
#for key in extra_options:
# self.assertTrue(isinstance(extra_options[key], list))
# self.assertTrue(len(extra_options[key]), 3)
name = "pi"
version = "3.14"
self.contents = '\n'.join([
'name = "%s"' % name,
'version = "%s"' % version,
'homepage = "http://example.com"',
'description = "test easyconfig"',
'toolchain = {"name":"dummy", "version": "dummy"}',
'exts_list = ["ext1"]',
])
self.writeEC()
stdoutorig = sys.stdout
sys.stdout = open("/dev/null", 'w')
ec = EasyConfig(self.eb_file)
eb = EasyBlock(ec)
self.assertEqual(eb.cfg['name'], name)
self.assertEqual(eb.cfg['version'], version)
self.assertRaises(NotImplementedError, eb.run_all_steps, True)
check_extra_options_format(eb.extra_options())
sys.stdout.close()
sys.stdout = stdoutorig
# test extensioneasyblock, as extension
exeb1 = ExtensionEasyBlock(eb, {'name': 'foo', 'version': '0.0'})
self.assertEqual(exeb1.cfg['name'], 'foo')
extra_options = exeb1.extra_options()
check_extra_options_format(extra_options)
self.assertTrue('options' in [key for (key, _) in extra_options])
# test extensioneasyblock, as easyblock
exeb2 = ExtensionEasyBlock(ec)
self.assertEqual(exeb2.cfg['name'], 'pi')
self.assertEqual(exeb2.cfg['version'], '3.14')
extra_options = exeb2.extra_options()
check_extra_options_format(extra_options)
self.assertTrue('options' in [key for (key, _) in extra_options])
class TestExtension(ExtensionEasyBlock):
@staticmethod
def extra_options():
return ExtensionEasyBlock.extra_options([('extra_param', [None, "help", CUSTOM])])
texeb = TestExtension(eb, {'name': 'bar'})
self.assertEqual(texeb.cfg['name'], 'bar')
extra_options = texeb.extra_options()
check_extra_options_format(extra_options)
self.assertTrue('options' in [key for (key, _) in extra_options])
self.assertEqual([val for (key, val) in extra_options if key == 'extra_param'][0], [None, "help", CUSTOM])
# cleanup
eb.close_log()
os.remove(eb.logfile)
