feat: add unit and integration tests for mDNS.

Author: sumanjeet0012

tests/discovery/__init__.py

@@ -0,0 +1,90 @@
+"""
+Unit tests for mDNS broadcaster component.
+"""
+import socket
+import pytest
+from zeroconf import ServiceInfo, Zeroconf
+
+from libp2p.discovery.mdns.broadcaster import PeerBroadcaster
+from libp2p.peer.id import ID
+
+
+class TestPeerBroadcaster:
+    """Basic unit tests for PeerBroadcaster."""
+
+    def test_broadcaster_initialization(self):
+        """Test that broadcaster initializes correctly."""
+        zeroconf = Zeroconf()
+        service_type = "_p2p._udp.local."
+        service_name = "test-peer._p2p._udp.local."
+        peer_id = "QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN"  # String, not ID object
+        port = 8000
+
+        broadcaster = PeerBroadcaster(
+            zeroconf=zeroconf,
+            service_type=service_type,
+            service_name=service_name,
+            peer_id=peer_id,
+            port=port
+        )
+
+        assert broadcaster.zeroconf == zeroconf
+        assert broadcaster.service_type == service_type
+        assert broadcaster.service_name == service_name
+        assert broadcaster.peer_id == peer_id
+        assert broadcaster.port == port
+        
+        # Clean up
+        zeroconf.close()
+
+    def test_broadcaster_service_creation(self):
+        """Test that broadcaster creates valid service info."""
+        zeroconf = Zeroconf()
+        service_type = "_p2p._udp.local."
+        service_name = "test-peer2._p2p._udp.local."
+        peer_id_obj = ID.from_base58("QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN")
+        peer_id = str(peer_id_obj)  # Convert to string
+        port = 8000
+
+        broadcaster = PeerBroadcaster(
+            zeroconf=zeroconf,
+            service_type=service_type,
+            service_name=service_name,
+            peer_id=peer_id,
+            port=port
+        )
+
+        # Verify service was created and registered
+        service_info = broadcaster.service_info
+        assert service_info is not None
+        assert service_info.type == service_type
+        assert service_info.name == service_name
+        assert service_info.port == port
+        assert b"id" in service_info.properties
+        assert service_info.properties[b"id"] == peer_id.encode()
+        
+        # Clean up
+        zeroconf.close()
+
+    def test_broadcaster_start_stop(self):
+        """Test that broadcaster can start and stop correctly."""
+        zeroconf = Zeroconf()
+        service_type = "_p2p._udp.local."
+        service_name = "test-start-stop._p2p._udp.local."
+        peer_id_obj = ID.from_base58("QmYyQSo1c1Ym7orWxLYvCrM2EmxFTANf8wXmmE7DWjhx5N")
+        peer_id = str(peer_id_obj)  # Convert to string
+        port = 8001
+
+        broadcaster = PeerBroadcaster(
+            zeroconf=zeroconf,
+            service_type=service_type,
+            service_name=service_name,
+            peer_id=peer_id,
+            port=port
+        )
+
+        # Service should be registered
+        assert broadcaster.service_info is not None
+        
+        # Clean up
+        zeroconf.close()

tests/discovery/mdns/__init__.py

@@ -0,0 +1,128 @@
+"""
+Basic integration tests for mDNS components.
+"""
+import socket
+import pytest
+from zeroconf import ServiceInfo, Zeroconf
+
+from libp2p.discovery.mdns.broadcaster import PeerBroadcaster
+from libp2p.discovery.mdns.listener import PeerListener
+from libp2p.peer.id import ID
+from libp2p.peer.peerstore import PeerStore
+
+
+class TestMDNSIntegration:
+    """Basic integration tests for mDNS components."""
+
+    def test_broadcaster_listener_basic_integration(self):
+        """Test basic broadcaster and listener integration with actual service discovery."""
+        import time
+        
+        # Create two separate Zeroconf instances
+        zeroconf1 = Zeroconf()
+        zeroconf2 = Zeroconf()
+        
+        try:
+            # Set up broadcaster
+            broadcaster_peer_id_obj = ID.from_base58("QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN")
+            broadcaster_peer_id = str(broadcaster_peer_id_obj)  # Convert to string
+            broadcaster = PeerBroadcaster(
+                zeroconf=zeroconf1,
+                service_type="_p2p._udp.local.",
+                service_name="broadcaster-peer._p2p._udp.local.",
+                peer_id=broadcaster_peer_id,
+                port=8000
+            )
+            
+            # Set up listener
+            peerstore = PeerStore()
+            listener = PeerListener(
+                peerstore=peerstore,
+                zeroconf=zeroconf2,
+                service_type="_p2p._udp.local.",
+                service_name="listener-peer._p2p._udp.local.",
+            )
+            
+            # Verify initial state
+            assert broadcaster.service_info is not None
+            assert listener.discovered_services == {}
+            assert len(peerstore.peer_ids()) == 0
+            
+            # Broadcaster registers its service
+            broadcaster.register()
+            
+            # Simulate discovery - listener discovers the broadcaster's service
+            listener.add_service(
+                zeroconf1,  # Use broadcaster's zeroconf to find the service
+                "_p2p._udp.local.",
+                "broadcaster-peer._p2p._udp.local."
+            )
+            
+            # Verify that the listener discovered the broadcaster
+            assert len(listener.discovered_services) > 0
+            assert "broadcaster-peer._p2p._udp.local." in listener.discovered_services
+            
+            # Verify the discovered peer ID matches what was broadcast
+            discovered_peer_id = listener.discovered_services["broadcaster-peer._p2p._udp.local."]
+            assert str(discovered_peer_id) == broadcaster_peer_id
+            
+            # Verify the peer was added to the peerstore
+            assert len(peerstore.peer_ids()) > 0
+            assert discovered_peer_id in peerstore.peer_ids()
+            
+            # Verify the addresses were correctly stored
+            addrs = peerstore.addrs(discovered_peer_id)
+            assert len(addrs) > 0
+            # Should be TCP since we always use TCP protocol
+            assert "/tcp/8000" in str(addrs[0])
+            
+            print(f"✅ Integration test successful!")
+            print(f"   Broadcaster peer ID: {broadcaster_peer_id}")
+            print(f"   Discovered peer ID: {discovered_peer_id}")
+            print(f"   Discovered addresses: {[str(addr) for addr in addrs]}")
+            
+            # Clean up
+            broadcaster.unregister()
+            
+        finally:
+            zeroconf1.close()
+            zeroconf2.close()
+
+    def test_service_info_extraction(self):
+        """Test service info extraction functionality."""
+        peerstore = PeerStore()
+        zeroconf = Zeroconf()
+        
+        try:
+            listener = PeerListener(
+                peerstore=peerstore,
+                zeroconf=zeroconf,
+                service_type="_p2p._udp.local.",
+                service_name="test-listener._p2p._udp.local.",
+            )
+            
+            # Create a test service info
+            test_peer_id = ID.from_base58("QmYyQSo1c1Ym7orWxLYvCrM2EmxFTANf8wXmmE7DWjhx5N")
+            hostname = socket.gethostname()
+            
+            service_info = ServiceInfo(
+                type_="_p2p._udp.local.",
+                name="test-service._p2p._udp.local.",
+                port=8001,
+                properties={b"id": str(test_peer_id).encode()},
+                server=f"{hostname}.local.",
+                addresses=[socket.inet_aton("192.168.1.100")],
+            )
+            
+            # Test extraction
+            peer_info = listener._extract_peer_info(service_info)
+            
+            assert peer_info is not None
+            assert peer_info.peer_id == test_peer_id
+            assert len(peer_info.addrs) == 1
+            assert "/tcp/8001" in str(peer_info.addrs[0])
+            
+            # Clean up
+            
+        finally:
+            zeroconf.close()

tests/discovery/mdns/test_broadcaster.py

@@ -0,0 +1,111 @@
+"""
+Unit tests for mDNS listener component.
+"""
+import socket
+import pytest
+from zeroconf import ServiceInfo, Zeroconf
+
+from libp2p.discovery.mdns.listener import PeerListener
+from libp2p.peer.id import ID
+from libp2p.peer.peerstore import PeerStore
+from libp2p.abc import Multiaddr
+
+
+class TestPeerListener:
+    """Basic unit tests for PeerListener."""
+
+    def test_listener_initialization(self):
+        """Test that listener initializes correctly."""
+        peerstore = PeerStore()
+        zeroconf = Zeroconf()
+        service_type = "_p2p._udp.local."
+        service_name = "local-peer._p2p._udp.local."
+
+        listener = PeerListener(
+            peerstore=peerstore,
+            zeroconf=zeroconf,
+            service_type=service_type,
+            service_name=service_name,
+        )
+
+        assert listener.peerstore == peerstore
+        assert listener.zeroconf == zeroconf
+        assert listener.service_type == service_type
+        assert listener.service_name == service_name
+        assert listener.discovered_services == {}
+        
+        # Clean up
+        listener.stop()
+        zeroconf.close()
+
+    def test_listener_extract_peer_info_success(self):
+        """Test successful PeerInfo extraction from ServiceInfo."""
+        peerstore = PeerStore()
+        zeroconf = Zeroconf()
+        
+        listener = PeerListener(
+            peerstore=peerstore,
+            zeroconf=zeroconf,
+            service_type="_p2p._udp.local.",
+            service_name="local._p2p._udp.local.",
+        )
+
+        # Create sample service info
+        sample_peer_id = ID.from_base58("QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN")
+        hostname = socket.gethostname()
+        local_ip = "192.168.1.100"
+        
+        sample_service_info = ServiceInfo(
+            type_="_p2p._udp.local.",
+            name="test-peer._p2p._udp.local.",
+            port=8000,
+            properties={b"id": str(sample_peer_id).encode()},
+            server=f"{hostname}.local.",
+            addresses=[socket.inet_aton(local_ip)],
+        )
+
+        peer_info = listener._extract_peer_info(sample_service_info)
+
+        assert peer_info is not None
+        assert isinstance(peer_info.peer_id, ID)
+        assert len(peer_info.addrs) > 0
+        assert all(isinstance(addr, Multiaddr) for addr in peer_info.addrs)
+        
+        # Check that protocol is TCP since we always use TCP
+        assert "/tcp/" in str(peer_info.addrs[0])
+        
+        # Clean up
+        listener.stop()
+        zeroconf.close()
+
+    def test_listener_extract_peer_info_invalid_id(self):
+        """Test PeerInfo extraction fails with invalid peer ID."""
+        peerstore = PeerStore()
+        zeroconf = Zeroconf()
+        
+        listener = PeerListener(
+            peerstore=peerstore,
+            zeroconf=zeroconf,
+            service_type="_p2p._udp.local.",
+            service_name="local._p2p._udp.local.",
+        )
+
+        # Create service info with invalid peer ID
+        hostname = socket.gethostname()
+        local_ip = "192.168.1.100"
+        
+        service_info = ServiceInfo(
+            type_="_p2p._udp.local.",
+            name="invalid-peer._p2p._udp.local.",
+            port=8000,
+            properties={b"id": b"invalid_peer_id_format"},
+            server=f"{hostname}.local.",
+            addresses=[socket.inet_aton(local_ip)],
+        )
+
+        peer_info = listener._extract_peer_info(service_info)
+        assert peer_info is None
+        
+        # Clean up
+        listener.stop()
+        zeroconf.close()