2020-02-18 04:50:13 -08:00
|
|
|
package types_test
|
2018-01-06 20:54:04 -08:00
|
|
|
|
|
|
|
import (
|
2020-04-20 12:32:10 -07:00
|
|
|
"encoding/json"
|
|
|
|
"errors"
|
|
|
|
"fmt"
|
2018-01-06 20:54:04 -08:00
|
|
|
"testing"
|
|
|
|
|
2018-06-29 18:10:15 -07:00
|
|
|
"github.com/stretchr/testify/require"
|
2019-09-12 12:22:25 -07:00
|
|
|
"github.com/tendermint/tendermint/crypto/secp256k1"
|
2020-04-20 12:32:10 -07:00
|
|
|
yaml "gopkg.in/yaml.v2"
|
2019-01-14 08:11:24 -08:00
|
|
|
|
2020-07-20 05:30:12 -07:00
|
|
|
"github.com/cosmos/cosmos-sdk/testutil/testdata"
|
2018-03-02 01:24:07 -08:00
|
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
2020-02-18 04:50:13 -08:00
|
|
|
"github.com/cosmos/cosmos-sdk/x/auth/types"
|
2018-01-06 20:54:04 -08:00
|
|
|
)
|
|
|
|
|
2018-05-26 14:21:29 -07:00
|
|
|
func TestBaseAddressPubKey(t *testing.T) {
|
2020-07-20 05:30:12 -07:00
|
|
|
_, pub1, addr1 := testdata.KeyTestPubAddr()
|
|
|
|
_, pub2, addr2 := testdata.KeyTestPubAddr()
|
2020-02-18 04:50:13 -08:00
|
|
|
acc := types.NewBaseAccountWithAddress(addr1)
|
2018-01-06 20:54:04 -08:00
|
|
|
|
2018-03-17 13:20:24 -07:00
|
|
|
// check the address (set) and pubkey (not set)
|
2018-06-29 18:10:15 -07:00
|
|
|
require.EqualValues(t, addr1, acc.GetAddress())
|
|
|
|
require.EqualValues(t, nil, acc.GetPubKey())
|
2018-01-17 16:42:05 -08:00
|
|
|
|
2018-03-17 13:53:27 -07:00
|
|
|
// can't override address
|
2018-03-17 13:20:24 -07:00
|
|
|
err := acc.SetAddress(addr2)
|
2018-06-29 18:10:15 -07:00
|
|
|
require.NotNil(t, err)
|
|
|
|
require.EqualValues(t, addr1, acc.GetAddress())
|
2018-03-17 13:20:24 -07:00
|
|
|
|
|
|
|
// set the pubkey
|
|
|
|
err = acc.SetPubKey(pub1)
|
2018-06-29 18:10:15 -07:00
|
|
|
require.Nil(t, err)
|
|
|
|
require.Equal(t, pub1, acc.GetPubKey())
|
2018-01-06 20:54:04 -08:00
|
|
|
|
2018-05-06 22:13:32 -07:00
|
|
|
// can override pubkey
|
2018-03-17 13:20:24 -07:00
|
|
|
err = acc.SetPubKey(pub2)
|
2018-06-29 18:10:15 -07:00
|
|
|
require.Nil(t, err)
|
|
|
|
require.Equal(t, pub2, acc.GetPubKey())
|
2018-01-06 20:54:04 -08:00
|
|
|
|
2018-03-17 13:20:24 -07:00
|
|
|
//------------------------------------
|
|
|
|
|
|
|
|
// can set address on empty account
|
2020-02-18 04:50:13 -08:00
|
|
|
acc2 := types.BaseAccount{}
|
2018-03-17 13:20:24 -07:00
|
|
|
err = acc2.SetAddress(addr2)
|
2018-06-29 18:10:15 -07:00
|
|
|
require.Nil(t, err)
|
|
|
|
require.EqualValues(t, addr2, acc2.GetAddress())
|
2018-03-17 13:20:24 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestBaseAccountSequence(t *testing.T) {
|
2020-07-20 05:30:12 -07:00
|
|
|
_, _, addr := testdata.KeyTestPubAddr()
|
2020-02-18 04:50:13 -08:00
|
|
|
acc := types.NewBaseAccountWithAddress(addr)
|
2018-11-26 03:29:21 -08:00
|
|
|
seq := uint64(7)
|
2018-03-17 13:20:24 -07:00
|
|
|
|
|
|
|
err := acc.SetSequence(seq)
|
2018-06-29 18:10:15 -07:00
|
|
|
require.Nil(t, err)
|
|
|
|
require.Equal(t, seq, acc.GetSequence())
|
2018-03-17 13:20:24 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestBaseAccountMarshal(t *testing.T) {
|
2020-07-20 05:30:12 -07:00
|
|
|
_, pub, addr := testdata.KeyTestPubAddr()
|
2020-02-18 04:50:13 -08:00
|
|
|
acc := types.NewBaseAccountWithAddress(addr)
|
2018-11-26 03:29:21 -08:00
|
|
|
seq := uint64(7)
|
2018-03-17 13:20:24 -07:00
|
|
|
|
|
|
|
// set everything on the account
|
|
|
|
err := acc.SetPubKey(pub)
|
2018-06-29 18:10:15 -07:00
|
|
|
require.Nil(t, err)
|
2018-03-17 13:20:24 -07:00
|
|
|
err = acc.SetSequence(seq)
|
2018-06-29 18:10:15 -07:00
|
|
|
require.Nil(t, err)
|
2018-03-17 13:20:24 -07:00
|
|
|
|
2020-05-20 12:21:00 -07:00
|
|
|
bz, err := app.AccountKeeper.MarshalAccount(acc)
|
2018-06-29 18:10:15 -07:00
|
|
|
require.Nil(t, err)
|
2018-01-06 20:54:04 -08:00
|
|
|
|
2020-05-20 12:21:00 -07:00
|
|
|
acc2, err := app.AccountKeeper.UnmarshalAccount(bz)
|
2018-06-29 18:10:15 -07:00
|
|
|
require.Nil(t, err)
|
|
|
|
require.Equal(t, acc, acc2)
|
2018-01-06 20:54:04 -08:00
|
|
|
|
2018-03-17 13:20:24 -07:00
|
|
|
// error on bad bytes
|
2020-05-20 12:21:00 -07:00
|
|
|
_, err = app.AccountKeeper.UnmarshalAccount(bz[:len(bz)/2])
|
2018-06-29 18:10:15 -07:00
|
|
|
require.NotNil(t, err)
|
2018-03-17 13:20:24 -07:00
|
|
|
}
|
2019-01-14 08:11:24 -08:00
|
|
|
|
2019-09-12 12:22:25 -07:00
|
|
|
func TestGenesisAccountValidate(t *testing.T) {
|
|
|
|
pubkey := secp256k1.GenPrivKey().PubKey()
|
|
|
|
addr := sdk.AccAddress(pubkey.Address())
|
2020-02-18 04:50:13 -08:00
|
|
|
baseAcc := types.NewBaseAccount(addr, pubkey, 0, 0)
|
|
|
|
|
2019-09-12 12:22:25 -07:00
|
|
|
tests := []struct {
|
|
|
|
name string
|
2020-05-20 12:21:00 -07:00
|
|
|
acc types.GenesisAccount
|
2020-02-20 08:15:22 -08:00
|
|
|
expErr bool
|
2019-09-12 12:22:25 -07:00
|
|
|
}{
|
|
|
|
{
|
|
|
|
"valid base account",
|
|
|
|
baseAcc,
|
2020-02-20 08:15:22 -08:00
|
|
|
false,
|
2019-09-12 12:22:25 -07:00
|
|
|
},
|
|
|
|
{
|
|
|
|
"invalid base valid account",
|
2020-02-18 04:50:13 -08:00
|
|
|
types.NewBaseAccount(addr, secp256k1.GenPrivKey().PubKey(), 0, 0),
|
2020-02-20 08:15:22 -08:00
|
|
|
true,
|
2019-09-12 12:22:25 -07:00
|
|
|
},
|
|
|
|
}
|
2020-02-18 04:50:13 -08:00
|
|
|
|
2019-09-12 12:22:25 -07:00
|
|
|
for _, tt := range tests {
|
2019-10-17 06:47:35 -07:00
|
|
|
tt := tt
|
2020-02-18 04:50:13 -08:00
|
|
|
|
2019-09-12 12:22:25 -07:00
|
|
|
t.Run(tt.name, func(t *testing.T) {
|
2020-02-20 08:15:22 -08:00
|
|
|
require.Equal(t, tt.expErr, tt.acc.Validate() != nil)
|
2019-09-12 12:22:25 -07:00
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
2020-04-20 12:32:10 -07:00
|
|
|
|
|
|
|
func TestModuleAccountMarshalYAML(t *testing.T) {
|
|
|
|
name := "test"
|
|
|
|
moduleAcc := types.NewEmptyModuleAccount(name, types.Minter, types.Burner, types.Staking)
|
|
|
|
bs, err := yaml.Marshal(moduleAcc)
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
want := "|\n address: cosmos1n7rdpqvgf37ktx30a2sv2kkszk3m7ncmg5drhe\n public_key: \"\"\n account_number: 0\n sequence: 0\n name: test\n permissions:\n - minter\n - burner\n - staking\n"
|
|
|
|
require.Equal(t, want, string(bs))
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestHasPermissions(t *testing.T) {
|
|
|
|
name := "test"
|
|
|
|
macc := types.NewEmptyModuleAccount(name, types.Staking, types.Minter, types.Burner)
|
|
|
|
cases := []struct {
|
|
|
|
permission string
|
|
|
|
expectHas bool
|
|
|
|
}{
|
|
|
|
{types.Staking, true},
|
|
|
|
{types.Minter, true},
|
|
|
|
{types.Burner, true},
|
|
|
|
{"other", false},
|
|
|
|
}
|
|
|
|
|
|
|
|
for i, tc := range cases {
|
|
|
|
hasPerm := macc.HasPermission(tc.permission)
|
|
|
|
if tc.expectHas {
|
|
|
|
require.True(t, hasPerm, "test case #%d", i)
|
|
|
|
} else {
|
|
|
|
require.False(t, hasPerm, "test case #%d", i)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestValidate(t *testing.T) {
|
|
|
|
addr := sdk.AccAddress(secp256k1.GenPrivKey().PubKey().Address())
|
|
|
|
baseAcc := types.NewBaseAccount(addr, nil, 0, 0)
|
|
|
|
tests := []struct {
|
|
|
|
name string
|
2020-05-20 12:21:00 -07:00
|
|
|
acc types.GenesisAccount
|
2020-04-20 12:32:10 -07:00
|
|
|
expErr error
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
"valid module account",
|
|
|
|
types.NewEmptyModuleAccount("test"),
|
|
|
|
nil,
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"invalid name and address pair",
|
|
|
|
types.NewModuleAccount(baseAcc, "test"),
|
|
|
|
fmt.Errorf("address %s cannot be derived from the module name 'test'", addr),
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"empty module account name",
|
|
|
|
types.NewModuleAccount(baseAcc, " "),
|
|
|
|
errors.New("module account name cannot be blank"),
|
|
|
|
},
|
|
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
|
|
tt := tt
|
|
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
|
|
err := tt.acc.Validate()
|
|
|
|
require.Equal(t, tt.expErr, err)
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestModuleAccountJSON(t *testing.T) {
|
|
|
|
pubkey := secp256k1.GenPrivKey().PubKey()
|
|
|
|
addr := sdk.AccAddress(pubkey.Address())
|
|
|
|
baseAcc := types.NewBaseAccount(addr, nil, 10, 50)
|
|
|
|
acc := types.NewModuleAccount(baseAcc, "test", "burner")
|
|
|
|
|
|
|
|
bz, err := json.Marshal(acc)
|
|
|
|
require.NoError(t, err)
|
|
|
|
|
|
|
|
bz1, err := acc.MarshalJSON()
|
|
|
|
require.NoError(t, err)
|
|
|
|
require.Equal(t, string(bz1), string(bz))
|
|
|
|
|
|
|
|
var a types.ModuleAccount
|
|
|
|
require.NoError(t, json.Unmarshal(bz, &a))
|
|
|
|
require.Equal(t, acc.String(), a.String())
|
|
|
|
}
|
2020-05-20 12:21:00 -07:00
|
|
|
|
|
|
|
func TestGenesisAccountsContains(t *testing.T) {
|
|
|
|
pubkey := secp256k1.GenPrivKey().PubKey()
|
|
|
|
addr := sdk.AccAddress(pubkey.Address())
|
|
|
|
acc := types.NewBaseAccount(addr, secp256k1.GenPrivKey().PubKey(), 0, 0)
|
|
|
|
|
|
|
|
genAccounts := types.GenesisAccounts{}
|
|
|
|
require.False(t, genAccounts.Contains(acc.GetAddress()))
|
|
|
|
|
|
|
|
genAccounts = append(genAccounts, acc)
|
|
|
|
require.True(t, genAccounts.Contains(acc.GetAddress()))
|
|
|
|
}
|