Fix a spurious test failure

api-server/stack-test-suite/tests/v2/helpers.rs

@@ -159,7 +159,7 @@ pub fn issue_and_mint_tokens_from_genesis(
 ) -> IssueAndMintTokensResult {
     let token_issuance_fee = tf.chainstate.get_chain_config().fungible_token_issuance_fee();
 
-    let issuance = test_utils::nft_utils::random_token_issuance_v1(
+    let issuance = test_utils::token_utils::random_token_issuance_v1(
         tf.chain_config(),
         Destination::AnyoneCanSpend,
         rng,

api-server/stack-test-suite/tests/v2/nft.rs

@@ -93,7 +93,7 @@ async fn ok(#[case] seed: Seed) {
 
                 let alice_destination = Destination::PublicKeyHash(PublicKeyHash::from(&alice_pk));
 
-                let nft = test_utils::nft_utils::random_nft_issuance(&chain_config, &mut rng);
+                let nft = test_utils::token_utils::random_nft_issuance(&chain_config, &mut rng);
 
                 let input = TxInput::from_utxo(
                     OutPointSourceId::BlockReward(tf.genesis().get_id().into()),

api-server/stack-test-suite/tests/v2/token_ids.rs

@@ -144,7 +144,7 @@ async fn ok(#[case] seed: Seed) {
 
                 let mut nft_ids = vec![];
                 for _ in 0..10 {
-                    let nft = test_utils::nft_utils::random_nft_issuance(&chain_config, &mut rng);
+                    let nft = test_utils::token_utils::random_nft_issuance(&chain_config, &mut rng);
                     let token_id =
                         make_token_id(&chain_config, tf.next_block_height(), &[input.clone()])
                             .unwrap();

api-server/stack-test-suite/tests/v2/token_ticker.rs

@@ -147,7 +147,7 @@ async fn ok(#[case] seed: Seed) {
                 let mut nft_ids = vec![];
                 for _ in 0..10 {
                     let mut nft =
-                        test_utils::nft_utils::random_nft_issuance(&chain_config, &mut rng);
+                        test_utils::token_utils::random_nft_issuance(&chain_config, &mut rng);
                     nft.metadata.ticker = token_ticker.as_bytes().to_vec();
                     let token_id =
                         make_token_id(&chain_config, tf.next_block_height(), &[input.clone()])

api-server/stack-test-suite/tests/v2/transaction.rs

@@ -467,7 +467,7 @@ async fn mint_tokens(#[case] seed: Seed) {
                 let token_issuance_fee =
                     tf.chainstate.get_chain_config().fungible_token_issuance_fee();
 
-                let issuance = test_utils::nft_utils::random_token_issuance_v1(
+                let issuance = test_utils::token_utils::random_token_issuance_v1(
                     tf.chain_config(),
                     Destination::AnyoneCanSpend,
                     &mut rng,

chainstate/constraints-value-accumulator/src/tests/constraints_tests.rs

@@ -37,8 +37,8 @@ use pos_accounting::{DelegationData, InMemoryPoSAccounting, PoSAccountingDB, Poo
 use randomness::{CryptoRng, Rng};
 use rstest::rstest;
 use test_utils::{
-    nft_utils::random_nft_issuance,
     random::{make_seedable_rng, Seed},
+    token_utils::random_nft_issuance,
 };
 
 use crate::{ConstrainedValueAccumulator, Error};
@@ -755,7 +755,7 @@ fn calculate_fee_for_token_issuance(#[case] seed: Seed) {
     ))];
 
     let outputs = vec![TxOutput::IssueFungibleToken(Box::new(TokenIssuance::V1(
-        test_utils::nft_utils::random_token_issuance_v1(
+        test_utils::token_utils::random_token_issuance_v1(
             &chain_config,
             Destination::AnyoneCanSpend,
             &mut rng,
@@ -805,7 +805,7 @@ fn calculate_token_supply_change_fee(#[case] seed: Seed) {
     let orders_db = OrdersAccountingDB::new(&orders_store);
 
     let token_data = tokens_accounting::TokenData::FungibleToken(
-        TokenIssuance::V1(test_utils::nft_utils::random_token_issuance_v1(
+        TokenIssuance::V1(test_utils::token_utils::random_token_issuance_v1(
             &chain_config,
             Destination::AnyoneCanSpend,
             &mut rng,
@@ -978,7 +978,7 @@ fn calculate_token_fee_freeze(#[case] seed: Seed) {
     let orders_db = OrdersAccountingDB::new(&orders_store);
 
     let token_data = tokens_accounting::TokenData::FungibleToken(
-        TokenIssuance::V1(test_utils::nft_utils::random_token_issuance_v1(
+        TokenIssuance::V1(test_utils::token_utils::random_token_issuance_v1(
             &chain_config,
             Destination::AnyoneCanSpend,
             &mut rng,
@@ -1110,7 +1110,7 @@ fn calculate_token_fee_change_authority(#[case] seed: Seed) {
     let orders_db = OrdersAccountingDB::new(&orders_store);
 
     let token_data = tokens_accounting::TokenData::FungibleToken(
-        TokenIssuance::V1(test_utils::nft_utils::random_token_issuance_v1(
+        TokenIssuance::V1(test_utils::token_utils::random_token_issuance_v1(
             &chain_config,
             Destination::AnyoneCanSpend,
             &mut rng,
@@ -1305,7 +1305,7 @@ fn calculate_token_fee_change_metadata_uri(#[case] seed: Seed) {
     let orders_db = OrdersAccountingDB::new(&orders_store);
 
     let token_data = tokens_accounting::TokenData::FungibleToken(
-        TokenIssuance::V1(test_utils::nft_utils::random_token_issuance_v1(
+        TokenIssuance::V1(test_utils::token_utils::random_token_issuance_v1(
             &chain_config,
             Destination::AnyoneCanSpend,
             &mut rng,

chainstate/test-framework/src/random_tx_maker.rs

@@ -50,7 +50,7 @@ use pos_accounting::{
     PoolData,
 };
 use randomness::{seq::IteratorRandom, CryptoRng, Rng, SliceRandom};
-use test_utils::{nft_utils::*, random_ascii_alphanumeric_string};
+use test_utils::{random_ascii_alphanumeric_string, token_utils::*};
 use tokens_accounting::{
     InMemoryTokensAccounting, TokensAccountingCache, TokensAccountingDB, TokensAccountingDeltaData,
     TokensAccountingOperations, TokensAccountingView,

chainstate/test-suite/src/tests/chainstate_storage_tests.rs

@@ -29,7 +29,7 @@ use common::{
     },
     primitives::{Amount, Id, Idable},
 };
-use test_utils::nft_utils::random_nft_issuance;
+use test_utils::token_utils::random_nft_issuance;
 use utxo::{Utxo, UtxosStorageRead, UtxosTxUndo};
 
 use super::*;

chainstate/test-suite/src/tests/fungible_tokens.rs

@@ -38,9 +38,9 @@ use crypto::hash::StreamHasher;
 use randomness::{CryptoRng, Rng};
 use serialization::extras::non_empty_vec::DataOrNoVec;
 use test_utils::{
-    nft_utils::random_token_issuance,
     random::{make_seedable_rng, Seed},
     random_ascii_alphanumeric_string,
+    token_utils::random_token_issuance,
 };
 use tx_verifier::CheckTransactionError;
 

chainstate/test-suite/src/tests/homomorphism.rs

@@ -28,7 +28,7 @@ use common::{
     primitives::{Amount, Idable},
 };
 use crypto::vrf::{VRFKeyKind, VRFPrivateKey};
-use test_utils::nft_utils::random_token_issuance_v1;
+use test_utils::token_utils::random_token_issuance_v1;
 
 // These tests prove that TransactionVerifiers hierarchy has homomorphic property: f(ab) == f(a)f(b)
 // Meaning that multiple operations done via a single verifier give the same result as using one

chainstate/test-suite/src/tests/htlc.rs

@@ -50,7 +50,7 @@ use common::{
 use crypto::key::{KeyKind, PrivateKey, PublicKey};
 use randomness::CryptoRng;
 use serialization::Encode;
-use test_utils::nft_utils::{random_token_issuance, random_token_issuance_v1};
+use test_utils::token_utils::{random_token_issuance, random_token_issuance_v1};
 use tx_verifier::{
     error::{InputCheckError, TranslationError},
     input_check::HashlockError,

chainstate/test-suite/src/tests/nft_burn.rs

@@ -27,8 +27,8 @@ use common::{
 };
 use randomness::Rng;
 use test_utils::{
-    nft_utils::random_nft_issuance,
     random::{make_seedable_rng, Seed},
+    token_utils::random_nft_issuance,
 };
 
 #[rstest]

chainstate/test-suite/src/tests/nft_issuance.rs

@@ -35,9 +35,9 @@ use randomness::{CryptoRng, Rng};
 use serialization::extras::non_empty_vec::DataOrNoVec;
 use test_utils::{
     gen_text_with_non_ascii,
-    nft_utils::{random_creator, random_nft_issuance, random_token_issuance_v1},
     random::{make_seedable_rng, Seed},
     random_ascii_alphanumeric_string,
+    token_utils::{random_creator, random_nft_issuance, random_token_issuance_v1},
 };
 use tx_verifier::{error::TokenIssuanceError, CheckTransactionError};
 

chainstate/test-suite/src/tests/nft_reorgs.rs

@@ -26,8 +26,8 @@ use common::{
 };
 use rstest::rstest;
 use test_utils::{
-    nft_utils::random_nft_issuance,
     random::{make_seedable_rng, Seed},
+    token_utils::random_nft_issuance,
 };
 
 #[rstest]

chainstate/test-suite/src/tests/nft_transfer.rs

@@ -29,8 +29,8 @@ use common::{
 };
 use randomness::Rng;
 use test_utils::{
-    nft_utils::random_nft_issuance,
     random::{make_seedable_rng, Seed},
+    token_utils::random_nft_issuance,
 };
 
 #[rstest]

chainstate/test-suite/src/tests/orders_tests.rs

@@ -46,8 +46,8 @@ use crypto::key::{KeyKind, PrivateKey};
 use logging::log;
 use randomness::{CryptoRng, Rng, SliceRandom};
 use test_utils::{
-    nft_utils::random_nft_issuance,
     random::{gen_random_bytes, make_seedable_rng, Seed},
+    token_utils::random_nft_issuance,
 };
 use tx_verifier::{
     error::{InputCheckError, InputCheckErrorPayload, ScriptError, TranslationError},

chainstate/test-suite/src/tests/stake_pool_tests.rs

@@ -46,8 +46,8 @@ use crypto::{
 use pos_accounting::PoSAccountingStorageRead;
 use randomness::Rng;
 use test_utils::{
-    nft_utils::random_token_issuance_v1,
     random::{make_seedable_rng, Seed},
+    token_utils::random_token_issuance_v1,
 };
 use tx_verifier::error::{InputCheckError, ScriptError};
 

common/src/chain/tokens/issuance.rs

@@ -29,7 +29,9 @@ use serialization::{Decode, Encode};
     Decode,
     serde::Serialize,
     serde::Deserialize,
+    strum::EnumDiscriminants,
 )]
+#[strum_discriminants(name(TokenTotalSupplyTag), derive(strum::EnumIter))]
 pub enum TokenTotalSupply {
     #[codec(index = 0)]
     Fixed(Amount), // fixed to a certain amount

p2p/src/sync/tests/no_discouragement_after_tx_reorg.rs

@@ -51,9 +51,10 @@ use p2p_types::PeerId;
 use randomness::Rng;
 use test_utils::{
     assert_matches,
-    nft_utils::random_nft_issuance,
     random::{gen_random_bytes, Seed},
-    random_ascii_alphanumeric_string, BasicTestTimeGetter,
+    random_ascii_alphanumeric_string,
+    token_utils::random_nft_issuance,
+    BasicTestTimeGetter,
 };
 
 use crate::{

test-utils/Cargo.toml

@@ -21,3 +21,4 @@ itertools.workspace = true
 rand_chacha.workspace = true
 regex.workspace = true
 rstest.workspace = true
+strum.workspace = true

test-utils/src/lib.rs

@@ -15,10 +15,10 @@
 
 mod basic_test_time_getter;
 pub mod mock_time_getter;
-pub mod nft_utils;
 pub mod random;
 pub mod test_dir;
 pub mod threading;
+pub mod token_utils;
 
 use std::collections::BTreeMap;
 

test-utils/src/nft_utils.rs → test-utils/src/token_utils.rs

@@ -13,22 +13,25 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use crate::random_ascii_alphanumeric_string;
+use strum::IntoEnumIterator as _;
+
 use common::{
     chain::{
         config::ChainConfig,
         tokens::{
             IsTokenFreezable, Metadata, NftIssuanceV0, TokenCreator, TokenIssuanceV0,
-            TokenIssuanceV1, TokenTotalSupply,
+            TokenIssuanceV1, TokenTotalSupply, TokenTotalSupplyTag,
         },
         Destination,
     },
-    primitives::Amount,
+    primitives::{amount, Amount},
 };
 use crypto::key::{KeyKind, PrivateKey};
-use randomness::{CryptoRng, Rng};
+use randomness::{seq::IteratorRandom as _, CryptoRng, Rng};
 use serialization::extras::non_empty_vec::DataOrNoVec;
 
+use crate::random_ascii_alphanumeric_string;
+
 pub fn random_creator(rng: &mut (impl Rng + CryptoRng)) -> TokenCreator {
     let (_, public_key) = PrivateKey::new_from_rng(rng, KeyKind::Secp256k1Schnorr);
     TokenCreator::from(public_key)
@@ -47,29 +50,24 @@ pub fn random_token_issuance(chain_config: &ChainConfig, rng: &mut impl Rng) ->
     }
 }
 
-pub fn random_token_issuance_v1(
+pub fn random_token_issuance_v1_with_min_supply(
     chain_config: &ChainConfig,
     authority: Destination,
+    min_supply: amount::UnsignedIntType,
     rng: &mut impl Rng,
 ) -> TokenIssuanceV1 {
     let max_ticker_len = chain_config.token_max_ticker_len();
     let max_dec_count = chain_config.token_max_dec_count();
     let max_uri_len = chain_config.token_max_uri_len();
 
-    let _fix_code_below_if_enum_changes = |supply: TokenTotalSupply| match supply {
-        TokenTotalSupply::Fixed(_) => unreachable!(),
-        TokenTotalSupply::Lockable => unreachable!(),
-        TokenTotalSupply::Unlimited => unreachable!(),
-    };
-
-    let supply = match rng.gen_range(0..3) {
-        0 => {
-            let supply = Amount::from_atoms(rng.gen_range(1..1_000_000));
+    let supply = match TokenTotalSupplyTag::iter().choose(rng).expect("cannot fail") {
+        TokenTotalSupplyTag::Fixed => {
+            let max_supply = std::cmp::max(min_supply * 2, 1_000_000);
+            let supply = Amount::from_atoms(rng.gen_range(min_supply..=max_supply));
             TokenTotalSupply::Fixed(supply)
         }
-        1 => TokenTotalSupply::Lockable,
-        2 => TokenTotalSupply::Unlimited,
-        _ => unreachable!(),
+        TokenTotalSupplyTag::Lockable => TokenTotalSupply::Lockable,
+        TokenTotalSupplyTag::Unlimited => TokenTotalSupply::Unlimited,
     };
 
     let is_freezable = if rng.gen::<bool>() {
@@ -88,6 +86,14 @@ pub fn random_token_issuance_v1(
     }
 }
 
+pub fn random_token_issuance_v1(
+    chain_config: &ChainConfig,
+    authority: Destination,
+    rng: &mut impl Rng,
+) -> TokenIssuanceV1 {
+    random_token_issuance_v1_with_min_supply(chain_config, authority, 1, rng)
+}
+
 pub fn random_nft_issuance(
     chain_config: &ChainConfig,
     rng: &mut (impl Rng + CryptoRng),