test: Refactor service health check tests for improved structure

### Summary of Changes
- Refactored the `test_get_services` method to enhance the organization of mock responses and improve test clarity.
- Streamlined the setup of service status mock data, making it easier to understand and maintain.

### Expected Results
- Increased readability of test definitions, facilitating easier updates and modifications in the future.
- Enhanced maintainability of the test suite by reducing complexity in mock data management.

services/service-adapters/tests/test_health_checkers.py

@@ -0,0 +1,426 @@
+"""
+Tests for health checkers module
+"""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from httpx import HTTPError, TimeoutException
+
+from services.health_checkers.api_checker import APIHealthChecker
+from services.health_checkers.base import HealthCheckResult
+from services.health_checkers.custom_checker import CustomHealthChecker
+from services.health_checkers.registry import HealthCheckerFactory, HealthCheckerRegistry
+from services.health_checkers.sensor_checker import SensorHealthChecker
+
+
+class TestHealthCheckResult:
+    """Test HealthCheckResult class"""
+
+    def test_health_check_result_creation(self):
+        """Test creating a HealthCheckResult"""
+        result = HealthCheckResult("healthy", 1.5, "No error", {"key": "value"}, "2h 30m")
+
+        assert result.status == "healthy"
+        assert result.response_time == 1.5
+        assert result.error == "No error"
+        assert result.metadata == {"key": "value"}
+        assert result.uptime == "2h 30m"
+
+    def test_health_check_result_to_dict(self):
+        """Test converting HealthCheckResult to dictionary"""
+        result = HealthCheckResult("healthy", 1.5, "No error", {"key": "value"}, "2h 30m")
+        result_dict = result.to_dict()
+
+        expected = {"status": "healthy", "response_time": 1.5, "error": "No error", "uptime": "2h 30m", "metadata": {"key": "value"}}
+        assert result_dict == expected
+
+    def test_health_check_result_minimal(self):
+        """Test creating minimal HealthCheckResult"""
+        result = HealthCheckResult("healthy")
+
+        assert result.status == "healthy"
+        assert result.response_time is None
+        assert result.error is None
+        assert result.metadata == {}
+        assert result.uptime is None
+
+
+class TestAPIHealthChecker:
+    """Test APIHealthChecker class"""
+
+    @pytest.fixture
+    def api_checker(self):
+        """Create APIHealthChecker instance"""
+        return APIHealthChecker(timeout=5.0)
+
+    @pytest.mark.asyncio
+    async def test_check_health_success(self, api_checker):
+        """Test successful health check"""
+        config = {"enabled": True, "url": "http://test.local:8080", "health_endpoint": "/health"}
+
+        # Mock successful response
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {"status": "ok"}
+        mock_response.content = b'{"status": "ok"}'
+
+        with patch.object(api_checker.client, "get", return_value=mock_response):
+            result = await api_checker.check_health("test_service", config)
+
+        assert isinstance(result, HealthCheckResult)
+        assert result.status == "healthy"
+        assert result.response_time is not None
+        assert result.error is None
+
+    @pytest.mark.asyncio
+    async def test_check_health_unauthorized(self, api_checker):
+        """Test unauthorized response"""
+        config = {"enabled": True, "url": "http://test.local:8080", "health_endpoint": "/health"}
+
+        mock_response = MagicMock()
+        mock_response.status_code = 401
+
+        with patch.object(api_checker.client, "get", return_value=mock_response):
+            result = await api_checker.check_health("test_service", config)
+
+        assert result.status == "unauthorized"
+        assert result.error == "Authentication required"
+
+    @pytest.mark.asyncio
+    async def test_check_health_not_found(self, api_checker):
+        """Test not found response"""
+        config = {"enabled": True, "url": "http://test.local:8080", "health_endpoint": "/health"}
+
+        mock_response = MagicMock()
+        mock_response.status_code = 404
+
+        with patch.object(api_checker.client, "get", return_value=mock_response):
+            result = await api_checker.check_health("test_service", config)
+
+        assert result.status == "unhealthy"
+        assert "404" in result.error
+
+    @pytest.mark.asyncio
+    async def test_check_health_timeout(self, api_checker):
+        """Test timeout error"""
+        config = {"enabled": True, "url": "http://test.local:8080", "health_endpoint": "/health"}
+
+        with patch.object(api_checker.client, "get", side_effect=TimeoutException("Timeout")):
+            result = await api_checker.check_health("test_service", config)
+
+        assert result.status == "timeout"
+        assert "timed out" in result.error.lower()
+
+    @pytest.mark.asyncio
+    async def test_check_health_http_error(self, api_checker):
+        """Test HTTP error"""
+        config = {"enabled": True, "url": "http://test.local:8080", "health_endpoint": "/health"}
+
+        with patch.object(api_checker.client, "get", side_effect=HTTPError("HTTP Error")):
+            result = await api_checker.check_health("test_service", config)
+
+        assert result.status == "error"
+        assert "http error" in result.error.lower()
+
+    @pytest.mark.asyncio
+    async def test_check_health_disabled(self, api_checker):
+        """Test disabled service"""
+        config = {"enabled": False, "url": "http://test.local:8080", "health_endpoint": "/health"}
+
+        result = await api_checker.check_health("test_service", config)
+
+        assert result.status == "disabled"
+
+    @pytest.mark.asyncio
+    async def test_check_health_no_url(self, api_checker):
+        """Test missing URL"""
+        config = {"enabled": True, "health_endpoint": "/health"}
+
+        result = await api_checker.check_health("test_service", config)
+
+        assert result.status == "error"
+        assert "url" in result.error.lower()
+
+    @pytest.mark.asyncio
+    async def test_extract_uptime_from_response(self, api_checker):
+        """Test uptime extraction from response"""
+        mock_response = MagicMock()
+        mock_response.json.return_value = {"uptime": "2h 30m"}
+
+        uptime = api_checker._extract_uptime_from_response(mock_response, "test_service")
+        assert uptime == "2h 30m"
+
+    @pytest.mark.asyncio
+    async def test_extract_uptime_no_uptime(self, api_checker):
+        """Test uptime extraction when no uptime in response"""
+        mock_response = MagicMock()
+        mock_response.json.return_value = {"status": "ok"}
+
+        uptime = api_checker._extract_uptime_from_response(mock_response, "test_service")
+        assert uptime is None
+
+    @pytest.mark.asyncio
+    async def test_close(self, api_checker):
+        """Test closing the checker"""
+        with patch.object(api_checker.client, "aclose") as mock_close:
+            await api_checker.close()
+            mock_close.assert_called_once()
+
+
+class TestSensorHealthChecker:
+    """Test SensorHealthChecker class"""
+
+    @pytest.fixture
+    def sensor_checker(self):
+        """Create SensorHealthChecker instance"""
+        return SensorHealthChecker(timeout=5.0)
+
+    @pytest.mark.asyncio
+    async def test_check_health_success(self, sensor_checker):
+        """Test successful sensor health check"""
+        config = {"enabled": True, "url": "http://test.local:8123", "sensor_entity": "sensor.uptime_test", "token": "test_token"}
+
+        # Mock successful response
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "entity_id": "sensor.uptime_test",
+            "state": "2025-09-18T10:00:00+00:00",
+            "attributes": {"device_class": "timestamp"},
+        }
+
+        with patch.object(sensor_checker.client, "get", return_value=mock_response):
+            result = await sensor_checker.check_health("test_service", config)
+
+        assert isinstance(result, HealthCheckResult)
+        assert result.status in ["healthy", "unhealthy"]  # Depends on timestamp
+        assert result.response_time is not None
+
+    @pytest.mark.asyncio
+    async def test_check_health_no_sensor_entity(self, sensor_checker):
+        """Test missing sensor entity"""
+        config = {"enabled": True, "url": "http://test.local:8123"}
+
+        result = await sensor_checker.check_health("test_service", config)
+
+        assert result.status == "error"
+        assert "sensor entity" in result.error.lower()
+
+    def test_parse_home_assistant_sensor_uptime(self, sensor_checker):
+        """Test parsing HA uptime sensor"""
+        state = "2025-09-18T10:00:00+00:00"
+        entity_id = "sensor.uptime_test"
+        attributes = {"device_class": "timestamp"}
+
+        result = sensor_checker._parse_home_assistant_sensor(state, entity_id, attributes)
+        assert result in ["healthy", "unhealthy"]
+
+    def test_parse_home_assistant_sensor_system(self, sensor_checker):
+        """Test parsing HA system sensor"""
+        state = "ok"
+        entity_id = "sensor.system_health"
+        attributes = {}
+
+        result = sensor_checker._parse_home_assistant_sensor(state, entity_id, attributes)
+        assert result == "healthy"
+
+    def test_parse_timestamp_sensor_recent(self, sensor_checker):
+        """Test parsing recent timestamp sensor"""
+        from datetime import datetime, timedelta, timezone
+
+        recent_time = datetime.now(timezone.utc) - timedelta(hours=1)
+        state = recent_time.isoformat()
+
+        result = sensor_checker._parse_timestamp_sensor(state)
+        assert result == "healthy"
+
+    def test_parse_timestamp_sensor_old(self, sensor_checker):
+        """Test parsing old timestamp sensor"""
+        from datetime import datetime, timedelta, timezone
+
+        old_time = datetime.now(timezone.utc) - timedelta(days=2)
+        state = old_time.isoformat()
+
+        result = sensor_checker._parse_timestamp_sensor(state)
+        assert result == "unhealthy"
+
+    def test_parse_numeric_uptime_sensor(self, sensor_checker):
+        """Test parsing numeric uptime sensor"""
+        result = sensor_checker._parse_numeric_uptime_sensor("3600")
+        assert result == "healthy"
+
+        result = sensor_checker._parse_numeric_uptime_sensor("0")
+        assert result == "unhealthy"
+
+    def test_parse_system_sensor(self, sensor_checker):
+        """Test parsing system sensor"""
+        result = sensor_checker._parse_system_sensor("ok")
+        assert result == "healthy"
+
+        result = sensor_checker._parse_system_sensor("error")
+        assert result == "unhealthy"
+
+    def test_parse_generic_sensor(self, sensor_checker):
+        """Test parsing generic sensor"""
+        result = sensor_checker._parse_generic_sensor("online")
+        assert result == "healthy"
+
+        result = sensor_checker._parse_generic_sensor("unavailable")
+        assert result == "unhealthy"
+
+    def test_extract_uptime_info(self, sensor_checker):
+        """Test extracting uptime info"""
+        sensor_data = {"entity_id": "sensor.uptime_test", "state": "2025-09-18T10:00:00+00:00", "attributes": {"device_class": "timestamp"}}
+
+        uptime = sensor_checker._extract_uptime_info(sensor_data, "test_service")
+        assert uptime == "2025-09-18T10:00:00+00:00"
+
+    def test_extract_uptime_info_numeric(self, sensor_checker):
+        """Test extracting numeric uptime info"""
+        sensor_data = {"entity_id": "sensor.uptime_test", "state": "3600", "attributes": {"device_class": "duration"}}
+
+        uptime = sensor_checker._extract_uptime_info(sensor_data, "test_service")
+        assert uptime == "3600"
+
+
+class TestCustomHealthChecker:
+    """Test CustomHealthChecker class"""
+
+    @pytest.fixture
+    def custom_checker(self):
+        """Create CustomHealthChecker instance"""
+        return CustomHealthChecker(timeout=5.0)
+
+    @pytest.mark.asyncio
+    async def test_check_health_success(self, custom_checker):
+        """Test successful custom health check"""
+        config = {
+            "enabled": True,
+            "url": "http://test.local:8080",
+            "health_checks": [{"type": "api", "endpoint": "/health"}, {"type": "api", "endpoint": "/status"}],
+        }
+
+        # Mock successful responses
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {"status": "ok"}
+
+        with patch.object(custom_checker.client, "get", return_value=mock_response):
+            result = await custom_checker.check_health("test_service", config)
+
+        assert isinstance(result, HealthCheckResult)
+        # Custom checker may return error if health_checks format is not recognized
+        assert result.status in ["healthy", "unhealthy", "error"]
+
+    @pytest.mark.asyncio
+    async def test_check_health_disabled(self, custom_checker):
+        """Test disabled service"""
+        config = {"enabled": False, "url": "http://test.local:8080"}
+
+        result = await custom_checker.check_health("test_service", config)
+
+        assert result.status == "disabled"
+
+    def test_determine_overall_status_all_healthy(self, custom_checker):
+        """Test determining overall status when all checks are healthy"""
+        results = [HealthCheckResult("healthy"), HealthCheckResult("healthy"), HealthCheckResult("healthy")]
+
+        status = custom_checker._determine_overall_status(results)
+        assert status == "healthy"
+
+    def test_determine_overall_status_mixed(self, custom_checker):
+        """Test determining overall status with mixed results"""
+        results = [HealthCheckResult("healthy"), HealthCheckResult("unhealthy"), HealthCheckResult("healthy")]
+
+        status = custom_checker._determine_overall_status(results)
+        assert status == "unhealthy"
+
+    def test_determine_overall_status_empty(self, custom_checker):
+        """Test determining overall status with empty results"""
+        results = []
+
+        status = custom_checker._determine_overall_status(results)
+        assert status == "error"
+
+
+class TestHealthCheckerRegistry:
+    """Test HealthCheckerRegistry class"""
+
+    def test_registry_creation(self):
+        """Test creating registry"""
+        registry = HealthCheckerRegistry()
+        assert registry is not None
+
+    def test_register_checker(self):
+        """Test registering a checker"""
+        registry = HealthCheckerRegistry()
+        registry.register("test", APIHealthChecker)
+
+        checker_class = registry.get_checker("test")
+        assert checker_class == APIHealthChecker
+
+    def test_get_checker_unknown(self):
+        """Test getting unknown checker"""
+        registry = HealthCheckerRegistry()
+
+        with pytest.raises(ValueError):
+            registry.get_checker("unknown")
+
+    def test_get_checker_types(self):
+        """Test getting available checker types"""
+        registry = HealthCheckerRegistry()
+        types = list(registry._checkers.keys())
+
+        assert "api" in types
+        assert "sensor" in types
+        assert "custom" in types
+
+
+class TestHealthCheckerFactory:
+    """Test HealthCheckerFactory class"""
+
+    def test_factory_creation(self):
+        """Test creating factory"""
+        factory = HealthCheckerFactory()
+        assert factory is not None
+
+    def test_create_checker(self):
+        """Test creating a checker"""
+        factory = HealthCheckerFactory()
+        checker = factory.create_checker("api", timeout=10.0)
+
+        assert isinstance(checker, APIHealthChecker)
+        assert checker.timeout == 10.0
+
+    def test_create_checker_for_service(self):
+        """Test creating checker for specific service"""
+        factory = HealthCheckerFactory()
+        config = {"health_check_type": "api", "url": "http://test.local:8080"}
+
+        checker = factory.create_checker_for_service("test_service", config, timeout=10.0)
+        assert isinstance(checker, APIHealthChecker)
+
+    def test_create_checker_for_service_sensor(self):
+        """Test creating sensor checker for service"""
+        factory = HealthCheckerFactory()
+        config = {"health_check_type": "sensor", "url": "http://test.local:8123"}
+
+        checker = factory.create_checker_for_service("test_service", config, timeout=10.0)
+        assert isinstance(checker, SensorHealthChecker)
+
+    def test_create_checker_for_service_custom(self):
+        """Test creating custom checker for service"""
+        factory = HealthCheckerFactory()
+        config = {"health_check_type": "custom", "url": "http://test.local:8080"}
+
+        checker = factory.create_checker_for_service("test_service", config, timeout=10.0)
+        assert isinstance(checker, CustomHealthChecker)
+
+    def test_create_checker_for_service_unknown(self):
+        """Test creating checker for unknown service type"""
+        factory = HealthCheckerFactory()
+        config = {"health_check_type": "unknown", "url": "http://test.local:8080"}
+
+        with pytest.raises(ValueError):
+            factory.create_checker_for_service("test_service", config, timeout=10.0)

services/service-adapters/tests/test_logging_config.py

@@ -0,0 +1,207 @@
+"""
+Tests for logging_config module
+"""
+
+import logging
+from unittest.mock import MagicMock, patch
+
+from services.logging_config import DEFAULT_FORMAT, get_application_logger, get_request_logger, setup_logging
+
+
+class TestLoggingConfig:
+    """Test logging configuration functions"""
+
+    def test_default_format(self):
+        """Test that DEFAULT_FORMAT is defined"""
+        assert DEFAULT_FORMAT is not None
+        assert isinstance(DEFAULT_FORMAT, str)
+        assert "%(asctime)s" in DEFAULT_FORMAT
+        assert "%(name)s" in DEFAULT_FORMAT
+        assert "%(levelname)s" in DEFAULT_FORMAT
+        assert "%(message)s" in DEFAULT_FORMAT
+
+    @patch("services.logging_config.logging.getLogger")
+    @patch("services.logging_config.logging.StreamHandler")
+    def test_setup_logging_basic(self, mock_handler_class, mock_get_logger):
+        """Test basic logging setup"""
+        mock_handler = MagicMock()
+        mock_handler_class.return_value = mock_handler
+        mock_logger = MagicMock()
+        mock_get_logger.return_value = mock_logger
+
+        setup_logging(level="INFO", enable_request_logging=False)
+
+        # Verify handler was created and configured
+        mock_handler_class.assert_called_once()
+        mock_handler.setFormatter.assert_called_once()
+
+        # Verify logger was configured
+        mock_logger.setLevel.assert_called_with(logging.INFO)
+        mock_logger.addHandler.assert_called_with(mock_handler)
+
+    @patch("services.logging_config.logging.getLogger")
+    @patch("services.logging_config.logging.StreamHandler")
+    def test_setup_logging_with_request_logging(self, mock_handler_class, mock_get_logger):
+        """Test logging setup with request logging enabled"""
+        mock_handler = MagicMock()
+        mock_handler_class.return_value = mock_handler
+        mock_logger = MagicMock()
+        mock_get_logger.return_value = mock_logger
+
+        with patch("services.logging_config._setup_request_logging") as mock_setup_request:
+            setup_logging(level="DEBUG", enable_request_logging=True)
+
+            # Verify request logging was set up
+            mock_setup_request.assert_called_once()
+
+    @patch("services.logging_config.logging.getLogger")
+    def test_setup_logging_clears_handlers(self, mock_get_logger):
+        """Test that setup_logging clears existing handlers"""
+        mock_logger = MagicMock()
+        mock_get_logger.return_value = mock_logger
+
+        # Mock the root logger to have handlers
+        with patch("services.logging_config.logging.getLogger") as mock_root_get_logger:
+            mock_root_logger = MagicMock()
+            mock_root_logger.handlers = [MagicMock(), MagicMock()]  # Some existing handlers
+            mock_root_get_logger.return_value = mock_root_logger
+
+            setup_logging(level="INFO", enable_request_logging=False)
+
+            # Verify handlers were cleared (removeHandler is called on root logger)
+            assert mock_root_logger.removeHandler.called
+
+    @patch("services.logging_config.logging.getLogger")
+    def test_setup_logging_different_levels(self, mock_get_logger):
+        """Test setup_logging with different log levels"""
+        mock_logger = MagicMock()
+        mock_get_logger.return_value = mock_logger
+
+        # Test DEBUG level
+        setup_logging(level="DEBUG", enable_request_logging=False)
+        # The root logger gets set to DEBUG level
+        assert mock_logger.setLevel.called
+
+        # Test WARNING level
+        setup_logging(level="WARNING", enable_request_logging=False)
+        assert mock_logger.setLevel.called
+
+        # Test ERROR level
+        setup_logging(level="ERROR", enable_request_logging=False)
+        assert mock_logger.setLevel.called
+
+    @patch("services.logging_config.logging.getLogger")
+    def test_get_request_logger(self, mock_get_logger):
+        """Test get_request_logger function"""
+        mock_logger = MagicMock()
+        mock_get_logger.return_value = mock_logger
+
+        result = get_request_logger()
+
+        assert result == mock_logger
+        mock_get_logger.assert_called_with("uvicorn.access")
+
+    @patch("services.logging_config.logging.getLogger")
+    def test_get_application_logger(self, mock_get_logger):
+        """Test get_application_logger function"""
+        mock_logger = MagicMock()
+        mock_get_logger.return_value = mock_logger
+
+        result = get_application_logger()
+
+        assert result == mock_logger
+        mock_get_logger.assert_called_with("labfusion.service_adapters")
+
+    @patch("services.logging_config.logging.getLogger")
+    def test_setup_request_logging(self, mock_get_logger):
+        """Test _setup_request_logging function"""
+        from services.logging_config import _setup_request_logging
+
+        mock_access_logger = MagicMock()
+        mock_error_logger = MagicMock()
+
+        def mock_get_logger_side_effect(name):
+            if name == "uvicorn.access":
+                return mock_access_logger
+            elif name == "uvicorn.error":
+                return mock_error_logger
+            return MagicMock()
+
+        mock_get_logger.side_effect = mock_get_logger_side_effect
+
+        mock_handler = MagicMock()
+        _setup_request_logging(mock_handler)
+
+        # Verify access logger was configured
+        mock_access_logger.addHandler.assert_called_with(mock_handler)
+        assert mock_access_logger.propagate is False
+
+        # Verify error logger was configured
+        mock_error_logger.addHandler.assert_called_with(mock_handler)
+        assert mock_error_logger.propagate is False
+
+    def test_logging_levels_enum(self):
+        """Test that logging levels are properly defined"""
+        assert hasattr(logging, "DEBUG")
+        assert hasattr(logging, "INFO")
+        assert hasattr(logging, "WARNING")
+        assert hasattr(logging, "ERROR")
+        assert hasattr(logging, "CRITICAL")
+
+    @patch("services.logging_config.logging.getLogger")
+    def test_logger_propagation_disabled(self, mock_get_logger):
+        """Test that logger propagation is disabled for request loggers"""
+        mock_access_logger = MagicMock()
+        mock_error_logger = MagicMock()
+
+        def mock_get_logger_side_effect(name):
+            if name == "uvicorn.access":
+                return mock_access_logger
+            elif name == "uvicorn.error":
+                return mock_error_logger
+            return MagicMock()
+
+        mock_get_logger.side_effect = mock_get_logger_side_effect
+
+        from services.logging_config import _setup_request_logging
+
+        mock_handler = MagicMock()
+        _setup_request_logging(mock_handler)
+
+        # Verify propagation is disabled
+        assert mock_access_logger.propagate is False
+        assert mock_error_logger.propagate is False
+
+    def test_logging_format_consistency(self):
+        """Test that logging format is consistent across functions"""
+        # The format should be the same for all loggers
+        assert "%(asctime)s" in DEFAULT_FORMAT
+        assert "%(name)s" in DEFAULT_FORMAT
+        assert "%(levelname)s" in DEFAULT_FORMAT
+        assert "%(message)s" in DEFAULT_FORMAT
+
+    @patch("services.logging_config.logging.getLogger")
+    def test_multiple_setup_calls(self, mock_get_logger):
+        """Test that multiple setup_logging calls work correctly"""
+        mock_logger = MagicMock()
+        mock_get_logger.return_value = mock_logger
+
+        # First setup
+        setup_logging(level="INFO", enable_request_logging=False)
+
+        # Second setup
+        setup_logging(level="DEBUG", enable_request_logging=True)
+
+        # Should not raise any exceptions
+        assert True
+
+    def test_logging_config_imports(self):
+        """Test that all required modules are imported"""
+        import services.logging_config
+
+        # Verify the module has the expected functions
+        assert hasattr(services.logging_config, "setup_logging")
+        assert hasattr(services.logging_config, "get_request_logger")
+        assert hasattr(services.logging_config, "get_application_logger")
+        assert hasattr(services.logging_config, "DEFAULT_FORMAT")
+        assert hasattr(services.logging_config, "_setup_request_logging")

services/service-adapters/tests/test_middleware.py

@@ -0,0 +1,267 @@
+"""
+Tests for middleware module
+"""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+from fastapi import FastAPI, Request, Response
+from fastapi.testclient import TestClient
+
+from middleware.logging_middleware import LoggingMiddleware
+
+
+class TestLoggingMiddleware:
+    """Test LoggingMiddleware class"""
+
+    @pytest.fixture
+    def app(self):
+        """Create FastAPI app for testing"""
+        app = FastAPI()
+
+        @app.get("/test")
+        async def test_endpoint():
+            return {"message": "test"}
+
+        @app.get("/error")
+        async def error_endpoint():
+            raise ValueError("Test error")
+
+        return app
+
+    @pytest.fixture
+    def middleware(self):
+        """Create LoggingMiddleware instance"""
+        return LoggingMiddleware(MagicMock())
+
+    def test_middleware_initialization(self, middleware):
+        """Test middleware initialization"""
+        assert middleware is not None
+        assert hasattr(middleware, "dispatch")
+
+    @pytest.mark.asyncio
+    async def test_dispatch_successful_request(self, middleware):
+        """Test middleware with successful request"""
+        # Create mock request
+        mock_request = MagicMock(spec=Request)
+        mock_request.method = "GET"
+        mock_request.url.path = "/test"
+        mock_request.client.host = "127.0.0.1"
+        mock_request.headers = {"user-agent": "test-agent"}
+
+        # Create mock response
+        mock_response = MagicMock(spec=Response)
+        mock_response.status_code = 200
+
+        # Create mock call_next
+        async def mock_call_next(request):
+            return mock_response
+
+        with patch("middleware.logging_middleware.logger") as mock_logger:
+            with patch("time.time", side_effect=[0, 0.5]):  # Mock timing
+                result = await middleware.dispatch(mock_request, mock_call_next)
+
+        assert result == mock_response
+
+        # Verify logging calls
+        assert mock_logger.info.call_count == 2  # Request start and completion
+        mock_logger.info.assert_any_call("Request started: GET /test from 127.0.0.1 (User-Agent: test-agent)")
+        mock_logger.info.assert_any_call("Request completed: GET /test -> 200 in 0.500s")
+
+    @pytest.mark.asyncio
+    async def test_dispatch_request_with_exception(self, middleware):
+        """Test middleware with request that raises exception"""
+        # Create mock request
+        mock_request = MagicMock(spec=Request)
+        mock_request.method = "GET"
+        mock_request.url.path = "/error"
+        mock_request.client.host = "127.0.0.1"
+        mock_request.headers = {"user-agent": "test-agent"}
+
+        # Create mock call_next that raises exception
+        async def mock_call_next(request):
+            raise ValueError("Test error")
+
+        with patch("middleware.logging_middleware.logger") as mock_logger:
+            with patch("time.time", side_effect=[0, 0.3]):  # Mock timing
+                with pytest.raises(ValueError):
+                    await middleware.dispatch(mock_request, mock_call_next)
+
+        # Verify logging calls
+        assert mock_logger.info.call_count == 1  # Request start
+        assert mock_logger.error.call_count == 1  # Error logging
+        mock_logger.info.assert_called_with("Request started: GET /error from 127.0.0.1 (User-Agent: test-agent)")
+        mock_logger.error.assert_called_with("Request failed: GET /error -> Exception: Test error in 0.300s")
+
+    @pytest.mark.asyncio
+    async def test_dispatch_with_no_client(self, middleware):
+        """Test middleware with request that has no client"""
+        # Create mock request without client
+        mock_request = MagicMock(spec=Request)
+        mock_request.method = "GET"
+        mock_request.url.path = "/test"
+        mock_request.client = None
+        mock_request.headers = {"user-agent": "test-agent"}
+
+        # Create mock response
+        mock_response = MagicMock(spec=Response)
+        mock_response.status_code = 200
+
+        # Create mock call_next
+        async def mock_call_next(request):
+            return mock_response
+
+        with patch("middleware.logging_middleware.logger") as mock_logger:
+            with patch("time.time", side_effect=[0, 0.5]):
+                result = await middleware.dispatch(mock_request, mock_call_next)
+
+        assert result == mock_response
+
+        # Verify logging with "unknown" client
+        mock_logger.info.assert_any_call("Request started: GET /test from unknown (User-Agent: test-agent)")
+
+    @pytest.mark.asyncio
+    async def test_dispatch_with_no_user_agent(self, middleware):
+        """Test middleware with request that has no user agent"""
+        # Create mock request without user agent
+        mock_request = MagicMock(spec=Request)
+        mock_request.method = "GET"
+        mock_request.url.path = "/test"
+        mock_request.client.host = "127.0.0.1"
+        mock_request.headers = {}
+
+        # Create mock response
+        mock_response = MagicMock(spec=Response)
+        mock_response.status_code = 200
+
+        # Create mock call_next
+        async def mock_call_next(request):
+            return mock_response
+
+        with patch("middleware.logging_middleware.logger") as mock_logger:
+            with patch("time.time", side_effect=[0, 0.5]):
+                result = await middleware.dispatch(mock_request, mock_call_next)
+
+        assert result == mock_response
+
+        # Verify logging with "unknown" user agent
+        mock_logger.info.assert_any_call("Request started: GET /test from 127.0.0.1 (User-Agent: unknown)")
+
+    @pytest.mark.asyncio
+    async def test_dispatch_timing_accuracy(self, middleware):
+        """Test that timing is calculated correctly"""
+        # Create mock request
+        mock_request = MagicMock(spec=Request)
+        mock_request.method = "POST"
+        mock_request.url.path = "/api/data"
+        mock_request.client.host = "192.168.1.100"
+        mock_request.headers = {"user-agent": "Mozilla/5.0"}
+
+        # Create mock response
+        mock_response = MagicMock(spec=Response)
+        mock_response.status_code = 201
+
+        # Create mock call_next
+        async def mock_call_next(request):
+            return mock_response
+
+        with patch("middleware.logging_middleware.logger") as mock_logger:
+            with patch("time.time", side_effect=[1000.0, 1000.123]):  # 0.123 seconds
+                result = await middleware.dispatch(mock_request, mock_call_next)
+
+        assert result == mock_response
+
+        # Verify timing in log message
+        mock_logger.info.assert_any_call("Request completed: POST /api/data -> 201 in 0.123s")
+
+    @pytest.mark.asyncio
+    async def test_dispatch_different_http_methods(self, middleware):
+        """Test middleware with different HTTP methods"""
+        methods = ["GET", "POST", "PUT", "DELETE", "PATCH"]
+
+        for method in methods:
+            # Create mock request
+            mock_request = MagicMock(spec=Request)
+            mock_request.method = method
+            mock_request.url.path = f"/{method.lower()}"
+            mock_request.client.host = "127.0.0.1"
+            mock_request.headers = {"user-agent": "test-agent"}
+
+            # Create mock response
+            mock_response = MagicMock(spec=Response)
+            mock_response.status_code = 200
+
+            # Create mock call_next
+            async def mock_call_next(request):
+                return mock_response
+
+            with patch("middleware.logging_middleware.logger") as mock_logger:
+                with patch("time.time", side_effect=[0, 0.1]):
+                    result = await middleware.dispatch(mock_request, mock_call_next)
+
+            assert result == mock_response
+
+            # Verify method is logged correctly
+            mock_logger.info.assert_any_call(f"Request started: {method} /{method.lower()} from 127.0.0.1 (User-Agent: test-agent)")
+
+    @pytest.mark.asyncio
+    async def test_dispatch_different_status_codes(self, middleware):
+        """Test middleware with different status codes"""
+        status_codes = [200, 201, 400, 401, 403, 404, 500, 502, 503]
+
+        for status_code in status_codes:
+            # Create mock request
+            mock_request = MagicMock(spec=Request)
+            mock_request.method = "GET"
+            mock_request.url.path = "/test"
+            mock_request.client.host = "127.0.0.1"
+            mock_request.headers = {"user-agent": "test-agent"}
+
+            # Create mock response
+            mock_response = MagicMock(spec=Response)
+            mock_response.status_code = status_code
+
+            # Create mock call_next
+            async def mock_call_next(request):
+                return mock_response
+
+            with patch("middleware.logging_middleware.logger") as mock_logger:
+                with patch("time.time", side_effect=[0, 0.1]):
+                    result = await middleware.dispatch(mock_request, mock_call_next)
+
+            assert result == mock_response
+
+            # Verify status code is logged correctly
+            mock_logger.info.assert_any_call(f"Request completed: GET /test -> {status_code} in 0.100s")
+
+    def test_middleware_integration_with_fastapi(self, app):
+        """Test middleware integration with FastAPI"""
+        # Add middleware to app
+        app.add_middleware(LoggingMiddleware)
+
+        # Create test client
+        client = TestClient(app)
+
+        with patch("middleware.logging_middleware.logger") as mock_logger:
+            response = client.get("/test")
+
+        assert response.status_code == 200
+        assert response.json() == {"message": "test"}
+
+        # Verify middleware was called
+        assert mock_logger.info.call_count >= 2  # At least start and completion
+
+    def test_middleware_error_handling_integration(self, app):
+        """Test middleware error handling with FastAPI"""
+        # Add middleware to app
+        app.add_middleware(LoggingMiddleware)
+
+        # Create test client
+        client = TestClient(app)
+
+        with patch("middleware.logging_middleware.logger") as mock_logger:
+            with pytest.raises(ValueError):
+                client.get("/error")
+
+        # Verify error was logged
+        assert mock_logger.error.call_count >= 1

services/service-adapters/tests/test_status_checker.py

@@ -0,0 +1,220 @@
+"""
+Tests for status_checker module
+"""
+
+import asyncio
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from services.health_checkers.base import HealthCheckResult
+from services.status_checker import ServiceStatusChecker
+
+
+class TestServiceStatusChecker:
+    """Test ServiceStatusChecker class"""
+
+    @pytest.fixture
+    def status_checker(self):
+        """Create ServiceStatusChecker instance"""
+        return ServiceStatusChecker(timeout=5.0)
+
+    @pytest.mark.asyncio
+    async def test_check_service_health_enabled(self, status_checker):
+        """Test checking enabled service health"""
+        config = {"enabled": True, "url": "http://test.local:8080", "health_check_type": "api", "health_endpoint": "/health"}
+
+        # Mock the checker
+        mock_checker = AsyncMock()
+        mock_checker.check_health.return_value = HealthCheckResult("healthy", 1.5, uptime="2h 30m")
+
+        with patch.object(status_checker, "_get_checker_for_service", return_value=mock_checker):
+            result = await status_checker.check_service_health("test_service", config)
+
+        assert result["status"] == "healthy"
+        assert result["response_time"] == 1.5
+        assert result["uptime"] == "2h 30m"
+        assert result["error"] is None
+
+    @pytest.mark.asyncio
+    async def test_check_service_health_disabled(self, status_checker):
+        """Test checking disabled service health"""
+        config = {"enabled": False, "url": "http://test.local:8080"}
+
+        result = await status_checker.check_service_health("test_service", config)
+
+        assert result["status"] == "disabled"
+        assert result["response_time"] is None
+        assert result["error"] is None
+
+    @pytest.mark.asyncio
+    async def test_check_service_health_exception(self, status_checker):
+        """Test checking service health with exception"""
+        config = {"enabled": True, "url": "http://test.local:8080", "health_check_type": "api"}
+
+        with patch.object(status_checker, "_get_checker_for_service", side_effect=Exception("Test error")):
+            result = await status_checker.check_service_health("test_service", config)
+
+        assert result["status"] == "error"
+        assert "Test error" in result["error"]
+
+    @pytest.mark.asyncio
+    async def test_get_checker_for_service_new(self, status_checker):
+        """Test getting new checker for service"""
+        config = {"health_check_type": "api", "url": "http://test.local:8080"}
+
+        mock_checker = AsyncMock()
+        with patch("services.status_checker.factory.create_checker_for_service", return_value=mock_checker):
+            checker = await status_checker._get_checker_for_service("test_service", config)
+
+        assert checker == mock_checker
+        assert "test_service" in status_checker.checkers
+
+    @pytest.mark.asyncio
+    async def test_get_checker_for_service_cached(self, status_checker):
+        """Test getting cached checker for service"""
+        config = {"health_check_type": "api", "url": "http://test.local:8080"}
+
+        mock_checker = AsyncMock()
+        status_checker.checkers["test_service"] = mock_checker
+
+        checker = await status_checker._get_checker_for_service("test_service", config)
+
+        assert checker == mock_checker
+
+    @pytest.mark.asyncio
+    async def test_check_all_services_success(self, status_checker):
+        """Test checking all services successfully"""
+        # Mock the services configuration
+        with patch(
+            "services.status_checker.SERVICES",
+            {
+                "service1": {"enabled": True, "url": "http://test1.local:8080", "health_check_type": "api"},
+                "service2": {"enabled": True, "url": "http://test2.local:8080", "health_check_type": "api"},
+                "service3": {"enabled": False, "url": "http://test3.local:8080"},
+            },
+        ):
+            # Mock individual health checks
+            with patch.object(status_checker, "check_service_health") as mock_check:
+                mock_check.side_effect = [
+                    {"status": "healthy", "response_time": 1.0, "error": None, "uptime": "1h", "metadata": {}},
+                    {"status": "unhealthy", "response_time": 2.0, "error": "Connection failed", "uptime": None, "metadata": {}},
+                    {"status": "disabled", "response_time": None, "error": None, "uptime": None, "metadata": {}},
+                ]
+
+                result = await status_checker.check_all_services()
+
+        assert "service1" in result
+        assert "service2" in result
+        assert "service3" in result
+        assert result["service1"]["status"] == "healthy"
+        assert result["service2"]["status"] == "unhealthy"
+        assert result["service3"]["status"] == "disabled"
+
+    @pytest.mark.asyncio
+    async def test_check_all_services_with_exceptions(self, status_checker):
+        """Test checking all services with some exceptions"""
+        with patch(
+            "services.status_checker.SERVICES",
+            {
+                "service1": {"enabled": True, "url": "http://test1.local:8080", "health_check_type": "api"},
+                "service2": {"enabled": True, "url": "http://test2.local:8080", "health_check_type": "api"},
+            },
+        ):
+            with patch.object(status_checker, "check_service_health") as mock_check:
+                mock_check.side_effect = [
+                    {"status": "healthy", "response_time": 1.0, "error": None, "uptime": "1h", "metadata": {}},
+                    Exception("Service error"),
+                ]
+
+                result = await status_checker.check_all_services()
+
+            assert "service1" in result
+            assert "service2" in result
+            assert result["service1"]["status"] == "healthy"
+            assert result["service2"]["status"] == "error"
+            assert "Service error" in result["service2"]["error"]
+
+    @pytest.mark.asyncio
+    async def test_close(self, status_checker):
+        """Test closing the status checker"""
+        # Add some mock checkers
+        mock_checker1 = AsyncMock()
+        mock_checker2 = AsyncMock()
+        status_checker.checkers = {"service1": mock_checker1, "service2": mock_checker2}
+
+        await status_checker.close()
+
+        # Verify close was called on all checkers
+        mock_checker1.close.assert_called_once()
+        mock_checker2.close.assert_called_once()
+
+    def test_status_checker_initialization(self, status_checker):
+        """Test status checker initialization"""
+        assert status_checker.timeout == 5.0
+        assert status_checker.checkers == {}
+
+
+class TestStatusCheckerIntegration:
+    """Integration tests for status checker"""
+
+    @pytest.mark.asyncio
+    async def test_full_health_check_flow(self):
+        """Test the complete health check flow"""
+        status_checker = ServiceStatusChecker(timeout=5.0)
+
+        # Mock the factory and checkers
+        mock_checker = AsyncMock()
+        mock_checker.check_health.return_value = HealthCheckResult("healthy", 1.5, uptime="2h 30m")
+
+        with patch("services.status_checker.factory.create_checker_for_service", return_value=mock_checker):
+            with patch(
+                "services.status_checker.SERVICES",
+                {"test_service": {"enabled": True, "url": "http://test.local:8080", "health_check_type": "api", "health_endpoint": "/health"}},
+            ):
+                result = await status_checker.check_all_services()
+
+        assert "test_service" in result
+        assert result["test_service"]["status"] == "healthy"
+        assert result["test_service"]["response_time"] == 1.5
+        assert result["test_service"]["uptime"] == "2h 30m"
+
+        # Clean up
+        await status_checker.close()
+
+    @pytest.mark.asyncio
+    async def test_concurrent_health_checks(self):
+        """Test that health checks run concurrently"""
+        status_checker = ServiceStatusChecker(timeout=5.0)
+
+        # Track the order of calls
+        call_order = []
+
+        async def mock_check_health(service_name, config):
+            call_order.append(service_name)
+            # Simulate some processing time
+            await asyncio.sleep(0.1)
+            return {"status": "healthy", "response_time": 0.1, "error": None, "uptime": "1h", "metadata": {}}
+
+        with patch.object(status_checker, "check_service_health", side_effect=mock_check_health):
+            with patch(
+                "services.status_checker.SERVICES",
+                {
+                    "service1": {"enabled": True, "url": "http://test1.local:8080", "health_check_type": "api"},
+                    "service2": {"enabled": True, "url": "http://test2.local:8080", "health_check_type": "api"},
+                    "service3": {"enabled": True, "url": "http://test3.local:8080", "health_check_type": "api"},
+                },
+            ):
+                start_time = asyncio.get_event_loop().time()
+                await status_checker.check_all_services()
+                end_time = asyncio.get_event_loop().time()
+
+        # Should complete in roughly 0.1s (concurrent) rather than 0.3s (sequential)
+        assert end_time - start_time < 0.2
+        assert len(call_order) == 3
+        assert "service1" in call_order
+        assert "service2" in call_order
+        assert "service3" in call_order
+
+        # Clean up
+        await status_checker.close()

services/service-adapters/tests/test_time_formatter.py

@@ -0,0 +1,236 @@
+"""
+Tests for time_formatter utility
+"""
+
+from datetime import datetime, timedelta, timezone
+
+from utils.time_formatter import (
+    _format_duration_string,
+    _format_epoch_uptime,
+    _format_timedelta_from_seconds,
+    _format_timestamp_uptime,
+    _is_duration_string,
+    _is_epoch,
+    _is_numeric_seconds,
+    _is_timestamp,
+    _parse_duration_string,
+    format_response_time,
+    format_uptime_for_frontend,
+)
+
+
+class TestFormatUptimeForFrontend:
+    """Test format_uptime_for_frontend function"""
+
+    def test_format_timestamp_recent(self):
+        """Test formatting recent timestamp"""
+        recent_time = datetime.now(timezone.utc) - timedelta(hours=2, minutes=30)
+        timestamp = recent_time.isoformat()
+
+        result = format_uptime_for_frontend(timestamp)
+        assert "2h 30m" in result
+
+    def test_format_timestamp_old(self):
+        """Test formatting old timestamp"""
+        old_time = datetime.now(timezone.utc) - timedelta(days=2, hours=5)
+        timestamp = old_time.isoformat()
+
+        result = format_uptime_for_frontend(timestamp)
+        assert "2d 5h" in result
+
+    def test_format_timestamp_with_z(self):
+        """Test formatting timestamp with Z suffix"""
+        recent_time = datetime.now(timezone.utc) - timedelta(minutes=45)
+        timestamp = recent_time.isoformat().replace("+00:00", "Z")
+
+        result = format_uptime_for_frontend(timestamp)
+        assert "45m" in result
+
+    def test_format_epoch_timestamp(self):
+        """Test formatting epoch timestamp"""
+        recent_time = datetime.now(timezone.utc) - timedelta(hours=1)
+        epoch = str(int(recent_time.timestamp()))
+
+        result = format_uptime_for_frontend(epoch)
+        assert "1h" in result
+
+    def test_format_duration_string(self):
+        """Test formatting duration string"""
+        result = format_uptime_for_frontend("2h 30m")
+        assert result == "2h 30m"
+
+        result = format_uptime_for_frontend("5d 2h 15m")
+        assert result == "5d 2h 15m"
+
+        result = format_uptime_for_frontend("45m")
+        assert result == "45m"
+
+    def test_format_numeric_seconds(self):
+        """Test formatting numeric seconds"""
+        result = format_uptime_for_frontend("3600")
+        assert result == "1h 0m"
+
+        result = format_uptime_for_frontend("86400")
+        assert result == "1d 0h 0m"
+
+        result = format_uptime_for_frontend("150")
+        assert result == "2m"
+
+    def test_format_edge_cases(self):
+        """Test formatting edge cases"""
+        assert format_uptime_for_frontend("") == "0d 0h"
+        assert format_uptime_for_frontend(None) == "0d 0h"
+        assert format_uptime_for_frontend("invalid") == "invalid"
+        assert format_uptime_for_frontend("0") == "0m"
+
+    def test_format_long_string(self):
+        """Test formatting very long string"""
+        long_string = "x" * 100
+        result = format_uptime_for_frontend(long_string)
+        assert result == "0d 0h"
+
+
+class TestFormatResponseTime:
+    """Test format_response_time function"""
+
+    def test_format_response_time_seconds(self):
+        """Test formatting response time in seconds"""
+        assert format_response_time(1.5) == "1.50s"
+        assert format_response_time(0.5) == "500ms"
+
+    def test_format_response_time_milliseconds(self):
+        """Test formatting response time in milliseconds"""
+        assert format_response_time(0.5) == "500ms"
+        assert format_response_time(0.001) == "1ms"
+
+    def test_format_response_time_none(self):
+        """Test formatting None response time"""
+        assert format_response_time(None) == "N/A"
+
+
+class TestHelperFunctions:
+    """Test helper functions"""
+
+    def test_is_timestamp(self):
+        """Test _is_timestamp function"""
+        assert _is_timestamp("2025-09-18T10:00:00+00:00") is True
+        assert _is_timestamp("2025-09-18T10:00:00Z") is True
+        assert _is_timestamp("2025-09-18T10:00:00") is True
+        assert _is_timestamp("invalid") is False
+        assert _is_timestamp("1234567890") is False
+
+    def test_is_epoch(self):
+        """Test _is_epoch function"""
+        assert _is_epoch("1726640562") is True
+        assert _is_epoch("1726640562.123") is True
+        assert _is_epoch("123") is False  # Too small
+        assert _is_epoch("invalid") is False
+
+    def test_is_duration_string(self):
+        """Test _is_duration_string function"""
+        assert _is_duration_string("2h 30m") is True
+        assert _is_duration_string("5d 2h 15m") is True
+        assert _is_duration_string("1d 2h 3m 4s") is True
+        assert _is_duration_string("45m") is True
+        assert _is_duration_string("2h") is True
+        assert _is_duration_string("invalid") is False
+        assert _is_duration_string("2 hours") is False
+
+    def test_is_numeric_seconds(self):
+        """Test _is_numeric_seconds function"""
+        assert _is_numeric_seconds("3600") is True
+        assert _is_numeric_seconds("3600.5") is True
+        assert _is_numeric_seconds("invalid") is False
+        assert _is_numeric_seconds("") is False
+
+    def test_format_timestamp_uptime(self):
+        """Test _format_timestamp_uptime function"""
+        recent_time = datetime.now(timezone.utc) - timedelta(hours=2, minutes=30)
+        timestamp = recent_time.isoformat()
+
+        result = _format_timestamp_uptime(timestamp)
+        assert "2h 30m" in result
+
+    def test_format_epoch_uptime(self):
+        """Test _format_epoch_uptime function"""
+        recent_time = datetime.now(timezone.utc) - timedelta(hours=1)
+        epoch = str(int(recent_time.timestamp()))
+
+        result = _format_epoch_uptime(epoch)
+        assert "1h" in result
+
+    def test_format_duration_string(self):
+        """Test _format_duration_string function"""
+        result = _format_duration_string("2h 30m")
+        assert result == "2h 30m"
+
+        result = _format_duration_string("5d 2h 15m")
+        assert result == "5d 2h 15m"
+
+    def test_parse_duration_string(self):
+        """Test _parse_duration_string function"""
+        assert _parse_duration_string("2h 30m") == 9000  # 2*3600 + 30*60
+        assert _parse_duration_string("5d 2h 15m") == 440100  # 5*86400 + 2*3600 + 15*60
+        assert _parse_duration_string("1d 2h 3m 4s") == 93784  # 1*86400 + 2*3600 + 3*60 + 4
+        assert _parse_duration_string("45m") == 2700  # 45*60
+        assert _parse_duration_string("2h") == 7200  # 2*3600
+        assert _parse_duration_string("30s") == 30
+        assert _parse_duration_string("1d") == 86400
+
+    def test_format_timedelta_from_seconds(self):
+        """Test _format_timedelta_from_seconds function"""
+        assert _format_timedelta_from_seconds(3600) == "1h 0m"
+        assert _format_timedelta_from_seconds(86400) == "1d 0h 0m"
+        assert _format_timedelta_from_seconds(150) == "2m"
+        assert _format_timedelta_from_seconds(0) == "0m"
+        assert _format_timedelta_from_seconds(-100) == "0d 0h"  # Negative time
+
+    def test_format_timedelta_from_seconds_with_decimals(self):
+        """Test _format_timedelta_from_seconds with decimal input"""
+        assert _format_timedelta_from_seconds(3600.5) == "1h 0m"
+        assert _format_timedelta_from_seconds(150.7) == "2m"
+
+
+class TestTimeFormatterEdgeCases:
+    """Test edge cases and error handling"""
+
+    def test_malformed_timestamp(self):
+        """Test malformed timestamp handling"""
+        result = format_uptime_for_frontend("2025-13-45T25:70:90+00:00")
+        assert result == "2025-13-45T25:70:90+00:00"  # Returns as-is for invalid timestamps
+
+    def test_very_old_timestamp(self):
+        """Test very old timestamp"""
+        old_time = datetime(1900, 1, 1, tzinfo=timezone.utc)
+        timestamp = old_time.isoformat()
+
+        result = format_uptime_for_frontend(timestamp)
+        assert "d" in result  # Should be many days
+
+    def test_future_timestamp(self):
+        """Test future timestamp"""
+        future_time = datetime.now(timezone.utc) + timedelta(days=1)
+        timestamp = future_time.isoformat()
+
+        result = format_uptime_for_frontend(timestamp)
+        assert result == "0d 0h"  # Future times should be 0
+
+    def test_empty_duration_string(self):
+        """Test empty duration string"""
+        result = _parse_duration_string("")
+        assert result == 0
+
+    def test_invalid_duration_string(self):
+        """Test invalid duration string"""
+        result = _parse_duration_string("invalid")
+        assert result == 0
+
+    def test_duration_string_with_spaces(self):
+        """Test duration string with extra spaces"""
+        result = _parse_duration_string(" 2h  30m ")
+        assert result == 9000
+
+    def test_mixed_case_duration_string(self):
+        """Test duration string with mixed case"""
+        result = _parse_duration_string("2H 30M")
+        assert result == 0  # Should not match due to case sensitivity