Add tests

Author: dirkbrnd

libs/agno/tests/unit/tools/test_python_tools.py

@@ -0,0 +1,159 @@
+import os
+import tempfile
+from pathlib import Path
+import pytest
+from unittest.mock import patch, MagicMock
+
+from agno.tools.python import PythonTools
+
+
+@pytest.fixture
+def temp_dir():
+    with tempfile.TemporaryDirectory() as tmpdirname:
+        yield Path(tmpdirname)
+
+
+@pytest.fixture
+def python_tools(temp_dir):
+    return PythonTools(
+        base_dir=temp_dir,
+        save_and_run=True,
+        pip_install=True,
+        uv_pip_install=True,
+        run_code=True,
+        list_files=True,
+        run_files=True,
+        read_files=True,
+    )
+
+
+def test_save_to_file_and_run_success(python_tools, temp_dir):
+    # Test successful code execution
+    code = "x = 42"
+    result = python_tools.save_to_file_and_run("test.py", code, "x")
+    assert result == "42"
+    assert (temp_dir / "test.py").exists()
+    assert (temp_dir / "test.py").read_text() == code
+
+
+def test_save_to_file_and_run_error(python_tools):
+    # Test code with syntax error
+    code = "x = "  # Invalid syntax
+    result = python_tools.save_to_file_and_run("test.py", code)
+    assert "Error saving and running code" in result
+
+
+def test_save_to_file_and_run_no_overwrite(python_tools, temp_dir):
+    # Test file overwrite prevention
+    file_path = temp_dir / "test.py"
+    file_path.write_text("original")
+    
+    result = python_tools.save_to_file_and_run("test.py", "new code", overwrite=False)
+    assert "already exists" in result
+    assert file_path.read_text() == "original"
+
+
+def test_run_python_file_return_variable(python_tools, temp_dir):
+    # Test running existing file and returning variable
+    file_path = temp_dir / "test.py"
+    file_path.write_text("x = 42")
+    
+    result = python_tools.run_python_file_return_variable("test.py", "x")
+    assert result == "42"
+
+
+def test_run_python_file_return_variable_not_found(python_tools, temp_dir):
+    # Test running file with non-existent variable
+    file_path = temp_dir / "test.py"
+    file_path.write_text("x = 42")
+    
+    result = python_tools.run_python_file_return_variable("test.py", "y")
+    assert "Variable y not found" in result
+
+
+def test_read_file(python_tools, temp_dir):
+    # Test reading file contents
+    file_path = temp_dir / "test.txt"
+    content = "Hello, World!"
+    file_path.write_text(content)
+    
+    result = python_tools.read_file("test.txt")
+    assert result == content
+
+
+def test_read_file_not_found(python_tools):
+    # Test reading non-existent file
+    result = python_tools.read_file("nonexistent.txt")
+    assert "Error reading file" in result
+
+
+def test_list_files(python_tools, temp_dir):
+    # Test listing files in directory
+    (temp_dir / "file1.txt").touch()
+    (temp_dir / "file2.txt").touch()
+    
+    result = python_tools.list_files()
+    assert "file1.txt" in result
+    assert "file2.txt" in result
+
+
+def test_run_python_code(python_tools):
+    # Test running Python code directly
+    code = "x = 42"
+    result = python_tools.run_python_code(code, "x")
+    assert result == "42"
+
+def test_run_python_code_advanced(python_tools):
+    # Test running Python code directly
+    code = """
+def fibonacci(n, print_steps: bool = False):
+    a, b = 0, 1
+    for _ in range(n):
+        if print_steps:
+            print(a)
+        a, b = b, a + b
+    return a
+
+result = fibonacci(10, print_steps=True)
+    """
+    result = python_tools.run_python_code(code, "result")
+    assert result == "55"
+
+def test_run_python_code_error(python_tools):
+    # Test running invalid Python code
+    code = "x = "  # Invalid syntax
+    result = python_tools.run_python_code(code)
+    assert "Error running python code" in result
+
+
+@patch("subprocess.check_call")
+def test_pip_install_package(mock_check_call, python_tools):
+    # Test pip package installation
+    result = python_tools.pip_install_package("requests")
+    assert "successfully installed package requests" in result
+    mock_check_call.assert_called_once()
+
+
+@patch("subprocess.check_call")
+def test_pip_install_package_error(mock_check_call, python_tools):
+    # Test pip package installation error
+    mock_check_call.side_effect = Exception("Installation failed")
+    result = python_tools.pip_install_package("requests")
+    assert "Error installing package requests" in result
+
+
+@patch("subprocess.check_call")
+def test_uv_pip_install_package(mock_check_call, python_tools):
+    # Test uv pip package installation
+    result = python_tools.uv_pip_install_package("requests")
+    assert "successfully installed package requests" in result
+    mock_check_call.assert_called_once()
+
+
+@patch("subprocess.check_call")
+def test_uv_pip_install_package_error(mock_check_call, python_tools):
+    # Test uv pip package installation error
+    mock_check_call.side_effect = Exception("Installation failed")
+    result = python_tools.uv_pip_install_package("requests")
+    assert "Error installing package requests" in result
+

libs/agno/tests/unit/utils/test_functions.py

@@ -0,0 +1,174 @@
+import json
+import pytest
+from typing import Dict, Optional
+
+from agno.tools.function import Function, FunctionCall
+from agno.utils.functions import get_function_call
+
+
+@pytest.fixture
+def sample_functions() -> Dict[str, Function]:
+    return {
+        "test_function": Function(
+            name="test_function",
+            description="A test function",
+            parameters={
+                "type": "object",
+                "properties": {
+                    "param1": {"type": "string"},
+                    "param2": {"type": "integer"},
+                    "param3": {"type": "boolean"},
+                },
+            },
+            sanitize_arguments=True,
+        ),
+        "no_sanitize_function": Function(
+            name="no_sanitize_function",
+            description="A function without argument sanitization",
+            parameters={
+                "type": "object",
+                "properties": {
+                    "param1": {"type": "string"},
+                },
+            },
+            sanitize_arguments=False,
+        ),
+    }
+
+
+def test_get_function_call_basic(sample_functions):
+    """Test basic function call creation with valid arguments."""
+    arguments = json.dumps({"param1": "test", "param2": 42, "param3": True})
+    call_id = "test-call-123"
+    
+    result = get_function_call(
+        name="test_function",
+        arguments=arguments,
+        call_id=call_id,
+        functions=sample_functions,
+    )
+    
+    assert result is not None
+    assert isinstance(result, FunctionCall)
+    assert result.function == sample_functions["test_function"]
+    assert result.call_id == call_id
+    assert result.arguments == {"param1": "test", "param2": 42, "param3": True}
+    assert result.error is None
+
+
+def test_get_function_call_invalid_name(sample_functions):
+    """Test function call with non-existent function name."""
+    result = get_function_call(
+        name="non_existent_function",
+        arguments='{"param1": "test"}',
+        functions=sample_functions,
+    )
+    
+    assert result is None
+
+
+def test_get_function_call_no_functions():
+    """Test function call with no functions dictionary."""
+    result = get_function_call(
+        name="test_function",
+        arguments='{"param1": "test"}',
+        functions=None,
+    )
+    
+    assert result is None
+
+
+def test_get_function_call_invalid_json(sample_functions):
+    """Test function call with invalid JSON arguments."""
+    result = get_function_call(
+        name="test_function",
+        arguments="invalid json",
+        functions=sample_functions,
+    )
+    
+    assert result is not None
+    assert result.error is not None
+    assert "Error while decoding function arguments" in result.error
+
+
+def test_get_function_call_non_dict_arguments(sample_functions):
+    """Test function call with non-dictionary arguments."""
+    result = get_function_call(
+        name="test_function",
+        arguments='["not", "a", "dict"]',
+        functions=sample_functions,
+    )
+    
+    assert result is not None
+    assert result.error is not None
+    assert "Function arguments are not a valid JSON object" in result.error
+
+
+def test_get_function_call_argument_sanitization(sample_functions):
+    """Test argument sanitization for boolean and null values."""
+    arguments = json.dumps({
+        "param1": "None",
+        "param2": "True",
+        "param3": "False",
+        "param4": "  test  ",
+    })
+    
+    result = get_function_call(
+        name="test_function",
+        arguments=arguments,
+        functions=sample_functions,
+    )
+    
+    assert result is not None
+    assert result.arguments == {
+        "param1": None,
+        "param2": True,
+        "param3": False,
+        "param4": "test",
+    }
+
+
+def test_get_function_call_no_sanitization(sample_functions):
+    """Test function call without argument sanitization."""
+    arguments = json.dumps({
+        "param1": "None",
+        "param2": "True",
+    })
+    
+    result = get_function_call(
+        name="no_sanitize_function",
+        arguments=arguments,
+        functions=sample_functions,
+    )
+    
+    assert result is not None
+    assert result.arguments == {
+        "param1": None,
+        "param2": True,
+    }
+
+
+def test_get_function_call_empty_arguments(sample_functions):
+    """Test function call with empty arguments."""
+    result = get_function_call(
+        name="test_function",
+        arguments="",
+        functions=sample_functions,
+    )
+    
+    assert result is not None
+    assert result.arguments is None
+    assert result.error is None
+
+
+def test_get_function_call_no_arguments(sample_functions):
+    """Test function call with no arguments provided."""
+    result = get_function_call(
+        name="test_function",
+        arguments=None,
+        functions=sample_functions,
+    )
+    
+    assert result is not None
+    assert result.arguments is None
+    assert result.error is None