increase codecoverage to 80% required by silver cii bestpractices

.travis.yml

@@ -2,6 +2,9 @@ sudo: false
 
 language: go
 
+# see https://github.com/golang/go/issues/31293
+dist: xenial
+
 go:
   - 1.12.x
 

cmd/skipper/breakerflags_test.go

@@ -0,0 +1,125 @@
+package main
+
+import (
+	"testing"
+	"time"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/zalando/skipper/circuit"
+)
+
+func Test_breakerFlags_String(t *testing.T) {
+	tests := []struct {
+		name string
+		b    *breakerFlags
+		want string
+	}{
+		{
+			name: "test consecutive breaker",
+			b: &breakerFlags{
+				circuit.BreakerSettings{
+					Type:             circuit.ConsecutiveFailures,
+					Host:             "example.com",
+					Window:           10,
+					Timeout:          3 * time.Second,
+					HalfOpenRequests: 3,
+					IdleTTL:          5 * time.Second,
+				},
+			},
+			want: "type=consecutive,host=example.com,timeout=3s,half-open-requests=3,idle-ttl=5s",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := tt.b.String(); got != tt.want {
+				t.Errorf("breakerFlags.String() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func Test_breakerFlags_Set(t *testing.T) {
+	tests := []struct {
+		name    string
+		args    string
+		wantErr bool
+		want    circuit.BreakerSettings
+	}{
+		{
+			name:    "test breaker settings",
+			args:    "type=consecutive,host=example.com,timeout=3s,half-open-requests=3,idle-ttl=5s",
+			wantErr: false,
+			want: circuit.BreakerSettings{
+				Type:             circuit.ConsecutiveFailures,
+				Host:             "example.com",
+				Timeout:          3 * time.Second,
+				HalfOpenRequests: 3,
+				IdleTTL:          5 * time.Second,
+			},
+		},
+		{
+			name:    "test breaker settings with window",
+			args:    "type=consecutive,window=4,host=example.com,timeout=3s,half-open-requests=3,idle-ttl=5s",
+			wantErr: false,
+			want: circuit.BreakerSettings{
+				Type:             circuit.ConsecutiveFailures,
+				Host:             "example.com",
+				Timeout:          3 * time.Second,
+				HalfOpenRequests: 3,
+				IdleTTL:          5 * time.Second,
+				Window:           4,
+			},
+		},
+		{
+			name:    "test breaker settings with wrong window",
+			args:    "type=consecutive,window=4s,host=example.com,timeout=3s,half-open-requests=3,idle-ttl=5s",
+			wantErr: true,
+		},
+		{
+			name:    "test breaker settings failurerate",
+			args:    "type=rate,host=example.com,timeout=3s,half-open-requests=3,idle-ttl=5s",
+			wantErr: false,
+			want: circuit.BreakerSettings{
+				Type:             circuit.FailureRate,
+				Host:             "example.com",
+				Timeout:          3 * time.Second,
+				HalfOpenRequests: 3,
+				IdleTTL:          5 * time.Second,
+			},
+		},
+		{
+			name:    "test breaker settings disabled",
+			args:    "type=disabled,host=example.com,timeout=3s,half-open-requests=3,idle-ttl=5s",
+			wantErr: false,
+			want: circuit.BreakerSettings{
+				Type:             circuit.BreakerDisabled,
+				Host:             "example.com",
+				Timeout:          3 * time.Second,
+				HalfOpenRequests: 3,
+				IdleTTL:          5 * time.Second,
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			bp := &breakerFlags{}
+
+			if err := bp.Set(tt.args); (err != nil) != tt.wantErr {
+				t.Errorf("breakerFlags.Set() error = %v, wantErr %v", err, tt.wantErr)
+			}
+
+			if !tt.wantErr {
+				b := *bp
+				if len(b) != 1 {
+					t.Errorf("Failed to have breaker created: %d != 1", len(b))
+				}
+
+				bs := b[0]
+				if bs.Type != tt.want.Type || bs.Host != tt.want.Host || bs.Window != tt.want.Window || bs.Failures != tt.want.Failures || bs.Timeout != tt.want.Timeout || bs.HalfOpenRequests != tt.want.HalfOpenRequests || bs.IdleTTL != tt.want.IdleTTL {
+					t.Errorf("breakerFlags.Set() got v, want v, %v", cmp.Diff(bs, tt.want))
+				}
+			}
+
+		})
+	}
+}

cmd/skipper/defaultfilterflags_test.go

@@ -0,0 +1,110 @@
+package main
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/zalando/skipper/eskip"
+)
+
+func Test_defaultFiltersFlags_String(t *testing.T) {
+	tests := []struct {
+		name    string
+		filters []*eskip.Filter
+		want    string
+	}{
+		{
+			name:    "test string",
+			filters: []*eskip.Filter{},
+			want:    "<default filters>",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			dpf := &defaultFiltersFlags{
+				filters: tt.filters,
+			}
+			if got := dpf.String(); got != tt.want {
+				t.Errorf("defaultFiltersFlags.String() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func Test_defaultFiltersFlags_Set(t *testing.T) {
+	oneFilter, _ := eskip.ParseFilters(`tee("https://www.zalando.de/")`)
+	manyFilters, _ := eskip.ParseFilters(`ratelimit(5, "10s") -> tee("https://www.zalando.de/")`)
+	tests := []struct {
+		name    string
+		args    string
+		want    []*eskip.Filter
+		wantErr bool
+	}{
+		{
+			name:    "test no filter",
+			args:    "",
+			want:    nil,
+			wantErr: false,
+		},
+		{
+			name:    "test one filter",
+			args:    `tee("https://www.zalando.de/")`,
+			want:    oneFilter,
+			wantErr: false,
+		},
+		{
+			name:    "test many filters",
+			args:    `ratelimit(5, "10s") -> tee("https://www.zalando.de/")`,
+			want:    manyFilters,
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			dpf := &defaultFiltersFlags{}
+			if err := dpf.Set(tt.args); (err != nil) != tt.wantErr {
+				t.Errorf("defaultFiltersFlags.Set() error = %v, wantErr %v", err, tt.wantErr)
+			}
+			if !tt.wantErr {
+				if len(tt.want) != len(dpf.filters) {
+					t.Errorf("defaultFiltersFlags size missmatch got %d want %d", len(dpf.filters), len(tt.want))
+				}
+			}
+		})
+	}
+}
+
+func Test_defaultFiltersFlags_Get(t *testing.T) {
+	oneFilter, _ := eskip.ParseFilters(`tee("https://www.zalando.de/")`)
+	manyFilters, _ := eskip.ParseFilters(`ratelimit(5, "10s") -> tee("https://www.zalando.de/")`)
+
+	tests := []struct {
+		name    string
+		filters []*eskip.Filter
+		want    []*eskip.Filter
+	}{
+		{
+			name: "get no filter",
+		},
+		{
+			name:    "get one filter",
+			filters: oneFilter,
+			want:    oneFilter,
+		},
+		{
+			name:    "get many filter",
+			filters: manyFilters,
+			want:    manyFilters,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			dpf := &defaultFiltersFlags{
+				filters: tt.filters,
+			}
+			if got := dpf.Get(); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("defaultFiltersFlags.Get() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

cmd/skipper/main_test.go

@@ -0,0 +1,35 @@
+package main
+
+import (
+	"reflect"
+	"testing"
+)
+
+func Test_parseHistogramBuckets(t *testing.T) {
+	for _, tt := range []struct {
+		name    string
+		args    string
+		want    []float64
+		wantErr bool
+	}{
+		{
+			name:    "test parse 1",
+			args:    "1",
+			want:    []float64{1},
+			wantErr: false,
+		},
+		{
+			name:    "test parse 1,1.33,1.5,1.66,2",
+			args:    "1,1.33,1.5,1.66,2",
+			want:    []float64{1, 1.33, 1.5, 1.66, 2},
+			wantErr: false,
+		}} {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := parseHistogramBuckets(tt.args)
+			if !reflect.DeepEqual(got, tt.want) || (tt.wantErr && err == nil) || (!tt.wantErr && err != nil) {
+				t.Errorf("Failed to parse histogram buckets: Want %v, got %v, err %v", tt.want, got, err)
+			}
+		})
+	}
+
+}

cmd/skipper/metricsFlags_test.go

@@ -0,0 +1,96 @@
+package main
+
+import (
+	"reflect"
+	"testing"
+)
+
+func Test_metricsFlags_String(t *testing.T) {
+	type fields struct {
+		values []string
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   string
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			m := &metricsFlags{
+				values: tt.fields.values,
+			}
+			if got := m.String(); got != tt.want {
+				t.Errorf("metricsFlags.String() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func Test_metricsFlags_Set(t *testing.T) {
+	tests := []struct {
+		name    string
+		args    string
+		values  []string
+		wantErr bool
+	}{
+		{
+			name:    "test set wrong value",
+			args:    "foo",
+			wantErr: true,
+		},
+		{
+			name:    "test set codahale value",
+			args:    "codahale",
+			wantErr: false,
+			values:  []string{"codahale"},
+		},
+		{
+			name:    "test set prometheus value",
+			args:    "prometheus",
+			wantErr: false,
+			values:  []string{"prometheus"},
+		},
+		{
+			name:    "test set codahale,prometheus value",
+			args:    "codahale,prometheus",
+			wantErr: false,
+			values:  []string{"codahale", "prometheus"},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			m := &metricsFlags{
+				values: tt.values,
+			}
+			if err := m.Set(tt.args); (err != nil) != tt.wantErr {
+				t.Errorf("metricsFlags.Set() error = %v, wantErr %v", err, tt.wantErr)
+			}
+		})
+	}
+}
+
+func Test_metricsFlags_Get(t *testing.T) {
+	tests := []struct {
+		name   string
+		values []string
+		want   []string
+	}{
+		{
+			name:   "test get",
+			values: []string{"foo"},
+			want:   []string{"foo"},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			m := &metricsFlags{
+				values: tt.values,
+			}
+			if got := m.Get(); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("metricsFlags.Get() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}

cmd/skipper/ratelimiterflags.go

@@ -45,7 +45,9 @@ func (r *ratelimitFlags) Set(value string) error {
 		case "type":
 			switch kv[1] {
 			case "local":
-				s.Type = ratelimit.LocalRatelimit
+				fallthrough
+			case "client":
+				s.Type = ratelimit.ClientRatelimit
 			case "service":
 				s.Type = ratelimit.ServiceRatelimit
 			case "disabled":