🐛 Fix handling of bool literals (#783)

Author: lig

src/serializers/type_serializers/literal.rs

@@ -44,7 +44,9 @@ impl BuildSerializer for LiteralSerializer {
         let mut repr_args: Vec<String> = Vec::new();
         for item in expected {
             repr_args.push(item.repr()?.extract()?);
-            if let Ok(int) = extract_i64(item) {
+            if let Ok(bool) = item.downcast::<PyBool>() {
+                expected_py.append(bool)?;
+            } else if let Ok(int) = extract_i64(item) {
                 expected_int.insert(int);
             } else if let Ok(py_str) = item.downcast::<PyString>() {
                 expected_str.insert(py_str.to_str()?.to_string());

tests/serializers/test_literal.py

@@ -61,3 +61,13 @@ def test_other_literal():
 def test_empty_literal():
     with pytest.raises(SchemaError, match='`expected` should have length > 0'):
         SchemaSerializer(core_schema.literal_schema([]))
+
+
+def test_bool_literal():
+    s = SchemaSerializer(core_schema.literal_schema([False]))
+    assert 'expected_int:{},expected_str:{},expected_py:Some(Py(' in plain_repr(s)
+
+    assert s.to_python(False) is False
+    assert s.to_python(False, mode='json') is False
+    assert s.to_python(True) is True
+    assert s.to_json(False) == b'false'

tests/serializers/test_union.py

@@ -1,12 +1,20 @@
 import dataclasses
 import json
 import re
+from typing import Union
 
 import pytest
+from typing_extensions import Literal
 
 from pydantic_core import PydanticSerializationUnexpectedValue, SchemaSerializer, core_schema
 
 
+class BaseModel:
+    def __init__(self, **kwargs) -> None:
+        for name, value in kwargs.items():
+            setattr(self, name, value)
+
+
 @pytest.mark.parametrize('input_value,expected_value', [(True, True), (False, False), (1, 1), (123, 123), (-42, -42)])
 def test_union_bool_int(input_value, expected_value):
     s = SchemaSerializer(core_schema.union_schema([core_schema.bool_schema(), core_schema.int_schema()]))
@@ -360,3 +368,31 @@ def __init__(self, name: str, price: float):
     assert s.to_python(User(name='foo', surname='bar')) == {'name': 'foo', 'surname': 'bar'}
     assert s.to_python(DBUser(name='foo', surname='bar', password_hash='x')) == {'name': 'foo', 'surname': 'bar'}
     assert s.to_json(DBUser(name='foo', surname='bar', password_hash='x')) == b'{"name":"foo","surname":"bar"}'
+
+
+@pytest.mark.parametrize(('data', 'json_value'), [(False, 'false'), ('abc', '"abc"')])
+def test_union_literal_with_other_type(data, json_value):
+    class Model(BaseModel):
+        value: Union[Literal[False], str]
+        value_types_reversed: Union[str, Literal[False]]
+
+    s = SchemaSerializer(
+        core_schema.model_schema(
+            Model,
+            core_schema.model_fields_schema(
+                {
+                    'value': core_schema.model_field(
+                        core_schema.union_schema([core_schema.literal_schema([False]), core_schema.str_schema()])
+                    ),
+                    'value_types_reversed': core_schema.model_field(
+                        core_schema.union_schema([core_schema.str_schema(), core_schema.literal_schema([False])])
+                    ),
+                }
+            ),
+        )
+    )
+
+    m = Model(value=data, value_types_reversed=data)
+
+    assert s.to_python(m) == {'value': data, 'value_types_reversed': data}
+    assert s.to_json(m) == f'{{"value":{json_value},"value_types_reversed":{json_value}}}'.encode()