fix tests and message formatting

Author: sydney-runkle

src/serializers/errors.rs

@@ -148,27 +148,33 @@ impl PydanticSerializationUnexpectedValue {
     }
 
     pub(crate) fn __str__(&self, py: Python) -> String {
-        let mut message = self.message.as_deref().unwrap_or("Unexpected Value").to_string();
+        let mut message = self.message.as_deref().unwrap_or("").to_string();
 
         if let Some(field_type) = &self.field_type {
+            if !message.is_empty() {
+                message.push_str(": ");
+            }
             message.push_str(&format!("Expected `{field_type}`"));
+            if self.input_value.is_some() {
+                message.push_str(" - serialized value may not be as expected");
+            }
         }
 
         if let Some(input_value) = &self.input_value {
             let bound_input = input_value.bind(py);
-            let type_name = bound_input
+            let input_type = bound_input
                 .get_type()
                 .name()
                 .unwrap_or_else(|_| PyString::new(py, "<unknown python object>"))
                 .to_string();
 
             let value_str = truncate_safe_repr(bound_input, None);
 
-            message.push_str(&format!(" but got `{type_name}` with value `{value_str}`"));
+            message.push_str(&format!(" [input_value={value_str}, input_type={input_type}]"));
         }
 
-        if self.input_value.is_some() || self.field_type.is_some() {
-            message.push_str(" - serialized value may not be as expected.");
+        if message.is_empty() {
+            message = "Unexpected Value".to_string();
         }
 
         message

src/serializers/fields.rs

@@ -219,7 +219,7 @@ impl GeneralFieldsSerializer {
             let required_fields = self.required_fields;
 
             Err(PydanticSerializationUnexpectedValue::new(
-                Some(format!("Expected {required_fields} fields but got {used_req_fields}. ").to_string()),
+                Some(format!("Expected {required_fields} fields but got {used_req_fields}").to_string()),
                 extra.model_type_name().map(|bound| bound.to_string()),
                 extra.model.map(|bound| bound.clone().unbind()),
             )

tests/serializers/test_any.py

@@ -164,7 +164,7 @@ def test_any_with_date_serializer():
         assert s.to_python(b'bang', mode='json') == 'bang'
 
     assert (
-        "Expected `date` but got `bytes` with value `b'bang'` - serialized value may not be as expected"
+        "Expected `date` - serialized value may not be as expected [input_value=b'bang', input_type=bytes]"
         in warning_info.list[0].message.args[0]
     )
 
@@ -179,7 +179,7 @@ def test_any_with_timedelta_serializer():
         assert s.to_python(b'bang', mode='json') == 'bang'
 
     assert (
-        "Expected `timedelta` but got `bytes` with value `b'bang'` - serialized value may not be as expected"
+        "Expected `timedelta` - serialized value may not be as expected [input_value=b'bang', input_type=bytes]"
         in warning_info.list[0].message.args[0]
     )
 

tests/serializers/test_bytes.py

@@ -47,19 +47,23 @@ 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` with value `123` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `bytes` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert s.to_python(123) == 123
     with pytest.warns(
-        UserWarning, match='Expected `bytes` but got `int` with value `123` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `bytes` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert s.to_python(123, mode='json') == 123
     with pytest.warns(
-        UserWarning, match='Expected `bytes` but got `int` with value `123` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `bytes` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert s.to_json(123) == b'123'
     with pytest.warns(
-        UserWarning, match="Expected `bytes` but got `str` with value `'foo'` - serialized value may not be as expected"
+        UserWarning,
+        match=r"Expected `bytes` - serialized value may not be as expected \[input_value='foo', input_type=str\]",
     ):
         assert s.to_json('foo') == b'"foo"'
 

tests/serializers/test_datetime.py

@@ -14,13 +14,13 @@ def test_datetime():
 
     with pytest.warns(
         UserWarning,
-        match='Expected `datetime` but got `int` with value `123` - serialized value may not be as expected',
+        match=r'Expected `datetime` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert v.to_python(123, mode='json') == 123
 
     with pytest.warns(
         UserWarning,
-        match='Expected `datetime` but got `int` with value `123` - serialized value may not be as expected',
+        match=r'Expected `datetime` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert v.to_json(123) == b'123'
 

tests/serializers/test_decimal.py

@@ -21,12 +21,14 @@ def test_decimal():
     )
 
     with pytest.warns(
-        UserWarning, match='Expected `decimal` but got `int` with value `123` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `decimal` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert v.to_python(123, mode='json') == 123
 
     with pytest.warns(
-        UserWarning, match='Expected `decimal` but got `int` with value `123` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `decimal` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert v.to_json(123) == b'123'
 

tests/serializers/test_enum.py

@@ -18,11 +18,13 @@ class MyEnum(Enum):
     assert v.to_json(MyEnum.a) == b'1'
 
     with pytest.warns(
-        UserWarning, match='Expected `enum` but got `int` with value `1` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `enum` - serialized value may not be as expected \[input_value=1, input_type=int\]',
     ):
         assert v.to_python(1) == 1
     with pytest.warns(
-        UserWarning, match='Expected `enum` but got `int` with value `1` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `enum` - serialized value may not be as expected \[input_value=1, input_type=int\]',
     ):
         assert v.to_json(1) == b'1'
 
@@ -40,11 +42,13 @@ class MyEnum(int, Enum):
     assert v.to_json(MyEnum.a) == b'1'
 
     with pytest.warns(
-        UserWarning, match='Expected `enum` but got `int` with value `1` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `enum` - serialized value may not be as expected \[input_value=1, input_type=int\]',
     ):
         assert v.to_python(1) == 1
     with pytest.warns(
-        UserWarning, match='Expected `enum` but got `int` with value `1` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `enum` - serialized value may not be as expected \[input_value=1, input_type=int\]',
     ):
         assert v.to_json(1) == b'1'
 
@@ -62,11 +66,13 @@ class MyEnum(str, Enum):
     assert v.to_json(MyEnum.a) == b'"a"'
 
     with pytest.warns(
-        UserWarning, match="Expected `enum` but got `str` with value `'a'` - serialized value may not be as expected"
+        UserWarning,
+        match=r"Expected `enum` - serialized value may not be as expected \[input_value='a', input_type=str\]",
     ):
         assert v.to_python('a') == 'a'
     with pytest.warns(
-        UserWarning, match="Expected `enum` but got `str` with value `'a'` - serialized value may not be as expected"
+        UserWarning,
+        match=r"Expected `enum` - serialized value may not be as expected \[input_value='a', input_type=str\]",
     ):
         assert v.to_json('a') == b'"a"'
 
@@ -89,11 +95,13 @@ class MyEnum(Enum):
     assert v.to_json({MyEnum.a: 'x'}) == b'{"1":"x"}'
 
     with pytest.warns(
-        UserWarning, match="Expected `enum` but got `str` with value `'x'` - serialized value may not be as expected"
+        UserWarning,
+        match=r"Expected `enum` - serialized value may not be as expected \[input_value='x', input_type=str\]",
     ):
         assert v.to_python({'x': 'x'}) == {'x': 'x'}
     with pytest.warns(
-        UserWarning, match="Expected `enum` but got `str` with value `'x'` - serialized value may not be as expected"
+        UserWarning,
+        match=r"Expected `enum` - serialized value may not be as expected \[input_value='x', input_type=str\]",
     ):
         assert v.to_json({'x': 'x'}) == b'{"x":"x"}'
 
@@ -116,10 +124,12 @@ class MyEnum(int, Enum):
     assert v.to_json({MyEnum.a: 'x'}) == b'{"1":"x"}'
 
     with pytest.warns(
-        UserWarning, match="Expected `enum` but got `str` with value `'x'` - serialized value may not be as expected"
+        UserWarning,
+        match=r"Expected `enum` - serialized value may not be as expected \[input_value='x', input_type=str\]",
     ):
         assert v.to_python({'x': 'x'}) == {'x': 'x'}
     with pytest.warns(
-        UserWarning, match="Expected `enum` but got `str` with value `'x'` - serialized value may not be as expected"
+        UserWarning,
+        match=r"Expected `enum` - serialized value may not be as expected \[input_value='x', input_type=str\]",
     ):
         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` with value `'abc'` - serialized value may not be as expected"
+    msg = r"Expected `list\[int\]` - serialized value may not be as expected \[input_value='abc', input_type=str\]"
     with pytest.warns(UserWarning, match=msg):
         assert s.to_python('abc') == 'abc'
 
@@ -323,15 +323,18 @@ def test_wrong_return_type():
         )
     )
     with pytest.warns(
-        UserWarning, match="Expected `int` but got `str` with value `'123'` - serialized value may not be as expected"
+        UserWarning,
+        match=r"Expected `int` - serialized value may not be as expected \[input_value='123', input_type=str\]",
     ):
         assert s.to_python(123) == '123'
     with pytest.warns(
-        UserWarning, match="Expected `int` but got `str` with value `'123'` - serialized value may not be as expected"
+        UserWarning,
+        match=r"Expected `int` - serialized value may not be as expected \[input_value='123', input_type=str\]",
     ):
         assert s.to_python(123, mode='json') == '123'
     with pytest.warns(
-        UserWarning, match="Expected `int` but got `str` with value `'123'` - serialized value may not be as expected"
+        UserWarning,
+        match=r"Expected `int` - serialized value may not be as expected \[input_value='123', input_type=str\]",
     ):
         assert s.to_json(123) == b'"123"'
 
@@ -363,15 +366,18 @@ def f(value, serializer):
     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` with value `42` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `str` - serialized value may not be as expected \[input_value=42, input_type=int\]',
     ):
         assert s.to_python(42) == 42
     with pytest.warns(
-        UserWarning, match='Expected `str` but got `int` with value `42` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `str` - serialized value may not be as expected \[input_value=42, input_type=int\]',
     ):
         assert s.to_python(42, mode='json') == 42
     with pytest.warns(
-        UserWarning, match='Expected `str` but got `int` with value `42` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `str` - serialized value may not be as expected \[input_value=42, input_type=int\]',
     ):
         assert s.to_json(42) == b'42'
 
@@ -624,7 +630,8 @@ def f(value, _info):
 
     s = SchemaSerializer(core_schema.with_info_after_validator_function(f, core_schema.int_schema()))
     with pytest.warns(
-        UserWarning, match="Expected `int` but got `str` with value `'abc'` - serialized value may not be as expected"
+        UserWarning,
+        match=r"Expected `int` - serialized value may not be as expected \[input_value='abc', input_type=str\]",
     ):
         assert s.to_python('abc') == 'abc'
 
@@ -635,7 +642,8 @@ def f(value, handler, _info):
 
     s = SchemaSerializer(core_schema.with_info_wrap_validator_function(f, core_schema.int_schema()))
     with pytest.warns(
-        UserWarning, match="Expected `int` but got `str` with value `'abc'` - serialized value may not be as expected"
+        UserWarning,
+        match=r"Expected `int` - serialized value may not be as expected \[input_value='abc', input_type=str\]",
     ):
         assert s.to_python('abc') == 'abc'
 

tests/serializers/test_generator.py

@@ -54,12 +54,20 @@ 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` with value `4` - serialized value may not be as expected'
-    with pytest.warns(UserWarning, match=msg):
+    with pytest.warns(
+        UserWarning,
+        match=r'Expected `generator` - serialized value may not be as expected \[input_value=4, input_type=int\]',
+    ):
         assert s.to_python(4) == 4
-    with pytest.warns(UserWarning, match="Expected `generator` but got `tuple` with value `\\('a', b'b', 3\\)`"):
+    with pytest.warns(
+        UserWarning,
+        match=r"Expected `generator` - serialized value may not be as expected \[input_value=\('a', b'b', 3\), input_type=tuple\]",
+    ):
         assert s.to_python(('a', b'b', 3)) == ('a', b'b', 3)
-    with pytest.warns(UserWarning, match="Expected `generator` but got `str` with value `'abc'`"):
+    with pytest.warns(
+        UserWarning,
+        match=r"Expected `generator` - serialized value may not be as expected \[input_value='abc', input_type=str\]",
+    ):
         assert s.to_python('abc') == 'abc'
 
     with pytest.raises(ValueError, match='oops'):
@@ -89,19 +97,21 @@ def test_generator_int():
         s.to_json(gen_error(1, 2))
 
     with pytest.warns(
-        UserWarning, match="Expected `int` but got `str` with value `'a'` - serialized value may not be as expected"
+        UserWarning,
+        match=r"Expected `int` - serialized value may not be as expected \[input_value='a', input_type=str\]",
     ):
         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` with value `'a'` - serialized value may not be as expected"
+        UserWarning,
+        match=r"Expected `int` - serialized value may not be as expected \[input_value='a', input_type=str\]",
     ):
         assert next(gen) == 'a'
     with pytest.warns(
         UserWarning,
-        match='Expected `generator` but got `tuple` with value `\\(1, 2, 3\\)` - serialized value may not.+',
+        match=r'Expected `generator` - serialized value may not be as expected \[input_value=\(1, 2, 3\), input_type=tuple\]',
     ):
         s.to_python((1, 2, 3))