github.com/Finschia/finschia-sdk@v0.49.1/client/keys/show_test.go (about)

     1  package keys
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  	"testing"
     7  
     8  	"github.com/stretchr/testify/require"
     9  
    10  	"github.com/Finschia/finschia-sdk/client"
    11  	"github.com/Finschia/finschia-sdk/client/flags"
    12  	"github.com/Finschia/finschia-sdk/crypto/hd"
    13  	"github.com/Finschia/finschia-sdk/crypto/keyring"
    14  	"github.com/Finschia/finschia-sdk/crypto/keys/multisig"
    15  	"github.com/Finschia/finschia-sdk/crypto/keys/secp256k1"
    16  	cryptotypes "github.com/Finschia/finschia-sdk/crypto/types"
    17  	"github.com/Finschia/finschia-sdk/testutil"
    18  	"github.com/Finschia/finschia-sdk/testutil/testdata"
    19  	sdk "github.com/Finschia/finschia-sdk/types"
    20  )
    21  
    22  func Test_multiSigKey_Properties(t *testing.T) {
    23  	tmpKey1 := secp256k1.GenPrivKeyFromSecret([]byte("mySecret"))
    24  	pk := multisig.NewLegacyAminoPubKey(
    25  		1,
    26  		[]cryptotypes.PubKey{tmpKey1.PubKey()},
    27  	)
    28  	tmp, err := keyring.NewMultiInfo("myMultisig", pk)
    29  	require.NoError(t, err)
    30  	require.Equal(t, "myMultisig", tmp.GetName())
    31  	require.Equal(t, keyring.TypeMulti, tmp.GetType())
    32  	require.Equal(t, "D3923267FA8A3DD367BB768FA8BDC8FF7F89DA3F", tmp.GetPubKey().Address().String())
    33  	require.Equal(t, "link16wfryel63g7axeamw68630wglalcnk3l6vulks", sdk.MustBech32ifyAddressBytes("link", tmp.GetAddress()))
    34  }
    35  
    36  func Test_showKeysCmd(t *testing.T) {
    37  	cmd := ShowKeysCmd()
    38  	require.NotNil(t, cmd)
    39  	require.Equal(t, "false", cmd.Flag(FlagAddress).DefValue)
    40  	require.Equal(t, "false", cmd.Flag(FlagPublicKey).DefValue)
    41  }
    42  
    43  func Test_runShowCmd(t *testing.T) {
    44  	cmd := ShowKeysCmd()
    45  	cmd.Flags().AddFlagSet(Commands("home").PersistentFlags())
    46  	mockIn := testutil.ApplyMockIODiscardOutErr(cmd)
    47  
    48  	kbHome := t.TempDir()
    49  	kb, err := keyring.New(sdk.KeyringServiceName(), keyring.BackendTest, kbHome, mockIn)
    50  	require.NoError(t, err)
    51  
    52  	clientCtx := client.Context{}.
    53  		WithKeyringDir(kbHome).
    54  		WithKeyring(kb)
    55  	ctx := context.WithValue(context.Background(), client.ClientContextKey, &clientCtx)
    56  
    57  	cmd.SetArgs([]string{"invalid"})
    58  	require.EqualError(t, cmd.ExecuteContext(ctx), "invalid is not a valid name or address: decoding bech32 failed: invalid bech32 string length 7")
    59  
    60  	cmd.SetArgs([]string{"invalid1", "invalid2"})
    61  	require.EqualError(t, cmd.ExecuteContext(ctx), "invalid1 is not a valid name or address: decoding bech32 failed: invalid separator index 7")
    62  
    63  	fakeKeyName1 := "runShowCmd_Key1"
    64  	fakeKeyName2 := "runShowCmd_Key2"
    65  
    66  	t.Cleanup(func() {
    67  		err := kb.Delete("runShowCmd_Key1")
    68  		require.NoError(t, err)
    69  		err = kb.Delete("runShowCmd_Key2")
    70  		require.NoError(t, err)
    71  	})
    72  
    73  	path := hd.NewFundraiserParams(1, sdk.CoinType, 0).String()
    74  	_, err = kb.NewAccount(fakeKeyName1, testdata.TestMnemonic, "", path, hd.Secp256k1)
    75  	require.NoError(t, err)
    76  
    77  	path2 := hd.NewFundraiserParams(1, sdk.CoinType, 1).String()
    78  	_, err = kb.NewAccount(fakeKeyName2, testdata.TestMnemonic, "", path2, hd.Secp256k1)
    79  	require.NoError(t, err)
    80  
    81  	// Now try single key
    82  	cmd.SetArgs([]string{
    83  		fakeKeyName1,
    84  		fmt.Sprintf("--%s=%s", flags.FlagHome, kbHome),
    85  		fmt.Sprintf("--%s=%s", flags.FlagKeyringBackend, keyring.BackendTest),
    86  		fmt.Sprintf("--%s=", FlagBechPrefix),
    87  	})
    88  	require.EqualError(t, cmd.ExecuteContext(ctx), "invalid Bech32 prefix encoding provided: ")
    89  
    90  	cmd.SetArgs([]string{
    91  		fakeKeyName1,
    92  		fmt.Sprintf("--%s=%s", flags.FlagHome, kbHome),
    93  		fmt.Sprintf("--%s=%s", flags.FlagKeyringBackend, keyring.BackendTest),
    94  		fmt.Sprintf("--%s=%s", FlagBechPrefix, sdk.PrefixAccount),
    95  	})
    96  
    97  	// try fetch by name
    98  	require.NoError(t, cmd.ExecuteContext(ctx))
    99  
   100  	// try fetch by addr
   101  	info, err := kb.Key(fakeKeyName1)
   102  	cmd.SetArgs([]string{
   103  		info.GetAddress().String(),
   104  		fmt.Sprintf("--%s=%s", flags.FlagHome, kbHome),
   105  		fmt.Sprintf("--%s=%s", flags.FlagKeyringBackend, keyring.BackendTest),
   106  		fmt.Sprintf("--%s=%s", FlagBechPrefix, sdk.PrefixAccount),
   107  	})
   108  
   109  	require.NoError(t, err)
   110  	require.NoError(t, cmd.ExecuteContext(ctx))
   111  
   112  	// Now try multisig key - set bech to acc
   113  	cmd.SetArgs([]string{
   114  		fakeKeyName1, fakeKeyName2,
   115  		fmt.Sprintf("--%s=%s", flags.FlagHome, kbHome),
   116  		fmt.Sprintf("--%s=%s", flags.FlagKeyringBackend, keyring.BackendTest),
   117  		fmt.Sprintf("--%s=%s", FlagBechPrefix, sdk.PrefixAccount),
   118  		fmt.Sprintf("--%s=0", flagMultiSigThreshold),
   119  	})
   120  	require.EqualError(t, cmd.ExecuteContext(ctx), "threshold must be a positive integer")
   121  
   122  	cmd.SetArgs([]string{
   123  		fakeKeyName1, fakeKeyName2,
   124  		fmt.Sprintf("--%s=%s", flags.FlagHome, kbHome),
   125  		fmt.Sprintf("--%s=%s", flags.FlagKeyringBackend, keyring.BackendTest),
   126  		fmt.Sprintf("--%s=%s", FlagBechPrefix, sdk.PrefixAccount),
   127  		fmt.Sprintf("--%s=2", flagMultiSigThreshold),
   128  	})
   129  	require.NoError(t, cmd.ExecuteContext(ctx))
   130  
   131  	// Now try multisig key - set bech to acc + threshold=2
   132  	cmd.SetArgs([]string{
   133  		fakeKeyName1, fakeKeyName2,
   134  		fmt.Sprintf("--%s=%s", flags.FlagHome, kbHome),
   135  		fmt.Sprintf("--%s=%s", flags.FlagKeyringBackend, keyring.BackendTest),
   136  		fmt.Sprintf("--%s=acc", FlagBechPrefix),
   137  		fmt.Sprintf("--%s=true", FlagDevice),
   138  		fmt.Sprintf("--%s=2", flagMultiSigThreshold),
   139  	})
   140  	require.EqualError(t, cmd.ExecuteContext(ctx), "the device flag (-d) can only be used for accounts stored in devices")
   141  
   142  	cmd.SetArgs([]string{
   143  		fakeKeyName1, fakeKeyName2,
   144  		fmt.Sprintf("--%s=%s", flags.FlagHome, kbHome),
   145  		fmt.Sprintf("--%s=%s", flags.FlagKeyringBackend, keyring.BackendTest),
   146  		fmt.Sprintf("--%s=val", FlagBechPrefix),
   147  		fmt.Sprintf("--%s=true", FlagDevice),
   148  		fmt.Sprintf("--%s=2", flagMultiSigThreshold),
   149  	})
   150  	require.EqualError(t, cmd.ExecuteContext(ctx), "the device flag (-d) can only be used for accounts")
   151  
   152  	cmd.SetArgs([]string{
   153  		fakeKeyName1, fakeKeyName2,
   154  		fmt.Sprintf("--%s=%s", flags.FlagHome, kbHome),
   155  		fmt.Sprintf("--%s=%s", flags.FlagKeyringBackend, keyring.BackendTest),
   156  		fmt.Sprintf("--%s=val", FlagBechPrefix),
   157  		fmt.Sprintf("--%s=true", FlagDevice),
   158  		fmt.Sprintf("--%s=2", flagMultiSigThreshold),
   159  		fmt.Sprintf("--%s=true", FlagPublicKey),
   160  	})
   161  	require.EqualError(t, cmd.ExecuteContext(ctx), "the device flag (-d) can only be used for addresses not pubkeys")
   162  }
   163  
   164  func Test_validateMultisigThreshold(t *testing.T) {
   165  	type args struct {
   166  		k     int
   167  		nKeys int
   168  	}
   169  	tests := []struct {
   170  		name    string
   171  		args    args
   172  		wantErr bool
   173  	}{
   174  		{"zeros", args{0, 0}, true},
   175  		{"1-0", args{1, 0}, true},
   176  		{"1-1", args{1, 1}, false},
   177  		{"1-2", args{1, 1}, false},
   178  		{"1-2", args{2, 1}, true},
   179  	}
   180  	for _, tt := range tests {
   181  		t.Run(tt.name, func(t *testing.T) {
   182  			if err := validateMultisigThreshold(tt.args.k, tt.args.nKeys); (err != nil) != tt.wantErr {
   183  				t.Errorf("validateMultisigThreshold() error = %v, wantErr %v", err, tt.wantErr)
   184  			}
   185  		})
   186  	}
   187  }
   188  
   189  func Test_getBechKeyOut(t *testing.T) {
   190  	type args struct {
   191  		bechPrefix string
   192  	}
   193  	tests := []struct {
   194  		name    string
   195  		args    args
   196  		want    bechKeyOutFn
   197  		wantErr bool
   198  	}{
   199  		{"empty", args{""}, nil, true},
   200  		{"wrong", args{"???"}, nil, true},
   201  		{"acc", args{sdk.PrefixAccount}, keyring.MkAccKeyOutput, false},
   202  		{"val", args{sdk.PrefixValidator}, keyring.MkValKeyOutput, false},
   203  		{"cons", args{sdk.PrefixConsensus}, keyring.MkConsKeyOutput, false},
   204  	}
   205  	for _, tt := range tests {
   206  		t.Run(tt.name, func(t *testing.T) {
   207  			got, err := getBechKeyOut(tt.args.bechPrefix)
   208  			if tt.wantErr {
   209  				require.Error(t, err)
   210  			} else {
   211  				require.NoError(t, err)
   212  				require.NotNil(t, got)
   213  			}
   214  		})
   215  	}
   216  }