ic-platform-protocol 0.3.0

Bounded external protocol formats for IC Platform
Documentation
use super::*;
fn limits() -> Limits {
    Limits {
        bytes: 65536,
        fields: 4096,
        allocation: 4096,
        items: 128,
    }
}
#[test]
fn literal_envelopes_preserve_presence_versions_and_application_errors() {
    let response = decode_get_value_response(&[16, 7, 26, 0, 40, 9], limits()).unwrap();
    assert_eq!(response.version, 7);
    assert_eq!(response.timestamp_nanoseconds, 9);
    assert_eq!(response.value, Some(&[][..]));
    assert_eq!(
        decode_get_value_response(&[], limits()).unwrap().value,
        None
    );
    let bytes = [10, 8, 8, 123, 18, 1, b'x', 26, 1, 255, 26, 1, 0];
    let r = decode_get_value_response(&bytes, limits()).unwrap();
    assert_eq!(
        r.error,
        Some(RegistryError {
            code: 123,
            reason: "x",
            key: &[255]
        })
    );
    assert!(
        decode_get_value_response(&[10, 0], limits())
            .unwrap()
            .error
            .is_some()
    );
    for bytes in [&[26, 0, 26, 0][..], &[16, 0, 16, 0], &[10, 4, 8, 0, 8, 0]] {
        assert_eq!(
            decode_get_value_response(bytes, limits()),
            Err(Error::DuplicateField)
        );
    }
    assert_eq!(
        decode_get_value_response(&[34, 0], limits()),
        Err(Error::ChunkedValue)
    );
    assert_eq!(
        decode_get_value_response(&[26, 2, 0], limits()),
        Err(Error::Malformed)
    );
    let mut cap = limits();
    cap.fields = 4;
    assert!(decode_get_value_response(&[10, 4, 8, 0, 18, 0, 26, 0], cap).is_ok());
    cap.fields = 3;
    assert_eq!(
        decode_get_value_response(&[10, 4, 8, 0, 18, 0, 26, 0], cap),
        Err(Error::FieldLimit)
    );
}
#[test]
fn requests_match_independent_protobuf_literals() {
    assert_eq!(
        encode_get_value_request(b"k", None, 3).unwrap(),
        [18, 1, b'k']
    );
    assert_eq!(
        encode_get_value_request(b"k", Some(0), 5).unwrap(),
        [10, 0, 18, 1, b'k']
    );
    assert_eq!(
        encode_get_value_request(b"k", Some(128), 8).unwrap(),
        [10, 3, 8, 128, 1, 18, 1, b'k']
    );
    for version in [None, Some(0), Some(127), Some(128), Some(u64::MAX)] {
        let bytes = encode_get_value_request(b"\0\xff", version, 64).unwrap();
        assert_eq!(
            encode_get_value_request(b"\0\xff", version, bytes.len()).unwrap(),
            bytes
        );
        assert_eq!(
            encode_get_value_request(b"\0\xff", version, bytes.len() - 1),
            Err(Error::OutputLimit)
        );
    }
}
#[test]
fn projections_keep_borrowed_presence_and_source_order() {
    let nodes = decode_subnet_list(&[18, 1, 4, 18, 0], limits()).unwrap();
    assert_eq!(nodes, vec![&[4][..], &[]]);
    let r = decode_node_record(&[122, 1, 4, 130, 1, 0, 138, 1, 0], limits()).unwrap();
    assert_eq!(r.node_operator_id, &[4]);
    assert_eq!(r.chip_id, Some(&[][..]));
    assert_eq!(r.hostos_version_id, Some(""));
    assert_eq!(decode_node_record(&[], limits()).unwrap().chip_id, None);
    let r = decode_subnet_record(
        &[26, 1, 4, 74, 1, b'v', 120, 2, 136, 1, 1, 224, 1, 0],
        limits(),
    )
    .unwrap();
    assert_eq!(r.membership, vec![&[4][..]]);
    assert_eq!(r.replica_version_id, "v");
    assert_eq!(r.subnet_type, 2);
    assert!(r.is_halted);
    assert!(!r.halt_at_cup_height);
    assert_eq!(
        decode_subnet_record(&[136, 1, 2], limits()),
        Err(Error::Malformed)
    );
    assert_eq!(
        decode_data_center_record(&[10, 1, 255], limits()),
        Err(Error::Malformed)
    );
    assert_eq!(
        decode_get_latest_version_response(&[8, 128, 1], limits()).unwrap(),
        128
    );
}
#[test]
fn repeated_and_unknown_fields_obey_all_budgets() {
    let bytes = [18, 1, 4, 18, 0];
    let mut cap = limits();
    cap.items = 1;
    assert_eq!(decode_subnet_list(&bytes, cap), Err(Error::ItemLimit));
    cap = limits();
    cap.allocation = 2 * std::mem::size_of::<&[u8]>();
    assert!(decode_subnet_list(&bytes, cap).is_ok());
    cap.allocation -= 1;
    assert_eq!(decode_subnet_list(&bytes, cap), Err(Error::AllocationLimit));
    cap = limits();
    cap.bytes = 4;
    assert_eq!(decode_subnet_list(&bytes, cap), Err(Error::ByteLimit));
    cap = limits();
    cap.fields = 1;
    assert_eq!(
        decode_subnet_list(&[8, 0, 18, 0], cap),
        Err(Error::FieldLimit)
    );
    assert_eq!(
        decode_subnet_list(&[8, 128], limits()),
        Err(Error::Malformed)
    );
}