Overhaul testing to use testify

internal/auth_test.go

@@ -4,11 +4,11 @@ import (
 	"fmt"
 	"net/http"
 	"net/url"
-	"reflect"
 	"strings"
 	"testing"
 	"time"
 
+	"github.com/stretchr/testify/assert"
 	"github.com/thomseddon/traefik-forward-auth/internal/provider"
 )
 
@@ -17,6 +17,7 @@ import (
  */
 
 func TestAuthValidateCookie(t *testing.T) {
+	assert := assert.New(t)
 	config, _ = NewConfig([]string{})
 	r, _ := http.NewRequest("GET", "http://example.com", nil)
 	c := &http.Cookie{}
@@ -24,87 +25,85 @@ func TestAuthValidateCookie(t *testing.T) {
 	// Should require 3 parts
 	c.Value = ""
 	valid, _, err := ValidateCookie(r, c)
-	if valid || err.Error() != "Invalid cookie format" {
-		t.Error("Should get \"Invalid cookie format\", got:", err)
+	assert.False(valid)
+	if assert.Error(err) {
+		assert.Equal("Invalid cookie format", err.Error())
 	}
 	c.Value = "1|2"
 	valid, _, err = ValidateCookie(r, c)
-	if valid || err.Error() != "Invalid cookie format" {
-		t.Error("Should get \"Invalid cookie format\", got:", err)
+	assert.False(valid)
+	if assert.Error(err) {
+		assert.Equal("Invalid cookie format", err.Error())
 	}
 	c.Value = "1|2|3|4"
 	valid, _, err = ValidateCookie(r, c)
-	if valid || err.Error() != "Invalid cookie format" {
-		t.Error("Should get \"Invalid cookie format\", got:", err)
+	assert.False(valid)
+	if assert.Error(err) {
+		assert.Equal("Invalid cookie format", err.Error())
 	}
 
 	// Should catch invalid mac
 	c.Value = "MQ==|2|3"
 	valid, _, err = ValidateCookie(r, c)
-	if valid || err.Error() != "Invalid cookie mac" {
-		t.Error("Should get \"Invalid cookie mac\", got:", err)
+	assert.False(valid)
+	if assert.Error(err) {
+		assert.Equal("Invalid cookie mac", err.Error())
 	}
 
 	// Should catch expired
 	config.Lifetime = time.Second * time.Duration(-1)
 	c = MakeCookie(r, "test@test.com")
 	valid, _, err = ValidateCookie(r, c)
-	if valid || err.Error() != "Cookie has expired" {
-		t.Error("Should get \"Cookie has expired\", got:", err)
+	assert.False(valid)
+	if assert.Error(err) {
+		assert.Equal("Cookie has expired", err.Error())
 	}
 
 	// Should accept valid cookie
 	config.Lifetime = time.Second * time.Duration(10)
 	c = MakeCookie(r, "test@test.com")
 	valid, email, err := ValidateCookie(r, c)
-	if !valid {
-		t.Error("Valid request should return as valid")
-	}
-	if err != nil {
-		t.Error("Valid request should not return error, got:", err)
-	}
-	if email != "test@test.com" {
-		t.Error("Valid request should return user email")
-	}
+	assert.True(valid, "valid request should return valid")
+	assert.Nil(err, "valid request should not return an error")
+	assert.Equal("test@test.com", email, "valid request should return user email")
 }
 
 func TestAuthValidateEmail(t *testing.T) {
+	assert := assert.New(t)
 	config, _ = NewConfig([]string{})
 
 	// Should allow any
-	if !ValidateEmail("test@test.com") || !ValidateEmail("one@two.com") {
-		t.Error("Should allow any domain if email domain is not defined")
-	}
+	v := ValidateEmail("test@test.com")
+	assert.True(v, "should allow any domain if email domain is not defined")
+	v = ValidateEmail("one@two.com")
+	assert.True(v, "should allow any domain if email domain is not defined")
 
 	// Should block non matching domain
 	config.Domains = []string{"test.com"}
-	if ValidateEmail("one@two.com") {
-		t.Error("Should not allow user from another domain")
-	}
+	v = ValidateEmail("one@two.com")
+	assert.False(v, "should not allow user from another domain")
 
 	// Should allow matching domain
 	config.Domains = []string{"test.com"}
-	if !ValidateEmail("test@test.com") {
-		t.Error("Should allow user from allowed domain")
-	}
+	v = ValidateEmail("test@test.com")
+	assert.True(v, "should allow user from allowed domain")
 
 	// Should block non whitelisted email address
 	config.Domains = []string{}
 	config.Whitelist = []string{"test@test.com"}
-	if ValidateEmail("one@two.com") {
-		t.Error("Should not allow user not in whitelist.")
-	}
+	v = ValidateEmail("one@two.com")
+	assert.False(v, "should not allow user not in whitelist")
 
 	// Should allow matching whitelisted email address
 	config.Domains = []string{}
 	config.Whitelist = []string{"test@test.com"}
-	if !ValidateEmail("test@test.com") {
-		t.Error("Should allow user in whitelist.")
-	}
+	v = ValidateEmail("test@test.com")
+	assert.True(v, "should allow user in whitelist")
 }
 
 // TODO: Split google tests out
 func TestAuthGetLoginURL(t *testing.T) {
+	assert := assert.New(t)
 	google := provider.Google{
 		ClientId:     "idtest",
 		ClientSecret: "sectest",
@@ -127,18 +126,10 @@ func TestAuthGetLoginURL(t *testing.T) {
 
 	// Check url
 	uri, err := url.Parse(GetLoginURL(r, "nonce"))
-	if err != nil {
-		t.Error("Error parsing login url:", err)
-	}
-	if uri.Scheme != "https" {
-		t.Error("Expected login Scheme to be \"https\", got:", uri.Scheme)
-	}
-	if uri.Host != "test.com" {
-		t.Error("Expected login Host to be \"test.com\", got:", uri.Host)
-	}
-	if uri.Path != "/auth" {
-		t.Error("Expected login Path to be \"/auth\", got:", uri.Path)
-	}
+	assert.Nil(err)
+	assert.Equal("https", uri.Scheme)
+	assert.Equal("test.com", uri.Host)
+	assert.Equal("/auth", uri.Path)
 
 	// Check query string
 	qs := uri.Query()
@@ -150,11 +141,7 @@ func TestAuthGetLoginURL(t *testing.T) {
 		"prompt":        []string{"consent select_account"},
 		"state":         []string{"nonce:http://example.com/hello"},
 	}
-	if !reflect.DeepEqual(qs, expectedQs) {
-		for _, err := range qsDiff(t, expectedQs, qs) {
-			t.Error(err)
-		}
-	}
+	assert.Equal(expectedQs, qs)
 
 	//
 	// With Auth URL but no matching cookie domain
@@ -166,18 +153,10 @@ func TestAuthGetLoginURL(t *testing.T) {
 
 	// Check url
 	uri, err = url.Parse(GetLoginURL(r, "nonce"))
-	if err != nil {
-		t.Error("Error parsing login url:", err)
-	}
-	if uri.Scheme != "https" {
-		t.Error("Expected login Scheme to be \"https\", got:", uri.Scheme)
-	}
-	if uri.Host != "test.com" {
-		t.Error("Expected login Host to be \"test.com\", got:", uri.Host)
-	}
-	if uri.Path != "/auth" {
-		t.Error("Expected login Path to be \"/auth\", got:", uri.Path)
-	}
+	assert.Nil(err)
+	assert.Equal("https", uri.Scheme)
+	assert.Equal("test.com", uri.Host)
+	assert.Equal("/auth", uri.Path)
 
 	// Check query string
 	qs = uri.Query()
@@ -189,11 +168,7 @@ func TestAuthGetLoginURL(t *testing.T) {
 		"prompt":        []string{"consent select_account"},
 		"state":         []string{"nonce:http://example.com/hello"},
 	}
-	if !reflect.DeepEqual(qs, expectedQs) {
-		for _, err := range qsDiff(t, expectedQs, qs) {
-			t.Error(err)
-		}
-	}
+	assert.Equal(expectedQs, qs)
 
 	//
 	// With correct Auth URL + cookie domain
@@ -205,18 +180,10 @@ func TestAuthGetLoginURL(t *testing.T) {
 
 	// Check url
 	uri, err = url.Parse(GetLoginURL(r, "nonce"))
-	if err != nil {
-		t.Error("Error parsing login url:", err)
-	}
-	if uri.Scheme != "https" {
-		t.Error("Expected login Scheme to be \"https\", got:", uri.Scheme)
-	}
-	if uri.Host != "test.com" {
-		t.Error("Expected login Host to be \"test.com\", got:", uri.Host)
-	}
-	if uri.Path != "/auth" {
-		t.Error("Expected login Path to be \"/auth\", got:", uri.Path)
-	}
+	assert.Nil(err)
+	assert.Equal("https", uri.Scheme)
+	assert.Equal("test.com", uri.Host)
+	assert.Equal("/auth", uri.Path)
 
 	// Check query string
 	qs = uri.Query()
@@ -228,14 +195,7 @@ func TestAuthGetLoginURL(t *testing.T) {
 		"state":         []string{"nonce:http://example.com/hello"},
 		"prompt":        []string{"consent select_account"},
 	}
-	for _, err := range qsDiff(t, expectedQs, qs) {
-		t.Error(err)
-	}
-	if !reflect.DeepEqual(qs, expectedQs) {
-		for _, err := range qsDiff(t, expectedQs, qs) {
-			t.Error(err)
-		}
-	}
+	assert.Equal(expectedQs, qs)
 
 	//
 	// With Auth URL + cookie domain, but from different domain
@@ -248,18 +208,10 @@ func TestAuthGetLoginURL(t *testing.T) {
 
 	// Check url
 	uri, err = url.Parse(GetLoginURL(r, "nonce"))
-	if err != nil {
-		t.Error("Error parsing login url:", err)
-	}
-	if uri.Scheme != "https" {
-		t.Error("Expected login Scheme to be \"https\", got:", uri.Scheme)
-	}
-	if uri.Host != "test.com" {
-		t.Error("Expected login Host to be \"test.com\", got:", uri.Host)
-	}
-	if uri.Path != "/auth" {
-		t.Error("Expected login Path to be \"/auth\", got:", uri.Path)
-	}
+	assert.Nil(err)
+	assert.Equal("https", uri.Scheme)
+	assert.Equal("test.com", uri.Host)
+	assert.Equal("/auth", uri.Path)
 
 	// Check query string
 	qs = uri.Query()
@@ -271,14 +223,7 @@ func TestAuthGetLoginURL(t *testing.T) {
 		"state":         []string{"nonce:http://another.com/hello"},
 		"prompt":        []string{"consent select_account"},
 	}
-	for _, err := range qsDiff(t, expectedQs, qs) {
-		t.Error(err)
-	}
-	if !reflect.DeepEqual(qs, expectedQs) {
-		for _, err := range qsDiff(t, expectedQs, qs) {
-			t.Error(err)
-		}
-	}
+	assert.Equal(expectedQs, qs)
 }
 
 // TODO
@@ -290,68 +235,47 @@ func TestAuthGetLoginURL(t *testing.T) {
 // }
 
 func TestAuthMakeCookie(t *testing.T) {
+	assert := assert.New(t)
 	config, _ = NewConfig([]string{})
 	r, _ := http.NewRequest("GET", "http://app.example.com", nil)
 	r.Header.Add("X-Forwarded-Host", "app.example.com")
 
 	c := MakeCookie(r, "test@example.com")
-	if c.Name != "_forward_auth" {
-		t.Error("Cookie name should be \"_forward_auth\", got:", c.Name)
-	}
+	assert.Equal("_forward_auth", c.Name)
 	parts := strings.Split(c.Value, "|")
-	if len(parts) != 3 {
-		t.Error("Cookie should be in 3 parts, got:", c.Value)
-	}
+	assert.Len(parts, 3, "cookie should be 3 parts")
 	valid, _, _ := ValidateCookie(r, c)
-	if !valid {
-		t.Error("Should generate valid cookie:", c.Value)
-	}
-	if c.Path != "/" {
-		t.Error("Cookie path should be \"/\", got:", c.Path)
-	}
-	if c.Domain != "app.example.com" {
-		t.Error("Cookie domain should be \"app.example.com\", got:", c.Domain)
-	}
-	if c.Secure != true {
-		t.Error("Cookie domain should be true, got:", c.Secure)
-	}
-	if !c.Expires.After(time.Now().Local()) {
-		t.Error("Expires should be after now, got:", c.Expires)
-	}
-	if !c.Expires.Before(time.Now().Local().Add(config.Lifetime).Add(10 * time.Second)) {
-		t.Error("Expires should be before lifetime + 10 seconds, got:", c.Expires)
-	}
+	assert.True(valid, "should generate valid cookie")
+	assert.Equal("/", c.Path)
+	assert.Equal("app.example.com", c.Domain)
+	assert.True(c.Secure)
+
+	expires := time.Now().Local().Add(config.Lifetime)
+	assert.WithinDuration(expires, c.Expires, 10*time.Second)
 
 	config.CookieName = "testname"
 	config.InsecureCookie = true
 	c = MakeCookie(r, "test@example.com")
-	if c.Name != "testname" {
-		t.Error("Cookie name should be \"testname\", got:", c.Name)
-	}
-	if c.Secure != false {
-		t.Error("Cookie domain should be false, got:", c.Secure)
-	}
+	assert.Equal("testname", c.Name)
+	assert.False(c.Secure)
 }
 
 func TestAuthMakeCSRFCookie(t *testing.T) {
+	assert := assert.New(t)
 	config, _ = NewConfig([]string{})
 	r, _ := http.NewRequest("GET", "http://app.example.com", nil)
 	r.Header.Add("X-Forwarded-Host", "app.example.com")
 
 	// No cookie domain or auth url
 	c := MakeCSRFCookie(r, "12345678901234567890123456789012")
-	if c.Domain != "app.example.com" {
-		t.Error("Cookie Domain should match request domain, got:", c.Domain)
-	}
+	assert.Equal("app.example.com", c.Domain)
 
 	// With cookie domain but no auth url
 	config = Config{
 		CookieDomains: []CookieDomain{*NewCookieDomain("example.com")},
 	}
 	c = MakeCSRFCookie(r, "12345678901234567890123456789012")
-	if c.Domain != "app.example.com" {
-		t.Error("Cookie Domain should match request domain, got:", c.Domain)
-	}
+	assert.Equal("app.example.com", c.Domain)
 
 	// With cookie domain and auth url
 	config = Config{
@@ -359,9 +283,7 @@ func TestAuthMakeCSRFCookie(t *testing.T) {
 		CookieDomains: []CookieDomain{*NewCookieDomain("example.com")},
 	}
 	c = MakeCSRFCookie(r, "12345678901234567890123456789012")
-	if c.Domain != "example.com" {
-		t.Error("Cookie Domain should match request domain, got:", c.Domain)
-	}
+	assert.Equal("example.com", c.Domain)
 }
 
 func TestAuthClearCSRFCookie(t *testing.T) {
@@ -375,6 +297,7 @@ func TestAuthClearCSRFCookie(t *testing.T) {
 }
 
 func TestAuthValidateCSRFCookie(t *testing.T) {
+	assert := assert.New(t)
 	config, _ = NewConfig([]string{})
 	c := &http.Cookie{}
 
@@ -388,103 +311,88 @@ func TestAuthValidateCSRFCookie(t *testing.T) {
 	r := newCsrfRequest("")
 	c.Value = ""
 	valid, _, err := ValidateCSRFCookie(r, c)
-	if valid || err.Error() != "Invalid CSRF cookie value" {
-		t.Error("Should get \"Invalid CSRF cookie value\", got:", err)
+	assert.False(valid)
+	if assert.Error(err) {
+		assert.Equal("Invalid CSRF cookie value", err.Error())
 	}
 	c.Value = "123456789012345678901234567890123"
 	valid, _, err = ValidateCSRFCookie(r, c)
-	if valid || err.Error() != "Invalid CSRF cookie value" {
-		t.Error("Should get \"Invalid CSRF cookie value\", got:", err)
+	assert.False(valid)
+	if assert.Error(err) {
+		assert.Equal("Invalid CSRF cookie value", err.Error())
 	}
 
 	// Should require valid state
 	r = newCsrfRequest("12345678901234567890123456789012:")
 	c.Value = "12345678901234567890123456789012"
 	valid, _, err = ValidateCSRFCookie(r, c)
-	if valid || err.Error() != "Invalid CSRF state value" {
-		t.Error("Should get \"Invalid CSRF state value\", got:", err)
+	assert.False(valid)
+	if assert.Error(err) {
+		assert.Equal("Invalid CSRF state value", err.Error())
 	}
 
 	// Should allow valid state
 	r = newCsrfRequest("12345678901234567890123456789012:99")
 	c.Value = "12345678901234567890123456789012"
 	valid, state, err := ValidateCSRFCookie(r, c)
-	if !valid {
-		t.Error("Valid request should return as valid")
-	}
-	if err != nil {
-		t.Error("Valid request should not return error, got:", err)
-	}
-	if state != "99" {
-		t.Error("Valid request should return correct state, got:", state)
-	}
+	assert.True(valid, "valid request should return valid")
+	assert.Nil(err, "valid request should not return an error")
+	assert.Equal("99", state, "valid request should return correct state")
 }
 
 func TestAuthNonce(t *testing.T) {
+	assert := assert.New(t)
 	err, nonce1 := Nonce()
-	if err != nil {
-		t.Error("Error generation nonce:", err)
-	}
+	assert.Nil(err, "error generating nonce")
+	assert.Len(nonce1, 32, "length should be 32 chars")
 
 	err, nonce2 := Nonce()
-	if err != nil {
-		t.Error("Error generation nonce:", err)
-	}
+	assert.Nil(err, "error generating nonce")
+	assert.Len(nonce2, 32, "length should be 32 chars")
 
-	if len(nonce1) != 32 || len(nonce2) != 32 {
-		t.Error("Nonce should be 32 chars")
-	}
-	if nonce1 == nonce2 {
-		t.Error("Nonce should not be equal")
-	}
+	assert.NotEqual(nonce1, nonce2, "nonce should not be equal")
 }
 
 func TestAuthCookieDomainMatch(t *testing.T) {
+	assert := assert.New(t)
 	cd := NewCookieDomain("example.com")
 
 	// Exact should match
-	if !cd.Match("example.com") {
-		t.Error("Exact domain should match")
-	}
+	assert.True(cd.Match("example.com"), "exact domain should match")
 
 	// Subdomain should match
-	if !cd.Match("test.example.com") {
-		t.Error("Subdomain should match")
-	}
+	assert.True(cd.Match("test.example.com"), "subdomain should match")
 
 	// Derived domain should not match
-	if cd.Match("testexample.com") {
-		t.Error("Derived domain should not match")
-	}
+	assert.False(cd.Match("testexample.com"), "derived domain should not match")
 
 	// Other domain should not match
-	if cd.Match("test.com") {
-		t.Error("Other domain should not match")
-	}
+	assert.False(cd.Match("test.com"), "other domain should not match")
 }
 
 func TestAuthCookieDomains(t *testing.T) {
+	assert := assert.New(t)
 	cds := CookieDomains{}
 
 	err := cds.UnmarshalFlag("one.com,two.org")
-	if err != nil {
-		t.Error(err)
-	}
-	if len(cds) != 2 {
-		t.Error("Expected UnmarshalFlag to provide 2 CookieDomains, got", cds)
-	}
-	if cds[0].Domain != "one.com" || cds[0].SubDomain != ".one.com" {
-		t.Error("Expected UnmarshalFlag to provide one.com, got", cds[0])
-	}
-	if cds[1].Domain != "two.org" || cds[1].SubDomain != ".two.org" {
-		t.Error("Expected UnmarshalFlag to provide two.org, got", cds[1])
+	assert.Nil(err)
+	expected := CookieDomains{
+		CookieDomain{
+			Domain:       "one.com",
+			DomainLen:    7,
+			SubDomain:    ".one.com",
+			SubDomainLen: 8,
+		},
+		CookieDomain{
+			Domain:       "two.org",
+			DomainLen:    7,
+			SubDomain:    ".two.org",
+			SubDomainLen: 8,
+		},
 	}
+	assert.Equal(expected, cds)
 
 	marshal, err := cds.MarshalFlag()
-	if err != nil {
-		t.Error(err)
-	}
-	if marshal != "one.com,two.org" {
-		t.Error("Expected MarshalFlag to provide \"one.com,two.org\", got", cds)
-	}
+	assert.Nil(err)
+	assert.Equal("one.com,two.org", marshal)
 }