chore: add negative tests, refactor total seconds to encapsulate more common logic

Author: ollz272

src/serializers/config.rs

@@ -109,7 +109,8 @@ serialization_mode! {
 }
 
 impl TimedeltaMode {
-    fn total_seconds<'py>(py_timedelta: &Bound<'py, PyDelta>) -> PyResult<Bound<'py, PyAny>> {
+    fn total_seconds<'py>(py: Python, either_delta: &EitherTimedelta) -> PyResult<Bound<'py, PyAny>> {
+        let py_timedelta = either_delta.try_into_py(py)?;
         py_timedelta.call_method0(intern!(py_timedelta.py(), "total_seconds"))
     }
 
@@ -122,15 +123,13 @@ impl TimedeltaMode {
             Self::Float => {
                 // convert to int via a py timedelta not duration since we know this this case the input would have
                 // been a py timedelta
-                let py_timedelta = either_delta.try_into_py(py)?;
-                let seconds = Self::total_seconds(&py_timedelta)?;
+                let seconds = Self::total_seconds(py, either_delta)?;
                 Ok(seconds.into_py(py))
             }
             Self::Millisecond => {
                 // convert to int via a py timedelta not duration since we know this this case the input would have
                 // been a py timedelta
-                let py_timedelta = either_delta.try_into_py(py)?;
-                let seconds: f64 = Self::total_seconds(&py_timedelta)?.extract()?;
+                let seconds = Self::total_seconds(py, either_delta)?;
                 let object: Bound<PyFloat> = PyFloat::new_bound(py, seconds * 1000.0);
                 Ok(object.into_py(py))
             }
@@ -144,13 +143,11 @@ impl TimedeltaMode {
                 Ok(d.to_string().into())
             }
             Self::Float => {
-                let py_timedelta = either_delta.try_into_py(py)?;
-                let seconds: f64 = Self::total_seconds(&py_timedelta)?.extract()?;
+                let seconds = Self::total_seconds(py, either_delta)?.extract()?;
                 Ok(seconds.to_string().into())
             }
             Self::Millisecond => {
-                let py_timedelta = either_delta.try_into_py(py)?;
-                let seconds: f64 = Self::total_seconds(&py_timedelta)?.extract()?;
+                let seconds = Self::total_seconds(py, either_delta)?.extract()?;
                 let milliseconds: f64 = seconds * 1000.0;
                 Ok(milliseconds.to_string().into())
             }
@@ -169,15 +166,15 @@ impl TimedeltaMode {
                 serializer.serialize_str(&d.to_string())
             }
             Self::Float => {
-                let py_timedelta = either_delta.try_into_py(py).map_err(py_err_se_err)?;
-                let seconds = Self::total_seconds(&py_timedelta).map_err(py_err_se_err)?;
-                let seconds: f64 = seconds.extract().map_err(py_err_se_err)?;
+                let seconds = Self::total_seconds(py, either_delta)?
+                    .extract()?
+                    .map_err(py_err_se_err)?;
                 serializer.serialize_f64(seconds)
             }
             Self::Millisecond => {
-                let py_timedelta = either_delta.try_into_py(py).map_err(py_err_se_err)?;
-                let seconds = Self::total_seconds(&py_timedelta).map_err(py_err_se_err)?;
-                let seconds: f64 = seconds.extract().map_err(py_err_se_err)?;
+                let seconds = Self::total_seconds(py, either_delta)?
+                    .extract()?
+                    .map_err(py_err_se_err)?;
                 let milliseconds: f64 = seconds * 1000.0;
                 serializer.serialize_f64(milliseconds)
             }

tests/serializers/test_any.py

@@ -201,6 +201,18 @@ def test_any_config_timedelta_float_faction():
     assert s.to_json({one_half_s: 'foo'}) == b'{"1.5":"foo"}'
 
 
+def test_any_config_timedelta_float_negative():
+    s = SchemaSerializer(core_schema.any_schema(), config={'ser_json_timedelta': 'float'})
+    one_half_s = timedelta(seconds=-1.5)
+    assert s.to_python(one_half_s) == one_half_s
+    assert s.to_python(one_half_s, mode='json') == -1.5
+    assert s.to_json(one_half_s) == b'-1.5'
+
+    assert s.to_python({one_half_s: 'foo'}) == {one_half_s: 'foo'}
+    assert s.to_python({one_half_s: 'foo'}, mode='json') == {'-1.5': 'foo'}
+    assert s.to_json({one_half_s: 'foo'}) == b'{"-1.5":"foo"}'
+
+
 def test_any_config_timedelta_millisecond():
     s = SchemaSerializer(core_schema.any_schema(), config={'ser_json_timedelta': 'millisecond'})
     h2 = timedelta(hours=2)
@@ -225,6 +237,18 @@ def test_any_config_timedelta_millisecond_fraction():
     assert s.to_json({h2: 'foo'}) == b'{"1500":"foo"}'
 
 
+def test_any_config_timedelta_millisecond_negative():
+    s = SchemaSerializer(core_schema.any_schema(), config={'ser_json_timedelta': 'millisecond'})
+    h2 = timedelta(seconds=-1.5)
+    assert s.to_python(h2) == h2
+    assert s.to_python(h2, mode='json') == -1500.0
+    assert s.to_json(h2) == b'-1500.0'
+
+    assert s.to_python({h2: 'foo'}) == {h2: 'foo'}
+    assert s.to_python({h2: 'foo'}, mode='json') == {'-1500': 'foo'}
+    assert s.to_json({h2: 'foo'}) == b'{"-1500":"foo"}'
+
+
 def test_recursion(any_serializer):
     v = [1, 2]
     v.append(v)