feat!: remove strict length check on tuple deserialization

src/ipld.rs

@@ -149,13 +149,13 @@ pub enum IpldIndex<'a> {
     MapRef(&'a str),
 }
 
-impl<'a> From<usize> for IpldIndex<'a> {
+impl From<usize> for IpldIndex<'_> {
     fn from(index: usize) -> Self {
         Self::List(index)
     }
 }
 
-impl<'a> From<String> for IpldIndex<'a> {
+impl From<String> for IpldIndex<'_> {
     fn from(key: String) -> Self {
         Self::Map(key)
     }

src/serde/de.rs

@@ -1,5 +1,6 @@
 use alloc::{borrow::ToOwned, collections::BTreeMap, format, string::String, vec::Vec};
 use core::{convert::TryFrom, fmt};
+use serde::de::Error;
 
 use cid::serde::{BytesToCidVisitor, CID_SERDE_PRIVATE_IDENTIFIER};
 use cid::Cid;
@@ -413,17 +414,11 @@ impl<'de> de::Deserializer<'de> for Ipld {
 
     fn deserialize_tuple<V: de::Visitor<'de>>(
         self,
-        len: usize,
+        _len: usize,
         visitor: V,
     ) -> Result<V::Value, Self::Error> {
         match self {
-            Self::List(list) => {
-                if len == list.len() {
-                    visit_seq(list, visitor)
-                } else {
-                    error(format!("The tuple size must match the length of the `Ipld::List`, tuple size: {}, `Ipld::List` length: {}", len, list.len()))
-                }
-            }
+            Self::List(list) => visit_seq(list, visitor),
             _ => error(format!(
                 "Only `Ipld::List` can be deserialized to tuple, input was `{:#?}`",
                 self
@@ -568,15 +563,27 @@ where
     V: de::Visitor<'de>,
 {
     let mut deserializer = MapDeserializer::new(map);
-    visitor.visit_map(&mut deserializer)
+    let res = visitor.visit_map(&mut deserializer)?;
+    match deserializer.remaining() {
+        0 => Ok(res),
+        remaining => Err(SerdeError::custom(format!(
+            "The type failed to consume the entire map: {remaining} items remaining"
+        ))),
+    }
 }
 
 fn visit_seq<'de, V>(list: Vec<Ipld>, visitor: V) -> Result<V::Value, SerdeError>
 where
     V: de::Visitor<'de>,
 {
     let mut deserializer = SeqDeserializer::new(list);
-    visitor.visit_seq(&mut deserializer)
+    let res = visitor.visit_seq(&mut deserializer)?;
+    match deserializer.remaining() {
+        0 => Ok(res),
+        remaining => Err(SerdeError::custom(format!(
+            "The type failed to consume the entire sequence: {remaining} items remaining"
+        ))),
+    }
 }
 
 // Heavily based on
@@ -593,6 +600,9 @@ impl MapDeserializer {
             value: None,
         }
     }
+    fn remaining(self) -> usize {
+        self.iter.count()
+    }
 }
 
 impl<'de> de::MapAccess<'de> for MapDeserializer {
@@ -641,6 +651,9 @@ impl SeqDeserializer {
             iter: vec.into_iter(),
         }
     }
+    fn remaining(self) -> usize {
+        self.iter.count()
+    }
 }
 
 impl<'de> de::SeqAccess<'de> for SeqDeserializer {

tests/serde_deserializer.rs

@@ -5,7 +5,7 @@ extern crate alloc;
 use alloc::collections::BTreeMap;
 use core::convert::TryFrom;
 
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use serde_bytes::ByteBuf;
 use serde_json::json;
 
@@ -367,7 +367,11 @@ fn ipld_deserializer_tuple() {
 
 #[test]
 fn ipld_deserializer_tuple_errors() {
-    let tuple = (true, "hello".to_string());
+    #[derive(Clone, Debug, Deserialize, Serialize, PartialEq)]
+    #[serde(deny_unknown_fields)]
+    struct Tuple(bool, String);
+
+    let tuple = Tuple(true, "hello".to_string());
 
     let ipld_not_enough = Ipld::List(vec![Ipld::Bool(tuple.0)]);
     error_except(tuple.clone(), &ipld_not_enough);
@@ -405,6 +409,7 @@ fn ipld_deserializer_tuple_struct() {
 #[test]
 fn ipld_deserializer_tuple_struct_errors() {
     #[derive(Clone, Debug, Deserialize, PartialEq)]
+    #[serde(deny_unknown_fields)]
     struct TupleStruct(u8, bool);
 
     let tuple_struct = TupleStruct(82, true);
@@ -644,11 +649,23 @@ fn ipld_deserializer_struct() {
 
     let deserialized = MyStruct::deserialize(ipld).unwrap();
     assert_eq!(deserialized, my_struct);
+
+    // Unknown fields are ignored by default.
+    let ipld = Ipld::Map(BTreeMap::from([
+        ("hello".into(), Ipld::Integer(my_struct.hello.into())),
+        ("world".into(), Ipld::Bool(my_struct.world)),
+        ("ignored".into(), Ipld::Bool(true)),
+    ]));
+    error_except(my_struct.clone(), &ipld);
+
+    let deserialized = MyStruct::deserialize(ipld).unwrap();
+    assert_eq!(deserialized, my_struct);
 }
 
 #[test]
 fn ipld_deserializer_struct_errors() {
     #[derive(Clone, Debug, Deserialize, PartialEq)]
+    #[serde(deny_unknown_fields)]
     struct MyStruct {
         hello: u8,
         world: bool,
@@ -671,7 +688,18 @@ fn ipld_deserializer_struct_errors() {
         "wrong".into(),
         Ipld::Integer(my_struct.hello.into()),
     )]));
+    error_except(my_struct.clone(), &ipld_wrong);
+    let error_wrong = MyStruct::deserialize(ipld_wrong);
+    assert!(error_wrong.is_err());
+
+    // Unknown fields are rejected.
+    let ipld_wrong = Ipld::Map(BTreeMap::from([
+        ("hello".into(), Ipld::Integer(my_struct.hello.into())),
+        ("world".into(), Ipld::Bool(my_struct.world)),
+        ("ignored".into(), Ipld::Bool(true)),
+    ]));
     error_except(my_struct, &ipld_wrong);
+
     let error_wrong = MyStruct::deserialize(ipld_wrong);
     assert!(error_wrong.is_err());
 }