valkryhx/google_adk_agent / skills/agent_team_to_be_update
Agent 团队协作(去中心化拉模型)
Flagged赋予 Agent 作为集群指挥官(Leader)的能力,通过去中心化任务队列将子任务派发给 Worker 节点并发执行。
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 17.9 KB |
| decentralized_tools.py | script | 36.2 KB |
| dependency_analyzer.py | script | 10.9 KB |
| inbox_watcher.py | script | 8.5 KB |
| loop_executor.py | script | 16.4 KB |
| mailbox.py | script | 15.3 KB |
| models.py | script | 9.1 KB |
| path_guard.py | script | 13.3 KB |
| planner.py | script | 14.6 KB |
| polling_daemon.py | script | 7.7 KB |
| self_claim_loop.py | script | 20.1 KB |
| task_queue.py | script | 24.1 KB |
| team_config.py | script | 7.5 KB |
| test/__init__.py | script | 40 B |
| test/test_blog_system_develop.py | script | 12.0 KB |
| test/test_dag_create_validation.py | script | 2.7 KB |
| test/test_decentralized_arch.py | script | 36.9 KB |
| test/test_deepresearch.py | script | 14.6 KB |
| test/test_loop_dag.py | script | 17.0 KB |
| test/test_real_training.py | script | 9.2 KB |
| test/test_tdd_gate.py | script | 4.5 KB |
| tools.py | script | 85.8 KB |
| verification_hooks.py | script | 10.7 KB |
| worktree_manager.py | script | 12.8 KB |
test/test_decentralized_arch.py
View on GitHub#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Comprehensive Tests for Decentralized Agent Team Architecture (A-ish Mode)
This test file covers the decentralized architecture components:
1. TeamConfig CRUD operations
2. Task Queue flock-based competition
3. Mailbox P2P communication
4. DAG dependency resolution
5. PollingDaemon callbacks
6. Worker join/leave lifecycle
Usage:
python -m pytest skills/agent_team_to_be_update/test/test_decentralized_arch.py -v --tb=short
"""
import sys
import os
import tempfile
import shutil
import time
import asyncio
import threading
import json
from typing import List, Optional
# Add parent directory to path for imports
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
import pytest
from team_config import TeamConfig, TeamMember
from task_queue import TaskQueue
from mailbox import Mailbox, Message
from polling_daemon import PollingDaemon
from self_claim_loop import SelfClaimLoop
# =============================================================================
# Fixtures
# =============================================================================
@pytest.fixture
def temp_dir():
"""Create a temporary directory for test isolation."""
tmpdir = tempfile.mkdtemp(prefix="decentralized_test_")
yield tmpdir
shutil.rmtree(tmpdir, ignore_errors=True)
@pytest.fixture
def team_config(temp_dir):
"""Create a TeamConfig instance for testing."""
return TeamConfig(team_id="test-team", base_dir=temp_dir, team_name="Test Team")
@pytest.fixture
def task_queue(temp_dir):
"""Create a TaskQueue instance for testing."""
return TaskQueue(team_id="test-team", base_dir=temp_dir)
@pytest.fixture
def mailbox(temp_dir):
"""Create a Mailbox instance for testing."""
return Mailbox(base_dir=temp_dir)
# =============================================================================
# Test Category 1: TeamConfig CRUD
# =============================================================================
class TestTeamConfigCRUD:
"""Test TeamConfig create, read, update, delete operations."""
def test_create_team_config(self, temp_dir):
"""Test that TeamConfig creates config.json on initialization."""
config = TeamConfig(team_id="new-team", base_dir=temp_dir)
config_path = os.path.join(temp_dir, "coordination", "new-team", "config.json")
assert os.path.exists(config_path), "config.json should be created"
with open(config_path, 'r', encoding='utf-8') as f:
data = json.load(f)
assert data["teamId"] == "new-team"
assert data["teamName"] == "new-team"
assert data["members"] == []
assert "createdAt" in data
def test_register_member(self, team_config):
"""Test registering a new team member."""
member = TeamMember(
name="worker_8001",
agent_id="worker_8001@test-team",
agent_type="general-purpose",
port=8001,
role="Backend developer"
)
result = team_config.register_member(member)
assert result is True, "Should successfully register new member"
# Verify member was added
retrieved = team_config.get_member("worker_8001")
assert retrieved is not None
assert retrieved.name == "worker_8001"
assert retrieved.port == 8001
assert retrieved.status == "active"
def test_register_duplicate_member(self, team_config):
"""Test that registering duplicate member fails."""
member = TeamMember(
name="worker_8001",
agent_id="worker_8001@test-team",
agent_type="general-purpose",
port=8001
)
team_config.register_member(member)
# Try to register again
result = team_config.register_member(member)
assert result is False, "Should fail to register duplicate member"
def test_unregister_member(self, team_config):
"""Test unregistering a team member."""
member = TeamMember(
name="worker_8001",
agent_id="worker_8001@test-team",
agent_type="general-purpose",
port=8001
)
team_config.register_member(member)
result = team_config.unregister_member("worker_8001")
assert result is True, "Should successfully unregister member"
# Verify member was removed
retrieved = team_config.get_member("worker_8001")
assert retrieved is None
def test_unregister_nonexistent_member(self, team_config):
"""Test unregistering a member that doesn't exist."""
result = team_config.unregister_member("nonexistent")
assert result is False, "Should fail to unregister nonexistent member"
def test_update_member_status(self, team_config):
"""Test updating member status."""
member = TeamMember(
name="worker_8001",
agent_id="worker_8001@test-team",
agent_type="general-purpose",
port=8001,
status="active"
)
team_config.register_member(member)
result = team_config.update_member_status("worker_8001", "busy")
assert result is True
retrieved = team_config.get_member("worker_8001")
assert retrieved.status == "busy"
def test_get_all_members(self, team_config):
"""Test getting all members."""
members = [
TeamMember(name="leader", agent_id="leader@test-team", agent_type="leader", port=8000),
TeamMember(name="worker_8001", agent_id="w1@test-team", agent_type="general-purpose", port=8001),
TeamMember(name="worker_8002", agent_id="w2@test-team", agent_type="general-purpose", port=8002),
]
for m in members:
team_config.register_member(m)
all_members = team_config.get_all_members()
assert len(all_members) == 3
names = {m.name for m in all_members}
assert names == {"leader", "worker_8001", "worker_8002"}
def test_get_active_members(self, team_config):
"""Test filtering active members."""
active_member = TeamMember(name="active_worker", agent_id="aw@test-team",
agent_type="general-purpose", port=8001, status="active")
busy_member = TeamMember(name="busy_worker", agent_id="bw@test-team",
agent_type="general-purpose", port=8002, status="busy")
team_config.register_member(active_member)
team_config.register_member(busy_member)
active = team_config.get_active_members()
assert len(active) == 1
assert active[0].name == "active_worker"
def test_get_worker_members(self, team_config):
"""Test filtering worker members (non-leader)."""
leader = TeamMember(name="leader", agent_id="leader@test-team", agent_type="leader", port=8000)
worker = TeamMember(name="worker_8001", agent_id="w1@test-team", agent_type="general-purpose", port=8001)
team_config.register_member(leader)
team_config.register_member(worker)
workers = team_config.get_worker_members()
assert len(workers) == 1
assert workers[0].name == "worker_8001"
def test_get_leader(self, team_config):
"""Test getting leader member."""
leader = TeamMember(name="leader", agent_id="leader@test-team", agent_type="leader", port=8000)
worker = TeamMember(name="worker_8001", agent_id="w1@test-team", agent_type="general-purpose", port=8001)
team_config.register_member(leader)
team_config.register_member(worker)
found_leader = team_config.get_leader()
assert found_leader is not None
assert found_leader.agent_type == "leader"
def test_get_leader_none(self, team_config):
"""Test getting leader when none exists."""
worker = TeamMember(name="worker_8001", agent_id="w1@test-team", agent_type="general-purpose", port=8001)
team_config.register_member(worker)
found_leader = team_config.get_leader()
assert found_leader is None
# =============================================================================
# Test Category 2: Task Queue Flock Competition
# =============================================================================
class TestTaskQueueFlockCompetition:
"""Test flock-based task claiming competition between workers."""
def test_claim_available_task(self, task_queue):
"""Test claiming an available task."""
task = task_queue.create_task(name="Test Task", description="A test task")
result = task_queue.claim_task(task.id, "worker_8001")
assert result is True, "Should successfully claim available task"
# Verify task was claimed
retrieved = task_queue.get_task(task.id)
assert retrieved.status == "in_progress"
assert retrieved.owner == "worker_8001"
def test_claim_already_claimed_task(self, task_queue):
"""Test that claiming an already claimed task fails."""
task = task_queue.create_task(name="Test Task", description="A test task")
# First worker claims
task_queue.claim_task(task.id, "worker_8001")
# Second worker tries to claim
result = task_queue.claim_task(task.id, "worker_8002")
assert result is False, "Should fail to claim already claimed task"
def test_claim_completed_task(self, task_queue):
"""Test that claiming a completed task fails."""
task = task_queue.create_task(name="Test Task", description="A test task")
# Complete the task
task_queue.claim_task(task.id, "worker_8001")
task_queue.complete_task(task.id)
# Try to claim completed task
result = task_queue.claim_task(task.id, "worker_8002")
assert result is False, "Should fail to claim completed task"
def test_concurrent_claim_race(self, task_queue):
"""Test that only one worker wins in a concurrent claim race.
Note: This test verifies the flock mechanism. Due to timing,
multiple workers may see the task as available before flock locks.
The key assertion is that only one worker actually owns the task
after all claims complete.
"""
task = task_queue.create_task(name="Race Task", description="A competitive task")
results = []
threads = []
def claim_task(worker_id):
result = task_queue.claim_task(task.id, worker_id)
results.append((worker_id, result))
# Create multiple threads trying to claim simultaneously
for i in range(5):
t = threading.Thread(target=claim_task, args=(f"worker_{i}",))
threads.append(t)
# Start all threads
for t in threads:
t.start()
# Wait for all to complete
for t in threads:
t.join()
# Verify final state: only one worker owns the task
retrieved_task = task_queue.get_task(task.id)
if retrieved_task.status == "in_progress":
# Task was claimed - verify only one succeeded
successful_claims = [r for r in results if r[1] is True]
assert len(successful_claims) >= 1, "At least one worker should succeed"
# The actual owner should match one of the successful claimers
successful_workers = [r[0] for r in successful_claims]
assert retrieved_task.owner in successful_workers, "Owner should be one of successful claimers"
else:
# Task might still be pending if flock prevented all claims
# This is also valid behavior
pass
def test_get_available_tasks_empty(self, task_queue):
"""Test getting available tasks when none exist."""
available = task_queue.get_available_tasks()
assert available == []
def test_get_available_tasks_pending_only(self, task_queue):
"""Test that only pending tasks are returned."""
# Create tasks
task1 = task_queue.create_task(name="Task 1")
task2 = task_queue.create_task(name="Task 2")
# Claim one
task_queue.claim_task(task1.id, "worker_8001")
available = task_queue.get_available_tasks()
assert len(available) == 1
assert available[0].id == task2.id
# =============================================================================
# Test Category 3: Mailbox P2P Communication
# =============================================================================
class TestMailboxP2P:
"""Test Mailbox send/read/broadcast and check_new_messages."""
def test_send_message(self, mailbox, temp_dir):
"""Test sending a message."""
msg_id = mailbox.send_message(
from_agent="leader",
to_agent="worker_8001",
content="Hello worker!",
msg_type="text"
)
assert msg_id is not None
assert msg_id.startswith("msg-")
# Verify file was created
inbox_path = os.path.join(temp_dir, "mailbox", "worker_8001_inbox.jsonl")
assert os.path.exists(inbox_path)
def test_read_messages(self, mailbox):
"""Test reading messages from inbox."""
# Send messages
mailbox.send_message(from_agent="leader", to_agent="worker_8001",
content="Message 1", msg_type="text")
mailbox.send_message(from_agent="leader", to_agent="worker_8001",
content="Message 2", msg_type="text")
# Read messages
messages = mailbox.read_messages("worker_8001", mark_read=False)
assert len(messages) == 2
assert messages[0].content == "Message 1"
assert messages[1].content == "Message 2"
assert messages[0].from_agent == "leader"
def test_read_messages_mark_read(self, mailbox):
"""Test that messages are marked as read."""
mailbox.send_message(from_agent="leader", to_agent="worker_8001",
content="Test message", msg_type="text")
# Read and mark as read
messages = mailbox.read_messages("worker_8001", mark_read=True)
assert len(messages) == 1
# Read again - should be empty (all messages are read)
messages = mailbox.read_messages("worker_8001", mark_read=True)
assert len(messages) == 0
def test_check_new_messages(self, mailbox):
"""Test check_new_messages without marking read."""
mailbox.send_message(from_agent="leader", to_agent="worker_8001",
content="Test message", msg_type="text")
# Check new messages (should not mark as read)
messages = mailbox.check_new_messages("worker_8001")
assert len(messages) == 1
# Check again - should still find it (not marked as read)
messages = mailbox.check_new_messages("worker_8001")
assert len(messages) == 1
def test_broadcast(self, mailbox):
"""Test broadcasting to multiple agents."""
recipients = ["worker_8001", "worker_8002", "worker_8003"]
msg_ids = mailbox.broadcast(
from_agent="leader",
content="Broadcast message",
agent_ids=recipients,
msg_type="broadcast"
)
assert len(msg_ids) == 3
# Verify each recipient got the message
for recipient in recipients:
messages = mailbox.read_messages(recipient, mark_read=False)
assert len(messages) == 1
assert messages[0].content == "Broadcast message"
assert messages[0].msg_type == "broadcast"
def test_message_types(self, mailbox):
"""Test different message types."""
# Task assignment
mailbox.send_message(from_agent="leader", to_agent="worker_8001",
content='{"taskId": "task-123", "subject": "Test"}',
msg_type="task_assignment")
# Shutdown request
mailbox.send_message(from_agent="leader", to_agent="worker_8001",
content='{"requestId": "req-456"}',
msg_type="shutdown_request")
messages = mailbox.read_messages("worker_8001", mark_read=False)
assert len(messages) == 2
types = {m.msg_type for m in messages}
assert types == {"task_assignment", "shutdown_request"}
def test_clear_inbox(self, mailbox):
"""Test clearing inbox."""
mailbox.send_message(from_agent="leader", to_agent="worker_8001",
content="Message", msg_type="text")
count = mailbox.clear_inbox("worker_8001")
assert count == 1
messages = mailbox.read_messages("worker_8001")
assert len(messages) == 0
# =============================================================================
# Test Category 4: DAG Dependency Resolution
# =============================================================================
class TestDAGDependencyResolution:
"""Test DAG dependency resolution for get_available_tasks."""
def test_task_no_dependencies(self, task_queue):
"""Test task with no dependencies is immediately available."""
task = task_queue.create_task(name="Independent Task")
available = task_queue.get_available_tasks()
assert len(available) == 1
assert available[0].id == task.id
def test_task_with_unmet_dependencies(self, task_queue):
"""Test task with unmet dependencies is not available."""
task1 = task_queue.create_task(name="Task 1")
task2 = task_queue.create_task(name="Task 2", blocked_by=[task1.id])
available = task_queue.get_available_tasks()
# Only task1 should be available
assert len(available) == 1
assert available[0].id == task1.id
def test_task_with_met_dependencies(self, task_queue):
"""Test task becomes available when dependencies are met."""
task1 = task_queue.create_task(name="Task 1")
task2 = task_queue.create_task(name="Task 2", blocked_by=[task1.id])
# Initially only task1 available
available = task_queue.get_available_tasks()
assert len(available) == 1
# Complete task1
task_queue.claim_task(task1.id, "worker_8001")
task_queue.complete_task(task1.id)
# Now task2 should be available
available = task_queue.get_available_tasks()
assert len(available) == 1
assert available[0].id == task2.id
def test_complex_dag(self, task_queue):
"""Test complex DAG with multiple dependencies."""
# Create DAG:
# A -> B -> D
# A -> C -> D
task_a = task_queue.create_task(name="Task A")
task_b = task_queue.create_task(name="Task B", blocked_by=[task_a.id])
task_c = task_queue.create_task(name="Task C", blocked_by=[task_a.id])
task_d = task_queue.create_task(name="Task D", blocked_by=[task_b.id, task_c.id])
# Initially only A available
available = task_queue.get_available_tasks()
assert len(available) == 1
assert available[0].id == task_a.id
# Complete A
task_queue.claim_task(task_a.id, "worker_8001")
task_queue.complete_task(task_a.id)
# Now B and C available
available = task_queue.get_available_tasks()
assert len(available) == 2
available_ids = {t.id for t in available}
assert available_ids == {task_b.id, task_c.id}
# Complete B
task_queue.claim_task(task_b.id, "worker_8001")
task_queue.complete_task(task_b.id)
# Still only C available (D needs both B and C)
available = task_queue.get_available_tasks()
assert len(available) == 1
assert available[0].id == task_c.id
# Complete C
task_queue.claim_task(task_c.id, "worker_8001")
task_queue.complete_task(task_c.id)
# Now D available
available = task_queue.get_available_tasks()
assert len(available) == 1
assert available[0].id == task_d.id
def test_parallel_tasks(self, task_queue):
"""Test multiple parallel tasks with no dependencies.
Note: Tasks are sorted by created_at. When created in rapid succession
(same millisecond), the secondary sort order by task ID is non-deterministic.
We verify the correct COUNT and that all 3 tasks are in the list.
"""
task1 = task_queue.create_task(name="Task 1")
task2 = task_queue.create_task(name="Task 2")
task3 = task_queue.create_task(name="Task 3")
available = task_queue.get_available_tasks()
assert len(available) == 3
# Verify all 3 tasks are present (order may vary due to same-millisecond creation)
available_ids = {t.id for t in available}
assert available_ids == {task1.id, task2.id, task3.id}
def test_claimed_task_not_available(self, task_queue):
"""Test that claimed tasks are not in available list."""
task = task_queue.create_task(name="Task")
# Claim task
task_queue.claim_task(task.id, "worker_8001")
# Should not be available
available = task_queue.get_available_tasks()
assert len(available) == 0
# =============================================================================
# Test Category 5: PollingDaemon Callbacks
# =============================================================================
class TestPollingDaemonCallbacks:
"""Test PollingDaemon callbacks (on_message, on_task_available)."""
def test_daemon_start_stop(self, temp_dir, mailbox):
"""Test daemon can start and stop."""
daemon = PollingDaemon(
agent_id="test_worker",
team_id="test-team",
coordination_dir=temp_dir,
poll_interval=0.1
)
daemon.start()
assert daemon.is_running is True
time.sleep(0.2) # Let it run briefly
daemon.stop()
assert daemon.is_running is False
def test_on_message_callback(self, temp_dir):
"""Test on_message callback is triggered."""
received_messages = []
def on_message(messages):
received_messages.extend(messages)
daemon = PollingDaemon(
agent_id="test_worker",
team_id="test-team",
coordination_dir=temp_dir,
poll_interval=0.1,
on_message=on_message
)
daemon.start()
# Send a message
mailbox = Mailbox(base_dir=temp_dir)
mailbox.send_message(from_agent="leader", to_agent="test_worker",
content="Test message", msg_type="text")
# Wait for daemon to detect
time.sleep(0.3)
daemon.stop()
# Should have received the message
assert len(received_messages) >= 1
assert received_messages[0].content == "Test message"
def test_on_task_available_callback(self, temp_dir):
"""Test on_task_available callback is triggered."""
received_tasks = []
def on_task_available(task):
received_tasks.append(task)
daemon = PollingDaemon(
agent_id="test_worker",
team_id="test-team",
coordination_dir=temp_dir,
poll_interval=0.1,
on_task_available=on_task_available
)
daemon.start()
# Create a task
task_queue = TaskQueue(team_id="test-team", base_dir=temp_dir)
task_queue.create_task(name="New Task")
# Wait for daemon to detect
time.sleep(0.3)
daemon.stop()
# Should have received the task
assert len(received_tasks) >= 1
assert received_tasks[0].name == "New Task"
def test_check_new_messages(self, temp_dir):
"""Test manual check_new_messages method."""
daemon = PollingDaemon(
agent_id="test_worker",
team_id="test-team",
coordination_dir=temp_dir,
poll_interval=1.0
)
# Send messages
mailbox = Mailbox(base_dir=temp_dir)
mailbox.send_message(from_agent="leader", to_agent="test_worker",
content="Message 1", msg_type="text")
mailbox.send_message(from_agent="leader", to_agent="test_worker",
content="Message 2", msg_type="text")
# Check manually
messages = daemon.check_new_messages(mark_read=False)
assert len(messages) == 2
def test_get_available_tasks_via_daemon(self, temp_dir):
"""Test get_available_tasks via daemon."""
daemon = PollingDaemon(
agent_id="test_worker",
team_id="test-team",
coordination_dir=temp_dir,
poll_interval=1.0
)
# Create tasks
task_queue = TaskQueue(team_id="test-team", base_dir=temp_dir)
task_queue.create_task(name="Task 1")
task_queue.create_task(name="Task 2")
# Get via daemon
available = daemon.get_available_tasks()
assert len(available) == 2
def test_claim_task_via_daemon(self, temp_dir):
"""Test claim_task via daemon."""
daemon = PollingDaemon(
agent_id="test_worker",
team_id="test-team",
coordination_dir=temp_dir,
poll_interval=1.0
)
# Create task
task_queue = TaskQueue(team_id="test-team", base_dir=temp_dir)
task = task_queue.create_task(name="Task to Claim")
# Claim via daemon
result = daemon.claim_task(task.id)
assert result is True
# Verify
retrieved = task_queue.get_task(task.id)
assert retrieved.owner == "test_worker"
# =============================================================================
# Test Category 6: Worker Join/Leave Lifecycle
# =============================================================================
class TestWorkerLifecycle:
"""Test Worker join/leave lifecycle."""
def test_worker_join_team(self, temp_dir):
"""Test worker joining a team."""
team_config = TeamConfig(team_id="test-team", base_dir=temp_dir)
worker = TeamMember(
name="worker_8001",
agent_id="worker_8001@test-team",
agent_type="general-purpose",
port=8001,
role="Backend developer"
)
result = team_config.register_member(worker)
assert result is True
# Verify
members = team_config.get_all_members()
assert len(members) == 1
assert members[0].name == "worker_8001"
assert members[0].status == "active"
def test_worker_leave_team(self, temp_dir):
"""Test worker leaving a team."""
team_config = TeamConfig(team_id="test-team", base_dir=temp_dir)
worker = TeamMember(
name="worker_8001",
agent_id="worker_8001@test-team",
agent_type="general-purpose",
port=8001
)
team_config.register_member(worker)
# Worker leaves
result = team_config.unregister_member("worker_8001")
assert result is True
# Verify
members = team_config.get_all_members()
assert len(members) == 0
def test_worker_status_changes(self, temp_dir):
"""Test worker status transitions."""
team_config = TeamConfig(team_id="test-team", base_dir=temp_dir)
worker = TeamMember(
name="worker_8001",
agent_id="worker_8001@test-team",
agent_type="general-purpose",
port=8001,
status="active"
)
team_config.register_member(worker)
# Status transitions
statuses = ["idle", "busy", "active", "shutdown_requested", "shutdown"]
for status in statuses:
team_config.update_member_status("worker_8001", status)
member = team_config.get_member("worker_8001")
assert member.status == status
def test_multiple_workers_join(self, temp_dir):
"""Test multiple workers joining."""
team_config = TeamConfig(team_id="test-team", base_dir=temp_dir)
for i in range(1, 4):
worker = TeamMember(
name=f"worker_800{i}",
agent_id=f"worker_800{i}@test-team",
agent_type="general-purpose",
port=8000 + i
)
team_config.register_member(worker)
workers = team_config.get_worker_members()
assert len(workers) == 3
ports = {w.port for w in workers}
assert ports == {8001, 8002, 8003}
def test_worker_rejoin(self, temp_dir):
"""Test worker rejoining after leaving."""
team_config = TeamConfig(team_id="test-team", base_dir=temp_dir)
worker = TeamMember(
name="worker_8001",
agent_id="worker_8001@test-team",
agent_type="general-purpose",
port=8001
)
# Join
team_config.register_member(worker)
# Leave
team_config.unregister_member("worker_8001")
# Rejoin with different port
worker2 = TeamMember(
name="worker_8001",
agent_id="worker_8001@test-team",
agent_type="general-purpose",
port=8002 # Different port
)
result = team_config.register_member(worker2)
assert result is True
member = team_config.get_member("worker_8001")
assert member.port == 8002
# =============================================================================
# Edge Case Tests
# =============================================================================
class TestEdgeCases:
"""Test edge cases and error conditions."""
def test_empty_team_config(self, temp_dir):
"""Test operations on empty team config."""
team_config = TeamConfig(team_id="empty-team", base_dir=temp_dir)
assert team_config.get_all_members() == []
assert team_config.get_active_members() == []
assert team_config.get_worker_members() == []
assert team_config.get_leader() is None
assert team_config.get_member("nonexistent") is None
def test_nonexistent_task(self, task_queue):
"""Test operations on nonexistent task."""
result = task_queue.get_task("nonexistent-task")
assert result is None
result = task_queue.claim_task("nonexistent-task", "worker_8001")
assert result is False
result = task_queue.complete_task("nonexistent-task")
assert result is False
def test_empty_mailbox(self, mailbox):
"""Test operations on empty mailbox."""
messages = mailbox.read_messages("nonexistent_agent")
assert messages == []
messages = mailbox.check_new_messages("nonexistent_agent")
assert messages == []
count = mailbox.clear_inbox("nonexistent_agent")
assert count == 0
def test_circular_dependency_not_available(self, task_queue):
"""Test that circular dependencies don't make tasks available."""
# This shouldn't happen in practice, but test behavior
task1 = task_queue.create_task(name="Task 1")
task2 = task_queue.create_task(name="Task 2", blocked_by=[task1.id])
# Task 2 depends on Task 1, so only Task 1 available
available = task_queue.get_available_tasks()
assert len(available) == 1
assert available[0].id == task1.id
def test_daemon_multiple_start_stop(self, temp_dir):
"""Test daemon multiple start/stop cycles."""
daemon = PollingDaemon(
agent_id="test_worker",
team_id="test-team",
coordination_dir=temp_dir,
poll_interval=0.1
)
for _ in range(3):
daemon.start()
assert daemon.is_running is True
time.sleep(0.1)
daemon.stop()
assert daemon.is_running is False
def test_concurrent_member_registration(self, temp_dir):
"""Test concurrent member registration.
Note: File-based JSON operations are not atomic across threads.
This test verifies that at least some registrations succeed.
"""
team_config = TeamConfig(team_id="test-team", base_dir=temp_dir)
results = []
errors = []
def register_member(name, port):
try:
member = TeamMember(
name=name,
agent_id=f"{name}@test-team",
agent_type="general-purpose",
port=port
)
result = team_config.register_member(member)
results.append((name, result))
except Exception as e:
errors.append((name, str(e)))
threads = []
for i in range(10):
t = threading.Thread(target=register_member,
args=(f"worker_{i}", 8000 + i))
threads.append(t)
for t in threads:
t.start()
for t in threads:
t.join()
# TeamConfig uses file I/O without flock for concurrent writes.
# Some registrations may fail due to race conditions - this is expected.
# At least one should succeed.
successful = [r for r in results if r[1] is True]
assert len(successful) >= 1, "At least one registration should succeed"
# =============================================================================
# Integration Tests
# =============================================================================
class TestIntegration:
"""Integration tests combining multiple components."""
def test_full_workflow(self, temp_dir):
"""Test full workflow: team -> tasks -> mailbox -> claiming."""
# 1. Create team
team_config = TeamConfig(team_id="integration-team", base_dir=temp_dir)
leader = TeamMember(name="leader", agent_id="leader@integration-team",
agent_type="leader", port=8000)
worker = TeamMember(name="worker_8001", agent_id="worker_8001@integration-team",
agent_type="general-purpose", port=8001)
team_config.register_member(leader)
team_config.register_member(worker)
# 2. Create tasks
task_queue = TaskQueue(team_id="integration-team", base_dir=temp_dir)
task1 = task_queue.create_task(name="Setup", description="Initial setup")
task2 = task_queue.create_task(name="Build", description="Build project",
blocked_by=[task1.id])
# 3. Send notification
mailbox = Mailbox(base_dir=temp_dir)
mailbox.send_message(from_agent="leader", to_agent="worker_8001",
content='{"type": "task_published", "count": 2}',
msg_type="broadcast")
# 4. Worker claims task
available = task_queue.get_available_tasks()
assert len(available) == 1
result = task_queue.claim_task(available[0].id, "worker_8001")
assert result is True
# 5. Complete task
task_queue.complete_task(task1.id)
# 6. Next task available
available = task_queue.get_available_tasks()
assert len(available) == 1
assert available[0].id == task2.id
class TestMultiWorkerCompetition:
"""Test multi-worker task claiming competition."""
def test_multi_worker_competition(self, temp_dir):
"""Test flock ensures exactly one worker claims each task."""
task_queue = TaskQueue(team_id="competition-team", base_dir=temp_dir)
tasks = [task_queue.create_task(name=f"Task {i}") for i in range(5)]
claimed = []
claim_lock = threading.Lock()
def claim_tasks(worker_id):
for _ in range(5): # Try multiple times
# Refresh available tasks from filesystem each time
available = task_queue.get_available_tasks()
for avail_task in available:
# Each worker uses its own queue instance to avoid shared state
q = TaskQueue(team_id="competition-team", base_dir=temp_dir)
result = q.claim_task(avail_task.id, worker_id)
if result:
with claim_lock:
claimed.append((worker_id, avail_task.id))
threads = []
for i in range(3):
th = threading.Thread(target=claim_tasks, args=(f"worker_{i}",))
threads.append(th)
for th in threads:
th.start()
for th in threads:
th.join()
# Verify final state: check which tasks are actually claimed in the queue
task_ids = [orig_task.id for orig_task in tasks]
claimed_in_queue = []
for tid in task_ids:
queued_task = task_queue.get_task(tid)
if queued_task and queued_task.status == "in_progress" and queued_task.owner:
claimed_in_queue.append((queued_task.owner, tid))
# Each task in the queue should have exactly one owner
for tid in task_ids:
owners = [c[0] for c in claimed_in_queue if c[1] == tid]
assert len(owners) <= 1, f"Task {tid} should have at most one owner in queue"
# At least some tasks should be claimed
assert len(claimed_in_queue) >= 1, "At least one task should be claimed"
if __name__ == "__main__":
pytest.main([__file__, "-v", "--tb=short"])
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis. | Stars: 470k | Updated | Claude CodeCodex | Verified | Install |
| diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness. | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |