mirror of
https://github.com/containous/traefik.git
synced 2024-12-24 21:34:39 +03:00
412 lines
9.1 KiB
Go
412 lines
9.1 KiB
Go
package types
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func TestStatusCodesSet(t *testing.T) {
|
|
testCases := []struct {
|
|
desc string
|
|
value string
|
|
expected StatusCodes
|
|
}{
|
|
{
|
|
desc: "One value should return StatusCodes of size 1",
|
|
value: "200",
|
|
expected: StatusCodes{"200"},
|
|
},
|
|
{
|
|
desc: "Two values separated by comma should return StatusCodes of size 2",
|
|
value: "200,400",
|
|
expected: StatusCodes{"200", "400"},
|
|
},
|
|
{
|
|
desc: "Two values separated by semicolon should return StatusCodes of size 2",
|
|
value: "200;400",
|
|
expected: StatusCodes{"200", "400"},
|
|
},
|
|
{
|
|
desc: "Three values separated by comma and semicolon should return StatusCodes of size 3",
|
|
value: "200,400;500",
|
|
expected: StatusCodes{"200", "400", "500"},
|
|
},
|
|
}
|
|
|
|
for _, test := range testCases {
|
|
test := test
|
|
t.Run(test.desc, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var statusCodes StatusCodes
|
|
err := statusCodes.Set(test.value)
|
|
assert.Nil(t, err)
|
|
assert.Equal(t, test.expected, statusCodes)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestStatusCodesGet(t *testing.T) {
|
|
testCases := []struct {
|
|
desc string
|
|
values StatusCodes
|
|
expected StatusCodes
|
|
}{
|
|
{
|
|
desc: "Should return 1 value",
|
|
values: StatusCodes{"200"},
|
|
expected: StatusCodes{"200"},
|
|
},
|
|
{
|
|
desc: "Should return 2 values",
|
|
values: StatusCodes{"200", "400"},
|
|
expected: StatusCodes{"200", "400"},
|
|
},
|
|
{
|
|
desc: "Should return 3 values",
|
|
values: StatusCodes{"200", "400", "500"},
|
|
expected: StatusCodes{"200", "400", "500"},
|
|
},
|
|
}
|
|
|
|
for _, test := range testCases {
|
|
test := test
|
|
t.Run(test.desc, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
actual := test.values.Get()
|
|
assert.Equal(t, test.expected, actual)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestStatusCodesString(t *testing.T) {
|
|
testCases := []struct {
|
|
desc string
|
|
values StatusCodes
|
|
expected string
|
|
}{
|
|
{
|
|
desc: "Should return 1 value",
|
|
values: StatusCodes{"200"},
|
|
expected: "[200]",
|
|
},
|
|
{
|
|
desc: "Should return 2 values",
|
|
values: StatusCodes{"200", "400"},
|
|
expected: "[200 400]",
|
|
},
|
|
{
|
|
desc: "Should return 3 values",
|
|
values: StatusCodes{"200", "400", "500"},
|
|
expected: "[200 400 500]",
|
|
},
|
|
}
|
|
|
|
for _, test := range testCases {
|
|
test := test
|
|
t.Run(test.desc, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
actual := test.values.String()
|
|
assert.Equal(t, test.expected, actual)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestStatusCodesSetValue(t *testing.T) {
|
|
testCases := []struct {
|
|
desc string
|
|
values StatusCodes
|
|
expected StatusCodes
|
|
}{
|
|
{
|
|
desc: "Should return 1 value",
|
|
values: StatusCodes{"200"},
|
|
expected: StatusCodes{"200"},
|
|
},
|
|
{
|
|
desc: "Should return 2 values",
|
|
values: StatusCodes{"200", "400"},
|
|
expected: StatusCodes{"200", "400"},
|
|
},
|
|
{
|
|
desc: "Should return 3 values",
|
|
values: StatusCodes{"200", "400", "500"},
|
|
expected: StatusCodes{"200", "400", "500"},
|
|
},
|
|
}
|
|
|
|
for _, test := range testCases {
|
|
test := test
|
|
t.Run(test.desc, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
var slice StatusCodes
|
|
slice.SetValue(test.values)
|
|
assert.Equal(t, test.expected, slice)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestFieldsNamesSet(t *testing.T) {
|
|
testCases := []struct {
|
|
desc string
|
|
value string
|
|
expected *FieldNames
|
|
}{
|
|
{
|
|
desc: "One value should return FieldNames of size 1",
|
|
value: "field-1=foo",
|
|
expected: &FieldNames{
|
|
"field-1": "foo",
|
|
},
|
|
},
|
|
{
|
|
desc: "Two values separated by space should return FieldNames of size 2",
|
|
value: "field-1=foo field-2=bar",
|
|
expected: &FieldNames{
|
|
"field-1": "foo",
|
|
"field-2": "bar",
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, test := range testCases {
|
|
test := test
|
|
t.Run(test.desc, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fieldsNames := &FieldNames{}
|
|
err := fieldsNames.Set(test.value)
|
|
assert.NoError(t, err)
|
|
|
|
assert.Equal(t, test.expected, fieldsNames)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestFieldsNamesGet(t *testing.T) {
|
|
testCases := []struct {
|
|
desc string
|
|
values FieldNames
|
|
expected FieldNames
|
|
}{
|
|
{
|
|
desc: "Should return 1 value",
|
|
values: FieldNames{"field-1": "foo"},
|
|
expected: FieldNames{"field-1": "foo"},
|
|
},
|
|
{
|
|
desc: "Should return 2 values",
|
|
values: FieldNames{"field-1": "foo", "field-2": "bar"},
|
|
expected: FieldNames{"field-1": "foo", "field-2": "bar"},
|
|
},
|
|
{
|
|
desc: "Should return 3 values",
|
|
values: FieldNames{"field-1": "foo", "field-2": "bar", "field-3": "powpow"},
|
|
expected: FieldNames{"field-1": "foo", "field-2": "bar", "field-3": "powpow"},
|
|
},
|
|
}
|
|
|
|
for _, test := range testCases {
|
|
test := test
|
|
t.Run(test.desc, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
actual := test.values.Get()
|
|
assert.Equal(t, test.expected, actual)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestFieldsNamesString(t *testing.T) {
|
|
testCases := []struct {
|
|
desc string
|
|
values FieldNames
|
|
expected string
|
|
}{
|
|
{
|
|
desc: "Should return 1 value",
|
|
values: FieldNames{"field-1": "foo"},
|
|
expected: "map[field-1:foo]",
|
|
},
|
|
}
|
|
|
|
for _, test := range testCases {
|
|
test := test
|
|
t.Run(test.desc, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
actual := test.values.String()
|
|
assert.Equal(t, test.expected, actual)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestFieldsNamesSetValue(t *testing.T) {
|
|
testCases := []struct {
|
|
desc string
|
|
values FieldNames
|
|
expected *FieldNames
|
|
}{
|
|
{
|
|
desc: "Should return 1 value",
|
|
values: FieldNames{"field-1": "foo"},
|
|
expected: &FieldNames{"field-1": "foo"},
|
|
},
|
|
{
|
|
desc: "Should return 2 values",
|
|
values: FieldNames{"field-1": "foo", "field-2": "bar"},
|
|
expected: &FieldNames{"field-1": "foo", "field-2": "bar"},
|
|
},
|
|
{
|
|
desc: "Should return 3 values",
|
|
values: FieldNames{"field-1": "foo", "field-2": "bar", "field-3": "powpow"},
|
|
expected: &FieldNames{"field-1": "foo", "field-2": "bar", "field-3": "powpow"},
|
|
},
|
|
}
|
|
|
|
for _, test := range testCases {
|
|
test := test
|
|
t.Run(test.desc, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
fieldsNames := &FieldNames{}
|
|
fieldsNames.SetValue(test.values)
|
|
assert.Equal(t, test.expected, fieldsNames)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestFieldsHeadersNamesSet(t *testing.T) {
|
|
testCases := []struct {
|
|
desc string
|
|
value string
|
|
expected *FieldHeaderNames
|
|
}{
|
|
{
|
|
desc: "One value should return FieldNames of size 1",
|
|
value: "X-HEADER-1=foo",
|
|
expected: &FieldHeaderNames{
|
|
"X-HEADER-1": "foo",
|
|
},
|
|
},
|
|
{
|
|
desc: "Two values separated by space should return FieldNames of size 2",
|
|
value: "X-HEADER-1=foo X-HEADER-2=bar",
|
|
expected: &FieldHeaderNames{
|
|
"X-HEADER-1": "foo",
|
|
"X-HEADER-2": "bar",
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, test := range testCases {
|
|
test := test
|
|
t.Run(test.desc, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
headersNames := &FieldHeaderNames{}
|
|
err := headersNames.Set(test.value)
|
|
assert.NoError(t, err)
|
|
|
|
assert.Equal(t, test.expected, headersNames)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestFieldsHeadersNamesGet(t *testing.T) {
|
|
testCases := []struct {
|
|
desc string
|
|
values FieldHeaderNames
|
|
expected FieldHeaderNames
|
|
}{
|
|
{
|
|
desc: "Should return 1 value",
|
|
values: FieldHeaderNames{"X-HEADER-1": "foo"},
|
|
expected: FieldHeaderNames{"X-HEADER-1": "foo"},
|
|
},
|
|
{
|
|
desc: "Should return 2 values",
|
|
values: FieldHeaderNames{"X-HEADER-1": "foo", "X-HEADER-2": "bar"},
|
|
expected: FieldHeaderNames{"X-HEADER-1": "foo", "X-HEADER-2": "bar"},
|
|
},
|
|
{
|
|
desc: "Should return 3 values",
|
|
values: FieldHeaderNames{"X-HEADER-1": "foo", "X-HEADER-2": "bar", "X-HEADER-3": "powpow"},
|
|
expected: FieldHeaderNames{"X-HEADER-1": "foo", "X-HEADER-2": "bar", "X-HEADER-3": "powpow"},
|
|
},
|
|
}
|
|
|
|
for _, test := range testCases {
|
|
test := test
|
|
t.Run(test.desc, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
actual := test.values.Get()
|
|
assert.Equal(t, test.expected, actual)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestFieldsHeadersNamesString(t *testing.T) {
|
|
testCases := []struct {
|
|
desc string
|
|
values FieldHeaderNames
|
|
expected string
|
|
}{
|
|
{
|
|
desc: "Should return 1 value",
|
|
values: FieldHeaderNames{"X-HEADER-1": "foo"},
|
|
expected: "map[X-HEADER-1:foo]",
|
|
},
|
|
}
|
|
|
|
for _, test := range testCases {
|
|
test := test
|
|
t.Run(test.desc, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
actual := test.values.String()
|
|
assert.Equal(t, test.expected, actual)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestFieldsHeadersNamesSetValue(t *testing.T) {
|
|
testCases := []struct {
|
|
desc string
|
|
values FieldHeaderNames
|
|
expected *FieldHeaderNames
|
|
}{
|
|
{
|
|
desc: "Should return 1 value",
|
|
values: FieldHeaderNames{"X-HEADER-1": "foo"},
|
|
expected: &FieldHeaderNames{"X-HEADER-1": "foo"},
|
|
},
|
|
{
|
|
desc: "Should return 2 values",
|
|
values: FieldHeaderNames{"X-HEADER-1": "foo", "X-HEADER-2": "bar"},
|
|
expected: &FieldHeaderNames{"X-HEADER-1": "foo", "X-HEADER-2": "bar"},
|
|
},
|
|
{
|
|
desc: "Should return 3 values",
|
|
values: FieldHeaderNames{"X-HEADER-1": "foo", "X-HEADER-2": "bar", "X-HEADER-3": "powpow"},
|
|
expected: &FieldHeaderNames{"X-HEADER-1": "foo", "X-HEADER-2": "bar", "X-HEADER-3": "powpow"},
|
|
},
|
|
}
|
|
|
|
for _, test := range testCases {
|
|
test := test
|
|
t.Run(test.desc, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
headersNames := &FieldHeaderNames{}
|
|
headersNames.SetValue(test.values)
|
|
assert.Equal(t, test.expected, headersNames)
|
|
})
|
|
}
|
|
}
|