add some unit tests

fmt & lint

provider/rancher.go

@@ -146,7 +146,7 @@ func (provider *Rancher) getDomain(service rancherData) string {
 	if label, err := getServiceLabel(service, "traefik.domain"); err == nil {
 		return label
 	}
-	return ""
+	return provider.Domain
 }
 
 func (provider *Rancher) hasMaxConnLabels(service rancherData) bool {
@@ -178,16 +178,6 @@ func (provider *Rancher) getMaxConnExtractorFunc(service rancherData) string {
 	return "request.host"
 }
 
-// Container Stuff
-func (provider *Rancher) getIPAddress(container *rancher.Container) string {
-	ipAdress := container.PrimaryIpAddress
-
-	if ipAdress != "" {
-		return ipAdress
-	}
-	return ""
-}
-
 func getServiceLabel(service rancherData, label string) (string, error) {
 	for key, value := range service.Labels {
 		if key == label {
@@ -362,7 +352,6 @@ func parseRancherData(environments []*rancher.Environment, services []*rancher.S
 func (provider *Rancher) loadRancherConfig(services []rancherData) *types.Configuration {
 
 	var RancherFuncMap = template.FuncMap{
-		"getIPAddress":                provider.getIPAddress,
 		"getPort":                     provider.getPort,
 		"getBackend":                  provider.getBackend,
 		"getWeight":                   provider.getWeight,
@@ -427,23 +416,11 @@ func (provider *Rancher) serviceFilter(service rancherData) bool {
 		return false
 	}
 
-	/*
-		constraintTags := strings.Split(container.Labels["traefik.tags"], ",")
-		if ok, failingConstraint := provider.MatchConstraints(constraintTags); !ok {
-			if failingConstraint != nil {
-				log.Debugf("Container %v pruned by '%v' constraint", container.Name, failingConstraint.String())
-			}
-			return false
-		}
-	*/
-
 	if service.Health != "" && service.Health != "healthy" {
 		log.Debugf("Filtering unhealthy or starting service %s", service.Name)
 		return false
 	}
 
-	log.Debugf("Service %s is enabled!", service.Name)
-
 	return true
 }
 
@@ -453,5 +430,5 @@ func isServiceEnabled(service rancherData, exposedByDefault bool) bool {
 		var v = service.Labels["traefik.enable"]
 		return exposedByDefault && v != "false" || v == "true"
 	}
-	return false
+	return exposedByDefault
 }

provider/rancher_test.go

@@ -0,0 +1,448 @@
+package provider
+
+import (
+	"github.com/containous/traefik/types"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+func TestRancherGetFrontendName(t *testing.T) {
+	provider := &Rancher{
+		Domain: "rancher.localhost",
+	}
+
+	services := []struct {
+		service  rancherData
+		expected string
+	}{
+		{
+			service: rancherData{
+				Name: "foo",
+			},
+			expected: "Host-foo-rancher-localhost",
+		},
+		{
+			service: rancherData{
+				Name: "test-service",
+				Labels: map[string]string{
+					"traefik.frontend.rule": "Headers:User-Agent,bat/0.1.0",
+				},
+			},
+
+			expected: "Headers-User-Agent-bat-0-1-0",
+		},
+		{
+			service: rancherData{
+				Name: "test-service",
+				Labels: map[string]string{
+					"traefik.frontend.rule": "Host:foo.bar",
+				},
+			},
+
+			expected: "Host-foo-bar",
+		},
+		{
+			service: rancherData{
+				Name: "test-service",
+				Labels: map[string]string{
+					"traefik.frontend.rule": "Path:/test",
+				},
+			},
+
+			expected: "Path-test",
+		},
+		{
+			service: rancherData{
+				Name: "test-service",
+				Labels: map[string]string{
+					"traefik.frontend.rule": "PathPrefix:/test2",
+				},
+			},
+
+			expected: "PathPrefix-test2",
+		},
+	}
+
+	for _, e := range services {
+		actual := provider.getFrontendName(e.service)
+		if actual != e.expected {
+			t.Fatalf("expected %q, got %q", e.expected, actual)
+		}
+	}
+}
+
+func TestRancherGetFrontendRule(t *testing.T) {
+	provider := &Rancher{
+		Domain: "rancher.localhost",
+	}
+
+	services := []struct {
+		service  rancherData
+		expected string
+	}{
+		{
+			service: rancherData{
+				Name: "foo",
+			},
+			expected: "Host:foo.rancher.localhost",
+		},
+		{
+			service: rancherData{
+				Name: "test-service",
+				Labels: map[string]string{
+					"traefik.frontend.rule": "Host:foo.bar.com",
+				},
+			},
+
+			expected: "Host:foo.bar.com",
+		},
+		{
+			service: rancherData{
+				Name: "test-service",
+				Labels: map[string]string{
+					"traefik.frontend.rule": "Path:/test",
+				},
+			},
+
+			expected: "Path:/test",
+		},
+		{
+			service: rancherData{
+				Name: "test-service",
+				Labels: map[string]string{
+					"traefik.frontend.rule": "PathPrefix:/test2",
+				},
+			},
+
+			expected: "PathPrefix:/test2",
+		},
+	}
+
+	for _, e := range services {
+		actual := provider.getFrontendRule(e.service)
+		if actual != e.expected {
+			t.Fatalf("expected %q, got %q", e.expected, actual)
+		}
+	}
+}
+
+func TestRancherGetBackend(t *testing.T) {
+	provider := &Rancher{
+		Domain: "rancher.localhost",
+	}
+
+	services := []struct {
+		service  rancherData
+		expected string
+	}{
+		{
+			service: rancherData{
+				Name: "test-service",
+			},
+			expected: "test-service",
+		},
+		{
+			service: rancherData{
+				Name: "test-service",
+				Labels: map[string]string{
+					"traefik.backend": "foobar",
+				},
+			},
+
+			expected: "foobar",
+		},
+	}
+
+	for _, e := range services {
+		actual := provider.getBackend(e.service)
+		if actual != e.expected {
+			t.Fatalf("expected %q, got %q", e.expected, actual)
+		}
+	}
+}
+
+func TestRancherGetWeight(t *testing.T) {
+	provider := &Rancher{
+		Domain: "rancher.localhost",
+	}
+
+	services := []struct {
+		service  rancherData
+		expected string
+	}{
+		{
+			service: rancherData{
+				Name: "test-service",
+			},
+			expected: "0",
+		},
+		{
+			service: rancherData{
+				Name: "test-service",
+				Labels: map[string]string{
+					"traefik.weight": "5",
+				},
+			},
+
+			expected: "5",
+		},
+	}
+
+	for _, e := range services {
+		actual := provider.getWeight(e.service)
+		if actual != e.expected {
+			t.Fatalf("expected %q, got %q", e.expected, actual)
+		}
+	}
+}
+
+func TestRancherGetPort(t *testing.T) {
+	provider := &Rancher{
+		Domain: "rancher.localhost",
+	}
+
+	services := []struct {
+		service  rancherData
+		expected string
+	}{
+		{
+			service: rancherData{
+				Name: "test-service",
+			},
+			expected: "",
+		},
+		{
+			service: rancherData{
+				Name: "test-service",
+				Labels: map[string]string{
+					"traefik.port": "1337",
+				},
+			},
+
+			expected: "1337",
+		},
+	}
+
+	for _, e := range services {
+		actual := provider.getPort(e.service)
+		if actual != e.expected {
+			t.Fatalf("expected %q, got %q", e.expected, actual)
+		}
+	}
+}
+
+func TestRancherGetDomain(t *testing.T) {
+	provider := &Rancher{
+		Domain: "rancher.localhost",
+	}
+
+	services := []struct {
+		service  rancherData
+		expected string
+	}{
+		{
+			service: rancherData{
+				Name: "test-service",
+			},
+			expected: "rancher.localhost",
+		},
+		{
+			service: rancherData{
+				Name: "test-service",
+				Labels: map[string]string{
+					"traefik.domain": "foo.bar",
+				},
+			},
+
+			expected: "foo.bar",
+		},
+	}
+
+	for _, e := range services {
+		actual := provider.getDomain(e.service)
+		if actual != e.expected {
+			t.Fatalf("expected %q, got %q", e.expected, actual)
+		}
+	}
+}
+
+func TestRancherGetProtocol(t *testing.T) {
+	provider := &Rancher{
+		Domain: "rancher.localhost",
+	}
+
+	services := []struct {
+		service  rancherData
+		expected string
+	}{
+		{
+			service: rancherData{
+				Name: "test-service",
+			},
+			expected: "http",
+		},
+		{
+			service: rancherData{
+				Name: "test-service",
+				Labels: map[string]string{
+					"traefik.protocol": "https",
+				},
+			},
+
+			expected: "https",
+		},
+	}
+
+	for _, e := range services {
+		actual := provider.getProtocol(e.service)
+		if actual != e.expected {
+			t.Fatalf("expected %q, got %q", e.expected, actual)
+		}
+	}
+}
+
+func TestRancherGetPassHostHeader(t *testing.T) {
+	provider := &Rancher{
+		Domain: "rancher.localhost",
+	}
+
+	services := []struct {
+		service  rancherData
+		expected string
+	}{
+		{
+			service: rancherData{
+				Name: "test-service",
+			},
+			expected: "true",
+		},
+		{
+			service: rancherData{
+				Name: "test-service",
+				Labels: map[string]string{
+					"traefik.frontend.passHostHeader": "false",
+				},
+			},
+
+			expected: "false",
+		},
+	}
+
+	for _, e := range services {
+		actual := provider.getPassHostHeader(e.service)
+		if actual != e.expected {
+			t.Fatalf("expected %q, got %q", e.expected, actual)
+		}
+	}
+}
+
+func TestRancherGetLabel(t *testing.T) {
+	services := []struct {
+		service  rancherData
+		expected string
+	}{
+		{
+			service: rancherData{
+				Name: "test-service",
+			},
+			expected: "Label not found",
+		},
+		{
+			service: rancherData{
+				Name: "test-service",
+				Labels: map[string]string{
+					"foo": "bar",
+				},
+			},
+
+			expected: "",
+		},
+	}
+
+	for _, e := range services {
+		label, err := getServiceLabel(e.service, "foo")
+		if e.expected != "" {
+			if err == nil || !strings.Contains(err.Error(), e.expected) {
+				t.Fatalf("expected an error with %q, got %v", e.expected, err)
+			}
+		} else {
+			if label != "bar" {
+				t.Fatalf("expected label 'bar', got %s", label)
+			}
+		}
+	}
+}
+
+func TestRancherLoadRancherConfig(t *testing.T) {
+	cases := []struct {
+		services          []rancherData
+		expectedFrontends map[string]*types.Frontend
+		expectedBackends  map[string]*types.Backend
+	}{
+		{
+			services:          []rancherData{},
+			expectedFrontends: map[string]*types.Frontend{},
+			expectedBackends:  map[string]*types.Backend{},
+		},
+		{
+			services: []rancherData{
+				{
+					Name: "test-service",
+					Labels: map[string]string{
+						"traefik.port": "80",
+					},
+					Health:     "healthy",
+					Containers: []string{"127.0.0.1"},
+				},
+			},
+			expectedFrontends: map[string]*types.Frontend{
+				"frontend-Host-test-service-rancher-localhost": {
+					Backend:        "backend-test-service",
+					PassHostHeader: true,
+					EntryPoints:    []string{},
+					Priority:       0,
+
+					Routes: map[string]types.Route{
+						"route-frontend-Host-test-service-rancher-localhost": {
+							Rule: "Host:test-service.rancher.localhost",
+						},
+					},
+				},
+			},
+			expectedBackends: map[string]*types.Backend{
+				"backend-test-service": {
+					Servers: map[string]types.Server{
+						"server-0": {
+							URL:    "http://127.0.0.1:80",
+							Weight: 0,
+						},
+					},
+					CircuitBreaker: nil,
+				},
+			},
+		},
+	}
+
+	provider := &Rancher{
+		Domain:           "rancher.localhost",
+		ExposedByDefault: true,
+	}
+
+	for _, c := range cases {
+		var rancherDataList []rancherData
+		for _, service := range c.services {
+			rancherDataList = append(rancherDataList, service)
+		}
+
+		actualConfig := provider.loadRancherConfig(rancherDataList)
+
+		// Compare backends
+		if !reflect.DeepEqual(actualConfig.Backends, c.expectedBackends) {
+			t.Fatalf("expected %#v, got %#v", c.expectedBackends, actualConfig.Backends)
+		}
+		if !reflect.DeepEqual(actualConfig.Frontends, c.expectedFrontends) {
+			t.Fatalf("expected %#v, got %#v", c.expectedFrontends, actualConfig.Frontends)
+		}
+	}
+}