github.com/number571/tendermint@v0.34.11-gost/privval/grpc/client_test.go (about)

     1  package grpc_test
     2  
     3  import (
     4  	"context"
     5  	"net"
     6  	"testing"
     7  	"time"
     8  
     9  	grpc "google.golang.org/grpc"
    10  	"google.golang.org/grpc/test/bufconn"
    11  
    12  	"github.com/number571/tendermint/crypto"
    13  	"github.com/number571/tendermint/crypto/tmhash"
    14  	"github.com/number571/tendermint/libs/log"
    15  	tmrand "github.com/number571/tendermint/libs/rand"
    16  	tmgrpc "github.com/number571/tendermint/privval/grpc"
    17  	privvalproto "github.com/number571/tendermint/proto/tendermint/privval"
    18  	tmproto "github.com/number571/tendermint/proto/tendermint/types"
    19  	"github.com/number571/tendermint/types"
    20  	"github.com/stretchr/testify/assert"
    21  	"github.com/stretchr/testify/require"
    22  )
    23  
    24  const chainID = "chain-id"
    25  
    26  func dialer(pv types.PrivValidator, logger log.Logger) (*grpc.Server, func(context.Context, string) (net.Conn, error)) {
    27  	listener := bufconn.Listen(1024 * 1024)
    28  
    29  	server := grpc.NewServer()
    30  
    31  	s := tmgrpc.NewSignerServer(chainID, pv, logger)
    32  
    33  	privvalproto.RegisterPrivValidatorAPIServer(server, s)
    34  
    35  	go func() {
    36  		if err := server.Serve(listener); err != nil {
    37  			panic(err)
    38  		}
    39  	}()
    40  
    41  	return server, func(context.Context, string) (net.Conn, error) {
    42  		return listener.Dial()
    43  	}
    44  }
    45  
    46  func TestSignerClient_GetPubKey(t *testing.T) {
    47  
    48  	ctx := context.Background()
    49  	mockPV := types.NewMockPV()
    50  	logger := log.TestingLogger()
    51  	srv, dialer := dialer(mockPV, logger)
    52  	defer srv.Stop()
    53  
    54  	conn, err := grpc.DialContext(ctx, "", grpc.WithInsecure(), grpc.WithContextDialer(dialer))
    55  	if err != nil {
    56  		panic(err)
    57  	}
    58  	defer conn.Close()
    59  
    60  	client, err := tmgrpc.NewSignerClient(conn, chainID, logger)
    61  	require.NoError(t, err)
    62  
    63  	pk, err := client.GetPubKey(context.Background())
    64  	require.NoError(t, err)
    65  	assert.Equal(t, mockPV.PrivKey.PubKey(), pk)
    66  }
    67  
    68  func TestSignerClient_SignVote(t *testing.T) {
    69  
    70  	ctx := context.Background()
    71  	mockPV := types.NewMockPV()
    72  	logger := log.TestingLogger()
    73  	srv, dialer := dialer(mockPV, logger)
    74  	defer srv.Stop()
    75  
    76  	conn, err := grpc.DialContext(ctx, "", grpc.WithInsecure(), grpc.WithContextDialer(dialer))
    77  	if err != nil {
    78  		panic(err)
    79  	}
    80  	defer conn.Close()
    81  
    82  	client, err := tmgrpc.NewSignerClient(conn, chainID, logger)
    83  	require.NoError(t, err)
    84  
    85  	ts := time.Now()
    86  	hash := tmrand.Bytes(tmhash.Size)
    87  	valAddr := tmrand.Bytes(crypto.AddressSize)
    88  
    89  	want := &types.Vote{
    90  		Type:             tmproto.PrecommitType,
    91  		Height:           1,
    92  		Round:            2,
    93  		BlockID:          types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
    94  		Timestamp:        ts,
    95  		ValidatorAddress: valAddr,
    96  		ValidatorIndex:   1,
    97  	}
    98  
    99  	have := &types.Vote{
   100  		Type:             tmproto.PrecommitType,
   101  		Height:           1,
   102  		Round:            2,
   103  		BlockID:          types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
   104  		Timestamp:        ts,
   105  		ValidatorAddress: valAddr,
   106  		ValidatorIndex:   1,
   107  	}
   108  
   109  	pbHave := have.ToProto()
   110  
   111  	err = client.SignVote(context.Background(), chainID, pbHave)
   112  	require.NoError(t, err)
   113  
   114  	pbWant := want.ToProto()
   115  
   116  	require.NoError(t, mockPV.SignVote(context.Background(), chainID, pbWant))
   117  
   118  	assert.Equal(t, pbWant.Signature, pbHave.Signature)
   119  }
   120  
   121  func TestSignerClient_SignProposal(t *testing.T) {
   122  
   123  	ctx := context.Background()
   124  	mockPV := types.NewMockPV()
   125  	logger := log.TestingLogger()
   126  	srv, dialer := dialer(mockPV, logger)
   127  	defer srv.Stop()
   128  
   129  	conn, err := grpc.DialContext(ctx, "", grpc.WithInsecure(), grpc.WithContextDialer(dialer))
   130  	if err != nil {
   131  		panic(err)
   132  	}
   133  	defer conn.Close()
   134  
   135  	client, err := tmgrpc.NewSignerClient(conn, chainID, logger)
   136  	require.NoError(t, err)
   137  
   138  	ts := time.Now()
   139  	hash := tmrand.Bytes(tmhash.Size)
   140  
   141  	have := &types.Proposal{
   142  		Type:      tmproto.ProposalType,
   143  		Height:    1,
   144  		Round:     2,
   145  		POLRound:  2,
   146  		BlockID:   types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
   147  		Timestamp: ts,
   148  	}
   149  	want := &types.Proposal{
   150  		Type:      tmproto.ProposalType,
   151  		Height:    1,
   152  		Round:     2,
   153  		POLRound:  2,
   154  		BlockID:   types.BlockID{Hash: hash, PartSetHeader: types.PartSetHeader{Hash: hash, Total: 2}},
   155  		Timestamp: ts,
   156  	}
   157  
   158  	pbHave := have.ToProto()
   159  
   160  	err = client.SignProposal(context.Background(), chainID, pbHave)
   161  	require.NoError(t, err)
   162  
   163  	pbWant := want.ToProto()
   164  
   165  	require.NoError(t, mockPV.SignProposal(context.Background(), chainID, pbWant))
   166  
   167  	assert.Equal(t, pbWant.Signature, pbHave.Signature)
   168  }