ClaudeFlow ported, needs cleanup
This commit is contained in:
Your Name
@@ -0,0 +1,521 @@
|
||||
"""Step definitions for CleverClaude agent management features."""
|
||||
|
||||
from behave import given, then, when
|
||||
from hypothesis import given as hypothesis_given
|
||||
from hypothesis import strategies as st
|
||||
|
||||
from cleverclaude.agents.types import AgentType
|
||||
|
||||
|
||||
@given("I have agent management capabilities")
|
||||
def step_agent_management_available(context):
|
||||
"""Ensure agent management is available."""
|
||||
# This would initialize agent management in the test context
|
||||
context.agent_management_available = True
|
||||
|
||||
|
||||
@given("I have created an agent named {agent_name}")
|
||||
def step_agent_created(context, agent_name):
|
||||
"""Create an agent for testing."""
|
||||
# Mock agent creation for testing
|
||||
if not hasattr(context, "created_agents"):
|
||||
context.created_agents = {}
|
||||
|
||||
context.created_agents[agent_name] = {
|
||||
"id": f"agent_{len(context.created_agents)}",
|
||||
"name": agent_name,
|
||||
"type": AgentType.RESEARCHER,
|
||||
"status": "active",
|
||||
"capabilities": {"research", "analysis"},
|
||||
}
|
||||
|
||||
|
||||
@given("I have a {agent_type} agent")
|
||||
def step_have_agent_type(context, agent_type):
|
||||
"""Ensure we have an agent of specific type."""
|
||||
agent_name = f"test_{agent_type}_agent"
|
||||
if not hasattr(context, "created_agents"):
|
||||
context.created_agents = {}
|
||||
|
||||
context.created_agents[agent_name] = {
|
||||
"id": f"agent_{len(context.created_agents)}",
|
||||
"name": agent_name,
|
||||
"type": getattr(AgentType, agent_type.upper()),
|
||||
"status": "active",
|
||||
"capabilities": {agent_type, "general"},
|
||||
}
|
||||
|
||||
|
||||
@given("I have multiple active agents")
|
||||
def step_multiple_active_agents(context):
|
||||
"""Create multiple active agents."""
|
||||
if not hasattr(context, "created_agents"):
|
||||
context.created_agents = {}
|
||||
|
||||
agent_types = ["researcher", "coder", "analyst"]
|
||||
for i, agent_type in enumerate(agent_types):
|
||||
agent_name = f"multi_agent_{i + 1}"
|
||||
context.created_agents[agent_name] = {
|
||||
"id": f"agent_{len(context.created_agents)}",
|
||||
"name": agent_name,
|
||||
"type": getattr(AgentType, agent_type.upper()),
|
||||
"status": "active",
|
||||
"capabilities": {agent_type, "general"},
|
||||
"health": {"cpu_usage": 25.5, "memory_usage": 150.2, "task_count": 3},
|
||||
}
|
||||
|
||||
|
||||
@given("I have agents with different capabilities")
|
||||
def step_agents_with_capabilities(context):
|
||||
"""Create agents with different capabilities."""
|
||||
if not hasattr(context, "created_agents"):
|
||||
context.created_agents = {}
|
||||
|
||||
agents_config = [
|
||||
{"name": "research_agent", "capabilities": {"research", "analysis"}},
|
||||
{"name": "data_agent", "capabilities": {"data_analysis", "visualization"}},
|
||||
{"name": "coding_agent", "capabilities": {"coding", "testing"}},
|
||||
]
|
||||
|
||||
for config in agents_config:
|
||||
context.created_agents[config["name"]] = {
|
||||
"id": f"agent_{len(context.created_agents)}",
|
||||
"name": config["name"],
|
||||
"type": AgentType.RESEARCHER,
|
||||
"status": "active",
|
||||
"capabilities": config["capabilities"],
|
||||
}
|
||||
|
||||
|
||||
@given("I have multiple agents of different types")
|
||||
def step_multiple_different_types(context):
|
||||
"""Create multiple agents of different types."""
|
||||
if not hasattr(context, "created_agents"):
|
||||
context.created_agents = {}
|
||||
|
||||
agent_configs = [
|
||||
{"name": "coord_researcher", "type": "RESEARCHER"},
|
||||
{"name": "coord_coder", "type": "CODER"},
|
||||
{"name": "coord_analyst", "type": "ANALYST"},
|
||||
]
|
||||
|
||||
for config in agent_configs:
|
||||
context.created_agents[config["name"]] = {
|
||||
"id": f"agent_{len(context.created_agents)}",
|
||||
"name": config["name"],
|
||||
"type": getattr(AgentType, config["type"]),
|
||||
"status": "active",
|
||||
"capabilities": {"general", config["type"].lower()},
|
||||
}
|
||||
|
||||
|
||||
@when('I create a {agent_type} agent named "{agent_name}"')
|
||||
def step_create_agent(context, agent_type, agent_name):
|
||||
"""Create an agent with specified type and name."""
|
||||
if not hasattr(context, "created_agents"):
|
||||
context.created_agents = {}
|
||||
|
||||
# Simulate agent creation
|
||||
agent_id = f"agent_{len(context.created_agents)}"
|
||||
context.created_agents[agent_name] = {
|
||||
"id": agent_id,
|
||||
"name": agent_name,
|
||||
"type": getattr(AgentType, agent_type.upper()),
|
||||
"status": "active",
|
||||
"capabilities": {agent_type.lower(), "general"},
|
||||
}
|
||||
|
||||
context.last_created_agent = agent_name
|
||||
context.agent_creation_result = "success"
|
||||
|
||||
|
||||
@when("I create the following agents")
|
||||
def step_create_multiple_agents(context):
|
||||
"""Create multiple agents from table data."""
|
||||
if not hasattr(context, "created_agents"):
|
||||
context.created_agents = {}
|
||||
|
||||
context.bulk_creation_results = []
|
||||
|
||||
for row in context.table:
|
||||
agent_type = row["type"]
|
||||
agent_name = row["name"]
|
||||
capabilities = {cap.strip() for cap in row["capabilities"].split(",")}
|
||||
|
||||
agent_id = f"agent_{len(context.created_agents)}"
|
||||
context.created_agents[agent_name] = {
|
||||
"id": agent_id,
|
||||
"name": agent_name,
|
||||
"type": getattr(AgentType, agent_type.upper()),
|
||||
"status": "active",
|
||||
"capabilities": capabilities,
|
||||
}
|
||||
|
||||
context.bulk_creation_results.append({"name": agent_name, "status": "success"})
|
||||
|
||||
|
||||
@when("I create a {agent_type} agent with {timeout:d} second timeout")
|
||||
def step_create_agent_with_timeout(context, agent_type, timeout):
|
||||
"""Create agent with specified timeout."""
|
||||
agent_name = f"timeout_{agent_type}_agent"
|
||||
if not hasattr(context, "created_agents"):
|
||||
context.created_agents = {}
|
||||
|
||||
agent_id = f"agent_{len(context.created_agents)}"
|
||||
context.created_agents[agent_name] = {
|
||||
"id": agent_id,
|
||||
"name": agent_name,
|
||||
"type": getattr(AgentType, agent_type.upper()),
|
||||
"status": "active",
|
||||
"capabilities": {agent_type.lower()},
|
||||
"timeout": timeout,
|
||||
}
|
||||
|
||||
context.timeout_agent = agent_name
|
||||
|
||||
|
||||
@when("I pause the agent")
|
||||
def step_pause_agent(context):
|
||||
"""Pause an agent."""
|
||||
# Get the last created agent or use a default
|
||||
agent_name = getattr(context, "last_created_agent", "test_agent")
|
||||
if hasattr(context, "created_agents") and agent_name in context.created_agents:
|
||||
context.created_agents[agent_name]["status"] = "paused"
|
||||
context.agent_action_result = "paused"
|
||||
|
||||
|
||||
@when("I resume the agent")
|
||||
def step_resume_agent(context):
|
||||
"""Resume an agent."""
|
||||
agent_name = getattr(context, "last_created_agent", "test_agent")
|
||||
if hasattr(context, "created_agents") and agent_name in context.created_agents:
|
||||
context.created_agents[agent_name]["status"] = "active"
|
||||
context.agent_action_result = "resumed"
|
||||
|
||||
|
||||
@when("I destroy the agent")
|
||||
def step_destroy_agent(context):
|
||||
"""Destroy an agent."""
|
||||
agent_name = getattr(context, "last_created_agent", "test_agent")
|
||||
if hasattr(context, "created_agents") and agent_name in context.created_agents:
|
||||
del context.created_agents[agent_name]
|
||||
context.agent_action_result = "destroyed"
|
||||
|
||||
|
||||
@when("I assign a research task to the agent")
|
||||
def step_assign_research_task(context):
|
||||
"""Assign a research task with multiline content."""
|
||||
task_content = context.text
|
||||
context.assigned_task = {"type": "research", "content": task_content, "status": "assigned"}
|
||||
|
||||
# Simulate task acceptance and execution
|
||||
context.task_execution_result = {
|
||||
"accepted": True,
|
||||
"status": "completed",
|
||||
"result": "Research task completed successfully with relevant findings",
|
||||
}
|
||||
|
||||
|
||||
@when("I check agent health status")
|
||||
def step_check_health_status(context):
|
||||
"""Check agent health status."""
|
||||
if hasattr(context, "created_agents"):
|
||||
context.health_check_results = {}
|
||||
for name, agent in context.created_agents.items():
|
||||
health = agent.get(
|
||||
"health", {"cpu_usage": 15.0, "memory_usage": 100.5, "task_count": 2, "status": "healthy"}
|
||||
)
|
||||
context.health_check_results[name] = health
|
||||
|
||||
|
||||
@when('I query for agents with "{capability}" capability')
|
||||
def step_query_agents_by_capability(context, capability):
|
||||
"""Query agents by capability."""
|
||||
if hasattr(context, "created_agents"):
|
||||
context.capability_query_results = []
|
||||
for name, agent in context.created_agents.items():
|
||||
if capability in agent.get("capabilities", set()):
|
||||
context.capability_query_results.append(
|
||||
{
|
||||
"name": name,
|
||||
"id": agent["id"],
|
||||
"type": agent["type"],
|
||||
"capabilities": list(agent["capabilities"]),
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
@when("I create a coordination task requiring multiple agent types")
|
||||
def step_create_coordination_task(context):
|
||||
"""Create a coordination task."""
|
||||
context.coordination_task = {
|
||||
"type": "coordination",
|
||||
"required_types": ["researcher", "coder", "analyst"],
|
||||
"task_data": {
|
||||
"description": "Complex analysis requiring multiple perspectives",
|
||||
"components": ["research", "coding", "analysis"],
|
||||
},
|
||||
}
|
||||
|
||||
# Simulate coordination
|
||||
context.coordination_result = {"distributed": True, "agents_assigned": 3, "status": "in_progress"}
|
||||
|
||||
|
||||
@when("I create many agents rapidly")
|
||||
def step_create_many_agents_rapidly(context):
|
||||
"""Stress test agent creation."""
|
||||
if not hasattr(context, "created_agents"):
|
||||
context.created_agents = {}
|
||||
|
||||
@hypothesis_given(
|
||||
st.lists(
|
||||
st.text(min_size=1, max_size=20, alphabet=st.characters(whitelist_categories=("Lu", "Ll", "Nd"))),
|
||||
min_size=10,
|
||||
max_size=50,
|
||||
)
|
||||
)
|
||||
def test_rapid_agent_creation(agent_names):
|
||||
stress_results = []
|
||||
|
||||
for i, name in enumerate(agent_names):
|
||||
try:
|
||||
agent_id = f"stress_agent_{i}"
|
||||
context.created_agents[f"stress_{name}"] = {
|
||||
"id": agent_id,
|
||||
"name": f"stress_{name}",
|
||||
"type": AgentType.RESEARCHER,
|
||||
"status": "active",
|
||||
"capabilities": {"stress_test"},
|
||||
}
|
||||
stress_results.append({"name": f"stress_{name}", "status": "success"})
|
||||
except Exception as e:
|
||||
stress_results.append({"name": f"stress_{name}", "status": "failed", "error": str(e)})
|
||||
|
||||
context.stress_test_results = stress_results
|
||||
# Check for system stability
|
||||
context.system_performance = {
|
||||
"stable": True,
|
||||
"resource_leaks": False,
|
||||
"created_count": len([r for r in stress_results if r["status"] == "success"]),
|
||||
}
|
||||
|
||||
# Run the hypothesis test
|
||||
test_rapid_agent_creation()
|
||||
|
||||
|
||||
@then("the agent should be created successfully")
|
||||
def step_agent_created_successfully(context):
|
||||
"""Verify agent creation success."""
|
||||
assert getattr(context, "agent_creation_result", None) == "success"
|
||||
assert hasattr(context, "last_created_agent")
|
||||
agent_name = context.last_created_agent
|
||||
assert hasattr(context, "created_agents")
|
||||
assert agent_name in context.created_agents
|
||||
|
||||
|
||||
@then('the agent should be in "{expected_status}" status')
|
||||
def step_agent_status_check(context, expected_status):
|
||||
"""Verify agent status."""
|
||||
agent_name = getattr(context, "last_created_agent", "test_agent")
|
||||
if hasattr(context, "created_agents") and agent_name in context.created_agents:
|
||||
actual_status = context.created_agents[agent_name]["status"]
|
||||
assert actual_status == expected_status, f"Expected {expected_status}, got {actual_status}"
|
||||
|
||||
|
||||
@then("the agent should have {agent_type} capabilities")
|
||||
def step_agent_capabilities_check(context, agent_type):
|
||||
"""Verify agent has expected capabilities."""
|
||||
agent_name = context.last_created_agent
|
||||
agent = context.created_agents[agent_name]
|
||||
capabilities = agent["capabilities"]
|
||||
expected_capability = agent_type.lower()
|
||||
assert expected_capability in capabilities, f"{expected_capability} not in {capabilities}"
|
||||
|
||||
|
||||
@then("all agents should be created successfully")
|
||||
def step_all_agents_created(context):
|
||||
"""Verify all agents in bulk creation succeeded."""
|
||||
assert hasattr(context, "bulk_creation_results")
|
||||
for result in context.bulk_creation_results:
|
||||
assert result["status"] == "success", f"Agent {result['name']} failed to create"
|
||||
|
||||
|
||||
@then("each agent should have the correct type and capabilities")
|
||||
def step_verify_agent_types_capabilities(context):
|
||||
"""Verify each agent has correct type and capabilities."""
|
||||
for row in context.table:
|
||||
agent_name = row["name"]
|
||||
expected_type = row["type"]
|
||||
expected_capabilities = {cap.strip() for cap in row["capabilities"].split(",")}
|
||||
|
||||
assert agent_name in context.created_agents
|
||||
agent = context.created_agents[agent_name]
|
||||
|
||||
assert agent["type"] == getattr(AgentType, expected_type.upper())
|
||||
assert expected_capabilities.issubset(agent["capabilities"])
|
||||
|
||||
|
||||
@then('the agent status should be "{expected_status}"')
|
||||
def step_verify_agent_status(context, expected_status):
|
||||
"""Verify agent status after action."""
|
||||
agent_name = getattr(context, "last_created_agent", "test_agent")
|
||||
if (
|
||||
(expected_status == "paused" or expected_status == "active")
|
||||
and hasattr(context, "created_agents")
|
||||
and agent_name in context.created_agents
|
||||
):
|
||||
actual_status = context.created_agents[agent_name]["status"]
|
||||
assert actual_status == expected_status
|
||||
|
||||
|
||||
@then("the agent should no longer exist")
|
||||
def step_agent_destroyed(context):
|
||||
"""Verify agent destruction."""
|
||||
agent_name = getattr(context, "last_created_agent", "test_agent")
|
||||
if hasattr(context, "created_agents"):
|
||||
assert agent_name not in context.created_agents
|
||||
|
||||
|
||||
@then("the agent should accept the task")
|
||||
def step_agent_accepts_task(context):
|
||||
"""Verify task acceptance."""
|
||||
assert hasattr(context, "task_execution_result")
|
||||
assert context.task_execution_result["accepted"] is True
|
||||
|
||||
|
||||
@then("the task should be executed within the timeout period")
|
||||
def step_task_executed_in_timeout(context):
|
||||
"""Verify task execution within timeout."""
|
||||
assert hasattr(context, "task_execution_result")
|
||||
assert context.task_execution_result["status"] in ["completed", "in_progress"]
|
||||
|
||||
|
||||
@then("the result should contain relevant research findings")
|
||||
def step_result_contains_findings(context):
|
||||
"""Verify research results."""
|
||||
assert hasattr(context, "task_execution_result")
|
||||
result = context.task_execution_result["result"]
|
||||
assert "research" in result.lower() or "findings" in result.lower()
|
||||
|
||||
|
||||
@then("each agent should report health metrics")
|
||||
def step_agents_report_health(context):
|
||||
"""Verify health metrics reporting."""
|
||||
assert hasattr(context, "health_check_results")
|
||||
for _agent_name, health in context.health_check_results.items():
|
||||
assert "cpu_usage" in health
|
||||
assert "memory_usage" in health
|
||||
assert "task_count" in health
|
||||
|
||||
|
||||
@then("unhealthy agents should be identified")
|
||||
def step_unhealthy_agents_identified(context):
|
||||
"""Verify unhealthy agent identification."""
|
||||
assert hasattr(context, "health_check_results")
|
||||
# For testing, we'll assume all agents are healthy unless specifically set
|
||||
for _agent_name, health in context.health_check_results.items():
|
||||
status = health.get("status", "healthy")
|
||||
if status != "healthy":
|
||||
# This would trigger alerting in real system
|
||||
pass
|
||||
|
||||
|
||||
@then("health metrics should include CPU, memory, and task count")
|
||||
def step_health_metrics_complete(context):
|
||||
"""Verify complete health metrics."""
|
||||
assert hasattr(context, "health_check_results")
|
||||
for _agent_name, health in context.health_check_results.items():
|
||||
assert "cpu_usage" in health
|
||||
assert "memory_usage" in health
|
||||
assert "task_count" in health
|
||||
assert isinstance(health["cpu_usage"], int | float)
|
||||
assert isinstance(health["memory_usage"], int | float)
|
||||
assert isinstance(health["task_count"], int)
|
||||
|
||||
|
||||
@then("only agents with that capability should be returned")
|
||||
def step_capability_query_filtered(context):
|
||||
"""Verify capability query filtering."""
|
||||
assert hasattr(context, "capability_query_results")
|
||||
capability = context.table.headings[0] if hasattr(context, "table") else "data_analysis"
|
||||
|
||||
for result in context.capability_query_results:
|
||||
capabilities = result["capabilities"]
|
||||
# This would be the capability we queried for
|
||||
assert any(capability in cap for cap in capabilities)
|
||||
|
||||
|
||||
@then("the results should include agent metadata")
|
||||
def step_results_include_metadata(context):
|
||||
"""Verify query results include metadata."""
|
||||
assert hasattr(context, "capability_query_results")
|
||||
for result in context.capability_query_results:
|
||||
assert "name" in result
|
||||
assert "id" in result
|
||||
assert "type" in result
|
||||
assert "capabilities" in result
|
||||
|
||||
|
||||
@then("the agents should coordinate automatically")
|
||||
def step_agents_coordinate(context):
|
||||
"""Verify agent coordination."""
|
||||
assert hasattr(context, "coordination_result")
|
||||
assert context.coordination_result["distributed"] is True
|
||||
|
||||
|
||||
@then("the task should be distributed appropriately")
|
||||
def step_task_distributed(context):
|
||||
"""Verify task distribution."""
|
||||
assert hasattr(context, "coordination_result")
|
||||
assert context.coordination_result["agents_assigned"] > 1
|
||||
|
||||
|
||||
@then("the results should be aggregated correctly")
|
||||
def step_results_aggregated(context):
|
||||
"""Verify result aggregation."""
|
||||
assert hasattr(context, "coordination_result")
|
||||
assert context.coordination_result["status"] in ["in_progress", "completed"]
|
||||
|
||||
|
||||
@then("the agent should be created with the specified timeout")
|
||||
def step_agent_created_with_timeout(context):
|
||||
"""Verify agent creation with timeout."""
|
||||
agent_name = context.timeout_agent
|
||||
assert agent_name in context.created_agents
|
||||
agent = context.created_agents[agent_name]
|
||||
assert "timeout" in agent
|
||||
|
||||
|
||||
@then("the agent should respect timeout limits during task execution")
|
||||
def step_agent_respects_timeout(context):
|
||||
"""Verify timeout respect during execution."""
|
||||
# This would be verified during actual task execution
|
||||
# For testing, we assume the timeout configuration is respected
|
||||
agent_name = context.timeout_agent
|
||||
agent = context.created_agents[agent_name]
|
||||
timeout = agent.get("timeout", 300)
|
||||
assert timeout > 0
|
||||
|
||||
|
||||
@then("all stress test agents should be created successfully")
|
||||
def step_stress_test_success(context):
|
||||
"""Verify stress test agent creation success."""
|
||||
assert hasattr(context, "stress_test_results")
|
||||
successful = [r for r in context.stress_test_results if r["status"] == "success"]
|
||||
total = len(context.stress_test_results)
|
||||
success_rate = len(successful) / total if total > 0 else 0
|
||||
assert success_rate > 0.9, f"Success rate too low: {success_rate}"
|
||||
|
||||
|
||||
@then("system performance should remain stable")
|
||||
def step_system_stable(context):
|
||||
"""Verify system stability during stress test."""
|
||||
assert hasattr(context, "system_performance")
|
||||
assert context.system_performance["stable"] is True
|
||||
|
||||
|
||||
@then("no resource leaks should occur")
|
||||
def step_no_resource_leaks(context):
|
||||
"""Verify no resource leaks during stress test."""
|
||||
assert hasattr(context, "system_performance")
|
||||
assert context.system_performance["resource_leaks"] is False
|
||||
Reference in New Issue
Block a user