KCL: Add unit tests for cleanup_type_string

Author: adamchalmers

rust/kcl-lib/src/docs/gen_std_tests.rs

@@ -567,6 +567,91 @@ fn cleanup_type_string(input: &str, fmt_for_text: bool, kcl_std: &ModData) -> St
     tys.join(if fmt_for_text { " or " } else { " | " })
 }
 
+#[test]
+fn test_cleanup_type_string() {
+    enum Expected {
+        Value(&'static str),
+        Panic,
+    }
+
+    struct Case {
+        input: &'static str,
+        expected_code: Expected,
+        expected_text: Expected,
+    }
+
+    use Expected::{Panic, Value};
+
+    let kcl_std = crate::docs::kcl_doc::walk_prelude();
+    let cases = [
+        Case {
+            input: "[[Solid; 2]]",
+            expected_code: Value("[[Solid; 2]]"),
+            expected_text: Value("`[[Solid; 2]]`"),
+        },
+        Case {
+            input: "[Solid; 1+]",
+            expected_code: Value("[Solid; 1+]"),
+            expected_text: Value("[`[Solid; 1+]`](/docs/kcl-std/types/std-types-Solid)"),
+        },
+        Case {
+            input: "[Solid; 1+] | ImportedGeometry",
+            expected_code: Value("[Solid; 1+] | ImportedGeometry"),
+            expected_text: Value(
+                "[`[Solid; 1+]`](/docs/kcl-std/types/std-types-Solid) or [`ImportedGeometry`](/docs/kcl-std/types/std-types-ImportedGeometry)",
+            ),
+        },
+        Case {
+            input: "[Solid | Sketch; 1+]",
+            expected_code: Panic,
+            expected_text: Panic,
+        },
+        Case {
+            input: "[Solid | Sketch; 1+] | ImportedGeometry",
+            expected_code: Value("[Solid | Sketch; 1+] | ImportedGeometry"),
+            expected_text: Value(
+                "`[Solid` or `Sketch; 1+]` or [`ImportedGeometry`](/docs/kcl-std/types/std-types-ImportedGeometry)",
+            ),
+        },
+    ];
+
+    for case in cases {
+        match case.expected_code {
+            Value(expected) => {
+                let actual = cleanup_type_string(case.input, false, &kcl_std);
+                assert_eq!(actual, expected, "fmt_for_text=false failed for input {}", case.input);
+            }
+            Panic => {
+                let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+                    cleanup_type_string(case.input, false, &kcl_std)
+                }));
+                assert!(
+                    result.is_err(),
+                    "fmt_for_text=false expected panic for input {}",
+                    case.input
+                );
+            }
+        }
+
+        match case.expected_text {
+            Value(expected) => {
+                let actual = cleanup_type_string(case.input, true, &kcl_std);
+                assert_eq!(actual, expected, "fmt_for_text=true failed for input {}", case.input);
+            }
+            Panic => {
+                let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+                    cleanup_type_string(case.input, true, &kcl_std)
+                }));
+                assert!(
+                    result.is_err(),
+                    "fmt_for_text=true expected panic for input {}",
+                    case.input
+                );
+            }
+        }
+    }
+}
+
 #[test]
 fn test_generate_stdlib_markdown_docs() {
     let kcl_std = crate::docs::kcl_doc::walk_prelude();
@@ -650,3 +735,53 @@ async fn run_example(text: &str) -> Result<()> {
     ctx.run(&program, &mut exec_state).await?;
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_cleanup_type_string() {
+        let kcl_std = crate::docs::kcl_doc::walk_prelude();
+
+        struct Test {
+            input: &'static str,
+            expected_text: &'static str,
+            expected_no_text: &'static str,
+        }
+
+        let tests = [
+            Test {
+                input: "v",
+                expected_text: "`v`",
+                expected_no_text: "v",
+            },
+            Test {
+                input: "number(mm)",
+                expected_text: "[`number(mm)`](/docs/kcl-std/types/std-types-number)",
+                expected_no_text: "number(mm)",
+            },
+            Test {
+                input: "number(mm) | string",
+                expected_text: "[`number(mm)`](/docs/kcl-std/types/std-types-number) or [`string`](/docs/kcl-std/types/std-types-string)",
+                expected_no_text: "number(mm) | string",
+            },
+            Test {
+                input: "[string; 1+]",
+                expected_text: "[`[string; 1+]`](/docs/kcl-std/types/std-types-string)",
+                expected_no_text: "[string; 1+]",
+            },
+            Test {
+                input: "[string; 1+] | number(mm)",
+                expected_text: "[`[string; 1+]`](/docs/kcl-std/types/std-types-string) or [`number(mm)`](/docs/kcl-std/types/std-types-number)",
+                expected_no_text: "[string; 1+] | number(mm)",
+            },
+        ];
+        for test in tests {
+            let actual_text = cleanup_type_string(test.input, true, &kcl_std);
+            assert_eq!(actual_text, test.expected_text);
+            let actual_no_text = cleanup_type_string(test.input, false, &kcl_std);
+            assert_eq!(actual_no_text, test.expected_no_text);
+        }
+    }
+}