qubit-value 0.11.0

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
87
88

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

//! Tests for `ValueWireDecodeError`.

use std::error::Error;

use qubit_budget::BudgetError;
use qubit_budget::Observation;
use qubit_budget::QuantityConversionError;
use qubit_budget::QuantityMeasurement;
use qubit_budget::json::JsonResource;
use qubit_value::ValueWireDecodeError;
use qubit_value::ValueWireV1;

#[test]
fn test_value_wire_decode_error_preserves_budget_source() {
    let error = ValueWireDecodeError::Budget(BudgetError::LimitExceeded {
        resource: JsonResource::InputBytes,
        observed: Observation::Exact(9),
        maximum: 8,
    });

    assert!(error.to_string().contains("InputBytes"));
    assert!(error.source().is_some());
}

#[test]
fn test_value_wire_decode_error_preserves_json_source() {
    let source =
        serde_json::from_slice::<u64>(br#""TOP_SECRET""#).expect_err("a JSON string cannot deserialize into u64");
    let error = ValueWireDecodeError::from(source);

    assert!(matches!(&error, ValueWireDecodeError::InvalidJson(_)));
    assert!(
        error
            .to_string()
            .starts_with("failed to decode V1 JSON wire input: JSON deserialization failed")
    );
    let source = error.source().expect("JSON errors expose safe metadata");
    assert!(source.to_string().starts_with("JSON deserialization failed"));
    assert!(!source.to_string().contains("TOP_SECRET"));
}

#[test]
fn test_value_wire_decode_error_maps_strict_deserialize_metadata() {
    let error =
        ValueWireV1::decode_json_slice(br#"{"version":1,"value":false}"#).expect_err("a boolean is not a V1 payload");

    assert!(matches!(&error, ValueWireDecodeError::InvalidJson(_)));
    let source = error.source().expect("JSON errors expose safe metadata");
    assert!(
        source.to_string().contains("JSON deserialization failed"),
        "unexpected safe JSON source: {source}"
    );
}

#[test]
fn test_value_wire_decode_error_reports_unsupported_version() {
    let error = ValueWireDecodeError::UnsupportedVersion { expected: 1, actual: 2 };

    assert_eq!(error.to_string(), "unsupported qubit-value wire version 2; expected 1");
    assert!(error.source().is_none());
}

#[test]
fn test_value_wire_decode_error_preserves_quantity_failure() {
    let source = QuantityConversionError::new(QuantityMeasurement::U64(u64::MAX), "usize");
    let error = ValueWireDecodeError::Quantity {
        resource: JsonResource::StringBytes,
        source,
    };

    assert!(matches!(
        &error,
        ValueWireDecodeError::Quantity {
            resource: JsonResource::StringBytes,
            source: actual,
        } if *actual == source
    ));
    assert!(error.to_string().contains("StringBytes"));
    assert_eq!(error.source().map(ToString::to_string), Some(source.to_string()));
}