Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
"""SQLite-backed tests for :mod:`services.model_load_balancing_service`."""
from __future__ import annotations
import json
from collections.abc import Generator
from contextlib import contextmanager
from typing import cast
from unittest.mock import MagicMock, patch
import pytest
from sqlalchemy import Engine, event, select
from sqlalchemy.orm import Session
from constants import HIDDEN_VALUE
from core.entities.provider_configuration import ProviderConfiguration, ProviderConfigurations
from core.entities.provider_entities import CustomConfiguration, CustomProviderConfiguration, SystemConfiguration
from core.plugin.impl.model_runtime_factory import PluginModelAssembly
from core.provider_manager import ProviderManager
from graphon.model_runtime.entities.common_entities import I18nObject
from graphon.model_runtime.entities.model_entities import ModelType
from graphon.model_runtime.entities.provider_entities import (
ConfigurateMethod,
CredentialFormSchema,
FieldModelSchema,
FormType,
ModelCredentialSchema,
ProviderCredentialSchema,
ProviderEntity,
)
from graphon.model_runtime.model_providers.model_provider_factory import ModelProviderFactory
from graphon.model_runtime.protocols.runtime import ModelRuntime
from models.engine import db
from models.enums import CredentialSourceType
from models.provider import (
LoadBalancingModelConfig,
ProviderCredential,
ProviderModelCredential,
ProviderModelSetting,
ProviderType,
)
from models.provider_ids import ModelProviderID
from services.model_load_balancing_service import ModelLoadBalancingService
pytestmark = pytest.mark.parametrize(
"sqlite_session",
[(LoadBalancingModelConfig, ProviderCredential, ProviderModelCredential, ProviderModelSetting)],
indirect=True,
)
def _provider_schema() -> ProviderCredentialSchema:
return ProviderCredentialSchema(
credential_form_schemas=[
CredentialFormSchema(variable="api_key", label=I18nObject(en_US="API Key"), type=FormType.SECRET_INPUT)
]
)
def _model_schema() -> ModelCredentialSchema:
return ModelCredentialSchema(
model=FieldModelSchema(label=I18nObject(en_US="Model")),
credential_form_schemas=[
CredentialFormSchema(variable="api_key", label=I18nObject(en_US="API Key"), type=FormType.SECRET_INPUT)
],
)
def _provider_configuration() -> ProviderConfiguration:
"""Build a concrete provider configuration for service tests."""
return ProviderConfiguration(
tenant_id="tenant-1",
provider=ProviderEntity(
provider="openai",
label=I18nObject(en_US="OpenAI"),
supported_model_types=[ModelType.LLM],
configurate_methods=[ConfigurateMethod.PREDEFINED_MODEL],
provider_credential_schema=_provider_schema(),
),
preferred_provider_type=ProviderType.SYSTEM,
using_provider_type=ProviderType.SYSTEM,
system_configuration=SystemConfiguration(enabled=False),
custom_configuration=CustomConfiguration(provider=None, models=[]),
model_settings=[],
)
type ServiceFixture = tuple[ModelLoadBalancingService, MagicMock, ProviderConfiguration]
@pytest.fixture
def service(monkeypatch: pytest.MonkeyPatch, sqlite_session: Session) -> ServiceFixture:
configuration = _provider_configuration()
manager = MagicMock()
manager.get_configurations.return_value = {"openai": configuration}
svc = ModelLoadBalancingService()
monkeypatch.setattr(svc, "_get_provider_manager", lambda _tenant_id: manager)
monkeypatch.setattr(
"services.model_load_balancing_service.create_plugin_provider_manager", lambda **_kwargs: manager
)
monkeypatch.setattr(
"services.model_load_balancing_service.ProviderManager.invalidate_configurations_cache", MagicMock()
)
monkeypatch.setattr("services.model_load_balancing_service.ProviderCredentialsCache", MagicMock())
sqlite_engine = cast(Engine, sqlite_session.get_bind())
monkeypatch.setattr(type(db), "engine", property(lambda _db: sqlite_engine))
return svc, manager, configuration
def _config(
session: Session,
*,
tenant_id: str = "tenant-1",
provider: str = "openai",
model: str = "gpt-4o-mini",
name: str = "primary",
encrypted_config: str | None = '{"api_key":"encrypted"}',
credential_id: str | None = None,
source: CredentialSourceType | None = None,
enabled: bool = True,
) -> LoadBalancingModelConfig:
config = LoadBalancingModelConfig(
tenant_id=tenant_id,
provider_name=provider,
model_name=model,
model_type=ModelType.LLM,
name=name,
encrypted_config=encrypted_config,
credential_id=credential_id,
credential_source_type=source,
enabled=enabled,
)
session.add(config)
session.commit()
return config
@contextmanager
def _raise_on_insert(engine: Engine) -> Generator[None]:
def raise_error(_conn, _cursor, statement: str, _parameters, _context, _executemany) -> None:
if statement.lstrip().upper().startswith("INSERT") and "load_balancing_model_configs" in statement:
raise RuntimeError("forced INSERT")
event.listen(engine, "before_cursor_execute", raise_error)
try:
yield
finally:
event.remove(engine, "before_cursor_execute", raise_error)
@pytest.mark.parametrize("enabled", [True, False])
def test_enable_disable_persists_provider_model_setting(
enabled: bool,
monkeypatch: pytest.MonkeyPatch,
sqlite_session: Session,
) -> None:
_config(sqlite_session, name="primary")
_config(sqlite_session, name="secondary")
configuration = _provider_configuration()
configurations = ProviderConfigurations(tenant_id="tenant-1")
configurations[str(ModelProviderID("openai"))] = configuration
manager = ProviderManager(cast(ModelRuntime, object()))
manager._configurations_cache["tenant-1"] = configurations
svc = ModelLoadBalancingService()
monkeypatch.setattr(svc, "_get_provider_manager", lambda _tenant_id: manager)
sqlite_engine = cast(Engine, sqlite_session.get_bind())
monkeypatch.setattr(type(db), "engine", property(lambda _db: sqlite_engine))
if enabled:
svc.enable_model_load_balancing("tenant-1", "openai", "gpt-4o-mini", "llm")
else:
svc.disable_model_load_balancing("tenant-1", "openai", "gpt-4o-mini", "llm")
sqlite_session.expire_all()
model_setting = sqlite_session.scalar(
select(ProviderModelSetting).where(
ProviderModelSetting.tenant_id == "tenant-1",
ProviderModelSetting.provider_name == "openai",
ProviderModelSetting.model_name == "gpt-4o-mini",
ProviderModelSetting.model_type == ModelType.LLM,
)
)
assert model_setting is not None
assert model_setting.load_balancing_enabled is enabled
def test_provider_missing_errors_use_runtime_boundary(service: ServiceFixture, sqlite_session: Session) -> None:
svc, manager, _ = service
manager.get_configurations.return_value = dict[str, object]()
with pytest.raises(ValueError, match="Provider openai does not exist"):
svc.enable_model_load_balancing("tenant-1", "openai", "model", ModelType.LLM)
with pytest.raises(ValueError, match="Provider openai does not exist"):
svc.get_load_balancing_configs("tenant-1", "openai", "model", ModelType.LLM, session=sqlite_session)
def test_get_configs_inserts_inherit_and_filters_tenant_provider_and_source(
monkeypatch: pytest.MonkeyPatch,
service: ServiceFixture,
sqlite_session: Session,
) -> None:
svc, _, configuration = service
configuration.custom_configuration.provider = CustomProviderConfiguration(credentials={})
sqlite_session.add(
ProviderModelSetting(
tenant_id="tenant-1",
provider_name="openai",
model_name="gpt-4o-mini",
model_type=ModelType.LLM,
load_balancing_enabled=True,
)
)
sqlite_session.commit()
matching = _config(sqlite_session, credential_id="cred-1", source=CredentialSourceType.PROVIDER, name="matching")
_config(sqlite_session, tenant_id="tenant-2", source=CredentialSourceType.PROVIDER, name="foreign-tenant")
_config(sqlite_session, provider="anthropic", source=CredentialSourceType.PROVIDER, name="foreign-provider")
_config(sqlite_session, source=CredentialSourceType.CUSTOM_MODEL, name="foreign-source")
monkeypatch.setattr(
"services.model_load_balancing_service.encrypter.get_decrypt_decoding", lambda _tenant: ("rsa", "cipher")
)
monkeypatch.setattr(
"services.model_load_balancing_service.encrypter.decrypt_token_with_decoding",
lambda _value, _decoding: "plain",
)
monkeypatch.setattr(
"services.model_load_balancing_service.LBModelManager.get_config_in_cooldown_and_ttl",
lambda **_kwargs: (False, 0),
)
enabled, configs = svc.get_load_balancing_configs(
"tenant-1",
"openai",
"gpt-4o-mini",
ModelType.LLM,
config_from="predefined-model",
session=sqlite_session,
)
assert enabled is True
assert [config["name"] for config in configs] == ["__inherit__", "matching"]
assert configs[1]["id"] == matching.id
assert configs[1]["credentials"] == {"api_key": "*" * 20}
persisted = sqlite_session.scalar(
select(LoadBalancingModelConfig).where(LoadBalancingModelConfig.name == "__inherit__")
)
assert persisted is not None
assert persisted.tenant_id == "tenant-1"
def test_get_configs_returns_empty_for_noncustom_provider(
monkeypatch: pytest.MonkeyPatch,
service: ServiceFixture,
sqlite_session: Session,
) -> None:
svc, _, _ = service
monkeypatch.setattr(
"services.model_load_balancing_service.encrypter.get_decrypt_decoding", lambda _tenant: ("rsa", "cipher")
)
enabled, configs = svc.get_load_balancing_configs(
"tenant-1", "openai", "gpt-4o-mini", ModelType.LLM, session=sqlite_session
)
assert enabled is False
assert configs == []
def test_get_configs_reorders_existing_inherit_and_tolerates_bad_credentials(
monkeypatch: pytest.MonkeyPatch,
service: ServiceFixture,
sqlite_session: Session,
) -> None:
svc, _, configuration = service
configuration.custom_configuration.provider = CustomProviderConfiguration(credentials={})
_config(sqlite_session, name="normal", encrypted_config='{"api_key":"bad"}')
_config(sqlite_session, name="__inherit__", encrypted_config="not-json", enabled=False)
monkeypatch.setattr(
"services.model_load_balancing_service.encrypter.get_decrypt_decoding", lambda _tenant: ("rsa", "cipher")
)
monkeypatch.setattr(
"services.model_load_balancing_service.encrypter.decrypt_token_with_decoding",
MagicMock(side_effect=ValueError("cannot decrypt")),
)
monkeypatch.setattr(
"services.model_load_balancing_service.LBModelManager.get_config_in_cooldown_and_ttl",
lambda **_kwargs: (True, 15),
)
_, configs = svc.get_load_balancing_configs(
"tenant-1", "openai", "gpt-4o-mini", ModelType.LLM, session=sqlite_session
)
assert [config["name"] for config in configs] == ["__inherit__", "normal"]
assert configs[0]["credentials"] == {}
assert configs[1]["credentials"] == {"api_key": "*" * 20}
assert configs[1]["in_cooldown"] is True
def test_get_single_config_is_tenant_scoped_and_obfuscated(service: ServiceFixture, sqlite_session: Session) -> None:
svc, _, _ = service
config = _config(sqlite_session, encrypted_config='{"api_key":"secret"}')
assert svc.get_load_balancing_config(
"tenant-1", "openai", "gpt-4o-mini", ModelType.LLM, config.id, session=sqlite_session
) == {"id": config.id, "name": "primary", "credentials": {"api_key": "*" * 20}, "enabled": True}
assert (
svc.get_load_balancing_config(
"tenant-2", "openai", "gpt-4o-mini", ModelType.LLM, config.id, session=sqlite_session
)
is None
)
def test_init_inherit_config_persists_and_sql_failure_rolls_back(
service: ServiceFixture,
sqlite_session: Session,
) -> None:
svc, _, _ = service
created = svc._init_inherit_config("tenant-1", "openai", "gpt-4o-mini", ModelType.LLM, sqlite_session)
assert sqlite_session.get(LoadBalancingModelConfig, created.id) is not None
sqlite_session.delete(created)
sqlite_session.commit()
sqlite_engine = cast(Engine, sqlite_session.get_bind())
with _raise_on_insert(sqlite_engine), pytest.raises(RuntimeError, match="forced INSERT"):
svc._init_inherit_config("tenant-1", "openai", "gpt-4o-mini", ModelType.LLM, sqlite_session)
sqlite_session.rollback()
assert sqlite_session.scalar(select(LoadBalancingModelConfig)) is None
@pytest.mark.parametrize(
("configs", "message"),
[
("invalid", "Invalid load balancing configs"),
(["invalid"], "Invalid load balancing config"),
([{"enabled": True}], "Invalid load balancing config name"),
([{"name": "missing-enabled"}], "Invalid load balancing config enabled"),
],
)
def test_update_configs_rejects_invalid_payloads(
configs: object,
message: str,
service: ServiceFixture,
sqlite_session: Session,
) -> None:
svc, _, _ = service
with pytest.raises(ValueError, match=message):
svc.update_load_balancing_configs(
"tenant-1",
"openai",
"gpt-4o-mini",
ModelType.LLM,
configs, # pyrefly: ignore[bad-argument-type]
"custom-model",
sqlite_session,
)
@pytest.mark.parametrize("existing", [True, False])
def test_update_configs_rejects_invalid_credentials_for_existing_and_new_configs(
existing: bool,
service: ServiceFixture,
sqlite_session: Session,
) -> None:
svc, _, _ = service
config = _config(sqlite_session) if existing else None
payload = {"name": "new", "enabled": True, "credentials": "bad"}
if config is not None:
payload["id"] = config.id
with pytest.raises(ValueError, match="Invalid load balancing config credentials"):
svc.update_load_balancing_configs(
"tenant-1", "openai", "gpt-4o-mini", ModelType.LLM, [payload], "custom-model", sqlite_session
)
def test_update_configs_updates_creates_and_deletes_persisted_rows(
monkeypatch: pytest.MonkeyPatch,
service: ServiceFixture,
sqlite_session: Session,
) -> None:
svc, _, _ = service
keep = _config(sqlite_session, name="keep", encrypted_config='{"api_key":"old"}')
removed = _config(sqlite_session, name="remove")
monkeypatch.setattr(
svc,
"_custom_credentials_validate",
lambda **kwargs: {"api_key": f"enc-{kwargs['credentials']['api_key']}"},
)
svc.update_load_balancing_configs(
"tenant-1",
"openai",
"gpt-4o-mini",
ModelType.LLM,
[
{"id": keep.id, "name": "updated", "enabled": False, "credentials": {"api_key": "new"}},
{"name": "created", "enabled": True, "credentials": {"api_key": "fresh"}},
],
"custom-model",
sqlite_session,
)
sqlite_session.expire_all()
records = sqlite_session.scalars(select(LoadBalancingModelConfig)).all()
assert {record.name for record in records} == {"updated", "created"}
assert sqlite_session.get(LoadBalancingModelConfig, removed.id) is None
updated = sqlite_session.get(LoadBalancingModelConfig, keep.id)
assert updated is not None
assert updated.enabled is False
assert updated.encrypted_config is not None
assert json.loads(updated.encrypted_config) == {"api_key": "enc-new"}
def test_update_configs_creates_from_tenant_scoped_provider_credential(
service: ServiceFixture, sqlite_session: Session
) -> None:
svc, _, _ = service
credential = ProviderCredential(
tenant_id="tenant-1",
provider_name="openai",
credential_name="Credential",
encrypted_config='{"api_key":"enc"}',
)
foreign = ProviderCredential(
tenant_id="tenant-2",
provider_name="openai",
credential_name="Foreign",
encrypted_config="{}",
)
sqlite_session.add_all([credential, foreign])
sqlite_session.commit()
svc.update_load_balancing_configs(
"tenant-1",
"openai",
"gpt-4o-mini",
ModelType.LLM,
[{"credential_id": credential.id, "enabled": True}],
"predefined-model",
sqlite_session,
)
created = sqlite_session.scalar(select(LoadBalancingModelConfig))
assert created is not None
assert created.name == "Credential"
assert created.credential_id == credential.id
assert created.credential_source_type == CredentialSourceType.PROVIDER
with pytest.raises(ValueError, match="not found"):
svc.update_load_balancing_configs(
"tenant-1",
"openai",
"other-model",
ModelType.LLM,
[{"credential_id": foreign.id, "enabled": True}],
"predefined-model",
sqlite_session,
)
def test_validate_credentials_uses_real_config_lookup(
monkeypatch: pytest.MonkeyPatch,
service: ServiceFixture,
sqlite_session: Session,
) -> None:
svc, manager, _ = service
config = _config(sqlite_session)
assembly = PluginModelAssembly(tenant_id="tenant-1")
assembly._provider_manager = manager
assembly._model_provider_factory = ModelProviderFactory(runtime=cast(ModelRuntime, object()))
monkeypatch.setattr(
"services.model_load_balancing_service.create_plugin_model_assembly", lambda **_kwargs: assembly
)
validate = MagicMock()
monkeypatch.setattr(svc, "_custom_credentials_validate", validate)
svc.validate_load_balancing_credentials(
"tenant-1",
"openai",
"gpt-4o-mini",
ModelType.LLM,
{"api_key": "raw"},
sqlite_session,
config.id,
)
assert validate.call_args.kwargs["load_balancing_model_config"].id == config.id
with pytest.raises(ValueError, match="does not exist"):
svc.validate_load_balancing_credentials(
"tenant-1", "openai", "gpt-4o-mini", ModelType.LLM, {}, sqlite_session, "missing"
)
def test_custom_credentials_validate_reuses_hidden_secret_and_encrypts(
monkeypatch: pytest.MonkeyPatch,
service: ServiceFixture,
sqlite_session: Session,
) -> None:
svc, _, configuration = service
config = _config(sqlite_session, encrypted_config='{"api_key":"old-encrypted"}')
monkeypatch.setattr("services.model_load_balancing_service.encrypter.decrypt_token", lambda *_args: "old-plain")
monkeypatch.setattr(
"services.model_load_balancing_service.encrypter.encrypt_token", lambda _tenant, value: f"enc-{value}"
)
result = svc._custom_credentials_validate(
"tenant-1",
configuration,
ModelType.LLM,
"gpt-4o-mini",
{"api_key": HIDDEN_VALUE},
config,
validate=False,
)
assert result == {"api_key": "enc-old-plain"}
def test_schema_selection_and_cache_boundary(service: ServiceFixture) -> None:
svc, _, configuration = service
provider_schema = configuration.provider.provider_credential_schema
assert svc._get_credential_schema(configuration) is provider_schema
configuration.provider.model_credential_schema = _model_schema()
assert isinstance(svc._get_credential_schema(configuration), ModelCredentialSchema)
configuration.provider.model_credential_schema = None
configuration.provider.provider_credential_schema = None
with pytest.raises(ValueError, match="No credential schema"):
svc._get_credential_schema(configuration)
with patch("services.model_load_balancing_service.ProviderCredentialsCache") as cache:
svc._clear_credentials_cache("tenant-1", "config-1")
cache.return_value.delete.assert_called_once()