fix(PocketIC): consensus registry version of instance resumed from existing state (#7502)

This PR fixes the consensus registry version of a PocketIC instance
resumed from an existing state: for canister http outcalls to work that
registry version must be equal to the latest registry version which was
not the case for a PocketIC instance resumed from an existing state (in
that case the consensus registry version was equal to the registry
version at which the corresponding subnet was created which is not
always equal to the latest registry version if there are multiple
subnets).

More details:
- the function `check_share_against_context`
[requires](https://github.com/dfinity/ic/blob/7a8c16764cdcfb901759ff62e64ac983633fcc17/rs/https_outcalls/consensus/src/payload_builder/utils.rs#L85)
the registry version of the canister http outcall share (set to the
[latest registry
version](https://github.com/dfinity/ic/blob/7a8c16764cdcfb901759ff62e64ac983633fcc17/rs/state_machine_tests/src/lib.rs#L2347)
by PocketIC) to match the [consensus registry
version](https://github.com/dfinity/ic/blob/7a8c16764cdcfb901759ff62e64ac983633fcc17/rs/https_outcalls/consensus/src/payload_builder.rs#L181-L194)
retrieved from the consensus pool cache set by PocketIC
[here](https://github.com/dfinity/ic/blob/7a8c16764cdcfb901759ff62e64ac983633fcc17/rs/state_machine_tests/src/lib.rs#L1773)
when loading an existing subnet and
[here](https://github.com/dfinity/ic/blob/7a8c16764cdcfb901759ff62e64ac983633fcc17/rs/state_machine_tests/src/lib.rs#L1644)
when creating a new subnet;
- the function `make_registry_cup` used so far creates a CUP with the
[registry
version](https://github.com/dfinity/ic/blob/7a8c16764cdcfb901759ff62e64ac983633fcc17/rs/consensus/cup_utils/src/lib.rs#L187)
at which the corresponding registry key
`catch_up_package_contents_{subnet_id}` was
[inserted](https://github.com/dfinity/ic/blob/7a8c16764cdcfb901759ff62e64ac983633fcc17/rs/state_machine_tests/src/lib.rs#L497-L503)
into the registry (the registry version at which the corresponding
subnet was created by PocketIC);
- the function `make_registry_cup_from_cup_contents` used in this PR
creates a CUP with a [registry
version](https://github.com/dfinity/ic/blob/7a8c16764cdcfb901759ff62e64ac983633fcc17/rs/consensus/cup_utils/src/lib.rs#L33)
specified in the function's input parameters which allows PocketIC to
use the latest registry version in the CUP.

Author: mraszyk

packages/pocket-ic/tests/tests.rs

@@ -1314,18 +1314,7 @@ fn test_vetkd() {
     }
 }
 
-#[test]
-fn test_canister_http() {
-    let pic = PocketIc::new();
-
-    // Create a canister and charge it with initial cycles.
-    let canister_id = pic.create_canister();
-    pic.add_cycles(canister_id, INIT_CYCLES);
-
-    // Install the test canister wasm file on the canister.
-    let test_wasm = test_canister_wasm();
-    pic.install_canister(canister_id, test_wasm, vec![], None);
-
+fn test_canister_http(pic: &PocketIc, canister_id: Principal) {
     // Submit an update call to the test canister making a canister http outcall
     // and mock a canister http outcall response.
     let call_id = pic
@@ -1370,6 +1359,48 @@ fn test_canister_http() {
     assert_eq!(http_response.unwrap().body, body);
 }
 
+#[test]
+fn test_canister_http_on_fresh_and_resumed_instance() {
+    // create an empty PocketIC state to be used:
+    // - initially by a fresh PocketIC instance;
+    // - later by a PocketIC instance resumed from that state.
+    let state = PocketIcState::new();
+
+    // create a fresh PocketIC instance with two application subnets
+    // so that the latest registry version is different
+    // from the registry version at which one of the subnets was created
+    // (this scenario led to a bug in PocketIC canister http outcalls)
+    let pic = PocketIcBuilder::new()
+        .with_application_subnet()
+        .with_application_subnet()
+        .with_state(state)
+        .build();
+
+    // create a test canister on every subnet
+    let topology = pic.topology();
+    let mut canisters = vec![];
+    for app_subnet in topology.get_app_subnets() {
+        let canister_id = pic.create_canister_on_subnet(None, None, app_subnet);
+        pic.add_cycles(canister_id, INIT_CYCLES);
+        pic.install_canister(canister_id, test_canister_wasm(), vec![], None);
+        canisters.push(canister_id);
+    }
+    // ensure that canister http outcalls work on every subnet
+    for canister_id in &canisters {
+        test_canister_http(&pic, *canister_id);
+    }
+
+    // drop the first PocketIC instance and serialize its state
+    let state = pic.drop_and_take_state().unwrap();
+
+    // create the second PocketIC instance resuming from the existing state
+    let pic = PocketIcBuilder::new().with_state(state).build();
+    // ensure that canister http outcalls still work on every subnet
+    for canister_id in &canisters {
+        test_canister_http(&pic, *canister_id);
+    }
+}
+
 #[test]
 fn test_canister_http_with_transform() {
     let pic = PocketIc::new();

rs/state_machine_tests/src/lib.rs

@@ -14,7 +14,7 @@ use ic_config::{
     subnet_config::SubnetConfig,
 };
 use ic_consensus::consensus::payload_builder::PayloadBuilderImpl;
-use ic_consensus_cup_utils::{make_registry_cup, make_registry_cup_from_cup_contents};
+use ic_consensus_cup_utils::make_registry_cup_from_cup_contents;
 use ic_consensus_utils::crypto::SignVerify;
 use ic_crypto_test_utils_crypto_returning_ok::CryptoReturningOk;
 use ic_crypto_test_utils_ni_dkg::{
@@ -146,7 +146,6 @@ use ic_types::{
     },
     canister_http::{CanisterHttpResponse, CanisterHttpResponseContent},
     consensus::{
-        CatchUpPackage,
         block_maker::SubnetRecords,
         certification::{Certification, CertificationContent},
     },
@@ -516,6 +515,28 @@ fn add_subnet_local_registry_records(
     );
 }
 
+fn make_fresh_registry_cup(
+    registry_client: Arc<FakeRegistryClient>,
+    subnet_id: SubnetId,
+    replica_logger: &ReplicaLogger,
+) -> pb::CatchUpPackage {
+    let registry_version = registry_client.get_latest_version();
+    let cup_contents = registry_client
+        .get_cup_contents(subnet_id, registry_version)
+        .unwrap()
+        .value
+        .unwrap();
+    let cup = make_registry_cup_from_cup_contents(
+        registry_client.as_ref(),
+        subnet_id,
+        cup_contents,
+        registry_version,
+        replica_logger,
+    )
+    .unwrap();
+    cup.into()
+}
+
 /// Convert an object into CBOR binary.
 fn into_cbor<R: Serialize>(r: &R) -> Vec<u8> {
     let mut ser = serde_cbor::Serializer::new(Vec::new());
@@ -1625,22 +1646,11 @@ impl StateMachine {
         // Since the latest registry version could have changed,
         // we update the CUP in `FakeConsensusPoolCache` to refer
         // to the latest registry version.
-        let registry_version = self.registry_client.get_latest_version();
-        let cup_contents = self
-            .registry_client
-            .get_cup_contents(self.subnet_id, registry_version)
-            .unwrap()
-            .value
-            .unwrap();
-        let cup = make_registry_cup_from_cup_contents(
-            self.registry_client.as_ref(),
+        let cup_proto = make_fresh_registry_cup(
+            self.registry_client.clone(),
             self.subnet_id,
-            cup_contents,
-            registry_version,
             &self.replica_logger,
-        )
-        .unwrap();
-        let cup_proto: pb::CatchUpPackage = cup.into();
+        );
         self.consensus_pool_cache.update_cup(cup_proto);
     }
 
@@ -1758,18 +1768,14 @@ impl StateMachine {
 
         let registry_client = FakeRegistryClient::new(Arc::clone(&registry_data_provider) as _);
         registry_client.update_to_latest_version();
-
-        // get the CUP from the registry
-        let cup: CatchUpPackage =
-            make_registry_cup(&registry_client, subnet_id, &replica_logger).unwrap();
-        let cup_proto: pb::CatchUpPackage = cup.into();
-        // now we can wrap the registry client into an Arc
         let registry_client = Arc::new(registry_client);
 
         let canister_http_pool = Arc::new(RwLock::new(CanisterHttpPoolImpl::new(
             metrics_registry.clone(),
             replica_logger.clone(),
         )));
+        let cup_proto =
+            make_fresh_registry_cup(registry_client.clone(), subnet_id, &replica_logger);
         let consensus_pool_cache = Arc::new(FakeConsensusPoolCache::new(cup_proto));
         let crypto = CryptoReturningOk::default();
         let canister_http_payload_builder = Arc::new(CanisterHttpPayloadBuilderImpl::new(