chore: move tests into separate files (#3206)

Moves tests into separate files
in order to limit the loc per file.

polkadot/node/core/runtime-api/src/tests.rs

@@ -0,0 +1,829 @@
+// Copyright 2020 Parity Technologies (UK) Ltd.
+// This file is part of Polkadot.
+
+// Polkadot is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// Polkadot is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with Polkadot.  If not, see <http://www.gnu.org/licenses/>.
+
+use super::*;
+
+use polkadot_primitives::v1::{
+    ValidatorId, ValidatorIndex, GroupRotationInfo, CoreState, PersistedValidationData,
+    Id as ParaId, OccupiedCoreAssumption, SessionIndex, ValidationCode,
+    CommittedCandidateReceipt, CandidateEvent, InboundDownwardMessage,
+    BlockNumber, InboundHrmpMessage, SessionInfo, AuthorityDiscoveryId,
+};
+use polkadot_node_subsystem_test_helpers as test_helpers;
+use sp_core::testing::TaskExecutor;
+use std::{collections::{HashMap, BTreeMap}, sync::{Arc, Mutex}};
+use futures::channel::oneshot;
+use polkadot_node_primitives::{
+    BabeEpoch, BabeEpochConfiguration, BabeAllowedSlots,
+};
+
+#[derive(Default, Clone)]
+struct MockRuntimeApi {
+    authorities: Vec<AuthorityDiscoveryId>,
+    validators: Vec<ValidatorId>,
+    validator_groups: Vec<Vec<ValidatorIndex>>,
+    availability_cores: Vec<CoreState>,
+    availability_cores_wait: Arc<Mutex<()>>,
+    validation_data: HashMap<ParaId, PersistedValidationData>,
+    session_index_for_child: SessionIndex,
+    session_info: HashMap<SessionIndex, SessionInfo>,
+    validation_code: HashMap<ParaId, ValidationCode>,
+    historical_validation_code: HashMap<ParaId, Vec<(BlockNumber, ValidationCode)>>,
+    validation_outputs_results: HashMap<ParaId, bool>,
+    candidate_pending_availability: HashMap<ParaId, CommittedCandidateReceipt>,
+    candidate_events: Vec<CandidateEvent>,
+    dmq_contents: HashMap<ParaId, Vec<InboundDownwardMessage>>,
+    hrmp_channels: HashMap<ParaId, BTreeMap<ParaId, Vec<InboundHrmpMessage>>>,
+    babe_epoch: Option<BabeEpoch>,
+}
+
+impl ProvideRuntimeApi<Block> for MockRuntimeApi {
+    type Api = Self;
+
+    fn runtime_api<'a>(&'a self) -> sp_api::ApiRef<'a, Self::Api> {
+        self.clone().into()
+    }
+}
+
+sp_api::mock_impl_runtime_apis! {
+    impl ParachainHost<Block> for MockRuntimeApi {
+        fn validators(&self) -> Vec<ValidatorId> {
+            self.validators.clone()
+        }
+
+        fn validator_groups(&self) -> (Vec<Vec<ValidatorIndex>>, GroupRotationInfo) {
+            (
+                self.validator_groups.clone(),
+                GroupRotationInfo {
+                    session_start_block: 1,
+                    group_rotation_frequency: 100,
+                    now: 10,
+                },
+            )
+        }
+
+        fn availability_cores(&self) -> Vec<CoreState> {
+            let _ = self.availability_cores_wait.lock().unwrap();
+            self.availability_cores.clone()
+        }
+
+        fn persisted_validation_data(
+            &self,
+            para: ParaId,
+            _assumption: OccupiedCoreAssumption,
+        ) -> Option<PersistedValidationData> {
+            self.validation_data.get(&para).cloned()
+        }
+
+        fn check_validation_outputs(
+            &self,
+            para_id: ParaId,
+            _commitments: polkadot_primitives::v1::CandidateCommitments,
+        ) -> bool {
+            self.validation_outputs_results
+                .get(&para_id)
+                .cloned()
+                .expect(
+                    "`check_validation_outputs` called but the expected result hasn't been supplied"
+                )
+        }
+
+        fn session_index_for_child(&self) -> SessionIndex {
+            self.session_index_for_child.clone()
+        }
+
+        fn session_info(&self, index: SessionIndex) -> Option<SessionInfo> {
+            self.session_info.get(&index).cloned()
+        }
+
+        fn validation_code(
+            &self,
+            para: ParaId,
+            _assumption: OccupiedCoreAssumption,
+        ) -> Option<ValidationCode> {
+            self.validation_code.get(&para).map(|c| c.clone())
+        }
+
+        fn historical_validation_code(
+            &self,
+            para: ParaId,
+            at: BlockNumber,
+        ) -> Option<ValidationCode> {
+            self.historical_validation_code.get(&para).and_then(|h_code| {
+                h_code.iter()
+                    .take_while(|(changed_at, _)| changed_at <= &at)
+                    .last()
+                    .map(|(_, code)| code.clone())
+            })
+        }
+
+        fn candidate_pending_availability(
+            &self,
+            para: ParaId,
+        ) -> Option<CommittedCandidateReceipt> {
+            self.candidate_pending_availability.get(&para).map(|c| c.clone())
+        }
+
+        fn candidate_events(&self) -> Vec<CandidateEvent> {
+            self.candidate_events.clone()
+        }
+
+        fn dmq_contents(
+            &self,
+            recipient: ParaId,
+        ) -> Vec<InboundDownwardMessage> {
+            self.dmq_contents.get(&recipient).map(|q| q.clone()).unwrap_or_default()
+        }
+
+        fn inbound_hrmp_channels_contents(
+            &self,
+            recipient: ParaId
+        ) -> BTreeMap<ParaId, Vec<InboundHrmpMessage>> {
+            self.hrmp_channels.get(&recipient).map(|q| q.clone()).unwrap_or_default()
+        }
+
+        fn validation_code_by_hash(
+            &self,
+            _hash: Hash,
+        ) -> Option<ValidationCode> {
+            unreachable!("not used in tests");
+        }
+    }
+
+    impl BabeApi<Block> for MockRuntimeApi {
+        fn configuration(&self) -> sp_consensus_babe::BabeGenesisConfiguration {
+            unimplemented!()
+        }
+
+        fn current_epoch_start(&self) -> sp_consensus_babe::Slot {
+            self.babe_epoch.as_ref().unwrap().start_slot
+        }
+
+        fn current_epoch(&self) -> BabeEpoch {
+            self.babe_epoch.as_ref().unwrap().clone()
+        }
+
+        fn next_epoch(&self) -> BabeEpoch {
+            unimplemented!()
+        }
+
+        fn generate_key_ownership_proof(
+            _slot: sp_consensus_babe::Slot,
+            _authority_id: sp_consensus_babe::AuthorityId,
+        ) -> Option<sp_consensus_babe::OpaqueKeyOwnershipProof> {
+            None
+        }
+
+        fn submit_report_equivocation_unsigned_extrinsic(
+            _equivocation_proof: sp_consensus_babe::EquivocationProof<polkadot_primitives::v1::Header>,
+            _key_owner_proof: sp_consensus_babe::OpaqueKeyOwnershipProof,
+        ) -> Option<()> {
+            None
+        }
+    }
+
+    impl AuthorityDiscoveryApi<Block> for MockRuntimeApi {
+        fn authorities(&self) -> Vec<AuthorityDiscoveryId> {
+            self.authorities.clone()
+        }
+    }
+}
+
+#[test]
+fn requests_authorities() {
+    let (ctx, mut ctx_handle) = test_helpers::make_subsystem_context(TaskExecutor::new());
+    let runtime_api = Arc::new(MockRuntimeApi::default());
+    let relay_parent = [1; 32].into();
+    let spawner = sp_core::testing::TaskExecutor::new();
+
+    let subsystem = RuntimeApiSubsystem::new(runtime_api.clone(), Metrics(None), spawner);
+    let subsystem_task = run(ctx, subsystem).map(|x| x.unwrap());
+    let test_task = async move {
+        let (tx, rx) = oneshot::channel();
+
+        ctx_handle.send(FromOverseer::Communication {
+            msg: RuntimeApiMessage::Request(relay_parent, Request::Authorities(tx))
+        }).await;
+
+        assert_eq!(rx.await.unwrap().unwrap(), runtime_api.authorities);
+
+        ctx_handle.send(FromOverseer::Signal(OverseerSignal::Conclude)).await;
+    };
+
+    futures::executor::block_on(future::join(subsystem_task, test_task));
+}
+
+#[test]
+fn requests_validators() {
+    let (ctx, mut ctx_handle) = test_helpers::make_subsystem_context(TaskExecutor::new());
+    let runtime_api = Arc::new(MockRuntimeApi::default());
+    let relay_parent = [1; 32].into();
+    let spawner = sp_core::testing::TaskExecutor::new();
+
+    let subsystem = RuntimeApiSubsystem::new(runtime_api.clone(), Metrics(None), spawner);
+    let subsystem_task = run(ctx, subsystem).map(|x| x.unwrap());
+    let test_task = async move {
+        let (tx, rx) = oneshot::channel();
+
+        ctx_handle.send(FromOverseer::Communication {
+            msg: RuntimeApiMessage::Request(relay_parent, Request::Validators(tx))
+        }).await;
+
+        assert_eq!(rx.await.unwrap().unwrap(), runtime_api.validators);
+
+        ctx_handle.send(FromOverseer::Signal(OverseerSignal::Conclude)).await;
+    };
+
+    futures::executor::block_on(future::join(subsystem_task, test_task));
+}
+
+#[test]
+fn requests_validator_groups() {
+    let (ctx, mut ctx_handle) = test_helpers::make_subsystem_context(TaskExecutor::new());
+    let runtime_api = Arc::new(MockRuntimeApi::default());
+    let relay_parent = [1; 32].into();
+    let spawner = sp_core::testing::TaskExecutor::new();
+
+    let subsystem = RuntimeApiSubsystem::new(runtime_api.clone(), Metrics(None), spawner);
+    let subsystem_task = run(ctx, subsystem).map(|x| x.unwrap());
+    let test_task = async move {
+        let (tx, rx) = oneshot::channel();
+
+        ctx_handle.send(FromOverseer::Communication {
+            msg: RuntimeApiMessage::Request(relay_parent, Request::ValidatorGroups(tx))
+        }).await;
+
+        assert_eq!(rx.await.unwrap().unwrap().0, runtime_api.validator_groups);
+
+        ctx_handle.send(FromOverseer::Signal(OverseerSignal::Conclude)).await;
+    };
+
+    futures::executor::block_on(future::join(subsystem_task, test_task));
+}
+
+#[test]
+fn requests_availability_cores() {
+    let (ctx, mut ctx_handle) = test_helpers::make_subsystem_context(TaskExecutor::new());
+    let runtime_api = Arc::new(MockRuntimeApi::default());
+    let relay_parent = [1; 32].into();
+    let spawner = sp_core::testing::TaskExecutor::new();
+
+    let subsystem = RuntimeApiSubsystem::new(runtime_api.clone(), Metrics(None), spawner);
+    let subsystem_task = run(ctx, subsystem).map(|x| x.unwrap());
+    let test_task = async move {
+        let (tx, rx) = oneshot::channel();
+
+        ctx_handle.send(FromOverseer::Communication {
+            msg: RuntimeApiMessage::Request(relay_parent, Request::AvailabilityCores(tx))
+        }).await;
+
+        assert_eq!(rx.await.unwrap().unwrap(), runtime_api.availability_cores);
+
+        ctx_handle.send(FromOverseer::Signal(OverseerSignal::Conclude)).await;
+    };
+
+    futures::executor::block_on(future::join(subsystem_task, test_task));
+}
+
+#[test]
+fn requests_persisted_validation_data() {
+    let (ctx, mut ctx_handle) = test_helpers::make_subsystem_context(TaskExecutor::new());
+    let relay_parent = [1; 32].into();
+    let para_a = 5.into();
+    let para_b = 6.into();
+    let spawner = sp_core::testing::TaskExecutor::new();
+
+    let mut runtime_api = MockRuntimeApi::default();
+    runtime_api.validation_data.insert(para_a, Default::default());
+    let runtime_api = Arc::new(runtime_api);
+
+    let subsystem = RuntimeApiSubsystem::new(runtime_api.clone(), Metrics(None), spawner);
+    let subsystem_task = run(ctx, subsystem).map(|x| x.unwrap());
+    let test_task = async move {
+        let (tx, rx) = oneshot::channel();
+
+        ctx_handle.send(FromOverseer::Communication {
+            msg: RuntimeApiMessage::Request(
+                relay_parent,
+                Request::PersistedValidationData(para_a, OccupiedCoreAssumption::Included, tx)
+            ),
+        }).await;
+
+        assert_eq!(rx.await.unwrap().unwrap(), Some(Default::default()));
+
+        let (tx, rx) = oneshot::channel();
+        ctx_handle.send(FromOverseer::Communication {
+            msg: RuntimeApiMessage::Request(
+                relay_parent,
+                Request::PersistedValidationData(para_b, OccupiedCoreAssumption::Included, tx)
+            ),
+        }).await;
+
+        assert_eq!(rx.await.unwrap().unwrap(), None);
+
+        ctx_handle.send(FromOverseer::Signal(OverseerSignal::Conclude)).await;
+    };
+
+    futures::executor::block_on(future::join(subsystem_task, test_task));
+}
+
+#[test]
+fn requests_check_validation_outputs() {
+    let (ctx, mut ctx_handle) = test_helpers::make_subsystem_context(TaskExecutor::new());
+    let mut runtime_api = MockRuntimeApi::default();
+    let relay_parent = [1; 32].into();
+    let para_a = 5.into();
+    let para_b = 6.into();
+    let commitments = polkadot_primitives::v1::CandidateCommitments::default();
+    let spawner = sp_core::testing::TaskExecutor::new();
+
+    runtime_api.validation_outputs_results.insert(para_a, false);
+    runtime_api.validation_outputs_results.insert(para_b, true);
+
+    let runtime_api = Arc::new(runtime_api);
+
+    let subsystem = RuntimeApiSubsystem::new(runtime_api.clone(), Metrics(None), spawner);
+    let subsystem_task = run(ctx, subsystem).map(|x| x.unwrap());
+    let test_task = async move {
+        let (tx, rx) = oneshot::channel();
+
+        ctx_handle.send(FromOverseer::Communication {
+            msg: RuntimeApiMessage::Request(
+                relay_parent,
+                Request::CheckValidationOutputs(
+                    para_a,
+                    commitments.clone(),
+                    tx,
+                ),
+            )
+        }).await;
+        assert_eq!(
+            rx.await.unwrap().unwrap(),
+            runtime_api.validation_outputs_results[&para_a],
+        );
+
+        let (tx, rx) = oneshot::channel();
+        ctx_handle.send(FromOverseer::Communication {
+            msg: RuntimeApiMessage::Request(
+                relay_parent,
+                Request::CheckValidationOutputs(
+                    para_b,
+                    commitments,
+                    tx,
+                ),
+            )
+        }).await;
+        assert_eq!(
+            rx.await.unwrap().unwrap(),
+            runtime_api.validation_outputs_results[&para_b],
+        );
+
+        ctx_handle.send(FromOverseer::Signal(OverseerSignal::Conclude)).await;
+    };
+
+    futures::executor::block_on(future::join(subsystem_task, test_task));
+}
+
+#[test]
+fn requests_session_index_for_child() {
+    let (ctx, mut ctx_handle) = test_helpers::make_subsystem_context(TaskExecutor::new());
+    let runtime_api = Arc::new(MockRuntimeApi::default());
+    let relay_parent = [1; 32].into();
+    let spawner = sp_core::testing::TaskExecutor::new();
+
+    let subsystem = RuntimeApiSubsystem::new(runtime_api.clone(), Metrics(None), spawner);
+    let subsystem_task = run(ctx, subsystem).map(|x| x.unwrap());
+    let test_task = async move {
+        let (tx, rx) = oneshot::channel();
+
+        ctx_handle.send(FromOverseer::Communication {
+            msg: RuntimeApiMessage::Request(relay_parent, Request::SessionIndexForChild(tx))
+        }).await;
+
+        assert_eq!(rx.await.unwrap().unwrap(), runtime_api.session_index_for_child);
+
+        ctx_handle.send(FromOverseer::Signal(OverseerSignal::Conclude)).await;
+    };
+
+    futures::executor::block_on(future::join(subsystem_task, test_task));
+}
+
+#[test]
+fn requests_session_info() {
+    let (ctx, mut ctx_handle) = test_helpers::make_subsystem_context(TaskExecutor::new());
+    let mut runtime_api = MockRuntimeApi::default();
+    let session_index = 1;
+    runtime_api.session_info.insert(session_index, Default::default());
+    let runtime_api = Arc::new(runtime_api);
+    let spawner = sp_core::testing::TaskExecutor::new();
+
+    let relay_parent = [1; 32].into();
+
+    let subsystem = RuntimeApiSubsystem::new(runtime_api.clone(), Metrics(None), spawner);
+    let subsystem_task = run(ctx, subsystem).map(|x| x.unwrap());
+    let test_task = async move {
+        let (tx, rx) = oneshot::channel();
+
+        ctx_handle.send(FromOverseer::Communication {
+            msg: RuntimeApiMessage::Request(relay_parent, Request::SessionInfo(session_index, tx))
+        }).await;
+
+        assert_eq!(rx.await.unwrap().unwrap(), Some(Default::default()));
+
+        ctx_handle.send(FromOverseer::Signal(OverseerSignal::Conclude)).await;
+    };
+
+    futures::executor::block_on(future::join(subsystem_task, test_task));
+}
+
+#[test]
+fn requests_validation_code() {
+    let (ctx, mut ctx_handle) = test_helpers::make_subsystem_context(TaskExecutor::new());
+
+    let relay_parent = [1; 32].into();
+    let para_a = 5.into();
+    let para_b = 6.into();
+    let spawner = sp_core::testing::TaskExecutor::new();
+
+    let mut runtime_api = MockRuntimeApi::default();
+    runtime_api.validation_code.insert(para_a, Default::default());
+    let runtime_api = Arc::new(runtime_api);
+
+    let subsystem = RuntimeApiSubsystem::new(runtime_api.clone(), Metrics(None), spawner);
+    let subsystem_task = run(ctx, subsystem).map(|x| x.unwrap());
+    let test_task = async move {
+        let (tx, rx) = oneshot::channel();
+
+        ctx_handle.send(FromOverseer::Communication {
+            msg: RuntimeApiMessage::Request(
+                relay_parent,
+                Request::ValidationCode(para_a, OccupiedCoreAssumption::Included, tx)
+            ),
+        }).await;
+
+        assert_eq!(rx.await.unwrap().unwrap(), Some(Default::default()));
+
+        let (tx, rx) = oneshot::channel();
+        ctx_handle.send(FromOverseer::Communication {
+            msg: RuntimeApiMessage::Request(
+                relay_parent,
+                Request::ValidationCode(para_b, OccupiedCoreAssumption::Included, tx)
+            ),
+        }).await;
+
+        assert_eq!(rx.await.unwrap().unwrap(), None);
+
+        ctx_handle.send(FromOverseer::Signal(OverseerSignal::Conclude)).await;
+    };
+
+    futures::executor::block_on(future::join(subsystem_task, test_task));
+}
+
+#[test]
+fn requests_candidate_pending_availability() {
+    let (ctx, mut ctx_handle) = test_helpers::make_subsystem_context(TaskExecutor::new());
+    let relay_parent = [1; 32].into();
+    let para_a = 5.into();
+    let para_b = 6.into();
+    let spawner = sp_core::testing::TaskExecutor::new();
+
+    let mut runtime_api = MockRuntimeApi::default();
+    runtime_api.candidate_pending_availability.insert(para_a, Default::default());
+    let runtime_api = Arc::new(runtime_api);
+
+    let subsystem = RuntimeApiSubsystem::new(runtime_api.clone(), Metrics(None), spawner);
+    let subsystem_task = run(ctx, subsystem).map(|x| x.unwrap());
+    let test_task = async move {
+        let (tx, rx) = oneshot::channel();
+
+        ctx_handle.send(FromOverseer::Communication {
+            msg: RuntimeApiMessage::Request(
+                relay_parent,
+                Request::CandidatePendingAvailability(para_a, tx),
+            )
+        }).await;
+
+        assert_eq!(rx.await.unwrap().unwrap(), Some(Default::default()));
+
+        let (tx, rx) = oneshot::channel();
+
+        ctx_handle.send(FromOverseer::Communication {
+            msg: RuntimeApiMessage::Request(
+                relay_parent,
+                Request::CandidatePendingAvailability(para_b, tx),
+            )
+        }).await;
+
+        assert_eq!(rx.await.unwrap().unwrap(), None);
+
+        ctx_handle.send(FromOverseer::Signal(OverseerSignal::Conclude)).await;
+    };
+
+    futures::executor::block_on(future::join(subsystem_task, test_task));
+}
+
+#[test]
+fn requests_candidate_events() {
+    let (ctx, mut ctx_handle) = test_helpers::make_subsystem_context(TaskExecutor::new());
+    let runtime_api = Arc::new(MockRuntimeApi::default());
+    let relay_parent = [1; 32].into();
+    let spawner = sp_core::testing::TaskExecutor::new();
+
+    let subsystem = RuntimeApiSubsystem::new(runtime_api.clone(), Metrics(None), spawner);
+    let subsystem_task = run(ctx, subsystem).map(|x| x.unwrap());
+    let test_task = async move {
+        let (tx, rx) = oneshot::channel();
+
+        ctx_handle.send(FromOverseer::Communication {
+            msg: RuntimeApiMessage::Request(relay_parent, Request::CandidateEvents(tx))
+        }).await;
+
+        assert_eq!(rx.await.unwrap().unwrap(), runtime_api.candidate_events);
+
+        ctx_handle.send(FromOverseer::Signal(OverseerSignal::Conclude)).await;
+    };
+
+    futures::executor::block_on(future::join(subsystem_task, test_task));
+}
+
+#[test]
+fn requests_dmq_contents() {
+    let (ctx, mut ctx_handle) = test_helpers::make_subsystem_context(TaskExecutor::new());
+
+    let relay_parent = [1; 32].into();
+    let para_a = 5.into();
+    let para_b = 6.into();
+    let spawner = sp_core::testing::TaskExecutor::new();
+
+    let runtime_api = Arc::new({
+        let mut runtime_api = MockRuntimeApi::default();
+
+        runtime_api.dmq_contents.insert(para_a, vec![]);
+        runtime_api.dmq_contents.insert(
+            para_b,
+            vec![InboundDownwardMessage {
+                sent_at: 228,
+                msg: b"Novus Ordo Seclorum".to_vec(),
+            }],
+        );
+
+        runtime_api
+    });
+
+    let subsystem = RuntimeApiSubsystem::new(runtime_api.clone(), Metrics(None), spawner);
+    let subsystem_task = run(ctx, subsystem).map(|x| x.unwrap());
+    let test_task = async move {
+        let (tx, rx) = oneshot::channel();
+        ctx_handle
+            .send(FromOverseer::Communication {
+                msg: RuntimeApiMessage::Request(relay_parent, Request::DmqContents(para_a, tx)),
+            })
+            .await;
+        assert_eq!(rx.await.unwrap().unwrap(), vec![]);
+
+        let (tx, rx) = oneshot::channel();
+        ctx_handle
+            .send(FromOverseer::Communication {
+                msg: RuntimeApiMessage::Request(relay_parent, Request::DmqContents(para_b, tx)),
+            })
+            .await;
+        assert_eq!(
+            rx.await.unwrap().unwrap(),
+            vec![InboundDownwardMessage {
+                sent_at: 228,
+                msg: b"Novus Ordo Seclorum".to_vec(),
+            }]
+        );
+
+        ctx_handle
+            .send(FromOverseer::Signal(OverseerSignal::Conclude))
+            .await;
+    };
+    futures::executor::block_on(future::join(subsystem_task, test_task));
+}
+
+#[test]
+fn requests_inbound_hrmp_channels_contents() {
+    let (ctx, mut ctx_handle) = test_helpers::make_subsystem_context(TaskExecutor::new());
+
+    let relay_parent = [1; 32].into();
+    let para_a = 99.into();
+    let para_b = 66.into();
+    let para_c = 33.into();
+    let spawner = sp_core::testing::TaskExecutor::new();
+
+    let para_b_inbound_channels = [
+        (para_a, vec![]),
+        (
+            para_c,
+            vec![InboundHrmpMessage {
+                sent_at: 1,
+                data: "𝙀=𝙈𝘾²".as_bytes().to_owned(),
+            }],
+        ),
+    ]
+    .iter()
+    .cloned()
+    .collect::<BTreeMap<_, _>>();
+
+    let runtime_api = Arc::new({
+        let mut runtime_api = MockRuntimeApi::default();
+
+        runtime_api.hrmp_channels.insert(para_a, BTreeMap::new());
+        runtime_api
+            .hrmp_channels
+            .insert(para_b, para_b_inbound_channels.clone());
+
+        runtime_api
+    });
+
+    let subsystem = RuntimeApiSubsystem::new(runtime_api.clone(), Metrics(None), spawner);
+    let subsystem_task = run(ctx, subsystem).map(|x| x.unwrap());
+    let test_task = async move {
+        let (tx, rx) = oneshot::channel();
+        ctx_handle
+            .send(FromOverseer::Communication {
+                msg: RuntimeApiMessage::Request(
+                    relay_parent,
+                    Request::InboundHrmpChannelsContents(para_a, tx),
+                ),
+            })
+            .await;
+        assert_eq!(rx.await.unwrap().unwrap(), BTreeMap::new());
+
+        let (tx, rx) = oneshot::channel();
+        ctx_handle
+            .send(FromOverseer::Communication {
+                msg: RuntimeApiMessage::Request(
+                    relay_parent,
+                    Request::InboundHrmpChannelsContents(para_b, tx),
+                ),
+            })
+            .await;
+        assert_eq!(rx.await.unwrap().unwrap(), para_b_inbound_channels,);
+
+        ctx_handle
+            .send(FromOverseer::Signal(OverseerSignal::Conclude))
+            .await;
+    };
+    futures::executor::block_on(future::join(subsystem_task, test_task));
+}
+
+#[test]
+fn requests_historical_code() {
+    let (ctx, mut ctx_handle) = test_helpers::make_subsystem_context(TaskExecutor::new());
+
+    let para_a = 5.into();
+    let para_b = 6.into();
+    let spawner = sp_core::testing::TaskExecutor::new();
+
+    let runtime_api = Arc::new({
+        let mut runtime_api = MockRuntimeApi::default();
+
+        runtime_api.historical_validation_code.insert(
+            para_a,
+            vec![(1, vec![1, 2, 3].into()), (10, vec![4, 5, 6].into())],
+        );
+
+        runtime_api.historical_validation_code.insert(
+            para_b,
+            vec![(5, vec![7, 8, 9].into())],
+        );
+
+        runtime_api
+    });
+    let relay_parent = [1; 32].into();
+
+    let subsystem = RuntimeApiSubsystem::new(runtime_api, Metrics(None), spawner);
+    let subsystem_task = run(ctx, subsystem).map(|x| x.unwrap());
+    let test_task = async move {
+        {
+            let (tx, rx) = oneshot::channel();
+            ctx_handle.send(FromOverseer::Communication {
+                msg: RuntimeApiMessage::Request(
+                    relay_parent,
+                    Request::HistoricalValidationCode(para_a, 5, tx),
+                )
+            }).await;
+
+            assert_eq!(rx.await.unwrap().unwrap(), Some(ValidationCode::from(vec![1, 2, 3])));
+        }
+
+        {
+            let (tx, rx) = oneshot::channel();
+            ctx_handle.send(FromOverseer::Communication {
+                msg: RuntimeApiMessage::Request(
+                    relay_parent,
+                    Request::HistoricalValidationCode(para_a, 10, tx),
+                )
+            }).await;
+
+            assert_eq!(rx.await.unwrap().unwrap(), Some(ValidationCode::from(vec![4, 5, 6])));
+        }
+
+        {
+            let (tx, rx) = oneshot::channel();
+            ctx_handle.send(FromOverseer::Communication {
+                msg: RuntimeApiMessage::Request(
+                    relay_parent,
+                    Request::HistoricalValidationCode(para_b, 1, tx),
+                )
+            }).await;
+
+            assert!(rx.await.unwrap().unwrap().is_none());
+        }
+
+        ctx_handle.send(FromOverseer::Signal(OverseerSignal::Conclude)).await;
+    };
+
+    futures::executor::block_on(future::join(subsystem_task, test_task));
+}
+
+#[test]
+fn multiple_requests_in_parallel_are_working() {
+    let (ctx, mut ctx_handle) = test_helpers::make_subsystem_context(TaskExecutor::new());
+    let runtime_api = Arc::new(MockRuntimeApi::default());
+    let relay_parent = [1; 32].into();
+    let spawner = sp_core::testing::TaskExecutor::new();
+    let mutex = runtime_api.availability_cores_wait.clone();
+
+    let subsystem = RuntimeApiSubsystem::new(runtime_api.clone(), Metrics(None), spawner);
+    let subsystem_task = run(ctx, subsystem).map(|x| x.unwrap());
+    let test_task = async move {
+        // Make all requests block until we release this mutex.
+        let lock = mutex.lock().unwrap();
+
+        let mut receivers = Vec::new();
+
+        for _ in 0..MAX_PARALLEL_REQUESTS * 10 {
+            let (tx, rx) = oneshot::channel();
+
+            ctx_handle.send(FromOverseer::Communication {
+                msg: RuntimeApiMessage::Request(relay_parent, Request::AvailabilityCores(tx))
+            }).await;
+
+            receivers.push(rx);
+        }
+
+        let join = future::join_all(receivers);
+
+        drop(lock);
+
+        join.await
+            .into_iter()
+            .for_each(|r| assert_eq!(r.unwrap().unwrap(), runtime_api.availability_cores));
+
+        ctx_handle.send(FromOverseer::Signal(OverseerSignal::Conclude)).await;
+    };
+
+    futures::executor::block_on(future::join(subsystem_task, test_task));
+}
+
+#[test]
+fn request_babe_epoch() {
+    let (ctx, mut ctx_handle) = test_helpers::make_subsystem_context(TaskExecutor::new());
+    let mut runtime_api = MockRuntimeApi::default();
+    let epoch = BabeEpoch {
+        epoch_index: 100,
+        start_slot: sp_consensus_babe::Slot::from(1000),
+        duration: 10,
+        authorities: Vec::new(),
+        randomness: [1u8; 32],
+        config: BabeEpochConfiguration {
+            c: (1, 4),
+            allowed_slots: BabeAllowedSlots::PrimarySlots,
+        },
+    };
+    runtime_api.babe_epoch = Some(epoch.clone());
+    let runtime_api = Arc::new(runtime_api);
+    let relay_parent = [1; 32].into();
+    let spawner = sp_core::testing::TaskExecutor::new();
+
+    let subsystem = RuntimeApiSubsystem::new(runtime_api.clone(), Metrics(None), spawner);
+    let subsystem_task = run(ctx, subsystem).map(|x| x.unwrap());
+    let test_task = async move {
+        let (tx, rx) = oneshot::channel();
+
+        ctx_handle.send(FromOverseer::Communication {
+            msg: RuntimeApiMessage::Request(relay_parent, Request::CurrentBabeEpoch(tx))
+        }).await;
+
+        assert_eq!(rx.await.unwrap().unwrap(), epoch);
+        ctx_handle.send(FromOverseer::Signal(OverseerSignal::Conclude)).await;
+    };
+
+    futures::executor::block_on(future::join(subsystem_task, test_task));
+}