635 lines
12 KiB
Go
635 lines
12 KiB
Go
package config
|
|
|
|
import (
|
|
"fmt"
|
|
"net/http"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func TestLegalServiceName(t *testing.T) {
|
|
tests := []struct {
|
|
Raw string
|
|
Error error
|
|
}{
|
|
{
|
|
`{
|
|
"/": {
|
|
"invalid/service-name": {
|
|
|
|
}
|
|
}
|
|
}`,
|
|
ErrFormat.Wrap(ErrIllegalServiceName.WrapString("invalid/service-name")),
|
|
},
|
|
{
|
|
`{
|
|
"/": {
|
|
"invalid/service/name": {
|
|
|
|
}
|
|
}
|
|
}`,
|
|
ErrFormat.Wrap(ErrIllegalServiceName.WrapString("invalid/service/name")),
|
|
},
|
|
{
|
|
`{
|
|
"/": {
|
|
"invalid-service-name": {
|
|
|
|
}
|
|
}
|
|
}`,
|
|
ErrFormat.Wrap(ErrIllegalServiceName.WrapString("invalid-service-name")),
|
|
},
|
|
|
|
{
|
|
`{
|
|
"/": {
|
|
"valid.service_name": {
|
|
}
|
|
}
|
|
}`,
|
|
nil,
|
|
},
|
|
}
|
|
|
|
for i, test := range tests {
|
|
|
|
t.Run(fmt.Sprintf("service.%d", i), func(t *testing.T) {
|
|
_, err := Parse(strings.NewReader(test.Raw))
|
|
|
|
if err == nil && test.Error != nil {
|
|
t.Errorf("expected an error: '%s'", test.Error.Error())
|
|
t.FailNow()
|
|
}
|
|
if err != nil && test.Error == nil {
|
|
t.Errorf("unexpected error: '%s'", err.Error())
|
|
t.FailNow()
|
|
}
|
|
|
|
if err != nil && test.Error != nil {
|
|
if err.Error() != test.Error.Error() {
|
|
t.Errorf("expected the error '%s' (got '%s')", test.Error.Error(), err.Error())
|
|
t.FailNow()
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
func TestAvailableMethods(t *testing.T) {
|
|
reader := strings.NewReader(`{
|
|
"GET": { "info": "info" },
|
|
"POST": { "info": "info" },
|
|
"PUT": { "info": "info" },
|
|
"DELETE": { "info": "info" }
|
|
}`)
|
|
srv, err := Parse(reader)
|
|
if err != nil {
|
|
t.Errorf("unexpected error (got '%s')", err)
|
|
t.FailNow()
|
|
}
|
|
|
|
if srv.Method(http.MethodGet) == nil {
|
|
t.Errorf("expected method GET to be available")
|
|
t.Fail()
|
|
}
|
|
if srv.Method(http.MethodPost) == nil {
|
|
t.Errorf("expected method POST to be available")
|
|
t.Fail()
|
|
}
|
|
if srv.Method(http.MethodPut) == nil {
|
|
t.Errorf("expected method PUT to be available")
|
|
t.Fail()
|
|
}
|
|
if srv.Method(http.MethodDelete) == nil {
|
|
t.Errorf("expected method DELETE to be available")
|
|
t.Fail()
|
|
}
|
|
|
|
if srv.Method(http.MethodPatch) != nil {
|
|
t.Errorf("expected method PATH to be UNavailable")
|
|
t.Fail()
|
|
}
|
|
}
|
|
func TestParseEmpty(t *testing.T) {
|
|
reader := strings.NewReader(`{}`)
|
|
_, err := Parse(reader)
|
|
if err != nil {
|
|
t.Errorf("unexpected error (got '%s')", err)
|
|
t.FailNow()
|
|
}
|
|
}
|
|
func TestParseJsonError(t *testing.T) {
|
|
reader := strings.NewReader(`{
|
|
"GET": {
|
|
"info": "info
|
|
},
|
|
}`) // trailing ',' is invalid JSON
|
|
_, err := Parse(reader)
|
|
if err == nil {
|
|
t.Errorf("expected error")
|
|
t.FailNow()
|
|
}
|
|
}
|
|
|
|
func TestParseMissingMethodDescription(t *testing.T) {
|
|
tests := []struct {
|
|
Raw string
|
|
Error error
|
|
}{
|
|
{ // missing description
|
|
`{
|
|
"GET": {
|
|
|
|
}
|
|
}`,
|
|
ErrFormat.Wrap(ErrMissingMethodDesc.WrapString("GET /")),
|
|
},
|
|
{ // missing description
|
|
`{
|
|
"/": {
|
|
"subservice": {
|
|
"GET": {
|
|
|
|
}
|
|
}
|
|
}
|
|
}`,
|
|
ErrFormat.Wrap(ErrMissingMethodDesc.WrapString("GET subservice")),
|
|
},
|
|
{ // empty description
|
|
`{
|
|
"GET": {
|
|
"info": ""
|
|
}
|
|
}`,
|
|
ErrFormat.Wrap(ErrMissingMethodDesc.WrapString("GET /")),
|
|
},
|
|
{ // valid description
|
|
`{
|
|
"GET": {
|
|
"info": "a"
|
|
}
|
|
}`,
|
|
nil,
|
|
},
|
|
{ // valid description
|
|
`{
|
|
"GET": {
|
|
"info": "some description"
|
|
}
|
|
}`,
|
|
nil,
|
|
},
|
|
}
|
|
|
|
for i, test := range tests {
|
|
|
|
t.Run(fmt.Sprintf("method.%d", i), func(t *testing.T) {
|
|
_, err := Parse(strings.NewReader(test.Raw))
|
|
|
|
if err == nil && test.Error != nil {
|
|
t.Errorf("expected an error: '%s'", test.Error.Error())
|
|
t.FailNow()
|
|
}
|
|
if err != nil && test.Error == nil {
|
|
t.Errorf("unexpected error: '%s'", err.Error())
|
|
t.FailNow()
|
|
}
|
|
|
|
if err != nil && test.Error != nil {
|
|
if err.Error() != test.Error.Error() {
|
|
t.Errorf("expected the error '%s' (got '%s')", test.Error.Error(), err.Error())
|
|
t.FailNow()
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
}
|
|
|
|
func TestParamEmptyRenameNoRename(t *testing.T) {
|
|
reader := strings.NewReader(`{
|
|
"GET": {
|
|
"info": "info",
|
|
"in": {
|
|
"original": { "info": "valid-desc", "type": "valid-type", "name": "" }
|
|
}
|
|
}
|
|
}`)
|
|
srv, err := Parse(reader)
|
|
if err != nil {
|
|
t.Errorf("unexpected error: '%s'", err)
|
|
t.FailNow()
|
|
}
|
|
|
|
method := srv.Method(http.MethodGet)
|
|
if method == nil {
|
|
t.Errorf("expected GET method not to be nil")
|
|
t.FailNow()
|
|
}
|
|
for _, param := range method.Parameters {
|
|
|
|
if param.Rename != "original" {
|
|
t.Errorf("expected the parameter 'original' not to be renamed to '%s'", param.Rename)
|
|
t.FailNow()
|
|
}
|
|
}
|
|
|
|
}
|
|
func TestOptionalParam(t *testing.T) {
|
|
reader := strings.NewReader(`{
|
|
"GET": {
|
|
"info": "info",
|
|
"in": {
|
|
"optional": { "info": "valid-desc", "type": "?optional-type" },
|
|
"required": { "info": "valid-desc", "type": "required-type" },
|
|
"required2": { "info": "valid-desc", "type": "a" },
|
|
"optional2": { "info": "valid-desc", "type": "?a" }
|
|
}
|
|
}
|
|
}`)
|
|
srv, err := Parse(reader)
|
|
if err != nil {
|
|
t.Errorf("unexpected error: '%s'", err)
|
|
t.FailNow()
|
|
}
|
|
|
|
method := srv.Method(http.MethodGet)
|
|
if method == nil {
|
|
t.Errorf("expected GET method not to be nil")
|
|
t.FailNow()
|
|
}
|
|
for pName, param := range method.Parameters {
|
|
|
|
if pName == "optional" || pName == "optional2" {
|
|
if !param.Optional {
|
|
t.Errorf("expected parameter '%s' to be optional", pName)
|
|
t.Failed()
|
|
}
|
|
}
|
|
if pName == "required" || pName == "required2" {
|
|
if param.Optional {
|
|
t.Errorf("expected parameter '%s' to be required", pName)
|
|
t.Failed()
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
func TestParseParameters(t *testing.T) {
|
|
tests := []struct {
|
|
Raw string
|
|
Error error
|
|
ErrorAlternative error
|
|
}{
|
|
{ // invalid param name prefix
|
|
`{
|
|
"GET": {
|
|
"info": "info",
|
|
"in": {
|
|
"_param1": {}
|
|
}
|
|
}
|
|
}`,
|
|
ErrFormat.Wrap(ErrIllegalParamName.WrapString("GET / {_param1}")),
|
|
nil,
|
|
},
|
|
{ // invalid param name suffix
|
|
`{
|
|
"GET": {
|
|
"info": "info",
|
|
"in": {
|
|
"param1_": {}
|
|
}
|
|
}
|
|
}`,
|
|
ErrFormat.Wrap(ErrIllegalParamName.WrapString("GET / {param1_}")),
|
|
nil,
|
|
},
|
|
|
|
{ // missing param description
|
|
`{
|
|
"GET": {
|
|
"info": "info",
|
|
"in": {
|
|
"param1": {}
|
|
}
|
|
}
|
|
}`,
|
|
ErrFormat.Wrap(ErrMissingParamDesc.WrapString("GET / {param1}")),
|
|
nil,
|
|
},
|
|
{ // empty param description
|
|
`{
|
|
"GET": {
|
|
"info": "info",
|
|
"in": {
|
|
"param1": {
|
|
"info": ""
|
|
}
|
|
}
|
|
}
|
|
}`,
|
|
ErrFormat.Wrap(ErrMissingParamDesc.WrapString("GET / {param1}")),
|
|
nil,
|
|
},
|
|
|
|
{ // missing param type
|
|
`{
|
|
"GET": {
|
|
"info": "info",
|
|
"in": {
|
|
"param1": {
|
|
"info": "valid"
|
|
}
|
|
}
|
|
}
|
|
}`,
|
|
ErrFormat.Wrap(ErrMissingParamType.WrapString("GET / {param1}")),
|
|
nil,
|
|
},
|
|
{ // empty param type
|
|
`{
|
|
"GET": {
|
|
"info": "info",
|
|
"in": {
|
|
"param1": {
|
|
"info": "valid",
|
|
"type": ""
|
|
}
|
|
}
|
|
}
|
|
}`,
|
|
ErrFormat.Wrap(ErrMissingParamType.WrapString("GET / {param1}")),
|
|
nil,
|
|
},
|
|
{ // invalid type (optional mark only)
|
|
`{
|
|
"GET": {
|
|
"info": "info",
|
|
"in": {
|
|
"param1": {
|
|
"info": "valid",
|
|
"type": "?"
|
|
}
|
|
}
|
|
}
|
|
}`,
|
|
|
|
ErrFormat.Wrap(ErrMissingParamType.WrapString("GET / {param1}")),
|
|
ErrFormat.Wrap(ErrMissingParamType.WrapString("GET / {param1}")),
|
|
},
|
|
{ // valid description + valid type
|
|
`{
|
|
"GET": {
|
|
"info": "info",
|
|
"in": {
|
|
"param1": {
|
|
"info": "valid",
|
|
"type": "a"
|
|
}
|
|
}
|
|
}
|
|
}`,
|
|
nil,
|
|
nil,
|
|
},
|
|
{ // valid description + valid OPTIONAL type
|
|
`{
|
|
"GET": {
|
|
"info": "info",
|
|
"in": {
|
|
"param1": {
|
|
"info": "valid",
|
|
"type": "?valid"
|
|
}
|
|
}
|
|
}
|
|
}`,
|
|
nil,
|
|
nil,
|
|
},
|
|
|
|
{ // name conflict with rename
|
|
`{
|
|
"GET": {
|
|
"info": "info",
|
|
"in": {
|
|
"param1": { "info": "valid", "type": "valid" },
|
|
"param2": { "info": "valid", "type": "valid", "name": "param1" }
|
|
|
|
}
|
|
}
|
|
}`,
|
|
// 2 possible errors as map order is not deterministic
|
|
ErrFormat.Wrap(ErrParamNameConflict.WrapString("GET / {param1}")),
|
|
ErrFormat.Wrap(ErrParamNameConflict.WrapString("GET / {param2}")),
|
|
},
|
|
{ // rename conflict with name
|
|
`{
|
|
"GET": {
|
|
"info": "info",
|
|
"in": {
|
|
"param1": { "info": "valid", "type": "valid", "name": "param2" },
|
|
"param2": { "info": "valid", "type": "valid" }
|
|
|
|
}
|
|
}
|
|
}`,
|
|
// 2 possible errors as map order is not deterministic
|
|
ErrFormat.Wrap(ErrParamNameConflict.WrapString("GET / {param1}")),
|
|
ErrFormat.Wrap(ErrParamNameConflict.WrapString("GET / {param2}")),
|
|
},
|
|
{ // rename conflict with rename
|
|
`{
|
|
"GET": {
|
|
"info": "info",
|
|
"in": {
|
|
"param1": { "info": "valid", "type": "valid", "name": "conflict" },
|
|
"param2": { "info": "valid", "type": "valid", "name": "conflict" }
|
|
|
|
}
|
|
}
|
|
}`,
|
|
// 2 possible errors as map order is not deterministic
|
|
ErrFormat.Wrap(ErrParamNameConflict.WrapString("GET / {param1}")),
|
|
ErrFormat.Wrap(ErrParamNameConflict.WrapString("GET / {param2}")),
|
|
},
|
|
|
|
{ // both renamed with no conflict
|
|
`{
|
|
"GET": {
|
|
"info": "info",
|
|
"in": {
|
|
"param1": { "info": "valid", "type": "valid", "name": "freename" },
|
|
"param2": { "info": "valid", "type": "valid", "name": "freename2" }
|
|
|
|
}
|
|
}
|
|
}`,
|
|
nil,
|
|
nil,
|
|
},
|
|
}
|
|
|
|
for i, test := range tests {
|
|
|
|
t.Run(fmt.Sprintf("method.%d", i), func(t *testing.T) {
|
|
_, err := Parse(strings.NewReader(test.Raw))
|
|
|
|
if err == nil && test.Error != nil {
|
|
t.Errorf("expected an error: '%s'", test.Error.Error())
|
|
t.FailNow()
|
|
}
|
|
if err != nil && test.Error == nil {
|
|
t.Errorf("unexpected error: '%s'", err.Error())
|
|
t.FailNow()
|
|
}
|
|
|
|
if err != nil && test.Error != nil {
|
|
if err.Error() != test.Error.Error() && err.Error() != test.ErrorAlternative.Error() {
|
|
t.Errorf("expected the error '%s' (got '%s')", test.Error.Error(), err.Error())
|
|
t.FailNow()
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
}
|
|
|
|
func TestBrowseSimple(t *testing.T) {
|
|
tests := []struct {
|
|
Raw string
|
|
Path []string
|
|
BrowseDepth int
|
|
ValidDepth bool
|
|
}{
|
|
{ // false positive -1
|
|
`{
|
|
"/" : {
|
|
"parent": {
|
|
"/": {
|
|
"subdir": {}
|
|
}
|
|
}
|
|
}
|
|
}`,
|
|
[]string{"parent", "subdir"},
|
|
1,
|
|
false,
|
|
},
|
|
{ // false positive +1
|
|
`{
|
|
"/" : {
|
|
"parent": {
|
|
"/": {
|
|
"subdir": {}
|
|
}
|
|
}
|
|
}
|
|
}`,
|
|
[]string{"parent", "subdir"},
|
|
3,
|
|
false,
|
|
},
|
|
|
|
{
|
|
`{
|
|
"/" : {
|
|
"parent": {
|
|
"/": {
|
|
"subdir": {}
|
|
}
|
|
}
|
|
}
|
|
}`,
|
|
[]string{"parent", "subdir"},
|
|
2,
|
|
true,
|
|
},
|
|
{ // unknown path
|
|
`{
|
|
"/" : {
|
|
"parent": {
|
|
"/": {
|
|
"subdir": {}
|
|
}
|
|
}
|
|
}
|
|
}`,
|
|
[]string{"x", "y"},
|
|
2,
|
|
false,
|
|
},
|
|
{ // unknown path
|
|
`{
|
|
"/" : {
|
|
"parent": {
|
|
"/": {
|
|
"subdir": {}
|
|
}
|
|
}
|
|
}
|
|
}`,
|
|
[]string{"parent", "y"},
|
|
1,
|
|
true,
|
|
},
|
|
{ // Warning: this case is important to understand the precedence of service paths over
|
|
// the value of some variables. Here if we send a string parameter in the GET method that
|
|
// unfortunately is equal to 'subdir', it will call the sub-service /parent/subdir' instead
|
|
// of the service /parent with its parameter set to the value 'subdir'.
|
|
`{
|
|
"/" : {
|
|
"parent": {
|
|
"/": {
|
|
"subdir": {}
|
|
},
|
|
"GET": {
|
|
"info": "valid-desc",
|
|
"in": {
|
|
"some-value": {
|
|
"info": "valid-desc",
|
|
"type": "valid-type"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}`,
|
|
[]string{"parent", "subdir"},
|
|
2,
|
|
true,
|
|
},
|
|
}
|
|
|
|
for i, test := range tests {
|
|
|
|
t.Run(fmt.Sprintf("method.%d", i), func(t *testing.T) {
|
|
srv, err := Parse(strings.NewReader(test.Raw))
|
|
|
|
if err != nil {
|
|
t.Errorf("unexpected error: '%s'", err)
|
|
t.FailNow()
|
|
}
|
|
|
|
_, depth := srv.Browse(test.Path)
|
|
if test.ValidDepth {
|
|
if depth != test.BrowseDepth {
|
|
t.Errorf("expected a depth of %d (got %d)", test.BrowseDepth, depth)
|
|
t.FailNow()
|
|
}
|
|
} else {
|
|
if depth == test.BrowseDepth {
|
|
t.Errorf("expected a depth NOT %d (got %d)", test.BrowseDepth, depth)
|
|
t.FailNow()
|
|
}
|
|
|
|
}
|
|
})
|
|
}
|
|
|
|
}
|