github.com/cosmos/cosmos-sdk@v0.50.10/client/keys/import_test.go (about)

     1  package keys
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  	"os"
     7  	"path/filepath"
     8  	"testing"
     9  
    10  	"github.com/stretchr/testify/require"
    11  
    12  	"github.com/cosmos/cosmos-sdk/client"
    13  	"github.com/cosmos/cosmos-sdk/client/flags"
    14  	"github.com/cosmos/cosmos-sdk/crypto/keyring"
    15  	"github.com/cosmos/cosmos-sdk/testutil"
    16  	sdk "github.com/cosmos/cosmos-sdk/types"
    17  	moduletestutil "github.com/cosmos/cosmos-sdk/types/module/testutil"
    18  )
    19  
    20  func Test_runImportCmd(t *testing.T) {
    21  	cdc := moduletestutil.MakeTestEncodingConfig().Codec
    22  	testCases := []struct {
    23  		name           string
    24  		keyringBackend string
    25  		userInput      string
    26  		expectError    bool
    27  	}{
    28  		{
    29  			name:           "test backend success",
    30  			keyringBackend: keyring.BackendTest,
    31  			// key armor passphrase
    32  			userInput: "123456789\n",
    33  		},
    34  		{
    35  			name:           "test backend fail with wrong armor pass",
    36  			keyringBackend: keyring.BackendTest,
    37  			userInput:      "987654321\n",
    38  			expectError:    true,
    39  		},
    40  		{
    41  			name:           "file backend success",
    42  			keyringBackend: keyring.BackendFile,
    43  			// key armor passphrase + keyring password x2
    44  			userInput: "123456789\n12345678\n12345678\n",
    45  		},
    46  		{
    47  			name:           "file backend fail with wrong armor pass",
    48  			keyringBackend: keyring.BackendFile,
    49  			userInput:      "987654321\n12345678\n12345678\n",
    50  			expectError:    true,
    51  		},
    52  		{
    53  			name:           "file backend fail with wrong keyring pass",
    54  			keyringBackend: keyring.BackendFile,
    55  			userInput:      "123465789\n12345678\n87654321\n",
    56  			expectError:    true,
    57  		},
    58  		{
    59  			name:           "file backend fail with no keyring pass",
    60  			keyringBackend: keyring.BackendFile,
    61  			userInput:      "123465789\n",
    62  			expectError:    true,
    63  		},
    64  	}
    65  
    66  	armoredKey := `-----BEGIN TENDERMINT PRIVATE KEY-----
    67  salt: A790BB721D1C094260EA84F5E5B72289
    68  kdf: bcrypt
    69  
    70  HbP+c6JmeJy9JXe2rbbF1QtCX1gLqGcDQPBXiCtFvP7/8wTZtVOPj8vREzhZ9ElO
    71  3P7YnrzPQThG0Q+ZnRSbl9MAS8uFAM4mqm5r/Ys=
    72  =f3l4
    73  -----END TENDERMINT PRIVATE KEY-----
    74  `
    75  
    76  	for _, tc := range testCases {
    77  		t.Run(tc.name, func(t *testing.T) {
    78  			cmd := ImportKeyCommand()
    79  			cmd.Flags().AddFlagSet(Commands().PersistentFlags())
    80  			mockIn := testutil.ApplyMockIODiscardOutErr(cmd)
    81  
    82  			// Now add a temporary keybase
    83  			kbHome := filepath.Join(t.TempDir(), fmt.Sprintf("kbhome-%s", tc.name))
    84  			// Create dir, otherwise os.WriteFile will fail
    85  			if _, err := os.Stat(kbHome); os.IsNotExist(err) {
    86  				err = os.MkdirAll(kbHome, 0o700)
    87  				require.NoError(t, err)
    88  			}
    89  			kb, err := keyring.New(sdk.KeyringServiceName(), tc.keyringBackend, kbHome, nil, cdc)
    90  			require.NoError(t, err)
    91  
    92  			clientCtx := client.Context{}.
    93  				WithKeyringDir(kbHome).
    94  				WithKeyring(kb).
    95  				WithInput(mockIn).
    96  				WithCodec(cdc)
    97  			ctx := context.WithValue(context.Background(), client.ClientContextKey, &clientCtx)
    98  
    99  			t.Cleanup(cleanupKeys(t, kb, "keyname1"))
   100  
   101  			keyfile := filepath.Join(kbHome, "key.asc")
   102  			require.NoError(t, os.WriteFile(keyfile, []byte(armoredKey), 0o600))
   103  
   104  			defer func() {
   105  				_ = os.RemoveAll(kbHome)
   106  			}()
   107  
   108  			mockIn.Reset(tc.userInput)
   109  			cmd.SetArgs([]string{
   110  				"keyname1", keyfile,
   111  				fmt.Sprintf("--%s=%s", flags.FlagKeyringBackend, tc.keyringBackend),
   112  			})
   113  
   114  			err = cmd.ExecuteContext(ctx)
   115  			if tc.expectError {
   116  				require.Error(t, err)
   117  			} else {
   118  				require.NoError(t, err)
   119  			}
   120  		})
   121  	}
   122  }
   123  
   124  func Test_runImportHexCmd(t *testing.T) {
   125  	cdc := moduletestutil.MakeTestEncodingConfig().Codec
   126  	testCases := []struct {
   127  		name           string
   128  		keyringBackend string
   129  		hexKey         string
   130  		keyType        string
   131  		expectError    bool
   132  	}{
   133  		{
   134  			name:           "test backend success",
   135  			keyringBackend: keyring.BackendTest,
   136  			hexKey:         "0xa3e57952e835ed30eea86a2993ac2a61c03e74f2085b3635bd94aa4d7ae0cfdf",
   137  			keyType:        "secp256k1",
   138  		},
   139  	}
   140  
   141  	for _, tc := range testCases {
   142  		t.Run(tc.name, func(t *testing.T) {
   143  			cmd := ImportKeyHexCommand()
   144  			cmd.Flags().AddFlagSet(Commands().PersistentFlags())
   145  			mockIn := testutil.ApplyMockIODiscardOutErr(cmd)
   146  
   147  			// Now add a temporary keybase
   148  			kbHome := filepath.Join(t.TempDir(), fmt.Sprintf("kbhome-%s", tc.name))
   149  			kb, err := keyring.New(sdk.KeyringServiceName(), tc.keyringBackend, kbHome, nil, cdc)
   150  			require.NoError(t, err)
   151  
   152  			clientCtx := client.Context{}.
   153  				WithKeyringDir(kbHome).
   154  				WithKeyring(kb).
   155  				WithInput(mockIn).
   156  				WithCodec(cdc)
   157  			ctx := context.WithValue(context.Background(), client.ClientContextKey, &clientCtx)
   158  
   159  			t.Cleanup(cleanupKeys(t, kb, "keyname1"))
   160  
   161  			defer func() {
   162  				_ = os.RemoveAll(kbHome)
   163  			}()
   164  
   165  			cmd.SetArgs([]string{
   166  				"keyname1", tc.hexKey,
   167  				fmt.Sprintf("--%s=%s", flags.FlagKeyType, tc.keyType),
   168  				fmt.Sprintf("--%s=%s", flags.FlagKeyringBackend, tc.keyringBackend),
   169  			})
   170  
   171  			err = cmd.ExecuteContext(ctx)
   172  			if tc.expectError {
   173  				require.Error(t, err)
   174  			} else {
   175  				require.NoError(t, err)
   176  			}
   177  		})
   178  	}
   179  }