fastapi/tests/test_path.py

from dirty_equals import IsDict
from fastapi.testclient import TestClient
from fastapi.utils import match_pydantic_error_url

from .main import app

client = TestClient(app)


def test_text_get():
    response = client.get("/text")
    assert response.status_code == 200, response.text
    assert response.json() == "Hello World"


def test_nonexistent():
    response = client.get("/nonexistent")
    assert response.status_code == 404, response.text
    assert response.json() == {"detail": "Not Found"}


def test_path_foobar():
    response = client.get("/path/foobar")
    assert response.status_code == 200
    assert response.json() == "foobar"


def test_path_str_foobar():
    response = client.get("/path/str/foobar")
    assert response.status_code == 200
    assert response.json() == "foobar"


def test_path_str_42():
    response = client.get("/path/str/42")
    assert response.status_code == 200
    assert response.json() == "42"


def test_path_str_True():
    response = client.get("/path/str/True")
    assert response.status_code == 200
    assert response.json() == "True"


def test_path_int_foobar():
    response = client.get("/path/int/foobar")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "int_parsing",
                    "loc": ["path", "item_id"],
                    "msg": "Input should be a valid integer, unable to parse string as an integer",
                    "input": "foobar",
                    "url": match_pydantic_error_url("int_parsing"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "value is not a valid integer",
                    "type": "type_error.integer",
                }
            ]
        }
    )


def test_path_int_True():
    response = client.get("/path/int/True")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "int_parsing",
                    "loc": ["path", "item_id"],
                    "msg": "Input should be a valid integer, unable to parse string as an integer",
                    "input": "True",
                    "url": match_pydantic_error_url("int_parsing"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "value is not a valid integer",
                    "type": "type_error.integer",
                }
            ]
        }
    )


def test_path_int_42():
    response = client.get("/path/int/42")
    assert response.status_code == 200
    assert response.json() == 42


def test_path_int_42_5():
    response = client.get("/path/int/42.5")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "int_parsing",
                    "loc": ["path", "item_id"],
                    "msg": "Input should be a valid integer, unable to parse string as an integer",
                    "input": "42.5",
                    "url": match_pydantic_error_url("int_parsing"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "value is not a valid integer",
                    "type": "type_error.integer",
                }
            ]
        }
    )


def test_path_float_foobar():
    response = client.get("/path/float/foobar")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "float_parsing",
                    "loc": ["path", "item_id"],
                    "msg": "Input should be a valid number, unable to parse string as a number",
                    "input": "foobar",
                    "url": match_pydantic_error_url("float_parsing"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "value is not a valid float",
                    "type": "type_error.float",
                }
            ]
        }
    )


def test_path_float_True():
    response = client.get("/path/float/True")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "float_parsing",
                    "loc": ["path", "item_id"],
                    "msg": "Input should be a valid number, unable to parse string as a number",
                    "input": "True",
                    "url": match_pydantic_error_url("float_parsing"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "value is not a valid float",
                    "type": "type_error.float",
                }
            ]
        }
    )


def test_path_float_42():
    response = client.get("/path/float/42")
    assert response.status_code == 200
    assert response.json() == 42


def test_path_float_42_5():
    response = client.get("/path/float/42.5")
    assert response.status_code == 200
    assert response.json() == 42.5


def test_path_bool_foobar():
    response = client.get("/path/bool/foobar")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "bool_parsing",
                    "loc": ["path", "item_id"],
                    "msg": "Input should be a valid boolean, unable to interpret input",
                    "input": "foobar",
                    "url": match_pydantic_error_url("bool_parsing"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "value could not be parsed to a boolean",
                    "type": "type_error.bool",
                }
            ]
        }
    )


def test_path_bool_True():
    response = client.get("/path/bool/True")
    assert response.status_code == 200
    assert response.json() is True


def test_path_bool_42():
    response = client.get("/path/bool/42")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "bool_parsing",
                    "loc": ["path", "item_id"],
                    "msg": "Input should be a valid boolean, unable to interpret input",
                    "input": "42",
                    "url": match_pydantic_error_url("bool_parsing"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "value could not be parsed to a boolean",
                    "type": "type_error.bool",
                }
            ]
        }
    )


def test_path_bool_42_5():
    response = client.get("/path/bool/42.5")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "bool_parsing",
                    "loc": ["path", "item_id"],
                    "msg": "Input should be a valid boolean, unable to interpret input",
                    "input": "42.5",
                    "url": match_pydantic_error_url("bool_parsing"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "value could not be parsed to a boolean",
                    "type": "type_error.bool",
                }
            ]
        }
    )


def test_path_bool_1():
    response = client.get("/path/bool/1")
    assert response.status_code == 200
    assert response.json() is True


def test_path_bool_0():
    response = client.get("/path/bool/0")
    assert response.status_code == 200
    assert response.json() is False


def test_path_bool_true():
    response = client.get("/path/bool/true")
    assert response.status_code == 200
    assert response.json() is True


def test_path_bool_False():
    response = client.get("/path/bool/False")
    assert response.status_code == 200
    assert response.json() is False


def test_path_bool_false():
    response = client.get("/path/bool/false")
    assert response.status_code == 200
    assert response.json() is False


def test_path_param_foo():
    response = client.get("/path/param/foo")
    assert response.status_code == 200
    assert response.json() == "foo"


def test_path_param_minlength_foo():
    response = client.get("/path/param-minlength/foo")
    assert response.status_code == 200
    assert response.json() == "foo"


def test_path_param_minlength_fo():
    response = client.get("/path/param-minlength/fo")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "string_too_short",
                    "loc": ["path", "item_id"],
                    "msg": "String should have at least 3 characters",
                    "input": "fo",
                    "ctx": {"min_length": 3},
                    "url": match_pydantic_error_url("string_too_short"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "ensure this value has at least 3 characters",
                    "type": "value_error.any_str.min_length",
                    "ctx": {"limit_value": 3},
                }
            ]
        }
    )


def test_path_param_maxlength_foo():
    response = client.get("/path/param-maxlength/foo")
    assert response.status_code == 200
    assert response.json() == "foo"


def test_path_param_maxlength_foobar():
    response = client.get("/path/param-maxlength/foobar")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "string_too_long",
                    "loc": ["path", "item_id"],
                    "msg": "String should have at most 3 characters",
                    "input": "foobar",
                    "ctx": {"max_length": 3},
                    "url": match_pydantic_error_url("string_too_long"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "ensure this value has at most 3 characters",
                    "type": "value_error.any_str.max_length",
                    "ctx": {"limit_value": 3},
                }
            ]
        }
    )


def test_path_param_min_maxlength_foo():
    response = client.get("/path/param-min_maxlength/foo")
    assert response.status_code == 200
    assert response.json() == "foo"


def test_path_param_min_maxlength_foobar():
    response = client.get("/path/param-min_maxlength/foobar")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "string_too_long",
                    "loc": ["path", "item_id"],
                    "msg": "String should have at most 3 characters",
                    "input": "foobar",
                    "ctx": {"max_length": 3},
                    "url": match_pydantic_error_url("string_too_long"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "ensure this value has at most 3 characters",
                    "type": "value_error.any_str.max_length",
                    "ctx": {"limit_value": 3},
                }
            ]
        }
    )


def test_path_param_min_maxlength_f():
    response = client.get("/path/param-min_maxlength/f")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "string_too_short",
                    "loc": ["path", "item_id"],
                    "msg": "String should have at least 2 characters",
                    "input": "f",
                    "ctx": {"min_length": 2},
                    "url": match_pydantic_error_url("string_too_short"),
                }
            ]
        }
    ) | IsDict(
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "ensure this value has at least 2 characters",
                    "type": "value_error.any_str.min_length",
                    "ctx": {"limit_value": 2},
                }
            ]
        }
    )


def test_path_param_gt_42():
    response = client.get("/path/param-gt/42")
    assert response.status_code == 200
    assert response.json() == 42


def test_path_param_gt_2():
    response = client.get("/path/param-gt/2")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "greater_than",
                    "loc": ["path", "item_id"],
                    "msg": "Input should be greater than 3",
                    "input": "2",
                    "ctx": {"gt": 3.0},
                    "url": match_pydantic_error_url("greater_than"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "ensure this value is greater than 3",
                    "type": "value_error.number.not_gt",
                    "ctx": {"limit_value": 3},
                }
            ]
        }
    )


def test_path_param_gt0_0_05():
    response = client.get("/path/param-gt0/0.05")
    assert response.status_code == 200
    assert response.json() == 0.05


def test_path_param_gt0_0():
    response = client.get("/path/param-gt0/0")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "greater_than",
                    "loc": ["path", "item_id"],
                    "msg": "Input should be greater than 0",
                    "input": "0",
                    "ctx": {"gt": 0.0},
                    "url": match_pydantic_error_url("greater_than"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "ensure this value is greater than 0",
                    "type": "value_error.number.not_gt",
                    "ctx": {"limit_value": 0},
                }
            ]
        }
    )


def test_path_param_ge_42():
    response = client.get("/path/param-ge/42")
    assert response.status_code == 200
    assert response.json() == 42


def test_path_param_ge_3():
    response = client.get("/path/param-ge/3")
    assert response.status_code == 200
    assert response.json() == 3


def test_path_param_ge_2():
    response = client.get("/path/param-ge/2")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "greater_than_equal",
                    "loc": ["path", "item_id"],
                    "msg": "Input should be greater than or equal to 3",
                    "input": "2",
                    "ctx": {"ge": 3.0},
                    "url": match_pydantic_error_url("greater_than_equal"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "ensure this value is greater than or equal to 3",
                    "type": "value_error.number.not_ge",
                    "ctx": {"limit_value": 3},
                }
            ]
        }
    )


def test_path_param_lt_42():
    response = client.get("/path/param-lt/42")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "less_than",
                    "loc": ["path", "item_id"],
                    "msg": "Input should be less than 3",
                    "input": "42",
                    "ctx": {"lt": 3.0},
                    "url": match_pydantic_error_url("less_than"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "ensure this value is less than 3",
                    "type": "value_error.number.not_lt",
                    "ctx": {"limit_value": 3},
                }
            ]
        }
    )


def test_path_param_lt_2():
    response = client.get("/path/param-lt/2")
    assert response.status_code == 200
    assert response.json() == 2


def test_path_param_lt0__1():
    response = client.get("/path/param-lt0/-1")
    assert response.status_code == 200
    assert response.json() == -1


def test_path_param_lt0_0():
    response = client.get("/path/param-lt0/0")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "less_than",
                    "loc": ["path", "item_id"],
                    "msg": "Input should be less than 0",
                    "input": "0",
                    "ctx": {"lt": 0.0},
                    "url": match_pydantic_error_url("less_than"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "ensure this value is less than 0",
                    "type": "value_error.number.not_lt",
                    "ctx": {"limit_value": 0},
                }
            ]
        }
    )


def test_path_param_le_42():
    response = client.get("/path/param-le/42")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "less_than_equal",
                    "loc": ["path", "item_id"],
                    "msg": "Input should be less than or equal to 3",
                    "input": "42",
                    "ctx": {"le": 3.0},
                    "url": match_pydantic_error_url("less_than_equal"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "ensure this value is less than or equal to 3",
                    "type": "value_error.number.not_le",
                    "ctx": {"limit_value": 3},
                }
            ]
        }
    )


def test_path_param_le_3():
    response = client.get("/path/param-le/3")
    assert response.status_code == 200
    assert response.json() == 3


def test_path_param_le_2():
    response = client.get("/path/param-le/2")
    assert response.status_code == 200
    assert response.json() == 2


def test_path_param_lt_gt_2():
    response = client.get("/path/param-lt-gt/2")
    assert response.status_code == 200
    assert response.json() == 2


def test_path_param_lt_gt_4():
    response = client.get("/path/param-lt-gt/4")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "less_than",
                    "loc": ["path", "item_id"],
                    "msg": "Input should be less than 3",
                    "input": "4",
                    "ctx": {"lt": 3.0},
                    "url": match_pydantic_error_url("less_than"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "ensure this value is less than 3",
                    "type": "value_error.number.not_lt",
                    "ctx": {"limit_value": 3},
                }
            ]
        }
    )


def test_path_param_lt_gt_0():
    response = client.get("/path/param-lt-gt/0")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "greater_than",
                    "loc": ["path", "item_id"],
                    "msg": "Input should be greater than 1",
                    "input": "0",
                    "ctx": {"gt": 1.0},
                    "url": match_pydantic_error_url("greater_than"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "ensure this value is greater than 1",
                    "type": "value_error.number.not_gt",
                    "ctx": {"limit_value": 1},
                }
            ]
        }
    )


def test_path_param_le_ge_2():
    response = client.get("/path/param-le-ge/2")
    assert response.status_code == 200
    assert response.json() == 2


def test_path_param_le_ge_1():
    response = client.get("/path/param-le-ge/1")
    assert response.status_code == 200


def test_path_param_le_ge_3():
    response = client.get("/path/param-le-ge/3")
    assert response.status_code == 200
    assert response.json() == 3


def test_path_param_le_ge_4():
    response = client.get("/path/param-le-ge/4")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "less_than_equal",
                    "loc": ["path", "item_id"],
                    "msg": "Input should be less than or equal to 3",
                    "input": "4",
                    "ctx": {"le": 3.0},
                    "url": match_pydantic_error_url("less_than_equal"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "ensure this value is less than or equal to 3",
                    "type": "value_error.number.not_le",
                    "ctx": {"limit_value": 3},
                }
            ]
        }
    )


def test_path_param_lt_int_2():
    response = client.get("/path/param-lt-int/2")
    assert response.status_code == 200
    assert response.json() == 2


def test_path_param_lt_int_42():
    response = client.get("/path/param-lt-int/42")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "less_than",
                    "loc": ["path", "item_id"],
                    "msg": "Input should be less than 3",
                    "input": "42",
                    "ctx": {"lt": 3},
                    "url": match_pydantic_error_url("less_than"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "ensure this value is less than 3",
                    "type": "value_error.number.not_lt",
                    "ctx": {"limit_value": 3},
                }
            ]
        }
    )


def test_path_param_lt_int_2_7():
    response = client.get("/path/param-lt-int/2.7")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "int_parsing",
                    "loc": ["path", "item_id"],
                    "msg": "Input should be a valid integer, unable to parse string as an integer",
                    "input": "2.7",
                    "url": match_pydantic_error_url("int_parsing"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "value is not a valid integer",
                    "type": "type_error.integer",
                }
            ]
        }
    )


def test_path_param_gt_int_42():
    response = client.get("/path/param-gt-int/42")
    assert response.status_code == 200
    assert response.json() == 42


def test_path_param_gt_int_2():
    response = client.get("/path/param-gt-int/2")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "greater_than",
                    "loc": ["path", "item_id"],
                    "msg": "Input should be greater than 3",
                    "input": "2",
                    "ctx": {"gt": 3},
                    "url": match_pydantic_error_url("greater_than"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "ensure this value is greater than 3",
                    "type": "value_error.number.not_gt",
                    "ctx": {"limit_value": 3},
                }
            ]
        }
    )


def test_path_param_gt_int_2_7():
    response = client.get("/path/param-gt-int/2.7")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "int_parsing",
                    "loc": ["path", "item_id"],
                    "msg": "Input should be a valid integer, unable to parse string as an integer",
                    "input": "2.7",
                    "url": match_pydantic_error_url("int_parsing"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "value is not a valid integer",
                    "type": "type_error.integer",
                }
            ]
        }
    )


def test_path_param_le_int_42():
    response = client.get("/path/param-le-int/42")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "less_than_equal",
                    "loc": ["path", "item_id"],
                    "msg": "Input should be less than or equal to 3",
                    "input": "42",
                    "ctx": {"le": 3},
                    "url": match_pydantic_error_url("less_than_equal"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "ensure this value is less than or equal to 3",
                    "type": "value_error.number.not_le",
                    "ctx": {"limit_value": 3},
                }
            ]
        }
    )


def test_path_param_le_int_3():
    response = client.get("/path/param-le-int/3")
    assert response.status_code == 200
    assert response.json() == 3


def test_path_param_le_int_2():
    response = client.get("/path/param-le-int/2")
    assert response.status_code == 200
    assert response.json() == 2


def test_path_param_le_int_2_7():
    response = client.get("/path/param-le-int/2.7")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "int_parsing",
                    "loc": ["path", "item_id"],
                    "msg": "Input should be a valid integer, unable to parse string as an integer",
                    "input": "2.7",
                    "url": match_pydantic_error_url("int_parsing"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "value is not a valid integer",
                    "type": "type_error.integer",
                }
            ]
        }
    )


def test_path_param_ge_int_42():
    response = client.get("/path/param-ge-int/42")
    assert response.status_code == 200
    assert response.json() == 42


def test_path_param_ge_int_3():
    response = client.get("/path/param-ge-int/3")
    assert response.status_code == 200
    assert response.json() == 3


def test_path_param_ge_int_2():
    response = client.get("/path/param-ge-int/2")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "greater_than_equal",
                    "loc": ["path", "item_id"],
                    "msg": "Input should be greater than or equal to 3",
                    "input": "2",
                    "ctx": {"ge": 3},
                    "url": match_pydantic_error_url("greater_than_equal"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "ensure this value is greater than or equal to 3",
                    "type": "value_error.number.not_ge",
                    "ctx": {"limit_value": 3},
                }
            ]
        }
    )


def test_path_param_ge_int_2_7():
    response = client.get("/path/param-ge-int/2.7")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "int_parsing",
                    "loc": ["path", "item_id"],
                    "msg": "Input should be a valid integer, unable to parse string as an integer",
                    "input": "2.7",
                    "url": match_pydantic_error_url("int_parsing"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "value is not a valid integer",
                    "type": "type_error.integer",
                }
            ]
        }
    )


def test_path_param_lt_gt_int_2():
    response = client.get("/path/param-lt-gt-int/2")
    assert response.status_code == 200
    assert response.json() == 2


def test_path_param_lt_gt_int_4():
    response = client.get("/path/param-lt-gt-int/4")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "less_than",
                    "loc": ["path", "item_id"],
                    "msg": "Input should be less than 3",
                    "input": "4",
                    "ctx": {"lt": 3},
                    "url": match_pydantic_error_url("less_than"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "ensure this value is less than 3",
                    "type": "value_error.number.not_lt",
                    "ctx": {"limit_value": 3},
                }
            ]
        }
    )


def test_path_param_lt_gt_int_0():
    response = client.get("/path/param-lt-gt-int/0")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "greater_than",
                    "loc": ["path", "item_id"],
                    "msg": "Input should be greater than 1",
                    "input": "0",
                    "ctx": {"gt": 1},
                    "url": match_pydantic_error_url("greater_than"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "ensure this value is greater than 1",
                    "type": "value_error.number.not_gt",
                    "ctx": {"limit_value": 1},
                }
            ]
        }
    )


def test_path_param_lt_gt_int_2_7():
    response = client.get("/path/param-lt-gt-int/2.7")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "int_parsing",
                    "loc": ["path", "item_id"],
                    "msg": "Input should be a valid integer, unable to parse string as an integer",
                    "input": "2.7",
                    "url": match_pydantic_error_url("int_parsing"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "value is not a valid integer",
                    "type": "type_error.integer",
                }
            ]
        }
    )


def test_path_param_le_ge_int_2():
    response = client.get("/path/param-le-ge-int/2")
    assert response.status_code == 200
    assert response.json() == 2


def test_path_param_le_ge_int_1():
    response = client.get("/path/param-le-ge-int/1")
    assert response.status_code == 200
    assert response.json() == 1


def test_path_param_le_ge_int_3():
    response = client.get("/path/param-le-ge-int/3")
    assert response.status_code == 200
    assert response.json() == 3


def test_path_param_le_ge_int_4():
    response = client.get("/path/param-le-ge-int/4")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "less_than_equal",
                    "loc": ["path", "item_id"],
                    "msg": "Input should be less than or equal to 3",
                    "input": "4",
                    "ctx": {"le": 3},
                    "url": match_pydantic_error_url("less_than_equal"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "ensure this value is less than or equal to 3",
                    "type": "value_error.number.not_le",
                    "ctx": {"limit_value": 3},
                }
            ]
        }
    )


def test_path_param_le_ge_int_2_7():
    response = client.get("/path/param-le-ge-int/2.7")
    assert response.status_code == 422
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "int_parsing",
                    "loc": ["path", "item_id"],
                    "msg": "Input should be a valid integer, unable to parse string as an integer",
                    "input": "2.7",
                    "url": match_pydantic_error_url("int_parsing"),
                }
            ]
        }
    ) | IsDict(
        # TODO: remove when deprecating Pydantic v1
        {
            "detail": [
                {
                    "loc": ["path", "item_id"],
                    "msg": "value is not a valid integer",
                    "type": "type_error.integer",
                }
            ]
        }
    )