Another integration test

runtime/test-runtime/src/lib.rs

@@ -546,15 +546,17 @@ pub mod pallet_test_notifier {
 
 	#[pallet::config]
 	pub trait Config: frame_system::Config + pallet_xcm::Config {
-		type Event: From<Event<Self>> + IsType<<Self as frame_system::Config>::Event>;
-		type Origin: From<<Self as frame_system::Config>::Origin>
+		type Event: IsType<<Self as frame_system::Config>::Event> + From<Event<Self>>;
+		type Origin: IsType<<Self as frame_system::Config>::Origin>
 			+ Into<Result<pallet_xcm::Origin, <Self as Config>::Origin>>;
-		type Call: From<Call<Self>> + Into<<Self as pallet_xcm::Config>::Call>;
+		type Call: IsType<<Self as pallet_xcm::Config>::Call> + From<Call<Self>>;
 	}
 
 	#[pallet::event]
 	#[pallet::generate_deposit(pub(super) fn deposit_event)]
 	pub enum Event<T: Config> {
+		QueryPrepared(QueryId),
+		NotifyQueryPrepared(QueryId),
 		ResponseReceived(MultiLocation, QueryId, Response),
 	}
 
@@ -566,30 +568,47 @@ pub mod pallet_test_notifier {
 
 	#[pallet::call]
 	impl<T: Config> Pallet<T> {
+
 		#[pallet::weight(1_000_000)]
-		pub fn notification_received(
+		pub fn prepare_new_query(
 			origin: OriginFor<T>,
-			query_id: QueryId,
-			response: Response,
 		) -> DispatchResult {
-			let responder = ensure_response(<T as Config>::Origin::from(origin))?;
-			Self::deposit_event(Event::<T>::ResponseReceived(responder, query_id, response));
+			let who = ensure_signed(origin)?;
+			let id = who.using_encoded(|mut d| <[u8; 32]>::decode(&mut d))
+				.map_err(|_| Error::<T>::BadAccountFormat)?;
+			let qid = pallet_xcm::Pallet::<T>::new_query(
+				Junction::AccountId32 { network: Any, id }.into(),
+				100u32.into(),
+			);
+			Self::deposit_event(Event::<T>::QueryPrepared(qid));
 			Ok(())
 		}
 
 		#[pallet::weight(1_000_000)]
-		pub fn prepare_for_notification(
+		pub fn prepare_new_notify_query(
 			origin: OriginFor<T>,
 		) -> DispatchResult {
 			let who = ensure_signed(origin)?;
 			let id = who.using_encoded(|mut d| <[u8; 32]>::decode(&mut d))
 				.map_err(|_| Error::<T>::BadAccountFormat)?;
+			let call = Call::<T>::notification_received(0, Default::default());
 			let qid = pallet_xcm::Pallet::<T>::new_notify_query(
 				Junction::AccountId32 { network: Any, id }.into(),
-				<T as Config>::Call::from(Call::<T>::notification_received(0, Response::Assets(sp_std::vec::Vec::new().into()))).into(),
-				0u32.into(),
+				<T as Config>::Call::from(call),
+				100u32.into(),
 			);
-			ensure!(qid == 0, Error::<T>::UnexpectedId);
+			Self::deposit_event(Event::<T>::NotifyQueryPrepared(qid));
+			Ok(())
+		}
+
+		#[pallet::weight(1_000_000)]
+		pub fn notification_received(
+			origin: OriginFor<T>,
+			query_id: QueryId,
+			response: Response,
+		) -> DispatchResult {
+			let responder = ensure_response(<T as Config>::Origin::from(origin))?;
+			Self::deposit_event(Event::<T>::ResponseReceived(responder, query_id, response));
 			Ok(())
 		}
 	}

xcm/pallet-xcm/src/lib.rs

@@ -109,11 +109,11 @@ pub mod pallet {
 		Attempted(xcm::latest::Outcome),
 		Sent(MultiLocation, MultiLocation, Xcm<()>),
 		UnexpectedResponse(MultiLocation, QueryId),
-		OnResponse(MultiLocation, QueryId, Response, Weight),
-		Notifying(QueryId, u8, u8),
-		NotifyOverweight(QueryId, Weight, Weight),
-		NotifyDispatchError(QueryId),
-		NotifyDecodeFailed(QueryId),
+		ResponseReceived(MultiLocation, QueryId, Response, Weight),
+		Notified(QueryId, u8, u8),
+		NotifyOverweight(QueryId, u8, u8, Weight, Weight),
+		NotifyDispatchError(QueryId, u8, u8),
+		NotifyDecodeFailed(QueryId, u8, u8),
 		InvalidResponder(MultiLocation, QueryId, MultiLocation),
 		InvalidResponderVersion(MultiLocation, QueryId),
 	}
@@ -151,7 +151,7 @@ pub mod pallet {
 	}
 
 	/// The status of a query.
-	#[derive(Clone, Eq, PartialEq, Encode, Decode)]
+	#[derive(Clone, Eq, PartialEq, Encode, Decode, RuntimeDebug)]
 	pub enum QueryStatus<BlockNumber> {
 		/// The query was sent but no response has yet been received.
 		Pending {
@@ -172,6 +172,7 @@ pub mod pallet {
 
 	/// The ongoing queries.
 	#[pallet::storage]
+	#[pallet::getter(fn query)]
 	pub(super) type Queries<T: Config> =
 		StorageMap<_, Blake2_128Concat, QueryId, QueryStatus<T::BlockNumber>, OptionQuery>;
 
@@ -429,11 +430,8 @@ pub mod pallet {
 	impl<T: Config> OnResponse for Pallet<T> {
 		/// Returns `true` if we are expecting a response from `origin` for query `query_id`.
 		fn expecting_response(origin: &MultiLocation, query_id: QueryId) -> bool {
-
 			if let Some(QueryStatus::Pending { responder, .. }) = Queries::<T>::get(query_id) {
 				return MultiLocation::try_from(responder).map_or(false, |r| origin == &r)
-			} else {
-				Self::deposit_event(Event::UnexpectedResponse(origin.clone(), query_id));
 			}
 			false
 		}
@@ -445,15 +443,15 @@ pub mod pallet {
 			response: Response,
 			max_weight: Weight,
 		) -> Weight {
-			Self::deposit_event(Event::OnResponse(origin.clone(), query_id, response.clone(), max_weight));
+			let e = Event::ResponseReceived(origin.clone(), query_id, response.clone(), max_weight);
+			Self::deposit_event(e);
 			if let Some(QueryStatus::Pending { responder, maybe_notify, .. }) =
 				Queries::<T>::get(query_id)
 			{
 				if let Ok(responder) = MultiLocation::try_from(responder) {
 					if origin == &responder {
 						return match maybe_notify {
 							Some((pallet_index, call_index)) => {
-								Self::deposit_event(Event::Notifying(query_id, pallet_index, call_index));
 								// This is a bit horrible, but we happen to know that the `Call` will
 								// be built by `(pallet_index: u8, call_index: u8, QueryId, Response)`.
 								// So we just encode that and then re-encode to a real Call.
@@ -463,22 +461,35 @@ pub mod pallet {
 								{
 									let weight = call.get_dispatch_info().weight;
 									if weight > max_weight {
-										Self::deposit_event(Event::NotifyOverweight(query_id, weight, max_weight));
+										let e = Event::NotifyOverweight(
+											query_id,
+											pallet_index,
+											call_index,
+											weight,
+											max_weight,
+										);
+										Self::deposit_event(e);
 										return 0
 									}
 									let dispatch_origin = Origin::Response(origin.clone()).into();
 									match call.dispatch(dispatch_origin) {
-										Ok(post_info) => post_info.actual_weight,
+										Ok(post_info) => {
+											let e = Event::Notified(query_id, pallet_index, call_index);
+											Self::deposit_event(e);
+											post_info.actual_weight
+										},
 										Err(error_and_info) => {
-											Self::deposit_event(Event::NotifyDispatchError(query_id));
+											let e = Event::NotifyDispatchError(query_id, pallet_index, call_index);
+											Self::deposit_event(e);
 											// Not much to do with the result as it is. It's up to the parachain to ensure that the
 											// message makes sense.
 											error_and_info.post_info.actual_weight
 										},
 									}
 									.unwrap_or(weight)
 								} else {
-									Self::deposit_event(Event::NotifyDecodeFailed(query_id));
+									let e = Event::NotifyDecodeFailed(query_id, pallet_index, call_index);
+									Self::deposit_event(e);
 									0
 								}
 							},

xcm/src/v2/mod.rs

@@ -80,12 +80,20 @@ pub mod prelude {
 /// Response data to a query.
 #[derive(Clone, Eq, PartialEq, Encode, Decode, Debug)]
 pub enum Response {
+	/// No response. Serves as a neutral default.
+	Null,
 	/// Some assets.
 	Assets(MultiAssets),
 	/// The outcome of an XCM instruction.
 	ExecutionResult(result::Result<(), (u32, Error)>),
 }
 
+impl Default for Response {
+	fn default() -> Self {
+		Self::Null
+	}
+}
+
 /// An optional weight limit.
 #[derive(Clone, Eq, PartialEq, Encode, Decode, Debug)]
 pub enum WeightLimit {

xcm/xcm-executor/integration-tests/src/lib.rs

@@ -70,30 +70,140 @@ fn basic_buy_fees_message_executes() {
 		});
 }
 
-
 #[test]
-fn query_response_elicits_handler() {
+fn query_response_fires() {
+	use polkadot_test_runtime::Event::TestNotifier;
+	use pallet_test_notifier::Event::*;
+	use pallet_xcm::QueryStatus;
+
 	sp_tracing::try_init_simple();
 	let mut client = TestClientBuilder::new()
 		.set_execution_strategy(ExecutionStrategy::AlwaysWasm)
 		.build();
 
+	let mut block_builder = client.init_polkadot_block_builder();
+
+	let execute = construct_extrinsic(
+		&client,
+		polkadot_test_runtime::Call::TestNotifier(pallet_test_notifier::Call::prepare_new_query()),
+		sp_keyring::Sr25519Keyring::Alice,
+		0,
+	);
+
+	block_builder.push_polkadot_extrinsic(execute).expect("pushes extrinsic");
+
+	let block = block_builder.build().expect("Finalizes the block").block;
+	let block_hash = block.hash();
+
+	futures::executor::block_on(client.import(sp_consensus::BlockOrigin::Own, block))
+		.expect("imports the block");
+
+	let mut query_id = None;
+	client
+		.state_at(&BlockId::Hash(block_hash))
+		.expect("state should exist")
+		.inspect_state(|| {
+			for r in polkadot_test_runtime::System::events().iter() {
+				match r.event {
+					TestNotifier(QueryPrepared(q)) => query_id = Some(q),
+					_ => (),
+				}
+			}
+		});
+	let query_id = query_id.unwrap();
+
+	let mut block_builder = client.init_polkadot_block_builder();
+
 	let response = Response::ExecutionResult(Ok(()));
-	let msg = Xcm(vec![
-		QueryResponse { query_id: 0, response, max_weight: 1_000_000 },
-	]);
+	let max_weight = 1_000_000;
+	let msg = Xcm(vec![QueryResponse { query_id, response, max_weight }]);
+
+	let execute = construct_extrinsic(
+		&client,
+		polkadot_test_runtime::Call::Xcm(pallet_xcm::Call::execute(msg, 1_000_000_000)),
+		sp_keyring::Sr25519Keyring::Alice,
+		1,
+	);
+
+	block_builder.push_polkadot_extrinsic(execute).expect("pushes extrinsic");
+
+	let block = block_builder.build().expect("Finalizes the block").block;
+	let block_hash = block.hash();
+
+	futures::executor::block_on(client.import(sp_consensus::BlockOrigin::Own, block))
+		.expect("imports the block");
+
+	client
+		.state_at(&BlockId::Hash(block_hash))
+		.expect("state should exist")
+		.inspect_state(|| {
+			assert!(polkadot_test_runtime::System::events().iter().any(|r| matches!(
+				r.event,
+				polkadot_test_runtime::Event::Xcm(pallet_xcm::Event::ResponseReceived(
+					MultiLocation { parents: 0, interior: X1(Junction::AccountId32 { .. }) },
+					q,
+					Response::ExecutionResult(Ok(())),
+					1_000_000,
+				)) if q == query_id,
+			)));
+			assert_eq!(
+				polkadot_test_runtime::Xcm::query(query_id),
+				Some(QueryStatus::Ready {
+					response: Response::ExecutionResult(Ok(())),
+					at: 2u32.into()
+				}),
+			)
+		});
+}
+
+#[test]
+fn query_response_elicits_handler() {
+	use polkadot_test_runtime::Event::TestNotifier;
+	use pallet_test_notifier::Event::*;
+
+	sp_tracing::try_init_simple();
+	let mut client = TestClientBuilder::new()
+		.set_execution_strategy(ExecutionStrategy::AlwaysWasm)
+		.build();
 
 	let mut block_builder = client.init_polkadot_block_builder();
 
 	let execute = construct_extrinsic(
 		&client,
-		polkadot_test_runtime::Call::TestNotifier(pallet_test_notifier::Call::prepare_for_notification()),
+		polkadot_test_runtime::Call::TestNotifier(pallet_test_notifier::Call::prepare_new_notify_query()),
 		sp_keyring::Sr25519Keyring::Alice,
 		0,
 	);
 
 	block_builder.push_polkadot_extrinsic(execute).expect("pushes extrinsic");
 
+	let block = block_builder.build().expect("Finalizes the block").block;
+	let block_hash = block.hash();
+
+	futures::executor::block_on(client.import(sp_consensus::BlockOrigin::Own, block))
+		.expect("imports the block");
+
+	let mut query_id = None;
+	client
+		.state_at(&BlockId::Hash(block_hash))
+		.expect("state should exist")
+		.inspect_state(|| {
+			dbg!(polkadot_test_runtime::System::events());
+			for r in polkadot_test_runtime::System::events().iter() {
+				match r.event {
+					TestNotifier(NotifyQueryPrepared(q)) => query_id = Some(q),
+					_ => (),
+				}
+			}
+		});
+	let query_id = query_id.unwrap();
+
+	let mut block_builder = client.init_polkadot_block_builder();
+
+	let response = Response::ExecutionResult(Ok(()));
+	let max_weight = 1_000_000;
+	let msg = Xcm(vec![QueryResponse { query_id, response, max_weight }]);
+
 	let execute = construct_extrinsic(
 		&client,
 		polkadot_test_runtime::Call::Xcm(pallet_xcm::Call::execute(msg, 1_000_000_000)),
@@ -113,16 +223,13 @@ fn query_response_elicits_handler() {
 		.state_at(&BlockId::Hash(block_hash))
 		.expect("state should exist")
 		.inspect_state(|| {
-			dbg!(polkadot_test_runtime::System::events());
 			assert!(polkadot_test_runtime::System::events().iter().any(|r| matches!(
 				r.event,
-				polkadot_test_runtime::Event::TestNotifier(
-					pallet_test_notifier::Event::ResponseReceived(
-						MultiLocation { parents: 0, interior: X1(Junction::AccountId32 { .. }) },
-						0,
-						Response::ExecutionResult(Ok(())),
-					),
-				)
+				TestNotifier(ResponseReceived(
+					MultiLocation { parents: 0, interior: X1(Junction::AccountId32 { .. }) },
+					q,
+					Response::ExecutionResult(Ok(())),
+				)) if q == query_id,
 			)));
 		});
 }