Contracts: Refactor test builder (#4158)

- Moved `substrate/frame/contracts/src/tests/builder.rs` into a pub
test_utils module, so we can use that in the
`pallet-contracts-mock-network` tests
- Refactor xcm tests to use XCM builders, and simplify the use case for
xcm-send

substrate/frame/contracts/src/lib.rs

@@ -101,6 +101,7 @@ mod wasm;
 pub mod chain_extension;
 pub mod debug;
 pub mod migration;
+pub mod test_utils;
 pub mod weights;
 
 #[cfg(test)]

substrate/frame/contracts/src/test_utils.rs

@@ -0,0 +1,30 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//! Shared utilities for testing contracts.
+//! This is not part of the tests module because it is made public for other crates to use.
+#![cfg(feature = "std")]
+use frame_support::weights::Weight;
+pub use sp_runtime::AccountId32;
+
+pub const ALICE: AccountId32 = AccountId32::new([1u8; 32]);
+pub const BOB: AccountId32 = AccountId32::new([2u8; 32]);
+pub const CHARLIE: AccountId32 = AccountId32::new([3u8; 32]);
+pub const DJANGO: AccountId32 = AccountId32::new([4u8; 32]);
+
+pub const GAS_LIMIT: Weight = Weight::from_parts(100_000_000_000, 3 * 1024 * 1024);
+pub mod builder;

substrate/frame/contracts/src/test_utils/builder.rs

@@ -0,0 +1,220 @@
+// This file is part of Substrate.
+
+// Copyright (C) Parity Technologies (UK) Ltd.
+// SPDX-License-Identifier: Apache-2.0
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// 	http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+use super::GAS_LIMIT;
+use crate::{
+	AccountIdLookupOf, AccountIdOf, BalanceOf, Code, CodeHash, CollectEvents, Config,
+	ContractExecResult, ContractInstantiateResult, DebugInfo, Determinism, EventRecordOf,
+	ExecReturnValue, InstantiateReturnValue, OriginFor, Pallet, Weight,
+};
+use codec::{Encode, HasCompact};
+use core::fmt::Debug;
+use frame_support::pallet_prelude::DispatchResultWithPostInfo;
+use paste::paste;
+use scale_info::TypeInfo;
+
+/// Helper macro to generate a builder for contract API calls.
+macro_rules! builder {
+	// Entry point to generate a builder for the given method.
+	(
+		$method:ident($($field:ident: $type:ty,)*) -> $result:ty;
+        $($extra:item)*
+	) => {
+		paste!{
+			builder!([< $method:camel Builder >], $method($($field: $type,)* ) -> $result; $($extra)*);
+		}
+	};
+	// Generate the builder struct and its methods.
+	(
+		$name:ident,
+		$method:ident($($field:ident: $type:ty,)*) -> $result:ty;
+        $($extra:item)*
+	) => {
+		#[doc = concat!("A builder to construct a ", stringify!($method), " call")]
+		pub struct $name<T: Config> {
+			$($field: $type,)*
+		}
+
+		#[allow(dead_code)]
+		impl<T: Config> $name<T>
+		where
+			<BalanceOf<T> as HasCompact>::Type: Clone + Eq + PartialEq + Debug + TypeInfo + Encode,
+		{
+			$(
+				#[doc = concat!("Set the ", stringify!($field))]
+				pub fn $field(mut self, value: $type) -> Self {
+					self.$field = value;
+					self
+				}
+			)*
+
+			#[doc = concat!("Build the ", stringify!($method), " call")]
+			pub fn build(self) -> $result {
+				Pallet::<T>::$method(
+					$(self.$field,)*
+				)
+			}
+
+            $($extra)*
+		}
+	}
+}
+
+builder!(
+	instantiate_with_code(
+		origin: OriginFor<T>,
+		value: BalanceOf<T>,
+		gas_limit: Weight,
+		storage_deposit_limit: Option<<BalanceOf<T> as codec::HasCompact>::Type>,
+		code: Vec<u8>,
+		data: Vec<u8>,
+		salt: Vec<u8>,
+	) -> DispatchResultWithPostInfo;
+
+	/// Create an [`InstantiateWithCodeBuilder`] with default values.
+	pub fn instantiate_with_code(origin: OriginFor<T>, code: Vec<u8>) -> Self {
+		Self {
+			origin: origin,
+			value: 0u32.into(),
+			gas_limit: GAS_LIMIT,
+			storage_deposit_limit: None,
+			code,
+			data: vec![],
+			salt: vec![],
+		}
+	}
+);
+
+builder!(
+	instantiate(
+		origin: OriginFor<T>,
+		value: BalanceOf<T>,
+		gas_limit: Weight,
+		storage_deposit_limit: Option<<BalanceOf<T> as codec::HasCompact>::Type>,
+		code_hash: CodeHash<T>,
+		data: Vec<u8>,
+		salt: Vec<u8>,
+	) -> DispatchResultWithPostInfo;
+
+	/// Create an [`InstantiateBuilder`] with default values.
+	pub fn instantiate(origin: OriginFor<T>, code_hash: CodeHash<T>) -> Self {
+		Self {
+			origin,
+			value: 0u32.into(),
+			gas_limit: GAS_LIMIT,
+			storage_deposit_limit: None,
+			code_hash,
+			data: vec![],
+			salt: vec![],
+		}
+	}
+);
+
+builder!(
+	bare_instantiate(
+		origin: AccountIdOf<T>,
+		value: BalanceOf<T>,
+		gas_limit: Weight,
+		storage_deposit_limit: Option<BalanceOf<T>>,
+		code: Code<CodeHash<T>>,
+		data: Vec<u8>,
+		salt: Vec<u8>,
+		debug: DebugInfo,
+		collect_events: CollectEvents,
+	) -> ContractInstantiateResult<AccountIdOf<T>, BalanceOf<T>, EventRecordOf<T>>;
+
+	/// Build the instantiate call and unwrap the result.
+	pub fn build_and_unwrap_result(self) -> InstantiateReturnValue<AccountIdOf<T>> {
+		self.build().result.unwrap()
+	}
+
+	/// Build the instantiate call and unwrap the account id.
+	pub fn build_and_unwrap_account_id(self) -> AccountIdOf<T> {
+		self.build().result.unwrap().account_id
+	}
+
+	pub fn bare_instantiate(origin: AccountIdOf<T>, code: Code<CodeHash<T>>) -> Self {
+		Self {
+			origin,
+			value: 0u32.into(),
+			gas_limit: GAS_LIMIT,
+			storage_deposit_limit: None,
+			code,
+			data: vec![],
+			salt: vec![],
+			debug: DebugInfo::Skip,
+			collect_events: CollectEvents::Skip,
+		}
+	}
+);
+
+builder!(
+	call(
+		origin: OriginFor<T>,
+		dest: AccountIdLookupOf<T>,
+		value: BalanceOf<T>,
+		gas_limit: Weight,
+		storage_deposit_limit: Option<<BalanceOf<T> as codec::HasCompact>::Type>,
+		data: Vec<u8>,
+	) -> DispatchResultWithPostInfo;
+
+	/// Create a [`CallBuilder`] with default values.
+	pub fn call(origin: OriginFor<T>, dest: AccountIdLookupOf<T>) -> Self {
+		CallBuilder {
+			origin,
+			dest,
+			value: 0u32.into(),
+			gas_limit: GAS_LIMIT,
+			storage_deposit_limit: None,
+			data: vec![],
+		}
+	}
+);
+
+builder!(
+	bare_call(
+		origin: AccountIdOf<T>,
+		dest: AccountIdOf<T>,
+		value: BalanceOf<T>,
+		gas_limit: Weight,
+		storage_deposit_limit: Option<BalanceOf<T>>,
+		data: Vec<u8>,
+		debug: DebugInfo,
+		collect_events: CollectEvents,
+		determinism: Determinism,
+	) -> ContractExecResult<BalanceOf<T>, EventRecordOf<T>>;
+
+	/// Build the call and unwrap the result.
+	pub fn build_and_unwrap_result(self) -> ExecReturnValue {
+		self.build().result.unwrap()
+	}
+
+	/// Create a [`BareCallBuilder`] with default values.
+	pub fn bare_call(origin: AccountIdOf<T>, dest: AccountIdOf<T>) -> Self {
+		Self {
+			origin,
+			dest,
+			value: 0u32.into(),
+			gas_limit: GAS_LIMIT,
+			storage_deposit_limit: None,
+			data: vec![],
+			debug: DebugInfo::Skip,
+			collect_events: CollectEvents::Skip,
+			determinism: Determinism::Enforced,
+		}
+	}
+);

substrate/frame/contracts/src/tests.rs

@@ -15,7 +15,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-mod builder;
 mod pallet_dummy;
 mod test_debug;
 
@@ -98,7 +97,6 @@ macro_rules! assert_refcount {
 }
 
 pub mod test_utils {
-
 	use super::{Contracts, DepositPerByte, DepositPerItem, Hash, SysConfig, Test};
 	use crate::{
 		exec::AccountIdOf, BalanceOf, CodeHash, CodeInfo, CodeInfoOf, Config, ContractInfo,
@@ -166,6 +164,38 @@ pub mod test_utils {
 	}
 }
 
+mod builder {
+	use super::Test;
+	use crate::{
+		test_utils::{builder::*, AccountId32, ALICE},
+		tests::RuntimeOrigin,
+		AccountIdLookupOf, Code, CodeHash,
+	};
+
+	pub fn bare_instantiate(code: Code<CodeHash<Test>>) -> BareInstantiateBuilder<Test> {
+		BareInstantiateBuilder::<Test>::bare_instantiate(ALICE, code)
+	}
+
+	pub fn bare_call(dest: AccountId32) -> BareCallBuilder<Test> {
+		BareCallBuilder::<Test>::bare_call(ALICE, dest)
+	}
+
+	pub fn instantiate_with_code(code: Vec<u8>) -> InstantiateWithCodeBuilder<Test> {
+		InstantiateWithCodeBuilder::<Test>::instantiate_with_code(
+			RuntimeOrigin::signed(ALICE),
+			code,
+		)
+	}
+
+	pub fn instantiate(code_hash: CodeHash<Test>) -> InstantiateBuilder<Test> {
+		InstantiateBuilder::<Test>::instantiate(RuntimeOrigin::signed(ALICE), code_hash)
+	}
+
+	pub fn call(dest: AccountIdLookupOf<Test>) -> CallBuilder<Test> {
+		CallBuilder::<Test>::call(RuntimeOrigin::signed(ALICE), dest)
+	}
+}
+
 impl Test {
 	pub fn set_unstable_interface(unstable_interface: bool) {
 		UNSTABLE_INTERFACE.with(|v| *v.borrow_mut() = unstable_interface);
@@ -2439,14 +2469,7 @@ fn failed_deposit_charge_should_roll_back_call() {
 				transfer_proxy_call,
 			);
 
-			<Pallet<Test>>::call(
-				RuntimeOrigin::signed(ALICE),
-				addr_caller.clone(),
-				0,
-				GAS_LIMIT,
-				None,
-				data.encode(),
-			)
+			builder::call(addr_caller).data(data.encode()).build()
 		})
 	};
 

substrate/frame/contracts/src/tests/builder.rs

@@ -1,219 +0,0 @@
-// This file is part of Substrate.
-
-// Copyright (C) Parity Technologies (UK) Ltd.
-// SPDX-License-Identifier: Apache-2.0
-
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// 	http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-use super::{AccountId32, Test, ALICE, GAS_LIMIT};
-use crate::{
-	tests::RuntimeOrigin, AccountIdLookupOf, AccountIdOf, BalanceOf, Code, CodeHash, CollectEvents,
-	ContractExecResult, ContractInstantiateResult, DebugInfo, Determinism, EventRecordOf,
-	ExecReturnValue, OriginFor, Pallet, Weight,
-};
-use codec::Compact;
-use frame_support::pallet_prelude::DispatchResultWithPostInfo;
-use paste::paste;
-
-/// Helper macro to generate a builder for contract API calls.
-macro_rules! builder {
-	// Entry point to generate a builder for the given method.
-	(
-		$method:ident($($field:ident: $type:ty,)*) -> $result:ty
-	) => {
-		paste!{
-			builder!([< $method:camel Builder >], $method($($field: $type,)* ) -> $result);
-		}
-	};
-	// Generate the builder struct and its methods.
-	(
-		$name:ident,
-		$method:ident(
-			$($field:ident: $type:ty,)*
-		) -> $result:ty
-	) => {
-		#[doc = concat!("A builder to construct a ", stringify!($method), " call")]
-		pub struct $name {
-			$($field: $type,)*
-		}
-
-		#[allow(dead_code)]
-		impl $name
-		{
-			$(
-				#[doc = concat!("Set the ", stringify!($field))]
-				pub fn $field(mut self, value: $type) -> Self {
-					self.$field = value;
-					self
-				}
-			)*
-
-			#[doc = concat!("Build the ", stringify!($method), " call")]
-			pub fn build(self) -> $result {
-				Pallet::<Test>::$method(
-					$(self.$field,)*
-				)
-			}
-		}
-	}
-}
-
-builder!(
-	instantiate_with_code(
-		origin: OriginFor<Test>,
-		value: BalanceOf<Test>,
-		gas_limit: Weight,
-		storage_deposit_limit: Option<Compact<BalanceOf<Test>>>,
-		code: Vec<u8>,
-		data: Vec<u8>,
-		salt: Vec<u8>,
-	) -> DispatchResultWithPostInfo
-);
-
-builder!(
-	instantiate(
-		origin: OriginFor<Test>,
-		value: BalanceOf<Test>,
-		gas_limit: Weight,
-		storage_deposit_limit: Option<Compact<BalanceOf<Test>>>,
-		code_hash: CodeHash<Test>,
-		data: Vec<u8>,
-		salt: Vec<u8>,
-	) -> DispatchResultWithPostInfo
-);
-
-builder!(
-	bare_instantiate(
-		origin: AccountIdOf<Test>,
-		value: BalanceOf<Test>,
-		gas_limit: Weight,
-		storage_deposit_limit: Option<BalanceOf<Test>>,
-		code: Code<CodeHash<Test>>,
-		data: Vec<u8>,
-		salt: Vec<u8>,
-		debug: DebugInfo,
-		collect_events: CollectEvents,
-	) -> ContractInstantiateResult<AccountIdOf<Test>, BalanceOf<Test>, EventRecordOf<Test>>
-);
-
-builder!(
-	call(
-		origin: OriginFor<Test>,
-		dest: AccountIdLookupOf<Test>,
-		value: BalanceOf<Test>,
-		gas_limit: Weight,
-		storage_deposit_limit: Option<Compact<BalanceOf<Test>>>,
-		data: Vec<u8>,
-	) -> DispatchResultWithPostInfo
-);
-
-builder!(
-	bare_call(
-		origin: AccountIdOf<Test>,
-		dest: AccountIdOf<Test>,
-		value: BalanceOf<Test>,
-		gas_limit: Weight,
-		storage_deposit_limit: Option<BalanceOf<Test>>,
-		data: Vec<u8>,
-		debug: DebugInfo,
-		collect_events: CollectEvents,
-		determinism: Determinism,
-	) -> ContractExecResult<BalanceOf<Test>, EventRecordOf<Test>>
-);
-
-/// Create a [`BareInstantiateBuilder`] with default values.
-pub fn bare_instantiate(code: Code<CodeHash<Test>>) -> BareInstantiateBuilder {
-	BareInstantiateBuilder {
-		origin: ALICE,
-		value: 0,
-		gas_limit: GAS_LIMIT,
-		storage_deposit_limit: None,
-		code,
-		data: vec![],
-		salt: vec![],
-		debug: DebugInfo::Skip,
-		collect_events: CollectEvents::Skip,
-	}
-}
-
-impl BareInstantiateBuilder {
-	/// Build the instantiate call and unwrap the result.
-	pub fn build_and_unwrap_result(self) -> crate::InstantiateReturnValue<AccountIdOf<Test>> {
-		self.build().result.unwrap()
-	}
-
-	/// Build the instantiate call and unwrap the account id.
-	pub fn build_and_unwrap_account_id(self) -> AccountIdOf<Test> {
-		self.build().result.unwrap().account_id
-	}
-}
-
-/// Create a [`BareCallBuilder`] with default values.
-pub fn bare_call(dest: AccountId32) -> BareCallBuilder {
-	BareCallBuilder {
-		origin: ALICE,
-		dest,
-		value: 0,
-		gas_limit: GAS_LIMIT,
-		storage_deposit_limit: None,
-		data: vec![],
-		debug: DebugInfo::Skip,
-		collect_events: CollectEvents::Skip,
-		determinism: Determinism::Enforced,
-	}
-}
-
-impl BareCallBuilder {
-	/// Build the call and unwrap the result.
-	pub fn build_and_unwrap_result(self) -> ExecReturnValue {
-		self.build().result.unwrap()
-	}
-}
-
-/// Create an [`InstantiateWithCodeBuilder`] with default values.
-pub fn instantiate_with_code(code: Vec<u8>) -> InstantiateWithCodeBuilder {
-	InstantiateWithCodeBuilder {
-		origin: RuntimeOrigin::signed(ALICE),
-		value: 0,
-		gas_limit: GAS_LIMIT,
-		storage_deposit_limit: None,
-		code,
-		data: vec![],
-		salt: vec![],
-	}
-}
-
-/// Create an [`InstantiateBuilder`] with default values.
-pub fn instantiate(code_hash: CodeHash<Test>) -> InstantiateBuilder {
-	InstantiateBuilder {
-		origin: RuntimeOrigin::signed(ALICE),
-		value: 0,
-		gas_limit: GAS_LIMIT,
-		storage_deposit_limit: None,
-		code_hash,
-		data: vec![],
-		salt: vec![],
-	}
-}
-
-/// Create a [`CallBuilder`] with default values.
-pub fn call(dest: AccountIdLookupOf<Test>) -> CallBuilder {
-	CallBuilder {
-		origin: RuntimeOrigin::signed(ALICE),
-		dest,
-		value: 0,
-		gas_limit: GAS_LIMIT,
-		storage_deposit_limit: None,
-		data: vec![],
-	}
-}