rustfmt

integration-tests/tests/common/balances.rs

@@ -14,9 +14,9 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with Substrate-Libre-Currency. If not, see <https://www.gnu.org/licenses/>.
 
-use super::*;
 use super::node_runtime::runtime_types::gdev_runtime;
 use super::node_runtime::runtime_types::pallet_balances;
+use super::*;
 use sp_keyring::AccountKeyring;
 use subxt::{sp_runtime::MultiAddress, PairSigner};
 
@@ -28,8 +28,7 @@ pub async fn set_balance(
 ) -> Result<()> {
     let _events = create_block_with_extrinsic(
         &client,
-        api
-            .tx()
+        api.tx()
             .sudo()
             .sudo(gdev_runtime::Call::Balances(
                 pallet_balances::pallet::Call::set_balance {
@@ -80,8 +79,7 @@ pub async fn transfer_all(
 
     let _events = create_block_with_extrinsic(
         &client,
-        api
-            .tx()
+        api.tx()
             .balances()
             .transfer_all(to.clone().into(), false)
             .create_signed(&from, ())

integration-tests/tests/cucumber_tests.rs

@@ -64,12 +64,16 @@ fn parse_amount(amount: u64, unit: &str) -> (u64, bool) {
 #[given(regex = r"([a-zA-Z]+) have (\d+) (ĞD|cĞD|UD|mUD)")]
 async fn who_have(world: &mut DuniterWorld, who: String, amount: u64, unit: String) -> Result<()> {
     // Parse inputs
-    let who = AccountKeyring::from_str(&who)
-        .expect("unknown to");
+    let who = AccountKeyring::from_str(&who).expect("unknown to");
     let (mut amount, is_ud) = parse_amount(amount, &unit);
 
     if is_ud {
-		let current_ud_amount = world.api.storage().universal_dividend().current_ud_storage(None).await?;
+        let current_ud_amount = world
+            .api
+            .storage()
+            .universal_dividend()
+            .current_ud_storage(None)
+            .await?;
         amount = (amount * current_ud_amount) / 1_000;
     }
 
@@ -80,7 +84,13 @@ async fn who_have(world: &mut DuniterWorld, who: String, amount: u64, unit: Stri
 }
 
 #[when(regex = r"([a-zA-Z]+) send (\d+) (ĞD|cĞD|UD|mUD) to ([a-zA-Z]+)")]
-async fn transfer(world: &mut DuniterWorld, from: String, amount: u64, unit: String, to: String) -> Result<()> {
+async fn transfer(
+    world: &mut DuniterWorld,
+    from: String,
+    amount: u64,
+    unit: String,
+    to: String,
+) -> Result<()> {
     // Parse inputs
     let from = AccountKeyring::from_str(&from).expect("unknown from");
     let to = AccountKeyring::from_str(&to).expect("unknown to");
@@ -116,11 +126,20 @@ async fn should_have(world: &mut DuniterWorld, who: String, amount: u64) -> Resu
 }
 
 #[then(regex = r"current UD amount should be (\d+).(\d+)")]
-async fn current_ud_amount_should_be(world: &mut DuniterWorld, amount: u64, cents: u64) -> Result<()> {
+async fn current_ud_amount_should_be(
+    world: &mut DuniterWorld,
+    amount: u64,
+    cents: u64,
+) -> Result<()> {
     // Parse inputs
     let expected_amount = amount + (cents * 100);
 
-    let current_ud_amount = world.api.storage().universal_dividend().current_ud_storage(None).await?;
+    let current_ud_amount = world
+        .api
+        .storage()
+        .universal_dividend()
+        .current_ud_storage(None)
+        .await?;
     assert_eq!(current_ud_amount, expected_amount);
     Ok(())
 }