github.com/Finschia/finschia-sdk@v0.48.1/x/staking/types/msg_test.go (about)

     1  package types_test
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/require"
     7  
     8  	"github.com/Finschia/finschia-sdk/codec"
     9  	codectypes "github.com/Finschia/finschia-sdk/codec/types"
    10  	cryptocodec "github.com/Finschia/finschia-sdk/crypto/codec"
    11  	"github.com/Finschia/finschia-sdk/crypto/keys/ed25519"
    12  	cryptotypes "github.com/Finschia/finschia-sdk/crypto/types"
    13  	sdk "github.com/Finschia/finschia-sdk/types"
    14  	"github.com/Finschia/finschia-sdk/x/staking/types"
    15  )
    16  
    17  var (
    18  	coinPos  = sdk.NewInt64Coin(sdk.DefaultBondDenom, 1000)
    19  	coinZero = sdk.NewInt64Coin(sdk.DefaultBondDenom, 0)
    20  )
    21  
    22  func TestMsgDecode(t *testing.T) {
    23  	registry := codectypes.NewInterfaceRegistry()
    24  	cryptocodec.RegisterInterfaces(registry)
    25  	types.RegisterInterfaces(registry)
    26  	cdc := codec.NewProtoCodec(registry)
    27  
    28  	// firstly we start testing the pubkey serialization
    29  
    30  	pk1bz, err := cdc.MarshalInterface(pk1)
    31  	require.NoError(t, err)
    32  	var pkUnmarshaled cryptotypes.PubKey
    33  	err = cdc.UnmarshalInterface(pk1bz, &pkUnmarshaled)
    34  	require.NoError(t, err)
    35  	require.True(t, pk1.Equals(pkUnmarshaled.(*ed25519.PubKey)))
    36  
    37  	// now let's try to serialize the whole message
    38  
    39  	commission1 := types.NewCommissionRates(sdk.ZeroDec(), sdk.ZeroDec(), sdk.ZeroDec())
    40  	msg, err := types.NewMsgCreateValidator(valAddr1, pk1, coinPos, types.Description{}, commission1, sdk.OneInt())
    41  	require.NoError(t, err)
    42  	msgSerialized, err := cdc.MarshalInterface(msg)
    43  	require.NoError(t, err)
    44  
    45  	var msgUnmarshaled sdk.Msg
    46  	err = cdc.UnmarshalInterface(msgSerialized, &msgUnmarshaled)
    47  	require.NoError(t, err)
    48  	msg2, ok := msgUnmarshaled.(*types.MsgCreateValidator)
    49  	require.True(t, ok)
    50  	require.True(t, msg.Value.IsEqual(msg2.Value))
    51  	require.True(t, msg.Pubkey.Equal(msg2.Pubkey))
    52  }
    53  
    54  // test ValidateBasic for MsgCreateValidator
    55  func TestMsgCreateValidator(t *testing.T) {
    56  	commission1 := types.NewCommissionRates(sdk.ZeroDec(), sdk.ZeroDec(), sdk.ZeroDec())
    57  	commission2 := types.NewCommissionRates(sdk.NewDec(5), sdk.NewDec(5), sdk.NewDec(5))
    58  
    59  	tests := []struct {
    60  		name, moniker, identity, website, securityContact, details string
    61  		CommissionRates                                            types.CommissionRates
    62  		minSelfDelegation                                          sdk.Int
    63  		validatorAddr                                              sdk.ValAddress
    64  		pubkey                                                     cryptotypes.PubKey
    65  		bond                                                       sdk.Coin
    66  		expectPass                                                 bool
    67  	}{
    68  		{"basic good", "a", "b", "c", "d", "e", commission1, sdk.OneInt(), valAddr1, pk1, coinPos, true},
    69  		{"partial description", "", "", "c", "", "", commission1, sdk.OneInt(), valAddr1, pk1, coinPos, true},
    70  		{"empty description", "", "", "", "", "", commission2, sdk.OneInt(), valAddr1, pk1, coinPos, false},
    71  		{"empty address", "a", "b", "c", "d", "e", commission2, sdk.OneInt(), emptyAddr, pk1, coinPos, false},
    72  		{"empty pubkey", "a", "b", "c", "d", "e", commission1, sdk.OneInt(), valAddr1, emptyPubkey, coinPos, false},
    73  		{"empty bond", "a", "b", "c", "d", "e", commission2, sdk.OneInt(), valAddr1, pk1, coinZero, false},
    74  		{"nil bond", "a", "b", "c", "d", "e", commission2, sdk.OneInt(), valAddr1, pk1, sdk.Coin{}, false},
    75  		{"zero min self delegation", "a", "b", "c", "d", "e", commission1, sdk.ZeroInt(), valAddr1, pk1, coinPos, false},
    76  		{"negative min self delegation", "a", "b", "c", "d", "e", commission1, sdk.NewInt(-1), valAddr1, pk1, coinPos, false},
    77  		{"delegation less than min self delegation", "a", "b", "c", "d", "e", commission1, coinPos.Amount.Add(sdk.OneInt()), valAddr1, pk1, coinPos, false},
    78  	}
    79  
    80  	for _, tc := range tests {
    81  		description := types.NewDescription(tc.moniker, tc.identity, tc.website, tc.securityContact, tc.details)
    82  		msg, err := types.NewMsgCreateValidator(tc.validatorAddr, tc.pubkey, tc.bond, description, tc.CommissionRates, tc.minSelfDelegation)
    83  		require.NoError(t, err)
    84  		if tc.expectPass {
    85  			require.Nil(t, msg.ValidateBasic(), "test: %v", tc.name)
    86  		} else {
    87  			require.NotNil(t, msg.ValidateBasic(), "test: %v", tc.name)
    88  		}
    89  	}
    90  }
    91  
    92  // test ValidateBasic for MsgEditValidator
    93  func TestMsgEditValidator(t *testing.T) {
    94  	tests := []struct {
    95  		name, moniker, identity, website, securityContact, details string
    96  		validatorAddr                                              sdk.ValAddress
    97  		expectPass                                                 bool
    98  		minSelfDelegation                                          sdk.Int
    99  	}{
   100  		{"basic good", "a", "b", "c", "d", "e", valAddr1, true, sdk.OneInt()},
   101  		{"partial description", "", "", "c", "", "", valAddr1, true, sdk.OneInt()},
   102  		{"empty description", "", "", "", "", "", valAddr1, false, sdk.OneInt()},
   103  		{"empty address", "a", "b", "c", "d", "e", emptyAddr, false, sdk.OneInt()},
   104  		{"nil int", "a", "b", "c", "d", "e", emptyAddr, false, sdk.Int{}},
   105  	}
   106  
   107  	for _, tc := range tests {
   108  		description := types.NewDescription(tc.moniker, tc.identity, tc.website, tc.securityContact, tc.details)
   109  		newRate := sdk.ZeroDec()
   110  
   111  		msg := types.NewMsgEditValidator(tc.validatorAddr, description, &newRate, &tc.minSelfDelegation)
   112  		if tc.expectPass {
   113  			require.Nil(t, msg.ValidateBasic(), "test: %v", tc.name)
   114  		} else {
   115  			require.NotNil(t, msg.ValidateBasic(), "test: %v", tc.name)
   116  		}
   117  	}
   118  }
   119  
   120  // test ValidateBasic for MsgDelegate
   121  func TestMsgDelegate(t *testing.T) {
   122  	tests := []struct {
   123  		name          string
   124  		delegatorAddr sdk.AccAddress
   125  		validatorAddr sdk.ValAddress
   126  		bond          sdk.Coin
   127  		expectPass    bool
   128  	}{
   129  		{"basic good", sdk.AccAddress(valAddr1), valAddr2, coinPos, true},
   130  		{"self bond", sdk.AccAddress(valAddr1), valAddr1, coinPos, true},
   131  		{"empty delegator", sdk.AccAddress(emptyAddr), valAddr1, coinPos, false},
   132  		{"empty validator", sdk.AccAddress(valAddr1), emptyAddr, coinPos, false},
   133  		{"empty bond", sdk.AccAddress(valAddr1), valAddr2, coinZero, false},
   134  		{"nil bold", sdk.AccAddress(valAddr1), valAddr2, sdk.Coin{}, false},
   135  	}
   136  
   137  	for _, tc := range tests {
   138  		msg := types.NewMsgDelegate(tc.delegatorAddr, tc.validatorAddr, tc.bond)
   139  		if tc.expectPass {
   140  			require.Nil(t, msg.ValidateBasic(), "test: %v", tc.name)
   141  		} else {
   142  			require.NotNil(t, msg.ValidateBasic(), "test: %v", tc.name)
   143  		}
   144  	}
   145  }
   146  
   147  // test ValidateBasic for MsgUnbond
   148  func TestMsgBeginRedelegate(t *testing.T) {
   149  	tests := []struct {
   150  		name             string
   151  		delegatorAddr    sdk.AccAddress
   152  		validatorSrcAddr sdk.ValAddress
   153  		validatorDstAddr sdk.ValAddress
   154  		amount           sdk.Coin
   155  		expectPass       bool
   156  	}{
   157  		{"regular", sdk.AccAddress(valAddr1), valAddr2, valAddr3, sdk.NewInt64Coin(sdk.DefaultBondDenom, 1), true},
   158  		{"zero amount", sdk.AccAddress(valAddr1), valAddr2, valAddr3, sdk.NewInt64Coin(sdk.DefaultBondDenom, 0), false},
   159  		{"nil amount", sdk.AccAddress(valAddr1), valAddr2, valAddr3, sdk.Coin{}, false},
   160  		{"empty delegator", sdk.AccAddress(emptyAddr), valAddr1, valAddr3, sdk.NewInt64Coin(sdk.DefaultBondDenom, 1), false},
   161  		{"empty source validator", sdk.AccAddress(valAddr1), emptyAddr, valAddr3, sdk.NewInt64Coin(sdk.DefaultBondDenom, 1), false},
   162  		{"empty destination validator", sdk.AccAddress(valAddr1), valAddr2, emptyAddr, sdk.NewInt64Coin(sdk.DefaultBondDenom, 1), false},
   163  	}
   164  
   165  	for _, tc := range tests {
   166  		msg := types.NewMsgBeginRedelegate(tc.delegatorAddr, tc.validatorSrcAddr, tc.validatorDstAddr, tc.amount)
   167  		if tc.expectPass {
   168  			require.Nil(t, msg.ValidateBasic(), "test: %v", tc.name)
   169  		} else {
   170  			require.NotNil(t, msg.ValidateBasic(), "test: %v", tc.name)
   171  		}
   172  	}
   173  }
   174  
   175  // test ValidateBasic for MsgUnbond
   176  func TestMsgUndelegate(t *testing.T) {
   177  	tests := []struct {
   178  		name          string
   179  		delegatorAddr sdk.AccAddress
   180  		validatorAddr sdk.ValAddress
   181  		amount        sdk.Coin
   182  		expectPass    bool
   183  	}{
   184  		{"regular", sdk.AccAddress(valAddr1), valAddr2, sdk.NewInt64Coin(sdk.DefaultBondDenom, 1), true},
   185  		{"zero amount", sdk.AccAddress(valAddr1), valAddr2, sdk.NewInt64Coin(sdk.DefaultBondDenom, 0), false},
   186  		{"nil amount", sdk.AccAddress(valAddr1), valAddr2, sdk.Coin{}, false},
   187  		{"empty delegator", sdk.AccAddress(emptyAddr), valAddr1, sdk.NewInt64Coin(sdk.DefaultBondDenom, 1), false},
   188  		{"empty validator", sdk.AccAddress(valAddr1), emptyAddr, sdk.NewInt64Coin(sdk.DefaultBondDenom, 1), false},
   189  	}
   190  
   191  	for _, tc := range tests {
   192  		msg := types.NewMsgUndelegate(tc.delegatorAddr, tc.validatorAddr, tc.amount)
   193  		if tc.expectPass {
   194  			require.Nil(t, msg.ValidateBasic(), "test: %v", tc.name)
   195  		} else {
   196  			require.NotNil(t, msg.ValidateBasic(), "test: %v", tc.name)
   197  		}
   198  	}
   199  }