github.com/annwntech/go-micro/v2@v2.9.5/service/grpc/grpc_test.go (about)

     1  package grpc
     2  
     3  import (
     4  	"context"
     5  	"crypto/tls"
     6  	"sync"
     7  	"testing"
     8  	"time"
     9  
    10  	"github.com/annwntech/go-micro/v2/registry/memory"
    11  	"github.com/annwntech/go-micro/v2/service"
    12  	hello "github.com/annwntech/go-micro/v2/service/grpc/proto"
    13  	mls "github.com/annwntech/go-micro/v2/util/tls"
    14  )
    15  
    16  type testHandler struct{}
    17  
    18  func (t *testHandler) Call(ctx context.Context, req *hello.Request, rsp *hello.Response) error {
    19  	rsp.Msg = "Hello " + req.Name
    20  	return nil
    21  }
    22  
    23  func TestGRPCService(t *testing.T) {
    24  	var wg sync.WaitGroup
    25  	wg.Add(1)
    26  
    27  	ctx, cancel := context.WithCancel(context.Background())
    28  	defer cancel()
    29  
    30  	// create memory registry
    31  	r := memory.NewRegistry()
    32  
    33  	// create GRPC service
    34  	service := NewService(
    35  		service.Name("test.service"),
    36  		service.Registry(r),
    37  		service.AfterStart(func() error {
    38  			wg.Done()
    39  			return nil
    40  		}),
    41  		service.Context(ctx),
    42  	)
    43  
    44  	// register test handler
    45  	hello.RegisterTestHandler(service.Server(), &testHandler{})
    46  
    47  	// run service
    48  	errCh := make(chan error, 1)
    49  	go func() {
    50  		defer close(errCh)
    51  		errCh <- service.Run()
    52  	}()
    53  
    54  	// wait for start
    55  	wg.Wait()
    56  
    57  	// create client
    58  	test := hello.NewTestService("test.service", service.Client())
    59  
    60  	// call service
    61  	ctx2, cancel2 := context.WithTimeout(context.Background(), time.Duration(time.Second))
    62  	defer cancel2()
    63  	rsp, err := test.Call(ctx2, &hello.Request{
    64  		Name: "John",
    65  	})
    66  	if err != nil {
    67  		t.Fatal(err)
    68  	}
    69  
    70  	// check server
    71  	select {
    72  	case err := <-errCh:
    73  		t.Fatal(err)
    74  	case <-time.After(time.Second):
    75  		break
    76  	}
    77  
    78  	// check message
    79  	if rsp.Msg != "Hello John" {
    80  		t.Fatalf("unexpected response %s", rsp.Msg)
    81  	}
    82  }
    83  
    84  func TestGRPCTLSService(t *testing.T) {
    85  	var wg sync.WaitGroup
    86  	wg.Add(1)
    87  
    88  	ctx, cancel := context.WithCancel(context.Background())
    89  	defer cancel()
    90  
    91  	// create memory registry
    92  	r := memory.NewRegistry()
    93  
    94  	// create cert
    95  	cert, err := mls.Certificate("test.service")
    96  	if err != nil {
    97  		t.Fatal(err)
    98  	}
    99  	config := &tls.Config{
   100  		Certificates:       []tls.Certificate{cert},
   101  		InsecureSkipVerify: true,
   102  	}
   103  
   104  	// create GRPC service
   105  	service := NewService(
   106  		service.Name("test.service"),
   107  		service.Registry(r),
   108  		service.AfterStart(func() error {
   109  			wg.Done()
   110  			return nil
   111  		}),
   112  		service.Context(ctx),
   113  		// set TLS config
   114  		WithTLS(config),
   115  	)
   116  
   117  	// register test handler
   118  	hello.RegisterTestHandler(service.Server(), &testHandler{})
   119  
   120  	// run service
   121  	errCh := make(chan error, 1)
   122  	go func() {
   123  		defer close(errCh)
   124  		errCh <- service.Run()
   125  	}()
   126  
   127  	// wait for start
   128  	wg.Wait()
   129  
   130  	// create client
   131  	test := hello.NewTestService("test.service", service.Client())
   132  
   133  	// call service
   134  	ctx2, cancel2 := context.WithTimeout(context.Background(), time.Duration(time.Second))
   135  	defer cancel2()
   136  	rsp, err := test.Call(ctx2, &hello.Request{
   137  		Name: "John",
   138  	})
   139  	if err != nil {
   140  		t.Fatal(err)
   141  	}
   142  
   143  	// check server
   144  	select {
   145  	case err := <-errCh:
   146  		t.Fatal(err)
   147  	case <-time.After(time.Second):
   148  		break
   149  	}
   150  
   151  	// check message
   152  	if rsp.Msg != "Hello John" {
   153  		t.Fatalf("unexpected response %s", rsp.Msg)
   154  	}
   155  }