github.com/Finschia/finschia-sdk@v0.49.1/x/auth/types/genesis_test.go (about)

     1  package types_test
     2  
     3  import (
     4  	"encoding/json"
     5  	"testing"
     6  
     7  	proto "github.com/gogo/protobuf/proto"
     8  	"github.com/stretchr/testify/require"
     9  
    10  	codectypes "github.com/Finschia/finschia-sdk/codec/types"
    11  	"github.com/Finschia/finschia-sdk/crypto/keys/ed25519"
    12  	sdk "github.com/Finschia/finschia-sdk/types"
    13  	"github.com/Finschia/finschia-sdk/x/auth/types"
    14  )
    15  
    16  func TestSanitize(t *testing.T) {
    17  	addr1 := sdk.AccAddress(ed25519.GenPrivKey().PubKey().Address())
    18  	authAcc1 := types.NewBaseAccountWithAddress(addr1)
    19  	err := authAcc1.SetAccountNumber(1)
    20  	require.NoError(t, err)
    21  
    22  	addr2 := sdk.AccAddress(ed25519.GenPrivKey().PubKey().Address())
    23  	authAcc2 := types.NewBaseAccountWithAddress(addr2)
    24  
    25  	genAccs := types.GenesisAccounts{authAcc1, authAcc2}
    26  
    27  	require.True(t, genAccs[0].GetAccountNumber() > genAccs[1].GetAccountNumber())
    28  	require.Equal(t, genAccs[1].GetAddress(), addr2)
    29  	genAccs = types.SanitizeGenesisAccounts(genAccs)
    30  
    31  	require.False(t, genAccs[0].GetAccountNumber() > genAccs[1].GetAccountNumber())
    32  	require.Equal(t, genAccs[1].GetAddress(), addr1)
    33  }
    34  
    35  var (
    36  	pk1   = ed25519.GenPrivKey().PubKey()
    37  	pk2   = ed25519.GenPrivKey().PubKey()
    38  	addr1 = sdk.ValAddress(pk1.Address())
    39  	addr2 = sdk.ValAddress(pk2.Address())
    40  )
    41  
    42  // require duplicate accounts fails validation
    43  func TestValidateGenesisDuplicateAccounts(t *testing.T) {
    44  	acc1 := types.NewBaseAccountWithAddress(sdk.AccAddress(addr1))
    45  
    46  	genAccs := make(types.GenesisAccounts, 2)
    47  	genAccs[0] = acc1
    48  	genAccs[1] = acc1
    49  
    50  	require.Error(t, types.ValidateGenAccounts(genAccs))
    51  }
    52  
    53  func TestGenesisAccountIterator(t *testing.T) {
    54  	acc1 := types.NewBaseAccountWithAddress(sdk.AccAddress(addr1))
    55  	acc2 := types.NewBaseAccountWithAddress(sdk.AccAddress(addr2))
    56  
    57  	genAccounts := types.GenesisAccounts{acc1, acc2}
    58  
    59  	authGenState := types.DefaultGenesisState()
    60  	accounts, err := types.PackAccounts(genAccounts)
    61  	require.NoError(t, err)
    62  	authGenState.Accounts = accounts
    63  
    64  	appGenesis := make(map[string]json.RawMessage)
    65  	authGenStateBz, err := appCodec.MarshalJSON(authGenState)
    66  	require.NoError(t, err)
    67  
    68  	appGenesis[types.ModuleName] = authGenStateBz
    69  
    70  	var addresses []sdk.AccAddress
    71  	types.GenesisAccountIterator{}.IterateGenesisAccounts(
    72  		appCodec, appGenesis, func(acc types.AccountI) (stop bool) {
    73  			addresses = append(addresses, acc.GetAddress())
    74  			return false
    75  		},
    76  	)
    77  
    78  	require.Len(t, addresses, 2)
    79  	require.Equal(t, addresses[0], acc1.GetAddress())
    80  	require.Equal(t, addresses[1], acc2.GetAddress())
    81  }
    82  
    83  func TestPackAccountsAny(t *testing.T) {
    84  	var accounts []*codectypes.Any
    85  
    86  	testCases := []struct {
    87  		msg      string
    88  		malleate func()
    89  		expPass  bool
    90  	}{
    91  		{
    92  			"expected genesis account",
    93  			func() {
    94  				accounts = []*codectypes.Any{{}}
    95  			},
    96  			false,
    97  		},
    98  		{
    99  			"success",
   100  			func() {
   101  				genAccounts := types.GenesisAccounts{&types.BaseAccount{}}
   102  				accounts = make([]*codectypes.Any, len(genAccounts))
   103  
   104  				for i, a := range genAccounts {
   105  					msg, ok := a.(proto.Message)
   106  					require.Equal(t, ok, true)
   107  					any, err := codectypes.NewAnyWithValue(msg)
   108  					require.NoError(t, err)
   109  					accounts[i] = any
   110  				}
   111  			},
   112  			true,
   113  		},
   114  	}
   115  
   116  	for _, tc := range testCases {
   117  		t.Run(tc.msg, func(t *testing.T) {
   118  			tc.malleate()
   119  
   120  			res, err := types.UnpackAccounts(accounts)
   121  
   122  			if tc.expPass {
   123  				require.NoError(t, err)
   124  				require.NotNil(t, res)
   125  				require.Equal(t, len(res), len(accounts))
   126  			} else {
   127  				require.Error(t, err)
   128  				require.Nil(t, res)
   129  			}
   130  		})
   131  	}
   132  }