gitee.com/liuxuezhan/go-micro-v1.18.0@v1.0.0/web/service_test.go (about)

     1  package web
     2  
     3  import (
     4  	"crypto/tls"
     5  	"fmt"
     6  	"io/ioutil"
     7  	"net/http"
     8  	"os"
     9  	"os/signal"
    10  	"syscall"
    11  	"testing"
    12  	"time"
    13  
    14  	"gitee.com/liuxuezhan/go-micro-v1.18.0/registry"
    15  	"gitee.com/liuxuezhan/go-micro-v1.18.0/registry/memory"
    16  )
    17  
    18  func TestService(t *testing.T) {
    19  	var (
    20  		beforeStartCalled bool
    21  		afterStartCalled  bool
    22  		beforeStopCalled  bool
    23  		afterStopCalled   bool
    24  		str               = `<html><body><h1>Hello World</h1></body></html>`
    25  		fn                = func(w http.ResponseWriter, r *http.Request) { fmt.Fprint(w, str) }
    26  		reg               = memory.NewRegistry()
    27  	)
    28  
    29  	beforeStart := func() error {
    30  		beforeStartCalled = true
    31  		return nil
    32  	}
    33  
    34  	afterStart := func() error {
    35  		afterStartCalled = true
    36  		return nil
    37  	}
    38  
    39  	beforeStop := func() error {
    40  		beforeStopCalled = true
    41  		return nil
    42  	}
    43  
    44  	afterStop := func() error {
    45  		afterStopCalled = true
    46  		return nil
    47  	}
    48  
    49  	service := NewService(
    50  		Name("go.micro.web.test"),
    51  		Registry(reg),
    52  		BeforeStart(beforeStart),
    53  		AfterStart(afterStart),
    54  		BeforeStop(beforeStop),
    55  		AfterStop(afterStop),
    56  	)
    57  
    58  	service.HandleFunc("/", fn)
    59  
    60  	go func() {
    61  		if err := service.Run(); err != nil {
    62  			t.Fatal(err)
    63  		}
    64  	}()
    65  
    66  	var s []*registry.Service
    67  
    68  	eventually(func() bool {
    69  		var err error
    70  		s, err = reg.GetService("go.micro.web.test")
    71  		return err == nil
    72  	}, t.Fatal)
    73  
    74  	if have, want := len(s), 1; have != want {
    75  		t.Fatalf("Expected %d but got %d services", want, have)
    76  	}
    77  
    78  	rsp, err := http.Get(fmt.Sprintf("http://%s", s[0].Nodes[0].Address))
    79  	if err != nil {
    80  		t.Fatal(err)
    81  	}
    82  	defer rsp.Body.Close()
    83  
    84  	b, err := ioutil.ReadAll(rsp.Body)
    85  	if err != nil {
    86  		t.Fatal(err)
    87  	}
    88  
    89  	if string(b) != str {
    90  		t.Errorf("Expected %s got %s", str, string(b))
    91  	}
    92  
    93  	callbackTests := []struct {
    94  		subject string
    95  		have    interface{}
    96  	}{
    97  		{"beforeStartCalled", beforeStartCalled},
    98  		{"afterStartCalled", afterStartCalled},
    99  	}
   100  
   101  	for _, tt := range callbackTests {
   102  		if tt.have != true {
   103  			t.Errorf("unexpected %s: want true, have false", tt.subject)
   104  		}
   105  	}
   106  
   107  	ch := make(chan os.Signal, 1)
   108  	signal.Notify(ch, syscall.SIGTERM)
   109  
   110  	syscall.Kill(syscall.Getpid(), syscall.SIGTERM)
   111  	<-ch
   112  
   113  	eventually(func() bool {
   114  		_, err := reg.GetService("go.micro.web.test")
   115  		return err == registry.ErrNotFound
   116  	}, t.Error)
   117  
   118  	callbackTests = []struct {
   119  		subject string
   120  		have    interface{}
   121  	}{
   122  		{"beforeStopCalled", beforeStopCalled},
   123  		{"afterStopCalled", afterStopCalled},
   124  	}
   125  
   126  	for _, tt := range callbackTests {
   127  		if tt.have != true {
   128  			t.Errorf("unexpected %s: want true, have false", tt.subject)
   129  		}
   130  	}
   131  }
   132  
   133  func TestOptions(t *testing.T) {
   134  	var (
   135  		name             = "service-name"
   136  		id               = "service-id"
   137  		version          = "service-version"
   138  		address          = "service-addr"
   139  		advertise        = "service-adv"
   140  		reg              = memory.NewRegistry()
   141  		registerTTL      = 123 * time.Second
   142  		registerInterval = 456 * time.Second
   143  		handler          = http.NewServeMux()
   144  		metadata         = map[string]string{"key": "val"}
   145  		secure           = true
   146  	)
   147  
   148  	service := NewService(
   149  		Name(name),
   150  		Id(id),
   151  		Version(version),
   152  		Address(address),
   153  		Advertise(advertise),
   154  		Registry(reg),
   155  		RegisterTTL(registerTTL),
   156  		RegisterInterval(registerInterval),
   157  		Handler(handler),
   158  		Metadata(metadata),
   159  		Secure(secure),
   160  	)
   161  
   162  	opts := service.Options()
   163  
   164  	tests := []struct {
   165  		subject string
   166  		want    interface{}
   167  		have    interface{}
   168  	}{
   169  		{"name", name, opts.Name},
   170  		{"version", version, opts.Version},
   171  		{"id", id, opts.Id},
   172  		{"address", address, opts.Address},
   173  		{"advertise", advertise, opts.Advertise},
   174  		{"registry", reg, opts.Registry},
   175  		{"registerTTL", registerTTL, opts.RegisterTTL},
   176  		{"registerInterval", registerInterval, opts.RegisterInterval},
   177  		{"handler", handler, opts.Handler},
   178  		{"metadata", metadata["key"], opts.Metadata["key"]},
   179  		{"secure", secure, opts.Secure},
   180  	}
   181  
   182  	for _, tc := range tests {
   183  		if tc.want != tc.have {
   184  			t.Errorf("unexpected %s: want %v, have %v", tc.subject, tc.want, tc.have)
   185  		}
   186  	}
   187  }
   188  
   189  func eventually(pass func() bool, fail func(...interface{})) {
   190  	tick := time.NewTicker(10 * time.Millisecond)
   191  	defer tick.Stop()
   192  
   193  	timeout := time.After(time.Second)
   194  
   195  	for {
   196  		select {
   197  		case <-timeout:
   198  			fail("timed out")
   199  			return
   200  		case <-tick.C:
   201  			if pass() {
   202  				return
   203  			}
   204  		}
   205  	}
   206  }
   207  
   208  func TestTLS(t *testing.T) {
   209  	var (
   210  		str    = `<html><body><h1>Hello World</h1></body></html>`
   211  		fn     = func(w http.ResponseWriter, r *http.Request) { fmt.Fprint(w, str) }
   212  		secure = true
   213  		reg    = memory.NewRegistry()
   214  	)
   215  
   216  	service := NewService(
   217  		Name("go.micro.web.test"),
   218  		Secure(secure),
   219  		Registry(reg),
   220  	)
   221  
   222  	service.HandleFunc("/", fn)
   223  
   224  	go func() {
   225  		if err := service.Run(); err != nil {
   226  			t.Fatal(err)
   227  		}
   228  	}()
   229  
   230  	var s []*registry.Service
   231  
   232  	eventually(func() bool {
   233  		var err error
   234  		s, err = reg.GetService("go.micro.web.test")
   235  		return err == nil
   236  	}, t.Fatal)
   237  
   238  	if have, want := len(s), 1; have != want {
   239  		t.Fatalf("Expected %d but got %d services", want, have)
   240  	}
   241  
   242  	tr := &http.Transport{
   243  		TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
   244  	}
   245  	client := &http.Client{Transport: tr}
   246  	rsp, err := client.Get(fmt.Sprintf("https://%s", s[0].Nodes[0].Address))
   247  	if err != nil {
   248  		t.Fatal(err)
   249  	}
   250  	defer rsp.Body.Close()
   251  
   252  	b, err := ioutil.ReadAll(rsp.Body)
   253  	if err != nil {
   254  		t.Fatal(err)
   255  	}
   256  
   257  	if string(b) != str {
   258  		t.Errorf("Expected %s got %s", str, string(b))
   259  	}
   260  }