github.com/fibonacci-chain/fbc@v0.0.0-20231124064014-c7636198c1e9/x/farm/types/msg_test.go (about)

     1  //go:build ignore
     2  
     3  package types
     4  
     5  import (
     6  	"testing"
     7  
     8  	sdk "github.com/fibonacci-chain/fbc/libs/cosmos-sdk/types"
     9  	"github.com/stretchr/testify/require"
    10  )
    11  
    12  func testCode(t *testing.T, err sdk.Error, expectedCode uint32) {
    13  	if expectedCode != 0 {
    14  		require.NotNil(t, err)
    15  	} else {
    16  		require.Nil(t, err)
    17  	}
    18  }
    19  
    20  func TestMsgCreatePool(t *testing.T) {
    21  	negMinLockAmount := sdk.NewDecCoinFromDec("xxb", sdk.ZeroDec())
    22  	negMinLockAmount.Amount = sdk.NewDec(-1)
    23  	tests := []struct {
    24  		owner         sdk.AccAddress
    25  		poolName      string
    26  		minLockAmount sdk.SysCoin
    27  		yieldedSymbol string
    28  		errCode       uint32
    29  	}{
    30  		{sdk.AccAddress{0x1}, "pool", sdk.NewDecCoinFromDec("xxb", sdk.ZeroDec()), "wwb", sdk.CodeOK},
    31  		{nil, "pool", sdk.NewDecCoinFromDec("xxb", sdk.ZeroDec()), "wwb", sdk.CodeInvalidAddress},
    32  		{sdk.AccAddress{0x1}, "", sdk.NewDecCoinFromDec("xxb", sdk.ZeroDec()), "wwb", CodeInvalidInput},
    33  		{sdk.AccAddress{0x1}, "pool", negMinLockAmount, "wwb", sdk.CodeOK},
    34  		{sdk.AccAddress{0x1}, "pool", sdk.NewDecCoinFromDec("xxb", sdk.ZeroDec()), "", CodeInvalidInput},
    35  	}
    36  
    37  	for _, test := range tests {
    38  		msg := NewMsgCreatePool(test.owner, test.poolName, test.minLockAmount, test.yieldedSymbol)
    39  		require.Equal(t, createPoolMsgType, msg.Type())
    40  		require.Equal(t, ModuleName, msg.Route())
    41  		require.Equal(t, []sdk.AccAddress{test.owner}, msg.GetSigners())
    42  		require.Equal(t, sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(msg)), msg.GetSignBytes())
    43  		err := msg.ValidateBasic()
    44  		if test.errCode != sdk.CodeOK {
    45  			require.Error(t, err)
    46  			testCode(t, err, test.errCode)
    47  		}
    48  	}
    49  }
    50  
    51  func TestMsgDestroyPool(t *testing.T) {
    52  	tests := []struct {
    53  		owner    sdk.AccAddress
    54  		poolName string
    55  		errCode  uint32
    56  	}{
    57  		{sdk.AccAddress{0x1}, "pool", sdk.CodeOK},
    58  		{nil, "pool", CodeInvalidAddress},
    59  		{sdk.AccAddress{0x1}, "", CodeInvalidInput},
    60  	}
    61  
    62  	for _, test := range tests {
    63  		msg := NewMsgDestroyPool(test.owner, test.poolName)
    64  		require.Equal(t, destroyPoolMsgType, msg.Type())
    65  		require.Equal(t, ModuleName, msg.Route())
    66  		require.Equal(t, []sdk.AccAddress{test.owner}, msg.GetSigners())
    67  		require.Equal(t, sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(msg)), msg.GetSignBytes())
    68  		err := msg.ValidateBasic()
    69  		if test.errCode != sdk.CodeOK {
    70  			require.Error(t, err)
    71  			testCode(t, err, test.errCode)
    72  		}
    73  	}
    74  }
    75  
    76  func TestMsgProvide(t *testing.T) {
    77  	tests := []struct {
    78  		poolName         string
    79  		owner            sdk.AccAddress
    80  		amount           sdk.SysCoin
    81  		yieldPerBlock    sdk.Dec
    82  		startBlockHeight int64
    83  		errCode          uint32
    84  	}{
    85  		{
    86  			"pool",
    87  			sdk.AccAddress{0x1},
    88  			sdk.NewDecCoinFromDec("xxb", sdk.NewDec(100)),
    89  			sdk.NewDec(10),
    90  			1,
    91  			sdk.CodeOK,
    92  		},
    93  		{
    94  			"pool",
    95  			sdk.AccAddress{0x1},
    96  			sdk.NewDecCoinFromDec("xxb", sdk.NewDec(100)),
    97  			sdk.NewDec(100),
    98  			1,
    99  			sdk.CodeOK,
   100  		},
   101  		{
   102  			"pool",
   103  			sdk.AccAddress{0x1},
   104  			sdk.NewDecCoinFromDec("xxb", sdk.NewDec(100)),
   105  			sdk.NewDec(1000),
   106  			1,
   107  			CodeInvalidInput,
   108  		},
   109  		{
   110  			"pool",
   111  			nil,
   112  			sdk.NewDecCoinFromDec("xxb", sdk.NewDec(100)),
   113  			sdk.NewDec(10),
   114  			1,
   115  			CodeInvalidAddress,
   116  		},
   117  		{
   118  			"",
   119  			sdk.AccAddress{0x1},
   120  			sdk.NewDecCoinFromDec("xxb", sdk.NewDec(100)),
   121  			sdk.NewDec(10),
   122  			1,
   123  			CodeInvalidInput,
   124  		},
   125  		{
   126  			"pool",
   127  			sdk.AccAddress{0x1},
   128  			sdk.NewDecCoinFromDec("xxb", sdk.NewDec(0)),
   129  			sdk.NewDec(10),
   130  			1,
   131  			CodeInvalidInput,
   132  		},
   133  		{
   134  			"pool",
   135  			sdk.AccAddress{0x1},
   136  			sdk.NewDecCoinFromDec("xxb", sdk.NewDec(100)),
   137  			sdk.NewDec(0),
   138  			1,
   139  			CodeInvalidInput,
   140  		},
   141  		{
   142  			"pool",
   143  			sdk.AccAddress{0x1},
   144  			sdk.NewDecCoinFromDec("xxb", sdk.NewDec(100)),
   145  			sdk.NewDec(10),
   146  			0,
   147  			CodeInvalidInput,
   148  		},
   149  	}
   150  
   151  	for _, test := range tests {
   152  		msg := NewMsgProvide(test.poolName, test.owner, test.amount, test.yieldPerBlock, test.startBlockHeight)
   153  		require.Equal(t, provideMsgType, msg.Type())
   154  		require.Equal(t, ModuleName, msg.Route())
   155  		require.Equal(t, []sdk.AccAddress{test.owner}, msg.GetSigners())
   156  		require.Equal(t, sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(msg)), msg.GetSignBytes())
   157  		err := msg.ValidateBasic()
   158  		if test.errCode != sdk.CodeOK {
   159  			require.Error(t, err)
   160  			testCode(t, err, test.errCode)
   161  		}
   162  	}
   163  }
   164  
   165  func TestMsgLock(t *testing.T) {
   166  	tests := []struct {
   167  		poolName string
   168  		addr     sdk.AccAddress
   169  		amount   sdk.SysCoin
   170  		errCode  uint32
   171  	}{
   172  		{
   173  			"pool",
   174  			sdk.AccAddress{0x1},
   175  			sdk.NewDecCoinFromDec("xxb", sdk.NewDec(100)),
   176  			sdk.CodeOK,
   177  		},
   178  		{
   179  			"pool",
   180  			nil,
   181  			sdk.NewDecCoinFromDec("xxb", sdk.NewDec(100)),
   182  			CodeInvalidAddress,
   183  		},
   184  		{
   185  			"",
   186  			sdk.AccAddress{0x1},
   187  			sdk.NewDecCoinFromDec("xxb", sdk.NewDec(100)),
   188  			CodeInvalidInput,
   189  		},
   190  		{
   191  			"pool",
   192  			sdk.AccAddress{0x1},
   193  			sdk.NewDecCoinFromDec("xxb", sdk.NewDec(0)),
   194  			CodeInvalidInput,
   195  		},
   196  	}
   197  
   198  	for _, test := range tests {
   199  		msg := NewMsgLock(test.poolName, test.addr, test.amount)
   200  		require.Equal(t, lockMsgType, msg.Type())
   201  		require.Equal(t, ModuleName, msg.Route())
   202  		require.Equal(t, []sdk.AccAddress{test.addr}, msg.GetSigners())
   203  		require.Equal(t, sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(msg)), msg.GetSignBytes())
   204  		err := msg.ValidateBasic()
   205  		if test.errCode != sdk.CodeOK {
   206  			require.Error(t, err)
   207  			testCode(t, err, test.errCode)
   208  		}
   209  	}
   210  }
   211  
   212  func TestMsgUnlock(t *testing.T) {
   213  	tests := []struct {
   214  		poolName string
   215  		addr     sdk.AccAddress
   216  		amount   sdk.SysCoin
   217  		errCode  uint32
   218  	}{
   219  		{
   220  			"pool",
   221  			sdk.AccAddress{0x1},
   222  			sdk.NewDecCoinFromDec("xxb", sdk.NewDec(100)),
   223  			sdk.CodeOK,
   224  		},
   225  		{
   226  			"pool",
   227  			nil,
   228  			sdk.NewDecCoinFromDec("xxb", sdk.NewDec(100)),
   229  			CodeInvalidAddress,
   230  		},
   231  		{
   232  			"",
   233  			sdk.AccAddress{0x1},
   234  			sdk.NewDecCoinFromDec("xxb", sdk.NewDec(100)),
   235  			CodeInvalidInput,
   236  		},
   237  		{
   238  			"pool",
   239  			sdk.AccAddress{0x1},
   240  			sdk.NewDecCoinFromDec("xxb", sdk.NewDec(0)),
   241  			CodeInvalidInput,
   242  		},
   243  	}
   244  
   245  	for _, test := range tests {
   246  		msg := NewMsgUnlock(test.poolName, test.addr, test.amount)
   247  		require.Equal(t, unlockMsgType, msg.Type())
   248  		require.Equal(t, ModuleName, msg.Route())
   249  		require.Equal(t, []sdk.AccAddress{test.addr}, msg.GetSigners())
   250  		require.Equal(t, sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(msg)), msg.GetSignBytes())
   251  		err := msg.ValidateBasic()
   252  		if test.errCode != sdk.CodeOK {
   253  			require.Error(t, err)
   254  			testCode(t, err, test.errCode)
   255  		}
   256  	}
   257  }
   258  
   259  func TestMsgClaim(t *testing.T) {
   260  	tests := []struct {
   261  		poolName string
   262  		addr     sdk.AccAddress
   263  		amount   sdk.SysCoin
   264  		errCode  uint32
   265  	}{
   266  		{
   267  			"pool",
   268  			sdk.AccAddress{0x1},
   269  			sdk.NewDecCoinFromDec("xxb", sdk.NewDec(100)),
   270  			sdk.CodeOK,
   271  		},
   272  		{
   273  			"pool",
   274  			nil,
   275  			sdk.NewDecCoinFromDec("xxb", sdk.NewDec(100)),
   276  			CodeInvalidAddress,
   277  		},
   278  		{
   279  			"",
   280  			sdk.AccAddress{0x1},
   281  			sdk.NewDecCoinFromDec("xxb", sdk.NewDec(100)),
   282  			CodeInvalidInput,
   283  		},
   284  	}
   285  
   286  	for _, test := range tests {
   287  		msg := NewMsgClaim(test.poolName, test.addr)
   288  		require.Equal(t, claimMsgType, msg.Type())
   289  		require.Equal(t, ModuleName, msg.Route())
   290  		require.Equal(t, []sdk.AccAddress{test.addr}, msg.GetSigners())
   291  		require.Equal(t, sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(msg)), msg.GetSignBytes())
   292  		err := msg.ValidateBasic()
   293  		if test.errCode != sdk.CodeOK {
   294  			require.Error(t, err)
   295  			testCode(t, err, test.errCode)
   296  		}
   297  	}
   298  }