ic-query 0.93.1

Internet Computer query library for CloudEngine, NNS, SNS, ICRC, system canisters, and public network metadata
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
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

use super::*;
use crate::nns::governance::{NnsGovernanceError, validate_governance_time_interval};

struct UnexpectedSource;
impl NnsNeuronSource for UnexpectedSource {
    fn fetch_neuron_page<'a>(
        &'a self,
        _: &'a NnsGovernanceRequest,
        _: Option<u64>,
        _: u32,
    ) -> crate::nns::neuron::NnsNeuronSourceFuture<'a, crate::nns::neuron::NnsNeuronPage> {
        panic!("unexpected source call")
    }
    fn fetch_neuron<'a>(
        &'a self,
        _: &'a NnsGovernanceRequest,
        _: u64,
    ) -> crate::nns::neuron::NnsNeuronSourceFuture<'a, crate::nns::neuron::NnsNeuronRow> {
        panic!("unexpected source call")
    }
}

#[tokio::test(flavor = "current_thread")]
async fn collection_rejects_backward_continuations_and_restored_intervals() {
    let start = NnsGovernanceRequest::replicated_inter_canister_call_from_unix_secs("ic", 100);
    let state = NnsNeuronCollectionState::new(&start, 2, 3).unwrap();
    let before = NnsGovernanceRequest::replicated_inter_canister_call_from_unix_secs("ic", 99);
    let mut future = std::pin::pin!(advance_nns_neuron_collection_with_source(
        &before,
        &state,
        &UnexpectedSource
    ));
    let mut context = std::task::Context::from_waker(std::task::Waker::noop());
    let result = std::future::Future::poll(future.as_mut(), &mut context);
    assert!(matches!(
        result,
        std::task::Poll::Ready(Err(NnsNeuronError::Governance(
            NnsGovernanceError::InvalidTimestampOrder { .. }
        )))
    ));
    let mut value = serde_json::to_value(&state).unwrap();
    value["updated_at"] = serde_json::json!(before.fetched_at);
    let restored = serde_json::from_value(value).unwrap();
    assert!(matches!(
        validate_collection_state(&restored),
        Err(NnsNeuronError::Governance(
            NnsGovernanceError::InvalidTimestampOrder { .. }
        ))
    ));
    assert!(
        validate_governance_time_interval(
            "updated_at",
            &state.collection.updated_at,
            "fetched_at",
            &start.fetched_at
        )
        .is_ok()
    );
}

#[test]
fn collection_validates_request_and_restored_timestamps() {
    let mut request =
        NnsGovernanceRequest::replicated_inter_canister_call_from_unix_secs("ic", 1_700_000_000);
    let valid_state = NnsNeuronCollectionState::new(&request, 2, 3).expect("valid state");
    for (field, value) in [
        ("governance_canister_id", serde_json::json!("aaaaa-aa")),
        ("max_pages", serde_json::json!(0)),
        ("pages_fetched", serde_json::json!(4)),
    ] {
        let mut restored = serde_json::to_value(&valid_state).unwrap();
        restored[field] = value;
        let restored = serde_json::from_value(restored).unwrap();
        assert!(
            matches!(
                validate_collection_state(&restored),
                Err(NnsNeuronError::InvalidCollectionState { .. })
            ),
            "invalid restored {field}"
        );
    }
    for timestamp in ["not a UTC timestamp", "+2023-11-14T22:13:20Z"] {
        request.fetched_at = timestamp.to_string();
        assert!(matches!(
            NnsNeuronCollectionState::new(&request, 2, 3),
            Err(NnsNeuronError::Governance(
                NnsGovernanceError::InvalidTimestamp {
                    field: "fetched_at",
                    ..
                }
            ))
        ));
        for field in ["started_at", "updated_at"] {
            let mut value = serde_json::to_value(&valid_state).expect("serialize state");
            value[field] = serde_json::json!(timestamp);
            let state = serde_json::from_value(value).expect("restore caller state");
            assert!(matches!(
                validate_collection_state(&state),
                Err(NnsNeuronError::Governance(
                    NnsGovernanceError::InvalidTimestamp { value, .. }
                )) if value == timestamp
            ));
        }
    }
}