def test_command_avail(tmpdir, mock_modulepath): load = PymodCommand("load") avail = PymodCommand("avail") save = PymodCommand("save") # Build modules one = tmpdir.mkdir("1") one.join("a.py").write('setenv("a", "a")\n') one.join("b.py").write('setenv("b", "b")\nload("c")') one.join("c.py").write('setenv("c", "c")\nload("d")') one.join("d.py").write('setenv("d", "d")\nload("e")') one.join("e.py").write('setenv("e", "e")\n') two = tmpdir.mkdir("2") two.join("a.py").write('setenv("a", "a")\n') two.join("b.py").write('setenv("b", "b")\nload_first("c", "e", "d")') two.join("d.py").write('setenv("d", "c")\nadd_option("x")') two.join("g.py").write('setenv("g", "d")\nload_first("x", "y", "z", None)') mock_modulepath([one.strpath, two.strpath]) load("a") load("b") load("c") load("d", "x=foo") save("foo") avail() avail("-t") avail("--terse") avail("a") # regular expression avail("--terse", "a") # regular expression avail("-a") avail("--terse", "-a") avail("--terse", "-a", "a")
def test_command_path(modules_path, mock_modulepath): load = PymodCommand("load") path = PymodCommand("path") mock_modulepath([modules_path.one, modules_path.two]) load("a") load("b") path()
def test_command_load_3(modules_path, mock_modulepath): """Load a and b, b loads d. Then, unload b (d should also unload)""" load = PymodCommand("load") unload = PymodCommand("unload") mock_modulepath(modules_path.two) load("a") assert pymod.environ.get("a") == "a" load("b") for x in "ced": if x in "ce": assert pymod.environ.get(x) is None assert not pymod.mc.module_is_loaded(x) else: assert pymod.environ.get(x) == x assert pymod.mc.module_is_loaded(x) # unload b, e will also unload unload("b") assert pymod.environ.get("b") is None assert pymod.environ.get("c") is None assert pymod.environ.get("d") is None assert pymod.environ.get("e") is None assert pymod.environ.get("a") == "a" unload("a") assert pymod.environ.get("a") is None
def test_command_load_collection(tmpdir, mock_modulepath): save = PymodCommand("save") load = PymodCommand("load") purge = PymodCommand("purge") restore = PymodCommand("restore") tmpdir.join("a.py").write("") tmpdir.join("b.py").write("") tmpdir.join("c.py").write("") tmpdir.join("d.py").write("") mock_modulepath(tmpdir.strpath) a = load("a") b = load("b") c = load("c") d = load("d") save("foo") purge() restore("foo") for x in "abcd": m = pymod.modulepath.get(x) assert m.is_loaded purge() for x in "abcd": m = pymod.modulepath.get(x) assert not m.is_loaded load("foo") for x in "abcd": m = pymod.modulepath.get(x) assert m.is_loaded
def test_command_save(modules_path, mock_modulepath): mock_modulepath(modules_path.path) save = PymodCommand("save") restore = PymodCommand("restore") a = pymod.mc.load("a") b = pymod.mc.load("b") c = pymod.mc.load("c") d = pymod.mc.load("d") save("foo") pymod.mc.purge() assert not a.is_loaded assert not b.is_loaded assert not c.is_loaded assert not d.is_loaded b2 = pymod.mc.load("b2") restore("foo") assert a.is_loaded assert b.is_loaded assert c.is_loaded assert d.is_loaded assert not b2.is_loaded cat = PymodCommand("cat") cat("foo")
def test_command_load_2(modules_path, mock_modulepath): """Load a and b, b loads c, d, e. Then, unload b (c, d, e should also unload) """ load = PymodCommand("load") unload = PymodCommand("unload") mock_modulepath(modules_path.one) load("a") assert pymod.environ.get("a") == "a" load("b") for x in "bcde": assert pymod.environ.get(x) == x assert pymod.mc.module_is_loaded(x) # just unload e unload("d") assert pymod.environ.get("d") is None assert pymod.environ.get("e") is None # unload b, c and d also unload unload("b") assert pymod.environ.get("b") is None assert pymod.environ.get("c") is None assert pymod.environ.get("d") is None assert pymod.environ.get("a") == "a" unload("a") assert pymod.environ.get("a") is None
def test_command_refresh(modules_path, mock_modulepath): load = PymodCommand("load") refresh = PymodCommand("refresh") mock_modulepath(modules_path.one) load("a", "b", "c", "d") refresh() loaded = "".join(_.fullname for _ in pymod.mc.get_loaded_modules()) assert loaded == "abcd"
def test_command_load_1(modules_path, mock_modulepath): load = PymodCommand("load") unload = PymodCommand("unload") mock_modulepath(modules_path.one) load("a") assert pymod.environ.get("a") == "a" unload("a") assert pymod.environ.get("a") is None
def test_command_swap(modules_path, mock_modulepath): load = PymodCommand("load") swap = PymodCommand("swap") mock_modulepath(modules_path.one) load("a") loaded = "".join(_.fullname for _ in pymod.mc.get_loaded_modules()) assert loaded == "a" swap("a", "b") loaded = "".join(_.fullname for _ in pymod.mc.get_loaded_modules()) assert loaded == "b"
def test_command_unload_1(modules_path, mock_modulepath): load = PymodCommand("load") unload = PymodCommand("unload") mock_modulepath(modules_path.path) load("a") a = pymod.modulepath.get("a") assert pymod.environ.get("a") == "a" assert a.is_loaded pymod.mc.unload("a") assert pymod.environ.get("a") is None assert not a.is_loaded
def test_command_reload_1(modules_path, mock_modulepath): load = PymodCommand("load") reload = PymodCommand("reload") mock_modulepath(modules_path.path) load("a") assert pymod.environ.get("a") == "a" reload("a") assert pymod.environ.get("a") == "a" # Reference count should not change a = pymod.modulepath.get("a") assert a.refcount == 1
def test_command_list(tmpdir, mock_modulepath): tmpdir.join("a.py").write("") tmpdir.join("b.py").write('add_option("x")') tmpdir.join("c.py").write("") load = PymodCommand("load") list = PymodCommand("list") mock_modulepath(tmpdir.strpath) list() load("a") load("b", "x=foo") load("c") list() list("a") # regular expression list("-c") list("-t")
def test_command_remove(modules_path, mock_modulepath): mock_modulepath(modules_path.path) save = PymodCommand("save") remove = PymodCommand("remove") a = pymod.mc.load("a") b = pymod.mc.load("b") c = pymod.mc.load("c") d = pymod.mc.load("d") save("foo") assert pymod.collection.contains("foo") remove("foo") assert not pymod.collection.contains("foo")
def test_command_clone2(modules_path, mock_modulepath): mock_modulepath(modules_path.path) clone = PymodCommand("clone") a = pymod.mc.load("a") b = pymod.mc.load("b") c = pymod.mc.load("c") d = pymod.mc.load("d") clone("save", "foo") pymod.mc.purge() assert not a.is_loaded assert not b.is_loaded assert not c.is_loaded assert not d.is_loaded clone("restore", "foo") for x in "abcd": m = pymod.modulepath.get(x) assert m.is_loaded clone("avail") clone("avail", "-t") clone("avail", "--terse")
def test_command_find(tmpdir, mock_modulepath): tmpdir.join("a.py").write("") find = PymodCommand("find") mock_modulepath(tmpdir.strpath) find("a") with pytest.raises(pymod.error.ModuleNotFoundError): find("b")
def test_command_cache(tmpdir, mock_modulepath): tmpdir.join("a.py").write("") mock_modulepath(tmpdir.strpath) cache = PymodCommand("cache") cache("build") cache("rebuild") cache("remove")
def test_command_cat(modules_path, mock_modulepath): cat = PymodCommand("cat") mock_modulepath(modules_path.one) cat("a") with pytest.raises(Exception): cat("fake")
def test_command_info(tmpdir, mock_modulepath): tmpdir.join("a.py").write("") info = PymodCommand("info") mock_modulepath(tmpdir.strpath) info("a") with pytest.raises(pymod.error.ModuleNotFoundError): info("b")
def test_command_unuse(modules_path, mock_modulepath): unuse = PymodCommand("unuse") load = PymodCommand("load") mock_modulepath([modules_path.one, modules_path.two]) a = pymod.mc.load("a") b = pymod.mc.load("b") unuse(modules_path.one) c = pymod.mc.load("c") d = pymod.mc.load("d") unuse(modules_path.two) loaded = pymod.mc.get_loaded_modules() assert len(loaded) == 0 assert pymod.modulepath.size() == 0
def test_command_purge(modules_path, mock_modulepath): """Load a and b, b loads c, d, e. Then, unload b (c, d, e should also unload) """ load = PymodCommand("load") purge = PymodCommand("purge") mock_modulepath(modules_path.one) load("a") assert pymod.environ.get("a") == "a" load("b") for x in "bcde": assert pymod.environ.get(x) == x assert pymod.mc.module_is_loaded(x) purge() loaded = pymod.mc.get_loaded_modules() assert len(loaded) == 0
def test_command_whatis(tmpdir, modulecmds, mock_modulepath): m = modulecmds tmpdir.join("a.py").write(m.whatis("WHATIS A")) mock_modulepath(tmpdir.strpath) whatis = PymodCommand("whatis") whatis("a") with pytest.raises(ModuleNotFoundError): whatis("b")
def test_command_unload_3(modules_path, mock_modulepath): load = PymodCommand("load") unload = PymodCommand("unload") mock_modulepath(modules_path.path) load("a") load("a1") load("a2") assert pymod.environ.get("a") == "a" assert pymod.environ.get("a1") == "a1" assert pymod.environ.get("a2") == "a2" # a was "loaded" 3 times, loading b causes the unload("a2") a = pymod.modulepath.get("a") assert a.is_loaded unload("a1") assert a.is_loaded unload("a") assert not a.is_loaded
def test_command_show(tmpdir, mock_modulepath): tmpdir.join("a.py").write('append_path("FOO", "/a/b/c", sep=";")') show = PymodCommand("show") mock_modulepath(tmpdir.strpath) show("a", "+x") with pytest.raises(ModuleNotFoundError): show("fake") with pytest.raises(ValueError): # need module for options show("+x")
def test_command_hierarchy_1(modules_path, mock_modulepath): """Loop through the module hierarchy to make sure it is laid out correctly""" load = PymodCommand("load") core_path = modules_path.core mock_modulepath(modules_path.core) is_module = lambda x: pymod.modulepath.get(x) is not None for compiler_ver in compiler_versions: compiler_module_name = os.path.sep.join((compiler_vendor, compiler_ver)) load(compiler_module_name) compiler = pymod.modulepath.get(compiler_module_name) assert compiler is not None compiler_unlocks_dir = os.path.normpath( os.path.join(core_path, "..", "compiler", compiler_vendor, compiler_ver) ) assert os.path.isdir(compiler_unlocks_dir) assert pymod.modulepath.contains(compiler_unlocks_dir) a = pymod.modulepath.get("a") assert a is not None assert a.version.string == "1.0" assert a.filename == os.path.join( compiler_unlocks_dir, a.name, a.version.string + ".py" ) for mpi_ver in mpi_versions: mpi_module_name = os.path.sep.join((mpi_vendor, mpi_ver)) load(mpi_module_name) mpi = pymod.modulepath.get(mpi_module_name) assert mpi is not None mpi_unlocks_dir = os.path.normpath( os.path.join( core_path, "..", "mpi", compiler_vendor, compiler_ver, mpi_vendor, mpi_ver, ) ) assert os.path.isdir(mpi_unlocks_dir) assert pymod.modulepath.contains(mpi_unlocks_dir) load("b") return
def test_command_alias(tmpdir, mock_modulepath): a = tmpdir.join("a.py").write("") mock_modulepath(tmpdir.strpath) alias = PymodCommand("alias") alias("save", "a", "a-alias") a = pymod.mc.load("a-alias") aa = pymod.modulepath.get("a") assert a.filename == aa.filename alias("avail") alias("remove", "a-alias") assert pymod.alias.get("a-alias") is None with pytest.raises(ModuleNotFoundError): alias("save", "b", "b-alias")
def test_command_hierarchy_2(modules_path, mock_modulepath): """Tests the basic functionality of module hierarchy. Steps: - Load a compiler. The compiler unlocks compiler dependent modules - Load a compiler dependent module. - Load an mpi implementation. The mpi implementation unlocks mpi implementation dependent modules - Load an mpi implementation dependent module Now is the fun part - Load a different compiler. The compiler dependent and mpi dependent modules will all be updated accordingly """ load = PymodCommand("load") core_path = modules_path.core mock_modulepath(modules_path.core) _compiler_unlocks_dir = lambda cc, cv: os.path.normpath( os.path.join(core_path, "..", "compiler", cc, cv) ) _mpi_unlocks_dir = lambda cc, cv, mpi, mpiv: os.path.normpath( os.path.join(core_path, "..", "mpi", cc, cv, mpi, mpiv) ) compiler_ver = compiler_versions[0] compiler_module_name = os.path.sep.join((compiler_vendor, compiler_ver)) load(compiler_module_name) compiler = pymod.modulepath.get(compiler_module_name) assert compiler is not None compiler_unlocks_dir = _compiler_unlocks_dir(compiler_vendor, compiler_ver) assert os.path.isdir(compiler_unlocks_dir) assert pymod.modulepath.contains(compiler_unlocks_dir) a = pymod.modulepath.get("a") assert a is not None assert a.version.string == "1.0" assert a.filename == os.path.join( compiler_unlocks_dir, a.name, a.version.string + ".py" ) mpi_ver = mpi_versions[0] mpi_module_name = os.path.sep.join((mpi_vendor, mpi_ver)) load(mpi_module_name) mpi = pymod.modulepath.get(mpi_module_name) assert mpi is not None mpi_unlocks_dir = _mpi_unlocks_dir( compiler_vendor, compiler_ver, mpi_vendor, mpi_ver ) assert os.path.isdir(mpi_unlocks_dir) assert pymod.modulepath.contains(mpi_unlocks_dir) b = load("b") b = pymod.modulepath.get("b") assert b.filename == os.path.join(mpi_unlocks_dir, b.name, b.version.string + ".py") # Now, load a different compiler and a, mpi, and b modules will all be # updated automatically compiler_ver = compiler_versions[1] compiler_module_name = os.path.sep.join((compiler_vendor, compiler_ver)) load(compiler_module_name) compiler = pymod.modulepath.get(compiler_module_name) assert compiler is not None compiler_unlocks_dir = _compiler_unlocks_dir(compiler_vendor, compiler_ver) assert os.path.isdir(compiler_unlocks_dir) assert pymod.modulepath.contains(compiler_unlocks_dir) a = pymod.modulepath.get("a") assert a.filename == os.path.join( compiler_unlocks_dir, a.name, a.version.string + ".py" ) mpi = pymod.modulepath.get(mpi_module_name) assert mpi is not None mpi_unlocks_dir = _mpi_unlocks_dir( compiler_vendor, compiler_ver, mpi_vendor, mpi_ver ) assert os.path.isdir(mpi_unlocks_dir) assert pymod.modulepath.contains(mpi_unlocks_dir) b = pymod.modulepath.get("b") assert b.filename == os.path.join(mpi_unlocks_dir, b.name, b.version.string + ".py") return
def test_command_tutorial(): tutorial = PymodCommand("tutorial") tutorial("basic") tutorial("teardown")
def test_command_restore_clone_bad(modules_path, mock_modulepath): clone = PymodCommand("clone") with pytest.raises(CloneDoesNotExistError): clone("restore", "fake")
def test_command_commands_rst(): commands = PymodCommand("commands") commands("--format=rst")
def test_command_commands_default(): commands = PymodCommand("commands") commands()