Rename lock tokens and add randomness to functional test

lock_tokens -> lock_token_supply
specify a randomseed argument for the functional tests
randomize token supply change test

Author: OBorce

test/functional/test_framework/wallet_cli_controller.py

@@ -258,5 +258,5 @@ async def stop_staking(self) -> str:
     async def get_addresses_usage(self) -> str:
         return await self._write_command("showreceiveaddresses\n")
 
-    async def get_balance(self, with_locked: str = 'unlocked') -> str:
-        return await self._write_command(f"getbalance {with_locked}\n")
+    async def get_balance(self, with_locked: str = 'unlocked', utxo_states: List[str] = ['confirmed']) -> str:
+        return await self._write_command(f"getbalance {with_locked} {' '.join(utxo_states)}\n")

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,36 +146,39 @@ 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))
 
             self.generate_block()
             assert_in("Success", await wallet.sync())
 
-            assert_in(f"{token_id} amount: {total_tokens_supply}", await wallet.get_balance())
-
-            # 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
-            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))
-
-            self.generate_block()
-            assert_in("Success", await wallet.sync())
-            assert_in(f"{token_id} amount: {total_tokens_supply}", await wallet.get_balance())
-
-            # mint some more tokens
-            tokens_to_mint = 1000
-            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
+            # randomize minting and unminting
+            for _ in range(10):
+                if random.choice([True, False]):
+                    # mint some more tokens
+                    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))
+                else:
+                    # unmint some tokens
+                    tokens_to_unmint = random.randrange(1, 20000)
+                    if tokens_to_unmint <= total_tokens_supply:
+                        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))
+                    else:
+                        assert_in(f"Trying to unmint Amount {{ val: {tokens_to_unmint}00 }} but the current supply is Amount {{ val: {total_tokens_supply}00 }}", await wallet.unmint_tokens(token_id, tokens_to_unmint))
+                        continue
+
+                # either generate a new block or leave the transaction as in-memory state
+                if random.choice([True, False]):
+                    self.generate_block()
+                    assert_in("Success", await wallet.sync())
+
+                # check total supply is correct
+                assert_in(f"{token_id} amount: {total_tokens_supply}", await wallet.get_balance(utxo_states=['confirmed', 'inactive']))
+
+            # 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,