func (suite *AuthenticationBackendTestSuite) TestAuthenticateIncorrectPass(c *C) {
authBackend := authentication.InitJWTAuthenticationBackend()
user := models.User{
Username: "******",
Password: "******",
}
c.Assert(authBackend.Authenticate(&user), Equals, false)
}
func (suite *AuthenticationBackendTestSuite) TestAuthenticateIncorrectUsername(c *C) {
authBackend := authentication.InitJWTAuthenticationBackend()
user := &models.User{
Username: "******",
Password: "******",
}
c.Assert(authBackend.Authenticate(user), Equals, false)
}
func (s *MiddlewaresTestSuite) SetUpTest(c *C) {
authBackend := authentication.InitJWTAuthenticationBackend()
assert.NotNil(t, authBackend)
token, _ = authBackend.GenerateToken("1234")
router := routers.InitRoutes()
server = negroni.Classic()
server.UseHandler(router)
}
func (suite *AuthenticationBackendTestSuite) TestIsInBlacklist(c *C) {
authBackend := authentication.InitJWTAuthenticationBackend()
tokenString, err := authBackend.GenerateToken("1234")
token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
return authBackend.PublicKey, nil
})
err = authBackend.Logout(tokenString, token)
assert.Nil(t, err)
assert.True(t, authBackend.IsInBlacklist(tokenString))
}
func Logout(req *http.Request) error {
authBackend := authentication.InitJWTAuthenticationBackend()
tokenRequest, err := jwt.ParseFromRequest(req, func(token *jwt.Token) (interface{}, error) {
return authBackend.PublicKey, nil
})
if err != nil {
return err
}
tokenString := req.Header.Get("Authorization")
return authBackend.Logout(tokenString, tokenRequest)
}
func RefreshToken(requestUser *models.User) []byte {
authBackend := authentication.InitJWTAuthenticationBackend()
token, err := authBackend.GenerateToken(requestUser.UUID)
if err != nil {
panic(err)
}
response, err := json.Marshal(parameters.TokenAuthentication{token})
if err != nil {
panic(err)
}
return response
}
func (suite *AuthenticationBackendTestSuite) TestLogout(c *C) {
authBackend := authentication.InitJWTAuthenticationBackend()
tokenString, err := authBackend.GenerateToken("1234")
token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
return authBackend.PublicKey, nil
})
err = authBackend.Logout(tokenString, token)
assert.Nil(t, err)
redisConn := redis.Connect()
redisValue, err := redisConn.GetValue(tokenString)
assert.Nil(t, err)
assert.NotEmpty(t, redisValue)
}
func (suite *AuthenticationBackendTestSuite) TestGenerateToken(c *C) {
authBackend := authentication.InitJWTAuthenticationBackend()
tokenString, err := authBackend.GenerateToken("1234")
assert.Nil(t, err)
assert.NotEmpty(t, tokenString)
token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
return authBackend.PublicKey, nil
})
assert.Nil(t, err)
assert.True(t, token.Valid)
}
func Login(requestUser *models.User) (int, []byte) {
authBackend := authentication.InitJWTAuthenticationBackend()
if authBackend.Authenticate(requestUser) {
token, err := authBackend.GenerateToken(requestUser.UUID)
if err != nil {
return http.StatusInternalServerError, []byte("")
} else {
response, _ := json.Marshal(parameters.TokenAuthentication{token})
return http.StatusOK, response
}
}
return http.StatusUnauthorized, []byte("")
}
func (suite *AuthenticationBackendTestSuite) TestInitJWTAuthenticationBackend(c *C) {
authBackend := authentication.InitJWTAuthenticationBackend()
c.Assert(authBackend, NotNil)
c.Assert(authBackend.PublicKey, NotNil)
}
func (suite *AuthenticationBackendTestSuite) TestIsNotInBlacklist(c *C) {
authBackend := authentication.InitJWTAuthenticationBackend()
assert.False(t, authBackend.IsInBlacklist("1234"))
}