Initial Dever 0.0.1

test/rust/runtime/json.rs

@@ -0,0 +1,482 @@
+use dever_runtime::wire::{document, json::Json};
+
+#[path = "json/encode.rs"]
+mod encode;
+#[path = "json/input.rs"]
+mod input;
+
+#[test]
+fn fixed_wire_keeps_syntax_and_byte_limits_without_a_second_parse() {
+    use dever_runtime::wire;
+    for source in [r#""\ud800""#, r#""\udc00""#, r#""x" null"#] {
+        assert!(wire::decode_fixed::<String>(source).is_err(), "{source}");
+    }
+    let source = format!("\"{}\"", "x".repeat(document::MAX_BYTES - 2));
+    assert_eq!(
+        wire::decode_fixed::<String>(&source).unwrap().len(),
+        document::MAX_BYTES - 2
+    );
+    assert!(wire::decode_fixed::<String>(&(source + " ")).is_err());
+    let overhead = wire::response_fixed(&"").unwrap().len();
+    let value = "x".repeat(document::MAX_BYTES - overhead);
+    assert_eq!(
+        wire::response_fixed(&value).unwrap().len(),
+        document::MAX_BYTES
+    );
+    assert_eq!(
+        wire::response_fixed_bytes(&value).unwrap().len(),
+        document::MAX_BYTES
+    );
+    let oversized = value + "x";
+    assert!(wire::response_fixed(&oversized).is_err());
+    assert!(wire::response_fixed_bytes(&oversized).is_err());
+    let value = "雪\"\\\n";
+    assert_eq!(wire::response_fixed(&value), wire::response(&value));
+    assert_eq!(
+        wire::response_fixed_bytes(&value).unwrap(),
+        wire::response(&value).unwrap().into_bytes()
+    );
+}
+
+#[test]
+fn parser_keeps_numbers_order_and_node_ids() {
+    let source = r#"{"b":1e+03,"a":[null,"雪",-0]}"#;
+    let document = document::parse(source).unwrap();
+    assert_eq!(document.root, 5);
+    assert_eq!(document::stringify(&document).unwrap(), source);
+    assert_eq!(document::property(&document, document.root, "b"), Some(0));
+    assert_eq!(document::element(&document, 4, 1), Some(2));
+    for source in ["{}", "[{},[]]", r#"{"":{}}"#] {
+        let parsed = document::parse(source).unwrap();
+        assert_eq!(document::stringify(&parsed).unwrap(), source);
+        assert_eq!(document::property(&parsed, parsed.root, "missing"), None);
+    }
+}
+
+#[test]
+fn parser_rejects_duplicates_surrogates_and_trailing_content() {
+    for source in [
+        r#"{"name":1,"name":2}"#,
+        r#""\ud800""#,
+        r#"[1,]"#,
+        "null false",
+        r#""\udc00""#,
+        r#""\ud800\u0061""#,
+        r#""\u00""#,
+        "\"雪\n\"",
+    ] {
+        assert!(document::parse(source).is_err(), "{source}");
+    }
+    let duplicate = r#"{"雪":0,"\u96ea":[}"#;
+    let error = document::parse(duplicate).unwrap_err();
+    assert_eq!(error.message, "duplicate JSON object key");
+    assert_eq!(
+        error.position,
+        duplicate[..duplicate.rfind(':').unwrap()].chars().count()
+    );
+    assert!(
+        Json::parse(duplicate)
+            .unwrap_err()
+            .to_string()
+            .contains("duplicate JSON object key")
+    );
+    assert_eq!(
+        document::parse(r#""\ud83d\ude42""#).unwrap().nodes,
+        vec![document::Value::String("🙂".into())]
+    );
+    for text in ["", "plain text", "雪🙂", "雪\"\\\n\0🙂", "\u{08}\u{0c}\r\t"] {
+        let source = serde_json::to_string(text).unwrap();
+        let parsed = document::parse(&source).unwrap();
+        assert_eq!(parsed.nodes, vec![document::Value::String(text.into())]);
+        assert_eq!(document::stringify(&parsed).unwrap(), source);
+        assert_eq!(Json::parse(&source).unwrap().as_text().unwrap(), text);
+    }
+}
+
+#[test]
+fn document_string_escaping_matches_serde_for_unicode_and_control_boundaries() {
+    let encode = |text: String| {
+        let expected = serde_json::to_string(&text).unwrap();
+        let value = document::Document {
+            root: 0,
+            nodes: vec![document::Value::String(text)],
+        };
+        assert_eq!(document::stringify(&value).unwrap(), expected);
+        assert_eq!(document::parse(&expected).unwrap().nodes, value.nodes);
+    };
+    encode(
+        (0..=u32::from(char::MAX))
+            .filter_map(char::from_u32)
+            .collect(),
+    );
+    encode(
+        (128..=u32::from(char::MAX))
+            .filter_map(char::from_u32)
+            .collect(),
+    );
+    for character in (0..32).map(char::from).chain(['"', '\\']) {
+        for text in [
+            format!("雪🙂{character}𐀀a{character}"),
+            format!("{character}{character}雪🙂"),
+        ] {
+            encode(text);
+        }
+    }
+    encode(String::new());
+}
+
+#[test]
+fn json_property_update_and_scalar_reads_preserve_wire_text() {
+    let value = Json::parse(r#"{"a":1,"b":[true]}"#).unwrap();
+    assert_eq!(value.property("a").unwrap().unwrap().as_integer(), Ok(1));
+    assert_eq!(value.property("missing").unwrap(), None);
+    let updated = value
+        .set_property("a", &Json::parse("1.000e2").unwrap())
+        .unwrap();
+    assert_eq!(updated.as_str(), r#"{"a":1.000e2,"b":[true]}"#);
+    assert_eq!(
+        Json::parse(r#""hello""#).unwrap().as_text(),
+        Ok("hello".into())
+    );
+}
+
+#[test]
+fn parser_enforces_depth_and_value_budgets() {
+    let nested = "[".repeat(document::MAX_DEPTH) + &"]".repeat(document::MAX_DEPTH);
+    assert!(document::parse(&nested).is_ok());
+    let too_deep = "[".repeat(document::MAX_DEPTH + 1) + &"]".repeat(document::MAX_DEPTH + 1);
+    assert!(document::parse(&too_deep).is_err());
+    let allowed = format!("[{}0]", "0,".repeat(document::MAX_VALUES - 2));
+    assert!(document::parse(&allowed).is_ok());
+    let many = format!("[{}0]", "0,".repeat(document::MAX_VALUES - 1));
+    assert!(document::parse(&many).is_err());
+}
+
+#[test]
+fn invalid_utf8_escape_reports_a_codepoint_position_without_panicking() {
+    for source in [r#""\雪""#, r#""\u0雪雪""#] {
+        assert!(document::parse(source).is_err());
+    }
+    assert_eq!(document::parse("[\"雪\",]").unwrap_err().position, 5);
+    for source in ["\"plain", "\"雪🙂", "{\"雪🙂"] {
+        let error = document::parse(source).unwrap_err();
+        assert_eq!(error.message, "unterminated JSON string");
+        assert_eq!(error.position, source.chars().count());
+    }
+}
+
+#[test]
+fn manual_documents_reject_forward_references() {
+    let document = document::Document {
+        root: 1,
+        nodes: vec![document::Value::Null, document::Value::Array(vec![1])],
+    };
+    assert!(document::stringify(&document).is_err());
+}
+
+#[test]
+fn manual_document_numbers_preserve_json_lexical_rules() {
+    let encode = |raw: &str| {
+        document::stringify(&document::Document {
+            root: 0,
+            nodes: vec![document::Value::Number(raw.into())],
+        })
+    };
+    for raw in [
+        "0",
+        "-0",
+        "1.00",
+        "-0.125E+03",
+        "1e9999",
+        "1234567890123456789012345678901234e-12",
+    ] {
+        assert_eq!(encode(raw).unwrap(), raw);
+    }
+    for raw in [
+        "",
+        "-",
+        "+1",
+        "01",
+        "-01",
+        "0x1",
+        "NaN",
+        "1.",
+        ".1",
+        "1e",
+        "1e+",
+        "1_0",
+        " 1",
+        "1 ",
+        "1\n",
+        "null",
+        "[]",
+        "1true",
+        "1雪",
+        "0],\"x\":true",
+    ] {
+        let error = encode(raw).unwrap_err();
+        assert_eq!(error.node, 0, "{raw}");
+        assert_eq!(error.message, "invalid JSON number", "{raw}");
+    }
+}
+
+#[test]
+fn scalar_and_array_encoding_reuses_the_same_budgeted_parser() {
+    assert_eq!(Json::boolean(true).unwrap().as_str(), "true");
+    assert_eq!(Json::integer(42).unwrap().as_str(), "42");
+    assert_eq!(Json::string("雪").unwrap().as_str(), "\"雪\"");
+    assert!(Json::float(f64::NAN).is_err());
+    let array = Json::array(&[Json::integer(1).unwrap(), Json::boolean(false).unwrap()]).unwrap();
+    assert_eq!(array.as_str(), "[1,false]");
+}
+
+#[test]
+fn source_document_keeps_the_256_container_contract() {
+    let nested = "[".repeat(256) + &"]".repeat(256);
+    let parsed = document::parse_with_depth(&nested, document::DOCUMENT_MAX_DEPTH).unwrap();
+    assert_eq!(
+        document::stringify_with_depth(&parsed, document::DOCUMENT_MAX_DEPTH).unwrap(),
+        nested
+    );
+    assert!(document::stringify_with_depth(&parsed, 255).is_err());
+    let too_deep = "[".repeat(257) + &"]".repeat(257);
+    assert!(document::parse_with_depth(&too_deep, document::DOCUMENT_MAX_DEPTH).is_err());
+}
+
+#[test]
+fn raw_properties_preserve_subtree_bytes_and_distinguish_null_from_missing() {
+    let value = Json::parse(r#"{"payload": [ 1e9999, -0, "\u96ea" ], "empty": null}"#).unwrap();
+    assert_eq!(
+        value.property("payload").unwrap().unwrap().as_str(),
+        r#"[ 1e9999, -0, "\u96ea" ]"#
+    );
+    assert_eq!(value.property("empty").unwrap().unwrap().as_str(), "null");
+    assert_eq!(value.property("missing").unwrap(), None);
+    assert!(Json::integer(1).unwrap().property("key").is_err());
+    assert!(
+        Json::parse("[]")
+            .unwrap()
+            .set_property("key", &value)
+            .is_err()
+    );
+    let updated = value
+        .set_property("empty", &Json::boolean(true).unwrap())
+        .unwrap();
+    assert!(updated.as_str().contains(r#"[ 1e9999, -0, "\u96ea" ]"#));
+    assert_eq!(value.property("empty").unwrap().unwrap().as_str(), "null");
+}
+
+#[test]
+fn property_keys_compare_decoded_text_without_changing_subtree_spelling() {
+    let source =
+        r#" {"\u0061": [ 1e9999, -0 ], "雪\"\\\n": "\u96ea", "\ud83d\ude42": null, "last": true} "#;
+    let value = Json::parse(source).unwrap();
+    for (key, expected) in [
+        ("a", Some("[ 1e9999, -0 ]")),
+        ("雪\"\\\n", Some(r#""\u96ea""#)),
+        ("🙂", Some("null")),
+        ("last", Some("true")),
+        (r"\u0061", None),
+        ("missing", None),
+    ] {
+        assert_eq!(
+            value.property(key).unwrap().as_ref().map(Json::as_str),
+            expected,
+            "{key}"
+        );
+    }
+    assert_eq!(value.as_str(), source);
+    for source in [r#"{"a":1,"\u0061":2}"#, r#"{"a":1,"tail":[}"#] {
+        assert!(Json::parse(source).is_err());
+    }
+}
+
+#[test]
+fn shared_wire_checks_duplicate_names_and_all_three_budgets() {
+    use dever_runtime::wire;
+    for source in [r#"{"a":1,"\u0061":2}"#, r#"[{"a":1,"a":2}]"#, r#""\ud800""#] {
+        assert!(Json::parse(source).is_err(), "{source}");
+        assert!(
+            wire::decode::<serde_json::Value>(source).is_err(),
+            "{source}"
+        );
+    }
+    let maximum = format!("[{}0]", "0,".repeat(document::MAX_VALUES - 2));
+    assert!(Json::parse(&maximum).is_ok());
+    assert!(wire::decode::<Vec<i64>>(&maximum).is_ok());
+    let excessive = format!("[{}0]", "0,".repeat(document::MAX_VALUES - 1));
+    assert!(Json::parse(&excessive).is_err());
+    assert!(wire::decode::<Vec<i64>>(&excessive).is_err());
+    let nested = "[".repeat(document::MAX_DEPTH) + &"]".repeat(document::MAX_DEPTH);
+    assert!(Json::parse(&nested).is_ok());
+    assert!(Json::parse(&format!("[{nested}]")).is_err());
+    assert!(wire::response(&serde_json::from_str::<serde_json::Value>(&nested).unwrap()).is_err());
+    assert!(Json::string(&"x".repeat(document::MAX_BYTES - 2)).is_ok());
+    assert!(Json::string(&"x".repeat(document::MAX_BYTES - 1)).is_err());
+}
+
+#[test]
+fn manual_document_shared_subgraphs_are_bounded_before_expansion() {
+    let mut graph = document::Document {
+        root: 0,
+        nodes: vec![document::Value::Null],
+    };
+    for index in 1..40 {
+        graph.nodes.push(document::Value::Array(vec![
+            index as i64 - 1,
+            index as i64 - 1,
+        ]));
+        graph.root = index;
+    }
+    let error = document::stringify(&graph).unwrap_err();
+    assert!(error.node < 20, "{error}");
+    assert!(error.message.contains("65536"), "{error}");
+    let oversized = document::Document {
+        root: 1,
+        nodes: vec![
+            document::Value::String("x".repeat(document::MAX_BYTES / 2)),
+            document::Value::Array(vec![0, 0]),
+        ],
+    };
+    assert!(
+        document::stringify(&oversized)
+            .unwrap_err()
+            .message
+            .contains("16 MiB")
+    );
+}
+
+#[test]
+fn replacing_a_field_does_not_accumulate_obsolete_document_nodes() {
+    let source = format!(
+        r#"{{"count":0,"values":[{}0]}}"#,
+        "0,".repeat(document::MAX_VALUES - 4)
+    );
+    let original = Json::parse(&source).unwrap();
+    let updated = original
+        .set_property("count", &Json::integer(1).unwrap())
+        .unwrap();
+    assert_eq!(
+        updated.property("count").unwrap().unwrap().as_integer(),
+        Ok(1)
+    );
+    assert_eq!(
+        original.property("count").unwrap().unwrap().as_integer(),
+        Ok(0)
+    );
+    assert!(
+        updated
+            .set_property("extra", &Json::null().unwrap())
+            .is_err()
+    );
+}
+
+#[test]
+fn fixed_record_encoding_keeps_byte_limits_and_escaping() {
+    #[derive(serde::Serialize)]
+    struct Record<'value> {
+        text: &'value str,
+    }
+    for text in ["", "雪\"\\\n"] {
+        let value = Record { text };
+        assert_eq!(Json::encode_proven(&value, 2, 1), Json::encode(&value));
+    }
+    let text = "x".repeat(document::MAX_BYTES - r#"{"text":""}"#.len());
+    assert_eq!(
+        Json::encode(&Record { text: &text })
+            .unwrap()
+            .as_str()
+            .len(),
+        document::MAX_BYTES
+    );
+    assert!(
+        Json::encode(&Record {
+            text: &(text + "x")
+        })
+        .is_err()
+    );
+}
+
+#[test]
+fn decimal_wire_is_an_exact_string_not_a_floating_point_value() {
+    use dever_runtime::{value::decimal::Decimal, wire};
+    let value = wire::decode::<Decimal>(r#""1234567890123456789012345678901234""#).unwrap();
+    assert_eq!(
+        Json::encode(&value).unwrap().as_str(),
+        r#""1234567890123456789012345678901234""#
+    );
+    assert!(wire::decode::<Decimal>("1.25").is_err());
+    assert!(wire::decode::<Decimal>(r#""NaN""#).is_err());
+    assert!(wire::decode::<Decimal>(r#""12345678901234567890123456789012345""#).is_err());
+}
+
+#[test]
+fn decimal_nullable_lists_preserve_extremes_and_normalized_output() {
+    use dever_runtime::{value::decimal::Decimal, wire};
+    let values = [
+        "-0.00",
+        "1.2300",
+        "1E-6176",
+        "9.999999999999999999999999999999999E6144",
+    ];
+    let mut numbers = values
+        .map(|value| Some(Decimal::parse(value).unwrap()))
+        .to_vec();
+    numbers.push(None);
+    let encoded = Json::encode(&numbers).unwrap();
+    let expected = [
+        Some("0"),
+        Some("1.23"),
+        Some("1E-6176"),
+        Some("9.999999999999999999999999999999999E+6144"),
+        None,
+    ];
+    assert_eq!(encoded.as_str(), serde_json::to_string(&expected).unwrap());
+    assert_eq!(
+        wire::decode::<Vec<Option<Decimal>>>(encoded.as_str()).unwrap(),
+        numbers
+    );
+    assert!(wire::decode::<Vec<Decimal>>(encoded.as_str()).is_err());
+}
+
+#[test]
+fn raw_deserialization_preserves_subtree_text_and_enforces_bounds() {
+    let source = r#" {"huge": 1e9999, "text": "\u96ea", "array": [ 1, 2 ]} "#;
+    let value: Json = serde_json::from_str(source).unwrap();
+    assert_eq!(value.as_str(), source.trim());
+    assert_eq!(Json::parse(source).unwrap().as_str(), source);
+    let parsed = Json::parse(source.trim()).unwrap();
+    assert_eq!(value, parsed);
+    for value in [value, parsed] {
+        assert_eq!(format!("{value:?}"), format!("Json({:?})", source.trim()));
+        assert_eq!(
+            Json::encode_with(|output| output.json(&value))
+                .unwrap()
+                .as_str(),
+            source.trim()
+        );
+        assert_eq!(value.clone().into_text(), source.trim());
+        let child = value.property("array").unwrap().unwrap();
+        assert_eq!(
+            Json::encode_with(|output| output.json(&child))
+                .unwrap()
+                .as_str(),
+            "[ 1, 2 ]"
+        );
+        let updated = value.set_property("array", &child).unwrap();
+        assert_eq!(updated.property("array").unwrap().as_ref(), Some(&child));
+        assert_eq!(
+            updated.property("huge").unwrap().unwrap().as_str(),
+            "1e9999"
+        );
+    }
+    for source in [
+        r#"{"a":1,"\u0061":2}"#.to_owned(),
+        r#"["\ud800"]"#.to_owned(),
+        "[".repeat(65) + &"]".repeat(65),
+        format!("[{}0]", "0,".repeat(document::MAX_VALUES - 1)),
+        format!("\"{}\"", "x".repeat(document::MAX_BYTES - 1)),
+    ] {
+        assert!(serde_json::from_str::<Json>(&source).is_err());
+    }
+}