learningcircuit--local-deep-research/tests/web/services/test_socket_service_extended.py

# allow: no-sut-import — black-box HTTP test; drives real routes through the Flask test client
"""
Extended Tests for Socket Service

Phase 19: Socket & Real-time Services - Socket Service Tests
Tests socket connections, emissions, and subscription management.
"""

from unittest.mock import patch, MagicMock
import threading


class TestSocketConnection:
    """Tests for socket connection functionality"""

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_socket_connect_authenticated(self, mock_service_cls):
        """Test authenticated socket connection"""
        mock_service = MagicMock()
        mock_service._SocketIOService__handle_connect.return_value = {
            "connected": True,
            "session_id": "session_123",
        }

        mock_request = MagicMock()
        mock_request.sid = "client_123"

        result = mock_service._SocketIOService__handle_connect(mock_request)

        assert result["connected"] is True

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_socket_connect_unauthenticated(self, mock_service_cls):
        """Test unauthenticated socket connection"""
        mock_service = MagicMock()
        mock_service._SocketIOService__handle_connect.return_value = {
            "connected": True,
            "anonymous": True,
        }

        mock_request = MagicMock()
        mock_request.sid = "anon_123"

        result = mock_service._SocketIOService__handle_connect(mock_request)

        assert result["connected"] is True

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_socket_disconnect_cleanup(self, mock_service_cls):
        """Test cleanup on disconnect"""
        mock_service = MagicMock()
        mock_service._SocketIOService__socket_subscriptions = {
            "research_1": {"client_123"},
            "research_2": {"client_123", "client_456"},
        }

        mock_service._SocketIOService__handle_disconnect.return_value = {
            "cleaned_up": True,
            "subscriptions_removed": 2,
        }

        result = mock_service._SocketIOService__handle_disconnect(
            MagicMock(sid="client_123"), "client disconnect"
        )

        assert result["cleaned_up"] is True

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_socket_reconnect_handling(self, mock_service_cls):
        """Test reconnection handling"""
        mock_service = MagicMock()
        mock_service._handle_reconnect.return_value = {
            "reconnected": True,
            "subscriptions_restored": 3,
        }

        result = mock_service._handle_reconnect("client_123")

        assert result["reconnected"] is True

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_socket_session_binding(self, mock_service_cls):
        """Test session binding to socket"""
        mock_service = MagicMock()
        mock_service._bind_session.return_value = {
            "bound": True,
            "user_id": "user_123",
        }

        result = mock_service._bind_session("socket_123", "session_abc")

        assert result["bound"] is True

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_socket_namespace_isolation(self, mock_service_cls):
        """Test namespace isolation"""
        mock_service = MagicMock()
        mock_service._check_namespace_access.return_value = True

        has_access = mock_service._check_namespace_access(
            "client_123", "/research"
        )

        assert has_access is True

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_socket_room_join(self, mock_service_cls):
        """Test joining a room"""
        mock_service = MagicMock()
        mock_service._join_room.return_value = {
            "joined": True,
            "room": "research_123",
        }

        result = mock_service._join_room("client_123", "research_123")

        assert result["joined"] is True

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_socket_room_leave(self, mock_service_cls):
        """Test leaving a room"""
        mock_service = MagicMock()
        mock_service._leave_room.return_value = {
            "left": True,
            "room": "research_123",
        }

        result = mock_service._leave_room("client_123", "research_123")

        assert result["left"] is True

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_socket_connection_timeout(self, mock_service_cls):
        """Test connection timeout handling"""
        mock_service = MagicMock()
        mock_service._handle_timeout.return_value = {
            "disconnected": True,
            "reason": "ping_timeout",
        }

        result = mock_service._handle_timeout("client_123")

        assert result["disconnected"] is True

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_socket_heartbeat_mechanism(self, mock_service_cls):
        """Test heartbeat/ping mechanism"""
        mock_service = MagicMock()
        mock_service.ping_interval = 5
        mock_service.ping_timeout = 20

        assert mock_service.ping_interval == 5
        assert mock_service.ping_timeout == 20

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_socket_error_recovery(self, mock_service_cls):
        """Test error recovery"""
        mock_service = MagicMock()
        mock_service._handle_error.return_value = {
            "recovered": True,
            "error_type": "temporary",
        }

        result = mock_service._handle_error(
            "client_123", Exception("Test error")
        )

        assert result["recovered"] is True

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_socket_max_connections(self, mock_service_cls):
        """Test max connections enforcement"""
        mock_service = MagicMock()
        mock_service._check_max_connections.return_value = True

        can_connect = mock_service._check_max_connections()

        assert can_connect is True

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_socket_connection_metadata(self, mock_service_cls):
        """Test connection metadata storage"""
        mock_service = MagicMock()
        mock_service._store_metadata.return_value = {
            "stored": True,
            "client_id": "client_123",
        }

        result = mock_service._store_metadata(
            "client_123", {"user_agent": "Mozilla/5.0", "ip": "192.168.1.1"}
        )

        assert result["stored"] is True

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_socket_ip_tracking(self, mock_service_cls):
        """Test IP tracking"""
        mock_service = MagicMock()
        mock_service._get_client_ip.return_value = "192.168.1.1"

        ip = mock_service._get_client_ip(MagicMock())

        assert ip is not None

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_socket_rate_limiting(self, mock_service_cls):
        """Test rate limiting on connections"""
        mock_service = MagicMock()
        mock_service._check_rate_limit.return_value = {
            "allowed": True,
            "remaining": 99,
        }

        result = mock_service._check_rate_limit("192.168.1.1")

        assert result["allowed"] is True


class TestSocketEmission:
    """Tests for socket emission functionality"""

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_emit_to_single_subscriber(self, mock_service_cls):
        """Test emitting to single subscriber"""
        mock_service = MagicMock()
        mock_service.emit_socket_event.return_value = True

        result = mock_service.emit_socket_event(
            "progress", {"percent": 50}, room="client_123"
        )

        assert result is True

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_emit_to_multiple_subscribers(self, mock_service_cls):
        """Test emitting to multiple subscribers"""
        mock_service = MagicMock()
        mock_service.emit_to_subscribers.return_value = {
            "sent_to": 5,
            "failed": 0,
        }

        result = mock_service.emit_to_subscribers(
            "research_progress", "research_123", {"progress": 50}
        )

        assert result["sent_to"] == 5

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_emit_to_room(self, mock_service_cls):
        """Test emitting to room"""
        mock_service = MagicMock()
        mock_service.emit_socket_event.return_value = True

        result = mock_service.emit_socket_event(
            "update", {"data": "test"}, room="research_123"
        )

        assert result is True

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_emit_broadcast(self, mock_service_cls):
        """Test broadcast emission"""
        mock_service = MagicMock()
        mock_service.emit_socket_event.return_value = True

        result = mock_service.emit_socket_event(
            "announcement", {"message": "Server restart in 5 minutes"}
        )

        assert result is True

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_emit_with_callback(self, mock_service_cls):
        """Test emit with acknowledgment callback"""
        mock_service = MagicMock()
        mock_callback = MagicMock()

        mock_service._emit_with_callback.return_value = True

        result = mock_service._emit_with_callback(
            "event", {"data": "test"}, callback=mock_callback
        )

        assert result is True

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_emit_with_acknowledgment(self, mock_service_cls):
        """Test emit with ack response"""
        mock_service = MagicMock()
        mock_service._emit_with_ack.return_value = {
            "ack_received": True,
            "response": "OK",
        }

        result = mock_service._emit_with_ack(
            "event", {"data": "test"}, room="client_123"
        )

        assert result["ack_received"] is True

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_emit_binary_data(self, mock_service_cls):
        """Test emitting binary data"""
        mock_service = MagicMock()
        mock_service._emit_binary.return_value = True

        binary_data = b"PDF content here"
        result = mock_service._emit_binary(
            "file_download", binary_data, room="client_123"
        )

        assert result is True

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_emit_large_payload(self, mock_service_cls):
        """Test emitting large payload"""
        mock_service = MagicMock()
        mock_service._emit_large_payload.return_value = {
            "chunks_sent": 10,
            "total_size": 1000000,
        }

        large_data = "x" * 1000000
        result = mock_service._emit_large_payload(
            "large_data", large_data, room="client_123"
        )

        assert result["chunks_sent"] > 0

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_emit_queue_management(self, mock_service_cls):
        """Test emission queue management"""
        mock_service = MagicMock()
        mock_service._get_queue_status.return_value = {
            "pending": 5,
            "processing": 1,
        }

        status = mock_service._get_queue_status()

        assert status["pending"] >= 0

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_emit_priority_ordering(self, mock_service_cls):
        """Test priority-based emission ordering"""
        mock_service = MagicMock()
        mock_service._queue_with_priority.return_value = {
            "queued": True,
            "priority": "high",
        }

        result = mock_service._queue_with_priority(
            "urgent_event", {"urgent": True}, priority="high"
        )

        assert result["priority"] == "high"

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_emit_retry_on_failure(self, mock_service_cls):
        """Test retry on emission failure"""
        mock_service = MagicMock()
        mock_service._emit_with_retry.return_value = {
            "success": True,
            "attempts": 2,
        }

        result = mock_service._emit_with_retry(
            "event", {"data": "test"}, max_retries=3
        )

        assert result["success"] is True

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_emit_timeout_handling(self, mock_service_cls):
        """Test emission timeout handling"""
        mock_service = MagicMock()
        mock_service._emit_with_timeout.return_value = {
            "success": False,
            "error": "timeout",
        }

        result = mock_service._emit_with_timeout(
            "event", {"data": "test"}, timeout_ms=5000
        )

        # May timeout or succeed
        assert "success" in result

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_emit_batch_optimization(self, mock_service_cls):
        """Test batch emission optimization"""
        mock_service = MagicMock()
        mock_service._emit_batch.return_value = {
            "events_sent": 10,
            "time_saved_ms": 50,
        }

        events = [{"event": f"event_{i}", "data": {}} for i in range(10)]
        result = mock_service._emit_batch(events)

        assert result["events_sent"] == 10

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_emit_logging_control(self, mock_service_cls):
        """Test emission logging control"""
        mock_service = MagicMock()
        mock_service._SocketIOService__logging_enabled = True

        # Should be able to toggle logging
        mock_service._SocketIOService__logging_enabled = False

        assert mock_service._SocketIOService__logging_enabled is False

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_emit_thread_safety(self, mock_service_cls):
        """Test emission thread safety"""
        mock_service = MagicMock()
        mock_service._SocketIOService__lock = threading.Lock()

        emissions = []

        def emit_from_thread(n):
            with mock_service._SocketIOService__lock:
                emissions.append(n)

        threads = [
            threading.Thread(target=emit_from_thread, args=(i,))
            for i in range(10)
        ]
        for t in threads:
            t.start()
        for t in threads:
            t.join()

        assert len(emissions) == 10

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_emit_lock_contention(self, mock_service_cls):
        """Test handling lock contention"""
        mock_service = MagicMock()
        mock_service._acquire_lock.return_value = True

        acquired = mock_service._acquire_lock(timeout=1.0)

        assert acquired is True

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_emit_error_in_subscriber(self, mock_service_cls):
        """Test handling subscriber errors"""
        mock_service = MagicMock()
        mock_service._handle_subscriber_error.return_value = {
            "handled": True,
            "subscriber_removed": False,
        }

        result = mock_service._handle_subscriber_error(
            "client_123", Exception("Subscriber error")
        )

        assert result["handled"] is True

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_emit_partial_failure(self, mock_service_cls):
        """Test partial emission failure handling"""
        mock_service = MagicMock()
        mock_service.emit_to_subscribers.return_value = {
            "sent_to": 8,
            "failed": 2,
            "failed_clients": ["client_3", "client_7"],
        }

        result = mock_service.emit_to_subscribers(
            "event", "research_123", {"data": "test"}
        )

        assert result["sent_to"] > 0
        assert result["failed"] > 0

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_emit_metrics_tracking(self, mock_service_cls):
        """Test emission metrics tracking"""
        mock_service = MagicMock()
        mock_service._get_emission_metrics.return_value = {
            "total_emissions": 1000,
            "avg_latency_ms": 5,
            "error_rate": 0.01,
        }

        metrics = mock_service._get_emission_metrics()

        assert metrics["error_rate"] < 0.1

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_emit_event_filtering(self, mock_service_cls):
        """Test event filtering before emission"""
        mock_service = MagicMock()
        mock_service._should_emit.return_value = True

        should_emit = mock_service._should_emit("progress", {"progress": 50})

        assert should_emit is True


class TestSubscriptionManagement:
    """Tests for subscription management"""

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_subscribe_to_research(self, mock_service_cls):
        """Test subscribing to research updates"""
        mock_service = MagicMock()
        mock_service._SocketIOService__handle_subscribe.return_value = {
            "subscribed": True,
            "research_id": "research_123",
        }

        result = mock_service._SocketIOService__handle_subscribe(
            {"research_id": "research_123"}, MagicMock(sid="client_123"), {}
        )

        assert result["subscribed"] is True

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_unsubscribe_from_research(self, mock_service_cls):
        """Test unsubscribing from research"""
        mock_service = MagicMock()
        mock_service._unsubscribe.return_value = {"unsubscribed": True}

        result = mock_service._unsubscribe("client_123", "research_123")

        assert result["unsubscribed"] is True

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_get_subscribers(self, mock_service_cls):
        """Test getting subscribers for research"""
        mock_service = MagicMock()
        mock_service._get_subscribers.return_value = ["client_1", "client_2"]

        subscribers = mock_service._get_subscribers("research_123")

        assert len(subscribers) == 2


class TestSingletonPattern:
    """Tests for singleton pattern enforcement"""

    @patch("local_deep_research.web.services.socket_service.SocketIOService")
    def test_singleton_enforcement(self, mock_service_cls):
        """Test singleton pattern is enforced"""
        mock_service_cls._instance = None

        # Simulating singleton behavior
        instance1 = MagicMock()
        mock_service_cls._instance = instance1

        # Getting same instance
        instance2 = mock_service_cls._instance

        assert instance1 is instance2