Update tests

Author: BoxyUwU

tests/serializers/test_any.py

@@ -158,7 +158,7 @@ def test_any_with_date_serializer():
         assert s.to_python(b'bang', mode='json') == 'bang'
 
     assert [w.message.args[0] for w in warning_info.list] == [
-        'Pydantic serializer warnings:\n  Expected `date` but got `bytes` - serialized value may not be as expected'
+        "Pydantic serializer warnings:\n  Expected `date` but got `bytes` with value `b'bang'` - serialized value may not be as expected"
     ]
 
 
@@ -172,7 +172,7 @@ def test_any_with_timedelta_serializer():
         assert s.to_python(b'bang', mode='json') == 'bang'
 
     assert [w.message.args[0] for w in warning_info.list] == [
-        'Pydantic serializer warnings:\n  Expected `timedelta` but got `bytes` - '
+        "Pydantic serializer warnings:\n  Expected `timedelta` but got `bytes` with value `b'bang'` - "
         'serialized value may not be as expected'
     ]
 

tests/serializers/test_bytes.py

@@ -46,13 +46,21 @@ def test_bytes_dict_key():
 
 def test_bytes_fallback():
     s = SchemaSerializer(core_schema.bytes_schema())
-    with pytest.warns(UserWarning, match='Expected `bytes` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `bytes` but got `int` with value `123` - serialized value may not be as expected'
+    ):
         assert s.to_python(123) == 123
-    with pytest.warns(UserWarning, match='Expected `bytes` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `bytes` but got `int` with value `123` - serialized value may not be as expected'
+    ):
         assert s.to_python(123, mode='json') == 123
-    with pytest.warns(UserWarning, match='Expected `bytes` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `bytes` but got `int` with value `123` - serialized value may not be as expected'
+    ):
         assert s.to_json(123) == b'123'
-    with pytest.warns(UserWarning, match='Expected `bytes` but got `str` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match="Expected `bytes` but got `str` with value `'foo'` - serialized value may not be as expected"
+    ):
         assert s.to_json('foo') == b'"foo"'
 
 

tests/serializers/test_datetime.py

@@ -12,10 +12,16 @@ def test_datetime():
     assert v.to_python(datetime(2022, 12, 2, 12, 13, 14), mode='json') == '2022-12-02T12:13:14'
     assert v.to_json(datetime(2022, 12, 2, 12, 13, 14)) == b'"2022-12-02T12:13:14"'
 
-    with pytest.warns(UserWarning, match='Expected `datetime` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning,
+        match='Expected `datetime` but got `int` with value `123` - serialized value may not be as expected',
+    ):
         assert v.to_python(123, mode='json') == 123
 
-    with pytest.warns(UserWarning, match='Expected `datetime` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning,
+        match='Expected `datetime` but got `int` with value `123` - serialized value may not be as expected',
+    ):
         assert v.to_json(123) == b'123'
 
 

tests/serializers/test_decimal.py

@@ -20,10 +20,14 @@ def test_decimal():
         == b'"123456789123456789123456789.123456789123456789123456789"'
     )
 
-    with pytest.warns(UserWarning, match='Expected `decimal` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `decimal` but got `int` with value `123` - serialized value may not be as expected'
+    ):
         assert v.to_python(123, mode='json') == 123
 
-    with pytest.warns(UserWarning, match='Expected `decimal` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `decimal` but got `int` with value `123` - serialized value may not be as expected'
+    ):
         assert v.to_json(123) == b'123'
 
 

tests/serializers/test_enum.py

@@ -17,9 +17,13 @@ class MyEnum(Enum):
     assert v.to_python(MyEnum.a, mode='json') == 1
     assert v.to_json(MyEnum.a) == b'1'
 
-    with pytest.warns(UserWarning, match='Expected `enum` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `enum` but got `int` with value `1` - serialized value may not be as expected'
+    ):
         assert v.to_python(1) == 1
-    with pytest.warns(UserWarning, match='Expected `enum` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `enum` but got `int` with value `1` - serialized value may not be as expected'
+    ):
         assert v.to_json(1) == b'1'
 
 
@@ -35,9 +39,13 @@ class MyEnum(int, Enum):
     assert v.to_python(MyEnum.a, mode='json') == 1
     assert v.to_json(MyEnum.a) == b'1'
 
-    with pytest.warns(UserWarning, match='Expected `enum` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `enum` but got `int` with value `1` - serialized value may not be as expected'
+    ):
         assert v.to_python(1) == 1
-    with pytest.warns(UserWarning, match='Expected `enum` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `enum` but got `int` with value `1` - serialized value may not be as expected'
+    ):
         assert v.to_json(1) == b'1'
 
 
@@ -53,9 +61,13 @@ class MyEnum(str, Enum):
     assert v.to_python(MyEnum.a, mode='json') == 'a'
     assert v.to_json(MyEnum.a) == b'"a"'
 
-    with pytest.warns(UserWarning, match='Expected `enum` but got `str` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match="Expected `enum` but got `str` with value `'a'` - serialized value may not be as expected"
+    ):
         assert v.to_python('a') == 'a'
-    with pytest.warns(UserWarning, match='Expected `enum` but got `str` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match="Expected `enum` but got `str` with value `'a'` - serialized value may not be as expected"
+    ):
         assert v.to_json('a') == b'"a"'
 
 
@@ -76,9 +88,13 @@ class MyEnum(Enum):
     assert v.to_python({MyEnum.a: 'x'}, mode='json') == {'1': 'x'}
     assert v.to_json({MyEnum.a: 'x'}) == b'{"1":"x"}'
 
-    with pytest.warns(UserWarning, match='Expected `enum` but got `str` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match="Expected `enum` but got `str` with value `'x'` - serialized value may not be as expected"
+    ):
         assert v.to_python({'x': 'x'}) == {'x': 'x'}
-    with pytest.warns(UserWarning, match='Expected `enum` but got `str` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match="Expected `enum` but got `str` with value `'x'` - serialized value may not be as expected"
+    ):
         assert v.to_json({'x': 'x'}) == b'{"x":"x"}'
 
 
@@ -99,7 +115,11 @@ class MyEnum(int, Enum):
     assert v.to_python({MyEnum.a: 'x'}, mode='json') == {'1': 'x'}
     assert v.to_json({MyEnum.a: 'x'}) == b'{"1":"x"}'
 
-    with pytest.warns(UserWarning, match='Expected `enum` but got `str` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match="Expected `enum` but got `str` with value `'x'` - serialized value may not be as expected"
+    ):
         assert v.to_python({'x': 'x'}) == {'x': 'x'}
-    with pytest.warns(UserWarning, match='Expected `enum` but got `str` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match="Expected `enum` but got `str` with value `'x'` - serialized value may not be as expected"
+    ):
         assert v.to_json({'x': 'x'}) == b'{"x":"x"}'

tests/serializers/test_functions.py

@@ -207,7 +207,7 @@ def append_42(value, _info):
     assert s.to_python([1, 2, 3], mode='json') == [1, 2, 3, 42]
     assert s.to_json([1, 2, 3]) == b'[1,2,3,42]'
 
-    msg = r'Expected `list\[int\]` but got `str` - serialized value may not be as expected'
+    msg = r"Expected `list\[int\]` but got `str` with value `'abc'` - serialized value may not be as expected"
     with pytest.warns(UserWarning, match=msg):
         assert s.to_python('abc') == 'abc'
 
@@ -322,11 +322,17 @@ def test_wrong_return_type():
             )
         )
     )
-    with pytest.warns(UserWarning, match='Expected `int` but got `str` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match="Expected `int` but got `str` with value `'123'` - serialized value may not be as expected"
+    ):
         assert s.to_python(123) == '123'
-    with pytest.warns(UserWarning, match='Expected `int` but got `str` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match="Expected `int` but got `str` with value `'123'` - serialized value may not be as expected"
+    ):
         assert s.to_python(123, mode='json') == '123'
-    with pytest.warns(UserWarning, match='Expected `int` but got `str` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match="Expected `int` but got `str` with value `'123'` - serialized value may not be as expected"
+    ):
         assert s.to_json(123) == b'"123"'
 
 
@@ -356,11 +362,17 @@ def f(value, serializer):
     assert s.to_python(3) == 'result=3'
     assert s.to_python(3, mode='json') == 'result=3'
     assert s.to_json(3) == b'"result=3"'
-    with pytest.warns(UserWarning, match='Expected `str` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `str` but got `int` with value `42` - serialized value may not be as expected'
+    ):
         assert s.to_python(42) == 42
-    with pytest.warns(UserWarning, match='Expected `str` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `str` but got `int` with value `42` - serialized value may not be as expected'
+    ):
         assert s.to_python(42, mode='json') == 42
-    with pytest.warns(UserWarning, match='Expected `str` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `str` but got `int` with value `42` - serialized value may not be as expected'
+    ):
         assert s.to_json(42) == b'42'
 
 
@@ -611,7 +623,9 @@ def f(value, _info):
         return value
 
     s = SchemaSerializer(core_schema.with_info_after_validator_function(f, core_schema.int_schema()))
-    with pytest.warns(UserWarning, match='Expected `int` but got `str` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match="Expected `int` but got `str` with value `'abc'` - serialized value may not be as expected"
+    ):
         assert s.to_python('abc') == 'abc'
 
 
@@ -620,7 +634,9 @@ def f(value, handler, _info):
         return handler(value)
 
     s = SchemaSerializer(core_schema.with_info_wrap_validator_function(f, core_schema.int_schema()))
-    with pytest.warns(UserWarning, match='Expected `int` but got `str` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match="Expected `int` but got `str` with value `'abc'` - serialized value may not be as expected"
+    ):
         assert s.to_python('abc') == 'abc'
 
 

tests/serializers/test_generator.py

@@ -54,12 +54,12 @@ def test_generator_any():
     assert s.to_json(iter(['a', b'b', 3])) == b'["a","b",3]'
     assert s.to_json(gen_ok('a', b'b', 3)) == b'["a","b",3]'
 
-    msg = 'Expected `generator` but got `int` - serialized value may not be as expected'
+    msg = 'Expected `generator` but got `int` with value `4` - serialized value may not be as expected'
     with pytest.warns(UserWarning, match=msg):
         assert s.to_python(4) == 4
-    with pytest.warns(UserWarning, match='Expected `generator` but got `tuple`'):
+    with pytest.warns(UserWarning, match="Expected `generator` but got `tuple` with value `\\('a', b'b', 3\\)`"):
         assert s.to_python(('a', b'b', 3)) == ('a', b'b', 3)
-    with pytest.warns(UserWarning, match='Expected `generator` but got `str`'):
+    with pytest.warns(UserWarning, match="Expected `generator` but got `str` with value `'abc'`"):
         assert s.to_python('abc') == 'abc'
 
     with pytest.raises(ValueError, match='oops'):
@@ -88,14 +88,21 @@ def test_generator_int():
     with pytest.raises(ValueError, match='oops'):
         s.to_json(gen_error(1, 2))
 
-    with pytest.warns(UserWarning, match='Expected `int` but got `str` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match="Expected `int` but got `str` with value `'a'` - serialized value may not be as expected"
+    ):
         s.to_json(gen_ok(1, 'a'))
 
     gen = s.to_python(gen_ok(1, 'a'))
     assert next(gen) == 1
-    with pytest.warns(UserWarning, match='Expected `int` but got `str` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match="Expected `int` but got `str` with value `'a'` - serialized value may not be as expected"
+    ):
         assert next(gen) == 'a'
-    with pytest.warns(UserWarning, match='Expected `generator` but got `tuple` - serialized value may not.+'):
+    with pytest.warns(
+        UserWarning,
+        match='Expected `generator` but got `tuple` with value `\\(1, 2, 3\\)` - serialized value may not.+',
+    ):
         s.to_python((1, 2, 3))
 
 

tests/serializers/test_list_tuple.py

@@ -18,26 +18,26 @@ def test_list_any():
 
 def test_list_fallback():
     v = SchemaSerializer(core_schema.list_schema(core_schema.any_schema()))
-    msg = 'Expected `list[any]` but got `str` - serialized value may not be as expected'
+    msg = "Expected `list[any]` but got `str` with value `'apple'` - serialized value may not be as expected"
     with pytest.warns(UserWarning, match=re.escape(msg)):
         assert v.to_python('apple') == 'apple'
 
     with pytest.warns(UserWarning) as warning_info:
         assert v.to_json('apple') == b'"apple"'
     assert [w.message.args[0] for w in warning_info.list] == [
-        'Pydantic serializer warnings:\n  Expected `list[any]` but got `str` - serialized value may not be as expected'
+        "Pydantic serializer warnings:\n  Expected `list[any]` but got `str` with value `'apple'` - serialized value may not be as expected"
     ]
 
-    msg = 'Expected `list[any]` but got `bytes` - serialized value may not be as expected'
+    msg = "Expected `list[any]` but got `bytes` with value `b'apple'` - serialized value may not be as expected"
     with pytest.warns(UserWarning, match=re.escape(msg)):
         assert v.to_json(b'apple') == b'"apple"'
 
-    msg = 'Expected `list[any]` but got `tuple` - serialized value may not be as expected'
+    msg = 'Expected `list[any]` but got `tuple` with value `(1, 2, 3)` - serialized value may not be as expected'
     with pytest.warns(UserWarning, match=re.escape(msg)):
         assert v.to_python((1, 2, 3)) == (1, 2, 3)
 
     # # even though we're in the fallback state, non JSON types should still be converted to JSON here
-    msg = 'Expected `list[any]` but got `tuple` - serialized value may not be as expected'
+    msg = 'Expected `list[any]` but got `tuple` with value `(1, 2, 3)` - serialized value may not be as expected'
     with pytest.warns(UserWarning, match=re.escape(msg)):
         assert v.to_python((1, 2, 3), mode='json') == [1, 2, 3]
 
@@ -48,18 +48,18 @@ def test_list_str_fallback():
         assert v.to_json([1, 2, 3]) == b'[1,2,3]'
     assert [w.message.args[0] for w in warning_info.list] == [
         'Pydantic serializer warnings:\n'
-        '  Expected `str` but got `int` - serialized value may not be as expected\n'
-        '  Expected `str` but got `int` - serialized value may not be as expected\n'
-        '  Expected `str` but got `int` - serialized value may not be as expected'
+        '  Expected `str` but got `int` with value `1` - serialized value may not be as expected\n'
+        '  Expected `str` but got `int` with value `2` - serialized value may not be as expected\n'
+        '  Expected `str` but got `int` with value `3` - serialized value may not be as expected'
     ]
     with pytest.raises(PydanticSerializationError) as warning_ex:
         v.to_json([1, 2, 3], warnings='error')
     assert str(warning_ex.value) == ''.join(
         [
             'Pydantic serializer warnings:\n'
-            '  Expected `str` but got `int` - serialized value may not be as expected\n'
-            '  Expected `str` but got `int` - serialized value may not be as expected\n'
-            '  Expected `str` but got `int` - serialized value may not be as expected'
+            '  Expected `str` but got `int` with value `1` - serialized value may not be as expected\n'
+            '  Expected `str` but got `int` with value `2` - serialized value may not be as expected\n'
+            '  Expected `str` but got `int` with value `3` - serialized value may not be as expected'
         ]
     )
 
@@ -243,25 +243,25 @@ def test_include_error_call_time(schema_func, seq_f, include, exclude):
 
 def test_tuple_fallback():
     v = SchemaSerializer(core_schema.tuple_variable_schema(core_schema.any_schema()))
-    msg = 'Expected `tuple[any, ...]` but got `str` - serialized value may not be as expected'
+    msg = "Expected `tuple[any, ...]` but got `str` with value `'apple'` - serialized value may not be as expected"
     with pytest.warns(UserWarning, match=re.escape(msg)):
         assert v.to_python('apple') == 'apple'
 
     with pytest.warns(UserWarning) as warning_info:
         assert v.to_json([1, 2, 3]) == b'[1,2,3]'
     assert [w.message.args[0] for w in warning_info.list] == [
-        'Pydantic serializer warnings:\n  Expected `tuple[any, ...]` but got `list` - '
+        'Pydantic serializer warnings:\n  Expected `tuple[any, ...]` but got `list` with value `[1, 2, 3]` - '
         'serialized value may not be as expected'
     ]
 
-    msg = 'Expected `tuple[any, ...]` but got `bytes` - serialized value may not be as expected'
+    msg = "Expected `tuple[any, ...]` but got `bytes` with value `b'apple'` - serialized value may not be as expected"
     with pytest.warns(UserWarning, match=re.escape(msg)):
         assert v.to_json(b'apple') == b'"apple"'
 
     assert v.to_python((1, 2, 3)) == (1, 2, 3)
 
     # even though we're in the fallback state, non JSON types should still be converted to JSON here
-    msg = 'Expected `tuple[any, ...]` but got `list` - serialized value may not be as expected'
+    msg = 'Expected `tuple[any, ...]` but got `list` with value `[1, 2, 3]` - serialized value may not be as expected'
     with pytest.warns(UserWarning, match=re.escape(msg)):
         assert v.to_python([1, 2, 3], mode='json') == [1, 2, 3]
 

tests/serializers/test_model.py

@@ -230,14 +230,17 @@ def test_model_wrong_warn():
     assert s.to_python(None, mode='json') is None
     assert s.to_json(None) == b'null'
 
-    with pytest.warns(UserWarning, match='Expected `MyModel` but got `int` - serialized value may.+'):
+    with pytest.warns(UserWarning, match='Expected `MyModel` but got `int` with value `123` - serialized value may.+'):
         assert s.to_python(123) == 123
-    with pytest.warns(UserWarning, match='Expected `MyModel` but got `int` - serialized value may.+'):
+    with pytest.warns(UserWarning, match='Expected `MyModel` but got `int` with value `123` - serialized value may.+'):
         assert s.to_python(123, mode='json') == 123
-    with pytest.warns(UserWarning, match='Expected `MyModel` but got `int` - serialized value may.+'):
+    with pytest.warns(UserWarning, match='Expected `MyModel` but got `int` with value `123` - serialized value may.+'):
         assert s.to_json(123) == b'123'
 
-    with pytest.warns(UserWarning, match='Expected `MyModel` but got `dict` - serialized value may.+'):
+    with pytest.warns(
+        UserWarning,
+        match="Expected `MyModel` but got `dict` with value `{'foo': 1, 'bar': b'more'}` - serialized value may.+",
+    ):
         assert s.to_python({'foo': 1, 'bar': b'more'}) == {'foo': 1, 'bar': b'more'}