156 lines
3.0 KiB
Go
156 lines
3.0 KiB
Go
package http
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"net/http"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
api "github.com/micro/go-api/proto"
|
|
micro "github.com/micro/go-micro"
|
|
"github.com/micro/go-micro/client"
|
|
"github.com/micro/go-micro/registry"
|
|
"github.com/micro/go-micro/registry/mock"
|
|
"github.com/micro/go-micro/server"
|
|
)
|
|
|
|
func TestHTTPServer(t *testing.T) {
|
|
reg := mock.NewRegistry()
|
|
|
|
// create server
|
|
srv := NewServer(server.Registry(reg))
|
|
|
|
// create server mux
|
|
mux := http.NewServeMux()
|
|
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
|
|
w.Write([]byte(`hello world`))
|
|
})
|
|
|
|
// create handler
|
|
hd := srv.NewHandler(mux)
|
|
|
|
// register handler
|
|
if err := srv.Handle(hd); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// start server
|
|
if err := srv.Start(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// register server
|
|
if err := srv.Register(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// lookup server
|
|
service, err := reg.GetService(server.DefaultName)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if len(service) != 1 {
|
|
t.Fatalf("Expected 1 service got %d: %+v", len(service), service)
|
|
}
|
|
|
|
if len(service[0].Nodes) != 1 {
|
|
t.Fatalf("Expected 1 node got %d: %+v", len(service[0].Nodes), service[0].Nodes)
|
|
}
|
|
|
|
// make request
|
|
rsp, err := http.Get(fmt.Sprintf("http://%s:%d", service[0].Nodes[0].Address, service[0].Nodes[0].Port))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer rsp.Body.Close()
|
|
|
|
b, err := ioutil.ReadAll(rsp.Body)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
if s := string(b); s != "hello world" {
|
|
t.Fatalf("Expected response %s, got %s", "hello world", s)
|
|
}
|
|
|
|
// deregister server
|
|
if err := srv.Deregister(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// try get service
|
|
service, err = reg.GetService(server.DefaultName)
|
|
if err == nil {
|
|
t.Fatalf("Expected %v got %+v", registry.ErrNotFound, service)
|
|
}
|
|
|
|
// stop server
|
|
if err := srv.Stop(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func TestSubscriber(t *testing.T) {
|
|
reg := mock.NewRegistry()
|
|
|
|
// create server
|
|
srv := NewServer(server.Registry(reg))
|
|
|
|
// register handler
|
|
if err := srv.Handle(srv.NewHandler(http.NewServeMux())); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// start server
|
|
if err := srv.Start(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
topic := "topic"
|
|
ctx, cancel := context.WithTimeout(context.TODO(), time.Millisecond*10)
|
|
sub := srv.NewSubscriber(topic, func(context.Context, *api.Event) error {
|
|
cancel()
|
|
return nil
|
|
})
|
|
// subscribe
|
|
if err := srv.Subscribe(sub); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// register server
|
|
if err := srv.Register(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
// publish
|
|
wg := sync.WaitGroup{}
|
|
go func() {
|
|
wg.Add(1)
|
|
defer wg.Done()
|
|
mClient := client.NewClient(
|
|
client.Registry(reg),
|
|
client.Broker(srv.Options().Broker),
|
|
)
|
|
pub := micro.NewPublisher(topic, mClient)
|
|
if err := pub.Publish(ctx, &api.Event{}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}()
|
|
wg.Wait()
|
|
|
|
// wait cancel
|
|
<-ctx.Done()
|
|
if ctx.Err() != context.Canceled {
|
|
t.Fatalf("subscriber is not working, err: %s", ctx.Err())
|
|
}
|
|
|
|
// stop server
|
|
if err := srv.Stop(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|