test: missing predicate tests (#3983)

Author: szuecs

predicates/auth/headersha256_test.go

@@ -19,6 +19,12 @@ func TestHeaderSHA256Args(t *testing.T) {
 		{
 			args: []interface{}{"X-Secret", "00112233"},
 		},
+		{
+			args: []interface{}{5, "00112233"},
+		},
+		{
+			args: []interface{}{"X-Secret", 5},
+		},
 		{
 			args: []interface{}{"X-Secret", "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff", "AA"},
 		},
@@ -31,6 +37,9 @@ func TestHeaderSHA256Args(t *testing.T) {
 
 func TestHeaderSHA256Match(t *testing.T) {
 	s := NewHeaderSHA256()
+	if s.Name() == "" {
+		t.Fatal("predicate should have a name")
+	}
 	p, err := s.Create([]interface{}{
 		"X-Secret",
 		"2bb80d537b1da3e38bd30361aa855686bde0eacd7162fef6a25fe97bf527a25b", // "secret"

predicates/auth/jwt_test.go

@@ -6,6 +6,8 @@ import (
 	"reflect"
 	"regexp"
 	"testing"
+	"testing/synctest"
+	"time"
 
 	"github.com/stretchr/testify/require"
 	"github.com/zalando/skipper/eskip"
@@ -157,6 +159,12 @@ func Test_spec_Create(t *testing.T) {
 			matchBehavior: matchBehaviorAny,
 		},
 		wantErr: false,
+	}, {
+		name:    "many kv pair of args, one regexp error",
+		spec:    NewJWTPayloadAnyKVRegexp(),
+		args:    []interface{}{"uid", "^(?!4)", "claim1", "claimValue1"},
+		want:    nil,
+		wantErr: true,
 	}, {
 		name:    "many kv pair of args, one missing",
 		spec:    NewJWTPayloadAllKV(),
@@ -619,6 +627,69 @@ s: JWTPayloadAnyKVRegexp("https://identity.zalando.com/managed-id", "^ssz") -> s
 
 }
 
+func TestPredicateCacheClean(t *testing.T) {
+	synctest.Test(t, func(t *testing.T) {
+		reg := &registry{
+			quit:         make(chan struct{}),
+			predicateMap: make(map[string]*predicate),
+		}
+		go reg.clean()
+		defer reg.Close()
+
+		spec := &spec{
+			name:          predicates.JWTPayloadAllKVRegexpName,
+			matchBehavior: matchBehaviorAll,
+			matchMode:     matchModeRegexp,
+			reg:           reg,
+		}
+
+		p, err := spec.Create([]any{"https://identity.zalando.com/managed-id", "^ssz", "https://identity.zalando.com/token", "^Bear"})
+		if err != nil {
+			t.Fatalf("Failed to create predicate: %v", err)
+		}
+
+		token := "eyJraWQiOiJwbGF0Zm9ybS1pYW0tdmNlaHloajYiLCJhbGciOiJFUzI1NiJ9.eyJzdWIiOiJjNGRkZmU5ZC1hMGQzLTRhZmItYmYyNi0yNGI5NTg4NzMxYTAiLCJodHRwczovL2lkZW50aXR5LnphbGFuZG8uY29tL3JlYWxtIjoidXNlcnMiLCJodHRwczovL2lkZW50aXR5LnphbGFuZG8uY29tL3Rva2VuIjoiQmVhcmVyIiwiaHR0cHM6Ly9pZGVudGl0eS56YWxhbmRvLmNvbS9tYW5hZ2VkLWlkIjoic3N6dWVjcyIsImF6cCI6Inp0b2tlbiIsImh0dHBzOi8vaWRlbnRpdHkuemFsYW5kby5jb20vYnAiOiI4MTBkMWQwMC00MzEyLTQzZTUtYmQzMS1kODM3M2ZkZDI0YzciLCJhdXRoX3RpbWUiOjE1MjMyNTk0NjgsImlzcyI6Imh0dHBzOi8vaWRlbnRpdHkuemFsYW5kby5jb20iLCJleHAiOjE1MjUwMjQyODUsImlhdCI6MTUyNTAyMDY3NX0.uxHcC7DJrkP-_G81Jmiba5liVP0LJOmkpal4wsUr7CmtMlE23P1bptIMxnJLv5EMSN1NFn-BJe9hcEB2A3LarA"
+
+		r := &http.Request{
+			Header: http.Header{
+				authHeaderName: []string{"Bearer " + token},
+			},
+		}
+		if !p.Match(r) {
+			t.Fatal("Failed to match")
+		}
+
+		if l := len(reg.predicateMap); l != 1 {
+			t.Fatalf("Failed to get predicateMap of len 1, got: %d", l)
+		}
+
+		ok := false
+		for _, p := range reg.predicateMap {
+			p.cache.Range(func(k, v any) bool {
+				ok = true
+				return true
+			})
+		}
+		if !ok {
+			t.Fatal("Failed to get cache filled")
+		}
+
+		time.Sleep(time.Hour + time.Minute)
+
+		ok = true
+		for _, p := range reg.predicateMap {
+			p.cache.Range(func(k, v any) bool {
+				ok = false
+				return true
+			})
+		}
+		if !ok {
+			t.Fatal("Failed to get cache cleaned")
+		}
+
+	})
+}
+
 func BenchmarkJWTPayloadAnyKV(b *testing.B) {
 	sp := NewJWTPayloadAnyKV()
 	p, err := sp.Create([]interface{}{"https://identity.zalando.com/managed-id", "foo", "iss", "https://identity.zalando.com"})

predicates/content/content_length_between_test.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"net/http"
 	"testing"
+
+	"github.com/zalando/skipper/predicates"
 )
 
 func TestContentLengthCreate(t *testing.T) {
@@ -15,6 +17,32 @@ func TestContentLengthCreate(t *testing.T) {
 		t.Fatal("expected error here, lower bound equals upper bound")
 	}
 }
+func TestContentLengthCreateError(t *testing.T) {
+	spec := NewContentLengthBetween()
+	if spec.Name() == "" {
+		t.Fatal("predicate spec should have a name")
+	}
+
+	_, err := spec.Create([]any{})
+	if err != predicates.ErrInvalidPredicateParameters {
+		t.Fatalf("Failed to get expected error, got: %v", err)
+	}
+
+	_, err = spec.Create([]any{"5.0", "8.2"})
+	if err != predicates.ErrInvalidPredicateParameters {
+		t.Fatalf("Failed to get expected error, got: %v", err)
+	}
+
+	_, err = spec.Create([]any{5.0, "8.2"})
+	if err != predicates.ErrInvalidPredicateParameters {
+		t.Fatalf("Failed to get expected error, got: %v", err)
+	}
+
+	_, err = spec.Create([]any{5, 1})
+	if err != predicates.ErrInvalidPredicateParameters {
+		t.Fatalf("Failed to get expected error, got: %v", err)
+	}
+}
 
 func TestContentLengthMatch(t *testing.T) {
 	s := NewContentLengthBetween()

predicates/forwarded/forwarded_test.go

@@ -4,8 +4,54 @@ import (
 	"net/http"
 	"net/url"
 	"testing"
+
+	"github.com/zalando/skipper/predicates"
 )
 
+func TestForwardedHostCreateError(t *testing.T) {
+	spec := NewForwardedHost()
+	if spec.Name() == "" {
+		t.Fatal("predicate spec should have a name")
+	}
+
+	_, err := spec.Create([]any{})
+	if err != predicates.ErrInvalidPredicateParameters {
+		t.Fatalf("Failed to get expected error, got: %v", err)
+	}
+
+	_, err = spec.Create([]any{5})
+	if err != predicates.ErrInvalidPredicateParameters {
+		t.Fatalf("Failed to get expected error, got: %v", err)
+	}
+
+	_, err = spec.Create([]any{"^(?!4)"})
+	if err == nil || err == predicates.ErrInvalidPredicateParameters {
+		t.Fatalf("regexp is not valid RE2")
+	}
+}
+
+func TestForwardedProtoCreateError(t *testing.T) {
+	spec := NewForwardedProto()
+	if spec.Name() == "" {
+		t.Fatal("predicate spec should have a name")
+	}
+
+	_, err := spec.Create([]any{})
+	if err != predicates.ErrInvalidPredicateParameters {
+		t.Fatalf("Failed to get expected error, got: %v", err)
+	}
+
+	_, err = spec.Create([]any{5})
+	if err != predicates.ErrInvalidPredicateParameters {
+		t.Fatalf("Failed to get expected error, got: %v", err)
+	}
+
+	_, err = spec.Create([]any{"foo"})
+	if err != predicates.ErrInvalidPredicateParameters {
+		t.Fatalf("Failed to get expected error, got: %v", err)
+	}
+}
+
 type request struct {
 	url     string
 	headers http.Header

predicates/primitive/shutdown_test.go

@@ -9,7 +9,7 @@ import (
 
 func TestShutdown(t *testing.T) {
 	s, sigs := newShutdown()
-	p, err := s.Create([]interface{}{})
+	p, err := s.Create([]any{})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -25,4 +25,16 @@ func TestShutdown(t *testing.T) {
 	if !p.Match(req) {
 		t.Error("expected shutdown")
 	}
+
+	if s.Name() == "" {
+		t.Fatal("predicate should have a name")
+	}
+}
+
+func TestShutdownErrors(t *testing.T) {
+	s := NewShutdown()
+	_, err := s.Create([]any{"wrong args"})
+	if err == nil {
+		t.Fatal("Failed to get err")
+	}
 }

predicates/tee/tee_test.go

@@ -0,0 +1,65 @@
+package tee
+
+import (
+	"net/http"
+	"testing"
+
+	"github.com/zalando/skipper/predicates"
+)
+
+func TestTee(t *testing.T) {
+	p := New()
+
+	for _, tc := range []struct {
+		name  string
+		args  []any
+		match bool
+		err   error
+	}{
+		{
+			name: "no args",
+			args: []any{},
+			err:  predicates.ErrInvalidPredicateParameters,
+		},
+		{
+			name: "wrong args",
+			args: []any{1.2},
+			err:  predicates.ErrInvalidPredicateParameters,
+		},
+		{
+			name:  "match",
+			args:  []any{"goodmatch"},
+			match: true,
+		},
+		{
+			name:  "no match",
+			args:  []any{"nomatch"},
+			match: false,
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			pred, err := p.Create(tc.args)
+			if err != nil {
+				if err == tc.err {
+					return
+				}
+				t.Fatalf("Failed with not expected err want: %v, got: %v", tc.err, err)
+			} else {
+				if tc.err != nil {
+					t.Fatalf("Failed to get expected error: %v", tc.err)
+				}
+			}
+			req, _ := http.NewRequest("GET", "http://my-app.test", nil)
+			req.Header.Add(HeaderKey, "goodmatch")
+			res := pred.Match(req)
+			if res != tc.match {
+				t.Fatalf("Failed to get expected result, want %v, got %v", tc.match, res)
+			}
+
+			if p.Name() == "" {
+				t.Fatal("predicate name is empty")
+			}
+		})
+	}
+
+}