Update Luau require tests

Author: khvzak

tests/luau/require.rs

@@ -1,7 +1,7 @@
 use std::io::Result as IoResult;
 use std::result::Result as StdResult;
 
-use mlua::{Error, IntoLua, Lua, MultiValue, NavigateError, Require, Result, TextRequirer, Value};
+use mlua::{Error, FromLua, IntoLua, Lua, MultiValue, NavigateError, Require, Result, TextRequirer, Value};
 
 fn run_require(lua: &Lua, path: impl IntoLua) -> Result<Value> {
     lua.load(r#"return require(...)"#).call(path)
@@ -11,9 +11,14 @@ fn run_require_pcall(lua: &Lua, path: impl IntoLua) -> Result<MultiValue> {
     lua.load(r#"return pcall(require, ...)"#).call(path)
 }
 
+#[track_caller]
+fn get_value<V: FromLua>(value: &Value, key: impl IntoLua) -> V {
+    value.as_table().unwrap().get(key).unwrap()
+}
+
 #[track_caller]
 fn get_str(value: &Value, key: impl IntoLua) -> String {
-    value.as_table().unwrap().get::<String>(key).unwrap()
+    get_value(value, key)
 }
 
 #[test]
@@ -47,6 +52,16 @@ fn test_require_errors() {
     assert!(res.is_err());
     assert!((res.unwrap_err().to_string()).contains("require is not supported in this context"));
 
+    // RequireAliasThatDoesNotExist
+    let res = run_require(&lua, "@this.alias.does.not.exist");
+    assert!(res.is_err());
+    assert!((res.unwrap_err().to_string()).contains("@this.alias.does.not.exist is not a valid alias"));
+
+    // IllegalAlias
+    let res = run_require(&lua, "@");
+    assert!(res.is_err());
+    assert!((res.unwrap_err().to_string()).contains("@ is not a valid alias"));
+
     // Test throwing mlua::Error
     struct MyRequire(TextRequirer);
 
@@ -171,40 +186,64 @@ fn test_require_without_config() {
     assert!(res.is_table());
 }
 
-#[test]
-fn test_require_with_config() {
+fn test_require_with_config_inner(r#type: &str) {
     let lua = Lua::new();
 
+    let base_path = format!("./tests/luau/require/{type}");
+
     // RequirePathWithAlias
-    let res = run_require(&lua, "./tests/luau/require/with_config/src/alias_requirer").unwrap();
+    let res = run_require(&lua, format!("{base_path}/src/alias_requirer")).unwrap();
     assert_eq!("result from dependency", get_str(&res, 1));
 
     // RequirePathWithAlias (case-insensitive)
-    let res2 = run_require(&lua, "./tests/luau/require/with_config/src/alias_requirer_uc").unwrap();
+    let res2 = run_require(&lua, format!("{base_path}/src/alias_requirer_uc")).unwrap();
     assert_eq!("result from dependency", get_str(&res2, 1));
     assert_eq!(res.to_pointer(), res2.to_pointer());
 
     // RequirePathWithParentAlias
-    let res = run_require(&lua, "./tests/luau/require/with_config/src/parent_alias_requirer").unwrap();
+    let res = run_require(&lua, format!("{base_path}/src/parent_alias_requirer")).unwrap();
     assert_eq!("result from other_dependency", get_str(&res, 1));
 
     // RequirePathWithAliasPointingToDirectory
+    let res = run_require(&lua, format!("{base_path}/src/directory_alias_requirer")).unwrap();
+    assert_eq!("result from subdirectory_dependency", get_str(&res, 1));
+
+    // RequireChainedAliasesSuccess
     let res = run_require(
         &lua,
-        "./tests/luau/require/with_config/src/directory_alias_requirer",
+        format!("{base_path}/chained_aliases/subdirectory/successful_requirer"),
     )
     .unwrap();
-    assert_eq!("result from subdirectory_dependency", get_str(&res, 1));
+    assert_eq!("result from inner_dependency", get_str(&get_value(&res, 1), 1));
+    assert_eq!("result from outer_dependency", get_str(&get_value(&res, 2), 1));
 
-    // RequireAliasThatDoesNotExist
-    let res = run_require(&lua, "@this.alias.does.not.exist");
+    // RequireChainedAliasesFailureCyclic
+    let res = run_require(
+        &lua,
+        format!("{base_path}/chained_aliases/subdirectory/failing_requirer_cyclic"),
+    );
     assert!(res.is_err());
-    assert!((res.unwrap_err().to_string()).contains("@this.alias.does.not.exist is not a valid alias"));
+    let err_msg = "error requiring module \"@cyclicentry\": detected alias cycle (@cyclic1 -> @cyclic2 -> @cyclic3 -> @cyclic1)";
+    assert!(res.unwrap_err().to_string().contains(err_msg));
 
-    // IllegalAlias
-    let res = run_require(&lua, "@");
+    // RequireChainedAliasesFailureMissing
+    let res = run_require(
+        &lua,
+        format!("{base_path}/chained_aliases/subdirectory/failing_requirer_missing"),
+    );
     assert!(res.is_err());
-    assert!((res.unwrap_err().to_string()).contains("@ is not a valid alias"));
+    let err_msg = "error requiring module \"@brokenchain\": @missing is not a valid alias";
+    assert!(res.unwrap_err().to_string().contains(err_msg));
+}
+
+#[test]
+fn test_require_with_config() {
+    test_require_with_config_inner("with_config");
+}
+
+#[test]
+fn test_require_with_config_luau() {
+    test_require_with_config_inner("with_config_luau");
 }
 
 #[cfg(all(feature = "async", not(windows)))]

tests/luau/require/with_config/chained_aliases/.luaurc

@@ -0,0 +1,9 @@
+{
+    "aliases":{
+        "outer": "./",
+        "cyclicentry": "@cyclic1",
+        "cyclic1": "@cyclic2",
+        "cyclic2": "@cyclic3",
+        "cyclic3": "@cyclic1"
+    }
+}

tests/luau/require/with_config/chained_aliases/outer_dependency.luau

@@ -0,0 +1 @@
+return {"result from outer_dependency"}

tests/luau/require/with_config/chained_aliases/subdirectory/.luaurc

@@ -0,0 +1,10 @@
+{
+    "aliases":{
+        "passthroughinner": "./inner_dependency",
+        "passthroughouter": "@outer",
+        "dep": "@passthroughinner",
+        "outerdep": "@outer/outer_dependency",
+        "outerdir": "@passthroughouter",
+        "brokenchain": "@missing"
+    }
+}

tests/luau/require/with_config/chained_aliases/subdirectory/failing_requirer_cyclic.luau

@@ -0,0 +1 @@
+return require("@cyclicentry")

tests/luau/require/with_config/chained_aliases/subdirectory/failing_requirer_missing.luau

@@ -0,0 +1 @@
+return require("@brokenchain")

tests/luau/require/with_config/chained_aliases/subdirectory/inner_dependency.luau

@@ -0,0 +1 @@
+return {"result from inner_dependency"}

tests/luau/require/with_config/chained_aliases/subdirectory/successful_requirer.luau

@@ -0,0 +1,7 @@
+local result = {}
+
+table.insert(result, require("@dep"))
+table.insert(result, require("@outerdep"))
+table.insert(result, require("@outerdir/outer_dependency"))
+
+return result

tests/luau/require/with_config_luau/.config.luau

@@ -0,0 +1,8 @@
+return {
+    luau = {
+        aliases = {
+            dep = "./this_should_be_overwritten_by_child_luaurc",
+            otherdep = "./src/other_dependency"
+        }
+    }
+}

tests/luau/require/with_config_luau/chained_aliases/.config.luau

@@ -0,0 +1,11 @@
+return {
+    luau = {
+        aliases = {
+            outer = "./",
+            cyclicentry = "@cyclic1",
+            cyclic1 = "@cyclic2",
+            cyclic2 = "@cyclic3",
+            cyclic3 = "@cyclic1"
+        }
+    }
+}