CopilotJ / data /copilotj /test /multiagent /test_agent_loader.py
introvoyz045's picture
Migrated from GitHub
04f192c verified
Raw History Blame Contribute Delete
10.9 kB
# SPDX-FileCopyrightText: Copyright contributors to the CopilotJ project.
#
# SPDX-License-Identifier: Apache-2.0
import textwrap
from typing import Annotated
from unittest.mock import MagicMock
import pytest
from copilotj.core import FunctionTool
from copilotj.core.config import Config
from copilotj.multiagent import agent_loader as _loader_module
from copilotj.multiagent.agent_loader import _load_agent_configs
# ---------------------------------------------------------------------------
# Helpers — lightweight fakes so we don't import the real Executor / tools
# ---------------------------------------------------------------------------
class _FakeExecutor:
"""Minimal stand-in for Executor accepted by the loader.
Patched in via the ``_patch_executor`` fixture so the ``issubclass``
check in the loader accepts it.
"""
def __init__(self, *, name, description, prompt, tools, model_client):
self.name = name
self.description = description
self.prompt = prompt
self.tools = tools
self.model_client = model_client
@pytest.fixture(autouse=True)
def _patch_executor(monkeypatch):
"""Replace ``Executor`` in the loader module with our fake."""
monkeypatch.setattr(_loader_module, "Executor", _FakeExecutor)
def _write_toml(tmp_path, filename: str, content: str):
"""Write a TOML config file and return its path."""
p = tmp_path / filename
p.write_text(textwrap.dedent(content), encoding="utf-8")
return str(p)
def _make_model_client():
return MagicMock()
def _make_cfg(**overrides):
return Config(**overrides)
def _write_toml(tmp_path, filename: str, content: str):
"""Write a TOML config file and return its path."""
p = tmp_path / filename
p.write_text(textwrap.dedent(content), encoding="utf-8")
return str(p)
def _make_model_client():
return MagicMock()
def _make_cfg(**overrides):
return Config(**overrides)
# ---------------------------------------------------------------------------
# Tests — function field (existing behaviour)
# ---------------------------------------------------------------------------
def test_load_function_tool(tmp_path, monkeypatch):
"""Tools with ``function`` are imported directly and wrapped in FunctionTool."""
# Use a real, importable function as the tool target
toml = """
name = "Test Agent"
class = "copilotj.test.multiagent.test_agent_loader._FakeExecutor"
description = "test"
prompt = ""
[[tools]]
function = "copilotj.test.multiagent.test_agent_loader._sample_tool"
description = "A sample tool."
"""
pattern = str(tmp_path / "*.toml")
_write_toml(tmp_path, "test_agent.toml", toml)
agents = _load_agent_configs(pattern, model_client=_make_model_client(), cfg=_make_cfg())
assert "Test Agent" in agents
agent = agents["Test Agent"]
assert len(agent.tools) == 1
assert isinstance(agent.tools[0], FunctionTool)
def test_function_tool_schema_exposes_params(tmp_path):
"""The JSON schema for a function tool must contain its parameters."""
toml = """
name = "Schema Agent"
class = "copilotj.test.multiagent.test_agent_loader._FakeExecutor"
description = ""
prompt = ""
[[tools]]
function = "copilotj.test.multiagent.test_agent_loader._sample_tool"
description = "desc"
"""
pattern = str(tmp_path / "*.toml")
_write_toml(tmp_path, "schema_agent.toml", toml)
agents = _load_agent_configs(pattern, model_client=_make_model_client(), cfg=_make_cfg())
tool = agents["Schema Agent"].tools[0]
schema = tool.json_schema
assert "query" in schema["parameters"]["properties"]
# ---------------------------------------------------------------------------
# Tests — factory field (new behaviour)
# ---------------------------------------------------------------------------
def test_load_factory_tool(tmp_path):
"""Tools with ``factory`` are called with cfg; the returned callable is wrapped."""
toml = """
name = "Factory Agent"
class = "copilotj.test.multiagent.test_agent_loader._FakeExecutor"
description = ""
prompt = ""
[[tools]]
factory = "copilotj.test.multiagent.test_agent_loader.make_sample_tool"
description = "A factory-made tool."
"""
pattern = str(tmp_path / "*.toml")
_write_toml(tmp_path, "factory_agent.toml", toml)
cfg = _make_cfg(tavily_api_key="secret-123")
agents = _load_agent_configs(pattern, model_client=_make_model_client(), cfg=cfg)
assert "Factory Agent" in agents
agent = agents["Factory Agent"]
assert len(agent.tools) == 1
assert isinstance(agent.tools[0], FunctionTool)
def test_factory_tool_schema_hides_config(tmp_path):
"""A factory-produced tool must NOT expose cfg / api_key in its schema."""
toml = """
name = "Clean Schema Agent"
class = "copilotj.test.multiagent.test_agent_loader._FakeExecutor"
description = ""
prompt = ""
[[tools]]
factory = "copilotj.test.multiagent.test_agent_loader.make_sample_tool"
description = "desc"
"""
pattern = str(tmp_path / "*.toml")
_write_toml(tmp_path, "clean_agent.toml", toml)
cfg = _make_cfg(tavily_api_key="secret-123")
agents = _load_agent_configs(pattern, model_client=_make_model_client(), cfg=cfg)
tool = agents["Clean Schema Agent"].tools[0]
schema = tool.json_schema
props = schema["parameters"]["properties"]
assert "query" in props # LLM-facing param present
assert "cfg" not in props # config param hidden
assert "tavily_api_key" not in props # config param hidden
def test_factory_tool_receives_config(tmp_path):
"""The closure returned by a factory must have access to the injected config."""
async def _run():
toml = """
name = "Config Check Agent"
class = "copilotj.test.multiagent.test_agent_loader._FakeExecutor"
description = ""
prompt = ""
[[tools]]
factory = "copilotj.test.multiagent.test_agent_loader.make_echo_api_key"
description = "Echoes the API key."
"""
pattern = str(tmp_path / "*.toml")
_write_toml(tmp_path, "cfg_check_agent.toml", toml)
cfg = _make_cfg(tavily_api_key="my-secret-key")
agents = _load_agent_configs(pattern, model_client=_make_model_client(), cfg=cfg)
tool = agents["Config Check Agent"].tools[0]
args = tool.args_type()(query="test")
result = await tool.run(args)
assert result == "my-secret-key"
import asyncio
asyncio.run(_run())
# ---------------------------------------------------------------------------
# Tests — error handling & edge cases
# ---------------------------------------------------------------------------
def test_skip_empty_config(tmp_path):
"""Empty TOML files are skipped gracefully."""
pattern = str(tmp_path / "*.toml")
_write_toml(tmp_path, "empty_agent.toml", "")
agents = _load_agent_configs(pattern, model_client=_make_model_client(), cfg=_make_cfg())
assert agents == {}
def test_skip_missing_name_or_class(tmp_path):
"""Configs missing required fields are skipped."""
pattern = str(tmp_path / "*.toml")
_write_toml(tmp_path, "no_class.toml", 'name = "X"\n')
_write_toml(tmp_path, "no_name.toml", 'class = "X.Y"\n')
agents = _load_agent_configs(pattern, model_client=_make_model_client(), cfg=_make_cfg())
assert agents == {}
def test_skip_invalid_toml(tmp_path):
"""Malformed TOML files are skipped, not crashing the loader."""
pattern = str(tmp_path / "*.toml")
p = tmp_path / "bad.toml"
p.write_text("{{{{invalid", encoding="utf-8")
agents = _load_agent_configs(pattern, model_client=_make_model_client(), cfg=_make_cfg())
assert agents == {}
def test_skip_tool_missing_fields(tmp_path):
"""A tool entry with neither function, factory, nor class is skipped."""
toml = """
name = "Bad Tool Agent"
class = "copilotj.test.multiagent.test_agent_loader._FakeExecutor"
description = ""
prompt = ""
[[tools]]
name = "mystery"
description = "Has no function/factory/class"
"""
pattern = str(tmp_path / "*.toml")
_write_toml(tmp_path, "bad_tool.toml", toml)
agents = _load_agent_configs(pattern, model_client=_make_model_client(), cfg=_make_cfg())
assert "Bad Tool Agent" in agents
assert agents["Bad Tool Agent"].tools == []
def test_multiple_tools_mixed_types(tmp_path):
"""An agent can have a mix of function, factory, and class tools."""
toml = """
name = "Mixed Agent"
class = "copilotj.test.multiagent.test_agent_loader._FakeExecutor"
description = ""
prompt = ""
[[tools]]
function = "copilotj.test.multiagent.test_agent_loader._sample_tool"
description = "plain function"
[[tools]]
factory = "copilotj.test.multiagent.test_agent_loader.make_sample_tool"
description = "factory function"
"""
pattern = str(tmp_path / "*.toml")
_write_toml(tmp_path, "mixed.toml", toml)
cfg = _make_cfg(tavily_api_key="key")
agents = _load_agent_configs(pattern, model_client=_make_model_client(), cfg=cfg)
agent = agents["Mixed Agent"]
assert len(agent.tools) == 2
assert all(isinstance(t, FunctionTool) for t in agent.tools)
def test_multiple_agents_loaded(tmp_path):
"""Multiple TOML files produce multiple agents."""
toml_a = """
name = "Agent A"
class = "copilotj.test.multiagent.test_agent_loader._FakeExecutor"
description = ""
prompt = ""
"""
toml_b = """
name = "Agent B"
class = "copilotj.test.multiagent.test_agent_loader._FakeExecutor"
description = ""
prompt = ""
"""
pattern = str(tmp_path / "*.toml")
_write_toml(tmp_path, "a_agent.toml", toml_a)
_write_toml(tmp_path, "b_agent.toml", toml_b)
agents = _load_agent_configs(pattern, model_client=_make_model_client(), cfg=_make_cfg())
assert set(agents.keys()) == {"Agent A", "Agent B"}
# ---------------------------------------------------------------------------
# Dummy tool definitions used by the tests above
# ---------------------------------------------------------------------------
async def _sample_tool(query: Annotated[str, "Search query"]) -> str:
"""A trivial tool used for testing function loading."""
return f"result: {query}"
def make_sample_tool(cfg: Config):
"""Factory that returns a closure with access to cfg."""
async def _tool(query: Annotated[str, "Search query"]) -> str:
return f"result: {query}, key={cfg.tavily_api_key}"
return _tool
def make_echo_api_key(cfg: Config):
"""Factory that echoes the tavily_api_key — for verifying config binding."""
async def _echo(query: Annotated[str, "Ignored"]) -> str:
return cfg.tavily_api_key or ""
return _echo