github.com/ari-anchor/sei-tendermint@v0.0.0-20230519144642-dc826b7b56bb/abci/example/example_test.go (about)

     1  package example
     2  
     3  import (
     4  	"context"
     5  	"fmt"
     6  	"math/rand"
     7  	"net"
     8  	"os"
     9  	"testing"
    10  	"time"
    11  
    12  	"github.com/stretchr/testify/require"
    13  
    14  	"google.golang.org/grpc"
    15  
    16  	"github.com/ari-anchor/sei-tendermint/libs/log"
    17  	tmnet "github.com/ari-anchor/sei-tendermint/libs/net"
    18  
    19  	abciclient "github.com/ari-anchor/sei-tendermint/abci/client"
    20  	"github.com/ari-anchor/sei-tendermint/abci/example/code"
    21  	"github.com/ari-anchor/sei-tendermint/abci/example/kvstore"
    22  	abciserver "github.com/ari-anchor/sei-tendermint/abci/server"
    23  	"github.com/ari-anchor/sei-tendermint/abci/types"
    24  )
    25  
    26  func init() {
    27  	rand.Seed(time.Now().UnixNano())
    28  }
    29  
    30  func TestKVStore(t *testing.T) {
    31  	ctx, cancel := context.WithCancel(context.Background())
    32  	defer cancel()
    33  	logger := log.NewNopLogger()
    34  
    35  	t.Log("### Testing KVStore")
    36  	testBulk(ctx, t, logger, kvstore.NewApplication())
    37  }
    38  
    39  func TestBaseApp(t *testing.T) {
    40  	ctx, cancel := context.WithCancel(context.Background())
    41  	defer cancel()
    42  	logger := log.NewNopLogger()
    43  
    44  	t.Log("### Testing BaseApp")
    45  	testBulk(ctx, t, logger, types.NewBaseApplication())
    46  }
    47  
    48  func TestGRPC(t *testing.T) {
    49  	ctx, cancel := context.WithCancel(context.Background())
    50  	defer cancel()
    51  
    52  	logger := log.NewNopLogger()
    53  
    54  	t.Log("### Testing GRPC")
    55  	testGRPCSync(ctx, t, logger, types.NewBaseApplication())
    56  }
    57  
    58  func testBulk(ctx context.Context, t *testing.T, logger log.Logger, app types.Application) {
    59  	t.Helper()
    60  
    61  	const numDeliverTxs = 700000
    62  	socketFile := fmt.Sprintf("test-%08x.sock", rand.Int31n(1<<30))
    63  	defer os.Remove(socketFile)
    64  	socket := fmt.Sprintf("unix://%v", socketFile)
    65  	// Start the listener
    66  	server := abciserver.NewSocketServer(logger.With("module", "abci-server"), socket, app)
    67  	t.Cleanup(server.Wait)
    68  	err := server.Start(ctx)
    69  	require.NoError(t, err)
    70  
    71  	// Connect to the socket
    72  	client := abciclient.NewSocketClient(logger.With("module", "abci-client"), socket, false)
    73  	t.Cleanup(client.Wait)
    74  
    75  	err = client.Start(ctx)
    76  	require.NoError(t, err)
    77  
    78  	// Construct request
    79  	rfb := &types.RequestFinalizeBlock{Txs: make([][]byte, numDeliverTxs)}
    80  	for counter := 0; counter < numDeliverTxs; counter++ {
    81  		rfb.Txs[counter] = []byte("test")
    82  	}
    83  	// Send bulk request
    84  	res, err := client.FinalizeBlock(ctx, rfb)
    85  	require.NoError(t, err)
    86  	require.Equal(t, numDeliverTxs, len(res.TxResults), "Number of txs doesn't match")
    87  	for _, tx := range res.TxResults {
    88  		require.Equal(t, tx.Code, code.CodeTypeOK, "Tx failed")
    89  	}
    90  
    91  	// Send final flush message
    92  	err = client.Flush(ctx)
    93  	require.NoError(t, err)
    94  }
    95  
    96  //-------------------------
    97  // test grpc
    98  
    99  func dialerFunc(ctx context.Context, addr string) (net.Conn, error) {
   100  	return tmnet.Connect(addr)
   101  }
   102  
   103  func testGRPCSync(ctx context.Context, t *testing.T, logger log.Logger, app types.Application) {
   104  	t.Helper()
   105  	numDeliverTxs := 680000
   106  	socketFile := fmt.Sprintf("/tmp/test-%08x.sock", rand.Int31n(1<<30))
   107  	defer os.Remove(socketFile)
   108  	socket := fmt.Sprintf("unix://%v", socketFile)
   109  
   110  	// Start the listener
   111  	server := abciserver.NewGRPCServer(logger.With("module", "abci-server"), socket, app)
   112  
   113  	require.NoError(t, server.Start(ctx))
   114  	t.Cleanup(server.Wait)
   115  
   116  	// Connect to the socket
   117  	conn, err := grpc.Dial(socket,
   118  		grpc.WithInsecure(),
   119  		grpc.WithContextDialer(dialerFunc),
   120  	)
   121  	require.NoError(t, err, "Error dialing GRPC server")
   122  
   123  	t.Cleanup(func() {
   124  		if err := conn.Close(); err != nil {
   125  			t.Error(err)
   126  		}
   127  	})
   128  
   129  	client := types.NewABCIApplicationClient(conn)
   130  
   131  	// Construct request
   132  	rfb := types.RequestFinalizeBlock{Txs: make([][]byte, numDeliverTxs)}
   133  	for counter := 0; counter < numDeliverTxs; counter++ {
   134  		rfb.Txs[counter] = []byte("test")
   135  	}
   136  
   137  	// Send request
   138  	response, err := client.FinalizeBlock(ctx, &rfb)
   139  	require.NoError(t, err, "Error in GRPC FinalizeBlock")
   140  	require.Equal(t, numDeliverTxs, len(response.TxResults), "Number of txs returned via GRPC doesn't match")
   141  	for _, tx := range response.TxResults {
   142  		require.Equal(t, tx.Code, code.CodeTypeOK, "Tx failed")
   143  	}
   144  }