Add unknown ranges and open object values

crates/decodal-derive/tests/derive.rs

@@ -1,4 +1,6 @@
-use decodal::{Data, DecodalDecode, DecodalSchema, EmptyLoader, Engine};
+use std::collections::BTreeMap;
+
+use decodal::{Constraint, Data, DecodalDecode, DecodalSchema, EmptyLoader, Engine, Value};
 use decodal_derive::Decodal;
 
 #[derive(Debug, PartialEq, Decodal)]
@@ -24,6 +26,28 @@ struct Fleet {
     workers: Vec<Worker>,
 }
 
+#[derive(Debug, PartialEq, Decodal)]
+struct OpenConfig {
+    name: String,
+    #[decodal(default = true, rename = "feature.enabled")]
+    enabled: bool,
+    #[decodal(rest)]
+    extra: BTreeMap<String, Data>,
+}
+
+#[derive(Debug, PartialEq, Decodal)]
+struct StringLabels {
+    name: String,
+    #[decodal(rest)]
+    labels: BTreeMap<String, String>,
+}
+
+#[derive(Debug, PartialEq, Decodal)]
+struct OpenBag {
+    #[decodal(rest)]
+    values: BTreeMap<String, Data>,
+}
+
 #[test]
 fn derives_schema_and_decode() {
     let mut engine = Engine::new(EmptyLoader);
@@ -148,3 +172,97 @@ fn vec_schema_applies_nested_struct_defaults() {
         }
     );
 }
+
+#[test]
+fn rest_map_opens_the_derived_object_and_collects_additional_fields() {
+    let schema = OpenConfig::decodal_schema();
+    let Value::Object {
+        fields,
+        rest: Some(rest),
+    } = schema
+    else {
+        panic!("derived schema should have an object rest range")
+    };
+    assert_eq!(fields.len(), 2);
+    assert!(matches!(
+        *rest,
+        Value::Range { ref constraints, .. }
+            if constraints == &[Constraint::Unknown]
+    ));
+
+    let mut engine = Engine::new(EmptyLoader);
+    engine
+        .bind_global("OpenConfig", OpenConfig::decodal_schema())
+        .unwrap();
+    let module = engine
+        .add_root_source(
+            "test",
+            "test",
+            r#"
+            {
+              name = "api";
+              plugin = { name = "cache"; };
+              retries = 3;
+            } as OpenConfig
+            "#,
+        )
+        .unwrap();
+    let value = engine.eval_module(module).unwrap();
+    let data = engine.materialize(&value).unwrap();
+    let config = OpenConfig::decodal_decode(&data).unwrap();
+
+    assert_eq!(config.name, "api");
+    assert!(config.enabled);
+    assert_eq!(config.extra.get("retries"), Some(&Data::Int(3)));
+    assert!(matches!(config.extra.get("plugin"), Some(Data::Object(_))));
+    assert!(!config.extra.contains_key("name"));
+    assert!(!config.extra.contains_key("feature"));
+}
+
+#[test]
+fn typed_rest_map_constrains_each_additional_field() {
+    let mut engine = Engine::new(EmptyLoader);
+    engine
+        .bind_global("StringLabels", StringLabels::decodal_schema())
+        .unwrap();
+    let module = engine
+        .add_root_source(
+            "test",
+            "test",
+            r#"{ name = "service"; region = "ap-northeast-1"; tier = "edge"; } as StringLabels"#,
+        )
+        .unwrap();
+    let value = engine.eval_module(module).unwrap();
+    let data = engine.materialize(&value).unwrap();
+    let labels = StringLabels::decodal_decode(&data).unwrap();
+    assert_eq!(labels.labels.get("region"), Some(&"ap-northeast-1".into()));
+    assert_eq!(labels.labels.get("tier"), Some(&"edge".into()));
+
+    let module = engine
+        .add_root_source(
+            "invalid",
+            "invalid",
+            r#"{ name = "service"; priority = 1; } as StringLabels"#,
+        )
+        .unwrap();
+    assert!(engine.eval_module(module).is_err());
+}
+
+#[test]
+fn rest_only_struct_collects_every_field() {
+    let schema = OpenBag::decodal_schema();
+    assert!(matches!(
+        schema,
+        Value::Object {
+            ref fields,
+            rest: Some(_),
+        } if fields.is_empty()
+    ));
+
+    let data = Data::Object(vec![decodal::runtime::DataField {
+        name: "answer".into(),
+        value: Data::Int(42),
+    }]);
+    let bag = OpenBag::decodal_decode(&data).unwrap();
+    assert_eq!(bag.values.get("answer"), Some(&Data::Int(42)));
+}