Mirrors/mealie
1
0
Fork 0
mirror of https://github.com/mealie-recipes/mealie.git synced 2026-05-25 19:20:26 -04:00
Code Issues Packages Projects Releases Wiki Activity

feat: In-app AI Provider Configuration (#7650)

Browse Source
This commit is contained in:
Michael Genson
2026-05-23 11:13:10 -05:00
committed by GitHub
parent f6fe92b400
commit c3f87736d0
86 changed files with 3325 additions and 297 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
tests/conftest.py
View File

@@ -20,7 +20,6 @@ mp = MonkeyPatch()
mp.setenv("PRODUCTION", "True")
mp.setenv("TESTING", "True")
mp.setenv("ALLOW_SIGNUP", "True")
mp.setenv("OPENAI_API_KEY", "dummy-api-key")
from pathlib import Path
from fastapi.testclient import TestClient

136
tests/integration_tests/admin_tests/test_admin_ai_providers.py Normal file
View File

@@ -0,0 +1,136 @@
"""
Integration tests for admin AI provider management across groups.
"""
from fastapi.testclient import TestClient
from mealie.schema.group.ai_providers import AIProviderCreate
from tests.utils import api_routes
from tests.utils.factories import random_string
from tests.utils.fixture_schemas import TestUser
# =======================================================================
# Permissions
def test_admin_ai_provider_routes_require_admin(api_client: TestClient, unique_user: TestUser, admin_user: TestUser):
"""Non-admin users cannot access admin AI provider routes."""
group_id = unique_user.group_id
response = api_client.post(
api_routes.admin_groups_group_id_ai_providers_providers(group_id),
json={"name": random_string(), "model": "gpt-4o", "apiKey": "key"},
headers=unique_user.token,
)
assert response.status_code == 403
# =======================================================================
# Provider CRUD
def test_admin_create_ai_provider_for_group(api_client: TestClient, admin_user: TestUser, unique_user: TestUser):
"""Admin can create an AI provider for any group."""
provider_name = random_string()
response = api_client.post(
api_routes.admin_groups_group_id_ai_providers_providers(unique_user.group_id),
json={"name": provider_name, "model": "gpt-4o", "apiKey": "admin-created-key"},
headers=admin_user.token,
)
assert response.status_code == 200
provider = response.json()
try:
assert provider["name"] == provider_name
assert provider["model"] == "gpt-4o"
assert "id" in provider
assert "apiKey" not in provider
finally:
unique_user.repos.group_ai_providers.delete(provider["id"])
def test_admin_get_ai_provider_for_group(api_client: TestClient, admin_user: TestUser, unique_user: TestUser):
"""Admin can retrieve an AI provider from any group."""
provider = unique_user.repos.group_ai_providers.create(
AIProviderCreate(name=random_string(), model="gpt-4o", api_key="secret")
)
try:
response = api_client.get(
api_routes.admin_groups_group_id_ai_providers_providers_provider_id(unique_user.group_id, provider.id),
headers=admin_user.token,
)
assert response.status_code == 200
data = response.json()
assert data["id"] == str(provider.id)
assert data["name"] == provider.name
finally:
unique_user.repos.group_ai_providers.delete(provider.id)
def test_admin_update_ai_provider_for_group(api_client: TestClient, admin_user: TestUser, unique_user: TestUser):
"""Admin can update an AI provider in any group."""
provider = unique_user.repos.group_ai_providers.create(
AIProviderCreate(name=random_string(), model="gpt-4o", api_key="original-key")
)
try:
new_name = random_string()
response = api_client.put(
api_routes.admin_groups_group_id_ai_providers_providers_provider_id(unique_user.group_id, provider.id),
json={"name": new_name, "model": "gpt-4-turbo", "apiKey": "updated-key"},
headers=admin_user.token,
)
assert response.status_code == 200
data = response.json()
assert data["name"] == new_name
assert data["model"] == "gpt-4-turbo"
finally:
unique_user.repos.group_ai_providers.delete(provider.id)
def test_admin_delete_ai_provider_for_group(api_client: TestClient, admin_user: TestUser, unique_user: TestUser):
"""Admin can delete an AI provider from any group."""
provider = unique_user.repos.group_ai_providers.create(
AIProviderCreate(name=random_string(), model="gpt-4o", api_key="to-delete")
)
response = api_client.delete(
api_routes.admin_groups_group_id_ai_providers_providers_provider_id(unique_user.group_id, provider.id),
headers=admin_user.token,
)
assert response.status_code == 200
# Confirm gone
response = api_client.get(
api_routes.admin_groups_group_id_ai_providers_providers_provider_id(unique_user.group_id, provider.id),
headers=admin_user.token,
)
assert response.status_code == 404
def test_admin_can_manage_providers_across_groups(api_client: TestClient, admin_user: TestUser, unique_user: TestUser):
"""Admin can create providers in a group they are not a member of."""
# Create a brand new group the admin doesn't belong to
group_name = random_string()
create_resp = api_client.post(api_routes.admin_groups, json={"name": group_name}, headers=admin_user.token)
assert create_resp.status_code == 201
foreign_group_id = create_resp.json()["id"]
try:
response = api_client.post(
api_routes.admin_groups_group_id_ai_providers_providers(foreign_group_id),
json={"name": random_string(), "model": "gpt-4o", "apiKey": "cross-group-key"},
headers=admin_user.token,
)
assert response.status_code == 200
provider_id = response.json()["id"]
# Settings should also be accessible
# Cleanup provider before deleting group
api_client.delete(
api_routes.admin_groups_group_id_ai_providers_providers_provider_id(foreign_group_id, provider_id),
headers=admin_user.token,
)
finally:
api_client.delete(api_routes.admin_groups_item_id(foreign_group_id), headers=admin_user.token)

95
tests/integration_tests/admin_tests/test_admin_group_actions.py
View File

@@ -2,6 +2,7 @@ from fastapi.testclient import TestClient
from mealie.core.config import get_app_settings
from mealie.repos.repository_factory import AllRepositories
from mealie.schema.group.ai_providers import AIProviderCreate, AIProviderSettingsUpdate
from mealie.schema.user.user import GroupInDB
from tests.utils import api_routes
from tests.utils.assertion_helpers import assert_ignore_keys
@@ -79,6 +80,100 @@ def test_admin_update_group(api_client: TestClient, admin_user: TestUser, unique
assert_ignore_keys(as_json["preferences"], update_payload["preferences"]) # type: ignore
def test_admin_update_group_name_only(api_client: TestClient, admin_user: TestUser, unique_user: TestUser):
"""Updating only the name leaves preferences and ai_provider_settings untouched."""
new_name = random_string()
response = api_client.put(
api_routes.admin_groups_item_id(unique_user.group_id),
json={"id": unique_user.group_id, "name": new_name},
headers=admin_user.token,
)
assert response.status_code == 200
assert response.json()["name"] == new_name
def test_admin_update_group_ai_provider_settings(api_client: TestClient, admin_user: TestUser, unique_user: TestUser):
"""Admin can update ai_provider_settings for a group via the PUT endpoint."""
provider = unique_user.repos.group_ai_providers.create(
AIProviderCreate(name=random_string(), model="gpt-4o", api_key="test-key")
)
try:
update_payload = {
"id": unique_user.group_id,
"name": unique_user.group_id, # name is required but unchanged
"aiProviderSettings": {
"defaultProviderId": str(provider.id),
"audioProviderId": str(provider.id),
"imageProviderId": str(provider.id),
},
}
response = api_client.put(
api_routes.admin_groups_item_id(unique_user.group_id),
json=update_payload,
headers=admin_user.token,
)
assert response.status_code == 200
settings = response.json()["aiProviderSettings"]
assert settings["defaultProviderId"] == str(provider.id)
assert settings["audioProviderId"] == str(provider.id)
assert settings["imageProviderId"] == str(provider.id)
finally:
# Clear provider references before deleting the provider
unique_user.repos.group_ai_provider_settings.update(
unique_user.repos.group_id,
AIProviderSettingsUpdate(default_provider_id=None, audio_provider_id=None, image_provider_id=None),
)
unique_user.repos.group_ai_providers.delete(provider.id)
def test_admin_update_group_ai_provider_settings_clear(
api_client: TestClient, admin_user: TestUser, unique_user: TestUser
):
"""Admin can clear ai_provider_settings provider IDs for a group."""
provider = unique_user.repos.group_ai_providers.create(
AIProviderCreate(name=random_string(), model="gpt-4o", api_key="test-key")
)
try:
# First set the providers
api_client.put(
api_routes.admin_groups_item_id(unique_user.group_id),
json={
"id": unique_user.group_id,
"name": unique_user.group_id,
"aiProviderSettings": {
"defaultProviderId": str(provider.id),
"audioProviderId": None,
"imageProviderId": None,
},
},
headers=admin_user.token,
)
# Now clear them
response = api_client.put(
api_routes.admin_groups_item_id(unique_user.group_id),
json={
"id": unique_user.group_id,
"name": unique_user.group_id,
"aiProviderSettings": {
"defaultProviderId": None,
"audioProviderId": None,
"imageProviderId": None,
},
},
headers=admin_user.token,
)
assert response.status_code == 200
settings = response.json()["aiProviderSettings"]
assert settings["defaultProviderId"] is None
assert settings["audioProviderId"] is None
assert settings["imageProviderId"] is None
finally:
unique_user.repos.group_ai_providers.delete(provider.id)
def test_admin_delete_group(unfiltered_database: AllRepositories, api_client: TestClient, admin_user: TestUser):
group = unfiltered_database.groups.create({"name": random_string()})
response = api_client.delete(api_routes.admin_groups_item_id(group.id), headers=admin_user.token)

584
tests/integration_tests/user_group_tests/test_group_ai_providers.py Normal file
View File

@@ -0,0 +1,584 @@
"""
Integration tests for AI provider CRUD, settings, permissions, and API key security.
"""
from uuid import uuid4
from fastapi.testclient import TestClient
from mealie.schema.group.ai_providers import AIProviderCreate, AIProviderSettingsUpdate
from tests.utils import api_routes
from tests.utils.factories import random_string, user_registration_factory
from tests.utils.fixture_schemas import TestUser
# ==========================================
# Provider CRUD
# ==========================================
def test_create_provider(api_client: TestClient, unique_user: TestUser):
data = {"name": random_string(), "model": "gpt-4o", "apiKey": "test-key"}
response = api_client.post(api_routes.groups_ai_providers_providers, json=data, headers=unique_user.token)
assert response.status_code == 200
provider = response.json()
assert provider["name"] == data["name"]
assert provider["model"] == data["model"]
assert "id" in provider
api_client.delete(api_routes.groups_ai_providers_providers_provider_id(provider["id"]), headers=unique_user.token)
def test_get_provider(api_client: TestClient, unique_user: TestUser):
# Create a provider first
provider = unique_user.repos.group_ai_providers.create(
AIProviderCreate(name=random_string(), model="gpt-4o", api_key="test-key")
)
try:
response = api_client.get(
api_routes.groups_ai_providers_providers_provider_id(provider.id), headers=unique_user.token
)
assert response.status_code == 200
data = response.json()
assert data["id"] == str(provider.id)
assert data["name"] == provider.name
assert data["model"] == provider.model
finally:
api_client.delete(api_routes.groups_ai_providers_providers_provider_id(provider.id), headers=unique_user.token)
def test_get_provider_not_found(api_client: TestClient, unique_user: TestUser):
response = api_client.get(api_routes.groups_ai_providers_providers_provider_id(uuid4()), headers=unique_user.token)
assert response.status_code == 404
def test_update_provider(api_client: TestClient, unique_user: TestUser):
provider = unique_user.repos.group_ai_providers.create(
AIProviderCreate(name=random_string(), model="gpt-4o", api_key="original-key")
)
try:
new_model = "gpt-4-turbo"
update_data = {"name": provider.name, "model": new_model, "apiKey": "updated-key"}
response = api_client.put(
api_routes.groups_ai_providers_providers_provider_id(provider.id),
json=update_data,
headers=unique_user.token,
)
assert response.status_code == 200
updated = response.json()
assert updated["model"] == new_model
assert updated["id"] == str(provider.id)
finally:
api_client.delete(api_routes.groups_ai_providers_providers_provider_id(provider.id), headers=unique_user.token)
def test_delete_provider(api_client: TestClient, unique_user: TestUser):
provider = unique_user.repos.group_ai_providers.create(
AIProviderCreate(name=random_string(), model="gpt-4o", api_key="test-key")
)
response = api_client.delete(
api_routes.groups_ai_providers_providers_provider_id(provider.id), headers=unique_user.token
)
assert response.status_code == 200
# Verify it's gone
response = api_client.get(
api_routes.groups_ai_providers_providers_provider_id(provider.id), headers=unique_user.token
)
assert response.status_code == 404
# ==========================================
# Provider Settings CRUD
# ==========================================
def test_get_settings(api_client: TestClient, unique_user: TestUser):
response = api_client.get(api_routes.groups_ai_providers_settings, headers=unique_user.token)
assert response.status_code == 200
settings = response.json()
assert "providers" in settings
assert "defaultProviderId" in settings
assert "audioProviderId" in settings
assert "imageProviderId" in settings
def test_update_settings_set_default_provider(api_client: TestClient, unique_user: TestUser):
provider = unique_user.repos.group_ai_providers.create(
AIProviderCreate(name=random_string(), model="gpt-4o", api_key="test-key")
)
try:
update = {"defaultProviderId": str(provider.id), "audioProviderId": None, "imageProviderId": None}
response = api_client.put(api_routes.groups_ai_providers_settings, json=update, headers=unique_user.token)
assert response.status_code == 200
settings = response.json()
assert settings["defaultProviderId"] == str(provider.id)
finally:
unique_user.repos.group_ai_provider_settings.update(
unique_user.repos.group_id,
AIProviderSettingsUpdate(default_provider_id=None, audio_provider_id=None, image_provider_id=None),
)
api_client.delete(api_routes.groups_ai_providers_providers_provider_id(provider.id), headers=unique_user.token)
def test_update_settings_all_provider_types(api_client: TestClient, unique_user: TestUser):
default_provider = unique_user.repos.group_ai_providers.create(
AIProviderCreate(name=random_string(), model="gpt-4o", api_key="test-key")
)
audio_provider = unique_user.repos.group_ai_providers.create(
AIProviderCreate(name=random_string(), model="whisper-1", api_key="test-key")
)
image_provider = unique_user.repos.group_ai_providers.create(
AIProviderCreate(name=random_string(), model="dall-e-3", api_key="test-key")
)
try:
update = {
"defaultProviderId": str(default_provider.id),
"audioProviderId": str(audio_provider.id),
"imageProviderId": str(image_provider.id),
}
response = api_client.put(api_routes.groups_ai_providers_settings, json=update, headers=unique_user.token)
assert response.status_code == 200
settings = response.json()
assert settings["defaultProviderId"] == str(default_provider.id)
assert settings["audioProviderId"] == str(audio_provider.id)
assert settings["imageProviderId"] == str(image_provider.id)
finally:
unique_user.repos.group_ai_provider_settings.update(
unique_user.repos.group_id,
AIProviderSettingsUpdate(default_provider_id=None, audio_provider_id=None, image_provider_id=None),
)
for p in [default_provider, audio_provider, image_provider]:
api_client.delete(api_routes.groups_ai_providers_providers_provider_id(p.id), headers=unique_user.token)
def test_update_settings_clear_providers(api_client: TestClient, unique_user: TestUser):
provider = unique_user.repos.group_ai_providers.create(
AIProviderCreate(name=random_string(), model="gpt-4o", api_key="test-key")
)
unique_user.repos.group_ai_provider_settings.update(
unique_user.repos.group_id,
AIProviderSettingsUpdate(default_provider_id=provider.id, audio_provider_id=None, image_provider_id=None),
)
try:
# Now clear all
update = {"defaultProviderId": None, "audioProviderId": None, "imageProviderId": None}
response = api_client.put(api_routes.groups_ai_providers_settings, json=update, headers=unique_user.token)
assert response.status_code == 200
settings = response.json()
assert settings["defaultProviderId"] is None
finally:
api_client.delete(api_routes.groups_ai_providers_providers_provider_id(provider.id), headers=unique_user.token)
def test_settings_providers_list_populated(api_client: TestClient, unique_user: TestUser):
provider = unique_user.repos.group_ai_providers.create(
AIProviderCreate(name=random_string(), model="gpt-4o", api_key="test-key")
)
try:
response = api_client.get(api_routes.groups_ai_providers_settings, headers=unique_user.token)
assert response.status_code == 200
provider_ids = [p["id"] for p in response.json()["providers"]]
assert str(provider.id) in provider_ids
finally:
api_client.delete(api_routes.groups_ai_providers_providers_provider_id(provider.id), headers=unique_user.token)
# ==========================================
# Delete provider cascades to settings
# ==========================================
def test_delete_default_provider_clears_settings(api_client: TestClient, unique_user: TestUser):
provider = unique_user.repos.group_ai_providers.create(
AIProviderCreate(name=random_string(), model="gpt-4o", api_key="test-key")
)
unique_user.repos.group_ai_provider_settings.update(
unique_user.repos.group_id,
AIProviderSettingsUpdate(default_provider_id=provider.id, audio_provider_id=None, image_provider_id=None),
)
# Delete the provider
response = api_client.delete(
api_routes.groups_ai_providers_providers_provider_id(provider.id), headers=unique_user.token
)
assert response.status_code == 200
# Settings should now have nulled-out default
settings = unique_user.repos.group_ai_provider_settings.get_one(unique_user.repos.group_id)
assert settings is not None
assert settings.default_provider_id is None
def test_delete_audio_provider_clears_settings(api_client: TestClient, unique_user: TestUser):
default_provider = unique_user.repos.group_ai_providers.create(
AIProviderCreate(name=random_string(), model="gpt-4o", api_key="test-key")
)
audio_provider = unique_user.repos.group_ai_providers.create(
AIProviderCreate(name=random_string(), model="whisper-1", api_key="test-key")
)
unique_user.repos.group_ai_provider_settings.update(
unique_user.repos.group_id,
AIProviderSettingsUpdate(
default_provider_id=default_provider.id,
audio_provider_id=audio_provider.id,
image_provider_id=None,
),
)
try:
# Delete only the audio provider
api_client.delete(
api_routes.groups_ai_providers_providers_provider_id(audio_provider.id), headers=unique_user.token
)
settings = unique_user.repos.group_ai_provider_settings.get_one(unique_user.repos.group_id)
assert settings is not None
assert settings.audio_provider_id is None
assert settings.default_provider_id == default_provider.id
finally:
unique_user.repos.group_ai_provider_settings.update(
unique_user.repos.group_id,
AIProviderSettingsUpdate(default_provider_id=None, audio_provider_id=None, image_provider_id=None),
)
api_client.delete(
api_routes.groups_ai_providers_providers_provider_id(default_provider.id), headers=unique_user.token
)
def test_delete_image_provider_clears_settings(api_client: TestClient, unique_user: TestUser):
default_provider = unique_user.repos.group_ai_providers.create(
AIProviderCreate(name=random_string(), model="gpt-4o", api_key="test-key")
)
image_provider = unique_user.repos.group_ai_providers.create(
AIProviderCreate(name=random_string(), model="dall-e-3", api_key="test-key")
)
unique_user.repos.group_ai_provider_settings.update(
unique_user.repos.group_id,
AIProviderSettingsUpdate(
default_provider_id=default_provider.id,
audio_provider_id=None,
image_provider_id=image_provider.id,
),
)
try:
# Delete only the image provider
api_client.delete(
api_routes.groups_ai_providers_providers_provider_id(image_provider.id), headers=unique_user.token
)
settings = unique_user.repos.group_ai_provider_settings.get_one(unique_user.repos.group_id)
assert settings is not None
assert settings.image_provider_id is None
assert settings.default_provider_id == default_provider.id
finally:
unique_user.repos.group_ai_provider_settings.update(
unique_user.repos.group_id,
AIProviderSettingsUpdate(default_provider_id=None, audio_provider_id=None, image_provider_id=None),
)
api_client.delete(
api_routes.groups_ai_providers_providers_provider_id(default_provider.id), headers=unique_user.token
)
# ==========================================
# Permissions: can_manage required
# ==========================================
def test_providers_require_can_manage_get(api_client: TestClient, user_tuple: list[TestUser]):
usr, _ = user_tuple
# Ensure user does NOT have can_manage
user = usr.repos.users.get_one(usr.user_id)
assert user
user.can_manage = False
usr.repos.users.update(user.id, user)
# Create a provider so there's something to GET (using repos directly to bypass permission check)
provider = usr.repos.group_ai_providers.create(
AIProviderCreate(name=random_string(), model="gpt-4o", api_key="test-key")
)
try:
response = api_client.get(api_routes.groups_ai_providers_providers_provider_id(provider.id), headers=usr.token)
assert response.status_code == 403
finally:
usr.repos.group_ai_providers.delete(provider.id)
def test_providers_require_can_manage_create(api_client: TestClient, user_tuple: list[TestUser]):
usr, _ = user_tuple
user = usr.repos.users.get_one(usr.user_id)
assert user
user.can_manage = False
usr.repos.users.update(user.id, user)
data = {"name": random_string(), "model": "gpt-4o", "apiKey": "test-key"}
response = api_client.post(api_routes.groups_ai_providers_providers, json=data, headers=usr.token)
assert response.status_code == 403
def test_providers_require_can_manage_update(api_client: TestClient, user_tuple: list[TestUser]):
usr, _ = user_tuple
user = usr.repos.users.get_one(usr.user_id)
assert user
user.can_manage = False
usr.repos.users.update(user.id, user)
provider = usr.repos.group_ai_providers.create(
AIProviderCreate(name=random_string(), model="gpt-4o", api_key="test-key")
)
try:
update_data = {"name": provider.name, "model": "gpt-4-turbo", "apiKey": "key"}
response = api_client.put(
api_routes.groups_ai_providers_providers_provider_id(provider.id), json=update_data, headers=usr.token
)
assert response.status_code == 403
finally:
usr.repos.group_ai_providers.delete(provider.id)
def test_providers_require_can_manage_delete(api_client: TestClient, user_tuple: list[TestUser]):
usr, _ = user_tuple
user = usr.repos.users.get_one(usr.user_id)
assert user
user.can_manage = False
usr.repos.users.update(user.id, user)
provider = usr.repos.group_ai_providers.create(
AIProviderCreate(name=random_string(), model="gpt-4o", api_key="test-key")
)
try:
response = api_client.delete(
api_routes.groups_ai_providers_providers_provider_id(provider.id), headers=usr.token
)
assert response.status_code == 403
finally:
usr.repos.group_ai_providers.delete(provider.id)
def test_settings_require_can_manage_get(api_client: TestClient, user_tuple: list[TestUser]):
usr, _ = user_tuple
user = usr.repos.users.get_one(usr.user_id)
assert user
user.can_manage = False
usr.repos.users.update(user.id, user)
response = api_client.get(api_routes.groups_ai_providers_settings, headers=usr.token)
assert response.status_code == 403
def test_settings_require_can_manage_update(api_client: TestClient, user_tuple: list[TestUser]):
usr, _ = user_tuple
user = usr.repos.users.get_one(usr.user_id)
assert user
user.can_manage = False
usr.repos.users.update(user.id, user)
update = {"defaultProviderId": None, "audioProviderId": None, "imageProviderId": None}
response = api_client.put(api_routes.groups_ai_providers_settings, json=update, headers=usr.token)
assert response.status_code == 403
# ==========================================
# API key not exposed in responses
# ==========================================
def test_api_key_not_in_create_response(api_client: TestClient, unique_user: TestUser):
data = {"name": random_string(), "model": "gpt-4o", "apiKey": "super-secret-key"}
response = api_client.post(api_routes.groups_ai_providers_providers, json=data, headers=unique_user.token)
assert response.status_code == 200
provider = response.json()
try:
assert "apiKey" not in provider
assert "api_key" not in provider
assert "super-secret-key" not in str(provider)
finally:
api_client.delete(
api_routes.groups_ai_providers_providers_provider_id(provider["id"]), headers=unique_user.token
)
def test_api_key_not_in_get_response(api_client: TestClient, unique_user: TestUser):
provider = unique_user.repos.group_ai_providers.create(
AIProviderCreate(name=random_string(), model="gpt-4o", api_key="super-secret-key")
)
try:
response = api_client.get(
api_routes.groups_ai_providers_providers_provider_id(provider.id), headers=unique_user.token
)
assert response.status_code == 200
data = response.json()
assert "apiKey" not in data
assert "api_key" not in data
assert "super-secret-key" not in str(data)
finally:
api_client.delete(api_routes.groups_ai_providers_providers_provider_id(provider.id), headers=unique_user.token)
def test_api_key_not_in_update_response(api_client: TestClient, unique_user: TestUser):
provider = unique_user.repos.group_ai_providers.create(
AIProviderCreate(name=random_string(), model="gpt-4o", api_key="original-key")
)
try:
update_data = {"name": provider.name, "model": "gpt-4-turbo", "apiKey": "updated-secret-key"}
response = api_client.put(
api_routes.groups_ai_providers_providers_provider_id(provider.id),
json=update_data,
headers=unique_user.token,
)
assert response.status_code == 200
data = response.json()
assert "apiKey" not in data
assert "api_key" not in data
assert "updated-secret-key" not in str(data)
assert "original-key" not in str(data)
finally:
api_client.delete(api_routes.groups_ai_providers_providers_provider_id(provider.id), headers=unique_user.token)
def test_api_key_not_in_settings_response(api_client: TestClient, unique_user: TestUser):
provider = unique_user.repos.group_ai_providers.create(
AIProviderCreate(name=random_string(), model="gpt-4o", api_key="secret-in-settings")
)
unique_user.repos.group_ai_provider_settings.update(
unique_user.repos.group_id,
AIProviderSettingsUpdate(default_provider_id=provider.id, audio_provider_id=None, image_provider_id=None),
)
try:
response = api_client.get(api_routes.groups_ai_providers_settings, headers=unique_user.token)
assert response.status_code == 200
data = response.json()
assert "apiKey" not in data
assert "api_key" not in data
assert "secret-in-settings" not in str(data)
finally:
unique_user.repos.group_ai_provider_settings.update(
unique_user.repos.group_id,
AIProviderSettingsUpdate(default_provider_id=None, audio_provider_id=None, image_provider_id=None),
)
api_client.delete(api_routes.groups_ai_providers_providers_provider_id(provider.id), headers=unique_user.token)
def test_api_key_not_in_groups_self_response(api_client: TestClient, unique_user: TestUser):
"""Ensure the groups/self endpoint does not expose any AI provider data including API keys."""
provider = unique_user.repos.group_ai_providers.create(
AIProviderCreate(name=random_string(), model="gpt-4o", api_key="groups-self-secret")
)
try:
response = api_client.get(api_routes.groups_self, headers=unique_user.token)
assert response.status_code == 200
data = response.json()
assert "api_key" not in str(data)
assert "apiKey" not in str(data)
assert "groups-self-secret" not in str(data)
finally:
api_client.delete(api_routes.groups_ai_providers_providers_provider_id(provider.id), headers=unique_user.token)
# ==========================================
# New group creation creates empty settings singleton
# ==========================================
def test_new_group_has_empty_ai_provider_settings(api_client: TestClient):
"""When a user registers (creating a new group), empty AI provider settings are created."""
registration = user_registration_factory()
response = api_client.post(api_routes.users_register, json=registration.model_dump(by_alias=True))
assert response.status_code == 201
# Login
form_data = {"username": registration.email, "password": registration.password}
response = api_client.post(api_routes.auth_token, data=form_data)
assert response.status_code == 200
token = response.json()["access_token"]
headers = {"Authorization": f"Bearer {token}"}
# Fetch AI provider settings for the newly created group
response = api_client.get(api_routes.groups_ai_providers_settings, headers=headers)
assert response.status_code == 200
settings = response.json()
assert settings["defaultProviderId"] is None
assert settings["audioProviderId"] is None
assert settings["imageProviderId"] is None
assert settings["providers"] == []
def test_new_group_created_via_admin_has_empty_ai_provider_settings(
api_client: TestClient,
admin_token: dict,
):
"""When an admin creates a group, empty AI provider settings are created."""
group_name = random_string()
response = api_client.post(api_routes.admin_groups, json={"name": group_name}, headers=admin_token)
assert response.status_code == 201
group_id = response.json()["id"]
try:
# Create a user in the new group with can_manage=True
user_data = {
"fullName": random_string(),
"username": random_string(),
"email": f"{random_string()}@example.com",
"password": "useruser",
"group": group_name,
"household": "Family",
"admin": False,
"canManage": True,
"tokens": [],
}
response = api_client.post(api_routes.admin_users, json=user_data, headers=admin_token)
assert response.status_code == 201
# Login as the new user
form_data = {"username": user_data["email"], "password": "useruser"}
response = api_client.post(api_routes.auth_token, data=form_data)
assert response.status_code == 200
token = response.json()["access_token"]
headers = {"Authorization": f"Bearer {token}"}
response = api_client.get(api_routes.groups_ai_providers_settings, headers=headers)
assert response.status_code == 200
settings = response.json()
assert settings["defaultProviderId"] is None
assert settings["audioProviderId"] is None
assert settings["imageProviderId"] is None
assert settings["providers"] == []
finally:
api_client.delete(api_routes.admin_groups_item_id(group_id), headers=admin_token)

17
tests/integration_tests/user_recipe_tests/test_recipe_create_from_image.py
View File

@@ -3,6 +3,7 @@ import json
import pytest
from fastapi.testclient import TestClient
from mealie.schema.group.ai_providers import AIProviderCreate, AIProviderSettingsUpdate
from mealie.schema.openai.recipe import (
OpenAIRecipe,
OpenAIRecipeIngredient,
@@ -15,6 +16,22 @@ from tests.utils.factories import random_int, random_string
from tests.utils.fixture_schemas import TestUser
@pytest.fixture(scope="module", autouse=True)
def setup_ai_providers(unique_user: TestUser):
"""Create AI providers for the test group so image-based OpenAI routes are enabled."""
provider = unique_user.repos.group_ai_providers.create(
AIProviderCreate(name="test-provider", model="gpt-4o", api_key="test-key")
)
unique_user.repos.group_ai_provider_settings.update(
unique_user.repos.group_id,
AIProviderSettingsUpdate(
default_provider_id=provider.id,
audio_provider_id=None,
image_provider_id=provider.id,
),
)
def test_openai_create_recipe_from_image(
api_client: TestClient,
monkeypatch: pytest.MonkeyPatch,

23
tests/integration_tests/user_recipe_tests/test_recipe_create_from_openai.py
View File

@@ -4,7 +4,7 @@ import pytest
from fastapi.testclient import TestClient
import mealie.services.scraper.recipe_scraper as recipe_scraper_module
import mealie.services.scraper.scraper_strategies as scraper_strategies_module
from mealie.schema.group.ai_providers import AIProviderCreate, AIProviderSettingsUpdate
from mealie.schema.openai.general import OpenAIText
from mealie.services.openai import OpenAIService
from mealie.services.recipe.recipe_data_service import RecipeDataService
@@ -47,12 +47,17 @@ def recipe_url() -> str:
@pytest.fixture(autouse=True)
def openai_scraper_setup(monkeypatch: pytest.MonkeyPatch, bare_html: str):
"""Restrict to only RecipeScraperOpenAI, enable it unconditionally, and prevent real HTTP calls."""
def openai_scraper_setup(monkeypatch: pytest.MonkeyPatch, bare_html: str, unique_user: TestUser):
"""Restrict to only RecipeScraperOpenAI, create real DB provider data, and prevent real HTTP calls."""
monkeypatch.setattr(recipe_scraper_module, "DEFAULT_SCRAPER_STRATEGIES", [RecipeScraperOpenAI])
settings_stub = type("_Settings", (), {"OPENAI_ENABLED": True})()
monkeypatch.setattr(scraper_strategies_module, "get_app_settings", lambda: settings_stub)
provider = unique_user.repos.group_ai_providers.create(
AIProviderCreate(name=random_string(), model="gpt-4o", api_key="test-key")
)
unique_user.repos.group_ai_provider_settings.update(
unique_user.repos.group_id,
AIProviderSettingsUpdate(default_provider_id=provider.id, audio_provider_id=None, image_provider_id=None),
)
async def mock_safe_scrape_html(url: str) -> str:
return bare_html
@@ -171,9 +176,11 @@ def test_create_by_url_openai_disabled(
monkeypatch: pytest.MonkeyPatch,
recipe_url: str,
):
"""When OPENAI_ENABLED is False, can_scrape() returns False and the endpoint returns 400."""
disabled_settings = type("_Settings", (), {"OPENAI_ENABLED": False})()
monkeypatch.setattr(scraper_strategies_module, "get_app_settings", lambda: disabled_settings)
"""When no default provider is set, can_scrape() returns False and the endpoint returns 400."""
unique_user.repos.group_ai_provider_settings.update(
unique_user.repos.group_id,
AIProviderSettingsUpdate(default_provider_id=None, audio_provider_id=None, image_provider_id=None),
)
response = api_client.post(
api_routes.recipes_create_url,

22
tests/integration_tests/user_recipe_tests/test_recipe_create_from_video.py
View File

@@ -6,7 +6,7 @@ from fastapi.testclient import TestClient
import mealie.services.scraper.recipe_scraper as recipe_scraper_module
from mealie.core import exceptions
from mealie.core.config import get_app_settings
from mealie.schema.group.ai_providers import AIProviderCreate, AIProviderSettingsUpdate
from mealie.schema.openai.recipe import OpenAIRecipe, OpenAIRecipeIngredient, OpenAIRecipeInstruction
from mealie.services.openai import OpenAIService
from mealie.services.scraper.scraper_strategies import RecipeScraperOpenAITranscription
@@ -27,10 +27,22 @@ def _make_openai_recipe() -> OpenAIRecipe:
@pytest.fixture(autouse=True)
def video_scraper_setup(monkeypatch: pytest.MonkeyPatch):
def video_scraper_setup(monkeypatch: pytest.MonkeyPatch, unique_user: TestUser):
# Restrict to only the video scraper so other strategies don't interfere
monkeypatch.setattr(recipe_scraper_module, "DEFAULT_SCRAPER_STRATEGIES", [RecipeScraperOpenAITranscription])
provider = unique_user.repos.group_ai_providers.create(
AIProviderCreate(name=random_string(), model="gpt-4o", api_key="test-key")
)
unique_user.repos.group_ai_provider_settings.update(
unique_user.repos.group_id,
AIProviderSettingsUpdate(
default_provider_id=provider.id,
audio_provider_id=provider.id,
image_provider_id=None,
),
)
# Prevent any real HTTP calls during scraping
async def mock_safe_scrape_html(url: str) -> str:
return "<html></html>"
@@ -117,8 +129,10 @@ def test_create_recipe_from_video_transcription_disabled(
monkeypatch: pytest.MonkeyPatch,
unique_user: TestUser,
):
settings = get_app_settings()
monkeypatch.setattr(settings, "OPENAI_ENABLE_TRANSCRIPTION_SERVICES", False)
unique_user.repos.group_ai_provider_settings.update(
unique_user.repos.group_id,
AIProviderSettingsUpdate(default_provider_id=None, audio_provider_id=None, image_provider_id=None),
)
r = api_client.post(api_routes.recipes_create_url, json={"url": VIDEO_URL}, headers=unique_user.token)
assert r.status_code == 400

206
tests/unit_tests/schema_tests/test_ai_providers.py Normal file
View File

@@ -0,0 +1,206 @@
from uuid import uuid4
import pytest
from pydantic import ValidationError
from mealie.schema.group.ai_providers import (
AIProviderCreate,
AIProviderSettingsOut,
AIProviderSummary,
)
class AIProviderCreateTests:
def test_valid_create(self):
provider = AIProviderCreate(name="test", api_key="key", model="gpt-4o")
assert provider.name == "test"
assert provider.model == "gpt-4o"
assert provider.timeout == 300
assert provider.base_url is None
@pytest.mark.parametrize("field", ["name", "api_key", "model"])
def test_empty_field_raises(self, field: str):
data: dict = {"name": "test", "api_key": "key", "model": "gpt-4o", field: ""}
with pytest.raises(ValidationError):
AIProviderCreate(**data)
@pytest.mark.parametrize("timeout", [-1, -100])
def test_negative_timeout_raises(self, timeout: int):
with pytest.raises(ValidationError):
AIProviderCreate(name="test", api_key="key", model="gpt-4o", timeout=timeout)
def test_zero_timeout_is_valid(self):
provider = AIProviderCreate(name="test", api_key="key", model="gpt-4o", timeout=0)
assert provider.timeout == 0
@pytest.mark.parametrize("base_url", ["", None])
def test_base_url_empty_becomes_none(self, base_url: str | None):
provider = AIProviderCreate(name="test", api_key="key", model="gpt-4o", base_url=base_url)
assert provider.base_url is None
def test_api_key_excluded_from_serialization(self):
provider = AIProviderCreate(name="test", api_key="secret", model="gpt-4o")
dumped = provider.model_dump()
assert "api_key" not in dumped
def test_api_key_excluded_from_json(self):
provider = AIProviderCreate(name="test", api_key="secret", model="gpt-4o")
json_str = provider.model_dump_json()
assert "api_key" not in json_str
assert "secret" not in json_str
class AIProviderSettingsOutTests:
def _make_settings(
self,
*,
default_provider_id=None,
audio_provider_id=None,
image_provider_id=None,
providers=None,
) -> AIProviderSettingsOut:
if providers is None:
providers = []
return AIProviderSettingsOut(
default_provider_id=default_provider_id,
audio_provider_id=audio_provider_id,
image_provider_id=image_provider_id,
providers=providers,
)
# --- ai_enabled ---
def test_ai_enabled_false_when_no_default(self):
s = self._make_settings()
assert not s.ai_enabled
def test_ai_enabled_true_when_default_set(self):
pid = uuid4()
s = self._make_settings(default_provider_id=pid, providers=[AIProviderSummary(id=pid, name="p")])
assert s.ai_enabled
# --- audio_provider_enabled ---
def test_audio_provider_disabled_when_no_default(self):
audio_id = uuid4()
s = self._make_settings(
audio_provider_id=audio_id,
providers=[AIProviderSummary(id=audio_id, name="audio")],
)
# audio_provider_id is valid, but validate_providers sets audio_provider_id to None
# because without default_provider_id, it would be fine; let's test audio_provider_enabled
# which requires ai_enabled to be True
assert not s.ai_enabled
assert not s.audio_provider_enabled
def test_audio_provider_disabled_when_only_default_set(self):
pid = uuid4()
s = self._make_settings(default_provider_id=pid, providers=[AIProviderSummary(id=pid, name="p")])
assert s.ai_enabled
assert not s.audio_provider_enabled
def test_audio_provider_enabled_when_both_set(self):
pid = uuid4()
audio_id = uuid4()
s = self._make_settings(
default_provider_id=pid,
audio_provider_id=audio_id,
providers=[AIProviderSummary(id=pid, name="p"), AIProviderSummary(id=audio_id, name="audio")],
)
assert s.ai_enabled
assert s.audio_provider_enabled
# --- image_provider_enabled ---
def test_image_provider_disabled_when_no_default(self):
image_id = uuid4()
s = self._make_settings(
image_provider_id=image_id,
providers=[AIProviderSummary(id=image_id, name="img")],
)
assert not s.ai_enabled
assert not s.image_provider_enabled
def test_image_provider_disabled_when_only_default_set(self):
pid = uuid4()
s = self._make_settings(default_provider_id=pid, providers=[AIProviderSummary(id=pid, name="p")])
assert s.ai_enabled
assert not s.image_provider_enabled
def test_image_provider_enabled_when_both_set(self):
pid = uuid4()
image_id = uuid4()
s = self._make_settings(
default_provider_id=pid,
image_provider_id=image_id,
providers=[AIProviderSummary(id=pid, name="p"), AIProviderSummary(id=image_id, name="img")],
)
assert s.ai_enabled
assert s.image_provider_enabled
# --- validate_providers model validator ---
def test_validate_providers_strips_unknown_default(self):
s = self._make_settings(default_provider_id=uuid4(), providers=[])
assert s.default_provider_id is None
assert not s.ai_enabled
def test_validate_providers_strips_unknown_audio(self):
pid = uuid4()
providers = [AIProviderSummary(id=pid, name="p")]
s = self._make_settings(default_provider_id=pid, audio_provider_id=uuid4(), providers=providers)
assert s.default_provider_id == pid
assert s.audio_provider_id is None
def test_validate_providers_strips_unknown_image(self):
pid = uuid4()
providers = [AIProviderSummary(id=pid, name="p")]
s = self._make_settings(default_provider_id=pid, image_provider_id=uuid4(), providers=providers)
assert s.default_provider_id == pid
assert s.image_provider_id is None
def test_validate_providers_keeps_valid_ids(self):
pid = uuid4()
audio_id = uuid4()
image_id = uuid4()
providers = [
AIProviderSummary(id=pid, name="p"),
AIProviderSummary(id=audio_id, name="audio"),
AIProviderSummary(id=image_id, name="img"),
]
s = self._make_settings(
default_provider_id=pid,
audio_provider_id=audio_id,
image_provider_id=image_id,
providers=providers,
)
assert s.default_provider_id == pid
assert s.audio_provider_id == audio_id
assert s.image_provider_id == image_id
def test_validate_providers_strips_all_if_empty_list(self):
pid = uuid4()
s = self._make_settings(
default_provider_id=pid,
audio_provider_id=uuid4(),
image_provider_id=uuid4(),
providers=[],
)
assert s.default_provider_id is None
assert s.audio_provider_id is None
assert s.image_provider_id is None
def test_validate_providers_partial_strip(self):
"""Only the IDs pointing to missing providers are stripped."""
pid = uuid4()
audio_id = uuid4()
providers = [AIProviderSummary(id=pid, name="p"), AIProviderSummary(id=audio_id, name="audio")]
s = self._make_settings(
default_provider_id=pid,
audio_provider_id=audio_id,
image_provider_id=uuid4(), # not in list → stripped
providers=providers,
)
assert s.default_provider_id == pid
assert s.audio_provider_id == audio_id
assert s.image_provider_id is None

19
tests/unit_tests/services_tests/ingredient_parser/test_openai_parser.py
View File

@@ -49,6 +49,12 @@ def test_openai_parser(
monkeypatch.setattr(OpenAIService, "get_response", mock_get_response)
def mock_openai_init(self, repos):
self.repos = repos
self.custom_prompt_dir = None
monkeypatch.setattr(OpenAIService, "__init__", mock_openai_init)
with session_context() as session:
loop = asyncio.get_event_loop()
parser = get_parser(RegisteredParser.openai, unique_local_group_id, session, get_locale_provider())
@@ -69,7 +75,7 @@ def test_openai_parser_sanitize_output(
parsed_ingredient_data: tuple[list[IngredientFood], list[IngredientUnit]], # required so database is populated
monkeypatch: pytest.MonkeyPatch,
):
async def mock_get_raw_response(self, prompt: str, content: list[dict], response_schema) -> MagicMock:
async def mock_get_raw_response(self, prompt: str, content: list[dict], response_schema, provider) -> MagicMock:
# Create data with null character in JSON to test preprocessing
data = OpenAIIngredients(
ingredients=[
@@ -91,6 +97,17 @@ def test_openai_parser_sanitize_output(
# Mock the raw response here since we want to make sure our service executes processing before loading the model
monkeypatch.setattr(OpenAIService, "_get_raw_response", mock_get_raw_response)
def mock_openai_init(self, repos):
from unittest.mock import MagicMock
self.repos = repos
self.custom_prompt_dir = None
self.default_provider = MagicMock()
self.audio_provider = None
self.image_provider = None
monkeypatch.setattr(OpenAIService, "__init__", mock_openai_init)
with session_context() as session:
loop = asyncio.get_event_loop()
parser = get_parser(RegisteredParser.openai, unique_local_group_id, session, get_locale_provider())

4
tests/unit_tests/services_tests/scraper_tests/test_cleaner.py
View File

@@ -49,7 +49,7 @@ def test_html_with_recipe_data():
url = "https://www.bbc.co.uk/food/recipes/healthy_pasta_bake_60759"
translator = get_locale_provider()
open_graph_strategy = RecipeScraperOpenGraph(url, translator)
open_graph_strategy = RecipeScraperOpenGraph(url, translator, None) # type: ignore[arg-type]
recipe_data = open_graph_strategy.get_recipe_fields(path.read_text())
@@ -78,7 +78,7 @@ def test_clean_scraper_preserves_notes():
html = RecipeScraperPackage.ld_json_to_html(ld_json)
scraped = scrape_html(html, org_url="https://example.com", supported_only=False)
translator = get_locale_provider()
strategy = RecipeScraperPackage("https://example.com", translator)
strategy = RecipeScraperPackage("https://example.com", translator, None) # type: ignore[arg-type]
recipe, _ = strategy.clean_scraper(scraped, "https://example.com")

37
tests/unit_tests/services_tests/test_openai_service.py
View File

@@ -1,23 +1,28 @@
from unittest.mock import MagicMock
from uuid import uuid4
import pytest
import mealie.services.openai.openai as openai_module
from mealie.services.openai.openai import OpenAIService
def _make_mock_repos() -> MagicMock:
provider_settings = MagicMock()
provider_settings.ai_enabled = True
provider_settings.default_provider_id = uuid4()
provider_settings.audio_provider_id = None
provider_settings.image_provider_id = None
repos = MagicMock()
repos.group_id = uuid4()
repos.group_ai_provider_settings.get_one.return_value = provider_settings
repos.group_ai_providers.get_one.return_value = MagicMock()
return repos
class _SettingsStub:
OPENAI_ENABLED = True
OPENAI_MODEL = "gpt-4o"
OPENAI_AUDIO_MODEL = "whisper-1"
OPENAI_WORKERS = 1
OPENAI_SEND_DATABASE_DATA = False
OPENAI_ENABLE_IMAGE_SERVICES = True
OPENAI_ENABLE_TRANSCRIPTION_SERVICES = True
OPENAI_CUSTOM_PROMPT_DIR: str | None = None
OPENAI_BASE_URL: str | None = None
OPENAI_API_KEY = "dummy"
OPENAI_REQUEST_TIMEOUT = 30
OPENAI_CUSTOM_HEADERS: dict = {}
OPENAI_CUSTOM_PARAMS: dict = {}
@pytest.fixture()
@@ -39,7 +44,7 @@ def settings_stub(tmp_path, monkeypatch):
def test_get_prompt_default_only(settings_stub):
svc = OpenAIService()
svc = OpenAIService(_make_mock_repos())
out = svc.get_prompt("recipes.parse-recipe-ingredients")
assert out == "DEFAULT PROMPT"
@@ -51,7 +56,7 @@ def test_get_prompt_custom_dir_used(settings_stub, tmp_path):
settings_stub.OPENAI_CUSTOM_PROMPT_DIR = str(custom_dir)
svc = OpenAIService()
svc = OpenAIService(_make_mock_repos())
out = svc.get_prompt("recipes.parse-recipe-ingredients")
assert out == "CUSTOM PROMPT"
@@ -62,7 +67,7 @@ def test_get_prompt_custom_empty_falls_back_to_default(settings_stub, tmp_path):
(custom_dir / "recipes" / "parse-recipe-ingredients.txt").write_text("")
settings_stub.OPENAI_CUSTOM_PROMPT_DIR = str(custom_dir)
svc = OpenAIService()
svc = OpenAIService(_make_mock_repos())
out = svc.get_prompt("recipes.parse-recipe-ingredients")
assert out == "DEFAULT PROMPT"
@@ -73,7 +78,7 @@ def test_get_prompt_raises_when_no_files(settings_stub, monkeypatch):
for p in prompts_dir.rglob("*.txt"):
p.unlink()
svc = OpenAIService()
svc = OpenAIService(_make_mock_repos())
with pytest.raises(OSError) as ei:
svc.get_prompt("recipes.parse-recipe-ingredients")
assert "Unable to load prompt" in str(ei.value)

1
tests/unit_tests/test_config.py
View File

@@ -352,7 +352,6 @@ def test_oidc_settings_validation(data: OIDCValidationCase, monkeypatch: pytest.
def test_sensitive_settings_mask(monkeypatch: pytest.MonkeyPatch):
sensitive_settings = [
"LDAP_QUERY_PASSWORD",
"OPENAI_API_KEY",
"SMTP_USER",
"SMTP_PASSWORD",
"OIDC_CLIENT_SECRET",

26
tests/utils/api_routes/__init__.py
View File

@@ -11,8 +11,6 @@ admin_backups = "/api/admin/backups"
"""`/api/admin/backups`"""
admin_backups_upload = "/api/admin/backups/upload"
"""`/api/admin/backups/upload`"""
admin_debug_openai = "/api/admin/debug/openai"
"""`/api/admin/debug/openai`"""
admin_email = "/api/admin/email"
"""`/api/admin/email`"""
admin_groups = "/api/admin/groups"
@@ -57,6 +55,10 @@ foods = "/api/foods"
"""`/api/foods`"""
foods_merge = "/api/foods/merge"
"""`/api/foods/merge`"""
groups_ai_providers_providers = "/api/groups/ai-providers/providers"
"""`/api/groups/ai-providers/providers`"""
groups_ai_providers_settings = "/api/groups/ai-providers/settings"
"""`/api/groups/ai-providers/settings`"""
groups_households = "/api/groups/households"
"""`/api/groups/households`"""
groups_labels = "/api/groups/labels"
@@ -215,6 +217,21 @@ def admin_backups_file_name_restore(file_name):
return f"{prefix}/admin/backups/{file_name}/restore"
def admin_debug_openai_provider_id(provider_id):
"""`/api/admin/debug/openai/{provider_id}`"""
return f"{prefix}/admin/debug/openai/{provider_id}"
def admin_groups_group_id_ai_providers_providers(group_id):
"""`/api/admin/groups/{group_id}/ai-providers/providers`"""
return f"{prefix}/admin/groups/{group_id}/ai-providers/providers"
def admin_groups_group_id_ai_providers_providers_provider_id(group_id, provider_id):
"""`/api/admin/groups/{group_id}/ai-providers/providers/{provider_id}`"""
return f"{prefix}/admin/groups/{group_id}/ai-providers/providers/{provider_id}"
def admin_groups_item_id(item_id):
"""`/api/admin/groups/{item_id}`"""
return f"{prefix}/admin/groups/{item_id}"
@@ -315,6 +332,11 @@ def foods_item_id(item_id):
return f"{prefix}/foods/{item_id}"
def groups_ai_providers_providers_provider_id(provider_id):
"""`/api/groups/ai-providers/providers/{provider_id}`"""
return f"{prefix}/groups/ai-providers/providers/{provider_id}"
def groups_households_household_slug(household_slug):
"""`/api/groups/households/{household_slug}`"""
return f"{prefix}/groups/households/{household_slug}"