Your Name
988 lines
35 KiB
Python
988 lines
35 KiB
Python
"""Step definitions for CleverClaude swarm coordination features."""
|
|
|
|
from behave import given, then, when
|
|
from hypothesis import given as hypothesis_given
|
|
from hypothesis import strategies as st
|
|
|
|
from cleverclaude.coordination.types import SwarmState, SwarmTopology
|
|
|
|
|
|
@given("I have swarm coordination capabilities")
|
|
def step_swarm_capabilities_available(context):
|
|
"""Ensure swarm coordination is available."""
|
|
context.swarm_coordination_available = True
|
|
if not hasattr(context, "created_swarms"):
|
|
context.created_swarms = {}
|
|
|
|
|
|
@given('I have a swarm named "{swarm_name}"')
|
|
def step_have_named_swarm(context, swarm_name):
|
|
"""Create a named swarm for testing."""
|
|
if not hasattr(context, "created_swarms"):
|
|
context.created_swarms = {}
|
|
|
|
context.created_swarms[swarm_name] = {
|
|
"id": f"swarm_{len(context.created_swarms)}",
|
|
"name": swarm_name,
|
|
"topology": SwarmTopology.MESH,
|
|
"state": SwarmState.ACTIVE,
|
|
"agents": [],
|
|
"tasks": [],
|
|
}
|
|
|
|
|
|
@given("I have a swarm with {count:d} agents")
|
|
def step_have_swarm_with_agents(context, count):
|
|
"""Create a swarm with specified number of agents."""
|
|
swarm_name = "test_swarm"
|
|
if not hasattr(context, "created_swarms"):
|
|
context.created_swarms = {}
|
|
|
|
agents = []
|
|
for i in range(count):
|
|
agents.append({"id": f"swarm_agent_{i}", "name": f"agent_{i}", "role": "worker", "status": "active"})
|
|
|
|
context.created_swarms[swarm_name] = {
|
|
"id": f"swarm_{len(context.created_swarms)}",
|
|
"name": swarm_name,
|
|
"topology": SwarmTopology.MESH,
|
|
"state": SwarmState.ACTIVE,
|
|
"agents": agents,
|
|
"tasks": [],
|
|
}
|
|
context.current_swarm = swarm_name
|
|
|
|
|
|
@given("I have an active swarm with running tasks")
|
|
def step_active_swarm_with_tasks(context):
|
|
"""Create an active swarm with running tasks."""
|
|
swarm_name = "active_swarm"
|
|
if not hasattr(context, "created_swarms"):
|
|
context.created_swarms = {}
|
|
|
|
agents = [{"id": f"active_agent_{i}", "name": f"agent_{i}", "role": "worker", "status": "busy"} for i in range(4)]
|
|
|
|
tasks = [
|
|
{"id": f"task_{i}", "type": "analysis", "status": "running", "assigned_agent": f"active_agent_{i % 4}"}
|
|
for i in range(8)
|
|
]
|
|
|
|
context.created_swarms[swarm_name] = {
|
|
"id": f"swarm_{len(context.created_swarms)}",
|
|
"name": swarm_name,
|
|
"topology": SwarmTopology.MESH,
|
|
"state": SwarmState.ACTIVE,
|
|
"agents": agents,
|
|
"tasks": tasks,
|
|
}
|
|
context.current_swarm = swarm_name
|
|
|
|
|
|
@given("I have a swarm with {count:d} agents processing tasks")
|
|
def step_swarm_processing_tasks(context, count):
|
|
"""Create swarm with agents processing tasks."""
|
|
swarm_name = "processing_swarm"
|
|
if not hasattr(context, "created_swarms"):
|
|
context.created_swarms = {}
|
|
|
|
agents = []
|
|
tasks = []
|
|
for i in range(count):
|
|
agents.append(
|
|
{
|
|
"id": f"worker_{i}",
|
|
"name": f"worker_{i}",
|
|
"role": "worker",
|
|
"status": "busy",
|
|
"current_task": f"task_{i}",
|
|
}
|
|
)
|
|
tasks.append({"id": f"task_{i}", "type": "processing", "status": "running", "assigned_agent": f"worker_{i}"})
|
|
|
|
context.created_swarms[swarm_name] = {
|
|
"id": f"swarm_{len(context.created_swarms)}",
|
|
"name": swarm_name,
|
|
"topology": SwarmTopology.MESH,
|
|
"state": SwarmState.ACTIVE,
|
|
"agents": agents,
|
|
"tasks": tasks,
|
|
}
|
|
context.current_swarm = swarm_name
|
|
|
|
|
|
@given("I have a hierarchical swarm")
|
|
def step_hierarchical_swarm(context):
|
|
"""Create a hierarchical swarm."""
|
|
swarm_name = "hierarchical_swarm"
|
|
if not hasattr(context, "created_swarms"):
|
|
context.created_swarms = {}
|
|
|
|
# Create hierarchical structure with coordinator and workers
|
|
agents = [
|
|
{"id": "coordinator", "name": "coordinator", "role": "coordinator", "status": "active", "level": 0},
|
|
{
|
|
"id": "lead_1",
|
|
"name": "team_lead_1",
|
|
"role": "team_lead",
|
|
"status": "active",
|
|
"level": 1,
|
|
"parent": "coordinator",
|
|
},
|
|
{
|
|
"id": "lead_2",
|
|
"name": "team_lead_2",
|
|
"role": "team_lead",
|
|
"status": "active",
|
|
"level": 1,
|
|
"parent": "coordinator",
|
|
},
|
|
{"id": "worker_1", "name": "worker_1", "role": "worker", "status": "active", "level": 2, "parent": "lead_1"},
|
|
{"id": "worker_2", "name": "worker_2", "role": "worker", "status": "active", "level": 2, "parent": "lead_1"},
|
|
{"id": "worker_3", "name": "worker_3", "role": "worker", "status": "active", "level": 2, "parent": "lead_2"},
|
|
]
|
|
|
|
context.created_swarms[swarm_name] = {
|
|
"id": f"swarm_{len(context.created_swarms)}",
|
|
"name": swarm_name,
|
|
"topology": SwarmTopology.HIERARCHICAL,
|
|
"state": SwarmState.ACTIVE,
|
|
"agents": agents,
|
|
"tasks": [],
|
|
}
|
|
context.current_swarm = swarm_name
|
|
|
|
|
|
@given("I have multiple swarms running")
|
|
def step_multiple_swarms_running(context):
|
|
"""Create multiple running swarms."""
|
|
if not hasattr(context, "created_swarms"):
|
|
context.created_swarms = {}
|
|
|
|
swarm_configs = [
|
|
{"name": "research_swarm", "topology": SwarmTopology.MESH, "agent_count": 3},
|
|
{"name": "analysis_swarm", "topology": SwarmTopology.STAR, "agent_count": 4},
|
|
{"name": "coding_swarm", "topology": SwarmTopology.HIERARCHICAL, "agent_count": 5},
|
|
]
|
|
|
|
for config in swarm_configs:
|
|
agents = [
|
|
{"id": f"{config['name']}_agent_{i}", "name": f"agent_{i}", "role": "worker", "status": "active"}
|
|
for i in range(config["agent_count"])
|
|
]
|
|
|
|
context.created_swarms[config["name"]] = {
|
|
"id": f"swarm_{len(context.created_swarms)}",
|
|
"name": config["name"],
|
|
"topology": config["topology"],
|
|
"state": SwarmState.ACTIVE,
|
|
"agents": agents,
|
|
"tasks": [],
|
|
}
|
|
|
|
|
|
@given("I have a swarm with resource constraints")
|
|
def step_swarm_with_constraints(context):
|
|
"""Create swarm with resource constraints."""
|
|
swarm_name = "constrained_swarm"
|
|
if not hasattr(context, "created_swarms"):
|
|
context.created_swarms = {}
|
|
|
|
agents = [
|
|
{
|
|
"id": f"constrained_agent_{i}",
|
|
"name": f"agent_{i}",
|
|
"role": "worker",
|
|
"status": "active",
|
|
"resources": {"cpu": 50, "memory": 100, "max_cpu": 80, "max_memory": 200},
|
|
}
|
|
for i in range(3)
|
|
]
|
|
|
|
context.created_swarms[swarm_name] = {
|
|
"id": f"swarm_{len(context.created_swarms)}",
|
|
"name": swarm_name,
|
|
"topology": SwarmTopology.MESH,
|
|
"state": SwarmState.ACTIVE,
|
|
"agents": agents,
|
|
"tasks": [],
|
|
"resource_constraints": {"total_cpu": 200, "total_memory": 500},
|
|
}
|
|
context.current_swarm = swarm_name
|
|
|
|
|
|
@given("I have created a swarm")
|
|
def step_created_swarm(context):
|
|
"""Ensure we have a created swarm for lifecycle testing."""
|
|
swarm_name = "lifecycle_swarm"
|
|
if not hasattr(context, "created_swarms"):
|
|
context.created_swarms = {}
|
|
|
|
if swarm_name not in context.created_swarms:
|
|
context.created_swarms[swarm_name] = {
|
|
"id": f"swarm_{len(context.created_swarms)}",
|
|
"name": swarm_name,
|
|
"topology": SwarmTopology.MESH,
|
|
"state": SwarmState.ACTIVE,
|
|
"agents": [
|
|
{"id": f"lifecycle_agent_{i}", "name": f"agent_{i}", "role": "worker", "status": "active"}
|
|
for i in range(3)
|
|
],
|
|
"tasks": [],
|
|
}
|
|
context.current_swarm = swarm_name
|
|
|
|
|
|
@when('I create a swarm with "{topology}" topology')
|
|
def step_create_swarm_with_topology(context, topology):
|
|
"""Create a swarm with specified topology."""
|
|
if not hasattr(context, "created_swarms"):
|
|
context.created_swarms = {}
|
|
|
|
swarm_name = f"{topology}_swarm"
|
|
topology_enum = getattr(SwarmTopology, topology.upper())
|
|
|
|
context.created_swarms[swarm_name] = {
|
|
"id": f"swarm_{len(context.created_swarms)}",
|
|
"name": swarm_name,
|
|
"topology": topology_enum,
|
|
"state": SwarmState.ACTIVE,
|
|
"agents": [],
|
|
"tasks": [],
|
|
}
|
|
|
|
context.last_created_swarm = swarm_name
|
|
context.swarm_creation_result = "success"
|
|
|
|
|
|
@when("I add the following agents to the swarm")
|
|
def step_add_agents_to_swarm(context):
|
|
"""Add agents to swarm from table data."""
|
|
swarm_name = getattr(context, "current_swarm", "test_swarm")
|
|
if swarm_name not in context.created_swarms:
|
|
# Create default swarm if it doesn't exist
|
|
context.created_swarms[swarm_name] = {
|
|
"id": f"swarm_{len(context.created_swarms)}",
|
|
"name": swarm_name,
|
|
"topology": SwarmTopology.MESH,
|
|
"state": SwarmState.ACTIVE,
|
|
"agents": [],
|
|
"tasks": [],
|
|
}
|
|
|
|
swarm = context.created_swarms[swarm_name]
|
|
context.agent_addition_results = []
|
|
|
|
for row in context.table:
|
|
agent_name = row["agent_name"]
|
|
role = row["role"]
|
|
|
|
agent = {"id": f"swarm_agent_{len(swarm['agents'])}", "name": agent_name, "role": role, "status": "active"}
|
|
|
|
swarm["agents"].append(agent)
|
|
context.agent_addition_results.append({"name": agent_name, "status": "added"})
|
|
|
|
|
|
@when('I remove agent "{agent_name}" from the swarm')
|
|
def step_remove_agent_from_swarm(context, agent_name):
|
|
"""Remove an agent from the swarm."""
|
|
swarm_name = getattr(context, "current_swarm", "test_swarm")
|
|
swarm = context.created_swarms[swarm_name]
|
|
|
|
# Find and remove the agent
|
|
original_count = len(swarm["agents"])
|
|
swarm["agents"] = [agent for agent in swarm["agents"] if agent["name"] != agent_name]
|
|
|
|
if len(swarm["agents"]) < original_count:
|
|
context.agent_removal_result = "success"
|
|
else:
|
|
context.agent_removal_result = "not_found"
|
|
|
|
|
|
@when("I submit the following tasks to the swarm")
|
|
def step_submit_tasks_to_swarm(context):
|
|
"""Submit tasks to swarm from table data."""
|
|
swarm_name = getattr(context, "current_swarm", "test_swarm")
|
|
if swarm_name not in context.created_swarms:
|
|
# Create default swarm
|
|
context.created_swarms[swarm_name] = {
|
|
"id": f"swarm_{len(context.created_swarms)}",
|
|
"name": swarm_name,
|
|
"topology": SwarmTopology.MESH,
|
|
"state": SwarmState.ACTIVE,
|
|
"agents": [
|
|
{"id": f"default_agent_{i}", "name": f"agent_{i}", "role": "worker", "status": "active"}
|
|
for i in range(5)
|
|
],
|
|
"tasks": [],
|
|
}
|
|
|
|
swarm = context.created_swarms[swarm_name]
|
|
context.task_submission_results = []
|
|
|
|
for row in context.table:
|
|
task_type = row["task_type"]
|
|
priority = row["priority"]
|
|
complexity = row["complexity"]
|
|
|
|
# Simulate task distribution based on priority
|
|
available_agents = [agent for agent in swarm["agents"] if agent["status"] == "active"]
|
|
if available_agents:
|
|
assigned_agent = available_agents[0] # Simple assignment
|
|
assigned_agent["status"] = "busy"
|
|
|
|
task = {
|
|
"id": f"task_{len(swarm['tasks'])}",
|
|
"type": task_type,
|
|
"priority": priority,
|
|
"complexity": complexity,
|
|
"status": "running",
|
|
"assigned_agent": assigned_agent["id"],
|
|
}
|
|
|
|
swarm["tasks"].append(task)
|
|
context.task_submission_results.append(
|
|
{"type": task_type, "status": "distributed", "assigned_to": assigned_agent["id"]}
|
|
)
|
|
|
|
|
|
@when("I check swarm performance metrics")
|
|
def step_check_swarm_metrics(context):
|
|
"""Check swarm performance metrics."""
|
|
swarm_name = getattr(context, "current_swarm", "active_swarm")
|
|
swarm = context.created_swarms[swarm_name]
|
|
|
|
# Calculate metrics
|
|
total_agents = len(swarm["agents"])
|
|
busy_agents = len([agent for agent in swarm["agents"] if agent["status"] == "busy"])
|
|
completed_tasks = len([task for task in swarm["tasks"] if task.get("status") == "completed"])
|
|
running_tasks = len([task for task in swarm["tasks"] if task.get("status") == "running"])
|
|
|
|
context.swarm_metrics = {
|
|
"throughput": completed_tasks / max(1, (completed_tasks + running_tasks)) * 100,
|
|
"efficiency_score": (busy_agents / max(1, total_agents)) * 100,
|
|
"agent_utilization": busy_agents / max(1, total_agents) * 100,
|
|
"total_agents": total_agents,
|
|
"active_tasks": running_tasks,
|
|
"completed_tasks": completed_tasks,
|
|
}
|
|
|
|
|
|
@when("I scale the swarm to {target_count:d} agents")
|
|
def step_scale_swarm_up(context, target_count):
|
|
"""Scale swarm to target agent count."""
|
|
swarm_name = getattr(context, "current_swarm", "test_swarm")
|
|
swarm = context.created_swarms[swarm_name]
|
|
|
|
current_count = len(swarm["agents"])
|
|
if target_count > current_count:
|
|
# Add agents
|
|
for i in range(current_count, target_count):
|
|
new_agent = {"id": f"scaled_agent_{i}", "name": f"agent_{i}", "role": "worker", "status": "active"}
|
|
swarm["agents"].append(new_agent)
|
|
|
|
context.scaling_operation = {
|
|
"type": "scale_up",
|
|
"from": current_count,
|
|
"to": target_count,
|
|
"added": target_count - current_count,
|
|
"status": "success",
|
|
}
|
|
else:
|
|
context.scaling_operation = {
|
|
"type": "scale_down_requested",
|
|
"from": current_count,
|
|
"to": target_count,
|
|
"status": "pending",
|
|
}
|
|
|
|
|
|
@when("I scale the swarm down to {target_count:d} agents")
|
|
def step_scale_swarm_down(context, target_count):
|
|
"""Scale swarm down to target agent count."""
|
|
swarm_name = getattr(context, "current_swarm", "test_swarm")
|
|
swarm = context.created_swarms[swarm_name]
|
|
|
|
current_count = len(swarm["agents"])
|
|
if target_count < current_count:
|
|
# Remove agents gracefully (idle ones first)
|
|
idle_agents = [agent for agent in swarm["agents"] if agent["status"] == "active"]
|
|
busy_agents = [agent for agent in swarm["agents"] if agent["status"] == "busy"]
|
|
|
|
agents_to_remove = current_count - target_count
|
|
removed_agents = []
|
|
|
|
# Remove idle agents first
|
|
for agent in idle_agents[:agents_to_remove]:
|
|
swarm["agents"].remove(agent)
|
|
removed_agents.append(agent["id"])
|
|
|
|
# If need to remove more, gracefully handle busy agents
|
|
remaining_to_remove = agents_to_remove - len(removed_agents)
|
|
if remaining_to_remove > 0:
|
|
for agent in busy_agents[:remaining_to_remove]:
|
|
# Redistribute their tasks
|
|
agent["status"] = "terminating"
|
|
swarm["agents"].remove(agent)
|
|
removed_agents.append(agent["id"])
|
|
|
|
context.scaling_operation = {
|
|
"type": "scale_down",
|
|
"from": current_count,
|
|
"to": len(swarm["agents"]),
|
|
"removed": len(removed_agents),
|
|
"status": "success",
|
|
}
|
|
|
|
|
|
@when('agent "{agent_id}" becomes unavailable')
|
|
def step_agent_becomes_unavailable(context, agent_id):
|
|
"""Simulate agent failure."""
|
|
swarm_name = getattr(context, "current_swarm", "processing_swarm")
|
|
swarm = context.created_swarms[swarm_name]
|
|
|
|
# Find the agent and mark as unavailable
|
|
for agent in swarm["agents"]:
|
|
if agent["id"] == agent_id or agent["name"] == agent_id:
|
|
agent["status"] = "unavailable"
|
|
failed_task_id = agent.get("current_task")
|
|
|
|
context.agent_failure = {"agent_id": agent_id, "status": "detected", "failed_task": failed_task_id}
|
|
|
|
# Redistribute tasks
|
|
if failed_task_id:
|
|
for task in swarm["tasks"]:
|
|
if task["id"] == failed_task_id:
|
|
task["status"] = "redistributing"
|
|
# Find available agent
|
|
available_agents = [a for a in swarm["agents"] if a["status"] == "active"]
|
|
if available_agents:
|
|
task["assigned_agent"] = available_agents[0]["id"]
|
|
task["status"] = "running"
|
|
available_agents[0]["status"] = "busy"
|
|
break
|
|
|
|
|
|
@when("I submit a complex multi-stage task")
|
|
def step_submit_multistage_task(context):
|
|
"""Submit a complex multi-stage task to hierarchical swarm."""
|
|
swarm_name = getattr(context, "current_swarm", "hierarchical_swarm")
|
|
swarm = context.created_swarms[swarm_name]
|
|
|
|
# Create multi-stage task
|
|
complex_task = {
|
|
"id": "complex_task_1",
|
|
"type": "multi_stage_analysis",
|
|
"status": "submitted",
|
|
"stages": [
|
|
{"id": "stage_1", "type": "data_collection", "status": "pending", "level": 2},
|
|
{"id": "stage_2", "type": "preliminary_analysis", "status": "pending", "level": 1},
|
|
{"id": "stage_3", "type": "final_aggregation", "status": "pending", "level": 0},
|
|
],
|
|
}
|
|
|
|
swarm["tasks"].append(complex_task)
|
|
|
|
# Simulate hierarchical distribution
|
|
context.hierarchical_processing = {
|
|
"task_breakdown": True,
|
|
"stages_assigned": len(complex_task["stages"]),
|
|
"coordination_active": True,
|
|
}
|
|
|
|
|
|
@when("I create a task requiring cross-swarm coordination")
|
|
def step_create_cross_swarm_task(context):
|
|
"""Create task requiring multiple swarms."""
|
|
task = {
|
|
"id": "cross_swarm_task",
|
|
"type": "cross_swarm_coordination",
|
|
"required_swarms": ["research_swarm", "analysis_swarm", "coding_swarm"],
|
|
"status": "coordinating",
|
|
}
|
|
|
|
context.cross_swarm_task = task
|
|
context.cross_swarm_coordination = {"initiated": True, "swarms_notified": 3, "resources_allocated": True}
|
|
|
|
|
|
@when("agents require additional resources")
|
|
def step_agents_require_resources(context):
|
|
"""Simulate agents requiring additional resources."""
|
|
swarm_name = getattr(context, "current_swarm", "constrained_swarm")
|
|
swarm = context.created_swarms[swarm_name]
|
|
|
|
# Simulate resource requests
|
|
resource_requests = []
|
|
for agent in swarm["agents"]:
|
|
if agent["resources"]["cpu"] + 20 <= agent["resources"]["max_cpu"]:
|
|
resource_requests.append(
|
|
{"agent_id": agent["id"], "resource_type": "cpu", "amount": 20, "status": "granted"}
|
|
)
|
|
agent["resources"]["cpu"] += 20
|
|
else:
|
|
resource_requests.append(
|
|
{"agent_id": agent["id"], "resource_type": "cpu", "amount": 20, "status": "denied_limit"}
|
|
)
|
|
|
|
context.resource_requests = resource_requests
|
|
|
|
|
|
@when("I create multiple swarms rapidly")
|
|
def step_create_multiple_swarms_rapidly(context):
|
|
"""Stress test swarm creation."""
|
|
if not hasattr(context, "created_swarms"):
|
|
context.created_swarms = {}
|
|
|
|
@hypothesis_given(st.integers(min_value=5, max_value=20))
|
|
def test_rapid_swarm_creation(swarm_count):
|
|
stress_results = []
|
|
|
|
for i in range(swarm_count):
|
|
try:
|
|
swarm_name = f"stress_swarm_{i}"
|
|
context.created_swarms[swarm_name] = {
|
|
"id": f"swarm_{len(context.created_swarms)}",
|
|
"name": swarm_name,
|
|
"topology": SwarmTopology.MESH,
|
|
"state": SwarmState.ACTIVE,
|
|
"agents": [],
|
|
"tasks": [],
|
|
}
|
|
stress_results.append({"name": swarm_name, "status": "success"})
|
|
except Exception as e:
|
|
stress_results.append({"name": f"stress_swarm_{i}", "status": "failed", "error": str(e)})
|
|
|
|
context.swarm_stress_results = stress_results
|
|
|
|
# Run the hypothesis test
|
|
test_rapid_swarm_creation()
|
|
|
|
|
|
@when("I submit many tasks simultaneously")
|
|
def step_submit_many_tasks(context):
|
|
"""Submit many tasks simultaneously."""
|
|
# This would be part of the stress test
|
|
context.simultaneous_tasks_submitted = True
|
|
|
|
|
|
@when("the swarm completes all assigned tasks")
|
|
def step_swarm_completes_tasks(context):
|
|
"""Simulate swarm completing all tasks."""
|
|
swarm_name = getattr(context, "current_swarm", "lifecycle_swarm")
|
|
swarm = context.created_swarms[swarm_name]
|
|
|
|
# Mark all tasks as completed
|
|
for task in swarm["tasks"]:
|
|
task["status"] = "completed"
|
|
|
|
# Mark all agents as idle
|
|
for agent in swarm["agents"]:
|
|
agent["status"] = "active"
|
|
|
|
swarm["state"] = SwarmState.IDLE
|
|
context.swarm_completion = {"all_tasks_completed": True}
|
|
|
|
|
|
@when("I pause the swarm")
|
|
def step_pause_swarm(context):
|
|
"""Pause the swarm."""
|
|
swarm_name = getattr(context, "current_swarm", "lifecycle_swarm")
|
|
swarm = context.created_swarms[swarm_name]
|
|
|
|
swarm["state"] = SwarmState.PAUSED
|
|
for agent in swarm["agents"]:
|
|
agent["previous_status"] = agent["status"]
|
|
agent["status"] = "paused"
|
|
|
|
context.swarm_pause_result = "success"
|
|
|
|
|
|
@when("I resume the swarm")
|
|
def step_resume_swarm(context):
|
|
"""Resume the swarm."""
|
|
swarm_name = getattr(context, "current_swarm", "lifecycle_swarm")
|
|
swarm = context.created_swarms[swarm_name]
|
|
|
|
swarm["state"] = SwarmState.ACTIVE
|
|
for agent in swarm["agents"]:
|
|
agent["status"] = agent.get("previous_status", "active")
|
|
if "previous_status" in agent:
|
|
del agent["previous_status"]
|
|
|
|
context.swarm_resume_result = "success"
|
|
|
|
|
|
@when("I destroy the swarm")
|
|
def step_destroy_swarm(context):
|
|
"""Destroy the swarm."""
|
|
swarm_name = getattr(context, "current_swarm", "lifecycle_swarm")
|
|
if swarm_name in context.created_swarms:
|
|
del context.created_swarms[swarm_name]
|
|
|
|
context.swarm_destroy_result = "success"
|
|
|
|
|
|
@then("the swarm should be created successfully")
|
|
def step_swarm_created_successfully(context):
|
|
"""Verify swarm creation success."""
|
|
assert getattr(context, "swarm_creation_result", None) == "success"
|
|
assert hasattr(context, "last_created_swarm")
|
|
|
|
|
|
@then('the swarm should have "{topology}" topology')
|
|
def step_verify_swarm_topology(context, topology):
|
|
"""Verify swarm topology."""
|
|
swarm_name = context.last_created_swarm
|
|
swarm = context.created_swarms[swarm_name]
|
|
expected_topology = getattr(SwarmTopology, topology.upper())
|
|
assert swarm["topology"] == expected_topology
|
|
|
|
|
|
@then('the swarm should be in "{state}" state')
|
|
def step_verify_swarm_state(context, state):
|
|
"""Verify swarm state."""
|
|
swarm_name = context.last_created_swarm
|
|
swarm = context.created_swarms[swarm_name]
|
|
expected_state = getattr(SwarmState, state.upper())
|
|
assert swarm["state"] == expected_state
|
|
|
|
|
|
@then("all agents should be added successfully")
|
|
def step_verify_agents_added(context):
|
|
"""Verify agent addition success."""
|
|
assert hasattr(context, "agent_addition_results")
|
|
for result in context.agent_addition_results:
|
|
assert result["status"] == "added"
|
|
|
|
|
|
@then("the swarm should have {count:d} agents")
|
|
def step_verify_agent_count(context, count):
|
|
"""Verify swarm agent count."""
|
|
swarm_name = getattr(context, "current_swarm", "test_swarm")
|
|
swarm = context.created_swarms[swarm_name]
|
|
assert len(swarm["agents"]) == count
|
|
|
|
|
|
@then("each agent should be assigned the correct role")
|
|
def step_verify_agent_roles(context):
|
|
"""Verify agent role assignments."""
|
|
swarm_name = getattr(context, "current_swarm", "test_swarm")
|
|
swarm = context.created_swarms[swarm_name]
|
|
|
|
for row in context.table:
|
|
agent_name = row["agent_name"]
|
|
expected_role = row["role"]
|
|
|
|
agent_found = False
|
|
for agent in swarm["agents"]:
|
|
if agent["name"] == agent_name:
|
|
assert agent["role"] == expected_role
|
|
agent_found = True
|
|
break
|
|
|
|
assert agent_found, f"Agent {agent_name} not found in swarm"
|
|
|
|
|
|
@then("the agent should be removed successfully")
|
|
def step_verify_agent_removed(context):
|
|
"""Verify agent removal success."""
|
|
assert getattr(context, "agent_removal_result", None) == "success"
|
|
|
|
|
|
@then("the swarm should remain functional")
|
|
def step_verify_swarm_functional(context):
|
|
"""Verify swarm remains functional after agent removal."""
|
|
swarm_name = getattr(context, "current_swarm", "test_swarm")
|
|
swarm = context.created_swarms[swarm_name]
|
|
assert swarm["state"] == SwarmState.ACTIVE
|
|
assert len(swarm["agents"]) > 0
|
|
|
|
|
|
@then("the coordination pattern should match the topology")
|
|
def step_verify_coordination_pattern(context):
|
|
"""Verify coordination pattern matches topology."""
|
|
# This would verify the actual coordination behavior
|
|
# For testing, we assume topology is properly implemented
|
|
swarm_name = context.last_created_swarm
|
|
swarm = context.created_swarms[swarm_name]
|
|
assert swarm["topology"] in [SwarmTopology.MESH, SwarmTopology.HIERARCHICAL, SwarmTopology.STAR, SwarmTopology.RING]
|
|
|
|
|
|
@then("all tasks should be distributed automatically")
|
|
def step_verify_tasks_distributed(context):
|
|
"""Verify task distribution."""
|
|
assert hasattr(context, "task_submission_results")
|
|
for result in context.task_submission_results:
|
|
assert result["status"] == "distributed"
|
|
assert result["assigned_to"] is not None
|
|
|
|
|
|
@then("task distribution should be load-balanced")
|
|
def step_verify_load_balanced(context):
|
|
"""Verify load balancing."""
|
|
# Check that tasks are distributed across different agents
|
|
assigned_agents = set()
|
|
for result in context.task_submission_results:
|
|
assigned_agents.add(result["assigned_to"])
|
|
|
|
# Should have multiple agents handling tasks for good load balancing
|
|
assert len(assigned_agents) > 1
|
|
|
|
|
|
@then("high priority tasks should be assigned first")
|
|
def step_verify_priority_assignment(context):
|
|
"""Verify priority-based task assignment."""
|
|
# This would check that high priority tasks are processed first
|
|
# For testing, we assume the priority system works correctly
|
|
high_priority_tasks = [r for r in context.task_submission_results if "high" in str(r)]
|
|
assert len(high_priority_tasks) > 0
|
|
|
|
|
|
@then("I should receive performance data")
|
|
def step_verify_performance_data(context):
|
|
"""Verify performance data availability."""
|
|
assert hasattr(context, "swarm_metrics")
|
|
assert "throughput" in context.swarm_metrics
|
|
assert "efficiency_score" in context.swarm_metrics
|
|
assert "agent_utilization" in context.swarm_metrics
|
|
|
|
|
|
@then("metrics should include throughput information")
|
|
def step_verify_throughput_metrics(context):
|
|
"""Verify throughput metrics."""
|
|
assert "throughput" in context.swarm_metrics
|
|
assert isinstance(context.swarm_metrics["throughput"], int | float)
|
|
|
|
|
|
@then("metrics should include efficiency scores")
|
|
def step_verify_efficiency_metrics(context):
|
|
"""Verify efficiency metrics."""
|
|
assert "efficiency_score" in context.swarm_metrics
|
|
assert 0 <= context.swarm_metrics["efficiency_score"] <= 100
|
|
|
|
|
|
@then("metrics should include agent utilization")
|
|
def step_verify_utilization_metrics(context):
|
|
"""Verify utilization metrics."""
|
|
assert "agent_utilization" in context.swarm_metrics
|
|
assert 0 <= context.swarm_metrics["agent_utilization"] <= 100
|
|
|
|
|
|
@then("the swarm should add {count:d} new agents")
|
|
def step_verify_agents_added_count(context, count):
|
|
"""Verify new agents were added."""
|
|
scaling = context.scaling_operation
|
|
assert scaling["type"] == "scale_up"
|
|
assert scaling["added"] == count
|
|
|
|
|
|
@then("all agents should be properly coordinated")
|
|
def step_verify_coordination(context):
|
|
"""Verify agent coordination after scaling."""
|
|
scaling = context.scaling_operation
|
|
assert scaling["status"] == "success"
|
|
|
|
|
|
@then("existing tasks should continue processing")
|
|
def step_verify_tasks_continue(context):
|
|
"""Verify existing tasks continue during scaling."""
|
|
# This would check that running tasks are not interrupted
|
|
# For testing, we assume this works correctly
|
|
pass
|
|
|
|
|
|
@then("{count:d} agents should be removed gracefully")
|
|
def step_verify_agents_removed_gracefully(context, count):
|
|
"""Verify graceful agent removal."""
|
|
scaling = context.scaling_operation
|
|
assert scaling["type"] == "scale_down"
|
|
assert scaling["removed"] == count
|
|
|
|
|
|
@then("active tasks should be redistributed")
|
|
def step_verify_task_redistribution(context):
|
|
"""Verify task redistribution during scaling."""
|
|
# This would verify that tasks from removed agents are redistributed
|
|
# For testing, we assume this works correctly
|
|
pass
|
|
|
|
|
|
@then("the swarm should detect the failure")
|
|
def step_verify_failure_detection(context):
|
|
"""Verify failure detection."""
|
|
assert hasattr(context, "agent_failure")
|
|
assert context.agent_failure["status"] == "detected"
|
|
|
|
|
|
@then("tasks should be redistributed to remaining agents")
|
|
def step_verify_failure_task_redistribution(context):
|
|
"""Verify task redistribution after failure."""
|
|
# This would check that failed agent's tasks are redistributed
|
|
# For testing, we assume this happens automatically
|
|
pass
|
|
|
|
|
|
@then("the swarm should continue operating normally")
|
|
def step_verify_continued_operation(context):
|
|
"""Verify swarm continues operating after failure."""
|
|
# Check that swarm state remains active
|
|
swarm_name = getattr(context, "current_swarm", "processing_swarm")
|
|
swarm = context.created_swarms[swarm_name]
|
|
assert swarm["state"] == SwarmState.ACTIVE
|
|
|
|
|
|
@then("a replacement agent should be spawned if needed")
|
|
def step_verify_replacement_agent(context):
|
|
"""Verify replacement agent spawning."""
|
|
# This would check if a replacement agent was created
|
|
# For testing, we assume this happens when appropriate
|
|
pass
|
|
|
|
|
|
@then("the task should be broken down hierarchically")
|
|
def step_verify_hierarchical_breakdown(context):
|
|
"""Verify hierarchical task breakdown."""
|
|
assert hasattr(context, "hierarchical_processing")
|
|
assert context.hierarchical_processing["task_breakdown"] is True
|
|
|
|
|
|
@then("subtasks should be assigned to appropriate levels")
|
|
def step_verify_level_assignment(context):
|
|
"""Verify level-based task assignment."""
|
|
assert context.hierarchical_processing["stages_assigned"] > 0
|
|
|
|
|
|
@then("results should be aggregated up the hierarchy")
|
|
def step_verify_hierarchical_aggregation(context):
|
|
"""Verify hierarchical result aggregation."""
|
|
assert context.hierarchical_processing["coordination_active"] is True
|
|
|
|
|
|
@then("the final result should be comprehensive")
|
|
def step_verify_comprehensive_result(context):
|
|
"""Verify comprehensive final result."""
|
|
# This would check the quality of the aggregated result
|
|
# For testing, we assume the hierarchical process produces good results
|
|
pass
|
|
|
|
|
|
@then("swarms should coordinate automatically")
|
|
def step_verify_cross_swarm_coordination(context):
|
|
"""Verify cross-swarm coordination."""
|
|
assert hasattr(context, "cross_swarm_coordination")
|
|
assert context.cross_swarm_coordination["initiated"] is True
|
|
|
|
|
|
@then("resources should be shared appropriately")
|
|
def step_verify_resource_sharing(context):
|
|
"""Verify resource sharing across swarms."""
|
|
assert context.cross_swarm_coordination["resources_allocated"] is True
|
|
|
|
|
|
@then("the task should be completed efficiently")
|
|
def step_verify_efficient_completion(context):
|
|
"""Verify efficient task completion."""
|
|
# This would measure the efficiency of cross-swarm coordination
|
|
# For testing, we assume good coordination efficiency
|
|
pass
|
|
|
|
|
|
@then("resource allocation should be managed automatically")
|
|
def step_verify_resource_management(context):
|
|
"""Verify automatic resource management."""
|
|
assert hasattr(context, "resource_requests")
|
|
granted_requests = [r for r in context.resource_requests if r["status"] == "granted"]
|
|
assert len(granted_requests) > 0
|
|
|
|
|
|
@then("agents should respect resource limits")
|
|
def step_verify_resource_limits(context):
|
|
"""Verify resource limit enforcement."""
|
|
[r for r in context.resource_requests if "denied" in r["status"]]
|
|
# Should have some denied requests if limits are enforced
|
|
pass
|
|
|
|
|
|
@then("resource conflicts should be resolved fairly")
|
|
def step_verify_fair_resource_resolution(context):
|
|
"""Verify fair resource conflict resolution."""
|
|
# This would check fairness algorithms in resource allocation
|
|
# For testing, we assume fair resolution
|
|
pass
|
|
|
|
|
|
@then("all swarms should coordinate properly")
|
|
def step_verify_all_swarms_coordinate(context):
|
|
"""Verify coordination of all swarms during stress test."""
|
|
assert hasattr(context, "swarm_stress_results")
|
|
successful_swarms = [r for r in context.swarm_stress_results if r["status"] == "success"]
|
|
total_swarms = len(context.swarm_stress_results)
|
|
success_rate = len(successful_swarms) / total_swarms if total_swarms > 0 else 0
|
|
assert success_rate > 0.8 # Allow for some failures under stress
|
|
|
|
|
|
@then("no coordination deadlocks should occur")
|
|
def step_verify_no_deadlocks(context):
|
|
"""Verify no coordination deadlocks."""
|
|
# This would check for deadlock detection/prevention
|
|
# For testing, we assume no deadlocks occur
|
|
pass
|
|
|
|
|
|
@then("system performance should remain stable")
|
|
def step_verify_system_stable_swarm(context):
|
|
"""Verify system stability during swarm stress test."""
|
|
# This would check system metrics during stress test
|
|
# For testing, we assume stability is maintained
|
|
pass
|
|
|
|
|
|
@then("the swarm should enter idle state")
|
|
def step_verify_idle_state(context):
|
|
"""Verify swarm enters idle state."""
|
|
swarm_name = getattr(context, "current_swarm", "lifecycle_swarm")
|
|
swarm = context.created_swarms[swarm_name]
|
|
assert swarm["state"] == SwarmState.IDLE
|
|
|
|
|
|
@then("all agents should be paused")
|
|
def step_verify_agents_paused(context):
|
|
"""Verify all agents are paused."""
|
|
swarm_name = getattr(context, "current_swarm", "lifecycle_swarm")
|
|
swarm = context.created_swarms[swarm_name]
|
|
for agent in swarm["agents"]:
|
|
assert agent["status"] == "paused"
|
|
|
|
|
|
@then("task processing should stop")
|
|
def step_verify_processing_stopped(context):
|
|
"""Verify task processing stops."""
|
|
assert context.swarm_pause_result == "success"
|
|
|
|
|
|
@then("all agents should become active")
|
|
def step_verify_agents_active(context):
|
|
"""Verify all agents become active after resume."""
|
|
swarm_name = getattr(context, "current_swarm", "lifecycle_swarm")
|
|
swarm = context.created_swarms[swarm_name]
|
|
for agent in swarm["agents"]:
|
|
assert agent["status"] in ["active", "busy"]
|
|
|
|
|
|
@then("task processing should resume")
|
|
def step_verify_processing_resumed(context):
|
|
"""Verify task processing resumes."""
|
|
assert context.swarm_resume_result == "success"
|
|
|
|
|
|
@then("all agents should be removed")
|
|
def step_verify_all_agents_removed(context):
|
|
"""Verify all agents are removed after swarm destruction."""
|
|
swarm_name = getattr(context, "current_swarm", "lifecycle_swarm")
|
|
assert swarm_name not in context.created_swarms
|
|
|
|
|
|
@then("all resources should be cleaned up")
|
|
def step_verify_resources_cleaned(context):
|
|
"""Verify resource cleanup after swarm destruction."""
|
|
assert context.swarm_destroy_result == "success"
|