legal-ai-assistant/tests/unit/test_schemas.py

import pytest
from pydantic import ValidationError
from backend.tools.api.schemas import (
    CourtSearch, JudgeSearch, DecisionSearch,
    CivilProceedingsSearch,
    CourtByID, JudgeByID, AdminProceedingsByID,
    ExecutorByID, ExecutorByECE,
    JudgeAutocomplete, ContractAutocomplete, CivilProceedingsAutocomplete,
    DecisionAutocomplete
)

class TestPagination:
    """
    Checks pagination (page/size) validation, 
    defaults, and sorting.
    """

    def test_page_is_valid(self) -> None:
        is_valid = JudgeSearch(page=0, size=10)
        assert is_valid.page == 0

    @pytest.mark.parametrize("page", [-1, -100])
    def test_invalid_page(self, page) -> None:
        with pytest.raises(ValidationError):
            JudgeSearch(page=page)

    @pytest.mark.parametrize("size", [0, -1, -100])
    def test_invalid_size(self, size) -> None:
        with pytest.raises(ValidationError):
            JudgeSearch(size=size)

    def test_sort_direction_default(self) -> None:
        asc = JudgeSearch()
        assert asc.sortDirection == "ASC"

    def test_sort_direction_desc(self) -> None:
        desc = JudgeSearch(sortDirection="DESC")
        assert desc.sortDirection == "DESC"

    def test_sort_direction_invalid(self) -> None:
        with pytest.raises(ValidationError):
            JudgeSearch(sortDirection="INVALID")

class TestIDNormalization:
    """
    Checks ID normalization 
    (adding prefixes and sanitizing input).
    """

    @pytest.mark.parametrize("input_id", ["sud_121", "121", " sud_121 ", "    121    "])
    def test_court_by_id(self, input_id) -> None:
        court = CourtByID(id=input_id)
        assert court.id == "sud_121"

    @pytest.mark.parametrize("input_id", ["sudca_121", "121", " sudca_121 ", "    121    "])
    def test_judge_by_id(self, input_id) -> None:
        court = JudgeByID(id=input_id)
        assert court.id == "sudca_121"

    @pytest.mark.parametrize("input_id", ["spravneKonanie_121", "121", " spravneKonanie_121 ", "    121    "])
    def test_admin_proceedings_by_id(self, input_id) -> None:
        assert AdminProceedingsByID(id=input_id).id == "spravneKonanie_121"

    @pytest.mark.parametrize("input_id", ["exekutor_121", "121", " exekutor_121 ", "    121    "])
    def test_executor_by_id(self, input_id) -> None:
        assert ExecutorByID(id=input_id).id == "exekutor_121"

    @pytest.mark.parametrize("ece", ["089", "   089", "089  "])
    def test_ece_accepted(self, ece) -> None:
        s = ExecutorByECE(ece=ece)
        assert s.ece == "089"
    
    @pytest.mark.parametrize("ece", ["", "   ", None])
    def test_ece_required(self, ece) -> None:
        with pytest.raises(ValidationError):
            ExecutorByECE(ece=ece)

class TestOptionalFields:
    """
    Checks the operation of optional fields 
    and the independence of parameters.
    """
    
    def test_facet_filter_accepts_list(self) -> None:
        s = CourtSearch(
            typSuduFacetFilter=["Okresný súd", "Krajský súd"],
            krajFacetFilter=["Bratislavský kraj"]
        )
        assert len(s.typSuduFacetFilter) == 2
        assert s.krajFacetFilter == ["Bratislavský kraj"]

    def test_date_fields_are_independent(self) -> None:
        s = DecisionSearch(vydaniaOd="01.01.2024")
        assert s.vydaniaOd == "01.01.2024"
        assert s.vydaniaDo is None

class TestSearchSchemas:
    """
    Checks the validity of search schemes 
    and basic fields.
    """
    
    def test_empty_search_is_valid(self, all_search) -> None:
        for cls in all_search:
            assert cls() is not None
    
    def test_civil_proceeding_search_bool(self) -> None:
        cp = CivilProceedingsSearch(verejneVyhlasenie=True)
        assert cp.verejneVyhlasenie is True


class TestAutocompleteCommon:
    """
    Checks common autocomplete behavior 
    (query, limit, defaults, validation).
    """
    
    def test_empty_is_valid(self, all_autocomplete) -> None:
        for cls in all_autocomplete:
            assert cls() is not None

    def test_query_accepts_string(self, all_autocomplete) -> None:
        for cls in all_autocomplete:
            s = cls(query="test")
            assert s.query == "test"

    def test_query_none_by_default(self, all_autocomplete) -> None:
        for cls in all_autocomplete:
            assert cls().query is None

    @pytest.mark.parametrize("limit", [0, -1, -100])
    def test_invalid_limit(self, limit, all_autocomplete) -> None:
        for cls in all_autocomplete:
            with pytest.raises(ValidationError):
                cls(limit=limit)


class TestAutocompleteUniqueFields:
    """
    Checks specific fields of various 
    autocomplete schemes.
    """

    def test_judge_autocomplete_giud_sud(self) -> None:
        s = JudgeAutocomplete(guidSud="sud_175")
        assert s.guidSud == "sud_175"

    def test_judge_autocomplete_guid_sud_none_by_default(self) -> None:
        s = JudgeAutocomplete()
        assert s.guidSud is None

    def test_civil_autocomplete_verejne_vyhlasenie(self) -> None:
        s = CivilProceedingsAutocomplete(verejneVyhlasenie=True)
        assert s.verejneVyhlasenie is True

    def test_civil_autocomplete_guid_sudca(self) -> None:
        s = CivilProceedingsAutocomplete(guidSudca="sudca_1")
        assert s.guidSudca == "sudca_1"

    def test_decision_autocomplete_guid_sud(self) -> None:
        s = DecisionAutocomplete(guidSud="sud_100")
        assert s.guidSud == "sud_100"

    def test_contract_autocomplete_guid_sud(self) -> None:
        s = ContractAutocomplete(guidSud="sud_100")
        assert s.guidSud == "sud_100"