commit 4276628b951927db41e02f046e853e50b3799e38
parent 52893f34bc8b90be05685313ed4c509ebe346f2a
Author: Sebastian Mancke <s.mancke@tarent.de>
Date: Mon, 15 May 2017 11:01:31 +0200
used . import for assert library in tests
Diffstat:
16 files changed, 301 insertions(+), 301 deletions(-)
diff --git a/caddy/setup_test.go b/caddy/setup_test.go
@@ -4,7 +4,7 @@ import (
"fmt"
"github.com/mholt/caddy"
"github.com/mholt/caddy/caddyhttp/httpserver"
- "github.com/stretchr/testify/assert"
+ . "github.com/stretchr/testify/assert"
"github.com/tarent/loginsrv/login"
"io/ioutil"
"os"
@@ -153,10 +153,10 @@ func TestSetup(t *testing.T) {
c := caddy.NewTestController("http", test.input)
err := setup(c)
if test.shouldErr {
- assert.Error(t, err, "test ")
+ Error(t, err, "test ")
return
} else {
- assert.NoError(t, err)
+ NoError(t, err)
}
mids := httpserver.GetConfig(c).Middleware()
if len(mids) == 0 {
@@ -164,7 +164,7 @@ func TestSetup(t *testing.T) {
return
}
middleware := mids[len(mids)-1](nil).(*CaddyHandler)
- assert.Equal(t, &test.config, middleware.config)
+ Equal(t, &test.config, middleware.config)
})
}
}
@@ -180,12 +180,12 @@ func TestSetup_RelativeTemplateFile(t *testing.T) {
config.Root = root
err := setup(c)
- assert.NoError(t, err)
+ NoError(t, err)
mids := httpserver.GetConfig(c).Middleware()
if len(mids) == 0 {
t.Errorf("no middlewares created")
}
middleware := mids[len(mids)-1](nil).(*CaddyHandler)
- assert.Equal(t, expectedPath, middleware.config.Template)
+ Equal(t, expectedPath, middleware.config.Template)
}
diff --git a/htpasswd/auth_test.go b/htpasswd/auth_test.go
@@ -1,7 +1,7 @@
package htpasswd
import (
- "github.com/stretchr/testify/assert"
+ . "github.com/stretchr/testify/assert"
"io/ioutil"
"testing"
)
@@ -20,61 +20,61 @@ bob-foo:{fooo}sdcsdcsdc/BfQ=
func TestClient_Hashes(t *testing.T) {
auth, err := NewAuth(writeTmpfile(testfile))
- assert.NoError(t, err)
+ NoError(t, err)
testUsers := []string{"bob-md5", "bob-bcrypt", "bob-sha"}
for _, name := range testUsers {
t.Run(name, func(t *testing.T) {
authenticated, err := auth.Authenticate(name, "secret")
- assert.NoError(t, err)
- assert.True(t, authenticated)
+ NoError(t, err)
+ True(t, authenticated)
authenticated, err = auth.Authenticate(name, "XXXXX")
- assert.NoError(t, err)
- assert.False(t, authenticated)
+ NoError(t, err)
+ False(t, authenticated)
})
}
}
func TestClient_UnknownUser(t *testing.T) {
auth, err := NewAuth(writeTmpfile(testfile))
- assert.NoError(t, err)
+ NoError(t, err)
authenticated, err := auth.Authenticate("unknown", "secret")
- assert.NoError(t, err)
- assert.False(t, authenticated)
+ NoError(t, err)
+ False(t, authenticated)
}
func TestClient_ErrorOnMissingFile(t *testing.T) {
_, err := NewAuth("/tmp/foo/bar/nothing")
- assert.Error(t, err)
+ Error(t, err)
}
func TestClient_ErrorOnInvalidFileContents(t *testing.T) {
_, err := NewAuth(writeTmpfile("foo bar bazz"))
- assert.Error(t, err)
+ Error(t, err)
_, err = NewAuth(writeTmpfile("foo:bar\nfoo:bar:bazz"))
- assert.Error(t, err)
+ Error(t, err)
}
func TestClient_BadMD5Format(t *testing.T) {
// missing $ separator in md5 hash
a, err := NewAuth(writeTmpfile("foo:$apr1$IDZSCL/oN68zaFDDRivjour94OVeB."))
- assert.NoError(t, err)
+ NoError(t, err)
authenticated, err := a.Authenticate("foo", "secret")
- assert.NoError(t, err)
- assert.False(t, authenticated)
+ NoError(t, err)
+ False(t, authenticated)
}
func TestClient_Hashes_UnknownAlgoError(t *testing.T) {
auth, err := NewAuth(writeTmpfile(testfile))
- assert.NoError(t, err)
+ NoError(t, err)
authenticated, err := auth.Authenticate("bob-foo", "secret")
- assert.Error(t, err)
- assert.False(t, authenticated)
+ Error(t, err)
+ False(t, authenticated)
}
func writeTmpfile(contents string) string {
diff --git a/htpasswd/backend_test.go b/htpasswd/backend_test.go
@@ -1,52 +1,52 @@
package htpasswd
import (
- "github.com/stretchr/testify/assert"
+ . "github.com/stretchr/testify/assert"
"github.com/tarent/loginsrv/login"
"testing"
)
func TestSetup(t *testing.T) {
p, exist := login.GetProvider(ProviderName)
- assert.True(t, exist)
- assert.NotNil(t, p)
+ True(t, exist)
+ NotNil(t, p)
file := writeTmpfile(testfile)
backend, err := p(map[string]string{
"file": file,
})
- assert.NoError(t, err)
- assert.Equal(t,
+ NoError(t, err)
+ Equal(t,
file,
backend.(*Backend).auth.filename)
}
func TestSetup_Error(t *testing.T) {
p, exist := login.GetProvider(ProviderName)
- assert.True(t, exist)
- assert.NotNil(t, p)
+ True(t, exist)
+ NotNil(t, p)
_, err := p(map[string]string{})
- assert.Error(t, err)
+ Error(t, err)
}
func TestSimpleBackend_Authenticate(t *testing.T) {
backend, err := NewBackend(writeTmpfile(testfile))
- assert.NoError(t, err)
+ NoError(t, err)
authenticated, userInfo, err := backend.Authenticate("bob-bcrypt", "secret")
- assert.True(t, authenticated)
- assert.Equal(t, "bob-bcrypt", userInfo.Sub)
- assert.NoError(t, err)
+ True(t, authenticated)
+ Equal(t, "bob-bcrypt", userInfo.Sub)
+ NoError(t, err)
authenticated, userInfo, err = backend.Authenticate("bob-bcrypt", "fooo")
- assert.False(t, authenticated)
- assert.Equal(t, "", userInfo.Sub)
- assert.NoError(t, err)
+ False(t, authenticated)
+ Equal(t, "", userInfo.Sub)
+ NoError(t, err)
authenticated, userInfo, err = backend.Authenticate("", "")
- assert.False(t, authenticated)
- assert.Equal(t, "", userInfo.Sub)
- assert.NoError(t, err)
+ False(t, authenticated)
+ Equal(t, "", userInfo.Sub)
+ NoError(t, err)
}
diff --git a/login/config_test.go b/login/config_test.go
@@ -2,7 +2,7 @@ package login
import (
"flag"
- "github.com/stretchr/testify/assert"
+ . "github.com/stretchr/testify/assert"
"os"
"testing"
"time"
@@ -16,7 +16,7 @@ func TestConfig_ReadConfigDefaults(t *testing.T) {
gotConfig := ReadConfig()
defaultConfig.JwtSecret = "random"
gotConfig.JwtSecret = "random"
- assert.Equal(t, defaultConfig, gotConfig)
+ Equal(t, defaultConfig, gotConfig)
}
func TestConfig_ReadConfig(t *testing.T) {
@@ -68,27 +68,27 @@ func TestConfig_ReadConfig(t *testing.T) {
}
cfg, err := readConfig(flag.NewFlagSet("", flag.ContinueOnError), input)
- assert.NoError(t, err)
- assert.Equal(t, expected, cfg)
+ NoError(t, err)
+ Equal(t, expected, cfg)
}
func TestConfig_ReadConfigFromEnv(t *testing.T) {
- assert.NoError(t, os.Setenv("LOGINSRV_HOST", "host"))
- assert.NoError(t, os.Setenv("LOGINSRV_PORT", "port"))
- assert.NoError(t, os.Setenv("LOGINSRV_LOG_LEVEL", "loglevel"))
- assert.NoError(t, os.Setenv("LOGINSRV_TEXT_LOGGING", "true"))
- assert.NoError(t, os.Setenv("LOGINSRV_JWT_SECRET", "jwtsecret"))
- assert.NoError(t, os.Setenv("LOGINSRV_JWT_EXPIRY", "42h42m"))
- assert.NoError(t, os.Setenv("LOGINSRV_SUCCESS_URL", "successurl"))
- assert.NoError(t, os.Setenv("LOGINSRV_LOGOUT_URL", "logouturl"))
- assert.NoError(t, os.Setenv("LOGINSRV_TEMPLATE", "template"))
- assert.NoError(t, os.Setenv("LOGINSRV_LOGIN_PATH", "loginpath"))
- assert.NoError(t, os.Setenv("LOGINSRV_COOKIE_NAME", "cookiename"))
- assert.NoError(t, os.Setenv("LOGINSRV_COOKIE_EXPIRY", "23m"))
- assert.NoError(t, os.Setenv("LOGINSRV_COOKIE_DOMAIN", "*.example.com"))
- assert.NoError(t, os.Setenv("LOGINSRV_COOKIE_HTTP_ONLY", "false"))
- assert.NoError(t, os.Setenv("LOGINSRV_SIMPLE", "foo=bar"))
- assert.NoError(t, os.Setenv("LOGINSRV_GITHUB", "client_id=foo,client_secret=bar"))
+ NoError(t, os.Setenv("LOGINSRV_HOST", "host"))
+ NoError(t, os.Setenv("LOGINSRV_PORT", "port"))
+ NoError(t, os.Setenv("LOGINSRV_LOG_LEVEL", "loglevel"))
+ NoError(t, os.Setenv("LOGINSRV_TEXT_LOGGING", "true"))
+ NoError(t, os.Setenv("LOGINSRV_JWT_SECRET", "jwtsecret"))
+ NoError(t, os.Setenv("LOGINSRV_JWT_EXPIRY", "42h42m"))
+ NoError(t, os.Setenv("LOGINSRV_SUCCESS_URL", "successurl"))
+ NoError(t, os.Setenv("LOGINSRV_LOGOUT_URL", "logouturl"))
+ NoError(t, os.Setenv("LOGINSRV_TEMPLATE", "template"))
+ NoError(t, os.Setenv("LOGINSRV_LOGIN_PATH", "loginpath"))
+ NoError(t, os.Setenv("LOGINSRV_COOKIE_NAME", "cookiename"))
+ NoError(t, os.Setenv("LOGINSRV_COOKIE_EXPIRY", "23m"))
+ NoError(t, os.Setenv("LOGINSRV_COOKIE_DOMAIN", "*.example.com"))
+ NoError(t, os.Setenv("LOGINSRV_COOKIE_HTTP_ONLY", "false"))
+ NoError(t, os.Setenv("LOGINSRV_SIMPLE", "foo=bar"))
+ NoError(t, os.Setenv("LOGINSRV_GITHUB", "client_id=foo,client_secret=bar"))
expected := &Config{
Host: "host",
@@ -119,6 +119,6 @@ func TestConfig_ReadConfigFromEnv(t *testing.T) {
}
cfg, err := readConfig(flag.NewFlagSet("", flag.ContinueOnError), []string{})
- assert.NoError(t, err)
- assert.Equal(t, expected, cfg)
+ NoError(t, err)
+ Equal(t, expected, cfg)
}
diff --git a/login/handler_test.go b/login/handler_test.go
@@ -4,7 +4,7 @@ import (
"errors"
"fmt"
"github.com/dgrijalva/jwt-go"
- "github.com/stretchr/testify/assert"
+ . "github.com/stretchr/testify/assert"
"github.com/tarent/loginsrv/model"
"github.com/tarent/loginsrv/oauth2"
"net/http"
@@ -90,11 +90,11 @@ func TestHandler_NewFromConfig(t *testing.T) {
t.Run(fmt.Sprintf("test %v", i), func(t *testing.T) {
h, err := NewHandler(test.config)
if test.expectError {
- assert.Error(t, err)
+ Error(t, err)
} else {
- assert.NoError(t, err)
- assert.Equal(t, test.backendCount, len(h.backends))
- assert.Equal(t, test.oauthCount, len(h.oauth.(*oauth2.Manager).GetConfigs()))
+ NoError(t, err)
+ Equal(t, test.backendCount, len(h.backends))
+ Equal(t, test.oauthCount, len(h.oauth.(*oauth2.Manager).GetConfigs()))
}
})
}
@@ -102,42 +102,42 @@ func TestHandler_NewFromConfig(t *testing.T) {
func TestHandler_LoginForm(t *testing.T) {
recorder := call(req("GET", "/context/login", ""))
- assert.Equal(t, 200, recorder.Code)
- assert.Contains(t, recorder.Body.String(), `class="container`)
- assert.Equal(t, "no-cache, no-store, must-revalidate", recorder.Header().Get("Cache-Control"))
+ Equal(t, 200, recorder.Code)
+ Contains(t, recorder.Body.String(), `class="container`)
+ Equal(t, "no-cache, no-store, must-revalidate", recorder.Header().Get("Cache-Control"))
}
func TestHandler_HEAD(t *testing.T) {
recorder := call(req("HEAD", "/context/login", ""))
- assert.Equal(t, 400, recorder.Code)
+ Equal(t, 400, recorder.Code)
}
func TestHandler_404(t *testing.T) {
recorder := call(req("GET", "/context/", ""))
- assert.Equal(t, 404, recorder.Code)
+ Equal(t, 404, recorder.Code)
recorder = call(req("GET", "/", ""))
- assert.Equal(t, 404, recorder.Code)
+ Equal(t, 404, recorder.Code)
- assert.Equal(t, "Not Found: The requested page does not exist", recorder.Body.String())
+ Equal(t, "Not Found: The requested page does not exist", recorder.Body.String())
}
func TestHandler_LoginJson(t *testing.T) {
// success
recorder := call(req("POST", "/context/login", `{"username": "bob", "password": "secret"}`, TypeJson, AcceptJwt))
- assert.Equal(t, 200, recorder.Code)
- assert.Equal(t, recorder.Header().Get("Content-Type"), "application/jwt")
+ Equal(t, 200, recorder.Code)
+ Equal(t, recorder.Header().Get("Content-Type"), "application/jwt")
// verify the token
claims, err := tokenAsMap(recorder.Body.String())
- assert.NoError(t, err)
- assert.Equal(t, "bob", claims["sub"])
- assert.InDelta(t, time.Now().Add(DefaultConfig().JwtExpiry).Unix(), claims["exp"], 2)
+ NoError(t, err)
+ Equal(t, "bob", claims["sub"])
+ InDelta(t, time.Now().Add(DefaultConfig().JwtExpiry).Unix(), claims["exp"], 2)
// wrong credentials
recorder = call(req("POST", "/context/login", `{"username": "bob", "password": "FOOOBAR"}`, TypeJson, AcceptJwt))
- assert.Equal(t, 403, recorder.Code)
- assert.Equal(t, "Wrong credentials", recorder.Body.String())
+ Equal(t, 403, recorder.Code)
+ Equal(t, "Wrong credentials", recorder.Body.String())
}
func TestHandler_HandleOauth(t *testing.T) {
@@ -163,8 +163,8 @@ func TestHandler_HandleOauth(t *testing.T) {
}
recorder := httptest.NewRecorder()
handler.ServeHTTP(recorder, req("GET", "/login/github", ""))
- assert.Equal(t, 303, recorder.Code)
- assert.Equal(t, "http://example.com", recorder.Header().Get("Location"))
+ Equal(t, 303, recorder.Code)
+ Equal(t, "http://example.com", recorder.Header().Get("Location"))
// test authentication
managerMock._Handle = func(w http.ResponseWriter, r *http.Request) (
@@ -176,10 +176,10 @@ func TestHandler_HandleOauth(t *testing.T) {
}
recorder = httptest.NewRecorder()
handler.ServeHTTP(recorder, req("GET", "/login/github", ""))
- assert.Equal(t, 200, recorder.Code)
+ Equal(t, 200, recorder.Code)
token, err := tokenAsMap(recorder.Body.String())
- assert.NoError(t, err)
- assert.Equal(t, "marvin", token["sub"])
+ NoError(t, err)
+ Equal(t, "marvin", token["sub"])
// test error in oauth
managerMock._Handle = func(w http.ResponseWriter, r *http.Request) (
@@ -191,7 +191,7 @@ func TestHandler_HandleOauth(t *testing.T) {
}
recorder = httptest.NewRecorder()
handler.ServeHTTP(recorder, req("GET", "/login/github", ""))
- assert.Equal(t, 500, recorder.Code)
+ Equal(t, 500, recorder.Code)
// test failure if no oauth action would be taken, because the url parameters where
// missing an action parts
@@ -204,67 +204,67 @@ func TestHandler_HandleOauth(t *testing.T) {
}
recorder = httptest.NewRecorder()
handler.ServeHTTP(recorder, req("GET", "/login/github", ""))
- assert.Equal(t, 403, recorder.Code)
+ Equal(t, 403, recorder.Code)
}
func TestHandler_LoginWeb(t *testing.T) {
// redirectSuccess
recorder := call(req("POST", "/context/login", "username=bob&password=secret", TypeForm, AcceptHtml))
- assert.Equal(t, 303, recorder.Code)
- assert.Equal(t, "/", recorder.Header().Get("Location"))
+ Equal(t, 303, recorder.Code)
+ Equal(t, "/", recorder.Header().Get("Location"))
// verify the token from the cookie
setCookieList := readSetCookies(recorder.Header())
- assert.Equal(t, 1, len(setCookieList))
+ Equal(t, 1, len(setCookieList))
cookie := setCookieList[0]
- assert.Equal(t, "jwt_token", cookie.Name)
- assert.Equal(t, "/", cookie.Path)
- assert.Equal(t, "example.com", cookie.Domain)
- assert.InDelta(t, time.Now().Add(testConfig().CookieExpiry).Unix(), cookie.Expires.Unix(), 2)
- assert.True(t, cookie.HttpOnly)
+ Equal(t, "jwt_token", cookie.Name)
+ Equal(t, "/", cookie.Path)
+ Equal(t, "example.com", cookie.Domain)
+ InDelta(t, time.Now().Add(testConfig().CookieExpiry).Unix(), cookie.Expires.Unix(), 2)
+ True(t, cookie.HttpOnly)
// check the token contens
claims, err := tokenAsMap(cookie.Value)
- assert.NoError(t, err)
- assert.Equal(t, "bob", claims["sub"])
- assert.InDelta(t, time.Now().Add(DefaultConfig().JwtExpiry).Unix(), claims["exp"], 2)
+ NoError(t, err)
+ Equal(t, "bob", claims["sub"])
+ InDelta(t, time.Now().Add(DefaultConfig().JwtExpiry).Unix(), claims["exp"], 2)
// show the login form again after authentication failed
recorder = call(req("POST", "/context/login", "username=bob&password=FOOBAR", TypeForm, AcceptHtml))
- assert.Equal(t, 403, recorder.Code)
- assert.Contains(t, recorder.Body.String(), `class="container"`)
- assert.Equal(t, recorder.Header().Get("Set-Cookie"), "")
+ Equal(t, 403, recorder.Code)
+ Contains(t, recorder.Body.String(), `class="container"`)
+ Equal(t, recorder.Header().Get("Set-Cookie"), "")
}
func TestHandler_Logout(t *testing.T) {
// DELETE
recorder := call(req("DELETE", "/context/login", ""))
- assert.Equal(t, 200, recorder.Code)
+ Equal(t, 200, recorder.Code)
checkDeleteCookei(t, recorder.Header())
// GET + param
recorder = call(req("GET", "/context/login?logout=true", ""))
- assert.Equal(t, 200, recorder.Code)
+ Equal(t, 200, recorder.Code)
checkDeleteCookei(t, recorder.Header())
// POST + param
recorder = call(req("POST", "/context/login", "logout=true", TypeForm))
- assert.Equal(t, 200, recorder.Code)
+ Equal(t, 200, recorder.Code)
checkDeleteCookei(t, recorder.Header())
- assert.Equal(t, "no-cache, no-store, must-revalidate", recorder.Header().Get("Cache-Control"))
+ Equal(t, "no-cache, no-store, must-revalidate", recorder.Header().Get("Cache-Control"))
}
func checkDeleteCookei(t *testing.T, h http.Header) {
setCookieList := readSetCookies(h)
- assert.Equal(t, 1, len(setCookieList))
+ Equal(t, 1, len(setCookieList))
cookie := setCookieList[0]
- assert.Equal(t, "jwt_token", cookie.Name)
- assert.Equal(t, "/", cookie.Path)
- assert.Equal(t, "example.com", cookie.Domain)
- assert.Equal(t, int64(0), cookie.Expires.Unix())
+ Equal(t, "jwt_token", cookie.Name)
+ Equal(t, "/", cookie.Path)
+ Equal(t, "example.com", cookie.Domain)
+ Equal(t, int64(0), cookie.Expires.Unix())
}
func TestHandler_CustomLogoutUrl(t *testing.T) {
@@ -277,9 +277,9 @@ func TestHandler_CustomLogoutUrl(t *testing.T) {
recorder := httptest.NewRecorder()
h.ServeHTTP(recorder, req("DELETE", "/login", ""))
- assert.Contains(t, recorder.Header().Get("Set-Cookie"), "jwt_token=delete; Path=/; Expires=Thu, 01 Jan 1970 00:00:00 GMT;")
- assert.Equal(t, 303, recorder.Code)
- assert.Equal(t, "http://example.com", recorder.Header().Get("Location"))
+ Contains(t, recorder.Header().Get("Set-Cookie"), "jwt_token=delete; Path=/; Expires=Thu, 01 Jan 1970 00:00:00 GMT;")
+ Equal(t, 303, recorder.Code)
+ Equal(t, "http://example.com", recorder.Header().Get("Location"))
}
func TestHandler_LoginError(t *testing.T) {
@@ -290,39 +290,39 @@ func TestHandler_LoginError(t *testing.T) {
recorder := httptest.NewRecorder()
h.ServeHTTP(recorder, request)
- assert.Equal(t, 500, recorder.Code)
- assert.Equal(t, recorder.Header().Get("Content-Type"), "text/plain")
- assert.Equal(t, recorder.Body.String(), "Internal Server Error")
+ Equal(t, 500, recorder.Code)
+ Equal(t, recorder.Header().Get("Content-Type"), "text/plain")
+ Equal(t, recorder.Body.String(), "Internal Server Error")
// backend returning an error with result type == html
request = req("POST", "/context/login", `{"username": "bob", "password": "secret"}`, TypeJson, AcceptHtml)
recorder = httptest.NewRecorder()
h.ServeHTTP(recorder, request)
- assert.Equal(t, 500, recorder.Code)
- assert.Contains(t, recorder.Header().Get("Content-Type"), "text/html")
- assert.Contains(t, recorder.Body.String(), `class="container"`)
- assert.Contains(t, recorder.Body.String(), "Internal Error")
+ Equal(t, 500, recorder.Code)
+ Contains(t, recorder.Header().Get("Content-Type"), "text/html")
+ Contains(t, recorder.Body.String(), `class="container"`)
+ Contains(t, recorder.Body.String(), "Internal Error")
}
func TestHandler_getToken_Valid(t *testing.T) {
h := testHandler()
input := model.UserInfo{Sub: "marvin", Expiry: time.Now().Add(time.Second).Unix()}
token, err := h.createToken(input)
- assert.NoError(t, err)
+ NoError(t, err)
r := &http.Request{
Header: http.Header{"Cookie": {h.config.CookieName + "=" + token + ";"}},
}
userInfo, valid := h.getToken(r)
- assert.True(t, valid)
- assert.Equal(t, input, userInfo)
+ True(t, valid)
+ Equal(t, input, userInfo)
}
func TestHandler_getToken_InvalidSecret(t *testing.T) {
h := testHandler()
input := model.UserInfo{Sub: "marvin"}
token, err := h.createToken(input)
- assert.NoError(t, err)
+ NoError(t, err)
r := &http.Request{
Header: http.Header{"Cookie": {h.config.CookieName + "=" + token + ";"}},
}
@@ -331,7 +331,7 @@ func TestHandler_getToken_InvalidSecret(t *testing.T) {
h.config.JwtSecret = "foobar"
_, valid := h.getToken(r)
- assert.False(t, valid)
+ False(t, valid)
}
func TestHandler_getToken_InvalidToken(t *testing.T) {
@@ -341,13 +341,13 @@ func TestHandler_getToken_InvalidToken(t *testing.T) {
}
_, valid := h.getToken(r)
- assert.False(t, valid)
+ False(t, valid)
}
func TestHandler_getToken_InvalidNoToken(t *testing.T) {
h := testHandler()
_, valid := h.getToken(&http.Request{})
- assert.False(t, valid)
+ False(t, valid)
}
func testHandler() *Handler {
diff --git a/login/login_form_test.go b/login/login_form_test.go
@@ -1,7 +1,7 @@
package login
import (
- "github.com/stretchr/testify/assert"
+ . "github.com/stretchr/testify/assert"
"github.com/tarent/loginsrv/model"
"io/ioutil"
"net/http/httptest"
@@ -19,10 +19,10 @@ func Test_form(t *testing.T) {
Backends: Options{"simple": {}},
},
})
- assert.Contains(t, recorder.Body.String(), `<form`)
- assert.NotContains(t, recorder.Body.String(), `github`)
- assert.NotContains(t, recorder.Body.String(), `Welcome`)
- assert.Contains(t, recorder.Body.String(), `Error`)
+ Contains(t, recorder.Body.String(), `<form`)
+ NotContains(t, recorder.Body.String(), `github`)
+ NotContains(t, recorder.Body.String(), `Welcome`)
+ Contains(t, recorder.Body.String(), `Error`)
// only form
recorder = httptest.NewRecorder()
@@ -32,10 +32,10 @@ func Test_form(t *testing.T) {
Backends: Options{"simple": {}},
},
})
- assert.Contains(t, recorder.Body.String(), `<form`)
- assert.NotContains(t, recorder.Body.String(), `github`)
- assert.NotContains(t, recorder.Body.String(), `Welcome`)
- assert.NotContains(t, recorder.Body.String(), `Error`)
+ Contains(t, recorder.Body.String(), `<form`)
+ NotContains(t, recorder.Body.String(), `github`)
+ NotContains(t, recorder.Body.String(), `Welcome`)
+ NotContains(t, recorder.Body.String(), `Error`)
// only links
recorder = httptest.NewRecorder()
@@ -45,10 +45,10 @@ func Test_form(t *testing.T) {
Oauth: Options{"github": {}},
},
})
- assert.NotContains(t, recorder.Body.String(), `<form`)
- assert.Contains(t, recorder.Body.String(), `href="/login/github"`)
- assert.NotContains(t, recorder.Body.String(), `Welcome`)
- assert.NotContains(t, recorder.Body.String(), `Error`)
+ NotContains(t, recorder.Body.String(), `<form`)
+ Contains(t, recorder.Body.String(), `href="/login/github"`)
+ NotContains(t, recorder.Body.String(), `Welcome`)
+ NotContains(t, recorder.Body.String(), `Error`)
// with form and links
recorder = httptest.NewRecorder()
@@ -59,10 +59,10 @@ func Test_form(t *testing.T) {
Oauth: Options{"github": {}},
},
})
- assert.Contains(t, recorder.Body.String(), `<form`)
- assert.Contains(t, recorder.Body.String(), `href="/login/github"`)
- assert.NotContains(t, recorder.Body.String(), `Welcome`)
- assert.NotContains(t, recorder.Body.String(), `Error`)
+ Contains(t, recorder.Body.String(), `<form`)
+ Contains(t, recorder.Body.String(), `href="/login/github"`)
+ NotContains(t, recorder.Body.String(), `Welcome`)
+ NotContains(t, recorder.Body.String(), `Error`)
// show only the user info
recorder = httptest.NewRecorder()
@@ -75,21 +75,21 @@ func Test_form(t *testing.T) {
Oauth: Options{"github": {}},
},
})
- assert.NotContains(t, recorder.Body.String(), `<form`)
- assert.NotContains(t, recorder.Body.String(), `href="/login/github"`)
- assert.Contains(t, recorder.Body.String(), `Welcome smancke`)
- assert.NotContains(t, recorder.Body.String(), `Error`)
+ NotContains(t, recorder.Body.String(), `<form`)
+ NotContains(t, recorder.Body.String(), `href="/login/github"`)
+ Contains(t, recorder.Body.String(), `Welcome smancke`)
+ NotContains(t, recorder.Body.String(), `Error`)
}
func Test_form_executeError(t *testing.T) {
recorder := httptest.NewRecorder()
writeLoginForm(recorder, loginFormData{})
- assert.Equal(t, 500, recorder.Code)
+ Equal(t, 500, recorder.Code)
}
func Test_form_customTemplate(t *testing.T) {
f, err := ioutil.TempFile("", "")
- assert.NoError(t, err)
+ NoError(t, err)
f.WriteString(`<html><body>My custom template {{template "login" .}}</body></html>`)
f.Close()
defer os.Remove(f.Name())
@@ -103,17 +103,17 @@ func Test_form_customTemplate(t *testing.T) {
Template: f.Name(),
},
})
- assert.Contains(t, recorder.Body.String(), `My custom template`)
- assert.Contains(t, recorder.Body.String(), `<form`)
- assert.NotContains(t, recorder.Body.String(), `github`)
- assert.NotContains(t, recorder.Body.String(), `Welcome`)
- assert.NotContains(t, recorder.Body.String(), `Error`)
- assert.NotContains(t, recorder.Body.String(), `style`)
+ Contains(t, recorder.Body.String(), `My custom template`)
+ Contains(t, recorder.Body.String(), `<form`)
+ NotContains(t, recorder.Body.String(), `github`)
+ NotContains(t, recorder.Body.String(), `Welcome`)
+ NotContains(t, recorder.Body.String(), `Error`)
+ NotContains(t, recorder.Body.String(), `style`)
}
func Test_form_customTemplate_ParseError(t *testing.T) {
f, err := ioutil.TempFile("", "")
- assert.NoError(t, err)
+ NoError(t, err)
f.WriteString(`<html><body>My custom template {{template "login" `)
f.Close()
defer os.Remove(f.Name())
@@ -126,7 +126,7 @@ func Test_form_customTemplate_ParseError(t *testing.T) {
Template: f.Name(),
},
})
- assert.Equal(t, 500, recorder.Code)
+ Equal(t, 500, recorder.Code)
}
func Test_form_customTemplate_MissingFile(t *testing.T) {
@@ -136,11 +136,11 @@ func Test_form_customTemplate_MissingFile(t *testing.T) {
Template: "/this/file/does/not/exist",
},
})
- assert.Equal(t, 500, recorder.Code)
+ Equal(t, 500, recorder.Code)
}
func Test_ucfirst(t *testing.T) {
- assert.Equal(t, "", ucfirst(""))
- assert.Equal(t, "A", ucfirst("a"))
- assert.Equal(t, "Abc def", ucfirst("abc def"))
+ Equal(t, "", ucfirst(""))
+ Equal(t, "A", ucfirst("a"))
+ Equal(t, "Abc def", ucfirst("abc def"))
}
diff --git a/login/simple_backend_test.go b/login/simple_backend_test.go
@@ -1,21 +1,21 @@
package login
import (
- "github.com/stretchr/testify/assert"
+ . "github.com/stretchr/testify/assert"
"testing"
)
func TestSetup(t *testing.T) {
p, exist := GetProvider(SimpleProviderName)
- assert.True(t, exist)
- assert.NotNil(t, p)
+ True(t, exist)
+ NotNil(t, p)
backend, err := p(map[string]string{
"bob": "secret",
})
- assert.NoError(t, err)
- assert.Equal(t,
+ NoError(t, err)
+ Equal(t,
map[string]string{
"bob": "secret",
},
@@ -28,17 +28,17 @@ func TestSimpleBackend_Authenticate(t *testing.T) {
})
authenticated, userInfo, err := backend.Authenticate("bob", "secret")
- assert.True(t, authenticated)
- assert.Equal(t, "bob", userInfo.Sub)
- assert.NoError(t, err)
+ True(t, authenticated)
+ Equal(t, "bob", userInfo.Sub)
+ NoError(t, err)
authenticated, userInfo, err = backend.Authenticate("bob", "fooo")
- assert.False(t, authenticated)
- assert.Equal(t, "", userInfo.Sub)
- assert.NoError(t, err)
+ False(t, authenticated)
+ Equal(t, "", userInfo.Sub)
+ NoError(t, err)
authenticated, userInfo, err = backend.Authenticate("", "")
- assert.False(t, authenticated)
- assert.Equal(t, "", userInfo.Sub)
- assert.NoError(t, err)
+ False(t, authenticated)
+ Equal(t, "", userInfo.Sub)
+ NoError(t, err)
}
diff --git a/main_test.go b/main_test.go
@@ -2,7 +2,7 @@ package main
import (
"github.com/dgrijalva/jwt-go"
- "github.com/stretchr/testify/assert"
+ . "github.com/stretchr/testify/assert"
"io/ioutil"
"net/http"
"os"
@@ -25,25 +25,25 @@ func Test_BasicEndToEnd(t *testing.T) {
// success
req, err := http.NewRequest("POST", "http://localhost:3000/login", strings.NewReader(`{"username": "bob", "password": "secret"}`))
- assert.NoError(t, err)
+ NoError(t, err)
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Accept", "application/jwt")
r, err := http.DefaultClient.Do(req)
- assert.NoError(t, err)
+ NoError(t, err)
- assert.Equal(t, 200, r.StatusCode)
- assert.Equal(t, r.Header.Get("Content-Type"), "application/jwt")
+ Equal(t, 200, r.StatusCode)
+ Equal(t, r.Header.Get("Content-Type"), "application/jwt")
b, err := ioutil.ReadAll(r.Body)
- assert.NoError(t, err)
+ NoError(t, err)
token, err := jwt.Parse(string(b), func(*jwt.Token) (interface{}, error) {
return []byte(secret), nil
})
- assert.NoError(t, err)
+ NoError(t, err)
if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
- assert.Equal(t, "bob", claims["sub"])
+ Equal(t, "bob", claims["sub"])
} else {
t.Fail()
}
diff --git a/oauth2/github_test.go b/oauth2/github_test.go
@@ -1,7 +1,7 @@
package oauth2
import (
- "github.com/stretchr/testify/assert"
+ . "github.com/stretchr/testify/assert"
"net/http"
"net/http/httptest"
"testing"
@@ -42,7 +42,7 @@ var githubTestUserResponse = `{
func Test_Github_getUserInfo(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- assert.Equal(t, "secret", r.FormValue("access_token"))
+ Equal(t, "secret", r.FormValue("access_token"))
w.Header().Set("Content-Type", "application/json; charset=utf-8")
w.Write([]byte(githubTestUserResponse))
}))
@@ -51,9 +51,9 @@ func Test_Github_getUserInfo(t *testing.T) {
githubApi = server.URL
u, rawJson, err := providerGithub.GetUserInfo(TokenInfo{AccessToken: "secret"})
- assert.NoError(t, err)
- assert.Equal(t, "octocat", u.Sub)
- assert.Equal(t, "octocat@github.com", u.Email)
- assert.Equal(t, "monalisa octocat", u.Name)
- assert.Equal(t, githubTestUserResponse, rawJson)
+ NoError(t, err)
+ Equal(t, "octocat", u.Sub)
+ Equal(t, "octocat@github.com", u.Email)
+ Equal(t, "monalisa octocat", u.Name)
+ Equal(t, githubTestUserResponse, rawJson)
}
diff --git a/oauth2/manager_test.go b/oauth2/manager_test.go
@@ -3,7 +3,7 @@ package oauth2
import (
"crypto/tls"
"errors"
- "github.com/stretchr/testify/assert"
+ . "github.com/stretchr/testify/assert"
"github.com/tarent/loginsrv/model"
"net/http"
"net/http/httptest"
@@ -21,7 +21,7 @@ func Test_Manager_Positive_Flow(t *testing.T) {
TokenURL: "https://example.com/login/oauth/access_token",
GetUserInfo: func(token TokenInfo) (model.UserInfo, string, error) {
getUserInfoCalled = true
- assert.Equal(t, token, expectedToken)
+ Equal(t, token, expectedToken)
return model.UserInfo{
Sub: "the-username",
}, "", nil
@@ -63,13 +63,13 @@ func Test_Manager_Positive_Flow(t *testing.T) {
r, _ := http.NewRequest("GET", "http://example.com/login/"+exampleProvider.Name, nil)
startedFlow, authenticated, userInfo, err := m.Handle(httptest.NewRecorder(), r)
- assert.NoError(t, err)
- assert.True(t, startedFlow)
- assert.False(t, authenticated)
- assert.Equal(t, model.UserInfo{}, userInfo)
+ NoError(t, err)
+ True(t, startedFlow)
+ False(t, authenticated)
+ Equal(t, model.UserInfo{}, userInfo)
- assert.True(t, startFlowCalled)
- assert.False(t, authenticateCalled)
+ True(t, startFlowCalled)
+ False(t, authenticateCalled)
assertEqualConfig(t, expectedConfig, startFlowReceivedConfig)
@@ -77,14 +77,14 @@ func Test_Manager_Positive_Flow(t *testing.T) {
r, _ = http.NewRequest("GET", "http://example.com/login/"+exampleProvider.Name+"?code=xyz", nil)
startedFlow, authenticated, userInfo, err = m.Handle(httptest.NewRecorder(), r)
- assert.NoError(t, err)
- assert.False(t, startedFlow)
- assert.True(t, authenticated)
- assert.Equal(t, model.UserInfo{Sub: "the-username"}, userInfo)
- assert.True(t, authenticateCalled)
+ NoError(t, err)
+ False(t, startedFlow)
+ True(t, authenticated)
+ Equal(t, model.UserInfo{Sub: "the-username"}, userInfo)
+ True(t, authenticateCalled)
assertEqualConfig(t, expectedConfig, authenticateReceivedConfig)
- assert.True(t, getUserInfoCalled)
+ True(t, getUserInfoCalled)
}
func Test_Manager_NoAauthOnWrongCode(t *testing.T) {
@@ -117,12 +117,12 @@ func Test_Manager_NoAauthOnWrongCode(t *testing.T) {
r, _ := http.NewRequest("GET", "http://example.com/login/"+exampleProvider.Name+"?code=xyz", nil)
startedFlow, authenticated, userInfo, err := m.Handle(httptest.NewRecorder(), r)
- assert.EqualError(t, err, "code not valid")
- assert.False(t, startedFlow)
- assert.False(t, authenticated)
- assert.Equal(t, model.UserInfo{}, userInfo)
- assert.True(t, authenticateCalled)
- assert.False(t, getUserInfoCalled)
+ EqualError(t, err, "code not valid")
+ False(t, startedFlow)
+ False(t, authenticated)
+ Equal(t, model.UserInfo{}, userInfo)
+ True(t, authenticateCalled)
+ False(t, getUserInfoCalled)
}
func Test_Manager_getConfig_ErrorCase(t *testing.T) {
@@ -135,19 +135,19 @@ func Test_Manager_getConfig_ErrorCase(t *testing.T) {
})
_, err := m.GetConfigFromRequest(r)
- assert.EqualError(t, err, "no oauth configuration for login")
+ EqualError(t, err, "no oauth configuration for login")
}
func Test_Manager_AddConfig_ErrorCases(t *testing.T) {
m := NewManager()
- assert.NoError(t,
+ NoError(t,
m.AddConfig("github", map[string]string{
"client_id": "foo",
"client_secret": "bar",
}))
- assert.EqualError(t,
+ EqualError(t,
m.AddConfig("FOOOO", map[string]string{
"client_id": "foo",
"client_secret": "bar",
@@ -155,14 +155,14 @@ func Test_Manager_AddConfig_ErrorCases(t *testing.T) {
"no provider for name FOOOO",
)
- assert.EqualError(t,
+ EqualError(t,
m.AddConfig("github", map[string]string{
"client_secret": "bar",
}),
"missing parameter client_id",
)
- assert.EqualError(t,
+ EqualError(t,
m.AddConfig("github", map[string]string{
"client_id": "foo",
}),
@@ -218,7 +218,7 @@ func Test_Manager_redirectUriFromRequest(t *testing.T) {
r.TLS = &tls.ConnectionState{}
}
uri := redirectUriFromRequest(r)
- assert.Equal(t, test.expected, uri)
+ Equal(t, test.expected, uri)
})
}
}
@@ -241,16 +241,16 @@ func Test_Manager_RedirectURI_Generation(t *testing.T) {
r, _ := http.NewRequest("GET", callUrl, nil)
_, _, _, err := m.Handle(httptest.NewRecorder(), r)
- assert.NoError(t, err)
- assert.Equal(t, callUrl, startFlowReceivedConfig.RedirectURI)
+ NoError(t, err)
+ Equal(t, callUrl, startFlowReceivedConfig.RedirectURI)
}
func assertEqualConfig(t *testing.T, c1, c2 Config) {
- assert.Equal(t, c1.AuthURL, c2.AuthURL)
- assert.Equal(t, c1.ClientID, c2.ClientID)
- assert.Equal(t, c1.ClientSecret, c2.ClientSecret)
- assert.Equal(t, c1.Scope, c2.Scope)
- assert.Equal(t, c1.RedirectURI, c2.RedirectURI)
- assert.Equal(t, c1.TokenURL, c2.TokenURL)
- assert.Equal(t, c1.Provider.Name, c2.Provider.Name)
+ Equal(t, c1.AuthURL, c2.AuthURL)
+ Equal(t, c1.ClientID, c2.ClientID)
+ Equal(t, c1.ClientSecret, c2.ClientSecret)
+ Equal(t, c1.Scope, c2.Scope)
+ Equal(t, c1.RedirectURI, c2.RedirectURI)
+ Equal(t, c1.TokenURL, c2.TokenURL)
+ Equal(t, c1.Provider.Name, c2.Provider.Name)
}
diff --git a/oauth2/oauth_test.go b/oauth2/oauth_test.go
@@ -2,7 +2,7 @@ package oauth2
import (
"fmt"
- "github.com/stretchr/testify/assert"
+ . "github.com/stretchr/testify/assert"
"io/ioutil"
"net/http"
"net/http/httptest"
@@ -24,11 +24,11 @@ func Test_StartFlow(t *testing.T) {
resp := httptest.NewRecorder()
StartFlow(testConfig, resp)
- assert.Equal(t, http.StatusFound, resp.Code)
+ Equal(t, http.StatusFound, resp.Code)
// assert that we received a state cookie
cHeader := strings.Split(resp.Header().Get("Set-Cookie"), ";")[0]
- assert.Equal(t, stateCookieName, strings.Split(cHeader, "=")[0])
+ Equal(t, stateCookieName, strings.Split(cHeader, "=")[0])
state := strings.Split(cHeader, "=")[1]
expectedLocation := fmt.Sprintf("%v?client_id=%v&redirect_uri=%v&response_type=code&scope=%v&state=%v",
@@ -39,18 +39,18 @@ func Test_StartFlow(t *testing.T) {
state,
)
- assert.Equal(t, expectedLocation, resp.Header().Get("Location"))
+ Equal(t, expectedLocation, resp.Header().Get("Location"))
}
func Test_Authenticate(t *testing.T) {
// mock a server for token exchange
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- assert.Equal(t, "POST", r.Method)
- assert.Equal(t, "application/x-www-form-urlencoded", r.Header.Get("Content-Type"))
- assert.Equal(t, "application/json", r.Header.Get("Accept"))
+ Equal(t, "POST", r.Method)
+ Equal(t, "application/x-www-form-urlencoded", r.Header.Get("Content-Type"))
+ Equal(t, "application/json", r.Header.Get("Accept"))
body, _ := ioutil.ReadAll(r.Body)
- assert.Equal(t, "client_id=client42&client_secret=secret&code=theCode", string(body))
+ Equal(t, "client_id=client42&client_secret=secret&code=theCode", string(body))
w.Header().Set("Content-Type", "application/json")
w.Write([]byte(`{"access_token":"e72e16c7e42f292c6912e7710c838347ae178b4a", "scope":"repo gist", "token_type":"bearer"}`))
@@ -66,10 +66,10 @@ func Test_Authenticate(t *testing.T) {
tokenInfo, err := Authenticate(testConfigCopy, request)
- assert.NoError(t, err)
- assert.Equal(t, "e72e16c7e42f292c6912e7710c838347ae178b4a", tokenInfo.AccessToken)
- assert.Equal(t, "repo gist", tokenInfo.Scope)
- assert.Equal(t, "bearer", tokenInfo.TokenType)
+ NoError(t, err)
+ Equal(t, "e72e16c7e42f292c6912e7710c838347ae178b4a", tokenInfo.AccessToken)
+ Equal(t, "repo gist", tokenInfo.Scope)
+ Equal(t, "bearer", tokenInfo.TokenType)
}
func Test_Authenticate_CodeExchangeError(t *testing.T) {
@@ -92,22 +92,22 @@ func Test_Authenticate_CodeExchangeError(t *testing.T) {
testReturnCode = 500
tokenInfo, err := Authenticate(testConfigCopy, request)
- assert.Error(t, err)
- assert.EqualError(t, err, "error: expected http status 200 on token exchange, but got 500")
- assert.Equal(t, "", tokenInfo.AccessToken)
+ Error(t, err)
+ EqualError(t, err, "error: expected http status 200 on token exchange, but got 500")
+ Equal(t, "", tokenInfo.AccessToken)
testReturnCode = 200
tokenInfo, err = Authenticate(testConfigCopy, request)
- assert.Error(t, err)
- assert.EqualError(t, err, `error: got "bad_verification_code" on token exchange`)
- assert.Equal(t, "", tokenInfo.AccessToken)
+ Error(t, err)
+ EqualError(t, err, `error: got "bad_verification_code" on token exchange`)
+ Equal(t, "", tokenInfo.AccessToken)
testReturnCode = 200
testResponseJson = `{"foo": "bar"}`
tokenInfo, err = Authenticate(testConfigCopy, request)
- assert.Error(t, err)
- assert.EqualError(t, err, `error: no access_token on token exchange`)
- assert.Equal(t, "", tokenInfo.AccessToken)
+ Error(t, err)
+ EqualError(t, err, `error: no access_token on token exchange`)
+ Equal(t, "", tokenInfo.AccessToken)
}
@@ -117,8 +117,8 @@ func Test_Authentication_ProviderError(t *testing.T) {
_, err := Authenticate(testConfig, request)
- assert.Error(t, err)
- assert.Equal(t, "error: provider_login_error", err.Error())
+ Error(t, err)
+ Equal(t, "error: provider_login_error", err.Error())
}
func Test_Authentication_StateError(t *testing.T) {
@@ -128,8 +128,8 @@ func Test_Authentication_StateError(t *testing.T) {
_, err := Authenticate(testConfig, request)
- assert.Error(t, err)
- assert.Equal(t, "error: oauth state param could not be verified", err.Error())
+ Error(t, err)
+ Equal(t, "error: oauth state param could not be verified", err.Error())
}
func Test_Authentication_NoCodeError(t *testing.T) {
@@ -139,8 +139,8 @@ func Test_Authentication_NoCodeError(t *testing.T) {
_, err := Authenticate(testConfig, request)
- assert.Error(t, err)
- assert.Equal(t, "error: no auth code provided", err.Error())
+ Error(t, err)
+ Equal(t, "error: no auth code provided", err.Error())
}
func Test_Authentication_Provider500(t *testing.T) {
@@ -159,8 +159,8 @@ func Test_Authentication_Provider500(t *testing.T) {
_, err := Authenticate(testConfigCopy, request)
- assert.Error(t, err)
- assert.Equal(t, "error: expected http status 200 on token exchange, but got 500", err.Error())
+ Error(t, err)
+ Equal(t, "error: expected http status 200 on token exchange, but got 500", err.Error())
}
func Test_Authentication_ProviderNetworkError(t *testing.T) {
@@ -174,8 +174,8 @@ func Test_Authentication_ProviderNetworkError(t *testing.T) {
_, err := Authenticate(testConfigCopy, request)
- assert.Error(t, err)
- assert.Contains(t, err.Error(), "invalid port")
+ Error(t, err)
+ Contains(t, err.Error(), "invalid port")
}
func Test_Authentication_TokenParseError(t *testing.T) {
@@ -197,6 +197,6 @@ func Test_Authentication_TokenParseError(t *testing.T) {
_, err := Authenticate(testConfigCopy, request)
- assert.Error(t, err)
- assert.Equal(t, "error on parsing oauth token: unexpected end of JSON input", err.Error())
+ Error(t, err)
+ Equal(t, "error on parsing oauth token: unexpected end of JSON input", err.Error())
}
diff --git a/oauth2/provider_test.go b/oauth2/provider_test.go
@@ -1,16 +1,16 @@
package oauth2
import (
- "github.com/stretchr/testify/assert"
+ . "github.com/stretchr/testify/assert"
"testing"
)
func Test_ProviderRegistration(t *testing.T) {
github, exist := GetProvider("github")
- assert.NotNil(t, github)
- assert.True(t, exist)
+ NotNil(t, github)
+ True(t, exist)
list := ProviderList()
- assert.Equal(t, 1, len(list))
- assert.Equal(t, "github", list[0])
+ Equal(t, 1, len(list))
+ Equal(t, "github", list[0])
}
diff --git a/osiam/backend_test.go b/osiam/backend_test.go
@@ -1,7 +1,7 @@
package osiam
import (
- "github.com/stretchr/testify/assert"
+ . "github.com/stretchr/testify/assert"
"github.com/tarent/loginsrv/model"
"net/http"
"net/http/httptest"
@@ -14,12 +14,12 @@ func TestBackend_Authenticate(t *testing.T) {
// positive case
backend, err := NewBackend(server.URL, "example-client", "secret")
- assert.NoError(t, err)
+ NoError(t, err)
authenticated, userInfo, err := backend.Authenticate("admin", "koala")
- assert.NoError(t, err)
- assert.True(t, authenticated)
- assert.Equal(t,
+ NoError(t, err)
+ True(t, authenticated)
+ Equal(t,
model.UserInfo{
Sub: "admin",
},
@@ -27,27 +27,27 @@ func TestBackend_Authenticate(t *testing.T) {
// wrong client credentials
backend, err = NewBackend(server.URL, "example-client", "XXX")
- assert.NoError(t, err)
+ NoError(t, err)
authenticated, userInfo, err = backend.Authenticate("admin", "koala")
- assert.Error(t, err)
- assert.False(t, authenticated)
+ Error(t, err)
+ False(t, authenticated)
// wrong user credentials
backend, err = NewBackend(server.URL, "example-client", "secret")
- assert.NoError(t, err)
+ NoError(t, err)
authenticated, userInfo, err = backend.Authenticate("admin", "XXX")
- assert.NoError(t, err)
- assert.False(t, authenticated)
+ NoError(t, err)
+ False(t, authenticated)
}
func TestBackend_AuthenticateErrorCases(t *testing.T) {
_, err := NewBackend("://", "example-client", "secret")
- assert.Error(t, err)
+ Error(t, err)
_, err = NewBackend("http://example.com", "", "secret")
- assert.Error(t, err)
+ Error(t, err)
_, err = NewBackend("http://example.com", "example-client", "")
- assert.Error(t, err)
+ Error(t, err)
}
diff --git a/osiam/client_test.go b/osiam/client_test.go
@@ -2,7 +2,7 @@ package osiam
import (
"fmt"
- "github.com/stretchr/testify/assert"
+ . "github.com/stretchr/testify/assert"
"io/ioutil"
"net/http"
"net/http/httptest"
@@ -17,9 +17,9 @@ func TestClient_GetTokenByPassword(t *testing.T) {
client := NewClient(server.URL, "example-client", "secret")
authenticated, token, err := client.GetTokenByPassword("admin", "koala")
- assert.NoError(t, err)
- assert.True(t, authenticated)
- assert.Equal(t,
+ NoError(t, err)
+ True(t, authenticated)
+ Equal(t,
&Token{
Userid: "84f6cffa-4505-48ec-a851-424160892283",
ExpiresIn: 28493,
@@ -33,8 +33,8 @@ func TestClient_GetTokenByPassword(t *testing.T) {
Scope: "ME",
},
token)
- assert.True(t, len(token.RefreshToken) > 0)
- assert.True(t, token.ExpiresIn > 0)
+ True(t, len(token.RefreshToken) > 0)
+ True(t, token.ExpiresIn > 0)
}
func TestClient_GetTokenByPasswordErrorCases(t *testing.T) {
@@ -44,23 +44,23 @@ func TestClient_GetTokenByPasswordErrorCases(t *testing.T) {
// wrong credentials
client := NewClient(server.URL, "example-client", "secret")
authenticated, _, err := client.GetTokenByPassword("admin", "XXX")
- assert.NoError(t, err)
- assert.False(t, authenticated)
+ NoError(t, err)
+ False(t, authenticated)
// wrong url -> 404
client = NewClient(server.URL+"/Foo", "example-client", "secret")
_, _, err = client.GetTokenByPassword("admin", "koala")
- assert.Error(t, err)
+ Error(t, err)
// wrong client secret
client = NewClient(server.URL, "example-client", "XXX")
_, _, err = client.GetTokenByPassword("admin", "koala")
- assert.Error(t, err)
+ Error(t, err)
// invalid url
client = NewClient("://", "example-client", "secret")
_, _, err = client.GetTokenByPassword("admin", "koala")
- assert.Error(t, err)
+ Error(t, err)
}
@@ -75,7 +75,7 @@ func TestClient_GetTokenByPasswordInvalidJson(t *testing.T) {
client := NewClient(server.URL, "example-client", "secret")
_, _, err := client.GetTokenByPassword("admin", "koala")
- assert.Error(t, err)
+ Error(t, err)
}
func TestClient_GetTokenByPasswordUnknownError(t *testing.T) {
@@ -89,7 +89,7 @@ func TestClient_GetTokenByPasswordUnknownError(t *testing.T) {
client := NewClient(server.URL, "example-client", "secret")
_, _, err := client.GetTokenByPassword("admin", "koala")
- assert.Error(t, err)
+ Error(t, err)
}
func TestClient_GetTokenByPasswordNoServer(t *testing.T) {
@@ -99,7 +99,7 @@ func TestClient_GetTokenByPasswordNoServer(t *testing.T) {
client := NewClient(server.URL, "example-client", "secret")
_, _, err := client.GetTokenByPassword("admin", "koala")
- assert.Error(t, err)
+ Error(t, err)
}
func osiamMockHandler(w http.ResponseWriter, r *http.Request) {
diff --git a/osiam/error_test.go b/osiam/error_test.go
@@ -1,14 +1,14 @@
package osiam
import (
- "github.com/stretchr/testify/assert"
+ . "github.com/stretchr/testify/assert"
"testing"
)
func TestError_ParseOsiamError_CornerCases(t *testing.T) {
e := ParseOsiamError([]byte(""))
- assert.Equal(t, "client_parse_error", e.Error)
+ Equal(t, "client_parse_error", e.Error)
e = ParseOsiamError([]byte("{}"))
- assert.Equal(t, "client_parse_error", e.Error)
+ Equal(t, "client_parse_error", e.Error)
}
diff --git a/osiam/token_test.go b/osiam/token_test.go
@@ -2,7 +2,7 @@ package osiam
import (
"encoding/json"
- "github.com/stretchr/testify/assert"
+ . "github.com/stretchr/testify/assert"
"testing"
"time"
)
@@ -35,8 +35,8 @@ var testTokenString = `{
func TestClient_TokenMarshaling(t *testing.T) {
tk := &Token{}
json.Unmarshal([]byte(testTokenString), tk)
- assert.Equal(t, testToken, tk)
+ Equal(t, testToken, tk)
_, err := json.Marshal(tk)
- assert.NoError(t, err)
+ NoError(t, err)
}