Dry out author rpc tests (#3878)

2026-06-12 17:01:09 +00:00 · 2019-10-22 16:53:20 +03:00
parent 378ea9db2f
commit 5a40da5cba
1 changed files with 60 additions and 89 deletions
@@ -20,13 +20,13 @@ use std::sync::Arc;
 use assert_matches::assert_matches;
 use codec::Encode;
 use primitives::{
-	H256, blake2_256, hexdisplay::HexDisplay, testing::{ED25519, SR25519, KeyStore}, ed25519,
+	H256, blake2_256, hexdisplay::HexDisplay, testing::{ED25519, SR25519, KeyStore}, traits::BareCryptoStorePtr, ed25519,
 	crypto::Pair,
 };
 use rpc::futures::Stream as _;
 use test_client::{
-	self, AccountKeyring, runtime::{Extrinsic, Transfer, SessionKeys}, DefaultTestClientBuilderExt,
-	TestClientBuilderExt,
+	self, AccountKeyring, runtime::{Extrinsic, Transfer, SessionKeys, RuntimeApi, Block}, DefaultTestClientBuilderExt,
+	TestClientBuilderExt, Backend, Client, Executor
 };
 use transaction_pool::{
 	txpool::Pool,
@@ -44,17 +44,41 @@ fn uxt(sender: AccountKeyring, nonce: u64) -> Extrinsic {
 	tx.into_signed_tx()
 }

+struct TestSetup {
+	pub runtime: runtime::Runtime,
+	pub client: Arc<Client<Backend>>,
+	pub keystore: BareCryptoStorePtr,
+	pub pool: Arc<Pool<FullChainApi<Client<Backend>, Block>>>,
+}
+
+impl Default for TestSetup {
+	fn default() -> Self {
+		let keystore = KeyStore::new();
+		let client = Arc::new(test_client::TestClientBuilder::new().set_keystore(keystore.clone()).build());
+		let pool = Arc::new(Pool::new(Default::default(), FullChainApi::new(client.clone())));
+		TestSetup {
+			runtime: runtime::Runtime::new().expect("Failed to create runtime in test setup"),
+			client,
+			keystore,
+			pool,
+		}
+	}
+}
+
+impl TestSetup {
+	fn author(&self) -> Author<Backend, Executor, FullChainApi<Client<Backend>, Block>, RuntimeApi> {
+		Author {
+			client: self.client.clone(),
+			pool: self.pool.clone(),
+			subscriptions: Subscriptions::new(Arc::new(self.runtime.executor())),
+			keystore: self.keystore.clone(),
+		}
+	}
+}
+
 #[test]
 fn submit_transaction_should_not_cause_error() {
-	let runtime = runtime::Runtime::new().unwrap();
-	let client = Arc::new(test_client::new());
-	let keystore = KeyStore::new();
-	let p = Author {
-		client: client.clone(),
-		pool: Arc::new(Pool::new(Default::default(), FullChainApi::new(client))),
-		subscriptions: Subscriptions::new(Arc::new(runtime.executor())),
-		keystore: keystore.clone(),
-	};
+	let p = TestSetup::default().author();
 	let xt = uxt(AccountKeyring::Alice, 1).encode();
 	let h: H256 = blake2_256(&xt).into();

@@ -69,15 +93,7 @@ fn submit_transaction_should_not_cause_error() {

 #[test]
 fn submit_rich_transaction_should_not_cause_error() {
-	let runtime = runtime::Runtime::new().unwrap();
-	let client = Arc::new(test_client::new());
-	let keystore = KeyStore::new();
-	let p = Author {
-		client: client.clone(),
-		pool: Arc::new(Pool::new(Default::default(), FullChainApi::new(client.clone()))),
-		subscriptions: Subscriptions::new(Arc::new(runtime.executor())),
-		keystore: keystore.clone(),
-	};
+	let p = TestSetup::default().author();
 	let xt = uxt(AccountKeyring::Alice, 0).encode();
 	let h: H256 = blake2_256(&xt).into();

@@ -93,23 +109,16 @@ fn submit_rich_transaction_should_not_cause_error() {
 #[test]
 fn should_watch_extrinsic() {
 	//given
-	let mut runtime = runtime::Runtime::new().unwrap();
-	let client = Arc::new(test_client::new());
-	let pool = Arc::new(Pool::new(Default::default(), FullChainApi::new(client.clone())));
-	let keystore = KeyStore::new();
-	let p = Author {
-		client,
-		pool: pool.clone(),
-		subscriptions: Subscriptions::new(Arc::new(runtime.executor())),
-		keystore: keystore.clone(),
-	};
+	let mut setup = TestSetup::default();
+	let p = setup.author();
+
 	let (subscriber, id_rx, data) = jsonrpc_pubsub::typed::Subscriber::new_test("test");

 	// when
 	p.watch_extrinsic(Default::default(), subscriber, uxt(AccountKeyring::Alice, 0).encode().into());

 	// then
-	assert_eq!(runtime.block_on(id_rx), Ok(Ok(1.into())));
+	assert_eq!(setup.runtime.block_on(id_rx), Ok(Ok(1.into())));
 	// check notifications
 	let replacement = {
 		let tx = Transfer {
@@ -121,14 +130,14 @@ fn should_watch_extrinsic() {
 		tx.into_signed_tx()
 	};
 	AuthorApi::submit_extrinsic(&p, replacement.encode().into()).wait().unwrap();
-	let (res, data) = runtime.block_on(data.into_future()).unwrap();
+	let (res, data) = setup.runtime.block_on(data.into_future()).unwrap();
 	assert_eq!(
 		res,
 		Some(r#"{"jsonrpc":"2.0","method":"test","params":{"result":"ready","subscription":1}}"#.into())
 	);
 	let h = blake2_256(&replacement.encode());
 	assert_eq!(
-		runtime.block_on(data.into_future()).unwrap().0,
+		setup.runtime.block_on(data.into_future()).unwrap().0,
 		Some(format!(r#"{{"jsonrpc":"2.0","method":"test","params":{{"result":{{"usurped":"0x{}"}},"subscription":1}}}}"#, HexDisplay::from(&h)))
 	);
 }
@@ -136,38 +145,23 @@ fn should_watch_extrinsic() {
 #[test]
 fn should_return_watch_validation_error() {
 	//given
-	let mut runtime = runtime::Runtime::new().unwrap();
-	let client = Arc::new(test_client::new());
-	let pool = Arc::new(Pool::new(Default::default(), FullChainApi::new(client.clone())));
-	let keystore = KeyStore::new();
-	let p = Author {
-		client,
-		pool: pool.clone(),
-		subscriptions: Subscriptions::new(Arc::new(runtime.executor())),
-		keystore: keystore.clone(),
-	};
+	let mut setup = TestSetup::default();
+	let p = setup.author();
+
 	let (subscriber, id_rx, _data) = jsonrpc_pubsub::typed::Subscriber::new_test("test");

 	// when
 	p.watch_extrinsic(Default::default(), subscriber, uxt(AccountKeyring::Alice, 179).encode().into());

 	// then
-	let res = runtime.block_on(id_rx).unwrap();
+	let res = setup.runtime.block_on(id_rx).unwrap();
 	assert!(res.is_err(), "Expected the transaction to be rejected as invalid.");
 }

 #[test]
 fn should_return_pending_extrinsics() {
-	let runtime = runtime::Runtime::new().unwrap();
-	let client = Arc::new(test_client::new());
-	let pool = Arc::new(Pool::new(Default::default(), FullChainApi::new(client.clone())));
-	let keystore = KeyStore::new();
-	let p = Author {
-		client,
-		pool: pool.clone(),
-		subscriptions: Subscriptions::new(Arc::new(runtime.executor())),
-		keystore: keystore.clone(),
-	};
+	let p = TestSetup::default().author();
+
 	let ex = uxt(AccountKeyring::Alice, 0);
 	AuthorApi::submit_extrinsic(&p, ex.encode().into()).wait().unwrap();
 	assert_matches!(
@@ -178,23 +172,16 @@ fn should_return_pending_extrinsics() {

 #[test]
 fn should_remove_extrinsics() {
-	let runtime = runtime::Runtime::new().unwrap();
-	let client = Arc::new(test_client::new());
-	let pool = Arc::new(Pool::new(Default::default(), FullChainApi::new(client.clone())));
-	let keystore = KeyStore::new();
-	let p = Author {
-		client,
-		pool: pool.clone(),
-		subscriptions: Subscriptions::new(Arc::new(runtime.executor())),
-		keystore: keystore.clone(),
-	};
+	let setup = TestSetup::default();
+	let p = setup.author();
+
 	let ex1 = uxt(AccountKeyring::Alice, 0);
 	p.submit_extrinsic(ex1.encode().into()).wait().unwrap();
 	let ex2 = uxt(AccountKeyring::Alice, 1);
 	p.submit_extrinsic(ex2.encode().into()).wait().unwrap();
 	let ex3 = uxt(AccountKeyring::Bob, 0);
 	let hash3 = p.submit_extrinsic(ex3.encode().into()).wait().unwrap();
-	assert_eq!(pool.status().ready, 3);
+	assert_eq!(setup.pool.status().ready, 3);

 	// now remove all 3
 	let removed = p.remove_extrinsic(vec![
@@ -208,15 +195,8 @@ fn should_remove_extrinsics() {

 #[test]
 fn should_insert_key() {
-	let runtime = runtime::Runtime::new().unwrap();
-	let client = Arc::new(test_client::new());
-	let keystore = KeyStore::new();
-	let p = Author {
-		client: client.clone(),
-		pool: Arc::new(Pool::new(Default::default(), FullChainApi::new(client))),
-		subscriptions: Subscriptions::new(Arc::new(runtime.executor())),
-		keystore: keystore.clone(),
-	};
+	let setup = TestSetup::default();
+	let p = setup.author();

 	let suri = "//Alice";
 	let key_pair = ed25519::Pair::from_string(suri, None).expect("Generates keypair");
@@ -226,7 +206,7 @@ fn should_insert_key() {
 		key_pair.public().0.to_vec().into(),
 	).expect("Insert key");

-	let store_key_pair = keystore.read()
+	let store_key_pair = setup.keystore.read()
 		.ed25519_key_pair(ED25519, &key_pair.public()).expect("Key exists in store");

 	assert_eq!(key_pair.public(), store_key_pair.public());
@@ -234,29 +214,20 @@ fn should_insert_key() {

 #[test]
 fn should_rotate_keys() {
-	let runtime = runtime::Runtime::new().unwrap();
-	let keystore = KeyStore::new();
-	let client = Arc::new(
-		test_client::TestClientBuilder::new().set_keystore(keystore.clone()).build(),
-	);
-	let p = Author {
-		client: client.clone(),
-		pool: Arc::new(Pool::new(Default::default(), FullChainApi::new(client))),
-		subscriptions: Subscriptions::new(Arc::new(runtime.executor())),
-		keystore: keystore.clone(),
-	};
+	let setup = TestSetup::default();
+	let p = setup.author();

 	let new_public_keys = p.rotate_keys().expect("Rotates the keys");

 	let session_keys = SessionKeys::decode(&mut &new_public_keys[..])
 		.expect("SessionKeys decode successfully");

-	let ed25519_key_pair = keystore.read().ed25519_key_pair(
+	let ed25519_key_pair = setup.keystore.read().ed25519_key_pair(
 		ED25519,
 		&session_keys.ed25519.clone().into(),
 	).expect("ed25519 key exists in store");

-	let sr25519_key_pair = keystore.read().sr25519_key_pair(
+	let sr25519_key_pair = setup.keystore.read().sr25519_key_pair(
 		SR25519,
 		&session_keys.sr25519.clone().into(),
 	).expect("sr25519 key exists in store");