test(value-convert): add validate_full_roundtrip testing (#594)

* test(value-convert): add `validate_full_roundtrip` testing

* add more comments

Author: badmonster0

python/cocoindex/tests/test_convert.py

@@ -1,7 +1,7 @@
 import uuid
 import datetime
 from dataclasses import dataclass, make_dataclass
-from typing import NamedTuple, Literal
+from typing import NamedTuple, Literal, Any, Callable
 import pytest
 import cocoindex
 from cocoindex.typing import encode_enriched_type
@@ -53,7 +53,9 @@ class CustomerNamedTuple(NamedTuple):
     tags: list[Tag] | None = None
 
 
-def build_engine_value_decoder(engine_type_in_py, python_type=None):
+def build_engine_value_decoder(
+    engine_type_in_py: Any, python_type: Any | None = None
+) -> Callable[[Any], Any]:
     """
     Helper to build a converter for the given engine-side type (as represented in Python).
     If python_type is not specified, uses engine_type_in_py as the target.
@@ -62,6 +64,27 @@ def build_engine_value_decoder(engine_type_in_py, python_type=None):
     return make_engine_value_decoder([], engine_type, python_type or engine_type_in_py)
 
 
+def validate_full_roundtrip(
+    value: Any, output_type: Any, input_type: Any | None = None
+) -> None:
+    """
+    Validate the given value doesn't change after encoding, sending to engine (using output_type), receiving back and decoding (using input_type).
+
+    If `input_type` is not specified, uses `output_type` as the target.
+    """
+    from cocoindex import _engine
+
+    encoded_value = encode_engine_value(value)
+    encoded_output_type = encode_enriched_type(output_type)["type"]
+    value_from_engine = _engine.testutil.seder_roundtrip(
+        encoded_value, encoded_output_type
+    )
+    decoded_value = build_engine_value_decoder(input_type or output_type, output_type)(
+        value_from_engine
+    )
+    assert decoded_value == value
+
+
 def test_encode_engine_value_basic_types():
     assert encode_engine_value(123) == 123
     assert encode_engine_value(3.14) == 3.14
@@ -434,57 +457,33 @@ def test_field_position_cases(
     assert decoder(engine_val) == PythonOrder(**expected_dict)
 
 
-def test_roundtrip_ltable():
+def test_roundtrip_ltable() -> None:
     t = list[Order]
     value = [Order("O1", "item1", 10.0), Order("O2", "item2", 20.0)]
-    encoded = encode_engine_value(value)
-    assert encoded == [
-        ["O1", "item1", 10.0, "default_extra"],
-        ["O2", "item2", 20.0, "default_extra"],
-    ]
-    decoded = build_engine_value_decoder(t)(encoded)
-    assert decoded == value
+    validate_full_roundtrip(value, t)
 
     t_nt = list[OrderNamedTuple]
     value_nt = [
         OrderNamedTuple("O1", "item1", 10.0),
         OrderNamedTuple("O2", "item2", 20.0),
     ]
-    encoded = encode_engine_value(value_nt)
-    assert encoded == [
-        ["O1", "item1", 10.0, "default_extra"],
-        ["O2", "item2", 20.0, "default_extra"],
-    ]
-    decoded = build_engine_value_decoder(t_nt)(encoded)
-    assert decoded == value_nt
+    validate_full_roundtrip(value_nt, t_nt)
 
 
-def test_roundtrip_ktable_str_key():
+def test_roundtrip_ktable_str_key() -> None:
     t = dict[str, Order]
     value = {"K1": Order("O1", "item1", 10.0), "K2": Order("O2", "item2", 20.0)}
-    encoded = encode_engine_value(value)
-    assert encoded == [
-        ["K1", "O1", "item1", 10.0, "default_extra"],
-        ["K2", "O2", "item2", 20.0, "default_extra"],
-    ]
-    decoded = build_engine_value_decoder(t)(encoded)
-    assert decoded == value
+    validate_full_roundtrip(value, t)
 
     t_nt = dict[str, OrderNamedTuple]
     value_nt = {
         "K1": OrderNamedTuple("O1", "item1", 10.0),
         "K2": OrderNamedTuple("O2", "item2", 20.0),
     }
-    encoded = encode_engine_value(value_nt)
-    assert encoded == [
-        ["K1", "O1", "item1", 10.0, "default_extra"],
-        ["K2", "O2", "item2", 20.0, "default_extra"],
-    ]
-    decoded = build_engine_value_decoder(t_nt)(encoded)
-    assert decoded == value_nt
+    validate_full_roundtrip(value_nt, t_nt)
 
 
-def test_roundtrip_ktable_struct_key():
+def test_roundtrip_ktable_struct_key() -> None:
     @dataclass(frozen=True)
     class OrderKey:
         shop_id: str
@@ -495,26 +494,14 @@ class OrderKey:
         OrderKey("A", 3): Order("O1", "item1", 10.0),
         OrderKey("B", 4): Order("O2", "item2", 20.0),
     }
-    encoded = encode_engine_value(value)
-    assert encoded == [
-        [["A", 3], "O1", "item1", 10.0, "default_extra"],
-        [["B", 4], "O2", "item2", 20.0, "default_extra"],
-    ]
-    decoded = build_engine_value_decoder(t)(encoded)
-    assert decoded == value
+    validate_full_roundtrip(value, t)
 
     t_nt = dict[OrderKey, OrderNamedTuple]
     value_nt = {
         OrderKey("A", 3): OrderNamedTuple("O1", "item1", 10.0),
         OrderKey("B", 4): OrderNamedTuple("O2", "item2", 20.0),
     }
-    encoded = encode_engine_value(value_nt)
-    assert encoded == [
-        [["A", 3], "O1", "item1", 10.0, "default_extra"],
-        [["B", 4], "O2", "item2", 20.0, "default_extra"],
-    ]
-    decoded = build_engine_value_decoder(t_nt)(encoded)
-    assert decoded == value_nt
+    validate_full_roundtrip(value_nt, t_nt)
 
 
 IntVectorType = cocoindex.Vector[int, Literal[5]]

src/base/value.rs

@@ -1142,3 +1142,13 @@ impl<'a, I: Iterator<Item = &'a Value> + Clone> Serialize for TypedFieldsValue<'
         map.end()
     }
 }
+
+pub mod test_util {
+    use super::*;
+
+    pub fn seder_roundtrip(value: &Value, typ: &ValueType) -> Result<Value> {
+        let json_value = serde_json::to_value(value)?;
+        let roundtrip_value = Value::from_json(json_value, typ)?;
+        Ok(roundtrip_value)
+    }
+}

src/py/mod.rs

@@ -530,6 +530,18 @@ fn add_auth_entry(key: String, value: Pythonized<serde_json::Value>) -> PyResult
     Ok(())
 }
 
+#[pyfunction]
+fn seder_roundtrip<'py>(
+    py: Python<'py>,
+    value: Bound<'py, PyAny>,
+    typ: Pythonized<ValueType>,
+) -> PyResult<Bound<'py, PyAny>> {
+    let typ = typ.into_inner();
+    let value = value_from_py_object(&typ, &value)?;
+    let value = value::test_util::seder_roundtrip(&value, &typ).into_py_result()?;
+    Ok(value_to_py_object(py, &value)?)
+}
+
 /// A Python module implemented in Rust.
 #[pymodule]
 #[pyo3(name = "_engine")]
@@ -558,5 +570,9 @@ fn cocoindex_engine(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<RenderedSpec>()?;
     m.add_class::<RenderedSpecLine>()?;
 
+    let testutil_module = PyModule::new(m.py(), "testutil")?;
+    testutil_module.add_function(wrap_pyfunction!(seder_roundtrip, &testutil_module)?)?;
+    m.add_submodule(&testutil_module)?;
+
     Ok(())
 }