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: TraefikWeight, defaultValue: DefaultWeight, expected: "0", }, { labels: map[string]string{ TraefikWeight: "10", }, labelName: TraefikWeight, defaultValue: DefaultWeight, expected: "10", }, } 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) }) } }