github.com/franono/tendermint@v0.32.2-0.20200527150959-749313264ce9/abci/example/example_test.go (about)

     1  package example
     2  
     3  import (
     4  	"fmt"
     5  	"math/rand"
     6  	"net"
     7  	"os"
     8  	"reflect"
     9  	"testing"
    10  	"time"
    11  
    12  	"github.com/stretchr/testify/require"
    13  
    14  	"google.golang.org/grpc"
    15  
    16  	"golang.org/x/net/context"
    17  
    18  	"github.com/franono/tendermint/libs/log"
    19  	tmnet "github.com/franono/tendermint/libs/net"
    20  
    21  	abcicli "github.com/franono/tendermint/abci/client"
    22  	"github.com/franono/tendermint/abci/example/code"
    23  	"github.com/franono/tendermint/abci/example/kvstore"
    24  	abciserver "github.com/franono/tendermint/abci/server"
    25  	"github.com/franono/tendermint/abci/types"
    26  )
    27  
    28  func init() {
    29  	rand.Seed(time.Now().UnixNano())
    30  }
    31  
    32  func TestKVStore(t *testing.T) {
    33  	fmt.Println("### Testing KVStore")
    34  	testStream(t, kvstore.NewApplication())
    35  }
    36  
    37  func TestBaseApp(t *testing.T) {
    38  	fmt.Println("### Testing BaseApp")
    39  	testStream(t, types.NewBaseApplication())
    40  }
    41  
    42  func TestGRPC(t *testing.T) {
    43  	fmt.Println("### Testing GRPC")
    44  	testGRPCSync(t, types.NewGRPCApplication(types.NewBaseApplication()))
    45  }
    46  
    47  func testStream(t *testing.T, app types.Application) {
    48  	numDeliverTxs := 20000
    49  	socketFile := fmt.Sprintf("test-%08x.sock", rand.Int31n(1<<30))
    50  	defer os.Remove(socketFile)
    51  	socket := fmt.Sprintf("unix://%v", socketFile)
    52  
    53  	// Start the listener
    54  	server := abciserver.NewSocketServer(socket, app)
    55  	server.SetLogger(log.TestingLogger().With("module", "abci-server"))
    56  	if err := server.Start(); err != nil {
    57  		require.NoError(t, err, "Error starting socket server")
    58  	}
    59  	defer server.Stop()
    60  
    61  	// Connect to the socket
    62  	client := abcicli.NewSocketClient(socket, false)
    63  	client.SetLogger(log.TestingLogger().With("module", "abci-client"))
    64  	if err := client.Start(); err != nil {
    65  		t.Fatalf("Error starting socket client: %v", err.Error())
    66  	}
    67  	defer client.Stop()
    68  
    69  	done := make(chan struct{})
    70  	counter := 0
    71  	client.SetResponseCallback(func(req *types.Request, res *types.Response) {
    72  		// Process response
    73  		switch r := res.Value.(type) {
    74  		case *types.Response_DeliverTx:
    75  			counter++
    76  			if r.DeliverTx.Code != code.CodeTypeOK {
    77  				t.Error("DeliverTx failed with ret_code", r.DeliverTx.Code)
    78  			}
    79  			if counter > numDeliverTxs {
    80  				t.Fatalf("Too many DeliverTx responses. Got %d, expected %d", counter, numDeliverTxs)
    81  			}
    82  			if counter == numDeliverTxs {
    83  				go func() {
    84  					time.Sleep(time.Second * 1) // Wait for a bit to allow counter overflow
    85  					close(done)
    86  				}()
    87  				return
    88  			}
    89  		case *types.Response_Flush:
    90  			// ignore
    91  		default:
    92  			t.Error("Unexpected response type", reflect.TypeOf(res.Value))
    93  		}
    94  	})
    95  
    96  	// Write requests
    97  	for counter := 0; counter < numDeliverTxs; counter++ {
    98  		// Send request
    99  		reqRes := client.DeliverTxAsync(types.RequestDeliverTx{Tx: []byte("test")})
   100  		_ = reqRes
   101  		// check err ?
   102  
   103  		// Sometimes send flush messages
   104  		if counter%123 == 0 {
   105  			client.FlushAsync()
   106  			// check err ?
   107  		}
   108  	}
   109  
   110  	// Send final flush message
   111  	client.FlushAsync()
   112  
   113  	<-done
   114  }
   115  
   116  //-------------------------
   117  // test grpc
   118  
   119  func dialerFunc(ctx context.Context, addr string) (net.Conn, error) {
   120  	return tmnet.Connect(addr)
   121  }
   122  
   123  func testGRPCSync(t *testing.T, app types.ABCIApplicationServer) {
   124  	numDeliverTxs := 2000
   125  	socketFile := fmt.Sprintf("test-%08x.sock", rand.Int31n(1<<30))
   126  	defer os.Remove(socketFile)
   127  	socket := fmt.Sprintf("unix://%v", socketFile)
   128  
   129  	// Start the listener
   130  	server := abciserver.NewGRPCServer(socket, app)
   131  	server.SetLogger(log.TestingLogger().With("module", "abci-server"))
   132  	if err := server.Start(); err != nil {
   133  		t.Fatalf("Error starting GRPC server: %v", err.Error())
   134  	}
   135  	defer server.Stop()
   136  
   137  	// Connect to the socket
   138  	conn, err := grpc.Dial(socket, grpc.WithInsecure(), grpc.WithContextDialer(dialerFunc))
   139  	if err != nil {
   140  		t.Fatalf("Error dialing GRPC server: %v", err.Error())
   141  	}
   142  	defer conn.Close()
   143  
   144  	client := types.NewABCIApplicationClient(conn)
   145  
   146  	// Write requests
   147  	for counter := 0; counter < numDeliverTxs; counter++ {
   148  		// Send request
   149  		response, err := client.DeliverTx(context.Background(), &types.RequestDeliverTx{Tx: []byte("test")})
   150  		if err != nil {
   151  			t.Fatalf("Error in GRPC DeliverTx: %v", err.Error())
   152  		}
   153  		counter++
   154  		if response.Code != code.CodeTypeOK {
   155  			t.Error("DeliverTx failed with ret_code", response.Code)
   156  		}
   157  		if counter > numDeliverTxs {
   158  			t.Fatal("Too many DeliverTx responses")
   159  		}
   160  		t.Log("response", counter)
   161  		if counter == numDeliverTxs {
   162  			go func() {
   163  				time.Sleep(time.Second * 1) // Wait for a bit to allow counter overflow
   164  			}()
   165  		}
   166  
   167  	}
   168  }