Enterprise agent platform for building, deploying, and operating AI teammates.
"""Test model service functionality"""
from contextlib import ExitStack
from types import SimpleNamespace
from unittest.mock import MagicMock, patch
import pytest
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from xagent.web.models.database import Base
from xagent.web.models.model import Model
from xagent.web.models.user import User, UserDefaultModel, UserModel
from xagent.web.services.llm_utils import UserAwareModelStorage
from xagent.web.services.model_service import (
_create_default_llm_instance,
_is_model_visible_to_user,
get_asr_models,
get_compact_model,
get_default_asr_model,
get_default_embedding_model,
get_default_image_edit_model,
get_default_image_generate_model,
get_default_model,
get_default_music_model,
get_default_rerank_model,
get_default_sound_effect_model,
get_default_tts_model,
get_default_vision_model,
get_embedding_model,
get_fast_model,
get_image_models,
get_music_models,
get_sound_effect_models,
get_tts_models,
get_vision_model,
set_model_visibility_hook,
set_visible_user_ids_hook,
)
# Test database setup - use in-memory database
SQLALCHEMY_DATABASE_URL = "sqlite:///:memory:"
engine = create_engine(
SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False}
)
TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
def test_batch_asr_registry_and_shared_default_skip_live_only_models(monkeypatch):
live = SimpleNamespace(
id=1,
model_provider="elevenlabs",
model_name="scribe_v2_realtime",
abilities=["asr"],
base_url=None,
)
batch = SimpleNamespace(
id=2,
model_provider="elevenlabs",
model_name="scribe_v2",
abilities=["asr"],
base_url=None,
)
db = MagicMock()
query = db.query.return_value
query.filter.return_value = query
query.join.return_value = query
query.first.return_value = SimpleNamespace(model=live)
monkeypatch.setattr(
"xagent.web.services.model_service._is_model_visible_to_user",
lambda *args: True,
)
monkeypatch.setattr(
"xagent.web.services.model_service._get_visible_user_ids", lambda *args: [1]
)
with patch("xagent.core.model.asr.adapter.get_asr_model_instance") as factory:
query.all.return_value = [live, batch]
models = get_asr_models(db, user_id=1)
assert list(models) == ["scribe_v2"]
factory.assert_called_once_with(batch)
factory.reset_mock()
query.all.return_value = [
SimpleNamespace(model=live),
SimpleNamespace(model=batch),
]
assert get_default_asr_model(1, db=db) is factory.return_value
factory.assert_called_once_with(batch)
@pytest.fixture
def owned_model_session(monkeypatch):
"""Expose one observable Session through the model-session owner."""
mock_db = MagicMock()
session_factory = MagicMock(return_value=mock_db)
monkeypatch.setattr(
"xagent.web.models.database._SessionLocal",
session_factory,
)
return mock_db, session_factory
@pytest.fixture(scope="function")
def db_session():
"""Create database session"""
Base.metadata.create_all(bind=engine)
db = TestingSessionLocal()
yield db
db.close()
Base.metadata.drop_all(bind=engine)
@pytest.fixture(scope="function")
def admin_user(db_session):
"""Create admin user"""
user = User(username="admin", password_hash="hashed_admin_pass", is_admin=True)
db_session.add(user)
db_session.commit()
db_session.refresh(user)
return user
@pytest.fixture(scope="function")
def regular_user(db_session):
"""Create regular user"""
user = User(username="regularuser", password_hash="hashed_pass", is_admin=False)
db_session.add(user)
db_session.commit()
db_session.refresh(user)
return user
@pytest.fixture(scope="function")
def sample_model(db_session):
"""Create sample model"""
model = Model(
model_id="test-openai-model",
category="llm",
model_provider="openai",
model_name="gpt-4",
api_key="test-api-key",
base_url="https://api.openai.com/v1",
temperature=0.7,
abilities=["chat", "tool_calling"],
)
db_session.add(model)
db_session.commit()
db_session.refresh(model)
return model
class TestModelService:
"""Test model service functionality"""
def test_configured_auto_default_uses_user_aware_resolver(self):
db = MagicMock()
db_model = MagicMock(
model_provider="router", model_name="auto", model_id="router-auto"
)
resolved_llm = MagicMock()
with (
patch(
"xagent.web.services.llm_utils.UserAwareModelStorage"
) as storage_class,
patch(
"xagent.web.services.llm_utils._create_llm_instance"
) as legacy_create,
):
storage_class.return_value.get_llm_by_id.return_value = resolved_llm
result = _create_default_llm_instance(db, db_model, user_id=7)
assert result is resolved_llm
storage_class.assert_called_once_with(db)
storage_class.return_value.get_llm_by_id.assert_called_once_with(
"router-auto", 7
)
legacy_create.assert_not_called()
def test_user_aware_shared_default_query_skips_inactive_model(
self, db_session, admin_user, regular_user, monkeypatch
):
model = Model(
model_id="shared-general",
category="llm",
model_provider="openai",
model_name="shared-general",
api_key="test-api-key",
abilities=["chat"],
is_active=False,
)
db_session.add(model)
db_session.flush()
db_session.add_all(
[
UserModel(
user_id=admin_user.id,
model_id=model.id,
is_owner=True,
is_shared=True,
),
UserDefaultModel(
user_id=admin_user.id,
model_id=model.id,
config_type="general",
),
]
)
db_session.commit()
storage = UserAwareModelStorage(db_session)
monkeypatch.setattr(
storage,
"_create_default_model",
lambda db_model, user_id: str(db_model.model_id),
)
monkeypatch.setattr(
"xagent.web.services.llm_utils.create_llm_from_env", lambda: None
)
assert (
storage.get_configured_defaults(regular_user.id, config_types=("general",))[
0
]
is None
)
model.is_active = True
db_session.commit()
assert (
storage.get_configured_defaults(regular_user.id, config_types=("general",))[
0
]
== "shared-general"
)
@pytest.mark.parametrize(
("resolver_name", "config_type", "category", "factory_kind"),
[
("vision", "visual", "llm", "chat"),
("general", "general", "llm", "chat"),
("fast", "small_fast", "llm", "chat"),
("compact", "compact", "llm", "chat"),
("embedding_instance", "embedding", "embedding", "embedding"),
("image_generate", "image", "image", "image"),
("image_edit", "image_edit", "image", "image"),
("embedding_id", "embedding", "embedding", None),
("rerank_id", "rerank", "rerank", None),
("asr", "asr", "asr", "asr"),
("tts", "tts", "tts", "tts"),
],
)
def test_shared_default_resolvers_skip_inactive_models(
self,
db_session,
admin_user,
resolver_name,
config_type,
category,
factory_kind,
):
model = Model(
model_id=f"shared-{resolver_name}",
category=category,
model_provider="openai",
model_name=f"shared-{resolver_name}",
api_key="test-api-key",
abilities=["chat", "generate"],
is_active=False,
)
db_session.add(model)
db_session.flush()
db_session.add_all(
[
UserModel(
user_id=admin_user.id,
model_id=model.id,
is_owner=True,
is_shared=True,
),
UserDefaultModel(
user_id=admin_user.id,
model_id=model.id,
config_type=config_type,
),
]
)
db_session.commit()
resolvers = {
"vision": lambda: get_default_vision_model(None, db=db_session),
"general": lambda: get_default_model(None),
"fast": lambda: get_fast_model(None),
"compact": lambda: get_compact_model(None),
"embedding_instance": lambda: get_embedding_model(None),
"image_generate": lambda: get_default_image_generate_model(
None, db=db_session
),
"image_edit": lambda: get_default_image_edit_model(None, db=db_session),
"embedding_id": lambda: get_default_embedding_model(None, db=db_session),
"rerank_id": lambda: get_default_rerank_model(None, db=db_session),
"asr": lambda: get_default_asr_model(None, db=db_session),
"tts": lambda: get_default_tts_model(None, db=db_session),
}
factory_targets = {
"chat": "xagent.web.services.model_service._create_default_llm_instance",
"embedding": "xagent.web.services.llm_utils._create_llm_instance",
"image": "xagent.core.model.image.adapter.get_image_model_instance",
"asr": "xagent.core.model.asr.adapter.get_asr_model_instance",
"tts": "xagent.core.model.tts.adapter.get_tts_model_instance",
}
with ExitStack() as stack:
stack.enter_context(
patch(
"xagent.web.models.database.get_db",
side_effect=lambda: iter([db_session]),
)
)
factory = (
stack.enter_context(patch(factory_targets[factory_kind]))
if factory_kind
else None
)
if factory is not None:
factory.return_value = MagicMock(name=f"{resolver_name}-instance")
assert resolvers[resolver_name]() is None
if factory is not None:
factory.assert_not_called()
model.is_active = True
db_session.commit()
result = resolvers[resolver_name]()
if factory is None:
assert result == model.model_id
else:
factory.assert_called_once()
assert result is factory.return_value
def test_get_default_model_user_specific(self):
"""Test getting user-specific default model"""
with (
patch("xagent.web.models.database.get_db") as mock_get_db,
patch("xagent.web.services.llm_utils._create_llm_instance") as mock_create,
):
# Setup mock database session
mock_db = MagicMock()
mock_get_db.return_value = iter([mock_db])
# Create mock objects
mock_user_default = MagicMock()
mock_user_default.user_id = 1
mock_user_default.config_type = "general"
mock_user_default.model = MagicMock()
mock_user_default.model.model_id = "test-model"
# Setup query result
mock_db.query.return_value.join.return_value.filter.return_value.first.return_value = mock_user_default
# Setup mock LLM creation
mock_llm = MagicMock()
mock_create.return_value = mock_llm
result = get_default_model(1)
assert result == mock_llm
mock_create.assert_called_once_with(mock_user_default.model)
def test_get_default_model_admin_shared(self):
"""Test getting admin shared default model — admin fallback uses _get_visible_user_ids."""
with (
patch("xagent.web.models.database.get_db") as mock_get_db,
patch("xagent.web.services.llm_utils._create_llm_instance") as mock_create,
patch(
"xagent.web.services.model_service._get_visible_user_ids"
) as mock_visible,
):
# _get_visible_user_ids returns admin user IDs
mock_visible.return_value = [1]
# Setup mock database session
mock_db = MagicMock()
mock_get_db.return_value = iter([mock_db])
# Setup query to return None for user-specific query and shared default for shared query
mock_query_result = MagicMock()
mock_query_result.first.return_value = None
mock_query_result.all.return_value = [MagicMock()]
mock_db.query.return_value.join.return_value.filter.return_value = (
mock_query_result
)
# Setup mock LLM creation
mock_llm = MagicMock()
mock_create.return_value = mock_llm
result = get_default_model(2) # regular user
assert result == mock_llm
mock_create.assert_called_once()
# Verify _get_visible_user_ids was called for admin fallback
mock_visible.assert_called_with(mock_db, 2)
def test_get_default_model_no_user_id(self):
"""Test getting default model without user ID - falls through to visible users fallback."""
with (
patch("xagent.web.models.database.get_db") as mock_get_db,
patch("xagent.web.services.llm_utils._create_llm_instance") as mock_create,
patch(
"xagent.web.services.model_service._get_visible_user_ids"
) as mock_visible,
):
mock_visible.return_value = [1]
mock_db = MagicMock()
mock_get_db.return_value = iter([mock_db])
# No user-specific default
mock_query_result = MagicMock()
mock_query_result.first.return_value = None
mock_query_result.all.return_value = [MagicMock()]
mock_db.query.return_value.join.return_value.filter.return_value = (
mock_query_result
)
mock_llm = MagicMock()
mock_create.return_value = mock_llm
result = get_default_model(None)
assert result == mock_llm
mock_visible.assert_called_with(mock_db, None)
def test_get_default_model_no_configuration(self):
"""Test getting default model when no configuration exists - should return None"""
with patch("xagent.web.models.database.get_db") as mock_get_db:
# Setup mock database session
mock_db = MagicMock()
mock_get_db.return_value = iter([mock_db])
# Setup query to return no results
mock_db.query.return_value.join.return_value.filter.return_value.first.return_value = None
mock_db.query.return_value.join.return_value.filter.return_value.all.return_value = []
result = get_default_model(1)
assert result is None
def test_model_service_multiple_users(self):
"""Test model service with multiple users — both fall through to admin shared default."""
with (
patch("xagent.web.models.database.get_db") as mock_get_db,
patch("xagent.web.services.llm_utils._create_llm_instance") as mock_create,
patch(
"xagent.web.services.model_service._get_visible_user_ids"
) as mock_visible,
):
mock_visible.return_value = [1] # admin user ID is visible to everyone
# Setup mock database session - create a new session for each call
mock_db1 = MagicMock()
mock_db2 = MagicMock()
mock_get_db.side_effect = [iter([mock_db1]), iter([mock_db2])]
# Setup query to return None for individual user defaults and shared default for shared query
mock_query_result1 = MagicMock()
mock_query_result1.first.return_value = None
mock_query_result1.all.return_value = [MagicMock()]
mock_db1.query.return_value.join.return_value.filter.return_value = (
mock_query_result1
)
mock_query_result2 = MagicMock()
mock_query_result2.first.return_value = None
mock_query_result2.all.return_value = [MagicMock()]
mock_db2.query.return_value.join.return_value.filter.return_value = (
mock_query_result2
)
# Setup mock LLM creation
mock_llm = MagicMock()
mock_create.return_value = mock_llm
# Both users should get the same shared model
admin_result = get_default_model(1) # admin user
regular_result = get_default_model(2) # regular user
assert admin_result == mock_llm
assert regular_result == mock_llm
# Should have been called twice (once for each user)
assert mock_create.call_count == 2
# _get_visible_user_ids should have been called for both users
assert mock_visible.call_count == 2
def test_is_model_visible_to_user_fails_closed_on_exception(self):
"""Visibility check must return False (deny) when the query raises."""
with patch(
"xagent.web.services.model_service._get_visible_user_ids"
) as mock_visible:
mock_visible.side_effect = RuntimeError("DB connection lost")
mock_db = MagicMock()
# Ownership check (step 1) returns None so code reaches step 2
mock_db.query.return_value.filter.return_value.first.return_value = None
result = _is_model_visible_to_user(mock_db, 1, 1)
assert result is False
def test_get_default_model_stale_default_skipped(self):
"""Stale user default (model no longer visible) falls through to admin fallback."""
with (
patch("xagent.web.models.database.get_db") as mock_get_db,
patch("xagent.web.services.llm_utils._create_llm_instance") as mock_create,
patch(
"xagent.web.services.model_service._get_visible_user_ids"
) as mock_visible,
patch(
"xagent.web.services.model_service._is_model_visible_to_user"
) as mock_visibility,
):
mock_visible.return_value = [1]
mock_visibility.return_value = False # model NOT visible — stale
mock_db = MagicMock()
mock_get_db.return_value = iter([mock_db])
# UserDefaultModel found, but visibility check fails
mock_user_default = MagicMock()
mock_user_default.user_id = 42
mock_user_default.config_type = "general"
mock_user_default.model = MagicMock()
mock_user_default.model.id = 42
mock_first_result = MagicMock()
mock_first_result.first.return_value = mock_user_default
mock_all_result = MagicMock()
mock_all_result.all.return_value = [MagicMock()]
# Two filter calls: one for user-specific (returns None after visibility fails),
# then admin fallback
mock_db.query.return_value.join.return_value.filter.side_effect = [
mock_first_result, # user-specific query
mock_all_result, # admin fallback query
]
mock_llm = MagicMock()
mock_create.return_value = mock_llm
result = get_default_model(42)
assert result == mock_llm
# Visibility check was called
mock_visibility.assert_called_once_with(mock_db, 42, 42)
# Admin fallback was used (create_llm called)
mock_create.assert_called_once()
# _get_visible_user_ids was called for admin fallback
mock_visible.assert_called_with(mock_db, 42)
def test_get_vision_model_filters_by_visibility(self):
"""get_vision_model returns the first visible vision-capable model."""
with (
patch(
"xagent.web.services.model_service._is_model_visible_to_user"
) as mock_visibility,
patch("xagent.web.services.llm_utils._create_llm_instance") as mock_create,
):
mock_db = MagicMock()
# Two vision-capable models
visible_model = MagicMock()
visible_model.id = 1
invisible_model = MagicMock()
invisible_model.id = 2
mock_db.query.return_value.filter.return_value.all.return_value = [
visible_model,
invisible_model,
]
# First model is visible, second is not
mock_visibility.side_effect = [True, False]
mock_llm = MagicMock()
mock_create.return_value = mock_llm
result = get_vision_model(mock_db, user_id=42)
assert result == mock_llm
mock_create.assert_called_once_with(visible_model)
assert mock_visibility.call_count == 1 # stops after first visible
def test_get_vision_model_returns_none_when_no_visible(self):
"""get_vision_model returns None when no vision model is visible."""
with patch(
"xagent.web.services.model_service._is_model_visible_to_user"
) as mock_visibility:
mock_db = MagicMock()
invisible_model = MagicMock()
invisible_model.id = 1
mock_db.query.return_value.filter.return_value.all.return_value = [
invisible_model
]
mock_visibility.return_value = False
result = get_vision_model(mock_db, user_id=42)
assert result is None
def test_get_image_models_filters_by_visibility(self):
"""get_image_models excludes image models not visible to the user."""
with (
patch(
"xagent.web.services.model_service._is_model_visible_to_user"
) as mock_visibility,
patch(
"xagent.web.services.model_service.DashScopeImageModel"
) as mock_dashscope,
):
mock_db = MagicMock()
visible_model = MagicMock()
visible_model.id = 1
visible_model.api_key = "key1"
visible_model.base_url = "http://url1"
visible_model.model_provider = "dashscope"
visible_model.model_name = "visible-model"
visible_model.model_id = "mid-1"
visible_model.abilities = ["generate"]
# An int, not the MagicMock default: _add_image_model_with_id now
# clamps this value with max(), which needs something orderable.
visible_model.max_retries = 3
invisible_model = MagicMock()
invisible_model.id = 2
invisible_model.api_key = "key2"
invisible_model.base_url = "http://url2"
invisible_model.model_provider = "dashscope"
invisible_model.model_name = "invisible-model"
invisible_model.model_id = "mid-2"
invisible_model.abilities = ["generate"]
invisible_model.max_retries = 3
mock_db.query.return_value.filter.return_value.all.return_value = [
visible_model,
invisible_model,
]
mock_visibility.side_effect = [True, False]
mock_instance = MagicMock()
mock_dashscope.return_value = mock_instance
result = get_image_models(mock_db, user_id=42)
assert len(result) == 1
assert "mid-1" in result
assert "mid-2" not in result
def test_get_asr_models_filters_by_visibility(self):
"""get_asr_models excludes speech models not visible to the user."""
with (
patch(
"xagent.web.services.model_service._is_model_visible_to_user"
) as mock_visibility,
patch(
"xagent.core.model.asr.adapter.get_asr_model_instance"
) as mock_asr_instance,
):
mock_db = MagicMock()
visible_model = MagicMock()
visible_model.id = 1
visible_model.abilities = ["asr"]
visible_model.api_key = "key1"
visible_model.base_url = "http://url1"
visible_model.model_provider = "xinference"
visible_model.model_name = "visible-asr"
invisible_model = MagicMock()
invisible_model.id = 2
invisible_model.abilities = ["asr"]
invisible_model.api_key = "key2"
invisible_model.base_url = "http://url2"
invisible_model.model_provider = "xinference"
invisible_model.model_name = "invisible-asr"
mock_db.query.return_value.filter.return_value.all.return_value = [
visible_model,
invisible_model,
]
mock_visibility.side_effect = [True, False]
mock_instance = MagicMock()
mock_asr_instance.return_value = mock_instance
result = get_asr_models(mock_db, user_id=42)
assert len(result) == 1
assert "visible-asr" in result
assert "invisible-asr" not in result
def test_get_tts_models_filters_by_visibility(self):
"""get_tts_models excludes speech models not visible to the user."""
with (
patch(
"xagent.web.services.model_service._is_model_visible_to_user"
) as mock_visibility,
patch(
"xagent.core.model.tts.adapter.get_tts_model_instance"
) as mock_tts_instance,
):
mock_db = MagicMock()
visible_model = MagicMock()
visible_model.id = 1
visible_model.abilities = ["tts"]
visible_model.api_key = "key1"
visible_model.base_url = "http://url1"
visible_model.model_provider = "xinference"
visible_model.model_name = "visible-tts"
invisible_model = MagicMock()
invisible_model.id = 2
invisible_model.abilities = ["tts"]
invisible_model.api_key = "key2"
invisible_model.base_url = "http://url2"
invisible_model.model_provider = "xinference"
invisible_model.model_name = "invisible-tts"
mock_db.query.return_value.filter.return_value.all.return_value = [
visible_model,
invisible_model,
]
mock_visibility.side_effect = [True, False]
mock_instance = MagicMock()
mock_tts_instance.return_value = mock_instance
result = get_tts_models(mock_db, user_id=42)
assert len(result) == 1
assert "visible-tts" in result
assert "invisible-tts" not in result
def test_get_tts_models_loads_elevenlabs_without_base_url(self):
"""ElevenLabs TTS models use SDK defaults and should not require base_url."""
with (
patch(
"xagent.web.services.model_service._is_model_visible_to_user"
) as mock_visibility,
patch(
"xagent.core.model.tts.adapter.get_tts_model_instance"
) as mock_tts_instance,
):
mock_db = MagicMock()
visible_model = MagicMock()
visible_model.id = 1
visible_model.abilities = ["tts"]
visible_model.api_key = "key1"
visible_model.base_url = None
visible_model.model_provider = "elevenlabs"
visible_model.model_name = "eleven_v3"
mock_db.query.return_value.filter.return_value.all.return_value = [
visible_model
]
mock_visibility.return_value = True
mock_instance = MagicMock()
mock_tts_instance.return_value = mock_instance
result = get_tts_models(mock_db, user_id=42)
assert result == {"eleven_v3": mock_instance}
def test_get_asr_models_loads_elevenlabs_without_base_url(self):
"""ElevenLabs ASR models use SDK defaults and should not require base_url."""
with (
patch(
"xagent.web.services.model_service._is_model_visible_to_user"
) as mock_visibility,
patch(
"xagent.core.model.asr.adapter.get_asr_model_instance"
) as mock_asr_instance,
):
mock_db = MagicMock()
visible_model = MagicMock()
visible_model.id = 1
visible_model.abilities = ["asr"]
visible_model.api_key = "key1"
visible_model.base_url = None
visible_model.model_provider = "elevenlabs"
visible_model.model_name = "scribe_v2"
mock_db.query.return_value.filter.return_value.all.return_value = [
visible_model
]
mock_visibility.return_value = True
mock_instance = MagicMock()
mock_asr_instance.return_value = mock_instance
result = get_asr_models(mock_db, user_id=42)
assert result == {"scribe_v2": mock_instance}
def test_get_sound_effect_models_uses_independent_category(self):
with (
patch(
"xagent.web.services.model_service._is_model_visible_to_user",
return_value=True,
),
patch(
"xagent.core.model.sound_effect.get_sound_effect_model_instance"
) as mock_instance_factory,
):
mock_db = MagicMock()
db_model = MagicMock()
db_model.id = 1
db_model.model_id = "sound-effect-default"
db_model.model_name = "eleven_text_to_sound_v2"
db_model.category = "sound_effect"
db_model.is_active = True
mock_db.query.return_value.filter.return_value.all.return_value = [db_model]
model = MagicMock()
mock_instance_factory.return_value = model
result = get_sound_effect_models(mock_db, user_id=42)
assert result == {"sound-effect-default": model}
mock_instance_factory.assert_called_once_with(db_model)
def test_get_music_models_uses_independent_category(self):
with (
patch(
"xagent.web.services.model_service._is_model_visible_to_user",
return_value=True,
),
patch(
"xagent.core.model.music.get_music_model_instance"
) as mock_instance_factory,
):
mock_db = MagicMock()
db_model = MagicMock()
db_model.id = 1
db_model.model_id = "music-default"
db_model.model_name = "music_v2"
db_model.category = "music"
db_model.is_active = True
mock_db.query.return_value.filter.return_value.all.return_value = [db_model]
model = MagicMock()
mock_instance_factory.return_value = model
result = get_music_models(mock_db, user_id=42)
assert result == {"music-default": model}
mock_instance_factory.assert_called_once_with(db_model)
@pytest.mark.parametrize(
"get_default",
[get_default_sound_effect_model, get_default_music_model],
)
def test_audio_generation_default_closes_owned_session(self, get_default):
mock_db = MagicMock()
filter_query = (
mock_db.query.return_value.join.return_value.join.return_value.filter
)
shared_query = filter_query.return_value
shared_query.limit.return_value.all.return_value = []
session_factory = MagicMock(return_value=mock_db)
with patch("xagent.web.models.database._SessionLocal", session_factory):
result = get_default(user_id=None)
assert result is None
assert any(
getattr(getattr(condition, "right", None), "value", None) == '"generate"'
for condition in filter_query.call_args.args
)
session_factory.assert_called_once_with()
mock_db.close.assert_called_once_with()
@pytest.mark.parametrize(
"get_default",
[get_default_sound_effect_model, get_default_music_model],
)
def test_audio_generation_shared_default_requires_active_model(self, get_default):
"""The shared-default branch must filter on is_active.
Without it an inactive shared default still resolves to a model
instance that is absent from the audio tool's own registry, so its
usage records fall back to a phantom model name instead of the real
one. This mirrors the user-default branch, which already filtered.
"""
mock_db = MagicMock()
filter_query = (
mock_db.query.return_value.join.return_value.join.return_value.filter
)
filter_query.return_value.limit.return_value.all.return_value = []
session_factory = MagicMock(return_value=mock_db)
with patch("xagent.web.models.database._SessionLocal", session_factory):
get_default(user_id=None)
# The is_active column itself is passed as a filter condition, so look
# for a condition naming that column rather than a comparison value.
assert filter_query.call_args is not None, (
"the shared-default query never reached its filter() call"
)
assert any(
getattr(condition, "key", None) == "is_active"
or getattr(getattr(condition, "left", None), "key", None) == "is_active"
for condition in filter_query.call_args.args
), "shared audio-generation default must filter on DBModel.is_active"
@pytest.mark.parametrize(
("get_default", "category", "config_type", "factory_module"),
[
(
get_default_sound_effect_model,
"sound_effect",
"sound_effect",
"xagent.core.model.sound_effect.get_sound_effect_model_instance",
),
(
get_default_music_model,
"music",
"music",
"xagent.core.model.music.get_music_model_instance",
),
],
)
def test_audio_generation_shared_default_skips_inactive_model(
self,
db_session,
admin_user,
get_default,
category,
config_type,
factory_module,
):
"""An inactive shared default must not be selected or instantiated.
The expression-shape assertion above only proves that *some* condition
naming ``is_active`` is present; an inverted predicate such as
``DBModel.is_active.is_(False)`` would satisfy it while still handing
back a deactivated model. This exercises the real query against SQLite
so polarity is observable: the inactive row must be skipped, and an
active one must still be returned.
"""
inactive = Model(
model_id=f"inactive-{category}",
category=category,
model_provider="test",
model_name=f"inactive-{category}",
api_key="test-api-key",
abilities=["generate"],
is_active=False,
)
db_session.add(inactive)
db_session.commit()
db_session.refresh(inactive)
db_session.add(
UserModel(user_id=admin_user.id, model_id=inactive.id, is_shared=True)
)
db_session.add(
UserDefaultModel(
user_id=admin_user.id,
model_id=inactive.id,
config_type=config_type,
)
)
db_session.commit()
with patch(factory_module) as factory:
assert get_default(user_id=None, db=db_session) is None
factory.assert_not_called()
# Same wiring, but active: proves the query is not simply matching
# nothing for an unrelated reason.
inactive.is_active = True
db_session.commit()
with patch(factory_module) as factory:
result = get_default(user_id=None, db=db_session)
factory.assert_called_once()
assert result is factory.return_value
@pytest.mark.parametrize(
"get_default",
[get_default_embedding_model, get_default_rerank_model],
)
def test_text_default_closes_owned_session_after_shared_fallback(
self, get_default, owned_model_session, monkeypatch
):
mock_db, session_factory = owned_model_session
shared_default = MagicMock()
shared_default.model.model_id = "shared-text-model"
shared_query = mock_db.query.return_value.join.return_value.join.return_value.filter.return_value
shared_query.limit.return_value.all.return_value = [shared_default]
monkeypatch.setattr(
"xagent.web.services.model_service._get_visible_user_ids",
lambda db, user_id: [1],
)
result = get_default(user_id=None)
assert result == "shared-text-model"
session_factory.assert_called_once_with()
mock_db.close.assert_called_once_with()
@pytest.mark.parametrize(
"get_default",
[get_default_embedding_model, get_default_rerank_model],
)
def test_text_default_closes_owned_session_after_user_early_return(
self, get_default, owned_model_session, monkeypatch
):
mock_db, session_factory = owned_model_session
user_default = MagicMock()
user_default.model.id = 42
user_default.model.model_id = "user-text-model"
user_query = mock_db.query.return_value.join.return_value.filter.return_value
user_query.first.return_value = user_default
monkeypatch.setattr(
"xagent.web.services.model_service._is_model_visible_to_user",
lambda db, model_id, user_id: True,
)
result = get_default(user_id=7)
assert result == "user-text-model"
session_factory.assert_called_once_with()
mock_db.close.assert_called_once_with()
@pytest.mark.parametrize(
("get_default", "propagates"),
[
(get_default_embedding_model, True),
(get_default_rerank_model, False),
],
)
def test_text_default_closes_owned_session_after_query_error(
self, get_default, propagates, owned_model_session
):
mock_db, session_factory = owned_model_session
mock_db.query.side_effect = RuntimeError("query failed")
if propagates:
with pytest.raises(RuntimeError, match="query failed"):
get_default(user_id=None)
else:
assert get_default(user_id=None) is None
session_factory.assert_called_once_with()
mock_db.close.assert_called_once_with()
@pytest.mark.parametrize(
"get_default",
[get_default_embedding_model, get_default_rerank_model],
)
def test_text_default_does_not_close_caller_owned_session(
self, get_default, monkeypatch
):
caller_db = MagicMock()
shared_query = caller_db.query.return_value.join.return_value.join.return_value.filter.return_value
shared_query.limit.return_value.all.return_value = []
monkeypatch.setattr(
"xagent.web.services.model_service._get_visible_user_ids",
lambda db, user_id: [1],
)
assert get_default(user_id=None, db=caller_db) is None
caller_db.close.assert_not_called()
@pytest.mark.parametrize(
("get_default", "propagates"),
[
(get_default_embedding_model, True),
(get_default_rerank_model, False),
],
)
def test_text_default_does_not_close_caller_owned_session_after_query_error(
self, get_default, propagates
):
caller_db = MagicMock()
caller_db.query.side_effect = RuntimeError("query failed")
if propagates:
with pytest.raises(RuntimeError, match="query failed"):
get_default(user_id=None, db=caller_db)
else:
assert get_default(user_id=None, db=caller_db) is None
caller_db.close.assert_not_called()
def test_rerank_default_propagates_owned_session_factory_error(self, monkeypatch):
def fail_session_factory():
raise RuntimeError("session factory failed")
monkeypatch.setattr(
"xagent.web.models.database._SessionLocal",
fail_session_factory,
)
with pytest.raises(RuntimeError, match="session factory failed"):
get_default_rerank_model(user_id=None)
def test_rerank_default_propagates_owned_session_close_error(
self, owned_model_session
):
mock_db, _session_factory = owned_model_session
shared_query = mock_db.query.return_value.join.return_value.filter.return_value
shared_query.limit.return_value.all.return_value = []
mock_db.close.side_effect = RuntimeError("session close failed")
with pytest.raises(RuntimeError, match="session close failed"):
get_default_rerank_model(user_id=None)
class TestModelVisibilityHook:
"""The model visibility hook hides individual models from individual users."""
@pytest.fixture(autouse=True)
def _reset_hooks(self):
set_model_visibility_hook(None)
set_visible_user_ids_hook(None)
yield
set_model_visibility_hook(None)
set_visible_user_ids_hook(None)
@staticmethod
def _image_model(db, admin, model_id, *, shared=True, default_for=()):
model = Model(
model_id=model_id,
category="image",
model_provider="openai",
model_name=model_id,
api_key="k",
base_url="http://u",
abilities=["generate", "edit"],
)
db.add(model)
db.flush()
db.add(
UserModel(
user_id=admin.id, model_id=model.id, is_owner=True, is_shared=shared
)
)
for config_type in default_for:
db.add(
UserDefaultModel(
user_id=admin.id, model_id=model.id, config_type=config_type
)
)
db.commit()
return model
@staticmethod
def _hide(model_id):
return lambda db, user_id, db_model: db_model.model_id != model_id
def test_hook_hides_shared_model(self, db_session, admin_user, regular_user):
qwen = self._image_model(db_session, admin_user, "qwen")
assert _is_model_visible_to_user(db_session, qwen.id, regular_user.id)
set_model_visibility_hook(self._hide("qwen"))
assert not _is_model_visible_to_user(db_session, qwen.id, regular_user.id)
assert "qwen" not in get_image_models(db_session, user_id=regular_user.id)
def test_hook_hides_owned_model(self, db_session, admin_user, regular_user):
qwen = self._image_model(db_session, admin_user, "qwen")
db_session.add(
UserModel(
user_id=regular_user.id,
model_id=qwen.id,
is_owner=True,
is_shared=False,
)
)
db_session.commit()
assert _is_model_visible_to_user(db_session, qwen.id, regular_user.id)
set_model_visibility_hook(self._hide("qwen"))
assert not _is_model_visible_to_user(db_session, qwen.id, regular_user.id)
def test_hook_only_narrows_for_the_hidden_user(
self, db_session, admin_user, regular_user
):
qwen = self._image_model(db_session, admin_user, "qwen")
set_model_visibility_hook(
lambda db, user_id, m: (
not (user_id == regular_user.id and m.model_id == "qwen")
)
)
assert not _is_model_visible_to_user(db_session, qwen.id, regular_user.id)
assert _is_model_visible_to_user(db_session, qwen.id, admin_user.id)
assert _is_model_visible_to_user(db_session, qwen.id, None)
def test_none_hook_is_noop(self, db_session, admin_user, regular_user):
qwen = self._image_model(db_session, admin_user, "qwen")
set_model_visibility_hook(self._hide("qwen"))
set_model_visibility_hook(None)
assert _is_model_visible_to_user(db_session, qwen.id, regular_user.id)
def test_missing_model_row_skips_hook(self, db_session, regular_user):
calls = []
set_model_visibility_hook(lambda *a: calls.append(a) or False)
# No such Model row: the hook is not asked, the normal checks decide.
assert not _is_model_visible_to_user(db_session, 9999, regular_user.id)
assert calls == []
@pytest.mark.parametrize(
"config_type,getter",
[
("image", get_default_image_generate_model),
("image_edit", get_default_image_edit_model),
],
)
def test_default_image_getter_skips_hidden_default(
self, db_session, admin_user, regular_user, config_type, getter
):
# admin's shared default is Qwen; a second visible user shares gpt-image.
other = User(username="other", password_hash="x", is_admin=True)
db_session.add(other)
db_session.commit()
qwen = self._image_model(
db_session, admin_user, "qwen", default_for=[config_type]
)
gpt = self._image_model(
db_session, other, "gpt-image", default_for=[config_type]
)
# The user's own default is Qwen as well.
db_session.add(
UserDefaultModel(
user_id=regular_user.id, model_id=qwen.id, config_type=config_type
)
)
db_session.commit()
set_visible_user_ids_hook(lambda db, user_id: [admin_user.id, other.id])
with patch(
"xagent.core.model.image.adapter.get_image_model_instance",
side_effect=lambda m: MagicMock(),
):
set_model_visibility_hook(self._hide("qwen"))
result = getter(regular_user.id, db=db_session)
assert result is not None
assert result.model_id == gpt.model_id