fix: Enable email configuration for backends (issue #47) (#51)

This commit fixes issue #47 where email configuration was not working
due to lambda syntax errors in backend factory registrations.

Core Implementation Changes:
- Fixed backend factory lambda syntax to accept email parameter
- Added missing self.email = email in CrossValidatorBackend.__init__
- Implemented generic parameter filtering using inspect.signature()
- Added get_supported_params() method to BackendRegistry
- Updated config generation to only include supported parameters

Test Infrastructure Improvements:
- Added backend import to conftest.py for test-wide registration
- Fixed temp config file fixture to flush content before yielding
- Added registry state save/restore fixture for test isolation
- Created comprehensive integration and unit tests for email config

Files Modified:
- src/aletheia_probe/backends/base.py: Parameter filtering logic
- src/aletheia_probe/backends/cross_validator.py: Email attribute fix
- src/aletheia_probe/config.py: Updated default config generation
- tests/*: New tests and fixtures for email configuration

All 239 tests passing with full quality checks (ruff, mypy, formatting).

Fixes #47

Co-authored-by: florath-ai-assistant[bot] <Andreas.Florath@telekom.de>

Author: coding-ai-assistant[bot]

src/aletheia_probe/backends/base.py

@@ -3,6 +3,7 @@
 
 import asyncio
 import hashlib
+import inspect
 import time
 from abc import ABC, abstractmethod
 from collections.abc import Callable
@@ -351,8 +352,59 @@ def create_backend(self, name: str, **config: Any) -> Backend:
         # Merge provided config with defaults
         merged_config = {**self._default_configs[name], **config}
 
+        # Filter config parameters based on factory signature
+        factory = self._factories[name]
+        filtered_config = self._filter_config_params(factory, merged_config)
+
         # Create backend instance using factory
-        return self._factories[name](**merged_config)
+        return factory(**filtered_config)
+
+    def _filter_config_params(
+        self, factory: Callable[..., Backend], config: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Filter config parameters based on factory function signature.
+
+        Args:
+            factory: Backend factory function
+            config: Configuration parameters to filter
+
+        Returns:
+            Filtered configuration with only parameters the factory accepts
+        """
+        try:
+            sig = inspect.signature(factory)
+            accepted_params = set(sig.parameters.keys())
+
+            # Filter config to only include parameters the factory accepts
+            filtered_config = {
+                key: value for key, value in config.items() if key in accepted_params
+            }
+
+            return filtered_config
+        except Exception:
+            # If signature inspection fails, return original config
+            # This ensures backward compatibility
+            return config
+
+    def get_supported_params(self, name: str) -> set[str]:
+        """Get the set of parameters supported by a backend.
+
+        Args:
+            name: Backend name
+
+        Returns:
+            Set of parameter names the backend accepts
+        """
+        if name not in self._factories:
+            return set()
+
+        try:
+            factory = self._factories[name]
+            sig = inspect.signature(factory)
+            return set(sig.parameters.keys())
+        except Exception:
+            # If signature inspection fails, return empty set
+            return set()
 
     def get_backend(self, name: str) -> Backend:
         """Get a backend by name with default configuration."""

src/aletheia_probe/backends/cross_validator.py

@@ -24,6 +24,7 @@ def __init__(
             cache_ttl_hours: Cache TTL in hours
         """
         super().__init__(cache_ttl_hours)
+        self.email = email
         self.openalex_backend = OpenAlexAnalyzerBackend(email, cache_ttl_hours)
         self.crossref_backend = CrossrefAnalyzerBackend(email, cache_ttl_hours)
 

src/aletheia_probe/config.py

@@ -98,6 +98,10 @@ def __init__(self, config_path: Path | None = None):
         self.config_path = config_path or self._find_config_file()
         self._config: AppConfig | None = None
 
+    def _reset_cache(self) -> None:
+        """Reset cached configuration. Useful for testing."""
+        self._config = None
+
     def _find_config_file(self) -> Path | None:
         """Find configuration file in standard locations."""
         search_paths = [
@@ -273,15 +277,22 @@ def get_default_config_with_all_backends(self) -> dict[str, Any]:
 
         backends_config = {}
         for backend_name in backend_names:
-            backends_config[backend_name] = {
+            # Start with common config fields
+            backend_config = {
                 "name": backend_name,
                 "enabled": True,
                 "weight": DEFAULT_BACKEND_WEIGHT,
                 "timeout": DEFAULT_BACKEND_TIMEOUT,
-                "email": None,  # Use backend default unless configured
                 "config": {},
             }
 
+            # Only add parameters that this backend supports
+            supported_params = backend_registry.get_supported_params(backend_name)
+            if "email" in supported_params:
+                backend_config["email"] = None  # Use backend default unless configured
+
+            backends_config[backend_name] = backend_config
+
         return {
             "backends": backends_config,
             "heuristics": {

tests/conftest.py

@@ -5,6 +5,7 @@
 
 import pytest
 
+import aletheia_probe.backends  # Import backends to register them
 from aletheia_probe.models import BackendResult, BackendStatus, QueryInput