refactor: ECS labels.

provider/ecs/config_test.go

@@ -14,7 +14,7 @@ import (
 )
 
 func TestBuildConfiguration(t *testing.T) {
-	tests := []struct {
+	testCases := []struct {
 		desc     string
 		services map[string][]ecsInstance
 		expected *types.Configuration
@@ -346,14 +346,17 @@ func TestBuildConfiguration(t *testing.T) {
 		},
 	}
 
-	for _, test := range tests {
+	for _, test := range testCases {
 		test := test
 		t.Run(test.desc, func(t *testing.T) {
 			t.Parallel()
 
 			provider := &Provider{}
-			got, err := provider.buildConfiguration(test.services)
-			assert.Equal(t, test.err, err)
+
+			services := fakeLoadTraefikLabels(test.services)
+
+			got, err := provider.buildConfiguration(services)
+			assert.Equal(t, test.err, err) // , err.Error()
 			assert.Equal(t, test.expected, got, test.desc)
 		})
 	}
@@ -381,7 +384,7 @@ func TestFilterInstance(t *testing.T) {
 		label.TraefikPort: aws.String("80"),
 	})
 
-	tests := []struct {
+	testCases := []struct {
 		desc             string
 		instanceInfo     ecsInstance
 		exposedByDefault bool
@@ -459,7 +462,7 @@ func TestFilterInstance(t *testing.T) {
 		},
 	}
 
-	for _, test := range tests {
+	for _, test := range testCases {
 		test := test
 		t.Run(test.desc, func(t *testing.T) {
 			t.Parallel()
@@ -475,7 +478,7 @@ func TestFilterInstance(t *testing.T) {
 
 func TestChunkedTaskArns(t *testing.T) {
 	testVal := "a"
-	tests := []struct {
+	testCases := []struct {
 		desc            string
 		count           int
 		expectedLengths []int
@@ -532,7 +535,7 @@ func TestChunkedTaskArns(t *testing.T) {
 		},
 	}
 
-	for _, test := range tests {
+	for _, test := range testCases {
 		test := test
 		t.Run(test.desc, func(t *testing.T) {
 			t.Parallel()
@@ -555,7 +558,7 @@ func TestChunkedTaskArns(t *testing.T) {
 }
 
 func TestGetHost(t *testing.T) {
-	tests := []struct {
+	testCases := []struct {
 		desc         string
 		expected     string
 		instanceInfo ecsInstance
@@ -567,7 +570,7 @@ func TestGetHost(t *testing.T) {
 		},
 	}
 
-	for _, test := range tests {
+	for _, test := range testCases {
 		test := test
 		t.Run(test.desc, func(t *testing.T) {
 			t.Parallel()
@@ -579,7 +582,7 @@ func TestGetHost(t *testing.T) {
 }
 
 func TestGetPort(t *testing.T) {
-	tests := []struct {
+	testCases := []struct {
 		desc         string
 		expected     string
 		instanceInfo ecsInstance
@@ -605,7 +608,7 @@ func TestGetPort(t *testing.T) {
 		},
 	}
 
-	for _, test := range tests {
+	for _, test := range testCases {
 		test := test
 		t.Run(test.desc, func(t *testing.T) {
 			t.Parallel()
@@ -617,7 +620,7 @@ func TestGetPort(t *testing.T) {
 }
 
 func TestGetFuncStringValue(t *testing.T) {
-	tests := []struct {
+	testCases := []struct {
 		desc         string
 		expected     string
 		instanceInfo ecsInstance
@@ -643,19 +646,19 @@ func TestGetFuncStringValue(t *testing.T) {
 		},
 	}
 
-	for _, test := range tests {
+	for _, test := range testCases {
 		test := test
 		t.Run(test.desc, func(t *testing.T) {
 			t.Parallel()
 
-			actual := getFuncStringValue(label.TraefikProtocol, label.DefaultProtocol)(test.instanceInfo)
+			actual := getFuncStringValueV1(label.TraefikProtocol, label.DefaultProtocol)(test.instanceInfo)
 			assert.Equal(t, test.expected, actual)
 		})
 	}
 }
 
 func TestGetFuncSliceString(t *testing.T) {
-	tests := []struct {
+	testCases := []struct {
 		desc         string
 		expected     []string
 		instanceInfo ecsInstance
@@ -681,12 +684,12 @@ func TestGetFuncSliceString(t *testing.T) {
 		},
 	}
 
-	for _, test := range tests {
+	for _, test := range testCases {
 		test := test
 		t.Run(test.desc, func(t *testing.T) {
 			t.Parallel()
 
-			actual := getFuncSliceString(label.TraefikFrontendEntryPoints)(test.instanceInfo)
+			actual := getFuncSliceStringV1(label.TraefikFrontendEntryPoints)(test.instanceInfo)
 			assert.Equal(t, test.expected, actual)
 		})
 	}
@@ -707,7 +710,7 @@ func makeEcsInstance(containerDef *ecs.ContainerDefinition) ecsInstance {
 		}
 	}
 
-	return ecsInstance{
+	instance := ecsInstance{
 		Name: "foo-http",
 		ID:   "123456789abc",
 		task: &ecs.Task{
@@ -725,6 +728,12 @@ func makeEcsInstance(containerDef *ecs.ContainerDefinition) ecsInstance {
 			},
 		},
 	}
+
+	if containerDef != nil {
+		instance.TraefikLabels = aws.StringValueMap(containerDef.DockerLabels)
+	}
+
+	return instance
 }
 
 func simpleEcsInstance(labels map[string]*string) ecsInstance {
@@ -747,782 +756,15 @@ func simpleEcsInstanceNoNetwork(labels map[string]*string) ecsInstance {
 	})
 }
 
-func TestGetCircuitBreaker(t *testing.T) {
-	testCases := []struct {
-		desc     string
-		instance ecsInstance
-		expected *types.CircuitBreaker
-	}{
-		{
-			desc: "should return nil when no CB label",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{},
-				},
-			},
-			expected: nil,
-		},
-		{
-			desc: "",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{
-						label.TraefikBackendCircuitBreakerExpression: aws.String("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()
-
-			actual := getCircuitBreaker(test.instance)
-
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-}
-
-func TestGetLoadBalancer(t *testing.T) {
-	testCases := []struct {
-		desc     string
-		instance ecsInstance
-		expected *types.LoadBalancer
-	}{
-		{
-			desc: "should return nil when no LB labels",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{},
-				},
-			},
-			expected: nil,
-		},
-		{
-			desc: "should return a struct when labels are set",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{
-						label.TraefikBackendLoadBalancerMethod:               aws.String("drr"),
-						label.TraefikBackendLoadBalancerSticky:               aws.String("true"),
-						label.TraefikBackendLoadBalancerStickiness:           aws.String("true"),
-						label.TraefikBackendLoadBalancerStickinessCookieName: aws.String("foo"),
-					}}},
-			expected: &types.LoadBalancer{
-				Method: "drr",
-				Sticky: true,
-				Stickiness: &types.Stickiness{
-					CookieName: "foo",
-				},
-			},
-		},
-		{
-			desc: "should return a nil Stickiness when Stickiness is not set",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{
-						label.TraefikBackendLoadBalancerMethod:               aws.String("drr"),
-						label.TraefikBackendLoadBalancerSticky:               aws.String("true"),
-						label.TraefikBackendLoadBalancerStickinessCookieName: aws.String("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()
-
-			actual := getLoadBalancer(test.instance)
-
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-}
-
-func TestGetMaxConn(t *testing.T) {
-	testCases := []struct {
-		desc     string
-		instance ecsInstance
-		expected *types.MaxConn
-	}{
-		{
-			desc: "should return nil when no max conn labels",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{},
-				},
-			},
-			expected: nil,
-		},
-		{
-			desc: "should return nil when no amount label",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{
-						label.TraefikBackendMaxConnExtractorFunc: aws.String("client.ip"),
-					}}},
-			expected: nil,
-		},
-		{
-			desc: "should return default when no empty extractorFunc label",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{
-						label.TraefikBackendMaxConnExtractorFunc: aws.String(""),
-						label.TraefikBackendMaxConnAmount:        aws.String("666"),
-					}}},
-			expected: &types.MaxConn{
-				ExtractorFunc: "request.host",
-				Amount:        666,
-			},
-		},
-		{
-			desc: "should return a struct when max conn labels are set",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{
-						label.TraefikBackendMaxConnExtractorFunc: aws.String("client.ip"),
-						label.TraefikBackendMaxConnAmount:        aws.String("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()
-
-			actual := getMaxConn(test.instance)
-
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-}
-
-func TestGetHealthCheck(t *testing.T) {
-	testCases := []struct {
-		desc     string
-		instance ecsInstance
-		expected *types.HealthCheck
-	}{
-		{
-			desc: "should return nil when no health check labels",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{},
-				}},
-			expected: nil,
-		},
-		{
-			desc: "should return nil when no health check Path label",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{
-						label.TraefikBackendHealthCheckPort:     aws.String("80"),
-						label.TraefikBackendHealthCheckInterval: aws.String("6"),
-					}}},
-			expected: nil,
-		},
-		{
-			desc: "should return a struct when health check labels are set",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{
-						label.TraefikBackendHealthCheckPath:     aws.String("/health"),
-						label.TraefikBackendHealthCheckPort:     aws.String("80"),
-						label.TraefikBackendHealthCheckInterval: aws.String("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()
-
-			actual := getHealthCheck(test.instance)
-
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-}
-
-func TestGetBuffering(t *testing.T) {
-	testCases := []struct {
-		desc     string
-		instance ecsInstance
-		expected *types.Buffering
-	}{
-		{
-			desc: "should return nil when no buffering labels",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{},
-				}},
-			expected: nil,
-		},
-		{
-			desc: "should return a struct when health check labels are set",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{
-						label.TraefikBackendBufferingMaxResponseBodyBytes: aws.String("10485760"),
-						label.TraefikBackendBufferingMemResponseBodyBytes: aws.String("2097152"),
-						label.TraefikBackendBufferingMaxRequestBodyBytes:  aws.String("10485760"),
-						label.TraefikBackendBufferingMemRequestBodyBytes:  aws.String("2097152"),
-						label.TraefikBackendBufferingRetryExpression:      aws.String("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()
-
-			actual := getBuffering(test.instance)
-
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-}
-
-func TestGetServers(t *testing.T) {
-	testCases := []struct {
-		desc      string
-		instances []ecsInstance
-		expected  map[string]types.Server
-	}{
-		{
-			desc: "should return a dumb server when no IP and no ",
-			instances: []ecsInstance{{
-				Name: "test",
-				ID:   "0",
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{},
-				},
-				machine: &ec2.Instance{
-					PrivateIpAddress: nil,
-				},
-				container: &ecs.Container{
-					NetworkBindings: []*ecs.NetworkBinding{{
-						HostPort: nil,
-					}},
-				}}},
-			expected: map[string]types.Server{
-				"server-test-0": {URL: "http://:0", Weight: 0},
-			},
-		},
-		{
-			desc: "should use default weight when invalid weight value",
-			instances: []ecsInstance{{
-				Name: "test",
-				ID:   "0",
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{
-						label.TraefikWeight: aws.String("oops"),
-					}},
-				machine: &ec2.Instance{
-					PrivateIpAddress: aws.String("10.10.10.0"),
-				},
-				container: &ecs.Container{
-					NetworkBindings: []*ecs.NetworkBinding{{
-						HostPort: aws.Int64(80),
-					}},
-				}}},
-			expected: map[string]types.Server{
-				"server-test-0": {URL: "http://10.10.10.0:80", Weight: 0},
-			},
-		},
-		{
-			desc: "should return a map when configuration keys are defined",
-			instances: []ecsInstance{
-				{
-					Name: "test",
-					ID:   "0",
-					containerDefinition: &ecs.ContainerDefinition{
-						DockerLabels: map[string]*string{
-							label.TraefikWeight: aws.String("6"),
-						}},
-					machine: &ec2.Instance{
-						PrivateIpAddress: aws.String("10.10.10.0"),
-					},
-					container: &ecs.Container{
-						NetworkBindings: []*ecs.NetworkBinding{{
-							HostPort: aws.Int64(80),
-						}},
-					}},
-				{
-					Name: "test",
-					ID:   "1",
-					containerDefinition: &ecs.ContainerDefinition{
-						DockerLabels: map[string]*string{}},
-					machine: &ec2.Instance{
-						PrivateIpAddress: aws.String("10.10.10.1"),
-					},
-					container: &ecs.Container{
-						NetworkBindings: []*ecs.NetworkBinding{{
-							HostPort: aws.Int64(90),
-						}},
-					}},
-			},
-			expected: map[string]types.Server{
-				"server-test-0": {
-					URL:    "http://10.10.10.0:80",
-					Weight: 6,
-				},
-				"server-test-1": {
-					URL:    "http://10.10.10.1:90",
-					Weight: 0,
-				},
-			},
-		},
-	}
-
-	for _, test := range testCases {
-		test := test
-		t.Run(test.desc, func(t *testing.T) {
-			t.Parallel()
-
-			actual := getServers(test.instances)
-
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-}
-
-func TestWhiteList(t *testing.T) {
-	testCases := []struct {
-		desc     string
-		instance ecsInstance
-		expected *types.WhiteList
-	}{
-		{
-			desc: "should return nil when no white list labels",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{},
-				},
-			},
-			expected: nil,
-		},
-		{
-			desc: "should return a struct when only range",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{
-						label.TraefikFrontendWhiteListSourceRange: aws.String("10.10.10.10"),
-					}},
-			},
-			expected: &types.WhiteList{
-				SourceRange: []string{
-					"10.10.10.10",
-				},
-				UseXForwardedFor: false,
-			},
-		},
-		{
-			desc: "should return a struct when range and UseXForwardedFor",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{
-						label.TraefikFrontendWhiteListSourceRange:      aws.String("10.10.10.10"),
-						label.TraefikFrontendWhiteListUseXForwardedFor: aws.String("true"),
-					}},
-			},
-			expected: &types.WhiteList{
-				SourceRange: []string{
-					"10.10.10.10",
-				},
-				UseXForwardedFor: true,
-			},
-		},
-		{
-			desc: "should return nil when only UseXForwardedFor",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{
-						label.TraefikFrontendWhiteListUseXForwardedFor: aws.String("true"),
-					}},
-			},
-		},
-	}
-
-	for _, test := range testCases {
-		test := test
-		t.Run(test.desc, func(t *testing.T) {
-			t.Parallel()
-
-			actual := getWhiteList(test.instance)
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-}
-
-func TestGetRedirect(t *testing.T) {
-	testCases := []struct {
-		desc     string
-		instance ecsInstance
-		expected *types.Redirect
-	}{
-		{
-			desc: "should return nil when no redirect labels",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{},
-				},
-			},
-			expected: nil,
-		},
-		{
-			desc: "should use only entry point tag when mix regex redirect and entry point redirect",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{
-						label.TraefikFrontendRedirectEntryPoint:  aws.String("https"),
-						label.TraefikFrontendRedirectRegex:       aws.String("(.*)"),
-						label.TraefikFrontendRedirectReplacement: aws.String("$1"),
-					}},
-			},
-			expected: &types.Redirect{
-				EntryPoint: "https",
-			},
-		},
-		{
-			desc: "should return a struct when entry point redirect label",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{
-						label.TraefikFrontendRedirectEntryPoint: aws.String("https"),
-					}},
-			},
-			expected: &types.Redirect{
-				EntryPoint: "https",
-			},
-		},
-		{
-			desc: "should return a struct when entry point redirect label (permanent)",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{
-						label.TraefikFrontendRedirectEntryPoint: aws.String("https"),
-						label.TraefikFrontendRedirectPermanent:  aws.String("true"),
-					}},
-			},
-			expected: &types.Redirect{
-				EntryPoint: "https",
-				Permanent:  true,
-			},
-		},
-		{
-			desc: "should return a struct when regex redirect labels",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{
-						label.TraefikFrontendRedirectRegex:       aws.String("(.*)"),
-						label.TraefikFrontendRedirectReplacement: aws.String("$1"),
-					}},
-			},
-			expected: &types.Redirect{
-				Regex:       "(.*)",
-				Replacement: "$1",
-			},
-		},
-		{
-			desc: "should return a struct when regex redirect tags (permanent)",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{
-						label.TraefikFrontendRedirectRegex:       aws.String("(.*)"),
-						label.TraefikFrontendRedirectReplacement: aws.String("$1"),
-						label.TraefikFrontendRedirectPermanent:   aws.String("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()
-
-			actual := getRedirect(test.instance)
-
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-}
-
-func TestGetErrorPages(t *testing.T) {
-	testCases := []struct {
-		desc     string
-		instance ecsInstance
-		expected map[string]*types.ErrorPage
-	}{
-		{
-			desc: "",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{},
-				},
-			},
-			expected: nil,
-		},
-		{
-			desc: "2 errors pages",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{
-						label.Prefix + label.BaseFrontendErrorPage + "foo." + label.SuffixErrorPageStatus:  aws.String("404"),
-						label.Prefix + label.BaseFrontendErrorPage + "foo." + label.SuffixErrorPageBackend: aws.String("foo_backend"),
-						label.Prefix + label.BaseFrontendErrorPage + "foo." + label.SuffixErrorPageQuery:   aws.String("foo_query"),
-						label.Prefix + label.BaseFrontendErrorPage + "bar." + label.SuffixErrorPageStatus:  aws.String("500,600"),
-						label.Prefix + label.BaseFrontendErrorPage + "bar." + label.SuffixErrorPageBackend: aws.String("bar_backend"),
-						label.Prefix + label.BaseFrontendErrorPage + "bar." + label.SuffixErrorPageQuery:   aws.String("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",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{
-						label.Prefix + label.BaseFrontendErrorPage + "foo." + label.SuffixErrorPageStatus: aws.String("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()
-
-			actual := getErrorPages(test.instance)
-
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-}
-
-func TestGetRateLimit(t *testing.T) {
-	testCases := []struct {
-		desc     string
-		instance ecsInstance
-		expected *types.RateLimit
-	}{
-		{
-			desc: "should return nil when no rate limit labels",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{},
-				},
-			},
-			expected: nil,
-		},
-		{
-			desc: "should return a struct when rate limit labels are defined",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{
-						label.TraefikFrontendRateLimitExtractorFunc:                                        aws.String("client.ip"),
-						label.Prefix + label.BaseFrontendRateLimit + "foo." + label.SuffixRateLimitPeriod:  aws.String("6"),
-						label.Prefix + label.BaseFrontendRateLimit + "foo." + label.SuffixRateLimitAverage: aws.String("12"),
-						label.Prefix + label.BaseFrontendRateLimit + "foo." + label.SuffixRateLimitBurst:   aws.String("18"),
-						label.Prefix + label.BaseFrontendRateLimit + "bar." + label.SuffixRateLimitPeriod:  aws.String("3"),
-						label.Prefix + label.BaseFrontendRateLimit + "bar." + label.SuffixRateLimitAverage: aws.String("6"),
-						label.Prefix + label.BaseFrontendRateLimit + "bar." + label.SuffixRateLimitBurst:   aws.String("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",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{
-						label.Prefix + label.BaseFrontendRateLimit + "foo." + label.SuffixRateLimitPeriod:  aws.String("6"),
-						label.Prefix + label.BaseFrontendRateLimit + "foo." + label.SuffixRateLimitAverage: aws.String("12"),
-						label.Prefix + label.BaseFrontendRateLimit + "foo." + label.SuffixRateLimitBurst:   aws.String("18"),
-						label.Prefix + label.BaseFrontendRateLimit + "bar." + label.SuffixRateLimitPeriod:  aws.String("3"),
-						label.Prefix + label.BaseFrontendRateLimit + "bar." + label.SuffixRateLimitAverage: aws.String("6"),
-						label.Prefix + label.BaseFrontendRateLimit + "bar." + label.SuffixRateLimitBurst:   aws.String("9"),
-					},
-				},
-			},
-			expected: nil,
-		},
-	}
-
-	for _, test := range testCases {
-		test := test
-		t.Run(test.desc, func(t *testing.T) {
-			t.Parallel()
-
-			actual := getRateLimit(test.instance)
-
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-}
-
-func TestGetHeaders(t *testing.T) {
-	testCases := []struct {
-		desc     string
-		instance ecsInstance
-		expected *types.Headers
-	}{
-		{
-			desc: "",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{},
-				},
-			},
-			expected: nil,
-		},
-		{
-			desc: "should return nil when no custom headers options are set",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{},
-				},
-			},
-			expected: nil,
-		},
-		{
-			desc: "should return a struct when all custom headers options are set",
-			instance: ecsInstance{
-				containerDefinition: &ecs.ContainerDefinition{
-					DockerLabels: map[string]*string{
-						label.TraefikFrontendRequestHeaders:          aws.String("Access-Control-Allow-Methods:POST,GET,OPTIONS || Content-type: application/json; charset=utf-8"),
-						label.TraefikFrontendResponseHeaders:         aws.String("Access-Control-Allow-Methods:POST,GET,OPTIONS || Content-type: application/json; charset=utf-8"),
-						label.TraefikFrontendSSLProxyHeaders:         aws.String("Access-Control-Allow-Methods:POST,GET,OPTIONS || Content-type: application/json; charset=utf-8"),
-						label.TraefikFrontendAllowedHosts:            aws.String("foo,bar,bor"),
-						label.TraefikFrontendHostsProxyHeaders:       aws.String("foo,bar,bor"),
-						label.TraefikFrontendSSLHost:                 aws.String("foo"),
-						label.TraefikFrontendCustomFrameOptionsValue: aws.String("foo"),
-						label.TraefikFrontendContentSecurityPolicy:   aws.String("foo"),
-						label.TraefikFrontendPublicKey:               aws.String("foo"),
-						label.TraefikFrontendReferrerPolicy:          aws.String("foo"),
-						label.TraefikFrontendCustomBrowserXSSValue:   aws.String("foo"),
-						label.TraefikFrontendSTSSeconds:              aws.String("666"),
-						label.TraefikFrontendSSLRedirect:             aws.String("true"),
-						label.TraefikFrontendSSLTemporaryRedirect:    aws.String("true"),
-						label.TraefikFrontendSTSIncludeSubdomains:    aws.String("true"),
-						label.TraefikFrontendSTSPreload:              aws.String("true"),
-						label.TraefikFrontendForceSTSHeader:          aws.String("true"),
-						label.TraefikFrontendFrameDeny:               aws.String("true"),
-						label.TraefikFrontendContentTypeNosniff:      aws.String("true"),
-						label.TraefikFrontendBrowserXSSFilter:        aws.String("true"),
-						label.TraefikFrontendIsDevelopment:           aws.String("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()
-
-			actual := getHeaders(test.instance)
-
-			assert.Equal(t, test.expected, actual)
-		})
+func fakeLoadTraefikLabels(services map[string][]ecsInstance) map[string][]ecsInstance {
+	result := make(map[string][]ecsInstance)
+	for name, srcInstances := range services {
+		var instances []ecsInstance
+		for _, instance := range srcInstances {
+			instance.TraefikLabels = aws.StringValueMap(instance.containerDefinition.DockerLabels)
+			instances = append(instances, instance)
+		}
+		result[name] = instances
 	}
+	return result
 }