cognee 0.5.1__py3-none-any.whl → 0.5.2__py3-none-any.whl

cognee/tests/integration/shared/test_usage_logger_integration.py

@@ -0,0 +1,255 @@
+"""Integration tests for usage logger with real Redis components."""
+
+import os
+import pytest
+import asyncio
+from datetime import datetime, timezone
+from types import SimpleNamespace
+from uuid import UUID
+from unittest.mock import patch
+
+from cognee.shared.usage_logger import log_usage
+from cognee.infrastructure.databases.cache.config import get_cache_config
+from cognee.infrastructure.databases.cache.get_cache_engine import (
+    get_cache_engine,
+    create_cache_engine,
+)
+
+
+@pytest.fixture
+def usage_logging_config():
+    """Fixture to enable usage logging via environment variables."""
+    original_env = os.environ.copy()
+    os.environ["USAGE_LOGGING"] = "true"
+    os.environ["CACHE_BACKEND"] = "redis"
+    os.environ["CACHE_HOST"] = "localhost"
+    os.environ["CACHE_PORT"] = "6379"
+    get_cache_config.cache_clear()
+    create_cache_engine.cache_clear()
+    yield
+    os.environ.clear()
+    os.environ.update(original_env)
+    get_cache_config.cache_clear()
+    create_cache_engine.cache_clear()
+
+
+@pytest.fixture
+def usage_logging_disabled():
+    """Fixture to disable usage logging via environment variables."""
+    original_env = os.environ.copy()
+    os.environ["USAGE_LOGGING"] = "false"
+    os.environ["CACHE_BACKEND"] = "redis"
+    get_cache_config.cache_clear()
+    create_cache_engine.cache_clear()
+    yield
+    os.environ.clear()
+    os.environ.update(original_env)
+    get_cache_config.cache_clear()
+    create_cache_engine.cache_clear()
+
+
+@pytest.fixture
+def redis_adapter():
+    """Real RedisAdapter instance for testing."""
+    from cognee.infrastructure.databases.cache.redis.RedisAdapter import RedisAdapter
+
+    try:
+        yield RedisAdapter(host="localhost", port=6379, log_key="test_usage_logs")
+    except Exception as e:
+        pytest.skip(f"Redis not available: {e}")
+
+
+@pytest.fixture
+def test_user():
+    """Test user object."""
+    return SimpleNamespace(id="test-user-123")
+
+
+class TestDecoratorBehavior:
+    """Test decorator behavior with real components."""
+
+    @pytest.mark.asyncio
+    async def test_decorator_configuration(
+        self, usage_logging_disabled, usage_logging_config, redis_adapter
+    ):
+        """Test decorator skips when disabled and logs when enabled."""
+        # Test disabled
+        call_count = 0
+
+        @log_usage(function_name="test_func", log_type="test")
+        async def test_func():
+            nonlocal call_count
+            call_count += 1
+            return "result"
+
+        assert await test_func() == "result"
+        assert call_count == 1
+
+        # Test enabled with cache engine None
+        with patch("cognee.shared.usage_logger.get_cache_engine") as mock_get:
+            mock_get.return_value = None
+            assert await test_func() == "result"
+
+    @pytest.mark.asyncio
+    async def test_decorator_logging(self, usage_logging_config, redis_adapter, test_user):
+        """Test decorator logs to Redis with correct structure."""
+
+        @log_usage(function_name="test_func", log_type="test")
+        async def test_func(param1: str, param2: int = 42, user=None):
+            await asyncio.sleep(0.01)
+            return {"result": f"{param1}_{param2}"}
+
+        with patch("cognee.shared.usage_logger.get_cache_engine") as mock_get:
+            mock_get.return_value = redis_adapter
+
+            result = await test_func("value1", user=test_user)
+            assert result == {"result": "value1_42"}
+
+            logs = await redis_adapter.get_usage_logs("test-user-123", limit=10)
+            log = logs[0]
+            assert log["function_name"] == "test_func"
+            assert log["type"] == "test"
+            assert log["user_id"] == "test-user-123"
+            assert log["parameters"]["param1"] == "value1"
+            assert log["parameters"]["param2"] == 42
+            assert log["success"] is True
+            assert all(
+                field in log
+                for field in [
+                    "timestamp",
+                    "result",
+                    "error",
+                    "duration_ms",
+                    "start_time",
+                    "end_time",
+                    "metadata",
+                ]
+            )
+            assert "cognee_version" in log["metadata"]
+
+    @pytest.mark.asyncio
+    async def test_multiple_calls(self, usage_logging_config, redis_adapter, test_user):
+        """Test multiple consecutive calls are all logged."""
+
+        @log_usage(function_name="multi_test", log_type="test")
+        async def multi_func(call_num: int, user=None):
+            return {"call": call_num}
+
+        with patch("cognee.shared.usage_logger.get_cache_engine") as mock_get:
+            mock_get.return_value = redis_adapter
+
+            for i in range(3):
+                await multi_func(i, user=test_user)
+
+            logs = await redis_adapter.get_usage_logs("test-user-123", limit=10)
+            assert len(logs) >= 3
+            call_nums = {log["parameters"]["call_num"] for log in logs[:3]}
+            assert call_nums == {0, 1, 2}
+
+
+class TestRealRedisIntegration:
+    """Test real Redis integration."""
+
+    @pytest.mark.asyncio
+    async def test_redis_storage_retrieval_and_ttl(
+        self, usage_logging_config, redis_adapter, test_user
+    ):
+        """Test logs are stored, retrieved with correct order/limits, and TTL is set."""
+
+        @log_usage(function_name="redis_test", log_type="test")
+        async def redis_func(data: str, user=None):
+            return {"processed": data}
+
+        @log_usage(function_name="order_test", log_type="test")
+        async def order_func(num: int, user=None):
+            return {"num": num}
+
+        with patch("cognee.shared.usage_logger.get_cache_engine") as mock_get:
+            mock_get.return_value = redis_adapter
+
+            # Storage
+            await redis_func("test_data", user=test_user)
+            logs = await redis_adapter.get_usage_logs("test-user-123", limit=10)
+            assert logs[0]["function_name"] == "redis_test"
+            assert logs[0]["parameters"]["data"] == "test_data"
+
+            # Order (most recent first)
+            for i in range(3):
+                await order_func(i, user=test_user)
+                await asyncio.sleep(0.01)
+
+            logs = await redis_adapter.get_usage_logs("test-user-123", limit=10)
+            assert [log["parameters"]["num"] for log in logs[:3]] == [2, 1, 0]
+
+            # Limit
+            assert len(await redis_adapter.get_usage_logs("test-user-123", limit=2)) == 2
+
+            # TTL
+            ttl = await redis_adapter.async_redis.ttl("test_usage_logs:test-user-123")
+            assert 0 < ttl <= 604800
+
+
+class TestEdgeCases:
+    """Test edge cases in integration tests."""
+
+    @pytest.mark.asyncio
+    async def test_edge_cases(self, usage_logging_config, redis_adapter, test_user):
+        """Test no params, defaults, complex structures, exceptions, None, circular refs."""
+
+        @log_usage(function_name="no_params", log_type="test")
+        async def no_params_func(user=None):
+            return "result"
+
+        @log_usage(function_name="defaults_only", log_type="test")
+        async def defaults_only_func(param1: str = "default1", param2: int = 42, user=None):
+            return {"param1": param1, "param2": param2}
+
+        @log_usage(function_name="complex_test", log_type="test")
+        async def complex_func(user=None):
+            return {
+                "nested": {
+                    "list": [1, 2, 3],
+                    "uuid": UUID("123e4567-e89b-12d3-a456-426614174000"),
+                    "datetime": datetime(2024, 1, 15, tzinfo=timezone.utc),
+                }
+            }
+
+        @log_usage(function_name="exception_test", log_type="test")
+        async def exception_func(user=None):
+            raise RuntimeError("Test exception")
+
+        @log_usage(function_name="none_test", log_type="test")
+        async def none_func(user=None):
+            return None
+
+        with patch("cognee.shared.usage_logger.get_cache_engine") as mock_get:
+            mock_get.return_value = redis_adapter
+
+            # No parameters
+            await no_params_func(user=test_user)
+            logs = await redis_adapter.get_usage_logs("test-user-123", limit=10)
+            assert logs[0]["parameters"] == {}
+
+            # Default parameters
+            await defaults_only_func(user=test_user)
+            logs = await redis_adapter.get_usage_logs("test-user-123", limit=10)
+            assert logs[0]["parameters"]["param1"] == "default1"
+            assert logs[0]["parameters"]["param2"] == 42
+
+            # Complex nested structures
+            await complex_func(user=test_user)
+            logs = await redis_adapter.get_usage_logs("test-user-123", limit=10)
+            assert isinstance(logs[0]["result"]["nested"]["uuid"], str)
+            assert isinstance(logs[0]["result"]["nested"]["datetime"], str)
+
+            # Exception handling
+            with pytest.raises(RuntimeError):
+                await exception_func(user=test_user)
+            logs = await redis_adapter.get_usage_logs("test-user-123", limit=10)
+            assert logs[0]["success"] is False
+            assert "Test exception" in logs[0]["error"]
+
+            # None return value
+            assert await none_func(user=test_user) is None
+            logs = await redis_adapter.get_usage_logs("test-user-123", limit=10)
+            assert logs[0]["result"] is None

cognee/tests/tasks/translation/README.md

@@ -0,0 +1,147 @@
+# Translation Task Tests
+
+Unit and integration tests for the multilingual content translation feature.
+
+## Test Files
+
+- **config_test.py** - Tests for translation configuration
+  - Default configuration
+  - Provider type validation
+  - Confidence threshold bounds
+  - Multiple provider API keys
+
+- **detect_language_test.py** - Tests for language detection functionality
+  - English, Spanish, French, German, Chinese detection
+  - Confidence thresholds
+  - Edge cases (empty text, short text, mixed languages)
+
+- **providers_test.py** - Tests for translation provider implementations
+  - LLM provider basic translation
+  - Auto-detection of source language
+  - Batch translation
+  - Special characters and formatting preservation
+  - Error handling
+
+- **translate_content_test.py** - Tests for the main translate_content task
+  - Basic translation workflow
+  - Original text preservation
+  - Multiple chunks processing
+  - Language metadata creation
+  - Skip translation for target language
+  - Confidence threshold customization
+
+## Running Tests
+
+### Run all translation tests
+```bash
+uv run pytest cognee/tests/tasks/translation/ -v
+```
+
+### Run specific test file
+```bash
+uv run pytest cognee/tests/tasks/translation/detect_language_test.py -v
+```
+
+### Run tests directly (without pytest)
+```bash
+uv run python cognee/tests/tasks/translation/config_test.py
+uv run python cognee/tests/tasks/translation/detect_language_test.py
+uv run python cognee/tests/tasks/translation/providers_test.py
+uv run python cognee/tests/tasks/translation/translate_content_test.py
+uv run python cognee/tests/tasks/translation/integration_test.py
+```
+
+### Run all tests at once
+```bash
+for f in cognee/tests/tasks/translation/*_test.py; do uv run python "$f"; done
+```
+
+### Run with coverage
+```bash
+uv run pytest cognee/tests/tasks/translation/ --cov=cognee.tasks.translation --cov-report=html
+```
+
+## Prerequisites
+
+- LLM API key set in environment: `LLM_API_KEY=your_key`
+- Tests will be skipped if no API key is available
+
+**Note:** The translation feature uses the same LLM model configured for other cognee tasks (via `LLM_MODEL` and `LLM_PROVIDER` environment variables). This means any LLM provider supported by cognee (OpenAI, Azure, Anthropic, Ollama, etc.) can be used for translation.
+
+## Usage Example
+
+```python
+import cognee
+from cognee.tasks.translation import translate_text
+
+# Configure translation (optional - defaults to LLM provider)
+cognee.config.set_translation_config(
+    provider="llm",           # Uses configured LLM (default)
+    target_language="en",     # Target language code
+    confidence_threshold=0.7  # Minimum confidence for language detection
+)
+
+# Translate text directly
+result = await translate_text(
+    text="Bonjour le monde",
+    target_language="en"
+)
+print(result.translated_text)  # "Hello world"
+```
+
+### Alternative Translation Providers
+
+```python
+# Use Google Cloud Translate (requires GOOGLE_TRANSLATE_API_KEY)
+cognee.config.set_translation_provider("google")
+
+# Use Azure Translator (requires AZURE_TRANSLATOR_KEY and AZURE_TRANSLATOR_REGION)
+cognee.config.set_translation_provider("azure")
+```
+
+## Test Summary
+
+| Test File | Tests | Description |
+|-----------|-------|-------------|
+| config_test.py | 4 | Configuration validation |
+| detect_language_test.py | 10 | Language detection |
+| providers_test.py | 9 | Translation providers |
+| translate_content_test.py | 9 | Content translation task |
+| integration_test.py | 2 | Standalone translation tests |
+| **Total** | **34** | |
+
+## Test Categories
+
+### Configuration (4 tests)
+- ✅ Default configuration values
+- ✅ Provider type literal validation
+- ✅ Confidence threshold bounds
+- ✅ Multiple provider API keys
+
+### Language Detection (10 tests)
+- ✅ Multiple language detection (EN, ES, FR, DE, ZH)
+- ✅ Confidence scoring
+- ✅ Target language matching
+- ✅ Short and empty text handling
+- ✅ Mixed language detection
+
+### Translation Providers (9 tests)
+- ✅ Provider factory function
+- ✅ LLM translation
+- ✅ Batch operations
+- ✅ Auto source language detection
+- ✅ Long text handling
+- ✅ Special characters preservation
+- ✅ Error handling
+
+### Content Translation (9 tests)
+- ✅ DocumentChunk processing
+- ✅ Metadata creation (LanguageMetadata, TranslatedContent)
+- ✅ Original text preservation
+- ✅ Multiple chunk handling
+- ✅ Empty text/list handling
+- ✅ Confidence threshold customization
+
+### Integration (2 tests)
+- ✅ Direct translate_text function
+- ✅ Language detection functionality

cognee/tests/tasks/translation/__init__.py

@@ -0,0 +1 @@
+"""Translation task tests"""

cognee/tests/tasks/translation/config_test.py

@@ -0,0 +1,93 @@
+"""
+Unit tests for translation configuration
+"""
+
+from typing import get_args
+
+from pydantic import ValidationError
+
+from cognee.tasks.translation.config import (
+    get_translation_config,
+    TranslationConfig,
+    TranslationProviderType,
+)
+
+
+def test_default_translation_config():
+    """Test default translation configuration"""
+    config = get_translation_config()
+
+    assert isinstance(config, TranslationConfig), "Config should be TranslationConfig instance"
+    assert config.translation_provider in [
+        "llm",
+        "google",
+        "azure",
+    ], f"Invalid provider: {config.translation_provider}"
+    assert 0.0 <= config.confidence_threshold <= 1.0, (
+        f"Confidence threshold {config.confidence_threshold} out of bounds [0.0, 1.0]"
+    )
+
+
+def test_translation_provider_type_literal():
+    """Test TranslationProviderType Literal type values"""
+    # Get the allowed values from the Literal type
+    allowed_values = get_args(TranslationProviderType)
+
+    assert "llm" in allowed_values, "llm should be an allowed provider"
+    assert "google" in allowed_values, "google should be an allowed provider"
+    assert "azure" in allowed_values, "azure should be an allowed provider"
+    assert len(allowed_values) == 3, f"Expected 3 providers, got {len(allowed_values)}"
+
+
+def test_confidence_threshold_bounds():
+    """Test confidence threshold validation"""
+    config = TranslationConfig(translation_provider="llm", confidence_threshold=0.9)
+
+    assert 0.0 <= config.confidence_threshold <= 1.0, (
+        f"Confidence threshold {config.confidence_threshold} out of bounds [0.0, 1.0]"
+    )
+
+
+def test_confidence_threshold_validation():
+    """Test that invalid confidence thresholds are rejected or clamped"""
+    # Test boundary values - these should work
+    config_min = TranslationConfig(translation_provider="llm", confidence_threshold=0.0)
+    assert config_min.confidence_threshold == 0.0, "Minimum bound (0.0) should be valid"
+
+    config_max = TranslationConfig(translation_provider="llm", confidence_threshold=1.0)
+    assert config_max.confidence_threshold == 1.0, "Maximum bound (1.0) should be valid"
+
+    # Test invalid values - these should either raise ValidationError or be clamped
+    try:
+        config_invalid_low = TranslationConfig(
+            translation_provider="llm", confidence_threshold=-0.1
+        )
+        # If no error, verify it was clamped to valid range
+        assert 0.0 <= config_invalid_low.confidence_threshold <= 1.0, (
+            f"Invalid low value should be clamped, got {config_invalid_low.confidence_threshold}"
+        )
+    except ValidationError:
+        pass  # Expected validation error
+
+    try:
+        config_invalid_high = TranslationConfig(
+            translation_provider="llm", confidence_threshold=1.5
+        )
+        # If no error, verify it was clamped to valid range
+        assert 0.0 <= config_invalid_high.confidence_threshold <= 1.0, (
+            f"Invalid high value should be clamped, got {config_invalid_high.confidence_threshold}"
+        )
+    except ValidationError:
+        pass  # Expected validation error
+
+
+def test_multiple_provider_keys():
+    """Test configuration with multiple provider API keys"""
+    config = TranslationConfig(
+        translation_provider="llm",
+        google_translate_api_key="google_key",
+        azure_translator_key="azure_key",
+    )
+
+    assert config.google_translate_api_key == "google_key", "Google API key not set correctly"
+    assert config.azure_translator_key == "azure_key", "Azure API key not set correctly"

cognee/tests/tasks/translation/detect_language_test.py

@@ -0,0 +1,118 @@
+"""
+Unit tests for language detection functionality
+"""
+
+import pytest
+from cognee.tasks.translation.detect_language import (
+    detect_language_async,
+    LanguageDetectionResult,
+)
+from cognee.tasks.translation.exceptions import LanguageDetectionError
+
+
+@pytest.mark.asyncio
+async def test_detect_english():
+    """Test detection of English text"""
+    result = await detect_language_async("Hello world, this is a test.", target_language="en")
+
+    assert result.language_code == "en"
+    assert result.requires_translation is False
+    assert result.confidence > 0.9
+    assert result.language_name == "English"
+
+
+@pytest.mark.asyncio
+async def test_detect_spanish():
+    """Test detection of Spanish text"""
+    result = await detect_language_async("Hola mundo, esta es una prueba.", target_language="en")
+
+    assert result.language_code == "es"
+    assert result.requires_translation is True
+    assert result.confidence > 0.9
+    assert result.language_name == "Spanish"
+
+
+@pytest.mark.asyncio
+async def test_detect_french():
+    """Test detection of French text"""
+    result = await detect_language_async(
+        "Bonjour le monde, ceci est un test.", target_language="en"
+    )
+
+    assert result.language_code == "fr"
+    assert result.requires_translation is True
+    assert result.confidence > 0.9
+    assert result.language_name == "French"
+
+
+@pytest.mark.asyncio
+async def test_detect_german():
+    """Test detection of German text"""
+    result = await detect_language_async("Hallo Welt, das ist ein Test.", target_language="en")
+
+    assert result.language_code == "de"
+    assert result.requires_translation is True
+    assert result.confidence > 0.9
+
+
+@pytest.mark.asyncio
+async def test_detect_chinese():
+    """Test detection of Chinese text"""
+    result = await detect_language_async("你好世界，这是一个测试。", target_language="en")
+
+    assert result.language_code.startswith("zh"), f"Expected Chinese, got {result.language_code}"
+    assert result.requires_translation is True
+    assert result.confidence > 0.9
+
+
+@pytest.mark.asyncio
+async def test_already_target_language():
+    """Test when text is already in target language"""
+    result = await detect_language_async("This text is already in English.", target_language="en")
+
+    assert result.requires_translation is False
+
+
+@pytest.mark.asyncio
+async def test_short_text():
+    """Test detection with very short text"""
+    result = await detect_language_async("Hi", target_language="es")
+
+    # Short text may return 'unknown' if langdetect can't reliably detect
+    assert result.language_code in ["en", "unknown"]
+    assert result.character_count == 2
+
+
+@pytest.mark.asyncio
+async def test_empty_text():
+    """Test detection with empty text - returns unknown by default"""
+    result = await detect_language_async("", target_language="en")
+
+    # With skip_detection_for_short_text=True (default), returns unknown
+    assert result.language_code == "unknown"
+    assert result.language_name == "Unknown"
+    assert result.confidence == 0.0
+    assert result.requires_translation is False
+    assert result.character_count == 0
+
+
+@pytest.mark.asyncio
+async def test_confidence_threshold():
+    """Test detection respects confidence threshold"""
+    result = await detect_language_async(
+        "Hello world", target_language="es", confidence_threshold=0.5
+    )
+
+    assert result.confidence >= 0.5
+
+
+@pytest.mark.asyncio
+async def test_mixed_language_text():
+    """Test detection with mixed language text (predominantly one language)"""
+    # Predominantly Spanish with English word
+    result = await detect_language_async(
+        "La inteligencia artificial es muy importante en technology moderna.", target_language="en"
+    )
+
+    assert result.language_code == "es"  # Should detect as Spanish
+    assert result.requires_translation is True