github.com/cosmos/cosmos-sdk@v0.50.10/types/denom_internal_test.go (about)

     1  package types
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/suite"
     7  
     8  	"cosmossdk.io/math"
     9  )
    10  
    11  var (
    12  	atom  = "atom"  // 1 (base denom unit)
    13  	matom = "matom" // 10^-3 (milli)
    14  	uatom = "uatom" // 10^-6 (micro)
    15  	natom = "natom" // 10^-9 (nano)
    16  )
    17  
    18  type internalDenomTestSuite struct {
    19  	suite.Suite
    20  }
    21  
    22  func TestInternalDenomTestSuite(t *testing.T) {
    23  	suite.Run(t, new(internalDenomTestSuite))
    24  }
    25  
    26  func (s *internalDenomTestSuite) TestRegisterDenom() {
    27  	atomUnit := math.LegacyOneDec() // 1 (base denom unit)
    28  
    29  	s.Require().NoError(RegisterDenom(atom, atomUnit))
    30  	s.Require().Error(RegisterDenom(atom, atomUnit))
    31  
    32  	res, ok := GetDenomUnit(atom)
    33  	s.Require().True(ok)
    34  	s.Require().Equal(atomUnit, res)
    35  
    36  	res, ok = GetDenomUnit(matom)
    37  	s.Require().False(ok)
    38  	s.Require().Equal(math.LegacyZeroDec(), res)
    39  
    40  	err := SetBaseDenom(atom)
    41  	s.Require().NoError(err)
    42  
    43  	res, ok = GetDenomUnit(atom)
    44  	s.Require().True(ok)
    45  	s.Require().Equal(atomUnit, res)
    46  
    47  	// reset registration
    48  	baseDenom = ""
    49  	denomUnits = map[string]math.LegacyDec{}
    50  }
    51  
    52  func (s *internalDenomTestSuite) TestConvertCoins() {
    53  	atomUnit := math.LegacyOneDec() // 1 (base denom unit)
    54  	s.Require().NoError(RegisterDenom(atom, atomUnit))
    55  
    56  	matomUnit := math.LegacyNewDecWithPrec(1, 3) // 10^-3 (milli)
    57  	s.Require().NoError(RegisterDenom(matom, matomUnit))
    58  
    59  	uatomUnit := math.LegacyNewDecWithPrec(1, 6) // 10^-6 (micro)
    60  	s.Require().NoError(RegisterDenom(uatom, uatomUnit))
    61  
    62  	natomUnit := math.LegacyNewDecWithPrec(1, 9) // 10^-9 (nano)
    63  	s.Require().NoError(RegisterDenom(natom, natomUnit))
    64  
    65  	res, err := GetBaseDenom()
    66  	s.Require().NoError(err)
    67  	s.Require().Equal(res, natom)
    68  	s.Require().Equal(NormalizeCoin(NewCoin(uatom, math.NewInt(1))), NewCoin(natom, math.NewInt(1000)))
    69  	s.Require().Equal(NormalizeCoin(NewCoin(matom, math.NewInt(1))), NewCoin(natom, math.NewInt(1000000)))
    70  	s.Require().Equal(NormalizeCoin(NewCoin(atom, math.NewInt(1))), NewCoin(natom, math.NewInt(1000000000)))
    71  
    72  	coins, err := ParseCoinsNormalized("1atom,1matom,1uatom")
    73  	s.Require().NoError(err)
    74  	s.Require().Equal(coins, Coins{
    75  		Coin{natom, math.NewInt(1000000000)},
    76  		Coin{natom, math.NewInt(1000000)},
    77  		Coin{natom, math.NewInt(1000)},
    78  	})
    79  
    80  	testCases := []struct {
    81  		input  Coin
    82  		denom  string
    83  		result Coin
    84  		expErr bool
    85  	}{
    86  		{NewCoin("foo", math.ZeroInt()), atom, Coin{}, true},
    87  		{NewCoin(atom, math.ZeroInt()), "foo", Coin{}, true},
    88  		{NewCoin(atom, math.ZeroInt()), "FOO", Coin{}, true},
    89  
    90  		{NewCoin(atom, math.NewInt(5)), matom, NewCoin(matom, math.NewInt(5000)), false},       // atom => matom
    91  		{NewCoin(atom, math.NewInt(5)), uatom, NewCoin(uatom, math.NewInt(5000000)), false},    // atom => uatom
    92  		{NewCoin(atom, math.NewInt(5)), natom, NewCoin(natom, math.NewInt(5000000000)), false}, // atom => natom
    93  
    94  		{NewCoin(uatom, math.NewInt(5000000)), matom, NewCoin(matom, math.NewInt(5000)), false},       // uatom => matom
    95  		{NewCoin(uatom, math.NewInt(5000000)), natom, NewCoin(natom, math.NewInt(5000000000)), false}, // uatom => natom
    96  		{NewCoin(uatom, math.NewInt(5000000)), atom, NewCoin(atom, math.NewInt(5)), false},            // uatom => atom
    97  
    98  		{NewCoin(matom, math.NewInt(5000)), natom, NewCoin(natom, math.NewInt(5000000000)), false}, // matom => natom
    99  		{NewCoin(matom, math.NewInt(5000)), uatom, NewCoin(uatom, math.NewInt(5000000)), false},    // matom => uatom
   100  	}
   101  
   102  	for i, tc := range testCases {
   103  		res, err := ConvertCoin(tc.input, tc.denom)
   104  		s.Require().Equal(
   105  			tc.expErr, err != nil,
   106  			"unexpected error; tc: #%d, input: %s, denom: %s", i+1, tc.input, tc.denom,
   107  		)
   108  		s.Require().Equal(
   109  			tc.result, res,
   110  			"invalid result; tc: #%d, input: %s, denom: %s", i+1, tc.input, tc.denom,
   111  		)
   112  	}
   113  
   114  	// reset registration
   115  	baseDenom = ""
   116  	denomUnits = map[string]math.LegacyDec{}
   117  }
   118  
   119  func (s *internalDenomTestSuite) TestConvertDecCoins() {
   120  	atomUnit := math.LegacyOneDec() // 1 (base denom unit)
   121  	s.Require().NoError(RegisterDenom(atom, atomUnit))
   122  
   123  	matomUnit := math.LegacyNewDecWithPrec(1, 3) // 10^-3 (milli)
   124  	s.Require().NoError(RegisterDenom(matom, matomUnit))
   125  
   126  	uatomUnit := math.LegacyNewDecWithPrec(1, 6) // 10^-6 (micro)
   127  	s.Require().NoError(RegisterDenom(uatom, uatomUnit))
   128  
   129  	natomUnit := math.LegacyNewDecWithPrec(1, 9) // 10^-9 (nano)
   130  	s.Require().NoError(RegisterDenom(natom, natomUnit))
   131  
   132  	res, err := GetBaseDenom()
   133  	s.Require().NoError(err)
   134  	s.Require().Equal(res, natom)
   135  	s.Require().Equal(NormalizeDecCoin(NewDecCoin(uatom, math.NewInt(1))), NewDecCoin(natom, math.NewInt(1000)))
   136  	s.Require().Equal(NormalizeDecCoin(NewDecCoin(matom, math.NewInt(1))), NewDecCoin(natom, math.NewInt(1000000)))
   137  	s.Require().Equal(NormalizeDecCoin(NewDecCoin(atom, math.NewInt(1))), NewDecCoin(natom, math.NewInt(1000000000)))
   138  
   139  	coins, err := ParseCoinsNormalized("0.1atom,0.1matom,0.1uatom")
   140  	s.Require().NoError(err)
   141  	s.Require().Equal(coins, Coins{
   142  		Coin{natom, math.NewInt(100000000)},
   143  		Coin{natom, math.NewInt(100000)},
   144  		Coin{natom, math.NewInt(100)},
   145  	})
   146  
   147  	testCases := []struct {
   148  		input  DecCoin
   149  		denom  string
   150  		result DecCoin
   151  		expErr bool
   152  	}{
   153  		{NewDecCoin("foo", math.ZeroInt()), atom, DecCoin{}, true},
   154  		{NewDecCoin(atom, math.ZeroInt()), "foo", DecCoin{}, true},
   155  		{NewDecCoin(atom, math.ZeroInt()), "FOO", DecCoin{}, true},
   156  
   157  		// 0.5atom
   158  		{NewDecCoinFromDec(atom, math.LegacyNewDecWithPrec(5, 1)), matom, NewDecCoin(matom, math.NewInt(500)), false},       // atom => matom
   159  		{NewDecCoinFromDec(atom, math.LegacyNewDecWithPrec(5, 1)), uatom, NewDecCoin(uatom, math.NewInt(500000)), false},    // atom => uatom
   160  		{NewDecCoinFromDec(atom, math.LegacyNewDecWithPrec(5, 1)), natom, NewDecCoin(natom, math.NewInt(500000000)), false}, // atom => natom
   161  
   162  		{NewDecCoin(uatom, math.NewInt(5000000)), matom, NewDecCoin(matom, math.NewInt(5000)), false},       // uatom => matom
   163  		{NewDecCoin(uatom, math.NewInt(5000000)), natom, NewDecCoin(natom, math.NewInt(5000000000)), false}, // uatom => natom
   164  		{NewDecCoin(uatom, math.NewInt(5000000)), atom, NewDecCoin(atom, math.NewInt(5)), false},            // uatom => atom
   165  
   166  		{NewDecCoin(matom, math.NewInt(5000)), natom, NewDecCoin(natom, math.NewInt(5000000000)), false}, // matom => natom
   167  		{NewDecCoin(matom, math.NewInt(5000)), uatom, NewDecCoin(uatom, math.NewInt(5000000)), false},    // matom => uatom
   168  	}
   169  
   170  	for i, tc := range testCases {
   171  		res, err := ConvertDecCoin(tc.input, tc.denom)
   172  		s.Require().Equal(
   173  			tc.expErr, err != nil,
   174  			"unexpected error; tc: #%d, input: %s, denom: %s", i+1, tc.input, tc.denom,
   175  		)
   176  		s.Require().Equal(
   177  			tc.result, res,
   178  			"invalid result; tc: #%d, input: %s, denom: %s", i+1, tc.input, tc.denom,
   179  		)
   180  	}
   181  
   182  	// reset registration
   183  	baseDenom = ""
   184  	denomUnits = map[string]math.LegacyDec{}
   185  }
   186  
   187  func (s *internalDenomTestSuite) TestDecOperationOrder() {
   188  	dec, err := math.LegacyNewDecFromStr("11")
   189  	s.Require().NoError(err)
   190  	s.Require().NoError(RegisterDenom("unit1", dec))
   191  	dec, err = math.LegacyNewDecFromStr("100000011")
   192  	s.Require().NoError(err)
   193  	s.Require().NoError(RegisterDenom("unit2", dec))
   194  
   195  	coin, err := ConvertCoin(NewCoin("unit1", math.NewInt(100000011)), "unit2")
   196  	s.Require().NoError(err)
   197  	s.Require().Equal(coin, NewCoin("unit2", math.NewInt(11)))
   198  
   199  	// reset registration
   200  	baseDenom = ""
   201  	denomUnits = map[string]math.LegacyDec{}
   202  }
   203  
   204  func (s *internalDenomTestSuite) TestSetBaseDenomError() {
   205  	err := SetBaseDenom(atom)
   206  	s.Require().Error(err)
   207  
   208  	// reset registration
   209  	baseDenom = ""
   210  	denomUnits = map[string]math.LegacyDec{}
   211  }