github.com/cosmos/cosmos-sdk@v0.50.10/client/tx/factory_test.go (about)

     1  package tx
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/require"
     7  
     8  	"github.com/cosmos/cosmos-sdk/client"
     9  	"github.com/cosmos/cosmos-sdk/codec"
    10  	codectypes "github.com/cosmos/cosmos-sdk/codec/types"
    11  	cryptocodec "github.com/cosmos/cosmos-sdk/crypto/codec"
    12  	"github.com/cosmos/cosmos-sdk/crypto/hd"
    13  	"github.com/cosmos/cosmos-sdk/crypto/keyring"
    14  	"github.com/cosmos/cosmos-sdk/crypto/keys/multisig"
    15  	"github.com/cosmos/cosmos-sdk/crypto/keys/secp256k1"
    16  	"github.com/cosmos/cosmos-sdk/crypto/types"
    17  	"github.com/cosmos/cosmos-sdk/testutil/testdata"
    18  	"github.com/cosmos/cosmos-sdk/types/tx/signing"
    19  )
    20  
    21  func TestFactoryPrepare(t *testing.T) {
    22  	t.Parallel()
    23  
    24  	factory := Factory{}
    25  	clientCtx := client.Context{}
    26  
    27  	output, err := factory.Prepare(clientCtx.WithOffline(true))
    28  	require.NoError(t, err)
    29  	require.Equal(t, output, factory)
    30  
    31  	factory = Factory{}.WithAccountRetriever(client.MockAccountRetriever{ReturnAccNum: 10, ReturnAccSeq: 1}).WithAccountNumber(5)
    32  	output, err = factory.Prepare(clientCtx.WithFrom("foo"))
    33  	require.NoError(t, err)
    34  	require.NotEqual(t, output, factory)
    35  	require.Equal(t, output.AccountNumber(), uint64(5))
    36  	require.Equal(t, output.Sequence(), uint64(1))
    37  
    38  	factory = Factory{}.WithAccountRetriever(client.MockAccountRetriever{ReturnAccNum: 10, ReturnAccSeq: 1})
    39  	output, err = factory.Prepare(clientCtx.WithFrom("foo"))
    40  	require.NoError(t, err)
    41  	require.NotEqual(t, output, factory)
    42  	require.Equal(t, output.AccountNumber(), uint64(10))
    43  	require.Equal(t, output.Sequence(), uint64(1))
    44  }
    45  
    46  func TestFactory_getSimPKType(t *testing.T) {
    47  	// setup keyring
    48  	registry := codectypes.NewInterfaceRegistry()
    49  	cryptocodec.RegisterInterfaces(registry)
    50  	k := keyring.NewInMemory(codec.NewProtoCodec(registry))
    51  
    52  	tests := []struct {
    53  		name     string
    54  		fromName string
    55  		genKey   func(fromName string, k keyring.Keyring) error
    56  		wantType types.PubKey
    57  	}{
    58  		{
    59  			name:     "simple key",
    60  			fromName: "testKey",
    61  			genKey: func(fromName string, k keyring.Keyring) error {
    62  				_, err := k.NewAccount(fromName, testdata.TestMnemonic, "", "", hd.Secp256k1)
    63  				return err
    64  			},
    65  			wantType: (*secp256k1.PubKey)(nil),
    66  		},
    67  		{
    68  			name:     "multisig key",
    69  			fromName: "multiKey",
    70  			genKey: func(fromName string, k keyring.Keyring) error {
    71  				pk := multisig.NewLegacyAminoPubKey(1, []types.PubKey{&multisig.LegacyAminoPubKey{}})
    72  				_, err := k.SaveMultisig(fromName, pk)
    73  				return err
    74  			},
    75  			wantType: (*multisig.LegacyAminoPubKey)(nil),
    76  		},
    77  	}
    78  
    79  	for _, tt := range tests {
    80  		t.Run(tt.name, func(t *testing.T) {
    81  			err := tt.genKey(tt.fromName, k)
    82  			require.NoError(t, err)
    83  			f := Factory{
    84  				keybase:            k,
    85  				fromName:           tt.fromName,
    86  				simulateAndExecute: true,
    87  			}
    88  			got, err := f.getSimPK()
    89  			require.NoError(t, err)
    90  			require.IsType(t, tt.wantType, got)
    91  		})
    92  	}
    93  }
    94  
    95  func TestFactory_getSimSignatureData(t *testing.T) {
    96  	tests := []struct {
    97  		name     string
    98  		pk       types.PubKey
    99  		wantType any
   100  	}{
   101  		{
   102  			name:     "simple pubkey",
   103  			pk:       &secp256k1.PubKey{},
   104  			wantType: (*signing.SingleSignatureData)(nil),
   105  		},
   106  		{
   107  			name:     "multisig pubkey",
   108  			pk:       &multisig.LegacyAminoPubKey{},
   109  			wantType: (*signing.MultiSignatureData)(nil),
   110  		},
   111  	}
   112  
   113  	for _, tt := range tests {
   114  		t.Run(tt.name, func(t *testing.T) {
   115  			got := Factory{}.getSimSignatureData(tt.pk)
   116  			require.IsType(t, tt.wantType, got)
   117  		})
   118  	}
   119  }