def test_refer_all(ns_cache: atom.Atom[NamespaceMap]): ns1 = get_or_create_ns(sym.symbol("ns1")) var_sym1, var_val1 = sym.symbol("useful-value"), "cool string" var1 = Var(ns1, var_sym1) var1.set_value(var_val1) ns1.intern(var_sym1, var1) var_sym2, var_val2 = sym.symbol("private-value"), "private string" var2 = Var(ns1, var_sym2, meta=lmap.map({kw.keyword("private"): True})) var2.set_value(var_val2) ns1.intern(var_sym2, var2) var_sym3, var_val3 = sym.symbol("existing-value"), "interned string" var3 = Var(ns1, var_sym3) var3.set_value(var_val3) ns1.intern(var_sym3, var3) ns2 = get_or_create_ns(sym.symbol("ns2")) var_val4 = "some other value" var4 = Var(ns2, var_sym3) var4.set_value(var_val4) ns2.intern(var_sym3, var4) ns2.refer_all(ns1) assert var1 is ns2.get_refer(var_sym1) assert var1 is ns2.find(var_sym1) assert var_val1 == ns2.find(var_sym1).value assert None is ns2.get_refer(var_sym2) assert None is ns2.find(var_sym2) assert var3 is ns2.get_refer(var_sym3) assert var4 is ns2.find(var_sym3) assert var_val4 == ns2.find(var_sym3).value
def test_demunged_import(testdir: Testdir): with TemporaryDirectory() as tmpdir: tmp_module = os.path.join( tmpdir, "long__AMP__namespace_name__PLUS__with___LT__punctuation__GT__.lpy" ) with open(tmp_module, mode="w") as module: code = """ (ns long&namespace-name+with-<punctuation>) """ module.write(code) with runtime.remove_ns_bindings(): with patch("sys.path", new=[tmpdir]), patch("sys.meta_path", new=[importer.BasilispImporter()]): importlib.import_module( "long__AMP__namespace_name__PLUS__with___LT__punctuation__GT__" ) assert (runtime.Namespace.get( sym.symbol("long&namespace-name+with-<punctuation>")) is not None) assert (runtime.Namespace.get( sym.symbol( "long__AMP__namespace_name__PLUS__with___LT__punctuation__GT__" )) is None)
def test_symbol_name_and_ns(): sym = symbol("sym", ns="ns") assert sym.name == "sym" assert sym.ns == "ns" sym = symbol("sym") assert sym.name == "sym" assert sym.ns is None
def test_alter_atom_meta(): a = atom.Atom(None) assert a.meta is None a.alter_meta(runtime.assoc, "type", sym.symbol("str")) assert a.meta == lmap.m(type=sym.symbol("str")) a.alter_meta(runtime.assoc, "tag", kw.keyword("async")) assert a.meta == lmap.m(type=sym.symbol("str"), tag=kw.keyword("async"))
def test_reset_atom_meta(): a = atom.Atom(None) assert a.meta is None a.reset_meta(lmap.map({"type": sym.symbol("str")})) assert a.meta == lmap.m(type=sym.symbol("str")) a.reset_meta(lmap.m(tag=kw.keyword("async"))) assert a.meta == lmap.m(tag=kw.keyword("async"))
def test_literal_to_lisp(self): assert None is runtime.to_lisp(None) assert 1 == runtime.to_lisp(1) assert 1.6 == runtime.to_lisp(1.6) assert "string" == runtime.to_lisp("string") assert sym.symbol("sym") == runtime.to_lisp(sym.symbol("sym")) assert sym.symbol("sym", ns="ns") == runtime.to_lisp(sym.symbol("sym", ns="ns")) assert kw.keyword("kw") == runtime.to_lisp(kw.keyword("kw")) assert kw.keyword("kw", ns="ns") == runtime.to_lisp(kw.keyword("kw", ns="ns"))
def test_find_safe( ns_sym: sym.Symbol, var_name: sym.Symbol, intern_val, ): v = Var.intern(ns_sym, var_name, intern_val) ns_qualified_sym = sym.symbol(var_name.name, ns=ns_sym.name) v_in_ns = Var.find_safe(ns_qualified_sym) assert v == v_in_ns with pytest.raises(RuntimeException): Var.find_safe(sym.symbol("some-other-var", ns="doesnt.matter"))
def test_reset_ns_meta( ns_cache: atom.Atom[NamespaceMap], ns_sym: sym.Symbol, ): ns = get_or_create_ns(ns_sym) assert ns.meta is None ns.reset_meta(lmap.map({"type": sym.symbol("str")})) assert ns.meta == lmap.m(type=sym.symbol("str")) ns.reset_meta(lmap.m(tag=kw.keyword("async"))) assert ns.meta == lmap.m(tag=kw.keyword("async"))
def test_alter_ns_meta( ns_cache: atom.Atom[NamespaceMap], ns_sym: sym.Symbol, ): ns = get_or_create_ns(ns_sym) assert ns.meta is None ns.alter_meta(runtime.assoc, "type", sym.symbol("str")) assert ns.meta == lmap.m(type=sym.symbol("str")) ns.alter_meta(runtime.assoc, "tag", kw.keyword("async")) assert ns.meta == lmap.m(type=sym.symbol("str"), tag=kw.keyword("async"))
def test_cannot_refer_private(ns_cache: atom.Atom[NamespaceMap]): ns1 = get_or_create_ns(sym.symbol("ns1")) var_sym, var_val = sym.symbol("useful-value"), "cool string" var = Var(ns1, var_sym, meta=lmap.map({kw.keyword("private"): True})) var.set_value(var_val) ns1.intern(var_sym, var) ns2 = get_or_create_ns(sym.symbol("ns2")) ns2.add_refer(var_sym, var) assert None is ns2.get_refer(var_sym) assert None is ns2.find(var_sym)
def test_refer(ns_cache: atom.Atom[NamespaceMap]): ns1 = get_or_create_ns(sym.symbol("ns1")) var_sym, var_val = sym.symbol("useful-value"), "cool string" var = Var(ns1, var_sym) var.set_value(var_val) ns1.intern(var_sym, var) ns2 = get_or_create_ns(sym.symbol("ns2")) ns2.add_refer(var_sym, var) assert var is ns2.get_refer(var_sym) assert var_val == ns2.find(var_sym).value
def test_import_module_without_init(self, make_new_module, load_namespace): """Load a Basilisp namespace and a Basilisp child namespace in the typical Clojure fashion.""" make_new_module("core.lpy", ns_name="core") make_new_module("core", "child.lpy", ns_name="core.child") core = load_namespace("core") core_child = load_namespace("core.child") assert "core" == core.find(sym.symbol("val")).value assert "core.child" == core_child.find(sym.symbol("val")).value
def test_import_basilisp_child_with_basilisp_init( self, make_new_module, load_namespace): """Load a Basilisp package namespace setup as a Python package and a child Basilisp namespace of that package.""" make_new_module("core", "__init__.lpy", ns_name="core") make_new_module("core", "sub.lpy", ns_name="core.sub") core = load_namespace("core") core_sub = load_namespace("core.sub") assert "core" == core.find(sym.symbol("val")).value assert "core.sub" == core_sub.find(sym.symbol("val")).value
def test_symbol_str_and_repr(): sym = symbol("sym", ns="ns") assert str(sym) == "ns/sym" assert repr(sym) == "ns/sym" sym = symbol("sym", ns="some.ns") assert str(sym) == "some.ns/sym" assert repr(sym) == "some.ns/sym" sym = symbol("sym") assert str(sym) == "sym" assert repr(sym) == "sym"
def test_alter_var_meta( ns_sym: sym.Symbol, var_name: sym.Symbol, intern_val, ): v = Var.intern(ns_sym, var_name, intern_val) assert v.meta is None v.alter_meta(assoc, "type", sym.symbol("str")) assert v.meta == lmap.m(type=sym.symbol("str")) v.alter_meta(assoc, "tag", kw.keyword("async")) assert v.meta == lmap.m(type=sym.symbol("str"), tag=kw.keyword("async"))
def test_reset_var_meta( ns_sym: sym.Symbol, var_name: sym.Symbol, intern_val, ): v = Var.intern(ns_sym, var_name, intern_val) assert v.meta is None v.reset_meta(lmap.map({"type": sym.symbol("str")})) assert v.meta == lmap.m(type=sym.symbol("str")) v.reset_meta(lmap.m(tag=kw.keyword("async"))) assert v.meta == lmap.m(tag=kw.keyword("async"))
def test_unmap(ns_cache: atom.Atom[NamespaceMap]): ns = get_or_create_ns(sym.symbol("ns1")) var_sym = sym.symbol("useful-value") var_val = "cool string" var = Var(ns, var_sym) var.set_value(var_val) ns.intern(var_sym, var) assert var is ns.find(var_sym) assert var_val == ns.find(var_sym).value ns.unmap(var_sym) assert None is ns.find(var_sym)
def test_import_module_with_namespace_only_pkg(self, make_new_module, load_namespace): """Load a Basilisp namespace and another Basilisp namespace using a Python namespace package.""" make_new_module("core.lpy", ns_name="core") make_new_module("core", "nested", "child.lpy", ns_name="core.nested.child") core = load_namespace("core") core_nested_child = load_namespace("core.nested.child") assert "core" == core.find(sym.symbol("val")).value assert ("core.nested.child" == core_nested_child.find( sym.symbol("val")).value)
def run_result(self, pytester: Pytester) -> RunResult: code = """ (ns test-testrunner (:require [basilisp.test :refer [deftest is are testing]])) (deftest assertion-test (testing "is assertions" (is true) (is false) (is (= "string" "string")) (is (thrown? basilisp.lang.exception/ExceptionInfo (throw (ex-info "Exception" {})))) (is (thrown? basilisp.lang.exception/ExceptionInfo (throw (python/Exception)))) (is (throw (ex-info "Uncaught exception" {})))) (testing "are assertions" (are [exp actual] (= exp actual) 1 1 :hi :hi "true" false 4.6 4.6))) (deftest passing-test (is true)) (deftest error-test (throw (ex-info "This test will count as an error." {}))) """ pytester.makefile(".lpy", test_testrunner=code) yield pytester.runpytest() runtime.Namespace.remove(sym.symbol("test-testrunner"))
def test_imports(ns_cache: atom.Atom[NamespaceMap]): ns = get_or_create_ns(sym.symbol("ns1")) time = __import__("time") ns.add_import(sym.symbol("time"), time, sym.symbol("py-time"), sym.symbol("py-tm")) assert time == ns.get_import(sym.symbol("time")) assert time == ns.get_import(sym.symbol("py-time")) assert time == ns.get_import(sym.symbol("py-tm")) assert None is ns.get_import(sym.symbol("python-time"))
def bootstrap_repl(ctx: compiler.CompilerContext, which_ns: str) -> types.ModuleType: """Bootstrap the REPL with a few useful vars and returned the bootstrapped module so it's functions can be used by the REPL command.""" ns = runtime.Namespace.get_or_create(sym.symbol(which_ns)) eval_str(f"(ns {sym.symbol(which_ns)} (:use basilisp.repl))", ctx, ns, object()) return importlib.import_module(REPL_NS)
def test_import_module_with_non_code_child(self, make_new_module, load_namespace): make_new_module("core.lpy", ns_name="core") make_new_module("core", "resource.txt", module_text="{}") core = load_namespace("core") assert "core" == core.find(sym.symbol("val")).value
def test_find( ns_sym: sym.Symbol, var_name: sym.Symbol, intern_val, ): v = Var.intern(ns_sym, var_name, intern_val) ns_qualified_sym = sym.symbol(var_name.name, ns=ns_sym.name) v_in_ns = Var.find(ns_qualified_sym) assert v == v_in_ns
def test_refer_does_not_shadow_intern(ns_cache: atom.Atom[NamespaceMap]): ns1 = get_or_create_ns(sym.symbol("ns1")) var_sym = sym.symbol("useful-value") var_val1 = "cool string" var1 = Var(ns1, var_sym) var1.set_value(var_val1) ns1.intern(var_sym, var1) ns2 = get_or_create_ns(sym.symbol("ns2")) var_val2 = "lame string" var2 = Var(ns1, var_sym) var2.set_value(var_val2) ns2.intern(var_sym, var2) ns2.add_refer(var_sym, var1) assert var1 is ns2.get_refer(var_sym) assert var_val2 == ns2.find(var_sym).value
def test_symbol_with_meta(): sym = symbol("sym") assert sym.meta is None meta1 = lmap.m(type=symbol("str")) sym1 = symbol("sym", meta=meta1) assert sym1.meta == meta1 meta2 = lmap.m(tag=keyword("async")) sym2 = sym1.with_meta(meta2) assert sym1 is not sym2 assert sym1 == sym2 assert sym2.meta == lmap.m(tag=keyword("async")) meta3 = lmap.m(tag=keyword("macro")) sym3 = sym2.with_meta(meta3) assert sym2 is not sym3 assert sym2 == sym3 assert sym3.meta == lmap.m(tag=keyword("macro"))
def test_import_module_with_invalid_cache_magic_number( self, module_dir, cached_module_ns, cached_module_file, load_namespace): cache_filename = importer._cache_from_source( os.path.join(module_dir, cached_module_file)) with open(cache_filename, mode="r+b") as f: f.seek(0) f.write(b"1999") using_cache = load_namespace(cached_module_ns) assert cached_module_ns == using_cache.find(sym.symbol("val")).value
def test_multi_function(): def dispatch(v) -> kw.Keyword: if v == "i": return kw.keyword("a") elif v == "ii": return kw.keyword("b") return kw.keyword("default") def fn_a(v) -> str: return "1" def fn_b(v) -> str: return "2" def fn_default(v) -> str: return "BLAH" f = multifn.MultiFunction(sym.symbol("test-fn"), dispatch, kw.keyword("default")) f.add_method(kw.keyword("a"), fn_a) f.add_method(kw.keyword("b"), fn_b) f.add_method(kw.keyword("default"), fn_default) assert (lmap.map({ kw.keyword("a"): fn_a, kw.keyword("b"): fn_b, kw.keyword("default"): fn_default, }) == f.methods) assert kw.keyword("default") == f.default assert fn_a is f.get_method(kw.keyword("a")) assert fn_b is f.get_method(kw.keyword("b")) assert fn_default is f.get_method(kw.keyword("default")) assert fn_default is f.get_method(kw.keyword("other")) assert "1" == f("i") assert "2" == f("ii") assert "BLAH" == f("iii") assert "BLAH" == f("whatever") f.remove_method(kw.keyword("b")) assert "1" == f("i") assert "BLAH" == f("ii") assert "BLAH" == f("iii") assert "BLAH" == f("whatever") f.remove_all_methods() assert lmap.PersistentMap.empty() == f.methods with pytest.raises(NotImplementedError): f("blah")
def test_import_basilisp_and_python_module_siblings( self, make_new_module, load_namespace): """Load a Python module and Basilisp namespace which are siblings.""" make_new_module("core.lpy", ns_name="core") make_new_module("main.py", module_text="""val = __name__""") core = load_namespace("core") pymain = importlib.import_module("main") assert "core" == core.find(sym.symbol("val")).value assert "main" == pymain.val
def test_import_module_with_truncated_timestamp(self, module_dir, cached_module_ns, cached_module_file, load_namespace): cache_filename = importer._cache_from_source( os.path.join(module_dir, cached_module_file)) with open(cache_filename, mode="w+b") as f: f.write(importer.MAGIC_NUMBER) f.write(b"abc") using_cache = load_namespace(cached_module_ns) assert cached_module_ns == using_cache.find(sym.symbol("val")).value
def test_import_module_with_invalid_rawsize(self, module_dir, cached_module_ns, cached_module_file, load_namespace): cache_filename = importer._cache_from_source( os.path.join(module_dir, cached_module_file)) with open(cache_filename, mode="r+b") as f: f.seek(8) f.write(importer._w_long(7733)) using_cache = load_namespace(cached_module_ns) assert cached_module_ns == using_cache.find(sym.symbol("val")).value