Merge pull request #130 from unistack-org/improvements

Improvements

api/api_test.go

@@ -3,10 +3,27 @@ package api
 import (
 	"strings"
 	"testing"
+
+	"go.unistack.org/micro/v3/metadata"
+	"go.unistack.org/micro/v3/server"
 )
 
+func TestDecode(t *testing.T) {
+	md := metadata.New(0)
+	md.Set("host", "localhost", "method", "GET", "path", "/")
+	ep := Decode(md)
+	if md == nil {
+		t.Fatalf("failed to decode md %#+v", md)
+	} else if len(ep.Host) != 1 || len(ep.Method) != 1 || len(ep.Path) != 1 {
+		t.Fatalf("ep invalid after decode %#+v", ep)
+	}
+	if ep.Host[0] != "localhost" || ep.Method[0] != "GET" || ep.Path[0] != "/" {
+		t.Fatalf("ep invalid after decode %#+v", ep)
+	}
+}
+
 //nolint:gocyclo
-func TestEncoding(t *testing.T) {
+func TestEncode(t *testing.T) {
 	testData := []*Endpoint{
 		nil,
 		{
@@ -150,3 +167,79 @@ func TestValidate(t *testing.T) {
 		t.Fatalf("invalid pcre %v", epPcreInvalid.Path[0])
 	}
 }
+
+func TestWithEndpoint(t *testing.T) {
+	ep := &Endpoint{
+		Name:        "Foo.Bar",
+		Description: "A test endpoint",
+		Handler:     "meta",
+		Host:        []string{"foo.com"},
+		Method:      []string{"GET"},
+		Path:        []string{"/test/{id}"},
+	}
+	o := WithEndpoint(ep)
+	opts := server.NewHandlerOptions(o)
+	if opts.Metadata == nil {
+		t.Fatalf("WithEndpoint not works %#+v", opts)
+	}
+	md, ok := opts.Metadata[ep.Name]
+	if !ok {
+		t.Fatalf("WithEndpoint not works %#+v", opts)
+	}
+	if v, ok := md.Get("Endpoint"); !ok || v != "Foo.Bar" {
+		t.Fatalf("WithEndpoint not works %#+v", md)
+	}
+}
+
+func TestValidateNilErr(t *testing.T) {
+	var ep *Endpoint
+	if err := Validate(ep); err == nil {
+		t.Fatalf("Validate not works")
+	}
+}
+
+func TestValidateMissingNameErr(t *testing.T) {
+	ep := &Endpoint{}
+	if err := Validate(ep); err == nil {
+		t.Fatalf("Validate not works")
+	}
+}
+
+func TestValidateMissingHandlerErr(t *testing.T) {
+	ep := &Endpoint{Name: "test"}
+	if err := Validate(ep); err == nil {
+		t.Fatalf("Validate not works")
+	}
+}
+
+func TestValidateRegexpStartErr(t *testing.T) {
+	ep := &Endpoint{Name: "test", Handler: "test"}
+	ep.Path = []string{"^/"}
+	if err := Validate(ep); err == nil {
+		t.Fatalf("Validate not works")
+	}
+}
+
+func TestValidateRegexpEndErr(t *testing.T) {
+	ep := &Endpoint{Name: "test", Handler: "test", Path: []string{""}}
+	ep.Path[0] = "/$"
+	if err := Validate(ep); err == nil {
+		t.Fatalf("Validate not works")
+	}
+}
+
+func TestValidateRegexpNonErr(t *testing.T) {
+	ep := &Endpoint{Name: "test", Handler: "test", Path: []string{""}}
+	ep.Path[0] = "^/(.*)$"
+	if err := Validate(ep); err != nil {
+		t.Fatalf("Validate not works")
+	}
+}
+
+func TestValidateRegexpErr(t *testing.T) {
+	ep := &Endpoint{Name: "test", Handler: "test", Path: []string{""}}
+	ep.Path[0] = "^/(.$"
+	if err := Validate(ep); err == nil {
+		t.Fatalf("Validate not works")
+	}
+}

broker/context_test.go

@@ -7,16 +7,31 @@ import (
 
 func TestFromContext(t *testing.T) {
 	ctx := context.WithValue(context.TODO(), brokerKey{}, NewBroker())
-
 	c, ok := FromContext(ctx)
 	if c == nil || !ok {
 		t.Fatal("FromContext not works")
 	}
 }
 
+func TestFromNilContext(t *testing.T) {
+	// nolint: staticcheck
+	c, ok := FromContext(nil)
+	if ok || c != nil {
+		t.Fatal("FromContext not works")
+	}
+}
+
 func TestNewContext(t *testing.T) {
 	ctx := NewContext(context.TODO(), NewBroker())
+	c, ok := FromContext(ctx)
+	if c == nil || !ok {
+		t.Fatal("NewContext not works")
+	}
+}
 
+func TestNewNilContext(t *testing.T) {
+	// nolint: staticcheck
+	ctx := NewContext(nil, NewBroker())
 	c, ok := FromContext(ctx)
 	if c == nil || !ok {
 		t.Fatal("NewContext not works")

client/context_test.go

@@ -14,9 +14,25 @@ func TestFromContext(t *testing.T) {
 	}
 }
 
+func TestFromNilContext(t *testing.T) {
+	// nolint: staticcheck
+	c, ok := FromContext(nil)
+	if ok || c != nil {
+		t.Fatal("FromContext not works")
+	}
+}
+
 func TestNewContext(t *testing.T) {
 	ctx := NewContext(context.TODO(), NewClient())
+	c, ok := FromContext(ctx)
+	if c == nil || !ok {
+		t.Fatal("NewContext not works")
+	}
+}
 
+func TestNewNilContext(t *testing.T) {
+	// nolint: staticcheck
+	ctx := NewContext(nil, NewClient())
 	c, ok := FromContext(ctx)
 	if c == nil || !ok {
 		t.Fatal("NewContext not works")

client/noop.go

@@ -9,6 +9,7 @@ import (
 	"go.unistack.org/micro/v3/codec"
 	"go.unistack.org/micro/v3/errors"
 	"go.unistack.org/micro/v3/metadata"
+	"go.unistack.org/micro/v3/selector"
 )
 
 // DefaultCodecs will be used to encode/decode data
@@ -233,18 +234,7 @@ func (n *noopClient) Call(ctx context.Context, req Request, rsp interface{}, opt
 		callOpts.Address = []string{n.opts.Proxy}
 	}
 
-	// lookup the route to send the reques to
+	var next selector.Next
-	// TODO apply any filtering here
-	routes, err := n.opts.Lookup(ctx, req, callOpts)
-	if err != nil {
-		return errors.InternalServerError("go.micro.client", err.Error())
-	}
-
-	// balance the list of nodes
-	next, err := callOpts.Selector.Select(routes)
-	if err != nil {
-		return err
-	}
 
 	// return errors.New("go.micro.client", "request timeout", 408)
 	call := func(i int) error {
@@ -259,6 +249,22 @@ func (n *noopClient) Call(ctx context.Context, req Request, rsp interface{}, opt
 			time.Sleep(t)
 		}
 
+		if next == nil {
+			var routes []string
+			// lookup the route to send the reques to
+			// TODO apply any filtering here
+			routes, err = n.opts.Lookup(ctx, req, callOpts)
+			if err != nil {
+				return errors.InternalServerError("go.micro.client", err.Error())
+			}
+
+			// balance the list of nodes
+			next, err = callOpts.Selector.Select(routes)
+			if err != nil {
+				return err
+			}
+		}
+
 		node := next()
 
 		// make the call
@@ -323,6 +329,8 @@ func (n *noopClient) NewMessage(topic string, msg interface{}, opts ...MessageOp
 }
 
 func (n *noopClient) Stream(ctx context.Context, req Request, opts ...CallOption) (Stream, error) {
+	var err error
+
 	// make a copy of call opts
 	callOpts := n.opts.CallOptions
 	for _, o := range opts {
@@ -374,18 +382,7 @@ func (n *noopClient) Stream(ctx context.Context, req Request, opts ...CallOption
 		callOpts.Address = []string{n.opts.Proxy}
 	}
 
-	// lookup the route to send the reques to
+	var next selector.Next
-	// TODO apply any filtering here
-	routes, err := n.opts.Lookup(ctx, req, callOpts)
-	if err != nil {
-		return nil, errors.InternalServerError("go.micro.client", err.Error())
-	}
-
-	// balance the list of nodes
-	next, err := callOpts.Selector.Select(routes)
-	if err != nil {
-		return nil, err
-	}
 
 	call := func(i int) (Stream, error) {
 		// call backoff first. Someone may want an initial start delay
@@ -399,6 +396,22 @@ func (n *noopClient) Stream(ctx context.Context, req Request, opts ...CallOption
 			time.Sleep(t)
 		}
 
+		if next == nil {
+			var routes []string
+			// lookup the route to send the reques to
+			// TODO apply any filtering here
+			routes, err = n.opts.Lookup(ctx, req, callOpts)
+			if err != nil {
+				return nil, errors.InternalServerError("go.micro.client", err.Error())
+			}
+
+			// balance the list of nodes
+			next, err = callOpts.Selector.Select(routes)
+			if err != nil {
+				return nil, err
+			}
+		}
+
 		node := next()
 
 		stream, cerr := n.stream(ctx, node, req, callOpts)

config/context_test.go

@@ -5,6 +5,24 @@ import (
 	"testing"
 )
 
+func TestFromNilContext(t *testing.T) {
+	// nolint: staticcheck
+	c, ok := FromContext(nil)
+	if ok || c != nil {
+		t.Fatal("FromContext not works")
+	}
+}
+
+func TestNewNilContext(t *testing.T) {
+	// nolint: staticcheck
+	ctx := NewContext(nil, NewConfig())
+
+	c, ok := FromContext(ctx)
+	if c == nil || !ok {
+		t.Fatal("NewContext not works")
+	}
+}
+
 func TestFromContext(t *testing.T) {
 	ctx := context.WithValue(context.TODO(), configKey{}, NewConfig())
 

flow/context_test.go

@@ -5,6 +5,24 @@ import (
 	"testing"
 )
 
+func TestFromNilContext(t *testing.T) {
+	// nolint: staticcheck
+	c, ok := FromContext(nil)
+	if ok || c != nil {
+		t.Fatal("FromContext not works")
+	}
+}
+
+func TestNewNilContext(t *testing.T) {
+	// nolint: staticcheck
+	ctx := NewContext(nil, NewFlow())
+
+	c, ok := FromContext(ctx)
+	if c == nil || !ok {
+		t.Fatal("NewContext not works")
+	}
+}
+
 func TestFromContext(t *testing.T) {
 	ctx := context.WithValue(context.TODO(), flowKey{}, NewFlow())
 

logger/context_test.go

@@ -5,6 +5,24 @@ import (
 	"testing"
 )
 
+func TestFromNilContext(t *testing.T) {
+	// nolint: staticcheck
+	c, ok := FromContext(nil)
+	if ok || c != nil {
+		t.Fatal("FromContext not works")
+	}
+}
+
+func TestNewNilContext(t *testing.T) {
+	// nolint: staticcheck
+	ctx := NewContext(nil, NewLogger())
+
+	c, ok := FromContext(ctx)
+	if c == nil || !ok {
+		t.Fatal("NewContext not works")
+	}
+}
+
 func TestFromContext(t *testing.T) {
 	ctx := context.WithValue(context.TODO(), loggerKey{}, NewLogger())
 

metadata/context_test.go

@@ -5,6 +5,24 @@ import (
 	"testing"
 )
 
+func TestFromNilContext(t *testing.T) {
+	// nolint: staticcheck
+	c, ok := FromContext(nil)
+	if ok || c != nil {
+		t.Fatal("FromContext not works")
+	}
+}
+
+func TestNewNilContext(t *testing.T) {
+	// nolint: staticcheck
+	ctx := NewContext(nil, New(0))
+
+	c, ok := FromContext(ctx)
+	if c == nil || !ok {
+		t.Fatal("NewContext not works")
+	}
+}
+
 func TestFromContext(t *testing.T) {
 	ctx := context.WithValue(context.TODO(), mdKey{}, &rawMetadata{New(0)})
 

metadata/metadata.go

@@ -76,17 +76,24 @@ func (md Metadata) Get(key string) (string, bool) {
 }
 
 // Set is used to store value in metadata
-func (md Metadata) Set(key, val string) {
+func (md Metadata) Set(kv ...string) {
-	md[textproto.CanonicalMIMEHeaderKey(key)] = val
+	if len(kv)%2 == 1 {
+		kv = kv[:len(kv)-1]
+	}
+	for idx := 0; idx < len(kv); idx += 2 {
+		md[textproto.CanonicalMIMEHeaderKey(kv[idx])] = kv[idx+1]
+	}
 }
 
 // Del is used to remove value from metadata
-func (md Metadata) Del(key string) {
+func (md Metadata) Del(keys ...string) {
+	for _, key := range keys {
 		// fast path
 		delete(md, key)
 		// slow path
 		delete(md, textproto.CanonicalMIMEHeaderKey(key))
 	}
+}
 
 // Copy makes a copy of the metadata
 func Copy(md Metadata) Metadata {
@@ -129,13 +136,6 @@ func Pairs(kv ...string) (Metadata, bool) {
 		return nil, false
 	}
 	md := New(len(kv) / 2)
-	var k string
+	md.Set(kv...)
-	for i, v := range kv {
-		if i%2 == 0 {
-			k = v
-			continue
-		}
-		md.Set(k, v)
-	}
 	return md, true
 }

metadata/metadata_test.go

@@ -5,6 +5,21 @@ import (
 	"testing"
 )
 
+func TestMetadataSetMultiple(t *testing.T) {
+	md := New(4)
+	md.Set("key1", "val1", "key2", "val2", "key3")
+
+	if v, ok := md.Get("key1"); !ok || v != "val1" {
+		t.Fatalf("invalid kv %#+v", md)
+	}
+	if v, ok := md.Get("key2"); !ok || v != "val2" {
+		t.Fatalf("invalid kv %#+v", md)
+	}
+	if _, ok := md.Get("key3"); ok {
+		t.Fatalf("invalid kv %#+v", md)
+	}
+}
+
 func TestAppend(t *testing.T) {
 	ctx := context.Background()
 	ctx = AppendIncomingContext(ctx, "key1", "val1", "key2", "val2")

meter/context_test.go

@@ -5,6 +5,24 @@ import (
 	"testing"
 )
 
+func TestFromNilContext(t *testing.T) {
+	// nolint: staticcheck
+	c, ok := FromContext(nil)
+	if ok || c != nil {
+		t.Fatal("FromContext not works")
+	}
+}
+
+func TestNewNilContext(t *testing.T) {
+	// nolint: staticcheck
+	ctx := NewContext(nil, NewMeter())
+
+	c, ok := FromContext(ctx)
+	if c == nil || !ok {
+		t.Fatal("NewContext not works")
+	}
+}
+
 func TestFromContext(t *testing.T) {
 	ctx := context.WithValue(context.TODO(), meterKey{}, NewMeter())
 

register/context_test.go

@@ -5,6 +5,24 @@ import (
 	"testing"
 )
 
+func TestFromNilContext(t *testing.T) {
+	// nolint: staticcheck
+	c, ok := FromContext(nil)
+	if ok || c != nil {
+		t.Fatal("FromContext not works")
+	}
+}
+
+func TestNewNilContext(t *testing.T) {
+	// nolint: staticcheck
+	ctx := NewContext(nil, NewRegister())
+
+	c, ok := FromContext(ctx)
+	if c == nil || !ok {
+		t.Fatal("NewContext not works")
+	}
+}
+
 func TestFromContext(t *testing.T) {
 	ctx := context.WithValue(context.TODO(), registerKey{}, NewRegister())
 

router/context_test.go

@@ -5,6 +5,24 @@ import (
 	"testing"
 )
 
+func TestFromNilContext(t *testing.T) {
+	// nolint: staticcheck
+	c, ok := FromContext(nil)
+	if ok || c != nil {
+		t.Fatal("FromContext not works")
+	}
+}
+
+func TestNewNilContext(t *testing.T) {
+	// nolint: staticcheck
+	ctx := NewContext(nil, NewRouter())
+
+	c, ok := FromContext(ctx)
+	if c == nil || !ok {
+		t.Fatal("NewContext not works")
+	}
+}
+
 func TestFromContext(t *testing.T) {
 	ctx := context.WithValue(context.TODO(), routerKey{}, NewRouter())
 

server/context_test.go

@@ -5,6 +5,24 @@ import (
 	"testing"
 )
 
+func TestFromNilContext(t *testing.T) {
+	// nolint: staticcheck
+	c, ok := FromContext(nil)
+	if ok || c != nil {
+		t.Fatal("FromContext not works")
+	}
+}
+
+func TestNewNilContext(t *testing.T) {
+	// nolint: staticcheck
+	ctx := NewContext(nil, NewServer())
+
+	c, ok := FromContext(ctx)
+	if c == nil || !ok {
+		t.Fatal("NewContext not works")
+	}
+}
+
 func TestFromContext(t *testing.T) {
 	ctx := context.WithValue(context.TODO(), serverKey{}, NewServer())
 

store/context_test.go

@@ -5,6 +5,24 @@ import (
 	"testing"
 )
 
+func TestFromNilContext(t *testing.T) {
+	// nolint: staticcheck
+	c, ok := FromContext(nil)
+	if ok || c != nil {
+		t.Fatal("FromContext not works")
+	}
+}
+
+func TestNewNilContext(t *testing.T) {
+	// nolint: staticcheck
+	ctx := NewContext(nil, NewStore())
+
+	c, ok := FromContext(ctx)
+	if c == nil || !ok {
+		t.Fatal("NewContext not works")
+	}
+}
+
 func TestFromContext(t *testing.T) {
 	ctx := context.WithValue(context.TODO(), storeKey{}, NewStore())
 

tracer/context_test.go

@@ -5,6 +5,24 @@ import (
 	"testing"
 )
 
+func TestFromNilContext(t *testing.T) {
+	// nolint: staticcheck
+	c, ok := FromContext(nil)
+	if ok || c != nil {
+		t.Fatal("FromContext not works")
+	}
+}
+
+func TestNewNilContext(t *testing.T) {
+	// nolint: staticcheck
+	ctx := NewContext(nil, NewTracer())
+
+	c, ok := FromContext(ctx)
+	if c == nil || !ok {
+		t.Fatal("NewContext not works")
+	}
+}
+
 func TestFromContext(t *testing.T) {
 	ctx := context.WithValue(context.TODO(), tracerKey{}, NewTracer())