refactor(consulcatalog): reorganize code.

provider/consul/consul_catalog.go

@@ -2,7 +2,6 @@ package consul
 
 import (
 	"errors"
-	"strconv"
 	"strings"
 	"text/template"
 	"time"
@@ -95,7 +94,7 @@ func (p *CatalogProvider) Provide(configurationChan chan<- types.ConfigMessage,
 	}
 	p.client = client
 	p.Constraints = append(p.Constraints, constraints...)
-	p.setupFrontEndTemplate()
+	p.setupFrontEndRuleTemplate()
 
 	pool.Go(func(stop chan bool) {
 		notify := func(err error, time time.Duration) {
@@ -431,48 +430,7 @@ func (p *CatalogProvider) nodeFilter(service string, node *api.ServiceEntry) boo
 }
 
 func (p *CatalogProvider) isServiceEnabled(node *api.ServiceEntry) bool {
-	enable, err := strconv.ParseBool(p.getAttribute(label.SuffixEnable, node.Service.Tags, strconv.FormatBool(p.ExposedByDefault)))
+	return p.getBoolAttribute(label.SuffixEnable, node.Service.Tags, p.ExposedByDefault)
-	if err != nil {
-		log.Debugf("Invalid value for enable, set to %b", p.ExposedByDefault)
-		return p.ExposedByDefault
-	}
-	return enable
-}
-
-func (p *CatalogProvider) getPrefixedName(name string) string {
-	if len(p.Prefix) > 0 && len(name) > 0 {
-		return p.Prefix + "." + name
-	}
-	return name
-}
-
-func (p *CatalogProvider) getAttribute(name string, tags []string, defaultValue string) string {
-	return getTag(p.getPrefixedName(name), tags, defaultValue)
-}
-
-func hasTag(name string, tags []string) bool {
-	// Very-very unlikely that a Consul tag would ever start with '=!='
-	tag := getTag(name, tags, "=!=")
-	return tag != "=!="
-}
-
-func getTag(name string, tags []string, defaultValue string) string {
-	for _, tag := range tags {
-		// Given the nature of Consul tags, which could be either singular markers, or key=value pairs, we check if the consul tag starts with 'name'
-		if strings.HasPrefix(strings.ToLower(tag), strings.ToLower(name)) {
-			// In case, where a tag might be a key=value, try to split it by the first '='
-			// - If the first element (which would always be there, even if the tag is a singular marker without '=' in it
-			if kv := strings.SplitN(tag, "=", 2); strings.ToLower(kv[0]) == strings.ToLower(name) {
-				// If the returned result is a key=value pair, return the 'value' component
-				if len(kv) == 2 {
-					return kv[1]
-				}
-				// If the returned result is a singular marker, return the 'key' component
-				return kv[0]
-			}
-		}
-	}
-	return defaultValue
 }
 
 func (p *CatalogProvider) getConstraintTags(tags []string) []string {

provider/consul/consul_catalog_config.go

@@ -16,19 +16,23 @@ import (
 
 func (p *CatalogProvider) buildConfiguration(catalog []catalogUpdate) *types.Configuration {
 	var FuncMap = template.FuncMap{
-		"getBackend":              getBackend,
-		"getFrontendRule":         p.getFrontendRule,
-		"getBackendName":          getBackendName,
-		"getBackendAddress":       getBackendAddress,
-		"getBasicAuth":            p.getBasicAuth,
-		"getSticky":               p.getSticky,
-		"hasStickinessLabel":      p.hasStickinessLabel,
-		"getStickinessCookieName": p.getStickinessCookieName,
 		"getAttribute": p.getAttribute,
 		"getTag":       getTag,
 		"hasTag":       hasTag,
-		"getEntryPoints":          getEntryPoints,
+
+		// Backend functions
+		"getBackend":              getBackend,
+		"getBackendAddress":       getBackendAddress,
 		"hasMaxconnAttributes":    p.hasMaxConnAttributes,
+		"getSticky":               p.getSticky,
+		"hasStickinessLabel":      p.hasStickinessLabel,
+		"getStickinessCookieName": p.getStickinessCookieName,
+
+		// Frontend functions
+		"getBackendName":  getBackendName,
+		"getFrontendRule": p.getFrontendRule,
+		"getBasicAuth":    p.getBasicAuth,
+		"getEntryPoints":  getEntryPoints,
 	}
 
 	var allNodes []*api.ServiceEntry
@@ -58,7 +62,7 @@ func (p *CatalogProvider) buildConfiguration(catalog []catalogUpdate) *types.Con
 	return configuration
 }
 
-func (p *CatalogProvider) setupFrontEndTemplate() {
+func (p *CatalogProvider) setupFrontEndRuleTemplate() {
 	var FuncMap = template.FuncMap{
 		"getAttribute": p.getAttribute,
 		"getTag":       getTag,
@@ -68,6 +72,8 @@ func (p *CatalogProvider) setupFrontEndTemplate() {
 	p.frontEndRuleTemplate = tmpl
 }
 
+// Specific functions
+
 func (p *CatalogProvider) getFrontendRule(service serviceUpdate) string {
 	customFrontendRule := p.getAttribute(label.SuffixFrontendRule, service.Attributes, "")
 	if customFrontendRule == "" {
@@ -102,19 +108,16 @@ func (p *CatalogProvider) getFrontendRule(service serviceUpdate) string {
 }
 
 func (p *CatalogProvider) getBasicAuth(tags []string) []string {
-	list := p.getAttribute(label.SuffixFrontendAuthBasic, tags, "")
+	return p.getSliceAttribute(label.SuffixFrontendAuthBasic, tags)
-	if list != "" {
-		return strings.Split(list, ",")
-	}
-	return []string{}
 }
 
 func (p *CatalogProvider) hasMaxConnAttributes(attributes []string) bool {
 	amount := p.getAttribute(label.SuffixBackendMaxConnAmount, attributes, "")
-	extractorfunc := p.getAttribute(label.SuffixBackendMaxConnExtractorFunc, attributes, "")
+	extractorFunc := p.getAttribute(label.SuffixBackendMaxConnExtractorFunc, attributes, "")
-	return amount != "" && extractorfunc != ""
+	return amount != "" && extractorFunc != ""
 }
 
+// Deprecated
 func getEntryPoints(list string) []string {
 	return strings.Split(list, ",")
 }
@@ -146,7 +149,8 @@ func getBackendName(node *api.ServiceEntry, index int) string {
 }
 
 // TODO: Deprecated
-// Deprecated replaced by Stickiness
+// replaced by Stickiness
+// Deprecated
 func (p *CatalogProvider) getSticky(tags []string) string {
 	stickyTag := p.getAttribute(label.SuffixBackendLoadBalancerSticky, tags, "")
 	if len(stickyTag) > 0 {
@@ -165,3 +169,77 @@ func (p *CatalogProvider) hasStickinessLabel(tags []string) bool {
 func (p *CatalogProvider) getStickinessCookieName(tags []string) string {
 	return p.getAttribute(label.SuffixBackendLoadBalancerStickinessCookieName, tags, "")
 }
+
+// Base functions
+
+func (p *CatalogProvider) getSliceAttribute(name string, tags []string) []string {
+	rawValue := getTag(p.getPrefixedName(name), tags, "")
+
+	if len(rawValue) == 0 {
+		return nil
+	}
+	return label.SplitAndTrimString(rawValue, ",")
+}
+
+func (p *CatalogProvider) getBoolAttribute(name string, tags []string, defaultValue bool) bool {
+	rawValue := getTag(p.getPrefixedName(name), tags, "")
+
+	if len(rawValue) == 0 {
+		return defaultValue
+	}
+
+	value, err := strconv.ParseBool(rawValue)
+	if err != nil {
+		log.Errorf("Invalid value for %s: %s", name, rawValue)
+		return defaultValue
+	}
+	return value
+}
+
+func (p *CatalogProvider) getAttribute(name string, tags []string, defaultValue string) string {
+	return getTag(p.getPrefixedName(name), tags, defaultValue)
+}
+
+func (p *CatalogProvider) getPrefixedName(name string) string {
+	if len(p.Prefix) > 0 && len(name) > 0 {
+		return p.Prefix + "." + name
+	}
+	return name
+}
+
+func hasTag(name string, tags []string) bool {
+	lowerName := strings.ToLower(name)
+
+	for _, tag := range tags {
+		lowerTag := strings.ToLower(tag)
+
+		// Given the nature of Consul tags, which could be either singular markers, or key=value pairs
+		if strings.HasPrefix(lowerTag, lowerName+"=") || lowerTag == lowerName {
+			return true
+		}
+	}
+	return false
+}
+
+func getTag(name string, tags []string, defaultValue string) string {
+	lowerName := strings.ToLower(name)
+
+	for _, tag := range tags {
+		lowerTag := strings.ToLower(tag)
+
+		// Given the nature of Consul tags, which could be either singular markers, or key=value pairs
+		if strings.HasPrefix(lowerTag, lowerName+"=") || lowerTag == lowerName {
+			// In case, where a tag might be a key=value, try to split it by the first '='
+			kv := strings.SplitN(tag, "=", 2)
+
+			// If the returned result is a key=value pair, return the 'value' component
+			if len(kv) == 2 {
+				return kv[1]
+			}
+			// If the returned result is a singular marker, return the 'key' component
+			return kv[0]
+		}
+
+	}
+	return defaultValue
+}

provider/consul/consul_catalog_config_test.go

@@ -0,0 +1,571 @@
+package consul
+
+import (
+	"testing"
+	"text/template"
+
+	"github.com/containous/traefik/provider/label"
+	"github.com/containous/traefik/types"
+	"github.com/hashicorp/consul/api"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBuildConfiguration(t *testing.T) {
+	provider := &CatalogProvider{
+		Domain:               "localhost",
+		Prefix:               "traefik",
+		ExposedByDefault:     false,
+		FrontEndRule:         "Host:{{.ServiceName}}.{{.Domain}}",
+		frontEndRuleTemplate: template.New("consul catalog frontend rule"),
+	}
+
+	testCases := []struct {
+		desc              string
+		nodes             []catalogUpdate
+		expectedFrontends map[string]*types.Frontend
+		expectedBackends  map[string]*types.Backend
+	}{
+		{
+			desc:              "Should build config of nothing",
+			nodes:             []catalogUpdate{},
+			expectedFrontends: map[string]*types.Frontend{},
+			expectedBackends:  map[string]*types.Backend{},
+		},
+		{
+			desc: "Should build config with no frontend and backend",
+			nodes: []catalogUpdate{
+				{
+					Service: &serviceUpdate{
+						ServiceName: "test",
+					},
+				},
+			},
+			expectedFrontends: map[string]*types.Frontend{},
+			expectedBackends:  map[string]*types.Backend{},
+		},
+		{
+			desc: "Should build config who contains one frontend and one backend",
+			nodes: []catalogUpdate{
+				{
+					Service: &serviceUpdate{
+						ServiceName: "test",
+						Attributes: []string{
+							"traefik.backend.loadbalancer=drr",
+							"traefik.backend.circuitbreaker=NetworkErrorRatio() > 0.5",
+							"random.foo=bar",
+							"traefik.backend.maxconn.amount=1000",
+							"traefik.backend.maxconn.extractorfunc=client.ip",
+							"traefik.frontend.auth.basic=test:$apr1$H6uskkkW$IgXLP6ewTrSuBkTrqE8wj/,test2:$apr1$d9hr9HBB$4HxwgUir3HP4EsggP/QNo0",
+						},
+					},
+					Nodes: []*api.ServiceEntry{
+						{
+							Service: &api.AgentService{
+								Service: "test",
+								Address: "127.0.0.1",
+								Port:    80,
+								Tags: []string{
+									"traefik.backend.weight=42",
+									"random.foo=bar",
+									"traefik.backend.passHostHeader=true",
+									"traefik.protocol=https",
+								},
+							},
+							Node: &api.Node{
+								Node:    "localhost",
+								Address: "127.0.0.1",
+							},
+						},
+					},
+				},
+			},
+			expectedFrontends: map[string]*types.Frontend{
+				"frontend-test": {
+					Backend:        "backend-test",
+					PassHostHeader: true,
+					Routes: map[string]types.Route{
+						"route-host-test": {
+							Rule: "Host:test.localhost",
+						},
+					},
+					BasicAuth: []string{"test:$apr1$H6uskkkW$IgXLP6ewTrSuBkTrqE8wj/", "test2:$apr1$d9hr9HBB$4HxwgUir3HP4EsggP/QNo0"},
+				},
+			},
+			expectedBackends: map[string]*types.Backend{
+				"backend-test": {
+					Servers: map[string]types.Server{
+						"test--127-0-0-1--80--traefik-backend-weight-42--random-foo-bar--traefik-backend-passHostHeader-true--traefik-protocol-https--0": {
+							URL:    "https://127.0.0.1:80",
+							Weight: 42,
+						},
+					},
+					CircuitBreaker: &types.CircuitBreaker{
+						Expression: "NetworkErrorRatio() > 0.5",
+					},
+					LoadBalancer: &types.LoadBalancer{
+						Method: "drr",
+					},
+					MaxConn: &types.MaxConn{
+						Amount:        1000,
+						ExtractorFunc: "client.ip",
+					},
+				},
+			},
+		},
+	}
+
+	for _, test := range testCases {
+		test := test
+		t.Run(test.desc, func(t *testing.T) {
+			t.Parallel()
+
+			actualConfig := provider.buildConfiguration(test.nodes)
+			assert.NotNil(t, actualConfig)
+			assert.Equal(t, test.expectedBackends, actualConfig.Backends)
+			assert.Equal(t, test.expectedFrontends, actualConfig.Frontends)
+		})
+	}
+}
+
+func TestGetTag(t *testing.T) {
+	testCases := []struct {
+		desc         string
+		tags         []string
+		key          string
+		defaultValue string
+		expected     string
+	}{
+		{
+			desc: "Should return value of foo.bar key",
+			tags: []string{
+				"foo.bar=random",
+				"traefik.backend.weight=42",
+				"management",
+			},
+			key:          "foo.bar",
+			defaultValue: "0",
+			expected:     "random",
+		},
+		{
+			desc: "Should return default value when nonexistent key",
+			tags: []string{
+				"foo.bar.foo.bar=random",
+				"traefik.backend.weight=42",
+				"management",
+			},
+			key:          "foo.bar",
+			defaultValue: "0",
+			expected:     "0",
+		},
+	}
+
+	for _, test := range testCases {
+		test := test
+		t.Run(test.desc, func(t *testing.T) {
+			t.Parallel()
+
+			actual := getTag(test.key, test.tags, test.defaultValue)
+			assert.Equal(t, test.expected, actual)
+		})
+	}
+}
+
+func TestHasTag(t *testing.T) {
+	testCases := []struct {
+		desc     string
+		name     string
+		tags     []string
+		expected bool
+	}{
+		{
+			desc:     "tag without value",
+			name:     "foo",
+			tags:     []string{"foo"},
+			expected: true,
+		},
+		{
+			desc:     "tag with value",
+			name:     "foo",
+			tags:     []string{"foo=true"},
+			expected: true,
+		},
+		{
+			desc:     "missing tag",
+			name:     "foo",
+			tags:     []string{"foobar=true"},
+			expected: false,
+		},
+	}
+
+	for _, test := range testCases {
+		test := test
+		t.Run(test.desc, func(t *testing.T) {
+			t.Parallel()
+
+			actual := hasTag(test.name, test.tags)
+			assert.Equal(t, test.expected, actual)
+		})
+	}
+}
+
+func TestGetPrefixedName(t *testing.T) {
+	testCases := []struct {
+		desc     string
+		name     string
+		prefix   string
+		expected string
+	}{
+		{
+			desc:     "empty name with prefix",
+			name:     "",
+			prefix:   "foo",
+			expected: "",
+		},
+		{
+			desc:     "empty name without prefix",
+			name:     "",
+			prefix:   "",
+			expected: "",
+		},
+		{
+			desc:     "with prefix",
+			name:     "bar",
+			prefix:   "foo",
+			expected: "foo.bar",
+		},
+		{
+			desc:     "without prefix",
+			name:     "bar",
+			prefix:   "",
+			expected: "bar",
+		},
+	}
+
+	for _, test := range testCases {
+		test := test
+		t.Run(test.desc, func(t *testing.T) {
+			t.Parallel()
+
+			pro := &CatalogProvider{Prefix: test.prefix}
+
+			actual := pro.getPrefixedName(test.name)
+			assert.Equal(t, test.expected, actual)
+		})
+	}
+
+}
+
+func TestGetAttribute(t *testing.T) {
+	testCases := []struct {
+		desc         string
+		tags         []string
+		key          string
+		defaultValue string
+		prefix       string
+		expected     string
+	}{
+		{
+			desc:   "Should return tag value 42",
+			prefix: "traefik",
+			tags: []string{
+				"foo.bar=ramdom",
+				"traefik.backend.weight=42",
+			},
+			key:          "backend.weight",
+			defaultValue: "0",
+			expected:     "42",
+		},
+		{
+			desc:   "Should return tag default value 0",
+			prefix: "traefik",
+			tags: []string{
+				"foo.bar=ramdom",
+				"traefik.backend.wei=42",
+			},
+			key:          "backend.weight",
+			defaultValue: "0",
+			expected:     "0",
+		},
+		{
+			desc: "Should return tag value 42 when empty prefix",
+			tags: []string{
+				"foo.bar=ramdom",
+				"backend.weight=42",
+			},
+			key:          "backend.weight",
+			defaultValue: "0",
+			expected:     "42",
+		},
+		{
+			desc: "Should return default value 0 when empty prefix",
+			tags: []string{
+				"foo.bar=ramdom",
+				"backend.wei=42",
+			},
+			key:          "backend.weight",
+			defaultValue: "0",
+			expected:     "0",
+		},
+		{
+			desc: "Should return for.bar key value random when empty prefix",
+			tags: []string{
+				"foo.bar=ramdom",
+				"backend.wei=42",
+			},
+			key:          "foo.bar",
+			defaultValue: "random",
+			expected:     "ramdom",
+		},
+	}
+
+	for _, test := range testCases {
+		test := test
+		t.Run(test.desc, func(t *testing.T) {
+			t.Parallel()
+
+			p := &CatalogProvider{
+				Domain: "localhost",
+				Prefix: test.prefix,
+			}
+
+			actual := p.getAttribute(test.key, test.tags, test.defaultValue)
+			assert.Equal(t, test.expected, actual)
+		})
+	}
+}
+
+func TestGetFrontendRule(t *testing.T) {
+	testCases := []struct {
+		desc     string
+		service  serviceUpdate
+		expected string
+	}{
+		{
+			desc: "Should return default host foo.localhost",
+			service: serviceUpdate{
+				ServiceName: "foo",
+				Attributes:  []string{},
+			},
+			expected: "Host:foo.localhost",
+		},
+		{
+			desc: "Should return host *.example.com",
+			service: serviceUpdate{
+				ServiceName: "foo",
+				Attributes: []string{
+					"traefik.frontend.rule=Host:*.example.com",
+				},
+			},
+			expected: "Host:*.example.com",
+		},
+		{
+			desc: "Should return host foo.example.com",
+			service: serviceUpdate{
+				ServiceName: "foo",
+				Attributes: []string{
+					"traefik.frontend.rule=Host:{{.ServiceName}}.example.com",
+				},
+			},
+			expected: "Host:foo.example.com",
+		},
+		{
+			desc: "Should return path prefix /bar",
+			service: serviceUpdate{
+				ServiceName: "foo",
+				Attributes: []string{
+					"traefik.frontend.rule=PathPrefix:{{getTag \"contextPath\" .Attributes \"/\"}}",
+					"contextPath=/bar",
+				},
+			},
+			expected: "PathPrefix:/bar",
+		},
+	}
+
+	for _, test := range testCases {
+		test := test
+		t.Run(test.desc, func(t *testing.T) {
+			t.Parallel()
+
+			provider := &CatalogProvider{
+				Domain:               "localhost",
+				Prefix:               "traefik",
+				FrontEndRule:         "Host:{{.ServiceName}}.{{.Domain}}",
+				frontEndRuleTemplate: template.New("consul catalog frontend rule"),
+			}
+			provider.setupFrontEndRuleTemplate()
+
+			actual := provider.getFrontendRule(test.service)
+			assert.Equal(t, test.expected, actual)
+		})
+	}
+}
+
+func TestGetBackendAddress(t *testing.T) {
+	testCases := []struct {
+		desc     string
+		node     *api.ServiceEntry
+		expected string
+	}{
+		{
+			desc: "Should return the address of the service",
+			node: &api.ServiceEntry{
+				Node: &api.Node{
+					Address: "10.1.0.1",
+				},
+				Service: &api.AgentService{
+					Address: "10.2.0.1",
+				},
+			},
+			expected: "10.2.0.1",
+		},
+		{
+			desc: "Should return the address of the node",
+			node: &api.ServiceEntry{
+				Node: &api.Node{
+					Address: "10.1.0.1",
+				},
+				Service: &api.AgentService{
+					Address: "",
+				},
+			},
+			expected: "10.1.0.1",
+		},
+	}
+
+	for _, test := range testCases {
+		test := test
+		t.Run(test.desc, func(t *testing.T) {
+			t.Parallel()
+
+			actual := getBackendAddress(test.node)
+			assert.Equal(t, test.expected, actual)
+		})
+	}
+}
+
+func TestGetBackendName(t *testing.T) {
+	testCases := []struct {
+		desc     string
+		node     *api.ServiceEntry
+		expected string
+	}{
+		{
+			desc: "Should create backend name without tags",
+			node: &api.ServiceEntry{
+				Service: &api.AgentService{
+					Service: "api",
+					Address: "10.0.0.1",
+					Port:    80,
+					Tags:    []string{},
+				},
+			},
+			expected: "api--10-0-0-1--80--0",
+		},
+		{
+			desc: "Should create backend name with multiple tags",
+			node: &api.ServiceEntry{
+				Service: &api.AgentService{
+					Service: "api",
+					Address: "10.0.0.1",
+					Port:    80,
+					Tags:    []string{"traefik.weight=42", "traefik.enable=true"},
+				},
+			},
+			expected: "api--10-0-0-1--80--traefik-weight-42--traefik-enable-true--1",
+		},
+		{
+			desc: "Should create backend name with one tag",
+			node: &api.ServiceEntry{
+				Service: &api.AgentService{
+					Service: "api",
+					Address: "10.0.0.1",
+					Port:    80,
+					Tags:    []string{"a funny looking tag"},
+				},
+			},
+			expected: "api--10-0-0-1--80--a-funny-looking-tag--2",
+		},
+	}
+
+	for i, test := range testCases {
+		test := test
+		i := i
+		t.Run(test.desc, func(t *testing.T) {
+			t.Parallel()
+
+			actual := getBackendName(test.node, i)
+			assert.Equal(t, test.expected, actual)
+		})
+	}
+}
+
+func TestGetBasicAuth(t *testing.T) {
+	testCases := []struct {
+		desc     string
+		tags     []string
+		expected []string
+	}{
+		{
+			desc:     "label missing",
+			tags:     []string{},
+			expected: []string{},
+		},
+		{
+			desc: "label existing",
+			tags: []string{
+				"traefik.frontend.auth.basic=user:password",
+			},
+			expected: []string{"user:password"},
+		},
+	}
+
+	for _, test := range testCases {
+		test := test
+		t.Run(test.desc, func(t *testing.T) {
+			t.Parallel()
+			provider := &CatalogProvider{
+				Prefix: "traefik",
+			}
+			actual := provider.getBasicAuth(test.tags)
+			assert.Equal(t, test.expected, actual)
+		})
+	}
+}
+
+func TestHasStickinessLabel(t *testing.T) {
+	testCases := []struct {
+		desc     string
+		tags     []string
+		expected bool
+	}{
+		{
+			desc:     "label missing",
+			tags:     []string{},
+			expected: false,
+		},
+		{
+			desc: "stickiness=true",
+			tags: []string{
+				label.TraefikBackendLoadBalancerStickiness + "=true",
+			},
+			expected: true,
+		},
+		{
+			desc: "stickiness=false",
+			tags: []string{
+				label.TraefikBackendLoadBalancerStickiness + "=false",
+			},
+			expected: false,
+		},
+	}
+
+	for _, test := range testCases {
+		test := test
+		t.Run(test.desc, func(t *testing.T) {
+			t.Parallel()
+
+			actual := hasStickinessLabel(test.tags)
+			assert.Equal(t, test.expected, actual)
+		})
+	}
+}

provider/consul/consul_catalog_test.go

@@ -3,527 +3,12 @@ package consul
 import (
 	"sort"
 	"testing"
-	"text/template"
 
 	"github.com/BurntSushi/ty/fun"
-	"github.com/containous/traefik/provider/label"
-	"github.com/containous/traefik/types"
 	"github.com/hashicorp/consul/api"
 	"github.com/stretchr/testify/assert"
 )
 
-func TestGetPrefixedName(t *testing.T) {
-	testCases := []struct {
-		desc     string
-		name     string
-		prefix   string
-		expected string
-	}{
-		{
-			desc:     "empty name with prefix",
-			name:     "",
-			prefix:   "foo",
-			expected: "",
-		},
-		{
-			desc:     "empty name without prefix",
-			name:     "",
-			prefix:   "",
-			expected: "",
-		},
-		{
-			desc:     "with prefix",
-			name:     "bar",
-			prefix:   "foo",
-			expected: "foo.bar",
-		},
-		{
-			desc:     "without prefix",
-			name:     "bar",
-			prefix:   "",
-			expected: "bar",
-		},
-	}
-
-	for _, test := range testCases {
-		test := test
-		t.Run(test.desc, func(t *testing.T) {
-			t.Parallel()
-
-			pro := &CatalogProvider{Prefix: test.prefix}
-
-			actual := pro.getPrefixedName(test.name)
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-
-}
-
-func TestGetFrontendRule(t *testing.T) {
-
-	testCases := []struct {
-		desc     string
-		service  serviceUpdate
-		expected string
-	}{
-		{
-			desc: "Should return default host foo.localhost",
-			service: serviceUpdate{
-				ServiceName: "foo",
-				Attributes:  []string{},
-			},
-			expected: "Host:foo.localhost",
-		},
-		{
-			desc: "Should return host *.example.com",
-			service: serviceUpdate{
-				ServiceName: "foo",
-				Attributes: []string{
-					"traefik.frontend.rule=Host:*.example.com",
-				},
-			},
-			expected: "Host:*.example.com",
-		},
-		{
-			desc: "Should return host foo.example.com",
-			service: serviceUpdate{
-				ServiceName: "foo",
-				Attributes: []string{
-					"traefik.frontend.rule=Host:{{.ServiceName}}.example.com",
-				},
-			},
-			expected: "Host:foo.example.com",
-		},
-		{
-			desc: "Should return path prefix /bar",
-			service: serviceUpdate{
-				ServiceName: "foo",
-				Attributes: []string{
-					"traefik.frontend.rule=PathPrefix:{{getTag \"contextPath\" .Attributes \"/\"}}",
-					"contextPath=/bar",
-				},
-			},
-			expected: "PathPrefix:/bar",
-		},
-	}
-
-	for _, test := range testCases {
-		test := test
-		t.Run(test.desc, func(t *testing.T) {
-			t.Parallel()
-
-			provider := &CatalogProvider{
-				Domain:               "localhost",
-				Prefix:               "traefik",
-				FrontEndRule:         "Host:{{.ServiceName}}.{{.Domain}}",
-				frontEndRuleTemplate: template.New("consul catalog frontend rule"),
-			}
-			provider.setupFrontEndTemplate()
-
-			actual := provider.getFrontendRule(test.service)
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-}
-
-func TestGetTag(t *testing.T) {
-	testCases := []struct {
-		desc         string
-		tags         []string
-		key          string
-		defaultValue string
-		expected     string
-	}{
-		{
-			desc: "Should return value of foo.bar key",
-			tags: []string{
-				"foo.bar=random",
-				"traefik.backend.weight=42",
-				"management",
-			},
-			key:          "foo.bar",
-			defaultValue: "0",
-			expected:     "random",
-		},
-		{
-			desc: "Should return default value when nonexistent key",
-			tags: []string{
-				"foo.bar.foo.bar=random",
-				"traefik.backend.weight=42",
-				"management",
-			},
-			key:          "foo.bar",
-			defaultValue: "0",
-			expected:     "0",
-		},
-	}
-
-	for _, test := range testCases {
-		test := test
-		t.Run(test.desc, func(t *testing.T) {
-			t.Parallel()
-
-			actual := getTag(test.key, test.tags, test.defaultValue)
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-}
-
-func TestHasTag(t *testing.T) {
-	testCases := []struct {
-		desc     string
-		name     string
-		tags     []string
-		expected bool
-	}{
-		{
-			desc:     "tag without value",
-			name:     "foo",
-			tags:     []string{"foo"},
-			expected: true,
-		},
-		{
-			desc:     "tag with value",
-			name:     "foo",
-			tags:     []string{"foo=true"},
-			expected: true,
-		},
-		{
-			desc:     "missing tag",
-			name:     "foo",
-			tags:     []string{"foobar=true"},
-			expected: false,
-		},
-	}
-
-	for _, test := range testCases {
-		test := test
-		t.Run(test.desc, func(t *testing.T) {
-			t.Parallel()
-
-			actual := hasTag(test.name, test.tags)
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-}
-
-func TestGetAttribute(t *testing.T) {
-	provider := &CatalogProvider{
-		Domain: "localhost",
-		Prefix: "traefik",
-	}
-
-	testCases := []struct {
-		desc         string
-		tags         []string
-		key          string
-		defaultValue string
-		expected     string
-	}{
-		{
-			desc: "Should return tag value 42",
-			tags: []string{
-				"foo.bar=ramdom",
-				"traefik.backend.weight=42",
-			},
-			key:          "backend.weight",
-			defaultValue: "0",
-			expected:     "42",
-		},
-		{
-			desc: "Should return tag default value 0",
-			tags: []string{
-				"foo.bar=ramdom",
-				"traefik.backend.wei=42",
-			},
-			key:          "backend.weight",
-			defaultValue: "0",
-			expected:     "0",
-		},
-	}
-
-	for _, test := range testCases {
-		test := test
-		t.Run(test.desc, func(t *testing.T) {
-			t.Parallel()
-
-			actual := provider.getAttribute(test.key, test.tags, test.defaultValue)
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-}
-
-func TestGetAttributeWithEmptyPrefix(t *testing.T) {
-	provider := &CatalogProvider{
-		Domain: "localhost",
-		Prefix: "",
-	}
-
-	testCases := []struct {
-		desc         string
-		tags         []string
-		key          string
-		defaultValue string
-		expected     string
-	}{
-		{
-			desc: "Should return tag value 42",
-			tags: []string{
-				"foo.bar=ramdom",
-				"backend.weight=42",
-			},
-			key:          "backend.weight",
-			defaultValue: "0",
-			expected:     "42",
-		},
-		{
-			desc: "Should return default value 0",
-			tags: []string{
-				"foo.bar=ramdom",
-				"backend.wei=42",
-			},
-			key:          "backend.weight",
-			defaultValue: "0",
-			expected:     "0",
-		},
-		{
-			desc: "Should return for.bar key value random",
-			tags: []string{
-				"foo.bar=ramdom",
-				"backend.wei=42",
-			},
-			key:          "foo.bar",
-			defaultValue: "random",
-			expected:     "ramdom",
-		},
-	}
-
-	for _, test := range testCases {
-		test := test
-		t.Run(test.desc, func(t *testing.T) {
-			t.Parallel()
-
-			actual := provider.getAttribute(test.key, test.tags, test.defaultValue)
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-}
-
-func TestGetBackendAddress(t *testing.T) {
-	testCases := []struct {
-		desc     string
-		node     *api.ServiceEntry
-		expected string
-	}{
-		{
-			desc: "Should return the address of the service",
-			node: &api.ServiceEntry{
-				Node: &api.Node{
-					Address: "10.1.0.1",
-				},
-				Service: &api.AgentService{
-					Address: "10.2.0.1",
-				},
-			},
-			expected: "10.2.0.1",
-		},
-		{
-			desc: "Should return the address of the node",
-			node: &api.ServiceEntry{
-				Node: &api.Node{
-					Address: "10.1.0.1",
-				},
-				Service: &api.AgentService{
-					Address: "",
-				},
-			},
-			expected: "10.1.0.1",
-		},
-	}
-
-	for _, test := range testCases {
-		test := test
-		t.Run(test.desc, func(t *testing.T) {
-			t.Parallel()
-
-			actual := getBackendAddress(test.node)
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-}
-
-func TestGetBackendName(t *testing.T) {
-	testCases := []struct {
-		desc     string
-		node     *api.ServiceEntry
-		expected string
-	}{
-		{
-			desc: "Should create backend name without tags",
-			node: &api.ServiceEntry{
-				Service: &api.AgentService{
-					Service: "api",
-					Address: "10.0.0.1",
-					Port:    80,
-					Tags:    []string{},
-				},
-			},
-			expected: "api--10-0-0-1--80--0",
-		},
-		{
-			desc: "Should create backend name with multiple tags",
-			node: &api.ServiceEntry{
-				Service: &api.AgentService{
-					Service: "api",
-					Address: "10.0.0.1",
-					Port:    80,
-					Tags:    []string{"traefik.weight=42", "traefik.enable=true"},
-				},
-			},
-			expected: "api--10-0-0-1--80--traefik-weight-42--traefik-enable-true--1",
-		},
-		{
-			desc: "Should create backend name with one tag",
-			node: &api.ServiceEntry{
-				Service: &api.AgentService{
-					Service: "api",
-					Address: "10.0.0.1",
-					Port:    80,
-					Tags:    []string{"a funny looking tag"},
-				},
-			},
-			expected: "api--10-0-0-1--80--a-funny-looking-tag--2",
-		},
-	}
-
-	for i, test := range testCases {
-		test := test
-		i := i
-		t.Run(test.desc, func(t *testing.T) {
-			t.Parallel()
-
-			actual := getBackendName(test.node, i)
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-}
-
-func TestBuildConfiguration(t *testing.T) {
-	provider := &CatalogProvider{
-		Domain:               "localhost",
-		Prefix:               "traefik",
-		ExposedByDefault:     false,
-		FrontEndRule:         "Host:{{.ServiceName}}.{{.Domain}}",
-		frontEndRuleTemplate: template.New("consul catalog frontend rule"),
-	}
-
-	testCases := []struct {
-		desc              string
-		nodes             []catalogUpdate
-		expectedFrontends map[string]*types.Frontend
-		expectedBackends  map[string]*types.Backend
-	}{
-		{
-			desc:              "Should build config of nothing",
-			nodes:             []catalogUpdate{},
-			expectedFrontends: map[string]*types.Frontend{},
-			expectedBackends:  map[string]*types.Backend{},
-		},
-		{
-			desc: "Should build config with no frontend and backend",
-			nodes: []catalogUpdate{
-				{
-					Service: &serviceUpdate{
-						ServiceName: "test",
-					},
-				},
-			},
-			expectedFrontends: map[string]*types.Frontend{},
-			expectedBackends:  map[string]*types.Backend{},
-		},
-		{
-			desc: "Should build config who contains one frontend and one backend",
-			nodes: []catalogUpdate{
-				{
-					Service: &serviceUpdate{
-						ServiceName: "test",
-						Attributes: []string{
-							"traefik.backend.loadbalancer=drr",
-							"traefik.backend.circuitbreaker=NetworkErrorRatio() > 0.5",
-							"random.foo=bar",
-							"traefik.backend.maxconn.amount=1000",
-							"traefik.backend.maxconn.extractorfunc=client.ip",
-							"traefik.frontend.auth.basic=test:$apr1$H6uskkkW$IgXLP6ewTrSuBkTrqE8wj/,test2:$apr1$d9hr9HBB$4HxwgUir3HP4EsggP/QNo0",
-						},
-					},
-					Nodes: []*api.ServiceEntry{
-						{
-							Service: &api.AgentService{
-								Service: "test",
-								Address: "127.0.0.1",
-								Port:    80,
-								Tags: []string{
-									"traefik.backend.weight=42",
-									"random.foo=bar",
-									"traefik.backend.passHostHeader=true",
-									"traefik.protocol=https",
-								},
-							},
-							Node: &api.Node{
-								Node:    "localhost",
-								Address: "127.0.0.1",
-							},
-						},
-					},
-				},
-			},
-			expectedFrontends: map[string]*types.Frontend{
-				"frontend-test": {
-					Backend:        "backend-test",
-					PassHostHeader: true,
-					Routes: map[string]types.Route{
-						"route-host-test": {
-							Rule: "Host:test.localhost",
-						},
-					},
-					BasicAuth: []string{"test:$apr1$H6uskkkW$IgXLP6ewTrSuBkTrqE8wj/", "test2:$apr1$d9hr9HBB$4HxwgUir3HP4EsggP/QNo0"},
-				},
-			},
-			expectedBackends: map[string]*types.Backend{
-				"backend-test": {
-					Servers: map[string]types.Server{
-						"test--127-0-0-1--80--traefik-backend-weight-42--random-foo-bar--traefik-backend-passHostHeader-true--traefik-protocol-https--0": {
-							URL:    "https://127.0.0.1:80",
-							Weight: 42,
-						},
-					},
-					CircuitBreaker: &types.CircuitBreaker{
-						Expression: "NetworkErrorRatio() > 0.5",
-					},
-					LoadBalancer: &types.LoadBalancer{
-						Method: "drr",
-					},
-					MaxConn: &types.MaxConn{
-						Amount:        1000,
-						ExtractorFunc: "client.ip",
-					},
-				},
-			},
-		},
-	}
-
-	for _, test := range testCases {
-		test := test
-		t.Run(test.desc, func(t *testing.T) {
-			t.Parallel()
-
-			actualConfig := provider.buildConfiguration(test.nodes)
-			assert.Equal(t, test.expectedBackends, actualConfig.Backends)
-			assert.Equal(t, test.expectedFrontends, actualConfig.Frontends)
-		})
-	}
-}
-
 func TestNodeSorter(t *testing.T) {
 	testCases := []struct {
 		desc     string
@@ -972,81 +457,6 @@ func TestFilterEnabled(t *testing.T) {
 	}
 }
 
-func TestGetBasicAuth(t *testing.T) {
-	testCases := []struct {
-		desc     string
-		tags     []string
-		expected []string
-	}{
-		{
-			desc:     "label missing",
-			tags:     []string{},
-			expected: []string{},
-		},
-		{
-			desc: "label existing",
-			tags: []string{
-				"traefik.frontend.auth.basic=user:password",
-			},
-			expected: []string{"user:password"},
-		},
-	}
-
-	for _, test := range testCases {
-		test := test
-		t.Run(test.desc, func(t *testing.T) {
-			t.Parallel()
-			provider := &CatalogProvider{
-				Prefix: "traefik",
-			}
-			actual := provider.getBasicAuth(test.tags)
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-}
-
-func TestHasStickinessLabel(t *testing.T) {
-	p := &CatalogProvider{
-		Prefix: "traefik",
-	}
-
-	testCases := []struct {
-		desc     string
-		tags     []string
-		expected bool
-	}{
-		{
-			desc:     "label missing",
-			tags:     []string{},
-			expected: false,
-		},
-		{
-			desc: "stickiness=true",
-			tags: []string{
-				label.TraefikBackendLoadBalancerStickiness + "=true",
-			},
-			expected: true,
-		},
-		{
-			desc: "stickiness=false",
-			tags: []string{
-				label.TraefikBackendLoadBalancerStickiness + "=false",
-			},
-			expected: false,
-		},
-	}
-
-	for _, test := range testCases {
-		test := test
-		t.Run(test.desc, func(t *testing.T) {
-			t.Parallel()
-
-			actual := p.hasStickinessLabel(test.tags)
-			assert.Equal(t, test.expected, actual)
-		})
-	}
-}
-
 func TestGetChangedStringKeys(t *testing.T) {
 	testCases := []struct {
 		desc            string
@@ -1096,7 +506,7 @@ func TestGetChangedStringKeys(t *testing.T) {
 	}
 }
 
-func TestHasNodeOrTagschanged(t *testing.T) {
+func TestHasServiceChanged(t *testing.T) {
 	testCases := []struct {
 		desc     string
 		current  map[string]Service