mirror of
https://github.com/catlog22/Claude-Code-Workflow.git
synced 2026-02-10 02:24:35 +08:00
267 lines
9.1 KiB
Python
267 lines
9.1 KiB
Python
#!/usr/bin/env python3
|
|
"""Test for Go symbol discovery including all symbol types."""
|
|
import pytest
|
|
|
|
from code_index_mcp.indexing.strategies.go_strategy import GoParsingStrategy
|
|
|
|
|
|
@pytest.fixture
|
|
def test_code_with_all_symbols():
|
|
"""Fixture with variables, constants, functions, structs, interfaces and methods."""
|
|
return '''
|
|
package main
|
|
|
|
import (
|
|
"fmt" // comment mentioning ) parentheses )
|
|
strutil "strings"
|
|
helper "example.com/project/toolkit"
|
|
) // closing comment with ) ) characters
|
|
import ("math" /* inline comment ) inside */)
|
|
import . "errors"
|
|
import _ "embed"
|
|
import (
|
|
"time"
|
|
)
|
|
|
|
// Application version constant
|
|
const VERSION = "1.0.0"
|
|
|
|
// Global variable for configuration
|
|
var config string = "default"
|
|
|
|
// Add returns the sum of two integers.
|
|
func Add(x int, y int) int {
|
|
return x + y
|
|
}
|
|
|
|
// ComplexFunc demonstrates a complex function signature.
|
|
// It takes multiple parameters including variadic args.
|
|
func ComplexFunc(name string, values ...int) (int, error) {
|
|
sum := 0
|
|
for _, v := range values {
|
|
sum += v
|
|
}
|
|
return sum, nil
|
|
}
|
|
|
|
// Divide divides two numbers and returns the result.
|
|
// It returns an error if the divisor is zero.
|
|
//
|
|
// Parameters:
|
|
// - a: the dividend
|
|
// - b: the divisor
|
|
//
|
|
// Returns:
|
|
// - float64: the quotient
|
|
// - error: an error if b is zero
|
|
func Divide(a, b float64) (float64, error) {
|
|
if b == 0 {
|
|
return 0, errors.New("division by zero")
|
|
}
|
|
return a / b, nil
|
|
}
|
|
|
|
// ProcessData processes the given data with options.
|
|
//
|
|
// The function accepts a data string and processes it according to
|
|
// the provided options. It supports multiple processing modes.
|
|
//
|
|
// Args:
|
|
// data: the input data string to process
|
|
// options: configuration options for processing
|
|
//
|
|
// Returns:
|
|
// The processed result string and any error encountered.
|
|
//
|
|
// Example:
|
|
// result, err := ProcessData("hello", Options{Mode: "upper"})
|
|
// if err != nil {
|
|
// log.Fatal(err)
|
|
// }
|
|
func ProcessData(data string, options map[string]interface{}) (string, error) {
|
|
// Implementation
|
|
return strings.ToUpper(data), nil
|
|
}
|
|
|
|
// User represents a user in the system.
|
|
type User struct {
|
|
ID int
|
|
Name string
|
|
Email string
|
|
IsActive bool
|
|
}
|
|
|
|
// NewUser creates a new User instance.
|
|
func NewUser(id int, name string, email string) *User {
|
|
return &User{
|
|
ID: id,
|
|
Name: name,
|
|
Email: email,
|
|
}
|
|
}
|
|
|
|
// GetFullName returns the user's full name.
|
|
func (u *User) GetFullName() string {
|
|
return u.Name
|
|
}
|
|
|
|
// Activate marks the user as active.
|
|
// This is a pointer receiver method.
|
|
func (u *User) Activate() {
|
|
u.IsActive = true
|
|
}
|
|
|
|
// IsValid checks if the user has valid data.
|
|
// This is a value receiver method.
|
|
func (u User) IsValid() bool {
|
|
return u.ID > 0 && u.Name != ""
|
|
}
|
|
|
|
// Repository interface defines data access methods.
|
|
type Repository interface {
|
|
// Save stores an entity
|
|
Save(entity interface{}) error
|
|
|
|
// FindByID retrieves an entity by ID
|
|
FindByID(id int) (interface{}, error)
|
|
|
|
// Delete removes an entity
|
|
Delete(id int) error
|
|
}
|
|
|
|
// Logger is a simple interface for logging.
|
|
type Logger interface {
|
|
Log(message string)
|
|
}
|
|
|
|
// Calculate is a function type
|
|
type Calculate func(a, b int) int
|
|
'''
|
|
|
|
|
|
def test_go_symbol_discovery(test_code_with_all_symbols):
|
|
"""Test that all Go symbol types are correctly discovered."""
|
|
strategy = GoParsingStrategy()
|
|
symbols, file_info = strategy.parse_file("test.go", test_code_with_all_symbols)
|
|
|
|
# Create a lookup dict by symbol name for easier access
|
|
# This will throw KeyError if a symbol is missing
|
|
symbol_lookup = {}
|
|
for symbol_id, symbol_info in symbols.items():
|
|
# Extract the symbol name from the ID (format: "file.go::SymbolName")
|
|
if '::' in symbol_id:
|
|
name = symbol_id.split('::')[1]
|
|
symbol_lookup[name] = symbol_info
|
|
|
|
# Verify package is extracted
|
|
assert file_info.package == "main"
|
|
|
|
# Verify imports are extracted (including tricky formats and aliases)
|
|
assert "fmt" in file_info.imports
|
|
assert "strings" in file_info.imports
|
|
assert "errors" in file_info.imports
|
|
assert "example.com/project/toolkit" in file_info.imports
|
|
assert "math" in file_info.imports
|
|
assert "embed" in file_info.imports
|
|
assert "time" in file_info.imports
|
|
|
|
# Verify all expected functions are in file_info
|
|
discovered_functions = file_info.symbols.get('functions', [])
|
|
expected_functions = ['Add', 'ComplexFunc', 'Divide', 'ProcessData', 'NewUser', 'GetFullName', 'Activate', 'IsValid']
|
|
for func in expected_functions:
|
|
assert func in discovered_functions, f"Function '{func}' not in file_info.symbols['functions']"
|
|
|
|
# Verify structs and interfaces are discovered (in 'classes')
|
|
discovered_classes = file_info.symbols.get('classes', [])
|
|
assert 'User' in discovered_classes
|
|
assert 'Repository' in discovered_classes
|
|
assert 'Logger' in discovered_classes
|
|
|
|
# Verify all symbols are in lookup
|
|
assert 'Add' in symbol_lookup
|
|
assert 'ComplexFunc' in symbol_lookup
|
|
assert 'Divide' in symbol_lookup
|
|
assert 'ProcessData' in symbol_lookup
|
|
assert 'User' in symbol_lookup
|
|
assert 'NewUser' in symbol_lookup
|
|
assert 'GetFullName' in symbol_lookup
|
|
assert 'Activate' in symbol_lookup
|
|
assert 'IsValid' in symbol_lookup
|
|
assert 'Repository' in symbol_lookup
|
|
assert 'Logger' in symbol_lookup
|
|
|
|
# Check symbol types
|
|
assert symbol_lookup['Add'].type == 'function'
|
|
assert symbol_lookup['ComplexFunc'].type == 'function'
|
|
assert symbol_lookup['Divide'].type == 'function'
|
|
assert symbol_lookup['ProcessData'].type == 'function'
|
|
assert symbol_lookup['NewUser'].type == 'function'
|
|
assert symbol_lookup['GetFullName'].type == 'method'
|
|
assert symbol_lookup['Activate'].type == 'method'
|
|
assert symbol_lookup['IsValid'].type == 'method'
|
|
assert symbol_lookup['User'].type == 'struct'
|
|
assert symbol_lookup['Repository'].type == 'interface'
|
|
assert symbol_lookup['Logger'].type == 'interface'
|
|
|
|
# Check signatures are captured
|
|
assert symbol_lookup['Add'].signature is not None
|
|
assert 'Add' in symbol_lookup['Add'].signature
|
|
assert 'int' in symbol_lookup['Add'].signature
|
|
|
|
assert symbol_lookup['ComplexFunc'].signature is not None
|
|
assert 'ComplexFunc' in symbol_lookup['ComplexFunc'].signature
|
|
assert '...int' in symbol_lookup['ComplexFunc'].signature or 'values' in symbol_lookup['ComplexFunc'].signature
|
|
|
|
assert symbol_lookup['GetFullName'].signature is not None
|
|
assert 'GetFullName' in symbol_lookup['GetFullName'].signature
|
|
assert 'User' in symbol_lookup['GetFullName'].signature or '*User' in symbol_lookup['GetFullName'].signature
|
|
|
|
# Check line numbers are correct (approximate, since we know the structure)
|
|
assert symbol_lookup['Add'].line > 10
|
|
assert symbol_lookup['User'].line > symbol_lookup['Add'].line
|
|
assert symbol_lookup['GetFullName'].line > symbol_lookup['User'].line
|
|
|
|
# Check that methods are associated with correct receivers
|
|
# Method signatures should contain receiver information
|
|
assert 'User' in symbol_lookup['GetFullName'].signature
|
|
assert 'User' in symbol_lookup['Activate'].signature
|
|
assert 'User' in symbol_lookup['IsValid'].signature
|
|
|
|
# Check docstrings/comments are extracted
|
|
assert symbol_lookup['Add'].docstring == "Add returns the sum of two integers."
|
|
assert symbol_lookup['ComplexFunc'].docstring is not None
|
|
assert "complex function signature" in symbol_lookup['ComplexFunc'].docstring.lower()
|
|
assert "variadic" in symbol_lookup['ComplexFunc'].docstring.lower()
|
|
|
|
assert symbol_lookup['User'].docstring == "User represents a user in the system."
|
|
assert symbol_lookup['NewUser'].docstring == "NewUser creates a new User instance."
|
|
|
|
assert symbol_lookup['GetFullName'].docstring == "GetFullName returns the user's full name."
|
|
assert symbol_lookup['Activate'].docstring is not None
|
|
assert "marks the user as active" in symbol_lookup['Activate'].docstring.lower()
|
|
|
|
assert symbol_lookup['IsValid'].docstring is not None
|
|
assert "checks if the user has valid data" in symbol_lookup['IsValid'].docstring.lower()
|
|
|
|
assert symbol_lookup['Repository'].docstring == "Repository interface defines data access methods."
|
|
assert symbol_lookup['Logger'].docstring == "Logger is a simple interface for logging."
|
|
|
|
# Check Go standard docstring format with parameters and returns
|
|
divide_doc = symbol_lookup['Divide'].docstring
|
|
assert divide_doc is not None
|
|
assert "divides two numbers" in divide_doc.lower()
|
|
assert "Parameters:" in divide_doc
|
|
assert "Returns:" in divide_doc
|
|
assert "- a: the dividend" in divide_doc
|
|
assert "- b: the divisor" in divide_doc
|
|
assert "error if b is zero" in divide_doc.lower()
|
|
|
|
# Check detailed docstring with examples
|
|
process_doc = symbol_lookup['ProcessData'].docstring
|
|
assert process_doc is not None
|
|
assert "processes the given data" in process_doc.lower()
|
|
assert "Args:" in process_doc or "Parameters:" in process_doc.lower()
|
|
assert "Returns:" in process_doc
|
|
assert "Example:" in process_doc
|
|
assert "ProcessData" in process_doc
|