test: fix structured tool tests

No tests were being executed from this file
This commit is contained in:
Lucas Gomide
2025-06-09 17:29:06 -03:00
parent 5b740467cb
commit c52c42e361

View File

@@ -25,122 +25,121 @@ def schema_class():
return TestSchema return TestSchema
class InternalCrewStructuredTool: def test_initialization(basic_function, schema_class):
def test_initialization(self, basic_function, schema_class): """Test basic initialization of CrewStructuredTool"""
"""Test basic initialization of CrewStructuredTool""" tool = CrewStructuredTool(
tool = CrewStructuredTool( name="test_tool",
name="test_tool", description="Test tool description",
description="Test tool description", func=basic_function,
func=basic_function, args_schema=schema_class,
args_schema=schema_class, )
)
assert tool.name == "test_tool" assert tool.name == "test_tool"
assert tool.description == "Test tool description" assert tool.description == "Test tool description"
assert tool.func == basic_function assert tool.func == basic_function
assert tool.args_schema == schema_class assert tool.args_schema == schema_class
def test_from_function(self, basic_function): def test_from_function(basic_function):
"""Test creating tool from function""" """Test creating tool from function"""
tool = CrewStructuredTool.from_function( tool = CrewStructuredTool.from_function(
func=basic_function, name="test_tool", description="Test description" func=basic_function, name="test_tool", description="Test description"
) )
assert tool.name == "test_tool" assert tool.name == "test_tool"
assert tool.description == "Test description" assert tool.description == "Test description"
assert tool.func == basic_function assert tool.func == basic_function
assert isinstance(tool.args_schema, type(BaseModel)) assert isinstance(tool.args_schema, type(BaseModel))
def test_validate_function_signature(self, basic_function, schema_class): def test_validate_function_signature(basic_function, schema_class):
"""Test function signature validation""" """Test function signature validation"""
tool = CrewStructuredTool( tool = CrewStructuredTool(
name="test_tool", name="test_tool",
description="Test tool", description="Test tool",
func=basic_function, func=basic_function,
args_schema=schema_class, args_schema=schema_class,
) )
# Should not raise any exceptions # Should not raise any exceptions
tool._validate_function_signature() tool._validate_function_signature()
@pytest.mark.asyncio @pytest.mark.asyncio
async def test_ainvoke(self, basic_function): async def test_ainvoke(basic_function):
"""Test asynchronous invocation""" """Test asynchronous invocation"""
tool = CrewStructuredTool.from_function(func=basic_function, name="test_tool") tool = CrewStructuredTool.from_function(func=basic_function, name="test_tool")
result = await tool.ainvoke(input={"param1": "test"}) result = await tool.ainvoke(input={"param1": "test"})
assert result == "test 0" assert result == "test 0"
def test_parse_args_dict(self, basic_function): def test_parse_args_dict(basic_function):
"""Test parsing dictionary arguments""" """Test parsing dictionary arguments"""
tool = CrewStructuredTool.from_function(func=basic_function, name="test_tool") tool = CrewStructuredTool.from_function(func=basic_function, name="test_tool")
parsed = tool._parse_args({"param1": "test", "param2": 42}) parsed = tool._parse_args({"param1": "test", "param2": 42})
assert parsed["param1"] == "test" assert parsed["param1"] == "test"
assert parsed["param2"] == 42 assert parsed["param2"] == 42
def test_parse_args_string(self, basic_function): def test_parse_args_string(basic_function):
"""Test parsing string arguments""" """Test parsing string arguments"""
tool = CrewStructuredTool.from_function(func=basic_function, name="test_tool") tool = CrewStructuredTool.from_function(func=basic_function, name="test_tool")
parsed = tool._parse_args('{"param1": "test", "param2": 42}') parsed = tool._parse_args('{"param1": "test", "param2": 42}')
assert parsed["param1"] == "test" assert parsed["param1"] == "test"
assert parsed["param2"] == 42 assert parsed["param2"] == 42
def test_complex_types(self): def test_complex_types():
"""Test handling of complex parameter types""" """Test handling of complex parameter types"""
def complex_func(nested: dict, items: list) -> str: def complex_func(nested: dict, items: list) -> str:
"""Process complex types.""" """Process complex types."""
return f"Processed {len(items)} items with {len(nested)} nested keys" return f"Processed {len(items)} items with {len(nested)} nested keys"
tool = CrewStructuredTool.from_function( tool = CrewStructuredTool.from_function(
func=complex_func, name="test_tool", description="Test complex types" func=complex_func, name="test_tool", description="Test complex types"
) )
result = tool.invoke({"nested": {"key": "value"}, "items": [1, 2, 3]}) result = tool.invoke({"nested": {"key": "value"}, "items": [1, 2, 3]})
assert result == "Processed 3 items with 1 nested keys" assert result == "Processed 3 items with 1 nested keys"
def test_schema_inheritance(self): def test_schema_inheritance():
"""Test tool creation with inherited schema""" """Test tool creation with inherited schema"""
def extended_func(base_param: str, extra_param: int) -> str: def extended_func(base_param: str, extra_param: int) -> str:
"""Test function with inherited schema.""" """Test function with inherited schema."""
return f"{base_param} {extra_param}" return f"{base_param} {extra_param}"
class BaseSchema(BaseModel): class BaseSchema(BaseModel):
base_param: str base_param: str
class ExtendedSchema(BaseSchema): class ExtendedSchema(BaseSchema):
extra_param: int extra_param: int
tool = CrewStructuredTool.from_function( tool = CrewStructuredTool.from_function(
func=extended_func, name="test_tool", args_schema=ExtendedSchema func=extended_func, name="test_tool", args_schema=ExtendedSchema
) )
result = tool.invoke({"base_param": "test", "extra_param": 42}) result = tool.invoke({"base_param": "test", "extra_param": 42})
assert result == "test 42" assert result == "test 42"
def test_default_values_in_schema(self): def test_default_values_in_schema():
"""Test handling of default values in schema""" """Test handling of default values in schema"""
def default_func( def default_func(
required_param: str, required_param: str,
optional_param: str = "default", optional_param: str = "default",
nullable_param: Optional[int] = None, nullable_param: Optional[int] = None,
) -> str: ) -> str:
"""Test function with default values.""" """Test function with default values."""
return f"{required_param} {optional_param} {nullable_param}" return f"{required_param} {optional_param} {nullable_param}"
tool = CrewStructuredTool.from_function( tool = CrewStructuredTool.from_function(
func=default_func, name="test_tool", description="Test defaults" func=default_func, name="test_tool", description="Test defaults"
) )
# Test with minimal parameters # Test with minimal parameters
result = tool.invoke({"required_param": "test"}) result = tool.invoke({"required_param": "test"})
assert result == "test default None" assert result == "test default None"
# Test with all parameters # Test with all parameters
result = tool.invoke( result = tool.invoke(
{"required_param": "test", "optional_param": "custom", "nullable_param": 42} {"required_param": "test", "optional_param": "custom", "nullable_param": 42}
) )
assert result == "test custom 42" assert result == "test custom 42"