gitee.com/liuxuezhan/go-micro-v1.18.0@v1.0.0/service/grpc/grpc_test.go (about)

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