ClaudeFlow ported, needs cleanup
This commit is contained in:
Your Name
@@ -0,0 +1,987 @@
|
||||
"""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"
|
||||
Reference in New Issue
Block a user