Skip to content

armgit / dify

Public Imported from GitHub
0

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.

15.7 KB
Raw Blame
"""Unit tests for Pydantic models defined in controllers.web modules.

Covers validation logic, field defaults, constraints, and custom validators
for all ~15 Pydantic models across the web controller layer.
"""

from __future__ import annotations

from uuid import uuid4

import pytest
from pydantic import ValidationError

# ---------------------------------------------------------------------------
# app.py models
# ---------------------------------------------------------------------------
from controllers.web.app import AppAccessModeQuery

# ---------------------------------------------------------------------------
# audio.py models
# ---------------------------------------------------------------------------
from controllers.web.audio import TextToAudioPayload

# ---------------------------------------------------------------------------
# completion.py models
# ---------------------------------------------------------------------------
from controllers.web.completion import ChatMessagePayload, CompletionMessagePayload

# ---------------------------------------------------------------------------
# conversation.py models
# ---------------------------------------------------------------------------
from controllers.web.conversation import ConversationListQuery, ConversationRenamePayload

# ---------------------------------------------------------------------------
# forgot_password.py models
# ---------------------------------------------------------------------------
from controllers.web.forgot_password import (
    ForgotPasswordCheckPayload,
    ForgotPasswordResetPayload,
    ForgotPasswordSendPayload,
)

# ---------------------------------------------------------------------------
# login.py models
# ---------------------------------------------------------------------------
from controllers.web.login import EmailCodeLoginSendPayload, EmailCodeLoginVerifyPayload, LoginPayload

# ---------------------------------------------------------------------------
# message.py models
# ---------------------------------------------------------------------------
from controllers.web.message import MessageFeedbackPayload, MessageListQuery, MessageMoreLikeThisQuery

# ---------------------------------------------------------------------------
# remote_files.py models
# ---------------------------------------------------------------------------
from controllers.web.remote_files import RemoteFileUploadPayload

# ---------------------------------------------------------------------------
# saved_message.py models
# ---------------------------------------------------------------------------
from controllers.web.saved_message import SavedMessageCreatePayload, SavedMessageListQuery

# ---------------------------------------------------------------------------
# workflow.py models
# ---------------------------------------------------------------------------
from controllers.web.workflow import WorkflowRunPayload


class TestAppAccessModeQuery:
    def test_alias_resolution(self) -> None:
        q = AppAccessModeQuery.model_validate({"appId": "abc", "appCode": "xyz"})
        assert q.app_id == "abc"
        assert q.app_code == "xyz"

    def test_defaults_to_none(self) -> None:
        q = AppAccessModeQuery.model_validate({})
        assert q.app_id is None
        assert q.app_code is None

    def test_accepts_snake_case(self) -> None:
        q = AppAccessModeQuery(app_id="id1", app_code="code1")
        assert q.app_id == "id1"
        assert q.app_code == "code1"


class TestTextToAudioPayload:
    def test_defaults(self) -> None:
        p = TextToAudioPayload.model_validate({})
        assert p.message_id is None
        assert p.voice is None
        assert p.text is None
        assert p.streaming is None

    def test_valid_uuid_message_id(self) -> None:
        uid = str(uuid4())
        p = TextToAudioPayload(message_id=uid)
        assert p.message_id == uid

    def test_none_message_id_passthrough(self) -> None:
        p = TextToAudioPayload(message_id=None)
        assert p.message_id is None

    def test_invalid_uuid_message_id(self) -> None:
        with pytest.raises(ValidationError, match="not a valid uuid"):
            TextToAudioPayload(message_id="not-a-uuid")


class TestCompletionMessagePayload:
    def test_defaults(self) -> None:
        p = CompletionMessagePayload(inputs={})
        assert p.query == ""
        assert p.files is None
        assert p.response_mode is None
        assert p.retriever_from == "web_app"

    def test_accepts_full_payload(self) -> None:
        p = CompletionMessagePayload(
            inputs={"key": "val"},
            query="test",
            files=[{"id": "f1"}],
            response_mode="streaming",
        )
        assert p.response_mode == "streaming"
        assert p.files == [{"id": "f1"}]

    def test_invalid_response_mode(self) -> None:
        with pytest.raises(ValidationError):
            CompletionMessagePayload(inputs={}, response_mode="invalid")  # pyrefly: ignore[bad-argument-type]


class TestChatMessagePayload:
    def test_valid_uuid_fields(self) -> None:
        cid = str(uuid4())
        pid = str(uuid4())
        p = ChatMessagePayload(inputs={}, query="hi", conversation_id=cid, parent_message_id=pid)
        assert p.conversation_id == cid
        assert p.parent_message_id == pid

    def test_none_uuid_fields(self) -> None:
        p = ChatMessagePayload(inputs={}, query="hi")
        assert p.conversation_id is None
        assert p.parent_message_id is None

    def test_invalid_conversation_id(self) -> None:
        with pytest.raises(ValidationError, match="not a valid uuid"):
            ChatMessagePayload(inputs={}, query="hi", conversation_id="bad")

    def test_invalid_parent_message_id(self) -> None:
        with pytest.raises(ValidationError, match="not a valid uuid"):
            ChatMessagePayload(inputs={}, query="hi", parent_message_id="bad")

    def test_query_required(self) -> None:
        with pytest.raises(ValidationError):
            ChatMessagePayload(inputs={})  # pyrefly: ignore[missing-argument]


class TestConversationListQuery:
    def test_defaults(self) -> None:
        q = ConversationListQuery()
        assert q.last_id is None
        assert q.limit == 20
        assert q.pinned is None
        assert q.sort_by == "-updated_at"

    def test_limit_lower_bound(self) -> None:
        with pytest.raises(ValidationError):
            ConversationListQuery(limit=0)  # pyrefly: ignore[bad-argument-type]

    def test_limit_upper_bound(self) -> None:
        with pytest.raises(ValidationError):
            ConversationListQuery(limit=101)  # pyrefly: ignore[bad-argument-type]

    def test_limit_boundaries_valid(self) -> None:
        assert ConversationListQuery(limit=1).limit == 1
        assert ConversationListQuery(limit=100).limit == 100

    def test_valid_sort_by_options(self) -> None:
        for opt in ("created_at", "-created_at", "updated_at", "-updated_at"):
            assert ConversationListQuery(sort_by=opt).sort_by == opt

    def test_invalid_sort_by(self) -> None:
        with pytest.raises(ValidationError):
            ConversationListQuery(sort_by="invalid")  # pyrefly: ignore[bad-argument-type]

    def test_valid_last_id(self) -> None:
        uid = str(uuid4())
        assert ConversationListQuery(last_id=uid).last_id == uid

    def test_invalid_last_id(self) -> None:
        with pytest.raises(ValidationError, match="not a valid uuid"):
            ConversationListQuery(last_id="not-uuid")


class TestConversationRenamePayload:
    def test_auto_generate_true_no_name_required(self) -> None:
        p = ConversationRenamePayload(auto_generate=True)
        assert p.name is None

    def test_auto_generate_false_requires_name(self) -> None:
        with pytest.raises(ValidationError, match="name is required"):
            ConversationRenamePayload(auto_generate=False)

    def test_auto_generate_false_blank_name_rejected(self) -> None:
        with pytest.raises(ValidationError, match="name is required"):
            ConversationRenamePayload(auto_generate=False, name="   ")

    def test_auto_generate_false_with_valid_name(self) -> None:
        p = ConversationRenamePayload(auto_generate=False, name="My Chat")
        assert p.name == "My Chat"

    def test_defaults(self) -> None:
        p = ConversationRenamePayload(name="test")
        assert p.auto_generate is False
        assert p.name == "test"


class TestMessageListQuery:
    def test_valid_query(self) -> None:
        cid = str(uuid4())
        q = MessageListQuery(conversation_id=cid)
        assert q.conversation_id == cid
        assert q.first_id is None
        assert q.limit == 20

    def test_invalid_conversation_id(self) -> None:
        with pytest.raises(ValidationError, match="must be a valid UUID"):
            MessageListQuery(conversation_id="bad")

    def test_limit_bounds(self) -> None:
        cid = str(uuid4())
        with pytest.raises(ValidationError):
            MessageListQuery(conversation_id=cid, limit=0)  # pyrefly: ignore[bad-argument-type]
        with pytest.raises(ValidationError):
            MessageListQuery(conversation_id=cid, limit=101)  # pyrefly: ignore[bad-argument-type]

    def test_valid_first_id(self) -> None:
        cid = str(uuid4())
        fid = str(uuid4())
        q = MessageListQuery(conversation_id=cid, first_id=fid)
        assert q.first_id == fid

    def test_invalid_first_id(self) -> None:
        cid = str(uuid4())
        with pytest.raises(ValidationError, match="must be a valid UUID"):
            MessageListQuery(conversation_id=cid, first_id="invalid")


class TestMessageFeedbackPayload:
    def test_defaults(self) -> None:
        p = MessageFeedbackPayload()
        assert p.rating is None
        assert p.content is None

    def test_valid_ratings(self) -> None:
        assert MessageFeedbackPayload(rating="like").rating == "like"
        assert MessageFeedbackPayload(rating="dislike").rating == "dislike"

    def test_invalid_rating(self) -> None:
        with pytest.raises(ValidationError):
            MessageFeedbackPayload(rating="neutral")  # pyrefly: ignore[bad-argument-type]


class TestMessageMoreLikeThisQuery:
    def test_valid_modes(self) -> None:
        assert MessageMoreLikeThisQuery(response_mode="blocking").response_mode == "blocking"
        assert MessageMoreLikeThisQuery(response_mode="streaming").response_mode == "streaming"

    def test_invalid_mode(self) -> None:
        with pytest.raises(ValidationError):
            MessageMoreLikeThisQuery(response_mode="invalid")  # pyrefly: ignore[bad-argument-type]

    def test_required(self) -> None:
        with pytest.raises(ValidationError):
            MessageMoreLikeThisQuery()  # pyrefly: ignore[missing-argument]


class TestRemoteFileUploadPayload:
    def test_valid_url(self) -> None:
        p = RemoteFileUploadPayload(url="https://example.com/file.pdf")
        assert p.url == "https://example.com/file.pdf"

    def test_url_syntax_is_validated_by_remote_file_service(self) -> None:
        payload = RemoteFileUploadPayload(url="not-a-url")

        assert payload.url == "not-a-url"

    def test_url_required(self) -> None:
        with pytest.raises(ValidationError):
            RemoteFileUploadPayload()  # pyrefly: ignore[missing-argument]


class TestSavedMessageListQuery:
    def test_defaults(self) -> None:
        q = SavedMessageListQuery()
        assert q.last_id is None
        assert q.limit == 20

    def test_limit_bounds(self) -> None:
        with pytest.raises(ValidationError):
            SavedMessageListQuery(limit=0)  # pyrefly: ignore[bad-argument-type]
        with pytest.raises(ValidationError):
            SavedMessageListQuery(limit=101)  # pyrefly: ignore[bad-argument-type]

    def test_valid_last_id(self) -> None:
        uid = str(uuid4())
        q = SavedMessageListQuery(last_id=uid)
        assert q.last_id == uid

    def test_empty_last_id(self) -> None:
        q = SavedMessageListQuery(last_id="")
        assert q.last_id == ""


class TestSavedMessageCreatePayload:
    def test_valid_message_id(self) -> None:
        uid = str(uuid4())
        p = SavedMessageCreatePayload(message_id=uid)
        assert p.message_id == uid

    def test_required(self) -> None:
        with pytest.raises(ValidationError):
            SavedMessageCreatePayload()  # pyrefly: ignore[missing-argument]


class TestWorkflowRunPayload:
    def test_defaults(self) -> None:
        p = WorkflowRunPayload(inputs={})
        assert p.inputs == {}
        assert p.files is None

    def test_with_files(self) -> None:
        p = WorkflowRunPayload(inputs={"k": "v"}, files=[{"id": "f1"}])
        assert p.files == [{"id": "f1"}]

    def test_inputs_required(self) -> None:
        with pytest.raises(ValidationError):
            WorkflowRunPayload()  # pyrefly: ignore[missing-argument]


class TestForgotPasswordSendPayload:
    def test_valid_email(self) -> None:
        p = ForgotPasswordSendPayload(email="[email protected]")
        assert p.email == "[email protected]"

    def test_invalid_email(self) -> None:
        with pytest.raises(ValidationError, match="not a valid email"):
            ForgotPasswordSendPayload(email="not-an-email")

    def test_language_optional(self) -> None:
        p = ForgotPasswordSendPayload(email="[email protected]")
        assert p.language is None


class TestForgotPasswordCheckPayload:
    def test_valid(self) -> None:
        p = ForgotPasswordCheckPayload(email="[email protected]", code="1234", token="tok")
        assert p.email == "[email protected]"
        assert p.code == "1234"
        assert p.token == "tok"

    def test_empty_token_rejected(self) -> None:
        with pytest.raises(ValidationError):
            ForgotPasswordCheckPayload(email="[email protected]", code="1234", token="")


class TestForgotPasswordResetPayload:
    def test_valid_passwords(self) -> None:
        p = ForgotPasswordResetPayload(token="tok", new_password="Valid1234", password_confirm="Valid1234")
        assert p.new_password == "Valid1234"

    def test_weak_password_rejected(self) -> None:
        with pytest.raises(ValidationError, match="Password must contain"):
            ForgotPasswordResetPayload(token="tok", new_password="short", password_confirm="short")

    def test_letters_only_password_rejected(self) -> None:
        with pytest.raises(ValidationError, match="Password must contain"):
            ForgotPasswordResetPayload(token="tok", new_password="abcdefghi", password_confirm="abcdefghi")

    def test_digits_only_password_rejected(self) -> None:
        with pytest.raises(ValidationError, match="Password must contain"):
            ForgotPasswordResetPayload(token="tok", new_password="123456789", password_confirm="123456789")


class TestLoginPayload:
    def test_valid(self) -> None:
        p = LoginPayload(email="[email protected]", password="Valid1234")
        assert p.email == "[email protected]"

    def test_invalid_email(self) -> None:
        with pytest.raises(ValidationError, match="not a valid email"):
            LoginPayload(email="bad", password="Valid1234")

    def test_weak_password(self) -> None:
        with pytest.raises(ValidationError, match="Password must contain"):
            LoginPayload(email="[email protected]", password="weak")


class TestEmailCodeLoginSendPayload:
    def test_valid(self) -> None:
        p = EmailCodeLoginSendPayload(email="[email protected]")
        assert p.language is None

    def test_with_language(self) -> None:
        p = EmailCodeLoginSendPayload(email="[email protected]", language="zh-Hans")
        assert p.language == "zh-Hans"


class TestEmailCodeLoginVerifyPayload:
    def test_valid(self) -> None:
        p = EmailCodeLoginVerifyPayload(email="[email protected]", code="1234", token="tok")
        assert p.code == "1234"

    def test_empty_token_rejected(self) -> None:
        with pytest.raises(ValidationError):
            EmailCodeLoginVerifyPayload(email="[email protected]", code="1234", token="")