ic-query 0.87.0

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
106
107
108
109
110
111
112

use crate::report::CollectionSourceRequest;
use crate::sns::report::SnsNeuronRow;
use crate::sns::report::tests::fixtures::*;
use crate::sns::report::tests::*;

struct InvalidBoundedSnsNeuronsSource;

delegate_sns_discovery!(InvalidBoundedSnsNeuronsSource);

impl SnsNeuronsSource for InvalidBoundedSnsNeuronsSource {
    fn fetch_sns_neurons<'a>(
        &'a self,
        request: &'a CollectionSourceRequest,
        sns: &'a MainnetSns,
        limit: u32,
        owner_principal_id: Option<&'a str>,
    ) -> crate::report::SourceFuture<'a, Result<Vec<SnsNeuronRow>, SnsHostError>> {
        Box::pin(async move {
            let mut neurons = FixtureSnsNeuronsSource
                .fetch_sns_neurons(request, sns, limit, owner_principal_id)
                .await?;
            neurons[0].neuron_id = "0A".to_string();
            Ok(neurons)
        })
    }

    fn fetch_sns_neuron_page<'a>(
        &'a self,
        _request: &'a CollectionSourceRequest,
        _sns: &'a MainnetSns,
        _limit: u32,
        _start_page_at: Option<&'a SnsNeuronId>,
        _owner_principal_id: Option<&'a str>,
    ) -> crate::report::SourceFuture<'a, Result<MainnetSnsNeuronPage, SnsHostError>> {
        Box::pin(async move { unreachable!("bounded validation fixture does not refresh") })
    }
}

#[tokio::test(flavor = "current_thread")]
async fn sns_neurons_resolves_list_id_and_renders_governance_neurons() {
    let mut request = neurons_request("1");
    request.collection = crate::sns::SnsNeuronCollection::Live {
        owner_principal_id: Some(GOVERNANCE_A.to_string()),
    };

    let report = build_sns_neurons_report_with_source(&request, &FixtureSnsNeuronsSource)
        .await
        .expect("sns neurons report");

    assert_eq!(report.schema_version, SNS_NEURONS_REPORT_SCHEMA_VERSION);
    assert_eq!(report.context.instance.id, 1);
    assert_eq!(report.context.instance.name, "Fixture SNS");
    assert_eq!(report.context.instance.root_canister_id, ROOT_A);
    assert_eq!(report.context.governance_canister_id, GOVERNANCE_A);
    assert_eq!(report.requested_limit, 10);
    assert_eq!(report.owner_principal_id.as_deref(), Some(GOVERNANCE_A));
    assert_eq!(report.total_neuron_count, 1);
    assert_eq!(report.neuron_count, 1);
    assert_eq!(report.provenance.data_source().as_str(), "live");
    assert!(report.provenance.cache_path().is_none());
    assert!(report.provenance.cache_complete().is_none());
    assert_eq!(report.neurons[0].neuron_id, NEURON_A);
    assert_eq!(report.neurons[0].cached_neuron_stake_e8s, 123);
    assert_eq!(report.neurons[0].maturity_e8s_equivalent, 456);
    assert_eq!(report.neurons[0].staked_maturity_e8s_equivalent, Some(789));
    assert_eq!(report.neurons[0].created_timestamp_seconds, 1_780_272_000);
    assert_eq!(report.neurons[0].source_nns_neuron_id, Some(42));
    assert_eq!(report.neurons[0].auto_stake_maturity, Some(true));
    assert_eq!(
        report.neurons[0].aging_since_timestamp_seconds,
        1_780_272_100
    );
    assert_eq!(
        report.neurons[0].dissolve_state,
        Some(SnsNeuronDissolveState::DissolveDelaySeconds(31_536_000))
    );
    assert_eq!(report.neurons[0].voting_power_percentage_multiplier, 100);
    assert_eq!(report.neurons[0].vesting_period_seconds, Some(63_072_000));
    assert_eq!(report.neurons[0].neuron_fees_e8s, 10);
}

#[tokio::test(flavor = "current_thread")]
async fn sns_neurons_builder_rejects_noncanonical_custom_source_rows() {
    let mut request = neurons_request("1");
    request.collection = crate::sns::SnsNeuronCollection::Live {
        owner_principal_id: Some(GOVERNANCE_A.to_string()),
    };

    let error = build_sns_neurons_report_with_source(&request, &InvalidBoundedSnsNeuronsSource)
        .await
        .expect_err("invalid custom-source row rejected");

    assert!(matches!(
        error,
        SnsHostError::InvalidSourceData {
            capability: "SNS neurons",
            reason,
        } if reason.contains("canonical lowercase hexadecimal")
    ));
}

#[tokio::test(flavor = "current_thread")]
async fn sns_neurons_live_owner_filter_is_admitted() {
    let mut request = neurons_request("1");
    request.collection = crate::sns::SnsNeuronCollection::Live {
        owner_principal_id: Some(GOVERNANCE_A.to_string()),
    };

    build_sns_neurons_report_with_source(&request, &FixtureSnsNeuronsSource)
        .await
        .expect("sns neurons report");
}