Segment labels: Docker

provider/docker/config_container_docker_test.go

@@ -1,7 +1,6 @@
 package docker
 
 import (
-	"reflect"
 	"strconv"
 	"testing"
 	"time"
@@ -319,7 +318,7 @@ func TestDockerBuildConfiguration(t *testing.T) {
 				Domain:           "docker.localhost",
 				ExposedByDefault: true,
 			}
-			actualConfig := provider.buildConfiguration(dockerDataList)
+			actualConfig := provider.buildConfigurationV2(dockerDataList)
 			require.NotNil(t, actualConfig, "actualConfig")
 
 			assert.EqualValues(t, test.expectedBackends, actualConfig.Backends)
@@ -631,7 +630,11 @@ func TestDockerTraefikFilter(t *testing.T) {
 		test := test
 		t.Run(strconv.Itoa(containerID), func(t *testing.T) {
 			t.Parallel()
+
 			dData := parseContainer(test.container)
+			segmentProperties := label.ExtractTraefikLabels(dData.Labels)
+			dData.SegmentLabels = segmentProperties[""]
+
 			actual := test.provider.containerFilter(dData)
 			if actual != test.expected {
 				t.Errorf("expected %v for %+v, got %+v", test.expected, test, actual)
@@ -642,21 +645,21 @@ func TestDockerTraefikFilter(t *testing.T) {
 
 func TestDockerGetFuncStringLabel(t *testing.T) {
 	testCases := []struct {
-		container    docker.ContainerJSON
+		labels       map[string]string
 		labelName    string
 		defaultValue string
 		expected     string
 	}{
 		{
-			container:    containerJSON(),
+			labels:       nil,
 			labelName:    label.TraefikWeight,
 			defaultValue: label.DefaultWeight,
 			expected:     "0",
 		},
 		{
-			container: containerJSON(labels(map[string]string{
+			labels: map[string]string{
 				label.TraefikWeight: "10",
-			})),
+			},
 			labelName:    label.TraefikWeight,
 			defaultValue: label.DefaultWeight,
 			expected:     "10",
@@ -668,13 +671,8 @@ func TestDockerGetFuncStringLabel(t *testing.T) {
 		t.Run(test.labelName+strconv.Itoa(containerID), func(t *testing.T) {
 			t.Parallel()
 
-			dData := parseContainer(test.container)
-
-			actual := getFuncStringLabel(test.labelName, test.defaultValue)(dData)
-
-			if actual != test.expected {
-				t.Errorf("got %q, expected %q", actual, test.expected)
-			}
+			actual := getFuncStringLabel(test.labelName, test.defaultValue)(test.labels)
+			assert.Equal(t, test.expected, actual)
 		})
 	}
 }
@@ -682,28 +680,28 @@ func TestDockerGetFuncStringLabel(t *testing.T) {
 func TestDockerGetSliceStringLabel(t *testing.T) {
 	testCases := []struct {
 		desc      string
-		container docker.ContainerJSON
+		labels    map[string]string
 		labelName string
 		expected  []string
 	}{
 		{
-			desc:      "no whitelist-label",
-			container: containerJSON(),
-			expected:  nil,
+			desc:     "no whitelist-label",
+			labels:   nil,
+			expected: nil,
 		},
 		{
 			desc: "whitelist-label with empty string",
-			container: containerJSON(labels(map[string]string{
+			labels: map[string]string{
 				label.TraefikFrontendWhitelistSourceRange: "",
-			})),
+			},
 			labelName: label.TraefikFrontendWhitelistSourceRange,
 			expected:  nil,
 		},
 		{
 			desc: "whitelist-label with IPv4 mask",
-			container: containerJSON(labels(map[string]string{
+			labels: map[string]string{
 				label.TraefikFrontendWhitelistSourceRange: "1.2.3.4/16",
-			})),
+			},
 			labelName: label.TraefikFrontendWhitelistSourceRange,
 			expected: []string{
 				"1.2.3.4/16",
@@ -711,9 +709,9 @@ func TestDockerGetSliceStringLabel(t *testing.T) {
 		},
 		{
 			desc: "whitelist-label with IPv6 mask",
-			container: containerJSON(labels(map[string]string{
+			labels: map[string]string{
 				label.TraefikFrontendWhitelistSourceRange: "fe80::/16",
-			})),
+			},
 			labelName: label.TraefikFrontendWhitelistSourceRange,
 			expected: []string{
 				"fe80::/16",
@@ -721,9 +719,9 @@ func TestDockerGetSliceStringLabel(t *testing.T) {
 		},
 		{
 			desc: "whitelist-label with multiple masks",
-			container: containerJSON(labels(map[string]string{
+			labels: map[string]string{
 				label.TraefikFrontendWhitelistSourceRange: "1.1.1.1/24, 1234:abcd::42/32",
-			})),
+			},
 			labelName: label.TraefikFrontendWhitelistSourceRange,
 			expected: []string{
 				"1.1.1.1/24",
@@ -736,13 +734,9 @@ func TestDockerGetSliceStringLabel(t *testing.T) {
 		test := test
 		t.Run(test.desc, func(t *testing.T) {
 			t.Parallel()
-			dData := parseContainer(test.container)
 
-			actual := getFuncSliceStringLabel(test.labelName)(dData)
-
-			if !reflect.DeepEqual(actual, test.expected) {
-				t.Errorf("expected %q, got %q", test.expected, actual)
-			}
+			actual := getFuncSliceStringLabel(test.labelName)(test.labels)
+			assert.EqualValues(t, test.expected, actual)
 		})
 	}
 }
@@ -793,14 +787,17 @@ func TestDockerGetFrontendName(t *testing.T) {
 		test := test
 		t.Run(strconv.Itoa(containerID), func(t *testing.T) {
 			t.Parallel()
+
 			dData := parseContainer(test.container)
+			segmentProperties := label.ExtractTraefikLabels(dData.Labels)
+			dData.SegmentLabels = segmentProperties[""]
+
 			provider := &Provider{
 				Domain: "docker.localhost",
 			}
+
 			actual := provider.getFrontendName(dData, 0)
-			if actual != test.expected {
-				t.Errorf("expected %q, got %q", test.expected, actual)
-			}
+			assert.Equal(t, test.expected, actual)
 		})
 	}
 }
@@ -842,14 +839,16 @@ func TestDockerGetFrontendRule(t *testing.T) {
 		test := test
 		t.Run(strconv.Itoa(containerID), func(t *testing.T) {
 			t.Parallel()
+
 			dData := parseContainer(test.container)
+			segmentProperties := label.ExtractTraefikLabels(dData.Labels)
+			dData.SegmentLabels = segmentProperties[""]
+
 			provider := &Provider{
 				Domain: "docker.localhost",
 			}
 			actual := provider.getFrontendRule(dData)
-			if actual != test.expected {
-				t.Errorf("expected %q, got %q", test.expected, actual)
-			}
+			assert.Equal(t, test.expected, actual)
 		})
 	}
 }
@@ -886,11 +885,13 @@ func TestDockerGetBackendName(t *testing.T) {
 		test := test
 		t.Run(strconv.Itoa(containerID), func(t *testing.T) {
 			t.Parallel()
+
 			dData := parseContainer(test.container)
+			segmentProperties := label.ExtractTraefikLabels(dData.Labels)
+			dData.SegmentLabels = segmentProperties[""]
+
 			actual := getBackendName(dData)
-			if actual != test.expected {
-				t.Errorf("expected %q, got %q", test.expected, actual)
-			}
+			assert.Equal(t, test.expected, actual)
 		})
 	}
 }
@@ -950,12 +951,15 @@ func TestDockerGetIPAddress(t *testing.T) {
 		test := test
 		t.Run(strconv.Itoa(containerID), func(t *testing.T) {
 			t.Parallel()
+
 			dData := parseContainer(test.container)
+			segmentProperties := label.ExtractTraefikLabels(dData.Labels)
+			dData.SegmentLabels = segmentProperties[""]
+
 			provider := &Provider{}
+
 			actual := provider.getIPAddress(dData)
-			if actual != test.expected {
-				t.Errorf("expected %q, got %q", test.expected, actual)
-			}
+			assert.Equal(t, test.expected, actual)
 		})
 	}
 }
@@ -1007,599 +1011,16 @@ func TestDockerGetPort(t *testing.T) {
 		},
 	}
 
-	for containerID, e := range testCases {
-		e := e
+	for containerID, test := range testCases {
+		test := test
 		t.Run(strconv.Itoa(containerID), func(t *testing.T) {
 			t.Parallel()
-			dData := parseContainer(e.container)
+
+			dData := parseContainer(test.container)
+			segmentProperties := label.ExtractTraefikLabels(dData.Labels)
+			dData.SegmentLabels = segmentProperties[""]
+
 			actual := getPort(dData)
-			if actual != e.expected {
-				t.Errorf("expected %q, got %q", e.expected, actual)
-			}
-		})
-	}
-}
-
-func TestDockerGetMaxConn(t *testing.T) {
-	testCases := []struct {
-		desc      string
-		container docker.ContainerJSON
-		expected  *types.MaxConn
-	}{
-		{
-			desc: "should return nil when no max conn labels",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{})),
-			expected: nil,
-		},
-		{
-			desc: "should return nil when no amount label",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{
-					label.TraefikBackendMaxConnExtractorFunc: "client.ip",
-				})),
-			expected: nil,
-		},
-		{
-			desc: "should return default when no empty extractorFunc label",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{
-					label.TraefikBackendMaxConnExtractorFunc: "",
-					label.TraefikBackendMaxConnAmount:        "666",
-				})),
-			expected: &types.MaxConn{
-				ExtractorFunc: "request.host",
-				Amount:        666,
-			},
-		},
-		{
-			desc: "should return a struct when max conn labels are set",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{
-					label.TraefikBackendMaxConnExtractorFunc: "client.ip",
-					label.TraefikBackendMaxConnAmount:        "666",
-				})),
-			expected: &types.MaxConn{
-				ExtractorFunc: "client.ip",
-				Amount:        666,
-			},
-		},
-	}
-
-	for _, test := range testCases {
-		test := test
-		t.Run(test.desc, func(t *testing.T) {
-			t.Parallel()
-
-			dData := parseContainer(test.container)
-
-			actual := getMaxConn(dData)
-
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-}
-
-func TestDockerGetCircuitBreaker(t *testing.T) {
-	testCases := []struct {
-		desc      string
-		container docker.ContainerJSON
-		expected  *types.CircuitBreaker
-	}{
-		{
-			desc: "should return nil when no CB labels",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{})),
-			expected: nil,
-		},
-		{
-			desc: "should return a struct CB when CB labels are set",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{
-					label.TraefikBackendCircuitBreakerExpression: "NetworkErrorRatio() > 0.5",
-				})),
-			expected: &types.CircuitBreaker{
-				Expression: "NetworkErrorRatio() > 0.5",
-			},
-		},
-	}
-
-	for _, test := range testCases {
-		test := test
-		t.Run(test.desc, func(t *testing.T) {
-			t.Parallel()
-
-			dData := parseContainer(test.container)
-
-			actual := getCircuitBreaker(dData)
-
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-}
-
-func TestDockerGetLoadBalancer(t *testing.T) {
-	testCases := []struct {
-		desc      string
-		container docker.ContainerJSON
-		expected  *types.LoadBalancer
-	}{
-		{
-			desc: "should return nil when no LB labels",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{})),
-			expected: nil,
-		},
-		{
-			desc: "should return a struct when labels are set",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{
-					label.TraefikBackendLoadBalancerMethod:               "drr",
-					label.TraefikBackendLoadBalancerSticky:               "true",
-					label.TraefikBackendLoadBalancerStickiness:           "true",
-					label.TraefikBackendLoadBalancerStickinessCookieName: "foo",
-				})),
-			expected: &types.LoadBalancer{
-				Method: "drr",
-				Sticky: true,
-				Stickiness: &types.Stickiness{
-					CookieName: "foo",
-				},
-			},
-		},
-		{
-			desc: "should return a nil Stickiness when Stickiness is not set",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{
-					label.TraefikBackendLoadBalancerMethod:               "drr",
-					label.TraefikBackendLoadBalancerSticky:               "true",
-					label.TraefikBackendLoadBalancerStickinessCookieName: "foo",
-				})),
-			expected: &types.LoadBalancer{
-				Method:     "drr",
-				Sticky:     true,
-				Stickiness: nil,
-			},
-		},
-	}
-
-	for _, test := range testCases {
-		test := test
-		t.Run(test.desc, func(t *testing.T) {
-			t.Parallel()
-
-			dData := parseContainer(test.container)
-
-			actual := getLoadBalancer(dData)
-
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-}
-
-func TestDockerGetRedirect(t *testing.T) {
-	testCases := []struct {
-		desc      string
-		container docker.ContainerJSON
-		expected  *types.Redirect
-	}{
-		{
-			desc: "should return nil when no redirect labels",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{})),
-			expected: nil,
-		},
-		{
-			desc: "should use only entry point tag when mix regex redirect and entry point redirect",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{
-					label.TraefikFrontendRedirectEntryPoint:  "https",
-					label.TraefikFrontendRedirectRegex:       "(.*)",
-					label.TraefikFrontendRedirectReplacement: "$1",
-				}),
-			),
-			expected: &types.Redirect{
-				EntryPoint: "https",
-			},
-		},
-		{
-			desc: "should return a struct when entry point redirect label",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{
-					label.TraefikFrontendRedirectEntryPoint: "https",
-				}),
-			),
-			expected: &types.Redirect{
-				EntryPoint: "https",
-			},
-		},
-		{
-			desc: "should return a struct when entry point redirect label (permanent)",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{
-					label.TraefikFrontendRedirectEntryPoint: "https",
-					label.TraefikFrontendRedirectPermanent:  "true",
-				}),
-			),
-			expected: &types.Redirect{
-				EntryPoint: "https",
-				Permanent:  true,
-			},
-		},
-		{
-			desc: "should return a struct when regex redirect labels",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{
-					label.TraefikFrontendRedirectRegex:       "(.*)",
-					label.TraefikFrontendRedirectReplacement: "$1",
-				}),
-			),
-			expected: &types.Redirect{
-				Regex:       "(.*)",
-				Replacement: "$1",
-			},
-		},
-		{
-			desc: "should return a struct when regex redirect tags (permanent)",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{
-					label.TraefikFrontendRedirectRegex:       "(.*)",
-					label.TraefikFrontendRedirectReplacement: "$1",
-					label.TraefikFrontendRedirectPermanent:   "true",
-				}),
-			),
-			expected: &types.Redirect{
-				Regex:       "(.*)",
-				Replacement: "$1",
-				Permanent:   true,
-			},
-		},
-	}
-
-	for _, test := range testCases {
-		test := test
-		t.Run(test.desc, func(t *testing.T) {
-			t.Parallel()
-
-			dData := parseContainer(test.container)
-
-			actual := getRedirect(dData)
-
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-}
-
-func TestDockerGetRateLimit(t *testing.T) {
-	testCases := []struct {
-		desc      string
-		container docker.ContainerJSON
-		expected  *types.RateLimit
-	}{
-		{
-			desc: "should return nil when no rate limit labels",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{})),
-			expected: nil,
-		},
-		{
-			desc: "should return a struct when rate limit labels are defined",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{
-					label.TraefikFrontendRateLimitExtractorFunc:                                        "client.ip",
-					label.Prefix + label.BaseFrontendRateLimit + "foo." + label.SuffixRateLimitPeriod:  "6",
-					label.Prefix + label.BaseFrontendRateLimit + "foo." + label.SuffixRateLimitAverage: "12",
-					label.Prefix + label.BaseFrontendRateLimit + "foo." + label.SuffixRateLimitBurst:   "18",
-					label.Prefix + label.BaseFrontendRateLimit + "bar." + label.SuffixRateLimitPeriod:  "3",
-					label.Prefix + label.BaseFrontendRateLimit + "bar." + label.SuffixRateLimitAverage: "6",
-					label.Prefix + label.BaseFrontendRateLimit + "bar." + label.SuffixRateLimitBurst:   "9",
-				})),
-			expected: &types.RateLimit{
-				ExtractorFunc: "client.ip",
-				RateSet: map[string]*types.Rate{
-					"foo": {
-						Period:  flaeg.Duration(6 * time.Second),
-						Average: 12,
-						Burst:   18,
-					},
-					"bar": {
-						Period:  flaeg.Duration(3 * time.Second),
-						Average: 6,
-						Burst:   9,
-					},
-				},
-			},
-		},
-		{
-			desc: "should return nil when ExtractorFunc is missing",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{
-					label.Prefix + label.BaseFrontendRateLimit + "foo." + label.SuffixRateLimitPeriod:  "6",
-					label.Prefix + label.BaseFrontendRateLimit + "foo." + label.SuffixRateLimitAverage: "12",
-					label.Prefix + label.BaseFrontendRateLimit + "foo." + label.SuffixRateLimitBurst:   "18",
-					label.Prefix + label.BaseFrontendRateLimit + "bar." + label.SuffixRateLimitPeriod:  "3",
-					label.Prefix + label.BaseFrontendRateLimit + "bar." + label.SuffixRateLimitAverage: "6",
-					label.Prefix + label.BaseFrontendRateLimit + "bar." + label.SuffixRateLimitBurst:   "9",
-				})),
-			expected: nil,
-		},
-	}
-
-	for _, test := range testCases {
-		test := test
-		t.Run(test.desc, func(t *testing.T) {
-			t.Parallel()
-
-			dData := parseContainer(test.container)
-
-			actual := getRateLimit(dData)
-
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-}
-
-func TestGetErrorPages(t *testing.T) {
-	testCases := []struct {
-		desc     string
-		data     dockerData
-		expected map[string]*types.ErrorPage
-	}{
-		{
-			desc: "2 errors pages",
-			data: parseContainer(containerJSON(
-				labels(map[string]string{
-					label.Prefix + label.BaseFrontendErrorPage + "foo." + label.SuffixErrorPageStatus:  "404",
-					label.Prefix + label.BaseFrontendErrorPage + "foo." + label.SuffixErrorPageBackend: "foo_backend",
-					label.Prefix + label.BaseFrontendErrorPage + "foo." + label.SuffixErrorPageQuery:   "foo_query",
-					label.Prefix + label.BaseFrontendErrorPage + "bar." + label.SuffixErrorPageStatus:  "500,600",
-					label.Prefix + label.BaseFrontendErrorPage + "bar." + label.SuffixErrorPageBackend: "bar_backend",
-					label.Prefix + label.BaseFrontendErrorPage + "bar." + label.SuffixErrorPageQuery:   "bar_query",
-				}))),
-			expected: map[string]*types.ErrorPage{
-				"foo": {
-					Status:  []string{"404"},
-					Query:   "foo_query",
-					Backend: "foo_backend",
-				},
-				"bar": {
-					Status:  []string{"500", "600"},
-					Query:   "bar_query",
-					Backend: "bar_backend",
-				},
-			},
-		},
-		{
-			desc: "only status field",
-			data: parseContainer(containerJSON(
-				labels(map[string]string{
-					label.Prefix + label.BaseFrontendErrorPage + "foo." + label.SuffixErrorPageStatus: "404",
-				}))),
-			expected: map[string]*types.ErrorPage{
-				"foo": {
-					Status: []string{"404"},
-				},
-			},
-		},
-	}
-
-	for _, test := range testCases {
-		test := test
-		t.Run(test.desc, func(t *testing.T) {
-			t.Parallel()
-
-			pages := getErrorPages(test.data)
-
-			assert.EqualValues(t, test.expected, pages)
-		})
-	}
-}
-
-func TestDockerGetHealthCheck(t *testing.T) {
-	testCases := []struct {
-		desc      string
-		container docker.ContainerJSON
-		expected  *types.HealthCheck
-	}{
-		{
-			desc: "should return nil when no health check labels",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{})),
-			expected: nil,
-		},
-		{
-			desc: "should return nil when no health check Path label",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{
-					label.TraefikBackendHealthCheckPort:     "80",
-					label.TraefikBackendHealthCheckInterval: "6",
-				})),
-			expected: nil,
-		},
-		{
-			desc: "should return a struct when health check labels are set",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{
-					label.TraefikBackendHealthCheckPath:     "/health",
-					label.TraefikBackendHealthCheckPort:     "80",
-					label.TraefikBackendHealthCheckInterval: "6",
-				})),
-			expected: &types.HealthCheck{
-				Path:     "/health",
-				Port:     80,
-				Interval: "6",
-			},
-		},
-	}
-
-	for _, test := range testCases {
-		test := test
-		t.Run(test.desc, func(t *testing.T) {
-			t.Parallel()
-
-			dData := parseContainer(test.container)
-
-			actual := getHealthCheck(dData)
-
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-}
-
-func TestDockerGetBuffering(t *testing.T) {
-	testCases := []struct {
-		desc      string
-		container docker.ContainerJSON
-		expected  *types.Buffering
-	}{
-		{
-			desc: "should return nil when no health check labels",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{})),
-			expected: nil,
-		},
-		{
-			desc: "should return a struct when buffering labels are set",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{
-					label.TraefikBackendBufferingMaxResponseBodyBytes: "10485760",
-					label.TraefikBackendBufferingMemResponseBodyBytes: "2097152",
-					label.TraefikBackendBufferingMaxRequestBodyBytes:  "10485760",
-					label.TraefikBackendBufferingMemRequestBodyBytes:  "2097152",
-					label.TraefikBackendBufferingRetryExpression:      "IsNetworkError() && Attempts() <= 2",
-				})),
-			expected: &types.Buffering{
-				MaxResponseBodyBytes: 10485760,
-				MemResponseBodyBytes: 2097152,
-				MaxRequestBodyBytes:  10485760,
-				MemRequestBodyBytes:  2097152,
-				RetryExpression:      "IsNetworkError() && Attempts() <= 2",
-			},
-		},
-	}
-
-	for _, test := range testCases {
-		test := test
-		t.Run(test.desc, func(t *testing.T) {
-			t.Parallel()
-
-			dData := parseContainer(test.container)
-
-			actual := getBuffering(dData)
-
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-}
-
-func TestDockerGetHeaders(t *testing.T) {
-	testCases := []struct {
-		desc      string
-		container docker.ContainerJSON
-		expected  *types.Headers
-	}{
-		{
-			desc: "should return nil when no custom headers options are set",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{})),
-			expected: nil,
-		},
-		{
-			desc: "should return a struct when all custom headers options are set",
-			container: containerJSON(
-				name("test1"),
-				labels(map[string]string{
-					label.TraefikFrontendRequestHeaders:          "Access-Control-Allow-Methods:POST,GET,OPTIONS || Content-type: application/json; charset=utf-8",
-					label.TraefikFrontendResponseHeaders:         "Access-Control-Allow-Methods:POST,GET,OPTIONS || Content-type: application/json; charset=utf-8",
-					label.TraefikFrontendSSLProxyHeaders:         "Access-Control-Allow-Methods:POST,GET,OPTIONS || Content-type: application/json; charset=utf-8",
-					label.TraefikFrontendAllowedHosts:            "foo,bar,bor",
-					label.TraefikFrontendHostsProxyHeaders:       "foo,bar,bor",
-					label.TraefikFrontendSSLHost:                 "foo",
-					label.TraefikFrontendCustomFrameOptionsValue: "foo",
-					label.TraefikFrontendContentSecurityPolicy:   "foo",
-					label.TraefikFrontendPublicKey:               "foo",
-					label.TraefikFrontendReferrerPolicy:          "foo",
-					label.TraefikFrontendCustomBrowserXSSValue:   "foo",
-					label.TraefikFrontendSTSSeconds:              "666",
-					label.TraefikFrontendSSLRedirect:             "true",
-					label.TraefikFrontendSSLTemporaryRedirect:    "true",
-					label.TraefikFrontendSTSIncludeSubdomains:    "true",
-					label.TraefikFrontendSTSPreload:              "true",
-					label.TraefikFrontendForceSTSHeader:          "true",
-					label.TraefikFrontendFrameDeny:               "true",
-					label.TraefikFrontendContentTypeNosniff:      "true",
-					label.TraefikFrontendBrowserXSSFilter:        "true",
-					label.TraefikFrontendIsDevelopment:           "true",
-				}),
-			),
-			expected: &types.Headers{
-				CustomRequestHeaders: map[string]string{
-					"Access-Control-Allow-Methods": "POST,GET,OPTIONS",
-					"Content-Type":                 "application/json; charset=utf-8",
-				},
-				CustomResponseHeaders: map[string]string{
-					"Access-Control-Allow-Methods": "POST,GET,OPTIONS",
-					"Content-Type":                 "application/json; charset=utf-8",
-				},
-				SSLProxyHeaders: map[string]string{
-					"Access-Control-Allow-Methods": "POST,GET,OPTIONS",
-					"Content-Type":                 "application/json; charset=utf-8",
-				},
-				AllowedHosts:            []string{"foo", "bar", "bor"},
-				HostsProxyHeaders:       []string{"foo", "bar", "bor"},
-				SSLHost:                 "foo",
-				CustomFrameOptionsValue: "foo",
-				ContentSecurityPolicy:   "foo",
-				PublicKey:               "foo",
-				ReferrerPolicy:          "foo",
-				CustomBrowserXSSValue:   "foo",
-				STSSeconds:              666,
-				SSLRedirect:             true,
-				SSLTemporaryRedirect:    true,
-				STSIncludeSubdomains:    true,
-				STSPreload:              true,
-				ForceSTSHeader:          true,
-				FrameDeny:               true,
-				ContentTypeNosniff:      true,
-				BrowserXSSFilter:        true,
-				IsDevelopment:           true,
-			},
-		},
-	}
-
-	for _, test := range testCases {
-		test := test
-		t.Run(test.desc, func(t *testing.T) {
-			t.Parallel()
-
-			dData := parseContainer(test.container)
-
-			actual := getHeaders(dData)
-
 			assert.Equal(t, test.expected, actual)
 		})
 	}