test_llm_config.py

"""
LLMConfig unit tests.

Covers:
- Default values
- from_dict parsing from config dictionary
- get_models
- Edge cases (missing keys, partial config)

All console output must be in English only (no emoji, no Chinese).
"""

import pytest
from video_transcript_api.llm.core.config import LLMConfig


class TestLLMConfigDefaults:
    """Test LLMConfig default values."""

    def test_required_fields(self):
        """Should require api_key, base_url, calibrate_model, summary_model."""
        config = LLMConfig(
            api_key="key",
            base_url="https://api.test.com",
            calibrate_model="model-a",
            summary_model="model-b",
        )
        assert config.api_key == "key"
        assert config.calibrate_model == "model-a"

    def test_default_retry_values(self):
        """Default retry config should be sensible."""
        config = LLMConfig(
            api_key="k", base_url="u",
            calibrate_model="m", summary_model="s",
        )
        assert config.max_retries == 3
        assert config.retry_delay == 5

    def test_default_segment_sizes(self):
        """Default segmentation config should be set."""
        config = LLMConfig(
            api_key="k", base_url="u",
            calibrate_model="m", summary_model="s",
        )
        assert config.segment_size == 2000
        assert config.max_segment_size == 3000
        assert config.enable_threshold == 5000

    def test_default_quality_weights(self):
        """Default quality score weights should sum to 1.0."""
        config = LLMConfig(
            api_key="k", base_url="u",
            calibrate_model="m", summary_model="s",
        )
        total = sum(config.quality_score_weights.values())
        assert abs(total - 1.0) < 0.01


class TestLLMConfigFromDict:
    """Test from_dict parsing."""

    def test_basic_config(self):
        """Should parse basic config dict."""
        config_dict = {
            "llm": {
                "api_key": "test-key",
                "base_url": "https://api.test.com",
                "calibrate_model": "deepseek-v4-flash",
                "summary_model": "deepseek-v4-pro",
            }
        }
        config = LLMConfig.from_dict(config_dict)
        assert config.api_key == "test-key"
        assert config.calibrate_model == "deepseek-v4-flash"
        assert config.summary_model == "deepseek-v4-pro"

    def test_old_risk_fields_ignored(self):
        """Old risk model fields in config should be silently ignored."""
        config_dict = {
            "llm": {
                "api_key": "k",
                "base_url": "u",
                "calibrate_model": "normal",
                "summary_model": "normal-summary",
                "risk_calibrate_model": "risk-model",
                "enable_risk_model_selection": True,
            }
        }
        config = LLMConfig.from_dict(config_dict)
        assert config.calibrate_model == "normal"
        assert not hasattr(config, "risk_calibrate_model")

    def test_segmentation_config(self):
        """Should parse segmentation config."""
        config_dict = {
            "llm": {
                "api_key": "k", "base_url": "u",
                "calibrate_model": "m", "summary_model": "s",
                "segmentation": {
                    "segment_size": 1500,
                    "max_segment_size": 2500,
                },
            }
        }
        config = LLMConfig.from_dict(config_dict)
        assert config.segment_size == 1500
        assert config.max_segment_size == 2500

    def test_missing_optional_fields_use_defaults(self):
        """Missing optional fields should use defaults."""
        config_dict = {
            "llm": {
                "api_key": "k", "base_url": "u",
                "calibrate_model": "m", "summary_model": "s",
            }
        }
        config = LLMConfig.from_dict(config_dict)
        assert config.max_retries == 3
        assert config.concurrent_workers == 10


class TestLLMConfigGetModels:
    """Test get_models method."""

    def test_returns_configured_models(self):
        """get_models should return all configured models."""
        config = LLMConfig(
            api_key="k", base_url="u",
            calibrate_model="cal-model",
            summary_model="sum-model",
        )
        models = config.get_models()
        assert models["calibrate_model"] == "cal-model"
        assert models["summary_model"] == "sum-model"

    def test_no_has_risk_in_result(self):
        """get_models result should not contain has_risk field."""
        config = LLMConfig(
            api_key="k", base_url="u",
            calibrate_model="m", summary_model="s",
        )
        models = config.get_models()
        assert "has_risk" not in models