Trying to get the tests back working

cumulus/runtime/src/validate_block/tests.rs

@@ -14,47 +14,42 @@
 // You should have received a copy of the GNU General Public License
 // along with Cumulus.  If not, see <http://www.gnu.org/licenses/>.
 
-use crate::ParachainBlock;
+use crate::{ParachainBlockData, WitnessData};
 
-use rio::{twox_128, TestExternalities};
+use rio::TestExternalities;
 use keyring::AccountKeyring;
-use primitives::map;
-use runtime_primitives::traits::Block as BlockT;
+use primitives::{storage::well_known_keys};
+use runtime_primitives::traits::{Block as BlockT, Header as HeaderT};
 use executor::{WasmExecutor, error::Result, wasmi::RuntimeValue::{I64, I32}};
-use test_runtime::{Block, Header, Transfer};
+use test_client::{
+	TestClientBuilder, TestClient,
+	runtime::{Block, Transfer}, TestClientBuilderExt,
+};
 
-use std::collections::BTreeMap;
+use std::collections::HashMap;
 
-use codec::{KeyedVec, Encode};
+use codec::Encode;
 
 const WASM_CODE: &[u8] =
-	include_bytes!("../../test-runtime/wasm/target/wasm32-unknown-unknown/release/cumulus_test_runtime.compact.wasm");
+	include_bytes!("../../../test/runtime/wasm/target/wasm32-unknown-unknown/release/cumulus_test_runtime.compact.wasm");
 
-fn create_witness_data() -> BTreeMap<Vec<u8>, Vec<u8>> {
-	map![
-		twox_128(&AccountKeyring::Alice.to_raw_public().to_keyed_vec(b"balance:")).to_vec() => vec![111u8, 0, 0, 0, 0, 0, 0, 0]
-	]
-}
-
-fn call_validate_block(block: ParachainBlock<Block>, prev_header: <Block as BlockT>::Header) -> Result<()> {
+fn call_validate_block(block_data: ParachainBlockData<Block>) -> Result<()> {
 	let mut ext = TestExternalities::default();
 	WasmExecutor::new().call_with_custom_signature(
 		&mut ext,
-		8,
+		1024,
 		&WASM_CODE,
 		"validate_block",
 		|alloc| {
-			let block = block.encode();
-			let prev_header = prev_header.encode();
-			let block_offset = alloc(&block)?;
-			let prev_head_offset = alloc(&prev_header)?;
+			let block_data = block_data.encode();
+			println!("ALLOC: {}", block_data.len());
+			let block_data_offset = alloc(&block_data)?;
+			println!("ALLOC");
 
 			Ok(
 				vec![
-					I32(block_offset as i32),
-					I64(block.len() as i64),
-					I32(prev_head_offset as i32),
-					I64(prev_header.len() as i64),
+					I32(block_data_offset as i32),
+					I64(block_data.len() as i64),
 				]
 			)
 		},
@@ -79,34 +74,62 @@ fn create_extrinsics() -> Vec<<Block as BlockT>::Extrinsic> {
 	]
 }
 
-fn create_prev_header() -> Header {
-	Header {
-		parent_hash: Default::default(),
-		number: 1,
-		state_root: Default::default(),
-		extrinsics_root: Default::default(),
-		digest: Default::default(),
-	}
+fn create_test_client() -> TestClient {
+	let mut genesis_extension = HashMap::new();
+	genesis_extension.insert(well_known_keys::CODE.to_vec(), WASM_CODE.to_vec());
+
+	TestClientBuilder::new()
+		.set_genesis_extension(genesis_extension)
+		.build_cumulus()
+}
+
+fn build_block_with_proof(
+	client: &TestClient,
+	extrinsics: Vec<<Block as BlockT>::Extrinsic>,
+) -> (Block, WitnessData) {
+	let mut builder = client.new_block().expect("Initializes new block");
+	builder.record_proof();
+
+	extrinsics.into_iter().for_each(|e| builder.push(e).expect("Pushes an extrinsic"));
+
+	let (block, proof) = builder
+		.bake_and_extract_proof()
+		.expect("Finalizes block");
+
+	(block, proof.expect("We enabled proof recording before."))
 }
 
 #[test]
 fn validate_block_with_empty_block() {
-	let prev_header = create_prev_header();
-	call_validate_block(ParachainBlock::default(), prev_header).expect("Calls `validate_block`");
+	let client = create_test_client();
+	let witness_data_storage_root = *client
+		.best_block_header()
+		.expect("Best block exists")
+		.state_root();
+	let (block, witness_data) = build_block_with_proof(&client, Vec::new());
+	let (header, extrinsics) = block.deconstruct();
+
+	let block_data = ParachainBlockData::new(
+		header,
+		extrinsics,
+		witness_data,
+		witness_data_storage_root
+	);
+	call_validate_block(block_data).expect("Calls `validate_block`");
 }
 
-#[test]
-fn validate_block_with_empty_witness_data() {
-	let prev_header = create_prev_header();
+// #[test]
+// fn validate_block_with_empty_witness_data() {
+// 	let prev_header = create_header();
 
-	let block = ParachainBlock::new(create_extrinsics(), Default::default());
-	assert!(call_validate_block(block, prev_header).is_err());
-}
+// 	let block = ParachainBlock::new(create_extrinsics(), Default::default());
+// 	assert!(call_validate_block(block).is_err());
+// }
 
-#[test]
-fn validate_block_with_witness_data() {
-	let prev_header = create_prev_header();
+// #[test]
+// fn validate_block_with_witness_data() {
+// 	let prev_header = create_header();
 
-	let block = ParachainBlock::new(create_extrinsics(), create_witness_data());
-	call_validate_block(block, prev_header).expect("`validate_block` succeeds");
-}
+// 	let block = ParachainBlock::new(create_extrinsics(), create_witness_data());
+// 	call_validate_block(block).expect("`validate_block` succeeds");
+// }