Rename lock tokens and add randomness to functional test

lock_tokens -> lock_token_supply
specify a randomseed argument for the functional tests

Author: OBorce

test/functional/test_runner.py

@@ -30,6 +30,7 @@
 import datetime
 import locale
 import os
+import random
 import time
 import shutil
 import signal
@@ -443,6 +444,7 @@ def __init__(self, *, num_tests_parallel, tests_dir, tmpdir, test_list, flags, u
         self.num_running = 0
         self.jobs = []
         self.use_term_control = use_term_control
+        self.randomseed = random.randrange(sys.maxsize)
 
     def get_next(self):
         while self.num_running < self.num_jobs and self.test_list:
@@ -451,14 +453,15 @@ def get_next(self):
             test = self.test_list.pop(0)
             portseed = len(self.test_list)
             portseed_arg = ["--portseed={}".format(portseed)]
+            randomseed_arg = [f"--randomseed={self.randomseed}"]
             log_stdout = tempfile.SpooledTemporaryFile(max_size=2**16)
             log_stderr = tempfile.SpooledTemporaryFile(max_size=2**16)
             test_argv = test.split()
             testdir = "{}/{}_{}".format(self.tmpdir, re.sub(".py$", "", test_argv[0]), portseed)
             tmpdir_arg = ["--tmpdir={}".format(testdir)]
             self.jobs.append((test,
                               time.time(),
-                              subprocess.Popen([sys.executable, self.tests_dir + test_argv[0]] + test_argv[1:] + self.flags + portseed_arg + tmpdir_arg,
+                              subprocess.Popen([sys.executable, self.tests_dir + test_argv[0]] + test_argv[1:] + self.flags + portseed_arg + tmpdir_arg + randomseed_arg,
                                                universal_newlines=True,
                                                stdout=log_stdout,
                                                stderr=log_stderr),

test/functional/wallet_tokens_change_supply.py

@@ -36,6 +36,7 @@
 
 import asyncio
 import sys
+import random
 
 class WalletTokens(BitcoinTestFramework):
 
@@ -145,7 +146,7 @@ async def async_test(self):
             self.generate_block()
             assert_in("Success", await wallet.sync())
 
-            tokens_to_mint = 10000
+            tokens_to_mint = random.randrange(2, 10000)
             total_tokens_supply = tokens_to_mint
             assert_in("The transaction was submitted successfully", await wallet.mint_tokens(token_id, address, tokens_to_mint))
 
@@ -157,7 +158,7 @@ async def async_test(self):
             # cannot unmint more than minted
             assert_in(f"Trying to unmint Amount {{ val: {tokens_to_mint+1}00 }} but the current supply is Amount {{ val: {tokens_to_mint}00 }}", await wallet.unmint_tokens(token_id, tokens_to_mint + 1))
 
-            tokens_to_unmint = 1000
+            tokens_to_unmint = random.randrange(1, tokens_to_mint // 2)
             total_tokens_supply = total_tokens_supply - tokens_to_unmint
             assert_in("The transaction was submitted successfully", await wallet.unmint_tokens(token_id, tokens_to_unmint))
 
@@ -166,15 +167,15 @@ async def async_test(self):
             assert_in(f"{token_id} amount: {total_tokens_supply}", await wallet.get_balance())
 
             # mint some more tokens
-            tokens_to_mint = 1000
+            tokens_to_mint = random.randrange(1, 10000)
             total_tokens_supply = total_tokens_supply + tokens_to_mint
             assert_in("The transaction was submitted successfully", await wallet.mint_tokens(token_id, address, tokens_to_mint))
 
             self.generate_block()
             assert_in("Success", await wallet.sync())
             assert_in(f"{token_id} amount: {total_tokens_supply}", await wallet.get_balance())
 
-            # lock token suply
+            # lock token supply
             assert_in("The transaction was submitted successfully", await wallet.lock_tokens(token_id))
             self.generate_block()
             assert_in("Success", await wallet.sync())

wallet/src/account/mod.rs

@@ -775,7 +775,7 @@ impl Account {
         )
     }
 
-    pub fn lock_tokens(
+    pub fn lock_token_supply(
         &mut self,
         db_tx: &mut impl WalletStorageWriteUnlocked,
         token_id: TokenId,

wallet/src/wallet/mod.rs

@@ -851,7 +851,7 @@ impl<B: storage::Backend> Wallet<B> {
         })
     }
 
-    pub fn lock_tokens(
+    pub fn lock_token_supply(
         &mut self,
         account_index: U31,
         token_id: TokenId,
@@ -860,7 +860,7 @@ impl<B: storage::Backend> Wallet<B> {
     ) -> WalletResult<SignedTransaction> {
         let latest_median_time = self.latest_median_time;
         self.for_account_rw_unlocked(account_index, |account, db_tx| {
-            account.lock_tokens(
+            account.lock_token_supply(
                 db_tx,
                 token_id,
                 latest_median_time,

wallet/src/wallet/tests.rs

@@ -2716,7 +2716,7 @@ fn change_token_supply_fixed(#[case] seed: Seed) {
     );
 
     let err = wallet
-        .lock_tokens(
+        .lock_token_supply(
             DEFAULT_ACCOUNT_INDEX,
             issued_token_id,
             FeeRate::new(Amount::ZERO),
@@ -2952,7 +2952,7 @@ fn change_token_supply_unlimited(#[case] seed: Seed) {
     );
 
     let err = wallet
-        .lock_tokens(
+        .lock_token_supply(
             DEFAULT_ACCOUNT_INDEX,
             issued_token_id,
             FeeRate::new(Amount::ZERO),
@@ -3183,7 +3183,7 @@ fn change_and_lock_token_supply_lockable(#[case] seed: Seed) {
     assert!(token_issuance_data.total_supply.check_can_lock().is_ok());
 
     let lock_transaction = wallet
-        .lock_tokens(
+        .lock_token_supply(
             DEFAULT_ACCOUNT_INDEX,
             issued_token_id,
             FeeRate::new(Amount::ZERO),
@@ -3249,7 +3249,7 @@ fn change_and_lock_token_supply_lockable(#[case] seed: Seed) {
     assert_eq!(err, WalletError::CannotChangeLockedTokenSupply);
 
     let err = wallet
-        .lock_tokens(
+        .lock_token_supply(
             DEFAULT_ACCOUNT_INDEX,
             issued_token_id,
             FeeRate::new(Amount::ZERO),

wallet/wallet-cli-lib/src/commands/helper_types.rs

@@ -238,7 +238,7 @@ pub fn to_per_thousand(
     variable_name: &str,
 ) -> Result<PerThousand, WalletCliError> {
     PerThousand::from_decimal_str(value_str).ok_or(WalletCliError::InvalidInput(format!(
-        "Failed to parse {variable_name} the decimal that must be in the range [0.001,1.000] or [0.1%,100%]",
+        "Failed to parse {variable_name}. The decimal must be in the range [0.001,1.000] or [0.1%,100%]",
     )))
 }
 

wallet/wallet-cli-lib/src/commands/mod.rs

@@ -891,7 +891,7 @@ impl CommandHandler {
 
                 self.get_synced_controller()
                     .await?
-                    .lock_tokens(token_id)
+                    .lock_token_supply(token_id)
                     .await
                     .map_err(WalletCliError::Controller)?;
 

wallet/wallet-controller/src/synced_controller.rs

@@ -205,13 +205,13 @@ impl<'a, T: NodeInterface, W: WalletEvents> SyncedController<'a, T, W> {
         self.broadcast_to_mempool(tx).await
     }
 
-    pub async fn lock_tokens(&mut self, token_id: TokenId) -> Result<(), ControllerError<T>> {
+    pub async fn lock_token_supply(&mut self, token_id: TokenId) -> Result<(), ControllerError<T>> {
         let (current_fee_rate, consolidate_fee_rate) =
             self.get_current_and_consolidation_fee_rate().await?;
 
         let tx = self
             .wallet
-            .lock_tokens(
+            .lock_token_supply(
                 self.account_index,
                 token_id,
                 current_fee_rate,