refactor(go-parser): add unit tests for Go function naming

Signed-off-by: Vladimir Belousov <[email protected]>

Author: vbelouso

src/vuln_analysis/tools/tests/conftest.py

@@ -0,0 +1,14 @@
+import pytest
+
+from vuln_analysis.utils.functions_parsers.golang_functions_parsers import (
+    GoLanguageFunctionsParser,
+)
+
+
+@pytest.fixture(scope="module")
+def go_parser() -> GoLanguageFunctionsParser:
+    """
+    Provides a single instance of the GoLanguageFunctionsParser
+    for all tests in a module.
+    """
+    return GoLanguageFunctionsParser()

src/vuln_analysis/tools/tests/test_go_segmenter.py

@@ -1,65 +1,60 @@
+import textwrap
+
 from vuln_analysis.utils.go_segmenter_extended import GoSegmenterExtended
 
 
 def _extract(code: str):
-    seg = GoSegmenterExtended(code)
-    return [s.strip() for s in seg.extract_functions_classes()]
+    seg = GoSegmenterExtended(textwrap.dedent(code))
+    return seg.extract_functions_classes()
 
 
-def test_generic_method_basic():
+def test_segmenter_extracts_type_and_generic_method():
     code = """
     type Box[T any] struct { value T }
     func (b *Box[T]) Set(v T) { b.value = v }
     """
-    chunks = _extract(code)
-    assert any("Set" in c for c in chunks), "generic method not extracted"
+    expected_chunks = [
+        "type Box[T any] struct { value T }",
+        "func (b *Box[T]) Set(v T) { b.value = v }",
+    ]
 
-
-def test_generic_multiple_type_params():
-    code = """
-    func MapKeys[K comparable, V any](m map[K]V) []K {
-        keys := make([]K, 0, len(m))
-        for k := range m {
-            keys = append(keys, k)
-        }
-        return keys
-    }
-    """
-    chunks = _extract(code)
-    assert any("MapKeys" in c for c in chunks), "multiple generics not parsed"
+    actual_chunks = [c.strip() for c in _extract(code)]
+    assert actual_chunks == expected_chunks
 
 
-def test_function_returning_func():
+def test_segmenter_extracts_toplevel_function_only_and_ignores_nested():
     code = """
     func makeAdder(x int) func(int) int {
         return func(y int) int { return x + y }
     }
     """
-    chunks = _extract(code)
-    assert any("makeAdder" in c for c in chunks), "failed to parse func returning func"
-
+    expected_chunks = [
+        textwrap.dedent("""
+        func makeAdder(x int) func(int) int {
+            return func(y int) int { return x + y }
+        }
+        """).strip()
+    ]
 
-def test_inline_anonymous_func():
-    code = """
-    func Worker() {
-        defer func() { cleanup() }()
-        go func() { runTask() }()
-    }
-    """
-    chunks = _extract(code)
-    assert any("Worker" in c for c in chunks), "missed inline anonymous func"
+    actual_chunks = [c.strip() for c in _extract(code)]
+    assert actual_chunks == expected_chunks
 
 
-def test_double_pointer_receiver():
+def test_segmenter_handles_double_pointer_receiver():
     code = """
     type Conn struct{}
     func (c **Conn) Reset() {}
     """
-    chunks = _extract(code)
-    assert any("Reset" in c for c in chunks), "failed to detect pointer receiver"
+    expected_chunks = [
+        "type Conn struct{}",
+        "func (c **Conn) Reset() {}",
+    ]
 
+    actual_chunks = [c.strip() for c in _extract(code)]
+    assert actual_chunks == expected_chunks
 
-def test_multiline_generic_method():
+
+def test_segmenter_handles_multiline_generic_method():
     code = """
     func (r *Repo[
         T any,
@@ -68,5 +63,16 @@ def test_multiline_generic_method():
         return nil, nil
     }
     """
-    chunks = _extract(code)
-    assert any("Save" in c for c in chunks), "multiline generic method not parsed"
+    expected_chunks = [
+        textwrap.dedent("""
+        func (r *Repo[
+            T any,
+            E error,
+        ]) Save(v T) (E, error) {
+            return nil, nil
+        }
+        """).strip()
+    ]
+
+    actual_chunks = [c.strip() for c in _extract(code)]
+    assert actual_chunks == expected_chunks

src/vuln_analysis/tools/tests/test_golang_functions_parsers.py

@@ -0,0 +1,132 @@
+
+import textwrap
+
+import pytest
+from langchain_core.documents import Document
+
+HAPPY_PATH_CASES = [
+    ("simple_function", "func DoSomething() {}", "DoSomething"),
+    ("with_parameters", "func DoSomething(p1 string, p2 int) {}", "DoSomething"),
+    ("with_return_value", "func DoSomething(v int) string {}", "DoSomething"),
+    (
+        "with_named_return",
+        "func DoSomething(a, b float64) (q float64, e error) {}",
+        "DoSomething",
+    ),
+    (
+        "method_with_receiver",
+        "func (p *Point) DoSomething() float64 {}",
+        "DoSomething",
+    ),
+]
+
+
+EDGE_CASES_TEST = [
+    ("generic_function", "func DoSomething[T any](s []T) {}", "DoSomething"),
+    (
+        "letter_or_underscores",
+        "func _internal_calculate_v2() {}",
+        "_internal_calculate_v2",
+    ),
+    (
+        "receivers_double_pointer_function",
+        "func (c **Connection) Close() error {}",
+        "Close",
+    ),
+    (
+        "receivers_without_the_name_function",
+        "func (*Point) IsOrigin() bool {}",
+        "IsOrigin",
+    ),
+    (
+        "multiline_function",
+        """
+        func (r *Repository[
+            T Model, 
+            K KeyType,
+        ]) FindByID(id K) (*T, error) {}
+        """,
+        "FindByID",
+    ),
+]
+
+NEGATIVE_ANONYMOUS_CASES = [
+    (
+        "assigned_to_variable",
+        "var greeter = func(name string) { fmt.Println('Hello,', name) }",
+    ),
+    (
+        "assigned_to_variable2",
+        textwrap.dedent(
+            """
+            greet := func() { // Assigning anonymous function to a variable 'greet'
+                fmt.Println("Greetings from a variable-assigned anonymous function!")
+            }
+            """
+        ),
+    ),
+    (
+        "go_routine",
+        "go func() { fmt.Println('Running in background') }()",
+    ),
+    (
+        "defer_statement",
+        "defer func() { file.Close() }()",
+    ),
+    (
+        "callback_argument",
+        "http.HandleFunc('/', func(w http.ResponseWriter, r *http.Request) {})",
+    ),
+]
+
+MALFORMED_INPUT_CASES = [
+    ("empty_string", ""),
+    ("whitespace_only", "   \n\t   "),
+    ("just_the_keyword", "func"),
+    ("incomplete_header", "func myFunc("),
+    ("garbage_input", "a = b + c;"),
+]
+
+@pytest.mark.parametrize("test_id, code_snippet, expected_name", HAPPY_PATH_CASES)
+def test_happy_path_function_names(go_parser, test_id,code_snippet, expected_name):
+    doc = Document(page_content=code_snippet.strip(), metadata={"source": "test.go"})
+    actual_name = go_parser.get_function_name(doc)
+    assert actual_name == expected_name, f"Test case '{test_id}' failed"
+
+@pytest.mark.parametrize("test_id, code_snippet, expected_name", EDGE_CASES_TEST)
+def test_edge_cases_function_names(go_parser, test_id, code_snippet, expected_name):
+    doc = Document(page_content=code_snippet.strip(), metadata={"source": "test.go"})
+    actual_name = go_parser.get_function_name(doc)
+    assert actual_name == expected_name, f"Test case '{test_id}' failed"
+
+@pytest.mark.parametrize("test_id, code_snippet", NEGATIVE_ANONYMOUS_CASES)
+def test_negative_cases_anonymous_functions(go_parser, test_id, code_snippet):
+    doc = Document(page_content=code_snippet.strip(), metadata={"source": "proxy.go"})
+    name = go_parser.get_function_name(doc)
+    assert name.startswith("anon_"), (
+        f"[{test_id}] Expected name to start with 'anon_', but got '{name}'"
+    )
+    parts = name.split("_")
+    assert len(parts) == 3, (
+        f"[{test_id}] Expected name format 'anon_<prefix>_<hash>', but got '{name}'"
+    )
+
+    assert parts[1] == "proxy", (
+        f"[{test_id}] Expected file prefix 'proxy', but got '{parts[1]}'"
+    )
+    hash_part = parts[2]
+    assert len(hash_part) == 8, (
+        f"[{test_id}] Hash part should be 8 characters, but got '{hash_part}'"
+    )
+    assert all(c in "0123456789abcdef" for c in hash_part), (
+        f"[{test_id}] Hash part should be hex, but got '{hash_part}'"
+    )
+
+@pytest.mark.parametrize("test_id, code_snippet", MALFORMED_INPUT_CASES)
+def test_malformed_input_graceful_failure(go_parser, test_id, code_snippet):
+    doc = Document(page_content=code_snippet, metadata={"source": "malformed.go"})
+    name = go_parser.get_function_name(doc)
+
+    assert name.startswith("anon_"), (
+        f"[{test_id}] Failed to handle malformed input gracefully. Got: {name}"
+    )