diff --git a/provider/docker/config_service_test.go b/provider/docker/config_service_test.go
index e93ba4cae..0cc7299b1 100644
--- a/provider/docker/config_service_test.go
+++ b/provider/docker/config_service_test.go
@@ -8,9 +8,175 @@ import (
 	"github.com/containous/traefik/provider/label"
 	"github.com/containous/traefik/types"
 	docker "github.com/docker/docker/api/types"
+	"github.com/docker/go-connections/nat"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
+func TestDockerServiceBuildConfiguration(t *testing.T) {
+	testCases := []struct {
+		containers        []docker.ContainerJSON
+		expectedFrontends map[string]*types.Frontend
+		expectedBackends  map[string]*types.Backend
+	}{
+		{
+			containers:        []docker.ContainerJSON{},
+			expectedFrontends: map[string]*types.Frontend{},
+			expectedBackends:  map[string]*types.Backend{},
+		},
+		{
+			containers: []docker.ContainerJSON{
+				containerJSON(
+					name("foo"),
+					labels(map[string]string{
+						"traefik.service.port":                         "2503",
+						"traefik.service.frontend.entryPoints":         "http,https",
+						"traefik.service.frontend.auth.basic":          "test:$apr1$H6uskkkW$IgXLP6ewTrSuBkTrqE8wj/,test2:$apr1$d9hr9HBB$4HxwgUir3HP4EsggP/QNo0",
+						"traefik.service.frontend.redirect.entryPoint": "https",
+					}),
+					ports(nat.PortMap{
+						"80/tcp": {},
+					}),
+					withNetwork("bridge", ipv4("127.0.0.1")),
+				),
+			},
+			expectedFrontends: map[string]*types.Frontend{
+				"frontend-foo-foo-service": {
+					Backend:        "backend-foo-foo-service",
+					PassHostHeader: true,
+					EntryPoints:    []string{"http", "https"},
+					BasicAuth:      []string{"test:$apr1$H6uskkkW$IgXLP6ewTrSuBkTrqE8wj/", "test2:$apr1$d9hr9HBB$4HxwgUir3HP4EsggP/QNo0"},
+					Redirect: &types.Redirect{
+						EntryPoint: "https",
+					},
+					Routes: map[string]types.Route{
+						"service-service": {
+							Rule: "Host:foo.docker.localhost",
+						},
+					},
+				},
+			},
+			expectedBackends: map[string]*types.Backend{
+				"backend-foo-foo-service": {
+					Servers: map[string]types.Server{
+						"service-0": {
+							URL:    "http://127.0.0.1:2503",
+							Weight: 0,
+						},
+					},
+					CircuitBreaker: nil,
+				},
+			},
+		},
+		{
+			containers: []docker.ContainerJSON{
+				containerJSON(
+					name("test1"),
+					labels(map[string]string{
+						"traefik.service.port":                         "2503",
+						"traefik.service.protocol":                     "https",
+						"traefik.service.weight":                       "80",
+						"traefik.service.frontend.backend":             "foobar",
+						"traefik.service.frontend.passHostHeader":      "false",
+						"traefik.service.frontend.rule":                "Path:/mypath",
+						"traefik.service.frontend.priority":            "5000",
+						"traefik.service.frontend.entryPoints":         "http,https,ws",
+						"traefik.service.frontend.auth.basic":          "test:$apr1$H6uskkkW$IgXLP6ewTrSuBkTrqE8wj/,test2:$apr1$d9hr9HBB$4HxwgUir3HP4EsggP/QNo0",
+						"traefik.service.frontend.redirect.entryPoint": "https",
+					}),
+					ports(nat.PortMap{
+						"80/tcp": {},
+					}),
+					withNetwork("bridge", ipv4("127.0.0.1")),
+				),
+				containerJSON(
+					name("test2"),
+					labels(map[string]string{
+						"traefik.anotherservice.port":          "8079",
+						"traefik.anotherservice.weight":        "33",
+						"traefik.anotherservice.frontend.rule": "Path:/anotherpath",
+					}),
+					ports(nat.PortMap{
+						"80/tcp": {},
+					}),
+					withNetwork("bridge", ipv4("127.0.0.1")),
+				),
+			},
+			expectedFrontends: map[string]*types.Frontend{
+				"frontend-test1-foobar": {
+					Backend:        "backend-test1-foobar",
+					PassHostHeader: false,
+					Priority:       5000,
+					EntryPoints:    []string{"http", "https", "ws"},
+					BasicAuth:      []string{"test:$apr1$H6uskkkW$IgXLP6ewTrSuBkTrqE8wj/", "test2:$apr1$d9hr9HBB$4HxwgUir3HP4EsggP/QNo0"},
+					Redirect: &types.Redirect{
+						EntryPoint: "https",
+					},
+					Routes: map[string]types.Route{
+						"service-service": {
+							Rule: "Path:/mypath",
+						},
+					},
+				},
+				"frontend-test2-test2-anotherservice": {
+					Backend:        "backend-test2-test2-anotherservice",
+					PassHostHeader: true,
+					EntryPoints:    []string{},
+					BasicAuth:      []string{},
+					Routes: map[string]types.Route{
+						"service-anotherservice": {
+							Rule: "Path:/anotherpath",
+						},
+					},
+				},
+			},
+			expectedBackends: map[string]*types.Backend{
+				"backend-test1-foobar": {
+					Servers: map[string]types.Server{
+						"service-0": {
+							URL:    "https://127.0.0.1:2503",
+							Weight: 80,
+						},
+					},
+					CircuitBreaker: nil,
+				},
+				"backend-test2-test2-anotherservice": {
+					Servers: map[string]types.Server{
+						"service-0": {
+							URL:    "http://127.0.0.1:8079",
+							Weight: 33,
+						},
+					},
+					CircuitBreaker: nil,
+				},
+			},
+		},
+	}
+
+	provider := &Provider{
+		Domain:           "docker.localhost",
+		ExposedByDefault: true,
+	}
+
+	for caseID, test := range testCases {
+		test := test
+		t.Run(strconv.Itoa(caseID), func(t *testing.T) {
+			t.Parallel()
+			var dockerDataList []dockerData
+			for _, container := range test.containers {
+				dData := parseContainer(container)
+				dockerDataList = append(dockerDataList, dData)
+			}
+
+			actualConfig := provider.buildConfiguration(dockerDataList)
+			require.NotNil(t, actualConfig, "actualConfig")
+
+			assert.EqualValues(t, test.expectedBackends, actualConfig.Backends)
+			assert.EqualValues(t, test.expectedFrontends, actualConfig.Frontends)
+		})
+	}
+}
+
 func TestDockerGetFuncMapLabel(t *testing.T) {
 	serviceName := "myservice"
 	fakeSuffix := "frontend.foo"
@@ -221,6 +387,116 @@ func TestDockerCheckPortLabels(t *testing.T) {
 	}
 }
 
+func TestDockerGetServiceBackend(t *testing.T) {
+	testCases := []struct {
+		container docker.ContainerJSON
+		expected  string
+	}{
+		{
+			container: containerJSON(name("foo")),
+			expected:  "foo-foo-myservice",
+		},
+		{
+			container: containerJSON(labels(map[string]string{
+				label.TraefikBackend: "another-backend",
+			})),
+			expected: "fake-another-backend-myservice",
+		},
+		{
+			container: containerJSON(labels(map[string]string{
+				"traefik.myservice.frontend.backend": "custom-backend",
+			})),
+			expected: "fake-custom-backend",
+		},
+	}
+
+	for containerID, test := range testCases {
+		test := test
+		t.Run(strconv.Itoa(containerID), func(t *testing.T) {
+			t.Parallel()
+			dData := parseContainer(test.container)
+			actual := getServiceBackend(dData, "myservice")
+			if actual != test.expected {
+				t.Errorf("expected %q, got %q", test.expected, actual)
+			}
+		})
+	}
+}
+
+func TestDockerGetServiceFrontendRule(t *testing.T) {
+	provider := &Provider{}
+
+	testCases := []struct {
+		container docker.ContainerJSON
+		expected  string
+	}{
+		{
+			container: containerJSON(name("foo")),
+			expected:  "",
+		},
+		{
+			container: containerJSON(labels(map[string]string{
+				label.TraefikFrontendRule: "Path:/helloworld",
+			})),
+			expected: "Path:/helloworld",
+		},
+		{
+			container: containerJSON(labels(map[string]string{
+				"traefik.myservice.frontend.rule": "Path:/mycustomservicepath",
+			})),
+			expected: "Path:/mycustomservicepath",
+		},
+	}
+
+	for containerID, test := range testCases {
+		test := test
+		t.Run(strconv.Itoa(containerID), func(t *testing.T) {
+			t.Parallel()
+			dData := parseContainer(test.container)
+			actual := provider.getServiceFrontendRule(dData, "myservice")
+			if actual != test.expected {
+				t.Errorf("expected %q, got %q", test.expected, actual)
+			}
+		})
+	}
+}
+
+func TestDockerGetServicePort(t *testing.T) {
+	testCases := []struct {
+		container docker.ContainerJSON
+		expected  string
+	}{
+		{
+			container: containerJSON(),
+			expected:  "",
+		},
+		{
+			container: containerJSON(labels(map[string]string{
+				label.TraefikPort: "2500",
+			})),
+			expected: "2500",
+		},
+		{
+			container: containerJSON(labels(map[string]string{
+				"traefik.myservice.port": "1234",
+			})),
+			expected: "1234",
+		},
+	}
+
+	for containerID, test := range testCases {
+		test := test
+		t.Run(strconv.Itoa(containerID), func(t *testing.T) {
+			t.Parallel()
+			dData := parseContainer(test.container)
+			actual := getServicePort(dData, "myservice")
+			if actual != test.expected {
+				t.Errorf("expected %q, got %q", test.expected, actual)
+			}
+		})
+	}
+}
+
 func TestGetServiceErrorPages(t *testing.T) {
 	service := "courgette"
 	testCases := []struct {
diff --git a/provider/docker/service_test.go b/provider/docker/service_test.go
deleted file mode 100644
index 73f46804b..000000000
--- a/provider/docker/service_test.go
+++ /dev/null
@@ -1,287 +0,0 @@
-package docker
-
-import (
-	"strconv"
-	"testing"
-
-	"github.com/containous/traefik/provider/label"
-	"github.com/containous/traefik/types"
-	docker "github.com/docker/docker/api/types"
-	"github.com/docker/go-connections/nat"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func TestDockerGetServicePort(t *testing.T) {
-	testCases := []struct {
-		container docker.ContainerJSON
-		expected  string
-	}{
-		{
-			container: containerJSON(),
-			expected:  "",
-		},
-		{
-			container: containerJSON(labels(map[string]string{
-				label.TraefikPort: "2500",
-			})),
-			expected: "2500",
-		},
-		{
-			container: containerJSON(labels(map[string]string{
-				"traefik.myservice.port": "1234",
-			})),
-			expected: "1234",
-		},
-	}
-
-	for containerID, test := range testCases {
-		test := test
-		t.Run(strconv.Itoa(containerID), func(t *testing.T) {
-			t.Parallel()
-			dData := parseContainer(test.container)
-			actual := getServicePort(dData, "myservice")
-			if actual != test.expected {
-				t.Errorf("expected %q, got %q", test.expected, actual)
-			}
-		})
-	}
-}
-
-func TestDockerGetServiceFrontendRule(t *testing.T) {
-	provider := &Provider{}
-
-	testCases := []struct {
-		container docker.ContainerJSON
-		expected  string
-	}{
-		{
-			container: containerJSON(name("foo")),
-			expected:  "",
-		},
-		{
-			container: containerJSON(labels(map[string]string{
-				label.TraefikFrontendRule: "Path:/helloworld",
-			})),
-			expected: "Path:/helloworld",
-		},
-		{
-			container: containerJSON(labels(map[string]string{
-				"traefik.myservice.frontend.rule": "Path:/mycustomservicepath",
-			})),
-			expected: "Path:/mycustomservicepath",
-		},
-	}
-
-	for containerID, test := range testCases {
-		test := test
-		t.Run(strconv.Itoa(containerID), func(t *testing.T) {
-			t.Parallel()
-			dData := parseContainer(test.container)
-			actual := provider.getServiceFrontendRule(dData, "myservice")
-			if actual != test.expected {
-				t.Errorf("expected %q, got %q", test.expected, actual)
-			}
-		})
-	}
-}
-
-func TestDockerGetServiceBackend(t *testing.T) {
-	testCases := []struct {
-		container docker.ContainerJSON
-		expected  string
-	}{
-		{
-			container: containerJSON(name("foo")),
-			expected:  "foo-foo-myservice",
-		},
-		{
-			container: containerJSON(labels(map[string]string{
-				label.TraefikBackend: "another-backend",
-			})),
-			expected: "fake-another-backend-myservice",
-		},
-		{
-			container: containerJSON(labels(map[string]string{
-				"traefik.myservice.frontend.backend": "custom-backend",
-			})),
-			expected: "fake-custom-backend",
-		},
-	}
-
-	for containerID, test := range testCases {
-		test := test
-		t.Run(strconv.Itoa(containerID), func(t *testing.T) {
-			t.Parallel()
-			dData := parseContainer(test.container)
-			actual := getServiceBackend(dData, "myservice")
-			if actual != test.expected {
-				t.Errorf("expected %q, got %q", test.expected, actual)
-			}
-		})
-	}
-}
-
-func TestDockerLoadDockerServiceConfig(t *testing.T) {
-	testCases := []struct {
-		containers        []docker.ContainerJSON
-		expectedFrontends map[string]*types.Frontend
-		expectedBackends  map[string]*types.Backend
-	}{
-		{
-			containers:        []docker.ContainerJSON{},
-			expectedFrontends: map[string]*types.Frontend{},
-			expectedBackends:  map[string]*types.Backend{},
-		},
-		{
-			containers: []docker.ContainerJSON{
-				containerJSON(
-					name("foo"),
-					labels(map[string]string{
-						"traefik.service.port":                         "2503",
-						"traefik.service.frontend.entryPoints":         "http,https",
-						"traefik.service.frontend.auth.basic":          "test:$apr1$H6uskkkW$IgXLP6ewTrSuBkTrqE8wj/,test2:$apr1$d9hr9HBB$4HxwgUir3HP4EsggP/QNo0",
-						"traefik.service.frontend.redirect.entryPoint": "https",
-					}),
-					ports(nat.PortMap{
-						"80/tcp": {},
-					}),
-					withNetwork("bridge", ipv4("127.0.0.1")),
-				),
-			},
-			expectedFrontends: map[string]*types.Frontend{
-				"frontend-foo-foo-service": {
-					Backend:        "backend-foo-foo-service",
-					PassHostHeader: true,
-					EntryPoints:    []string{"http", "https"},
-					BasicAuth:      []string{"test:$apr1$H6uskkkW$IgXLP6ewTrSuBkTrqE8wj/", "test2:$apr1$d9hr9HBB$4HxwgUir3HP4EsggP/QNo0"},
-					Redirect: &types.Redirect{
-						EntryPoint: "https",
-					},
-					Routes: map[string]types.Route{
-						"service-service": {
-							Rule: "Host:foo.docker.localhost",
-						},
-					},
-				},
-			},
-			expectedBackends: map[string]*types.Backend{
-				"backend-foo-foo-service": {
-					Servers: map[string]types.Server{
-						"service-0": {
-							URL:    "http://127.0.0.1:2503",
-							Weight: 0,
-						},
-					},
-					CircuitBreaker: nil,
-				},
-			},
-		},
-		{
-			containers: []docker.ContainerJSON{
-				containerJSON(
-					name("test1"),
-					labels(map[string]string{
-						"traefik.service.port":                         "2503",
-						"traefik.service.protocol":                     "https",
-						"traefik.service.weight":                       "80",
-						"traefik.service.frontend.backend":             "foobar",
-						"traefik.service.frontend.passHostHeader":      "false",
-						"traefik.service.frontend.rule":                "Path:/mypath",
-						"traefik.service.frontend.priority":            "5000",
-						"traefik.service.frontend.entryPoints":         "http,https,ws",
-						"traefik.service.frontend.auth.basic":          "test:$apr1$H6uskkkW$IgXLP6ewTrSuBkTrqE8wj/,test2:$apr1$d9hr9HBB$4HxwgUir3HP4EsggP/QNo0",
-						"traefik.service.frontend.redirect.entryPoint": "https",
-					}),
-					ports(nat.PortMap{
-						"80/tcp": {},
-					}),
-					withNetwork("bridge", ipv4("127.0.0.1")),
-				),
-				containerJSON(
-					name("test2"),
-					labels(map[string]string{
-						"traefik.anotherservice.port":          "8079",
-						"traefik.anotherservice.weight":        "33",
-						"traefik.anotherservice.frontend.rule": "Path:/anotherpath",
-					}),
-					ports(nat.PortMap{
-						"80/tcp": {},
-					}),
-					withNetwork("bridge", ipv4("127.0.0.1")),
-				),
-			},
-			expectedFrontends: map[string]*types.Frontend{
-				"frontend-test1-foobar": {
-					Backend:        "backend-test1-foobar",
-					PassHostHeader: false,
-					Priority:       5000,
-					EntryPoints:    []string{"http", "https", "ws"},
-					BasicAuth:      []string{"test:$apr1$H6uskkkW$IgXLP6ewTrSuBkTrqE8wj/", "test2:$apr1$d9hr9HBB$4HxwgUir3HP4EsggP/QNo0"},
-					Redirect: &types.Redirect{
-						EntryPoint: "https",
-					},
-					Routes: map[string]types.Route{
-						"service-service": {
-							Rule: "Path:/mypath",
-						},
-					},
-				},
-				"frontend-test2-test2-anotherservice": {
-					Backend:        "backend-test2-test2-anotherservice",
-					PassHostHeader: true,
-					EntryPoints:    []string{},
-					BasicAuth:      []string{},
-					Routes: map[string]types.Route{
-						"service-anotherservice": {
-							Rule: "Path:/anotherpath",
-						},
-					},
-				},
-			},
-			expectedBackends: map[string]*types.Backend{
-				"backend-test1-foobar": {
-					Servers: map[string]types.Server{
-						"service-0": {
-							URL:    "https://127.0.0.1:2503",
-							Weight: 80,
-						},
-					},
-					CircuitBreaker: nil,
-				},
-				"backend-test2-test2-anotherservice": {
-					Servers: map[string]types.Server{
-						"service-0": {
-							URL:    "http://127.0.0.1:8079",
-							Weight: 33,
-						},
-					},
-					CircuitBreaker: nil,
-				},
-			},
-		},
-	}
-
-	provider := &Provider{
-		Domain:           "docker.localhost",
-		ExposedByDefault: true,
-	}
-
-	for caseID, test := range testCases {
-		test := test
-		t.Run(strconv.Itoa(caseID), func(t *testing.T) {
-			t.Parallel()
-			var dockerDataList []dockerData
-			for _, container := range test.containers {
-				dData := parseContainer(container)
-				dockerDataList = append(dockerDataList, dData)
-			}
-
-			actualConfig := provider.buildConfiguration(dockerDataList)
-			require.NotNil(t, actualConfig, "actualConfig")
-
-			assert.EqualValues(t, test.expectedBackends, actualConfig.Backends)
-			assert.EqualValues(t, test.expectedFrontends, actualConfig.Frontends)
-		})
-	}
-}