2019-06-03 18:44:43 +01:00
|
|
|
package api
|
|
|
|
|
|
|
|
import (
|
|
|
|
"strings"
|
|
|
|
"testing"
|
2022-05-03 15:41:30 +03:00
|
|
|
|
|
|
|
"go.unistack.org/micro/v3/metadata"
|
|
|
|
"go.unistack.org/micro/v3/server"
|
2019-06-03 18:44:43 +01:00
|
|
|
)
|
|
|
|
|
2022-05-03 15:41:30 +03:00
|
|
|
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)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-02-14 16:16:01 +03:00
|
|
|
//nolint:gocyclo
|
2022-05-03 15:41:30 +03:00
|
|
|
func TestEncode(t *testing.T) {
|
2019-06-03 18:44:43 +01:00
|
|
|
testData := []*Endpoint{
|
|
|
|
nil,
|
|
|
|
{
|
|
|
|
Name: "Foo.Bar",
|
|
|
|
Description: "A test endpoint",
|
|
|
|
Handler: "meta",
|
|
|
|
Host: []string{"foo.com"},
|
|
|
|
Method: []string{"GET"},
|
|
|
|
Path: []string{"/test"},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
|
|
|
|
compare := func(expect, got []string) bool {
|
|
|
|
// no data to compare, return true
|
|
|
|
if len(expect) == 0 && len(got) == 0 {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
// no data expected but got some return false
|
|
|
|
if len(expect) == 0 && len(got) > 0 {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
// compare expected with what we got
|
|
|
|
for _, e := range expect {
|
|
|
|
var seen bool
|
|
|
|
for _, g := range got {
|
|
|
|
if e == g {
|
|
|
|
seen = true
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if !seen {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// we're done, return true
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, d := range testData {
|
|
|
|
// encode
|
|
|
|
e := Encode(d)
|
|
|
|
// decode
|
|
|
|
de := Decode(e)
|
|
|
|
|
|
|
|
// nil endpoint returns nil
|
|
|
|
if d == nil {
|
|
|
|
if e != nil {
|
|
|
|
t.Fatalf("expected nil got %v", e)
|
|
|
|
}
|
|
|
|
if de != nil {
|
|
|
|
t.Fatalf("expected nil got %v", de)
|
|
|
|
}
|
|
|
|
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
// check encoded map
|
|
|
|
name := e["endpoint"]
|
|
|
|
desc := e["description"]
|
|
|
|
method := strings.Split(e["method"], ",")
|
|
|
|
path := strings.Split(e["path"], ",")
|
|
|
|
host := strings.Split(e["host"], ",")
|
|
|
|
handler := e["handler"]
|
|
|
|
|
|
|
|
if name != d.Name {
|
|
|
|
t.Fatalf("expected %v got %v", d.Name, name)
|
|
|
|
}
|
|
|
|
if desc != d.Description {
|
|
|
|
t.Fatalf("expected %v got %v", d.Description, desc)
|
|
|
|
}
|
|
|
|
if handler != d.Handler {
|
|
|
|
t.Fatalf("expected %v got %v", d.Handler, handler)
|
|
|
|
}
|
|
|
|
if ok := compare(d.Method, method); !ok {
|
|
|
|
t.Fatalf("expected %v got %v", d.Method, method)
|
|
|
|
}
|
|
|
|
if ok := compare(d.Path, path); !ok {
|
|
|
|
t.Fatalf("expected %v got %v", d.Path, path)
|
|
|
|
}
|
|
|
|
if ok := compare(d.Host, host); !ok {
|
|
|
|
t.Fatalf("expected %v got %v", d.Host, host)
|
|
|
|
}
|
|
|
|
|
|
|
|
if de.Name != d.Name {
|
|
|
|
t.Fatalf("expected %v got %v", d.Name, de.Name)
|
|
|
|
}
|
|
|
|
if de.Description != d.Description {
|
|
|
|
t.Fatalf("expected %v got %v", d.Description, de.Description)
|
|
|
|
}
|
|
|
|
if de.Handler != d.Handler {
|
|
|
|
t.Fatalf("expected %v got %v", d.Handler, de.Handler)
|
|
|
|
}
|
|
|
|
if ok := compare(d.Method, de.Method); !ok {
|
|
|
|
t.Fatalf("expected %v got %v", d.Method, de.Method)
|
|
|
|
}
|
|
|
|
if ok := compare(d.Path, de.Path); !ok {
|
|
|
|
t.Fatalf("expected %v got %v", d.Path, de.Path)
|
|
|
|
}
|
|
|
|
if ok := compare(d.Host, de.Host); !ok {
|
|
|
|
t.Fatalf("expected %v got %v", d.Host, de.Host)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-04-29 15:23:10 +03:00
|
|
|
|
|
|
|
func TestValidate(t *testing.T) {
|
|
|
|
epPcre := &Endpoint{
|
|
|
|
Name: "Foo.Bar",
|
|
|
|
Description: "A test endpoint",
|
|
|
|
Handler: "meta",
|
|
|
|
Host: []string{"foo.com"},
|
|
|
|
Method: []string{"GET"},
|
|
|
|
Path: []string{"^/test/?$"},
|
|
|
|
}
|
|
|
|
if err := Validate(epPcre); err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
epGpath := &Endpoint{
|
|
|
|
Name: "Foo.Bar",
|
|
|
|
Description: "A test endpoint",
|
|
|
|
Handler: "meta",
|
|
|
|
Host: []string{"foo.com"},
|
|
|
|
Method: []string{"GET"},
|
|
|
|
Path: []string{"/test/{id}"},
|
|
|
|
}
|
|
|
|
if err := Validate(epGpath); err != nil {
|
|
|
|
t.Fatal(err)
|
|
|
|
}
|
|
|
|
|
|
|
|
epPcreInvalid := &Endpoint{
|
|
|
|
Name: "Foo.Bar",
|
|
|
|
Description: "A test endpoint",
|
|
|
|
Handler: "meta",
|
|
|
|
Host: []string{"foo.com"},
|
|
|
|
Method: []string{"GET"},
|
|
|
|
Path: []string{"/test/?$"},
|
|
|
|
}
|
|
|
|
if err := Validate(epPcreInvalid); err == nil {
|
|
|
|
t.Fatalf("invalid pcre %v", epPcreInvalid.Path[0])
|
|
|
|
}
|
|
|
|
}
|
2022-05-03 15:41:30 +03:00
|
|
|
|
|
|
|
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")
|
|
|
|
}
|
|
|
|
}
|