jarviscore-framework 0.1.0__py3-none-any.whl → 0.2.0__py3-none-any.whl

tests/test_08_distributed_multi_node.py

@@ -0,0 +1,454 @@
+"""
+Test 8: Distributed Mode - Multi-Node Tests
+
+Tests the P2P network layer between multiple mesh instances:
+- SWIM protocol node discovery
+- Capability announcements across nodes
+- Keepalive messaging between nodes
+- Cross-node message routing
+
+This file uses MOCKED agents (no real LLM) to test the P2P infrastructure.
+
+Run with: pytest tests/test_08_distributed_multi_node.py -v
+"""
+import asyncio
+import sys
+import pytest
+
+sys.path.insert(0, '.')
+
+from jarviscore import Mesh, Agent
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# TEST AGENTS
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class Node1Agent(Agent):
+    """Agent running on Node 1."""
+    role = "node1_worker"
+    capabilities = ["processing", "node1_specific"]
+
+    def __init__(self, agent_id=None):
+        super().__init__(agent_id)
+        self.messages_received = []
+
+    async def execute_task(self, task):
+        self.messages_received.append(task)
+        return {
+            "status": "success",
+            "output": f"Processed by {self.role} on Node 1",
+            "agent": self.agent_id
+        }
+
+
+class Node2Agent(Agent):
+    """Agent running on Node 2."""
+    role = "node2_worker"
+    capabilities = ["analysis", "node2_specific"]
+
+    def __init__(self, agent_id=None):
+        super().__init__(agent_id)
+        self.messages_received = []
+
+    async def execute_task(self, task):
+        self.messages_received.append(task)
+        return {
+            "status": "success",
+            "output": f"Analyzed by {self.role} on Node 2",
+            "agent": self.agent_id
+        }
+
+
+class SharedCapabilityAgent(Agent):
+    """Agent with shared capability (exists on both nodes)."""
+    role = "shared_worker"
+    capabilities = ["shared_capability", "common_task"]
+
+    def __init__(self, agent_id=None, node_name="unknown"):
+        super().__init__(agent_id)
+        self.node_name = node_name
+        self.tasks_executed = []
+
+    async def execute_task(self, task):
+        self.tasks_executed.append(task)
+        return {
+            "status": "success",
+            "output": f"Executed on {self.node_name}",
+            "agent": self.agent_id,
+            "node": self.node_name
+        }
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# FIXTURES
+# ═══════════════════════════════════════════════════════════════════════════════
+
+@pytest.fixture
+async def two_node_mesh():
+    """
+    Create two distributed mesh instances.
+
+    Note: Multi-node discovery requires proper SWIM seed configuration.
+    For simplicity, these tests focus on two independent nodes.
+    """
+    # Node 1
+    mesh1 = Mesh(mode="distributed", config={
+        'bind_host': '127.0.0.1',
+        'bind_port': 7970,
+        'node_name': 'node1',
+    })
+    agent1 = mesh1.add(Node1Agent)
+
+    # Node 2 (independent - no seed connection for simplicity)
+    mesh2 = Mesh(mode="distributed", config={
+        'bind_host': '127.0.0.1',
+        'bind_port': 7971,
+        'node_name': 'node2',
+    })
+    agent2 = mesh2.add(Node2Agent)
+
+    # Start both meshes sequentially with delay
+    await mesh1.start()
+    await asyncio.sleep(1.0)  # Wait for Node 1 to fully initialize
+    await mesh2.start()
+    await asyncio.sleep(0.5)  # Wait for Node 2
+
+    yield mesh1, mesh2, agent1, agent2
+
+    # Cleanup
+    await mesh2.stop()
+    await asyncio.sleep(0.5)
+    await mesh1.stop()
+
+
+@pytest.fixture
+async def single_distributed_mesh():
+    """Create a single distributed mesh for basic P2P tests."""
+    mesh = Mesh(mode="distributed", config={
+        'bind_host': '127.0.0.1',
+        'bind_port': 7972,
+        'node_name': 'test-node',
+        'keepalive_interval': 5,  # Fast keepalive for testing
+    })
+    mesh.add(Node1Agent)
+
+    await mesh.start()
+
+    yield mesh
+
+    await mesh.stop()
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# TEST CLASS: Multi-Node Discovery
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class TestMultiNodeDiscovery:
+    """Tests for node discovery via SWIM protocol."""
+
+    @pytest.mark.asyncio
+    async def test_two_nodes_start_successfully(self, two_node_mesh):
+        """Both nodes should start without errors."""
+        mesh1, mesh2, agent1, agent2 = two_node_mesh
+
+        assert mesh1._started is True
+        assert mesh2._started is True
+        assert mesh1._p2p_coordinator is not None
+        assert mesh2._p2p_coordinator is not None
+
+    @pytest.mark.asyncio
+    async def test_swim_nodes_initialized(self, two_node_mesh):
+        """SWIM nodes should be initialized on both meshes."""
+        mesh1, mesh2, agent1, agent2 = two_node_mesh
+
+        assert mesh1._p2p_coordinator.swim_manager is not None
+        assert mesh2._p2p_coordinator.swim_manager is not None
+        assert mesh1._p2p_coordinator.swim_manager.swim_node is not None
+        assert mesh2._p2p_coordinator.swim_manager.swim_node is not None
+
+    @pytest.mark.asyncio
+    async def test_nodes_discover_each_other(self, two_node_mesh):
+        """Nodes should discover each other via SWIM."""
+        mesh1, mesh2, agent1, agent2 = two_node_mesh
+
+        # Give extra time for discovery
+        await asyncio.sleep(2.0)
+
+        # Get member lists from both nodes
+        swim1 = mesh1._p2p_coordinator.swim_manager.swim_node
+        swim2 = mesh2._p2p_coordinator.swim_manager.swim_node
+
+        members1 = swim1.get_members() if hasattr(swim1, 'get_members') else []
+        members2 = swim2.get_members() if hasattr(swim2, 'get_members') else []
+
+        # At minimum, each node should see itself
+        # With discovery, they should see each other too
+        print(f"Node 1 members: {members1}")
+        print(f"Node 2 members: {members2}")
+
+        # Both nodes should be running
+        assert mesh1._p2p_coordinator._started
+        assert mesh2._p2p_coordinator._started
+
+    @pytest.mark.asyncio
+    async def test_zmq_agents_initialized(self, two_node_mesh):
+        """ZMQ agents should be initialized for messaging."""
+        mesh1, mesh2, agent1, agent2 = two_node_mesh
+
+        assert mesh1._p2p_coordinator.swim_manager.zmq_agent is not None
+        assert mesh2._p2p_coordinator.swim_manager.zmq_agent is not None
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# TEST CLASS: Capability Announcements
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class TestCapabilityAnnouncements:
+    """Tests for capability announcements across nodes."""
+
+    @pytest.mark.asyncio
+    async def test_node1_announces_capabilities(self, two_node_mesh):
+        """Node 1 should announce its capabilities."""
+        mesh1, mesh2, agent1, agent2 = two_node_mesh
+
+        cap_map = mesh1._p2p_coordinator._capability_map
+
+        # Node 1 has "processing" and "node1_specific"
+        assert "processing" in cap_map or len(cap_map) > 0
+
+    @pytest.mark.asyncio
+    async def test_node2_announces_capabilities(self, two_node_mesh):
+        """Node 2 should announce its capabilities."""
+        mesh1, mesh2, agent1, agent2 = two_node_mesh
+
+        cap_map = mesh2._p2p_coordinator._capability_map
+
+        # Node 2 has "analysis" and "node2_specific"
+        assert "analysis" in cap_map or len(cap_map) > 0
+
+    @pytest.mark.asyncio
+    async def test_capability_map_populated(self, single_distributed_mesh):
+        """Capability map should be populated after start."""
+        mesh = single_distributed_mesh
+
+        cap_map = mesh._p2p_coordinator._capability_map
+
+        # Should have capabilities from Node1Agent
+        assert len(cap_map) > 0
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# TEST CLASS: Keepalive
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class TestMultiNodeKeepalive:
+    """Tests for keepalive between nodes."""
+
+    @pytest.mark.asyncio
+    async def test_keepalive_manager_initialized(self, single_distributed_mesh):
+        """Keepalive manager should be initialized."""
+        mesh = single_distributed_mesh
+
+        assert mesh._p2p_coordinator.keepalive_manager is not None
+
+    @pytest.mark.asyncio
+    async def test_keepalive_manager_started(self, single_distributed_mesh):
+        """Keepalive manager should be started."""
+        mesh = single_distributed_mesh
+
+        km = mesh._p2p_coordinator.keepalive_manager
+        # KeepaliveManager uses _running attribute to track state
+        assert km._running is True
+
+    @pytest.mark.asyncio
+    async def test_keepalive_config_applied(self, single_distributed_mesh):
+        """Keepalive config should be applied."""
+        mesh = single_distributed_mesh
+
+        km = mesh._p2p_coordinator.keepalive_manager
+        # We set keepalive_interval to 5 in fixture
+        assert km.interval == 5
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# TEST CLASS: Multi-Node Messaging
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class TestMultiNodeMessaging:
+    """Tests for messaging between nodes."""
+
+    @pytest.mark.asyncio
+    async def test_broadcaster_initialized_on_both(self, two_node_mesh):
+        """Broadcaster should be initialized on both nodes."""
+        mesh1, mesh2, agent1, agent2 = two_node_mesh
+
+        assert mesh1._p2p_coordinator.broadcaster is not None
+        assert mesh2._p2p_coordinator.broadcaster is not None
+
+    @pytest.mark.asyncio
+    async def test_workflow_on_node1(self, two_node_mesh):
+        """Node 1 should execute workflow with its local agent."""
+        mesh1, mesh2, agent1, agent2 = two_node_mesh
+
+        results = await mesh1.workflow("node1-workflow", [
+            {"agent": "node1_worker", "task": "Process data on Node 1"}
+        ])
+
+        assert len(results) == 1
+        assert results[0]["status"] == "success"
+        assert "Node 1" in results[0]["output"]
+
+    @pytest.mark.asyncio
+    async def test_workflow_on_node2(self, two_node_mesh):
+        """Node 2 should execute workflow with its local agent."""
+        mesh1, mesh2, agent1, agent2 = two_node_mesh
+
+        results = await mesh2.workflow("node2-workflow", [
+            {"agent": "node2_worker", "task": "Analyze data on Node 2"}
+        ])
+
+        assert len(results) == 1
+        assert results[0]["status"] == "success"
+        assert "Node 2" in results[0]["output"]
+
+    @pytest.mark.asyncio
+    async def test_both_nodes_execute_independently(self, two_node_mesh):
+        """Both nodes should execute workflows independently."""
+        mesh1, mesh2, agent1, agent2 = two_node_mesh
+
+        # Execute on both nodes in parallel
+        results1, results2 = await asyncio.gather(
+            mesh1.workflow("parallel-1", [{"agent": "node1_worker", "task": "Task 1"}]),
+            mesh2.workflow("parallel-2", [{"agent": "node2_worker", "task": "Task 2"}])
+        )
+
+        assert results1[0]["status"] == "success"
+        assert results2[0]["status"] == "success"
+        assert "Node 1" in results1[0]["output"]
+        assert "Node 2" in results2[0]["output"]
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# TEST CLASS: P2P Coordinator State
+# ═══════════════════════════════════════════════════════════════════════════════
+
+class TestP2PCoordinatorState:
+    """Tests for P2P coordinator internal state."""
+
+    @pytest.mark.asyncio
+    async def test_coordinator_stores_agent_peer_clients(self, single_distributed_mesh):
+        """Coordinator should track registered peer clients."""
+        mesh = single_distributed_mesh
+
+        # In distributed mode, peer clients are registered
+        # (even though they're mainly used in p2p mode)
+        assert mesh._p2p_coordinator is not None
+
+    @pytest.mark.asyncio
+    async def test_coordinator_stop_cleans_up(self):
+        """Stopping coordinator should clean up resources."""
+        mesh = Mesh(mode="distributed", config={'bind_port': 7973})
+        mesh.add(Node1Agent)
+
+        await mesh.start()
+        assert mesh._p2p_coordinator._started is True
+
+        await mesh.stop()
+        assert mesh._p2p_coordinator._started is False
+
+    @pytest.mark.asyncio
+    async def test_multiple_starts_same_port_fails(self):
+        """Starting two meshes on same port should fail."""
+        mesh1 = Mesh(mode="distributed", config={'bind_port': 7974})
+        mesh1.add(Node1Agent)
+        await mesh1.start()
+
+        mesh2 = Mesh(mode="distributed", config={'bind_port': 7974})
+        mesh2.add(Node2Agent)
+
+        # Should fail because port is already in use
+        with pytest.raises(Exception):
+            await mesh2.start()
+
+        await mesh1.stop()
+
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# MANUAL DEMONSTRATION
+# ═══════════════════════════════════════════════════════════════════════════════
+
+async def run_multi_node_demo():
+    """Demonstrate multi-node distributed mode."""
+    print("\n" + "="*70)
+    print("DISTRIBUTED MODE - MULTI-NODE DEMONSTRATION")
+    print("="*70)
+
+    # Create Node 1 (seed)
+    print("\n[NODE 1] Creating seed node on port 7980...")
+    mesh1 = Mesh(mode="distributed", config={
+        'bind_host': '127.0.0.1',
+        'bind_port': 7980,
+        'node_name': 'node1-seed',
+    })
+    agent1 = mesh1.add(Node1Agent)
+    await mesh1.start()
+    print(f"  - Agent: {agent1.role}")
+    print(f"  - P2P Coordinator: {mesh1._p2p_coordinator is not None}")
+
+    # Create Node 2 (joins via seed)
+    print("\n[NODE 2] Creating node on port 7981, joining via seed...")
+    mesh2 = Mesh(mode="distributed", config={
+        'bind_host': '127.0.0.1',
+        'bind_port': 7981,
+        'node_name': 'node2-joiner',
+        'seed_nodes': '127.0.0.1:7980',
+    })
+    agent2 = mesh2.add(Node2Agent)
+    await mesh2.start()
+    print(f"  - Agent: {agent2.role}")
+    print(f"  - P2P Coordinator: {mesh2._p2p_coordinator is not None}")
+
+    # Give time for discovery
+    print("\n[DISCOVERY] Waiting for nodes to discover each other...")
+    await asyncio.sleep(2.0)
+
+    # Show capabilities
+    print("\n[CAPABILITIES]")
+    print(f"  Node 1 capabilities: {list(mesh1._p2p_coordinator._capability_map.keys())}")
+    print(f"  Node 2 capabilities: {list(mesh2._p2p_coordinator._capability_map.keys())}")
+
+    # Execute workflows on each node
+    print("\n[WORKFLOW] Executing on each node...")
+
+    results1 = await mesh1.workflow("demo-node1", [
+        {"agent": "node1_worker", "task": "Process data"}
+    ])
+    print(f"  Node 1 result: {results1[0]['output']}")
+
+    results2 = await mesh2.workflow("demo-node2", [
+        {"agent": "node2_worker", "task": "Analyze data"}
+    ])
+    print(f"  Node 2 result: {results2[0]['output']}")
+
+    # Parallel execution
+    print("\n[PARALLEL] Executing on both nodes simultaneously...")
+    r1, r2 = await asyncio.gather(
+        mesh1.workflow("parallel-demo-1", [{"agent": "node1_worker", "task": "Parallel 1"}]),
+        mesh2.workflow("parallel-demo-2", [{"agent": "node2_worker", "task": "Parallel 2"}])
+    )
+    print(f"  Node 1: {r1[0]['status']}")
+    print(f"  Node 2: {r2[0]['status']}")
+
+    # Cleanup
+    print("\n[CLEANUP] Stopping nodes...")
+    await mesh2.stop()
+    await mesh1.stop()
+
+    print("\n" + "="*70)
+    print("MULTI-NODE DEMONSTRATION COMPLETE")
+    print("="*70)
+
+
+if __name__ == "__main__":
+    asyncio.run(run_multi_node_demo())