Skip to content

PRINTFILM: AI short-video marketing and AI short-drama creation platform

17.7 KB
Raw Blame
"""Model switches must apply to catalogs and every new-call routing fallback."""

from types import SimpleNamespace
from unittest.mock import AsyncMock, Mock

import pytest

from app.config import Settings
from app.schemas_routing import DefaultModels, LogicalModel, LogicalModelBinding, SystemModelChannel
from app.services.logical_model_router import resolve_logical_model_candidates, resolve_upstream_model
from app.services.media_catalog import build_media_catalog, is_valid_project_media_model
from app.services.media_models.catalog import priced_catalog
from app.services.media_models.runtime import pin_route, restore_route
from app.services.model_settings import RoutingSnapshot


MODELS = {"text": "kimi-k2.6", "image": "seedream-5.0-pro",
          "video": "seedance-2.5", "audio": "qwen-tts-2025-05-22"}


@pytest.fixture
def routing(monkeypatch):
    settings = Settings(_env_file=None, debug=False, ark_mock=False, local_media_mock=False)
    monkeypatch.setattr("app.config.get_settings", lambda: settings)
    monkeypatch.setattr("app.services.media_models.runtime.get_settings", lambda: settings)
    monkeypatch.setattr("app.services.media_models.planning.get_settings", lambda: settings)
    monkeypatch.setattr("app.services.media_catalog.get_settings", lambda: settings)
    from app.services.media_models.runtime import current_operation, current_snapshot
    snapshot_token = current_snapshot.set(None)
    operation_token = current_operation.set(None)

    def configure(capability="image", *, enabled=True, binding_enabled=True, default=True):
        model_id = MODELS[capability]
        channel = SystemModelChannel(id="alpha", name="Alpha", base_url="https://alpha.test/v1",
            api_key="test-key", has_api_key=True, models=[model_id])
        model = LogicalModel(id=model_id, capability=capability, enabled=enabled,
            bindings=[LogicalModelBinding(channel_id=channel.id, upstream_model=model_id, enabled=binding_enabled)])
        defaults = DefaultModels(**{f"{capability}_model": model_id if default else ""})
        snapshot = RoutingSnapshot(channels=[channel], logical_models=[model], default_models=defaults)
        monkeypatch.setattr("app.services.model_settings._routing_snapshot", snapshot)
        return snapshot

    yield configure
    current_operation.reset(operation_token)
    current_snapshot.reset(snapshot_token)


@pytest.mark.parametrize("capability", MODELS)
def test_disabled_model_cannot_use_explicit_or_default_direct_channel_fallback(routing, capability):
    snapshot = routing(capability, enabled=False)
    model_id = MODELS[capability]
    assert resolve_logical_model_candidates(capability, model_id) == []
    assert resolve_logical_model_candidates(capability, "") == []
    with pytest.raises(ValueError):
        resolve_upstream_model(capability, model_id)
    assert snapshot.channels[0].enabled is True


@pytest.mark.parametrize("capability,alias", [
    ("image", " seedream-5-0-pro "), ("video", "SEEDANCE-2-5"),
    ("video", "doubao-seedance-2-5-260628"),
])
def test_disabled_media_alias_cannot_be_admitted(routing, capability, alias):
    routing(capability, enabled=False)
    with pytest.raises(ValueError):
        pin_route(capability, alias)
    assert is_valid_project_media_model(alias, capability) is False


@pytest.mark.parametrize("capability", MODELS)
def test_disabled_binding_cannot_be_replaced_by_direct_or_environment_fallback(routing, capability):
    routing(capability, binding_enabled=False)
    assert resolve_logical_model_candidates(capability, MODELS[capability]) == []
    with pytest.raises(ValueError):
        resolve_upstream_model(capability, MODELS[capability])


@pytest.mark.parametrize("capability", MODELS)
def test_managed_capability_with_empty_default_cannot_reactivate_environment_model(routing, capability):
    routing(capability, enabled=False, default=False)
    assert resolve_logical_model_candidates(capability, "") == []
    with pytest.raises(ValueError):
        resolve_upstream_model(capability, None)


def test_unmanaged_custom_model_keeps_legacy_direct_routing(routing):
    snapshot = routing(enabled=False)
    snapshot.channels[0].models.append("custom-image-model")
    candidates = resolve_logical_model_candidates("image", "custom-image-model")
    assert [route.upstream_model for route in candidates] == ["custom-image-model"]
    assert resolve_upstream_model("image", "custom-image-model") == "custom-image-model"


def test_raw_upstream_request_respects_binding_switch_on_each_channel(routing):
    snapshot = routing()
    alpha = snapshot.channels[0]
    alpha.models = ["custom-image-model"]
    beta = alpha.model_copy(update={"id": "beta", "name": "Beta"})
    snapshot.channels.append(beta)
    snapshot.logical_models = [LogicalModel(id="friendly-image", capability="image", bindings=[
        LogicalModelBinding(channel_id="alpha", upstream_model="custom-image-model", enabled=False),
        LogicalModelBinding(channel_id="beta", upstream_model="custom-image-model", enabled=True),
    ])]
    candidates = resolve_logical_model_candidates("image", "custom-image-model")
    assert [route.channel_id for route in candidates] == ["beta"]


@pytest.mark.parametrize("capability,bucket", [("image", "image_models"), ("video", "video_models")])
def test_catalog_presets_channels_and_default_cannot_reinsert_disabled_model(routing, capability, bucket):
    snapshot = routing(capability, enabled=False)
    result = build_media_catalog(logical_models=snapshot.logical_models, channels=snapshot.channels,
                                defaults=snapshot.default_models)
    assert MODELS[capability] not in {row["id"] for row in result[bucket]}
    assert result["defaults"][f"{capability}_model"] == ""


async def test_priced_catalog_also_excludes_disabled_rows(routing, monkeypatch):
    routing("image", enabled=False)
    monkeypatch.setattr("app.services.media_models.catalog.active_book", AsyncMock(return_value=None))
    result = await priced_catalog(SimpleNamespace(), {
        "image_models": [{"id": MODELS["image"]}], "video_models": [],
    })
    assert result["image_models"] == []


@pytest.mark.parametrize("logical_enabled,binding_enabled", [(False, True), (True, False)])
def test_frozen_route_continues_when_only_model_or_binding_is_disabled(
    routing, logical_enabled, binding_enabled,
):
    snapshot = routing("video", enabled=logical_enabled, binding_enabled=binding_enabled)
    saved = {"capability": "video", "logical_model_id": MODELS["video"],
             "upstream_model": MODELS["video"], "channel_id": "alpha", "channel_name": "Alpha",
             "base_url": "https://original.test/v1", "protocol": "openai", "api_format": "openai"}
    restored = restore_route(saved)
    assert restored.base_url == saved["base_url"]
    assert restored.api_key == snapshot.channels[0].api_key


@pytest.mark.parametrize("capability", MODELS)
def test_managed_model_without_enabled_bindings_cannot_switch_to_another_model(routing, capability):
    snapshot = routing(capability, binding_enabled=False)
    other = snapshot.logical_models[0].model_copy(deep=True)
    other.id = "other-model"
    other.bindings[0].upstream_model = "other-model"
    other.bindings[0].enabled = True
    snapshot.logical_models.append(other)
    snapshot.channels[0].models.append("other-model")
    assert resolve_logical_model_candidates(capability, MODELS[capability]) == []
    with pytest.raises(ValueError):
        resolve_upstream_model(capability, MODELS[capability])


@pytest.mark.parametrize("capability", MODELS)
def test_ark_without_channels_cannot_reactivate_disabled_model_from_environment(routing, capability):
    from app.services.ark import ArkGateway

    snapshot = routing(capability, enabled=False)
    snapshot.channels.clear()
    gateway = ArkGateway(settings=Settings(_env_file=None, debug=False))
    with pytest.raises(ValueError):
        gateway._resolve_ark_route(capability, MODELS[capability])


@pytest.mark.parametrize("capability", ["image", "video", "audio"])
async def test_mock_generation_respects_disabled_model_before_creating_output(routing, monkeypatch, capability):
    from app.services.ark import ArkGateway

    routing(capability, enabled=False)
    gateway = ArkGateway(settings=Settings(_env_file=None, debug=False, ark_mock=True))
    image = Mock(return_value="/static/mock.png")
    edge = AsyncMock()
    monkeypatch.setattr(gateway, "_write_mock_image", image)
    monkeypatch.setattr(gateway, "_tts_edge", edge)
    with pytest.raises(ValueError):
        if capability == "image":
            await gateway.gen_image("test", model=MODELS[capability])
        elif capability == "video":
            await gateway.gen_video_i2v("https://test/image.png", "test", 5, model=MODELS[capability])
        else:
            await gateway.tts("disabled audio", "Cherry")
    image.assert_not_called()
    edge.assert_not_called()


@pytest.mark.parametrize("method", ["_tts_openai_speech", "_tts_openai_chat_audio"])
async def test_qwen_actual_upstream_cannot_bypass_disabled_logical_audio_switch(
    routing, monkeypatch, tmp_path, method,
):
    from app.services.ark import ArkGateway

    routing("audio", enabled=False)
    assert resolve_logical_model_candidates("audio", "qwen3-omni-flash") == []
    gateway = ArkGateway(settings=Settings(_env_file=None, debug=False, ark_api_key="env-key"))
    request = AsyncMock(return_value=SimpleNamespace(status_code=500, text="fail", content=b""))
    monkeypatch.setattr(gateway, "_request_media", request)
    with pytest.raises(ValueError):
        await getattr(gateway, method)("test", "Cherry", tmp_path / "audio.mp3", model="qwen3-omni-flash")
    request.assert_not_called()


async def test_audio_request_uses_enabled_binding_credentials(routing, monkeypatch, tmp_path):
    from app.services.ark import ArkGateway

    snapshot = routing("audio")
    gateway = ArkGateway(settings=Settings(_env_file=None, debug=False, ark_api_key="env-key",
                                          ark_base_url="https://environment.test/v1"))
    request = AsyncMock(return_value=SimpleNamespace(status_code=500, text="fail", content=b""))
    monkeypatch.setattr(gateway, "_request_media", request)
    await gateway._tts_openai_chat_audio("test", "Cherry", tmp_path / "audio.mp3", model="qwen3-omni-flash")
    assert request.call_args.args[2] == snapshot.channels[0].base_url + "/chat/completions"
    assert request.call_args.kwargs["headers"]["Authorization"] == "Bearer test-key"


async def test_disabled_audio_fallback_is_skipped_before_calling_provider(routing, monkeypatch, tmp_path):
    from app.services.ark import ArkGateway

    snapshot = routing("audio", enabled=False)
    enabled = LogicalModel(id="gemini-2.5-pro-preview-tts", capability="audio", bindings=[
        LogicalModelBinding(channel_id="alpha", upstream_model="gemini-2.5-pro-preview-tts"),
    ])
    snapshot.logical_models.append(enabled)
    snapshot.channels[0].models.append(enabled.id)
    snapshot.default_models.audio_model = enabled.id
    gateway = ArkGateway(settings=Settings(_env_file=None, debug=False, ark_mock=False, ark_api_key="env-key"))
    speech = AsyncMock(return_value=False)
    monkeypatch.setattr(gateway, "_tts_openai_speech", speech)
    monkeypatch.setattr("app.services.ark.iter_tokenfree_tts_models", lambda _: [enabled.id, "qwen3-omni-flash"])
    monkeypatch.setattr("app.services.storage.project_dir", lambda _: tmp_path)
    monkeypatch.setattr("app.services.storage.publish_local", lambda _: "/audio.mp3")
    monkeypatch.setattr("app.services.ark.is_near_silent_audio", lambda _: False)

    async def edge(_text, dest, **_kwargs):
        dest.write_bytes(b"a" * 4000)

    monkeypatch.setattr(gateway, "_tts_edge", edge)
    assert await gateway.tts("test", "Cherry") == "/audio.mp3"
    assert [call.kwargs["model"] for call in speech.call_args_list] == [enabled.id]


@pytest.mark.parametrize("method", ["expand_content", "chat_storyboard"])
async def test_mock_text_generation_cannot_bypass_disabled_model(routing, method):
    from app.services.ark import ArkGateway

    routing("text", enabled=False)
    gateway = ArkGateway(settings=Settings(_env_file=None, debug=False, ark_mock=True))
    with pytest.raises(ValueError):
        if method == "expand_content":
            await gateway.expand_content("test")
        else:
            await gateway.chat_storyboard("test", "theme", "", "", 5, 10, 5)


def test_frozen_image_route_still_resolves_after_model_is_disabled(routing):
    from app.services.ark import ArkGateway
    from app.services.media_models.runtime import current_snapshot

    snapshot = routing("image", enabled=False)
    saved = {"capability": "image", "logical_model_id": MODELS["image"],
             "upstream_model": MODELS["image"], "channel_id": "alpha", "channel_name": "Alpha",
             "base_url": "https://original.test/v1", "protocol": "openai", "api_format": "openai"}
    current_snapshot.set({"items": [{"capability": "image", "model_id": MODELS["image"],
                                    "operation_id": "image:0", "route": saved}]})
    gateway = ArkGateway(settings=Settings(_env_file=None, debug=False))
    route = gateway._resolve_ark_route("image", MODELS["image"])
    assert route.base_url == saved["base_url"]
    assert route.api_key == snapshot.channels[0].api_key


def test_image_snapshot_does_not_exempt_new_audio_from_disabled_guard(routing):
    from app.services.ark import ArkGateway
    from app.services.media_models.runtime import current_snapshot

    routing("audio", enabled=False)
    current_snapshot.set({"items": [{"capability": "image"}]})
    gateway = ArkGateway(settings=Settings(_env_file=None, debug=False))
    with pytest.raises(ValueError):
        gateway._resolve_ark_route("audio", None)


@pytest.mark.parametrize("capability,stale_model", [("image", "gpt-image-2"), ("video", "seedance-2.0")])
async def test_task_planning_cannot_use_stale_environment_model_when_managed_default_is_empty(
    routing, capability, stale_model,
):
    from app.config import get_settings
    from app.services.media_models.planning import plan_items

    snapshot = routing(capability, enabled=False, default=False)
    snapshot.channels.clear()
    setattr(get_settings(), f"model_{capability}", stale_model)
    task = SimpleNamespace(domain="studio", task_type=f"tool_{capability}", payload={},
                           asset_id=None, shot_id=None, fragment_id=None, drama_project_id=None)
    with pytest.raises(ValueError, match="默认"):
        await plan_items(None, task)
    task.payload = {"model_id": stale_model}
    items = await plan_items(None, task)
    assert items[0]["model_id"] == stale_model


@pytest.mark.parametrize("capability,upstream", [
    ("image", "doubao-seedream-5-0-pro-260628"),
    ("video", "doubao-seedance-2-5-260628"),
])
def test_frozen_model_body_resolution_continues_after_new_requests_are_disabled(routing, capability, upstream):
    from app.services.drama.build_seedance_generate_body import resolve_seedance_model_endpoint
    from app.services.drama.seedream_options import resolve_seedream_model_endpoint
    from app.services.media_models.runtime import current_snapshot

    routing(capability, enabled=False, binding_enabled=False)
    saved = {"capability": capability, "logical_model_id": MODELS[capability],
             "upstream_model": upstream, "channel_id": "alpha", "channel_name": "Alpha",
             "base_url": "https://original.test/v1", "protocol": "openai", "api_format": "openai"}
    current_snapshot.set({"items": [{"capability": capability, "model_id": MODELS[capability],
                                    "operation_id": capability + ":0", "route": saved}]})
    assert resolve_upstream_model(capability, MODELS[capability]) == upstream
    if capability == "image":
        assert resolve_seedream_model_endpoint(MODELS[capability]) == upstream
    else:
        assert resolve_seedance_model_endpoint(MODELS[capability]) == MODELS[capability]


def test_enabled_standard_seedream_is_independent_of_disabled_pro(routing):
    from app.config import get_settings
    from app.services.media_models.runtime import execution_params

    snapshot = routing("image", enabled=False)
    get_settings().model_image = MODELS["image"]
    snapshot.logical_models.append(LogicalModel(id="seedream-5.0", capability="image", bindings=[
        LogicalModelBinding(channel_id="alpha", upstream_model="seedream-5.0"),
    ]))
    snapshot.channels[0].models.append("seedream-5.0")
    snapshot.default_models.image_model = "seedream-5.0"
    assert resolve_upstream_model("image", "seedream-5.0") == "seedream-5.0"
    assert resolve_upstream_model("image", None) == "seedream-5.0"
    strategy, _, _ = execution_params("image", {"resolution": "2K"})
    assert strategy.model_id == "seedream-5.0"


async def test_custom_audio_logical_name_keeps_qwen_channel_after_upstream_alias_conversion(
    routing, monkeypatch, tmp_path,
):
    from app.services.ark import ArkGateway

    snapshot = routing("audio")
    snapshot.logical_models[0].id = "friendly-voice"
    snapshot.default_models.audio_model = "friendly-voice"
    gateway = ArkGateway(settings=Settings(_env_file=None, debug=False, ark_mock=False,
                                          local_media_mock=True, ark_api_key="env-key"))
    request = AsyncMock(return_value=SimpleNamespace(status_code=200, content=b"simulated audio"))
    monkeypatch.setattr(gateway, "_request_media", request)
    monkeypatch.setattr("app.services.storage.project_dir", lambda _: tmp_path)
    metadata = {}
    await gateway.tts("test", "Cherry", result_metadata=metadata)
    assert request.call_count == 1
    assert request.call_args.args[2] == "https://alpha.test/v1/chat/completions"
    assert request.call_args.kwargs["headers"]["Authorization"] == "Bearer test-key"
    assert request.call_args.kwargs["json"]["model"] == "qwen3-omni-flash"
    assert metadata["model_id"] == "qwen3-omni-flash"