pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-06-14 00:31:07 +00:00
Code Issues Packages Projects Releases Wiki Activity

Run cargo fmt on the whole code base (#9394)

Browse Source 
* Run cargo fmt on the whole code base

* Second run

* Add CI check

* Fix compilation

* More unnecessary braces

* Handle weights

* Use --all

* Use correct attributes...

* Fix UI tests

* AHHHHHHHHH

* 🤦

* Docs

* Fix compilation

* 🤷

* Please stop

* 🤦 x 2

* More

* make rustfmt.toml consistent with polkadot

Co-authored-by: André Silva <andrerfosilva@gmail.com>
This commit is contained in:
Bastian Köcher
2021-07-21 16:32:32 +02:00
committed by GitHub
parent d451c38c1c
commit 7b56ab15b4
1010 changed files with 53339 additions and 51208 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/client/rpc/src/author/tests.rs
+51 -56
View File
@@ -18,37 +18,35 @@
use super::*;
use std::{mem, sync::Arc};
use assert_matches::assert_matches;
use codec::Encode;
use futures::{compat::Future01CompatExt, executor};
use rpc::futures::Stream as _;
use sc_transaction_pool::{BasicPool, FullChainApi};
use sp_core::{
ed25519, sr25519,
H256, blake2_256, hexdisplay::HexDisplay, testing::{ED25519, SR25519},
blake2_256,
crypto::{CryptoTypePublicPair, Pair, Public},
ed25519,
hexdisplay::HexDisplay,
sr25519,
testing::{ED25519, SR25519},
H256,
};
use sp_keystore::testing::KeyStore;
use rpc::futures::Stream as _;
use std::{mem, sync::Arc};
use substrate_test_runtime_client::{
self, AccountKeyring, runtime::{Extrinsic, Transfer, SessionKeys, Block},
DefaultTestClientBuilderExt, TestClientBuilderExt, Backend, Client,
self,
runtime::{Block, Extrinsic, SessionKeys, Transfer},
AccountKeyring, Backend, Client, DefaultTestClientBuilderExt, TestClientBuilderExt,
};
use sc_transaction_pool::{BasicPool, FullChainApi};
use futures::{executor, compat::Future01CompatExt};
fn uxt(sender: AccountKeyring, nonce: u64) -> Extrinsic {
let tx = Transfer {
amount: Default::default(),
nonce,
from: sender.into(),
to: Default::default(),
};
let tx =
Transfer { amount: Default::default(), nonce, from: sender.into(), to: Default::default() };
tx.into_signed_tx()
}
type FullTransactionPool = BasicPool<
FullChainApi<Client<Backend>, Block>,
Block,
>;
type FullTransactionPool = BasicPool<FullChainApi<Client<Backend>, Block>, Block>;
struct TestSetup {
pub client: Arc<Client<Backend>>,
@@ -63,18 +61,9 @@ impl Default for TestSetup {
let client = Arc::new(client_builder.set_keystore(keystore.clone()).build());
let spawner = sp_core::testing::TaskExecutor::new();
let pool = BasicPool::new_full(
Default::default(),
true.into(),
None,
spawner,
client.clone(),
);
TestSetup {
client,
keystore,
pool,
}
let pool =
BasicPool::new_full(Default::default(), true.into(), None, spawner, client.clone());
TestSetup { client, keystore, pool }
}
}
@@ -100,9 +89,7 @@ fn submit_transaction_should_not_cause_error() {
AuthorApi::submit_extrinsic(&p, xt.clone().into()).wait(),
Ok(h2) if h == h2
);
assert!(
AuthorApi::submit_extrinsic(&p, xt.into()).wait().is_err()
);
assert!(AuthorApi::submit_extrinsic(&p, xt.into()).wait().is_err());
}
#[test]
@@ -115,14 +102,12 @@ fn submit_rich_transaction_should_not_cause_error() {
AuthorApi::submit_extrinsic(&p, xt.clone().into()).wait(),
Ok(h2) if h == h2
);
assert!(
AuthorApi::submit_extrinsic(&p, xt.into()).wait().is_err()
);
assert!(AuthorApi::submit_extrinsic(&p, xt.into()).wait().is_err());
}
#[test]
fn should_watch_extrinsic() {
//given
// given
let setup = TestSetup::default();
let p = setup.author();
@@ -175,14 +160,18 @@ fn should_watch_extrinsic() {
#[test]
fn should_return_watch_validation_error() {
//given
// given
let 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());
p.watch_extrinsic(
Default::default(),
subscriber,
uxt(AccountKeyring::Alice, 179).encode().into(),
);
// then
let res = executor::block_on(id_rx.compat()).unwrap();
@@ -215,11 +204,13 @@ fn should_remove_extrinsics() {
assert_eq!(setup.pool.status().ready, 3);
// now remove all 3
let removed = p.remove_extrinsic(vec![
hash::ExtrinsicOrHash::Hash(hash3),
// Removing this one will also remove ex2
hash::ExtrinsicOrHash::Extrinsic(ex1.encode().into()),
]).unwrap();
let removed = p
.remove_extrinsic(vec![
hash::ExtrinsicOrHash::Hash(hash3),
// Removing this one will also remove ex2
hash::ExtrinsicOrHash::Extrinsic(ex1.encode().into()),
])
.unwrap();
assert_eq!(removed.len(), 3);
}
@@ -235,11 +226,13 @@ fn should_insert_key() {
String::from_utf8(ED25519.0.to_vec()).expect("Keytype is a valid string"),
suri.to_string(),
key_pair.public().0.to_vec().into(),
).expect("Insert key");
)
.expect("Insert key");
let public_keys = SyncCryptoStore::keys(&*setup.keystore, ED25519).unwrap();
assert!(public_keys.contains(&CryptoTypePublicPair(ed25519::CRYPTO_ID, key_pair.public().to_raw_vec())));
assert!(public_keys
.contains(&CryptoTypePublicPair(ed25519::CRYPTO_ID, key_pair.public().to_raw_vec())));
}
#[test]
@@ -249,14 +242,16 @@ fn should_rotate_keys() {
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 session_keys =
SessionKeys::decode(&mut &new_public_keys[..]).expect("SessionKeys decode successfully");
let ed25519_public_keys = SyncCryptoStore::keys(&*setup.keystore, ED25519).unwrap();
let sr25519_public_keys = SyncCryptoStore::keys(&*setup.keystore, SR25519).unwrap();
assert!(ed25519_public_keys.contains(&CryptoTypePublicPair(ed25519::CRYPTO_ID, session_keys.ed25519.to_raw_vec())));
assert!(sr25519_public_keys.contains(&CryptoTypePublicPair(sr25519::CRYPTO_ID, session_keys.sr25519.to_raw_vec())));
assert!(ed25519_public_keys
.contains(&CryptoTypePublicPair(ed25519::CRYPTO_ID, session_keys.ed25519.to_raw_vec())));
assert!(sr25519_public_keys
.contains(&CryptoTypePublicPair(sr25519::CRYPTO_ID, session_keys.sr25519.to_raw_vec())));
}
#[test]
@@ -264,10 +259,8 @@ fn test_has_session_keys() {
let setup = TestSetup::default();
let p = setup.author();
let non_existent_public_keys = TestSetup::default()
.author()
.rotate_keys()
.expect("Rotates the keys");
let non_existent_public_keys =
TestSetup::default().author().rotate_keys().expect("Rotates the keys");
let public_keys = p.rotate_keys().expect("Rotates the keys");
let test_vectors = vec![
@@ -295,7 +288,8 @@ fn test_has_key() {
String::from_utf8(ED25519.0.to_vec()).expect("Keytype is a valid string"),
suri.to_string(),
alice_key_pair.public().0.to_vec().into(),
).expect("Insert key");
)
.expect("Insert key");
let bob_key_pair = ed25519::Pair::from_string("//Bob", None).expect("Generates keypair");
let test_vectors = vec![
@@ -310,7 +304,8 @@ fn test_has_key() {
p.has_key(
key,
String::from_utf8(key_type.0.to_vec()).expect("Keytype is a valid string"),
).map_err(|e| mem::discriminant(&e)),
)
.map_err(|e| mem::discriminant(&e)),
);
}
}