693 lines
14 KiB
Go
693 lines
14 KiB
Go
package label
|
|
|
|
import (
|
|
"strconv"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func TestSplitAndTrimString(t *testing.T) {
|
|
testCases := []struct {
|
|
desc string
|
|
input string
|
|
expected []string
|
|
}{
|
|
{
|
|
desc: "empty string",
|
|
input: "",
|
|
expected: nil,
|
|
}, {
|
|
desc: "one piece",
|
|
input: "foo",
|
|
expected: []string{"foo"},
|
|
}, {
|
|
desc: "two pieces",
|
|
input: "foo,bar",
|
|
expected: []string{"foo", "bar"},
|
|
}, {
|
|
desc: "three pieces",
|
|
input: "foo,bar,zoo",
|
|
expected: []string{"foo", "bar", "zoo"},
|
|
}, {
|
|
desc: "two pieces with whitespace",
|
|
input: " foo , bar ",
|
|
expected: []string{"foo", "bar"},
|
|
}, {
|
|
desc: "consecutive commas",
|
|
input: " foo ,, bar ",
|
|
expected: []string{"foo", "bar"},
|
|
}, {
|
|
desc: "consecutive commas with whitespace",
|
|
input: " foo , , bar ",
|
|
expected: []string{"foo", "bar"},
|
|
}, {
|
|
desc: "leading and trailing commas",
|
|
input: ",, foo , , bar,, , ",
|
|
expected: []string{"foo", "bar"},
|
|
}, {
|
|
desc: "no valid pieces",
|
|
input: ", , , ,, ,",
|
|
expected: nil,
|
|
},
|
|
}
|
|
|
|
for _, test := range testCases {
|
|
test := test
|
|
t.Run(test.desc, func(t *testing.T) {
|
|
t.Parallel()
|
|
actual := SplitAndTrimString(test.input, ",")
|
|
assert.Equal(t, test.expected, actual)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGetStringValue(t *testing.T) {
|
|
testCases := []struct {
|
|
desc string
|
|
labels map[string]string
|
|
labelName string
|
|
defaultValue string
|
|
expected string
|
|
}{
|
|
{
|
|
desc: "empty labels map",
|
|
labelName: "foo",
|
|
defaultValue: "default",
|
|
expected: "default",
|
|
},
|
|
{
|
|
desc: "existing label",
|
|
labels: map[string]string{
|
|
"foo": "bar",
|
|
},
|
|
labelName: "foo",
|
|
defaultValue: "default",
|
|
expected: "bar",
|
|
},
|
|
{
|
|
desc: "non existing label",
|
|
labels: map[string]string{
|
|
"foo": "bar",
|
|
},
|
|
labelName: "fii",
|
|
defaultValue: "default",
|
|
expected: "default",
|
|
},
|
|
}
|
|
for _, test := range testCases {
|
|
test := test
|
|
t.Run(test.desc, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got := GetStringValue(test.labels, test.labelName, test.defaultValue)
|
|
assert.Equal(t, test.expected, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGetBoolValue(t *testing.T) {
|
|
testCases := []struct {
|
|
desc string
|
|
labels map[string]string
|
|
labelName string
|
|
defaultValue bool
|
|
expected bool
|
|
}{
|
|
{
|
|
desc: "empty map",
|
|
labelName: "foo",
|
|
},
|
|
{
|
|
desc: "invalid boolean value",
|
|
labels: map[string]string{
|
|
"foo": "bar",
|
|
},
|
|
labelName: "foo",
|
|
defaultValue: true,
|
|
expected: true,
|
|
},
|
|
{
|
|
desc: "valid boolean value: true",
|
|
labels: map[string]string{
|
|
"foo": "true",
|
|
},
|
|
labelName: "foo",
|
|
defaultValue: false,
|
|
expected: true,
|
|
},
|
|
{
|
|
desc: "valid boolean value: false",
|
|
labels: map[string]string{
|
|
"foo": "false",
|
|
},
|
|
labelName: "foo",
|
|
defaultValue: true,
|
|
expected: false,
|
|
},
|
|
}
|
|
for _, test := range testCases {
|
|
test := test
|
|
t.Run(test.desc, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got := GetBoolValue(test.labels, test.labelName, test.defaultValue)
|
|
assert.Equal(t, test.expected, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGetIntValue(t *testing.T) {
|
|
testCases := []struct {
|
|
desc string
|
|
labels map[string]string
|
|
labelName string
|
|
defaultValue int
|
|
expected int
|
|
}{
|
|
{
|
|
desc: "empty map",
|
|
labelName: "foo",
|
|
},
|
|
{
|
|
desc: "invalid int value",
|
|
labelName: "foo",
|
|
labels: map[string]string{
|
|
"foo": "bar",
|
|
},
|
|
defaultValue: 666,
|
|
expected: 666,
|
|
},
|
|
{
|
|
desc: "negative int value",
|
|
labelName: "foo",
|
|
labels: map[string]string{
|
|
"foo": "-1",
|
|
},
|
|
defaultValue: 666,
|
|
expected: -1,
|
|
},
|
|
{
|
|
desc: "positive int value",
|
|
labelName: "foo",
|
|
labels: map[string]string{
|
|
"foo": "1",
|
|
},
|
|
defaultValue: 666,
|
|
expected: 1,
|
|
},
|
|
}
|
|
for _, test := range testCases {
|
|
test := test
|
|
t.Run(test.desc, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got := GetIntValue(test.labels, test.labelName, test.defaultValue)
|
|
assert.Equal(t, test.expected, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGetInt64Value(t *testing.T) {
|
|
testCases := []struct {
|
|
desc string
|
|
labels map[string]string
|
|
labelName string
|
|
defaultValue int64
|
|
expected int64
|
|
}{
|
|
{
|
|
desc: "empty map",
|
|
labelName: "foo",
|
|
},
|
|
{
|
|
desc: "invalid int value",
|
|
labelName: "foo",
|
|
labels: map[string]string{
|
|
"foo": "bar",
|
|
},
|
|
defaultValue: 666,
|
|
expected: 666,
|
|
},
|
|
{
|
|
desc: "negative int value",
|
|
labelName: "foo",
|
|
labels: map[string]string{
|
|
"foo": "-1",
|
|
},
|
|
defaultValue: 666,
|
|
expected: -1,
|
|
},
|
|
{
|
|
desc: "positive int value",
|
|
labelName: "foo",
|
|
labels: map[string]string{
|
|
"foo": "1",
|
|
},
|
|
defaultValue: 666,
|
|
expected: 1,
|
|
},
|
|
}
|
|
for _, test := range testCases {
|
|
test := test
|
|
t.Run(test.desc, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got := GetInt64Value(test.labels, test.labelName, test.defaultValue)
|
|
assert.Equal(t, test.expected, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGetSliceStringValue(t *testing.T) {
|
|
testCases := []struct {
|
|
desc string
|
|
labels map[string]string
|
|
labelName string
|
|
expected []string
|
|
}{
|
|
{
|
|
desc: "empty map",
|
|
labelName: "foo",
|
|
},
|
|
{
|
|
desc: "empty value",
|
|
labels: map[string]string{
|
|
"foo": "",
|
|
},
|
|
labelName: "foo",
|
|
expected: nil,
|
|
},
|
|
{
|
|
desc: "one value, not split",
|
|
labels: map[string]string{
|
|
"foo": "bar",
|
|
},
|
|
labelName: "foo",
|
|
expected: []string{"bar"},
|
|
},
|
|
{
|
|
desc: "several values",
|
|
labels: map[string]string{
|
|
"foo": "bar,bir ,bur",
|
|
},
|
|
labelName: "foo",
|
|
expected: []string{"bar", "bir", "bur"},
|
|
},
|
|
}
|
|
for _, test := range testCases {
|
|
test := test
|
|
t.Run(test.desc, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got := GetSliceStringValue(test.labels, test.labelName)
|
|
assert.EqualValues(t, test.expected, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGetMapValue(t *testing.T) {
|
|
testCases := []struct {
|
|
desc string
|
|
labels map[string]string
|
|
labelName string
|
|
expected map[string]string
|
|
}{
|
|
{
|
|
desc: "empty map",
|
|
labelName: "foo",
|
|
},
|
|
{
|
|
desc: "existent label with empty entry",
|
|
labelName: "foo",
|
|
labels: map[string]string{
|
|
"foo": "",
|
|
},
|
|
expected: nil,
|
|
},
|
|
{
|
|
desc: "existent label with invalid entry",
|
|
labelName: "foo",
|
|
labels: map[string]string{
|
|
"foo": "bar",
|
|
},
|
|
expected: nil,
|
|
},
|
|
{
|
|
desc: "existent label with empty value",
|
|
labelName: "foo",
|
|
labels: map[string]string{
|
|
"foo": "bar:",
|
|
},
|
|
expected: map[string]string{
|
|
"Bar": "",
|
|
},
|
|
},
|
|
{
|
|
desc: "one entry",
|
|
labelName: "foo",
|
|
labels: map[string]string{
|
|
"foo": " Access-Control-Allow-Methods:POST,GET,OPTIONS ",
|
|
},
|
|
expected: map[string]string{
|
|
"Access-Control-Allow-Methods": "POST,GET,OPTIONS",
|
|
},
|
|
},
|
|
{
|
|
desc: "several entry",
|
|
labelName: "foo",
|
|
labels: map[string]string{
|
|
"foo": "Access-Control-Allow-Methods:POST,GET,OPTIONS || Content-type: application/json; charset=utf-8",
|
|
},
|
|
expected: map[string]string{
|
|
"Access-Control-Allow-Methods": "POST,GET,OPTIONS",
|
|
"Content-Type": "application/json; charset=utf-8",
|
|
},
|
|
},
|
|
}
|
|
for _, test := range testCases {
|
|
test := test
|
|
t.Run(test.desc, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got := GetMapValue(test.labels, test.labelName)
|
|
assert.EqualValues(t, test.expected, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGetStringMultipleStrict(t *testing.T) {
|
|
testCases := []struct {
|
|
desc string
|
|
labels map[string]string
|
|
labelNames []string
|
|
expected map[string]string
|
|
expectedErr bool
|
|
}{
|
|
{
|
|
desc: "empty labels names and empty labels map",
|
|
labels: map[string]string{},
|
|
expected: map[string]string{},
|
|
},
|
|
{
|
|
desc: "empty labels names",
|
|
labels: map[string]string{
|
|
"foo": "bar",
|
|
"fii": "bir",
|
|
},
|
|
expected: map[string]string{},
|
|
},
|
|
{
|
|
desc: "one label missing",
|
|
labels: map[string]string{
|
|
"foo": "bar",
|
|
"fii": "bir",
|
|
"fyy": "byr",
|
|
},
|
|
labelNames: []string{"foo", "fii", "fuu"},
|
|
expected: nil,
|
|
expectedErr: true,
|
|
},
|
|
{
|
|
desc: "all labels are present",
|
|
labels: map[string]string{
|
|
"foo": "bar",
|
|
"fii": "bir",
|
|
"fyy": "byr",
|
|
},
|
|
labelNames: []string{"foo", "fii"},
|
|
expected: map[string]string{
|
|
"foo": "bar",
|
|
"fii": "bir",
|
|
},
|
|
},
|
|
}
|
|
for _, test := range testCases {
|
|
test := test
|
|
t.Run(test.desc, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got, err := GetStringMultipleStrict(test.labels, test.labelNames...)
|
|
if (err != nil) != test.expectedErr {
|
|
t.Errorf("error = %v, wantErr %v", err, test.expectedErr)
|
|
return
|
|
}
|
|
assert.EqualValues(t, test.expected, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestHas(t *testing.T) {
|
|
testCases := []struct {
|
|
desc string
|
|
labels map[string]string
|
|
labelName string
|
|
expected bool
|
|
}{
|
|
{
|
|
desc: "nil labels map",
|
|
labelName: "foo",
|
|
},
|
|
{
|
|
desc: "nonexistent label",
|
|
labels: map[string]string{
|
|
"foo": "bar",
|
|
},
|
|
labelName: "fii",
|
|
expected: false,
|
|
},
|
|
{
|
|
desc: "existent label",
|
|
labels: map[string]string{
|
|
"foo": "bar",
|
|
},
|
|
labelName: "foo",
|
|
expected: true,
|
|
},
|
|
{
|
|
desc: "existent label with empty value",
|
|
labels: map[string]string{
|
|
"foo": "",
|
|
},
|
|
labelName: "foo",
|
|
expected: false,
|
|
},
|
|
}
|
|
for _, test := range testCases {
|
|
test := test
|
|
t.Run(test.desc, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got := Has(test.labels, test.labelName)
|
|
assert.Equal(t, test.expected, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestIsEnabled(t *testing.T) {
|
|
testCases := []struct {
|
|
desc string
|
|
labels map[string]string
|
|
exposedByDefault bool
|
|
expected bool
|
|
}{
|
|
{
|
|
desc: "empty labels map & exposedByDefault true",
|
|
exposedByDefault: true,
|
|
expected: true,
|
|
},
|
|
{
|
|
desc: "empty labels map & exposedByDefault false",
|
|
exposedByDefault: false,
|
|
expected: false,
|
|
},
|
|
{
|
|
desc: "exposedByDefault false and label enable true",
|
|
labels: map[string]string{
|
|
TraefikEnable: "true",
|
|
},
|
|
exposedByDefault: false,
|
|
expected: true,
|
|
},
|
|
{
|
|
desc: "exposedByDefault false and label enable false",
|
|
labels: map[string]string{
|
|
TraefikEnable: "false",
|
|
},
|
|
exposedByDefault: false,
|
|
expected: false,
|
|
},
|
|
{
|
|
desc: "exposedByDefault true and label enable false",
|
|
labels: map[string]string{
|
|
TraefikEnable: "false",
|
|
},
|
|
exposedByDefault: true,
|
|
expected: false,
|
|
},
|
|
{
|
|
desc: "exposedByDefault true and label enable true",
|
|
labels: map[string]string{
|
|
TraefikEnable: "true",
|
|
},
|
|
exposedByDefault: true,
|
|
expected: true,
|
|
},
|
|
}
|
|
for _, test := range testCases {
|
|
test := test
|
|
t.Run(test.desc, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got := IsEnabled(test.labels, test.exposedByDefault)
|
|
assert.Equal(t, test.expected, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestHasPrefix(t *testing.T) {
|
|
testCases := []struct {
|
|
desc string
|
|
labels map[string]string
|
|
prefix string
|
|
expected bool
|
|
}{
|
|
{
|
|
desc: "nil labels map",
|
|
prefix: "foo",
|
|
expected: false,
|
|
},
|
|
{
|
|
desc: "nonexistent prefix",
|
|
labels: map[string]string{
|
|
"foo.carotte": "bar",
|
|
},
|
|
prefix: "fii",
|
|
expected: false,
|
|
},
|
|
{
|
|
desc: "existent prefix",
|
|
labels: map[string]string{
|
|
"foo.carotte": "bar",
|
|
},
|
|
prefix: "foo",
|
|
expected: true,
|
|
},
|
|
{
|
|
desc: "existent prefix with empty value",
|
|
labels: map[string]string{
|
|
"foo.carotte": "",
|
|
},
|
|
prefix: "foo",
|
|
expected: false,
|
|
},
|
|
}
|
|
for _, test := range testCases {
|
|
test := test
|
|
t.Run(test.desc, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
got := HasPrefix(test.labels, test.prefix)
|
|
assert.Equal(t, test.expected, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGetFuncString(t *testing.T) {
|
|
testCases := []struct {
|
|
labels map[string]string
|
|
labelName string
|
|
defaultValue string
|
|
expected string
|
|
}{
|
|
{
|
|
labels: nil,
|
|
labelName: TraefikProtocol,
|
|
defaultValue: DefaultProtocol,
|
|
expected: "http",
|
|
},
|
|
{
|
|
labels: map[string]string{
|
|
TraefikProtocol: "https",
|
|
},
|
|
labelName: TraefikProtocol,
|
|
defaultValue: DefaultProtocol,
|
|
expected: "https",
|
|
},
|
|
}
|
|
|
|
for containerID, test := range testCases {
|
|
test := test
|
|
t.Run(test.labelName+strconv.Itoa(containerID), func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
actual := GetFuncString(test.labelName, test.defaultValue)(test.labels)
|
|
assert.Equal(t, test.expected, actual)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestGetSliceString(t *testing.T) {
|
|
testCases := []struct {
|
|
desc string
|
|
labels map[string]string
|
|
labelName string
|
|
expected []string
|
|
}{
|
|
{
|
|
desc: "no whitelist-label",
|
|
labels: nil,
|
|
expected: nil,
|
|
},
|
|
{
|
|
desc: "whitelist-label with empty string",
|
|
labels: map[string]string{
|
|
TraefikFrontendWhiteListSourceRange: "",
|
|
},
|
|
labelName: TraefikFrontendWhiteListSourceRange,
|
|
expected: nil,
|
|
},
|
|
{
|
|
desc: "whitelist-label with IPv4 mask",
|
|
labels: map[string]string{
|
|
TraefikFrontendWhiteListSourceRange: "1.2.3.4/16",
|
|
},
|
|
labelName: TraefikFrontendWhiteListSourceRange,
|
|
expected: []string{
|
|
"1.2.3.4/16",
|
|
},
|
|
},
|
|
{
|
|
desc: "whitelist-label with IPv6 mask",
|
|
labels: map[string]string{
|
|
TraefikFrontendWhiteListSourceRange: "fe80::/16",
|
|
},
|
|
labelName: TraefikFrontendWhiteListSourceRange,
|
|
expected: []string{
|
|
"fe80::/16",
|
|
},
|
|
},
|
|
{
|
|
desc: "whitelist-label with multiple masks",
|
|
labels: map[string]string{
|
|
TraefikFrontendWhiteListSourceRange: "1.1.1.1/24, 1234:abcd::42/32",
|
|
},
|
|
labelName: TraefikFrontendWhiteListSourceRange,
|
|
expected: []string{
|
|
"1.1.1.1/24",
|
|
"1234:abcd::42/32",
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, test := range testCases {
|
|
test := test
|
|
t.Run(test.desc, func(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
actual := GetFuncSliceString(test.labelName)(test.labels)
|
|
assert.EqualValues(t, test.expected, actual)
|
|
})
|
|
}
|
|
}
|