qubit-value 0.12.1

Type-safe containers for single, multi-valued, and named runtime values
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

// =============================================================================
//    Copyright (c) 2025 - 2026 Haixing Hu.
//
//    SPDX-License-Identifier: Apache-2.0
//
//    Licensed under the Apache License, Version 2.0.
// =============================================================================

//! Strict JSON serialization behavior.

#[cfg(all(feature = "converter", feature = "json"))]
use qubit_datatype::InvalidValueReason;
#[cfg(all(feature = "converter", feature = "json"))]
use qubit_value::ValueError;
#[cfg(all(feature = "converter", feature = "json"))]
use serde::Serialize;
#[cfg(all(feature = "converter", feature = "json"))]
use serde::Serializer;
#[cfg(all(feature = "converter", feature = "json"))]
use serde::ser::SerializeMap;

/// Emits a duplicate JSON object key through the public conversion boundary.
#[cfg(all(feature = "converter", feature = "json"))]
struct DuplicateKeyProbe;

#[cfg(all(feature = "converter", feature = "json"))]
impl Serialize for DuplicateKeyProbe {
    /// Serializes two entries using the same object key.
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let mut map = serializer.serialize_map(Some(2))?;
        map.serialize_entry("same", &1_u8)?;
        map.serialize_entry("same", &2_u8)?;
        map.end()
    }
}

#[cfg(all(feature = "converter", feature = "json"))]
#[test]
fn test_strict_json_rejects_non_finite_float() {
    use qubit_value::Value;

    let error = Value::from_serializable(&f64::NAN).expect_err("non-finite value must fail");
    let ValueError::Conversion(error) = error else {
        panic!("strict JSON projection must return a conversion error");
    };
    assert_eq!(error.reason(), Some(&InvalidValueReason::NonFinite));
}

/// Maps strict wide-integer failures to the shared out-of-range reason.
#[cfg(all(feature = "converter", feature = "json"))]
#[test]
fn test_strict_json_maps_wide_integer_to_out_of_range() {
    use qubit_value::Value;

    let error = Value::from_serializable(&u128::MAX).expect_err("wide integer must fail");
    let ValueError::Conversion(error) = error else {
        panic!("strict JSON projection must return a conversion error");
    };
    assert_eq!(error.reason(), Some(&InvalidValueReason::OutOfRange));
}

/// Rejects object keys that collide during strict JSON projection.
#[cfg(all(feature = "converter", feature = "json"))]
#[test]
fn test_strict_json_rejects_duplicate_object_key() {
    use qubit_value::Value;

    assert!(Value::from_serializable(&DuplicateKeyProbe).is_err());
}

/// Materializes RawValue as represented JSON instead of a protocol marker.
#[cfg(all(feature = "converter", feature = "json"))]
#[test]
fn test_strict_json_materializes_raw_value() {
    use qubit_value::Value;
    use serde_json::json;
    use serde_json::value::RawValue;

    let raw = RawValue::from_string(String::from(r#"{"ok":true}"#)).expect("fixture should be valid raw JSON");
    let value = Value::from_serializable(&raw).expect("strict RawValue should project");

    assert_eq!(value.to_json_value().expect("project JSON"), json!({"ok": true}));
}