Skip to content

Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.

28.3 KB
Raw Blame
# SPDX-License-Identifier: AGPL-3.0-only
# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0

import sys
from pathlib import Path

import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient
from pydantic import ValidationError


def _shared_setup_1(monkeypatch, store):
    monkeypatch.setattr("storage.studio_db.get_app_setting", lambda k, d = None: store.get(k, d))
    monkeypatch.setattr("storage.studio_db.upsert_app_settings", lambda d: store.update(d))

    app = FastAPI()
    app.dependency_overrides[get_current_subject] = lambda: "unsloth"
    app.include_router(settings_routes.router, prefix = "/api/settings")
    client = TestClient(app)
    return client


_BACKEND = Path(__file__).resolve().parents[1]
if str(_BACKEND) not in sys.path:
    sys.path.insert(0, str(_BACKEND))

import utils.personalization_settings as pers  # noqa: E402
from auth.authentication import get_current_subject  # noqa: E402
from routes import settings as settings_routes  # noqa: E402
from routes.settings import (  # noqa: E402
    MAX_SIDEBAR_MENU_INPUT_ITEMS,
    MAX_SIDEBAR_NAV_INPUT_ITEMS,
    PersonalizationPayload,
    SIDEBAR_MENU_ITEM_DEFAULTS,
    SIDEBAR_NAV_ITEM_DEFAULTS,
)


def test_defaults_fill_missing_fields():
    p = PersonalizationPayload.model_validate({})
    assert p.version == pers.PERSONALIZATION_VERSION
    assert p.appearance.theme == "system"
    assert p.appearance.palette == "standard"
    assert p.profile.avatarShape == "circle"
    assert p.profile.displayName == ""
    assert p.profile.showGreetingSloth is True
    assert p.profile.greetingStyle == "text"
    assert p.profile.greetingIcon == "sloth"
    assert p.profile.greetingText == ""
    assert p.profile.greetingIconDataUrl is None
    assert p.profile.greetingImageDataUrl is None


def test_unknown_keys_are_ignored():
    p = PersonalizationPayload.model_validate(
        {"profile": {"displayName": "Mike", "bogus": 1}, "extra": True}
    )
    assert p.profile.displayName == "Mike"


@pytest.mark.parametrize(
    "section, field, value",
    [
        pytest.param("appearance", "theme", "neon", id = "invalid_theme_rejected"),
        pytest.param("appearance", "palette", "neon", id = "invalid_palette_rejected"),
        pytest.param(
            "profile",
            "avatarDataUrl",
            "http://example.com/a.png",
            id = "avatar_must_be_image_data_url",
        ),
        pytest.param(
            "profile",
            "avatarDataUrl",
            "/Sloth%20emojis/../secret.png",
            id = "bundled_avatar_traversal_rejected",
        ),
    ],
)
def test_invalid_personalization_values_are_rejected(section, field, value):
    with pytest.raises(ValidationError):
        PersonalizationPayload.model_validate({section: {field: value}})


def test_customization_defaults():
    p = PersonalizationPayload.model_validate({})
    c = p.appearance.customization
    assert c.contrast == 50
    assert c.composerOutline is None
    assert c.elementOutline is None
    assert c.reduceMotion == "on"
    assert c.fontSmoothing is True
    assert c.pointerCursors is False
    assert c.codeLineNumbers is False
    assert c.codeWordWrap is False
    assert c.codeLigatures is True
    assert c.colors.light.accent is None
    assert c.headingFont is None
    assert c.chatFont is None
    assert c.uiFontSize is None
    assert c.chatWidth == "standard"
    assert c.sentAttachments == "auto"
    assert [(i.id, i.visible) for i in c.sidebarMenu] == [
        ("api", True),
        ("darkMode", True),
        ("guidedTour", True),
        ("profile", False),
        ("appearance", False),
        ("resources", False),
        ("chat", False),
        ("connections", False),
    ]


def test_customization_invalid_values_rejected():
    with pytest.raises(ValidationError):
        PersonalizationPayload.model_validate(
            {"appearance": {"customization": {"chatWidth": "invalid"}}}
        )
    with pytest.raises(ValidationError):
        PersonalizationPayload.model_validate(
            {"appearance": {"customization": {"colors": {"light": {"accent": "red"}}}}}
        )
    with pytest.raises(ValidationError):
        PersonalizationPayload.model_validate({"appearance": {"customization": {"uiFontSize": 99}}})
    with pytest.raises(ValidationError):
        PersonalizationPayload.model_validate({"appearance": {"customization": {"contrast": 500}}})
    with pytest.raises(ValidationError):
        PersonalizationPayload.model_validate(
            {"appearance": {"customization": {"sentAttachments": "grid"}}}
        )
    with pytest.raises(ValidationError):
        PersonalizationPayload.model_validate(
            {"appearance": {"customization": {"reduceMotion": "sometimes"}}}
        )
    with pytest.raises(ValidationError):
        PersonalizationPayload.model_validate(
            {"appearance": {"customization": {"sidebarMenu": [{"id": "chats"}]}}}
        )


def test_customization_sidebar_menu_normalized():
    p = PersonalizationPayload.model_validate(
        {
            "appearance": {
                "customization": {
                    "sidebarMenu": [
                        {"id": "guidedTour", "visible": False},
                        {"id": "guidedTour", "visible": True},
                        {"id": "api"},
                    ]
                }
            }
        }
    )
    assert [(i.id, i.visible) for i in p.appearance.customization.sidebarMenu] == [
        ("guidedTour", False),
        ("api", True),
        ("darkMode", True),
        ("profile", False),
        ("appearance", False),
        ("resources", False),
        ("chat", False),
        ("connections", False),
    ]


def _sidebar(items):
    return {"appearance": {"customization": {"sidebarMenu": items}}}


def test_customization_sidebar_menu_dedupes_oversized_payload():
    # Oversized stale payloads must reach the dedupe validator, not the length cap.
    ids = list(SIDEBAR_MENU_ITEM_DEFAULTS)
    doubled = [{"id": i} for i in ids] + [{"id": i} for i in ids]
    assert len(doubled) > len(SIDEBAR_MENU_ITEM_DEFAULTS)
    p = PersonalizationPayload.model_validate(_sidebar(doubled))
    result = [i.id for i in p.appearance.customization.sidebarMenu]
    assert result == ids
    assert len(result) == len(SIDEBAR_MENU_ITEM_DEFAULTS)


def test_customization_sidebar_menu_rejects_pathological_length():
    huge = [{"id": "api"} for _ in range(MAX_SIDEBAR_MENU_INPUT_ITEMS + 1)]
    with pytest.raises(ValidationError):
        PersonalizationPayload.model_validate(_sidebar(huge))


def _sidebar_nav(items):
    return {"appearance": {"customization": {"sidebarNav": items}}}


# Mirrors SIDEBAR_NAV_ITEM_IDS / SIDEBAR_NAV_DEFAULT_PINNED in appearance-custom-store.ts.
FRONTEND_SHIPPED_SIDEBAR_NAV = [
    ("hub", True),
    ("projects", True),
    ("library", True),
    ("images", True),
    ("video", False),
    ("audio", False),
    ("train", True),
    ("recipes", False),
    ("export", False),
    ("api", False),
    ("tasks", False),
]


def test_customization_sidebar_nav_accepts_the_frontend_shipped_layout():
    # The frontend always sends every nav id; a missing one 422s the whole PUT.
    p = PersonalizationPayload.model_validate(
        _sidebar_nav([{"id": i, "pinned": pinned} for i, pinned in FRONTEND_SHIPPED_SIDEBAR_NAV])
    )
    nav = p.appearance.customization.sidebarNav
    assert [(i.id, i.pinned) for i in nav] == FRONTEND_SHIPPED_SIDEBAR_NAV


def test_customization_sidebar_nav_defaults_match_shipped_layout():
    c = PersonalizationPayload().appearance.customization
    assert [(i.id, i.pinned) for i in c.sidebarNav] == FRONTEND_SHIPPED_SIDEBAR_NAV


def test_customization_sidebar_nav_preserves_order_and_normalizes():
    p = PersonalizationPayload.model_validate(
        _sidebar_nav(
            [
                {"id": "video", "pinned": True},
                {"id": "video", "pinned": False},
                {"id": "hub", "pinned": False},
            ]
        )
    )
    assert [(i.id, i.pinned) for i in p.appearance.customization.sidebarNav] == [
        ("video", True),
        ("hub", False),
        ("projects", True),
        ("library", True),
        ("images", True),
        ("audio", False),
        ("train", True),
        ("recipes", False),
        ("export", False),
        ("api", False),
        ("tasks", False),
    ]


def test_customization_sidebar_nav_rejects_unknown_id():
    with pytest.raises(ValidationError):
        PersonalizationPayload.model_validate(_sidebar_nav([{"id": "chats"}]))


def test_customization_sidebar_nav_dedupes_oversized_payload():
    ids = list(SIDEBAR_NAV_ITEM_DEFAULTS)
    doubled = [{"id": i} for i in ids] + [{"id": i} for i in ids]
    assert len(doubled) > len(SIDEBAR_NAV_ITEM_DEFAULTS)
    p = PersonalizationPayload.model_validate(_sidebar_nav(doubled))
    result = [i.id for i in p.appearance.customization.sidebarNav]
    assert result == ids


def test_customization_sidebar_nav_rejects_pathological_length():
    huge = [{"id": "hub"} for _ in range(MAX_SIDEBAR_NAV_INPUT_ITEMS + 1)]
    with pytest.raises(ValidationError):
        PersonalizationPayload.model_validate(_sidebar_nav(huge))


def _sidebar_nav_auto(value):
    return {"appearance": {"customization": {"sidebarNavAuto": value}}}


def test_customization_sidebar_nav_auto_defaults_to_none():
    # None, not a list: the client reads it as 'predates the field'.
    assert PersonalizationPayload().appearance.customization.sidebarNavAuto is None


def test_customization_sidebar_nav_auto_keeps_an_explicit_empty_list():
    p = PersonalizationPayload.model_validate(_sidebar_nav_auto([]))
    assert p.appearance.customization.sidebarNavAuto == []


def test_customization_sidebar_nav_auto_dedupes_and_validates():
    p = PersonalizationPayload.model_validate(_sidebar_nav_auto(["projects", "projects"]))
    assert p.appearance.customization.sidebarNavAuto == ["projects"]
    with pytest.raises(ValidationError):
        PersonalizationPayload.model_validate(_sidebar_nav_auto(["chats"]))
    with pytest.raises(ValidationError):
        PersonalizationPayload.model_validate(
            _sidebar_nav_auto(["hub"] * (MAX_SIDEBAR_NAV_INPUT_ITEMS + 1))
        )


def test_personalization_put_round_trips_sidebar_nav_auto(monkeypatch):
    store: dict = {}
    client = _shared_setup_1(monkeypatch, store)
    put = client.put(
        "/api/settings/personalization",
        json = _sidebar_nav_auto([]),
    )
    assert put.status_code == 200
    assert put.json()["appearance"]["customization"]["sidebarNavAuto"] == []
    stored = store[pers.PERSONALIZATION_SETTING_KEY]["appearance"]["customization"]
    assert stored["sidebarNavAuto"] == []
    body = client.get("/api/settings/personalization").json()
    assert body["appearance"]["customization"]["sidebarNavAuto"] == []


def test_customization_imported_fonts_validated():
    ok = PersonalizationPayload.model_validate(
        {
            "appearance": {
                "customization": {
                    "importedFonts": [{"name": "My Font", "dataUrl": "data:font/woff2;base64,AAAA"}]
                }
            }
        }
    )
    assert ok.appearance.customization.importedFonts[0].name == "My Font"
    with pytest.raises(ValidationError):
        PersonalizationPayload.model_validate(
            {
                "appearance": {
                    "customization": {
                        "importedFonts": [
                            {"name": "Evil", "dataUrl": "https://example.com/font.woff2"}
                        ]
                    }
                }
            }
        )
    with pytest.raises(ValidationError):
        PersonalizationPayload.model_validate(
            {
                "appearance": {
                    "customization": {
                        "importedFonts": [
                            {"name": f"Font {i}", "dataUrl": "data:font/ttf;base64,AAAA"}
                            for i in range(4)
                        ]
                    }
                }
            }
        )


def _imported(fonts):
    return {"appearance": {"customization": {"importedFonts": fonts}}}


def test_imported_font_name_rejects_css_characters():
    for bad in ['Ev"il', "Ev;il", "Ev{il", "Ev<il", "Ev'il", "Ev\\il", "Ev,il", "Ev/il", "Ev\til"]:
        with pytest.raises(ValidationError):
            PersonalizationPayload.model_validate(
                _imported([{"name": bad, "dataUrl": "data:font/woff2;base64,AAAA"}])
            )


def test_selected_font_names_validated():
    for field in ("uiFont", "headingFont", "chatFont", "codeFont"):
        for bad in ["Ev\\il", "Ev,il", "Ev/il", "Ev;il", "Ev\nil"]:
            with pytest.raises(ValidationError):
                PersonalizationPayload.model_validate(
                    {"appearance": {"customization": {field: bad}}}
                )
    p = PersonalizationPayload.model_validate(
        {"appearance": {"customization": {"uiFont": "Source Serif 4"}}}
    )
    assert p.appearance.customization.uiFont == "Source Serif 4"


def test_imported_font_data_url_must_be_base64():
    with pytest.raises(ValidationError):
        PersonalizationPayload.model_validate(
            _imported([{"name": "F", "dataUrl": "data:font/woff2;base64,?not base64?"}])
        )
    with pytest.raises(ValidationError):
        PersonalizationPayload.model_validate(
            _imported([{"name": "F", "dataUrl": "data:application/json;base64,AAAA"}])
        )


def test_imported_font_data_url_rejects_newline():
    # re's `$` matches before a trailing newline; reject it like the frontend pattern does.
    for bad in [
        "data:font/woff2;base64,AAAA\n",
        "data:font/woff2;base64,AAAA\nBBBB",
        "\ndata:font/woff2;base64,AAAA",
    ]:
        with pytest.raises(ValidationError):
            PersonalizationPayload.model_validate(_imported([{"name": "F", "dataUrl": bad}]))
    ok = PersonalizationPayload.model_validate(
        _imported([{"name": "F", "dataUrl": "data:font/woff2;base64,AAAA"}])
    )
    assert ok.appearance.customization.importedFonts[0].dataUrl == "data:font/woff2;base64,AAAA"


def test_imported_fonts_total_size_capped():
    big = "data:font/woff2;base64," + "A" * 1_600_000
    with pytest.raises(ValidationError):
        PersonalizationPayload.model_validate(
            _imported([{"name": f"F{i}", "dataUrl": big} for i in range(3)])
        )
    PersonalizationPayload.model_validate(
        _imported([{"name": f"F{i}", "dataUrl": big} for i in range(2)])
    )


def test_avatar_size_is_capped():
    big = "data:image/png;base64," + "A" * (pers.MAX_AVATAR_DATA_URL_BYTES + 1)
    with pytest.raises(ValidationError):
        PersonalizationPayload.model_validate({"profile": {"avatarDataUrl": big}})


def test_valid_avatar_and_shape():
    p = PersonalizationPayload.model_validate(
        {
            "profile": {
                "avatarDataUrl": "data:image/png;base64,AAAA",
                "avatarShape": "rounded",
            }
        }
    )
    assert p.profile.avatarShape == "rounded"


def test_bundled_avatar_url_allowed():
    p = PersonalizationPayload.model_validate(
        {"profile": {"avatarDataUrl": "/Sloth%20emojis/large%20sloth%20yay.png"}}
    )
    assert p.profile.avatarDataUrl == "/Sloth%20emojis/large%20sloth%20yay.png"


def test_bundled_avatar_subpath_allowed():
    p = PersonalizationPayload.model_validate(
        {"profile": {"avatarDataUrl": "/studio/Sloth%20emojis/large%20sloth%20yay.png"}}
    )
    assert "Sloth%20emojis" in p.profile.avatarDataUrl


def test_get_read_errors_propagate(monkeypatch):
    def fail(*args, **kwargs):
        raise RuntimeError("read failed")

    monkeypatch.setattr("storage.studio_db.get_app_setting", fail)

    with pytest.raises(RuntimeError, match = "read failed"):
        pers.get_personalization()


def test_get_set_roundtrip(monkeypatch):
    store: dict = {}
    monkeypatch.setattr("storage.studio_db.get_app_setting", lambda k, d = None: store.get(k, d))
    monkeypatch.setattr("storage.studio_db.upsert_app_settings", lambda d: store.update(d))

    assert pers.get_personalization() == {}
    data = {
        "version": 1,
        "profile": {"displayName": "Mike"},
        "appearance": {"theme": "dark"},
    }
    pers.set_personalization(data)
    assert store[pers.PERSONALIZATION_SETTING_KEY]["profile"]["displayName"] == "Mike"
    assert pers.get_personalization()["appearance"]["theme"] == "dark"


def test_personalization_route_roundtrip_real_shape(monkeypatch):
    store: dict = {}
    client = _shared_setup_1(monkeypatch, store)

    initial = client.get("/api/settings/personalization")
    assert initial.status_code == 200
    assert initial.json()["saved"] is False

    payload = {
        "version": 1,
        "profile": {
            "displayName": "Mike",
            "nickname": "M",
            "avatarDataUrl": "/Sloth%20emojis/large%20sloth%20yay.png",
            "avatarShape": "rounded",
            "showGreetingSloth": False,
            "greetingStyle": "image",
            "greetingIcon": "custom",
            "greetingIconDataUrl": "data:image/webp;base64,AAAA",
            "greetingText": "Hello there",
            "greetingImageDataUrl": "data:image/png;base64,BBBB",
        },
        "appearance": {
            "theme": "dark",
            "palette": "matcha",
            "language": "en",
            "customization": {
                "colors": {
                    "light": {"accent": "#339cff", "background": None, "foreground": None},
                    "dark": {"accent": None, "background": "#111111", "foreground": None},
                },
                "uiFont": "SF Pro Text",
                "headingFont": "Avenir Next",
                "chatFont": "Georgia",
                "chatWidth": "full",
                "sentAttachments": "chips",
                "codeFont": None,
                "importedFonts": [
                    {"name": "SF Pro Text", "dataUrl": "data:font/woff2;base64,AAAA"}
                ],
                "uiFontSize": 14,
                "codeFontSize": 13,
                "contrast": 60,
                "composerOutline": 40,
                "elementOutline": 0,
                "pointerCursors": True,
                "reduceMotion": "off",
                "fontSmoothing": True,
                "codeLineNumbers": True,
                "codeWordWrap": True,
                "codeLigatures": False,
                "sidebarMenu": [
                    {"id": "darkMode", "visible": True},
                    {"id": "api", "visible": False},
                    {"id": "guidedTour", "visible": True},
                    {"id": "profile", "visible": True},
                    {"id": "appearance", "visible": False},
                    {"id": "resources", "visible": False},
                    {"id": "chat", "visible": False},
                    {"id": "connections", "visible": False},
                ],
                "sidebarNav": [
                    {"id": "images", "pinned": True},
                    {"id": "video", "pinned": True},
                    {"id": "audio", "pinned": False},
                    {"id": "hub", "pinned": True},
                    {"id": "train", "pinned": True},
                    {"id": "projects", "pinned": False},
                    {"id": "library", "pinned": True},
                    {"id": "recipes", "pinned": False},
                    {"id": "export", "pinned": False},
                    {"id": "api", "pinned": False},
                    {"id": "tasks", "pinned": False},
                ],
                "sidebarNavAuto": [],
            },
        },
    }
    put = client.put("/api/settings/personalization", json = payload)
    assert put.status_code == 200

    saved = client.get("/api/settings/personalization")
    assert saved.status_code == 200
    body = saved.json()
    assert body["saved"] is True
    assert body["customizationSaved"] is True
    assert body["paletteSaved"] is True
    assert body["greetingSlothSaved"] is True
    assert body["greetingCustomSaved"] is True
    assert body["profile"] == payload["profile"]
    assert body["appearance"] == payload["appearance"]


def test_personalization_get_flags_legacy_fields(monkeypatch):
    # Pre-field records report fields unsaved so the client keeps local overrides.
    store: dict = {
        pers.PERSONALIZATION_SETTING_KEY: {
            "version": 1,
            "profile": {"displayName": "Mike"},
            "appearance": {"theme": "dark"},
        }
    }
    monkeypatch.setattr("storage.studio_db.get_app_setting", lambda k, d = None: store.get(k, d))

    app = FastAPI()
    app.dependency_overrides[get_current_subject] = lambda: "unsloth"
    app.include_router(settings_routes.router, prefix = "/api/settings")
    body = TestClient(app).get("/api/settings/personalization").json()
    assert body["saved"] is True
    assert body["customizationSaved"] is False
    assert body["paletteSaved"] is False
    assert body["greetingSlothSaved"] is False
    assert body["greetingCustomSaved"] is False
    assert body["profile"]["greetingStyle"] == "text"


def test_personalization_legacy_chat_width_presence(monkeypatch):
    store = {
        pers.PERSONALIZATION_SETTING_KEY: {
            "appearance": {"customization": {"uiFont": "Georgia"}},
        }
    }
    client = _shared_setup_1(monkeypatch, store)
    body = client.get("/api/settings/personalization").json()
    assert body["customizationSaved"] is True
    assert body["chatWidthSaved"] is False
    assert body["appearance"]["customization"]["chatWidth"] == "standard"

    put = client.put(
        "/api/settings/personalization",
        json = {"appearance": {"customization": {"uiFont": "Arial"}}},
    )
    assert put.status_code == 200
    assert client.get("/api/settings/personalization").json()["chatWidthSaved"] is False
    assert "chatWidth" not in store[pers.PERSONALIZATION_SETTING_KEY]["appearance"]["customization"]

    put = client.put(
        "/api/settings/personalization",
        json = {"appearance": {"customization": {"chatWidth": "full"}}},
    )
    assert put.status_code == 200
    body = client.get("/api/settings/personalization").json()
    assert body["chatWidthSaved"] is True
    assert body["appearance"]["customization"]["chatWidth"] == "full"
    assert body["appearance"]["customization"]["uiFont"] == "Arial"


def test_personalization_legacy_attachment_display_presence(monkeypatch):
    store = {
        pers.PERSONALIZATION_SETTING_KEY: {
            "appearance": {"customization": {"chatWidth": "wide"}},
        }
    }
    client = _shared_setup_1(monkeypatch, store)
    body = client.get("/api/settings/personalization").json()
    assert body["customizationSaved"] is True
    assert body["sentAttachmentsSaved"] is False
    assert body["appearance"]["customization"]["sentAttachments"] == "auto"

    put = client.put(
        "/api/settings/personalization",
        json = {"appearance": {"customization": {"sentAttachments": "chips"}}},
    )
    assert put.status_code == 200
    body = client.get("/api/settings/personalization").json()
    assert body["sentAttachmentsSaved"] is True
    assert body["appearance"]["customization"]["sentAttachments"] == "chips"


def test_personalization_ignores_retired_composer_attachments(monkeypatch):
    store = {
        pers.PERSONALIZATION_SETTING_KEY: {
            "appearance": {"customization": {"composerAttachments": "compact"}},
        }
    }
    client = _shared_setup_1(monkeypatch, store)
    body = client.get("/api/settings/personalization").json()
    assert "composerAttachments" not in body["appearance"]["customization"]
    assert "composerAttachmentsSaved" not in body

    put = client.put(
        "/api/settings/personalization",
        json = {"appearance": {"customization": {"composerAttachments": "compact"}}},
    )
    assert put.status_code == 200
    body = client.get("/api/settings/personalization").json()
    assert "composerAttachments" not in body["appearance"]["customization"]


@pytest.mark.parametrize("width", ["standard", "wide", "full"])
def test_personalization_saved_chat_width_survives_stale_write(monkeypatch, width):
    store = {
        pers.PERSONALIZATION_SETTING_KEY: {
            "appearance": {"customization": {"chatWidth": width}},
        }
    }
    client = _shared_setup_1(monkeypatch, store)
    put = client.put(
        "/api/settings/personalization",
        json = {"appearance": {"customization": {"uiFont": "Georgia"}}},
    )
    assert put.status_code == 200
    body = client.get("/api/settings/personalization").json()
    assert body["chatWidthSaved"] is True
    assert body["appearance"]["customization"]["chatWidth"] == width


def test_personalization_put_preserves_absent_fields(monkeypatch):
    store: dict = {}
    client = _shared_setup_1(monkeypatch, store)

    put = client.put(
        "/api/settings/personalization",
        json = {
            "version": 1,
            "profile": {"displayName": "Mike"},
            "appearance": {"theme": "dark", "language": "en"},
        },
    )
    assert put.status_code == 200

    stored_appearance = store[pers.PERSONALIZATION_SETTING_KEY]["appearance"]
    assert "palette" not in stored_appearance
    assert "customization" not in stored_appearance

    body = client.get("/api/settings/personalization").json()
    assert body["saved"] is True
    assert body["paletteSaved"] is False
    assert body["customizationSaved"] is False
    assert body["greetingSlothSaved"] is False


def test_personalization_put_preserves_existing_fields_on_stale_write(monkeypatch):
    store: dict = {
        pers.PERSONALIZATION_SETTING_KEY: {
            "version": 1,
            "profile": {"displayName": "Mike", "showGreetingSloth": False},
            "appearance": {
                "theme": "light",
                "palette": "matcha",
                "customization": {"uiFont": "Georgia"},
            },
        }
    }
    client = _shared_setup_1(monkeypatch, store)

    put = client.put(
        "/api/settings/personalization",
        json = {"version": 1, "profile": {"displayName": "Mike"}, "appearance": {"theme": "dark"}},
    )
    assert put.status_code == 200

    put_body = put.json()
    assert put_body["appearance"]["theme"] == "dark"
    assert put_body["appearance"]["palette"] == "matcha"
    assert put_body["appearance"]["customization"]["uiFont"] == "Georgia"

    stored_appearance = store[pers.PERSONALIZATION_SETTING_KEY]["appearance"]
    assert stored_appearance["theme"] == "dark"
    assert stored_appearance["palette"] == "matcha"
    assert stored_appearance["customization"]["uiFont"] == "Georgia"

    body = client.get("/api/settings/personalization").json()
    assert body["paletteSaved"] is True
    assert body["customizationSaved"] is True
    assert body["greetingSlothSaved"] is True


@pytest.mark.parametrize("field", ["greetingIconDataUrl", "greetingImageDataUrl"])
@pytest.mark.parametrize(
    "value",
    [
        "data:image/svg+xml;base64,PHN2Zz48c2NyaXB0Lz48L3N2Zz4=",
        "data:image/svg+xml,<svg onload=alert(1)>",
        "javascript:alert(1)",
        "https://example.com/a.png",
        "/Sloth%20emojis/large%20sloth%20yay.png",
        "data:image/png;base64,AAAA\nBBBB",
    ],
)
def test_greeting_images_must_be_raster_data_urls(field, value):
    with pytest.raises(ValidationError):
        PersonalizationPayload.model_validate({"profile": {field: value}})


@pytest.mark.parametrize("mime", ["png", "jpeg", "webp", "gif"])
def test_greeting_images_accept_raster_types(mime):
    url = f"data:image/{mime};base64,AAAA"
    p = PersonalizationPayload.model_validate(
        {"profile": {"greetingIconDataUrl": url, "greetingImageDataUrl": url}}
    )
    assert p.profile.greetingIconDataUrl == url
    assert p.profile.greetingImageDataUrl == url


def test_greeting_sizes_are_capped():
    icon = "data:image/png;base64," + "A" * settings_routes.MAX_GREETING_ICON_DATA_URL_LENGTH
    image = "data:image/png;base64," + "A" * settings_routes.MAX_GREETING_IMAGE_DATA_URL_LENGTH
    with pytest.raises(ValidationError):
        PersonalizationPayload.model_validate({"profile": {"greetingIconDataUrl": icon}})
    with pytest.raises(ValidationError):
        PersonalizationPayload.model_validate({"profile": {"greetingImageDataUrl": image}})
    with pytest.raises(ValidationError):
        PersonalizationPayload.model_validate({"profile": {"greetingText": "x" * 101}})


def test_unknown_greeting_choices_fall_back_to_defaults():
    p = PersonalizationPayload.model_validate(
        {"profile": {"greetingStyle": "video", "greetingIcon": "rocket"}}
    )
    assert p.profile.greetingStyle == "text"
    assert p.profile.greetingIcon == "sloth"