devstack/authorizer
4
0
Fork 0
Code Pull Requests Actions Activity

fix: unique constraint data

Browse Source
This commit is contained in:
Lakhan Samani 2021-12-22 15:31:45 +05:30
parent 508c714932
commit 3ee79c3937
21 changed files with 206 additions and 192 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@ -6,4 +6,4 @@ cmd:
clean:
rm -rf build
test:
cd server && go clean --testcache && go test -v ./...
cd server && go clean --testcache && go test -v ./test

4
server/db/arangodb.go
View File

@ -36,16 +36,12 @@ func initArangodb() (arangoDriver.Database, error) {
if arangodb_exists {
log.Println(constants.DATABASE_NAME + " db exists already")
arangodb, err = arangoClient.Database(nil, constants.DATABASE_NAME)
if err != nil {
return nil, err
}
} else {
arangodb, err = arangoClient.CreateDatabase(nil, constants.DATABASE_NAME, nil)
if err != nil {
return nil, err
}

25
server/db/mongodb.go
View File

@ -34,12 +34,6 @@ func initMongodb() (*mongo.Database, error) {
mongodb.CreateCollection(ctx, Collections.User, options.CreateCollection())
userCollection := mongodb.Collection(Collections.User, options.Collection())
userCollection.Indexes().CreateMany(ctx, []mongo.IndexModel{
mongo.IndexModel{
Keys: bson.M{"id": 1},
Options: options.Index().SetUnique(true).SetSparse(true),
},
}, options.CreateIndexes())
userCollection.Indexes().CreateMany(ctx, []mongo.IndexModel{
mongo.IndexModel{
Keys: bson.M{"email": 1},
@ -48,19 +42,15 @@ func initMongodb() (*mongo.Database, error) {
}, options.CreateIndexes())
userCollection.Indexes().CreateMany(ctx, []mongo.IndexModel{
mongo.IndexModel{
Keys: bson.M{"phone_number": 1},
Options: options.Index().SetUnique(true).SetSparse(true),
Keys: bson.M{"phone_number": 1},
Options: options.Index().SetUnique(true).SetSparse(true).SetPartialFilterExpression(map[string]interface{}{
"phone_number": map[string]string{"$type": "string"},
}),
},
}, options.CreateIndexes())
mongodb.CreateCollection(ctx, Collections.VerificationRequest, options.CreateCollection())
verificationRequestCollection := mongodb.Collection(Collections.VerificationRequest, options.Collection())
verificationRequestCollection.Indexes().CreateMany(ctx, []mongo.IndexModel{
mongo.IndexModel{
Keys: bson.M{"id": 1},
Options: options.Index().SetUnique(true).SetSparse(true),
},
}, options.CreateIndexes())
verificationRequestCollection.Indexes().CreateMany(ctx, []mongo.IndexModel{
mongo.IndexModel{
Keys: bson.M{"email": 1, "identifier": 1},
@ -75,13 +65,6 @@ func initMongodb() (*mongo.Database, error) {
}, options.CreateIndexes())
mongodb.CreateCollection(ctx, Collections.Session, options.CreateCollection())
sessionCollection := mongodb.Collection(Collections.Session, options.Collection())
sessionCollection.Indexes().CreateMany(ctx, []mongo.IndexModel{
mongo.IndexModel{
Keys: bson.M{"id": 1},
Options: options.Index().SetUnique(true).SetSparse(true),
},
}, options.CreateIndexes())
return mongodb, nil
}

5
server/db/session.go
View File

@ -10,8 +10,7 @@ import (
)
type Session struct {
Key string `json:"_key,omitempty" bson:"_key,omitempty"` // for arangodb
// ObjectID string `json:"_id,omitempty" bson:"_id"` // for arangodb & mongodb
Key string `json:"_key,omitempty" bson:"_key,omitempty"` // for arangodb
ID string `gorm:"primaryKey;type:char(36)" json:"_id" bson:"_id"`
UserID string `gorm:"type:char(36)" json:"user_id" bson:"user_id"`
User User `json:"-" bson:"-"`
@ -29,7 +28,6 @@ func (mgr *manager) AddSession(session Session) error {
if IsORMSupported {
session.Key = session.ID
// session.ObjectID = session.ID
res := mgr.sqlDB.Clauses(
clause.OnConflict{
DoNothing: true,
@ -53,7 +51,6 @@ func (mgr *manager) AddSession(session Session) error {
if IsMongoDB {
session.Key = session.ID
// session.ObjectID = session.ID
session.CreatedAt = time.Now().Unix()
session.UpdatedAt = time.Now().Unix()
sessionCollection := mgr.mongodb.Collection(Collections.Session, options.Collection())

38
server/db/user.go
View File

@ -17,22 +17,22 @@ type User struct {
Key string `json:"_key,omitempty" bson:"_key"` // for arangodb
ID string `gorm:"primaryKey;type:char(36)" json:"_id" bson:"_id"`
Email string `gorm:"unique" json:"email" bson:"email"`
EmailVerifiedAt int64 `json:"email_verified_at" bson:"email_verified_at"`
Password string `gorm:"type:text" json:"password" bson:"password"`
SignupMethods string `json:"signup_methods" bson:"signup_methods"`
GivenName string `json:"given_name" bson:"given_name"`
FamilyName string `json:"family_name" bson:"family_name"`
MiddleName string `json:"middle_name" bson:"middle_name"`
Nickname string `json:"nickname" bson:"nickname"`
Gender string `json:"gender" bson:"gender"`
Birthdate string `json:"birthdate" bson:"birthdate"`
PhoneNumber string `gorm:"unique" json:"phone_number" bson:"phone_number"`
PhoneNumberVerifiedAt int64 `json:"phone_number_verified_at" bson:"phone_number_verified_at"`
Picture string `gorm:"type:text" json:"picture" bson:"picture"`
Roles string `json:"roles" bson:"roles"`
UpdatedAt int64 `gorm:"autoUpdateTime" json:"updated_at" bson:"updated_at"`
CreatedAt int64 `gorm:"autoCreateTime" json:"created_at" bson:"created_at"`
Email string `gorm:"unique" json:"email" bson:"email"`
EmailVerifiedAt int64 `json:"email_verified_at" bson:"email_verified_at"`
Password *string `gorm:"type:text" json:"password" bson:"password"`
SignupMethods string `json:"signup_methods" bson:"signup_methods"`
GivenName *string `json:"given_name" bson:"given_name"`
FamilyName *string `json:"family_name" bson:"family_name"`
MiddleName *string `json:"middle_name" bson:"middle_name"`
Nickname *string `json:"nickname" bson:"nickname"`
Gender *string `json:"gender" bson:"gender"`
Birthdate *string `json:"birthdate" bson:"birthdate"`
PhoneNumber *string `gorm:"unique" json:"phone_number" bson:"phone_number"`
PhoneNumberVerifiedAt *int64 `json:"phone_number_verified_at" bson:"phone_number_verified_at"`
Picture *string `gorm:"type:text" json:"picture" bson:"picture"`
Roles string `json:"roles" bson:"roles"`
UpdatedAt int64 `gorm:"autoUpdateTime" json:"updated_at" bson:"updated_at"`
CreatedAt int64 `gorm:"autoCreateTime" json:"created_at" bson:"created_at"`
}
// AddUser function to add user even with email conflict
@ -44,7 +44,6 @@ func (mgr *manager) AddUser(user User) (User, error) {
if IsORMSupported {
// copy id as value for fields required for mongodb & arangodb
user.Key = user.ID
// user.ObjectID = user.ID
result := mgr.sqlDB.Clauses(
clause.OnConflict{
UpdateAll: true,
@ -67,14 +66,13 @@ func (mgr *manager) AddUser(user User) (User, error) {
return user, err
}
user.Key = meta.Key
// user.ObjectID = meta.ID.String()
user.ID = meta.ID.String()
}
if IsMongoDB {
user.CreatedAt = time.Now().Unix()
user.UpdatedAt = time.Now().Unix()
user.Key = user.ID
// user.ObjectID = user.ID
userCollection := mgr.mongodb.Collection(Collections.User, options.Collection())
_, err := userCollection.InsertOne(nil, user)
if err != nil {
@ -108,7 +106,7 @@ func (mgr *manager) UpdateUser(user User) (User, error) {
}
user.Key = meta.Key
// user.ObjectID = meta.ID.String()
user.ID = meta.ID.String()
}
if IsMongoDB {

7
server/db/verification_requests.go
View File

@ -13,8 +13,7 @@ import (
)
type VerificationRequest struct {
Key string `json:"_key,omitempty" bson:"_key"` // for arangodb
// ObjectID string `json:"_id,omitempty" bson:"_id"` // for arangodb & mongodb
Key string `json:"_key,omitempty" bson:"_key"` // for arangodb
ID string `gorm:"primaryKey;type:char(36)" json:"_id" bson:"_id"`
Token string `gorm:"type:text" json:"token" bson:"token"`
Identifier string `gorm:"uniqueIndex:idx_email_identifier" json:"identifier" bson:"identifier"`
@ -32,7 +31,6 @@ func (mgr *manager) AddVerification(verification VerificationRequest) (Verificat
if IsORMSupported {
// copy id as value for fields required for mongodb & arangodb
verification.Key = verification.ID
// verification.ObjectID = verification.ID
result := mgr.sqlDB.Clauses(clause.OnConflict{
Columns: []clause.Column{{Name: "email"}, {Name: "identifier"}},
DoUpdates: clause.AssignmentColumns([]string{"token", "expires_at"}),
@ -54,14 +52,13 @@ func (mgr *manager) AddVerification(verification VerificationRequest) (Verificat
return verification, err
}
verification.Key = meta.Key
// verification.ObjectID = meta.ID.String()
verification.ID = meta.ID.String()
}
if IsMongoDB {
verification.CreatedAt = time.Now().Unix()
verification.UpdatedAt = time.Now().Unix()
verification.Key = verification.ID
// verification.ObjectID = verification.ID
verificationRequestCollection := mgr.mongodb.Collection(Collections.VerificationRequest, options.Collection())
_, err := verificationRequestCollection.InsertOne(nil, verification)
if err != nil {

19
server/handlers/oauth_callback.go
View File

@ -89,10 +89,12 @@ func processGithubUserInfo(code string) (db.User, error) {
lastName = name[0]
}
picture := userRawData["avatar_url"]
user = db.User{
GivenName: firstName,
FamilyName: lastName,
Picture: userRawData["avatar_url"],
GivenName: &firstName,
FamilyName: &lastName,
Picture: &picture,
Email: userRawData["email"],
}
@ -130,10 +132,14 @@ func processFacebookUserInfo(code string) (db.User, error) {
picObject := userRawData["picture"].(map[string]interface{})["data"]
picDataObject := picObject.(map[string]interface{})
firstName := fmt.Sprintf("%v", userRawData["first_name"])
lastName := fmt.Sprintf("%v", userRawData["last_name"])
picture := fmt.Sprintf("%v", picDataObject["url"])
user = db.User{
GivenName: fmt.Sprintf("%v", userRawData["first_name"]),
FamilyName: fmt.Sprintf("%v", userRawData["last_name"]),
Picture: fmt.Sprintf("%v", picDataObject["url"]),
GivenName: &firstName,
FamilyName: &lastName,
Picture: &picture,
Email: email,
}
@ -246,7 +252,6 @@ func OAuthCallbackHandler() gin.HandlerFunc {
user.Roles = existingUser.Roles
}
user.Key = existingUser.Key
// user.ObjectID = existingUser.ObjectID
user.ID = existingUser.ID
user, err = db.Mgr.UpdateUser(user)
}

23
server/main.go
View File

@ -5,12 +5,10 @@ import (
"github.com/authorizerdev/authorizer/server/db"
"github.com/authorizerdev/authorizer/server/env"
"github.com/authorizerdev/authorizer/server/handlers"
"github.com/authorizerdev/authorizer/server/middlewares"
"github.com/authorizerdev/authorizer/server/oauth"
"github.com/authorizerdev/authorizer/server/router"
"github.com/authorizerdev/authorizer/server/session"
"github.com/authorizerdev/authorizer/server/utils"
"github.com/gin-contrib/location"
"github.com/gin-gonic/gin"
)
func main() {
@ -20,26 +18,15 @@ func main() {
oauth.InitOAuth()
utils.InitServer()
r := gin.Default()
r.Use(location.Default())
r.Use(middlewares.GinContextToContextMiddleware())
r.Use(middlewares.CORSMiddleware())
r.GET("/", handlers.PlaygroundHandler())
r.POST("/graphql", handlers.GraphqlHandler())
r.GET("/verify_email", handlers.VerifyEmailHandler())
r.GET("/oauth_login/:oauth_provider", handlers.OAuthLoginHandler())
r.GET("/oauth_callback/:oauth_provider", handlers.OAuthCallbackHandler())
router := router.InitRouter()
// login wall app related routes
r.LoadHTMLGlob("templates/*")
app := r.Group("/app")
router.LoadHTMLGlob("templates/*")
app := router.Group("/app")
{
app.Static("/build", "app/build")
app.GET("/", handlers.AppHandler())
app.GET("/reset-password", handlers.AppHandler())
}
r.Run(":" + constants.PORT)
router.Run(":" + constants.PORT)
}

2
server/resolvers/login.go
View File

@ -40,7 +40,7 @@ func Login(ctx context.Context, params model.LoginInput) (*model.AuthResponse, e
return res, fmt.Errorf(`email not verified`)
}
err = bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(params.Password))
err = bcrypt.CompareHashAndPassword([]byte(*user.Password), []byte(params.Password))
if err != nil {
log.Println("compare password error:", err)

2
server/resolvers/reset_password.go
View File

@ -39,7 +39,7 @@ func ResetPassword(ctx context.Context, params model.ResetPasswordInput) (*model
}
password, _ := utils.HashPassword(params.Password)
user.Password = password
user.Password = &password
signupMethod := user.SignupMethods
if !strings.Contains(signupMethod, enum.BasicAuth.String()) {

18
server/resolvers/signup.go
View File

@ -68,38 +68,38 @@ func Signup(ctx context.Context, params model.SignUpInput) (*model.AuthResponse,
user.Roles = strings.Join(inputRoles, ",")
password, _ := utils.HashPassword(params.Password)
user.Password = password
user.Password = &password
if params.GivenName != nil {
user.GivenName = *params.GivenName
user.GivenName = params.GivenName
}
if params.FamilyName != nil {
user.FamilyName = *params.FamilyName
user.FamilyName = params.FamilyName
}
if params.MiddleName != nil {
user.MiddleName = *params.MiddleName
user.MiddleName = params.MiddleName
}
if params.Nickname != nil {
user.Nickname = *params.Nickname
user.Nickname = params.Nickname
}
if params.Gender != nil {
user.Gender = *params.Gender
user.Gender = params.Gender
}
if params.Birthdate != nil {
user.Birthdate = *params.Birthdate
user.Birthdate = params.Birthdate
}
if params.PhoneNumber != nil {
user.PhoneNumber = *params.PhoneNumber
user.PhoneNumber = params.PhoneNumber
}
if params.Picture != nil {
user.Picture = *params.Picture
user.Picture = params.Picture
}
user.SignupMethods = enum.BasicAuth.String()

36
server/resolvers/update_profile.go
View File

@ -50,40 +50,40 @@ func UpdateProfile(ctx context.Context, params model.UpdateProfileInput) (*model
return res, err
}
if params.GivenName != nil && user.GivenName != *params.GivenName {
user.GivenName = *params.GivenName
if params.GivenName != nil && user.GivenName != params.GivenName {
user.GivenName = params.GivenName
}
if params.FamilyName != nil && user.FamilyName != *params.FamilyName {
user.FamilyName = *params.FamilyName
if params.FamilyName != nil && user.FamilyName != params.FamilyName {
user.FamilyName = params.FamilyName
}
if params.MiddleName != nil && user.MiddleName != *params.MiddleName {
user.MiddleName = *params.MiddleName
if params.MiddleName != nil && user.MiddleName != params.MiddleName {
user.MiddleName = params.MiddleName
}
if params.Nickname != nil && user.Nickname != *params.Nickname {
user.Nickname = *params.Nickname
if params.Nickname != nil && user.Nickname != params.Nickname {
user.Nickname = params.Nickname
}
if params.Birthdate != nil && user.Birthdate != *params.Birthdate {
user.Birthdate = *params.Birthdate
if params.Birthdate != nil && user.Birthdate != params.Birthdate {
user.Birthdate = params.Birthdate
}
if params.Gender != nil && user.Gender != *params.Gender {
user.Gender = *params.Gender
if params.Gender != nil && user.Gender != params.Gender {
user.Gender = params.Gender
}
if params.PhoneNumber != nil && user.PhoneNumber != *params.PhoneNumber {
user.PhoneNumber = *params.PhoneNumber
if params.PhoneNumber != nil && user.PhoneNumber != params.PhoneNumber {
user.PhoneNumber = params.PhoneNumber
}
if params.Picture != nil && user.Picture != *params.Picture {
user.Picture = *params.Picture
if params.Picture != nil && user.Picture != params.Picture {
user.Picture = params.Picture
}
if params.OldPassword != nil {
if err = bcrypt.CompareHashAndPassword([]byte(user.Password), []byte(*params.OldPassword)); err != nil {
if err = bcrypt.CompareHashAndPassword([]byte(*user.Password), []byte(*params.OldPassword)); err != nil {
return res, fmt.Errorf("incorrect old password")
}
@ -101,7 +101,7 @@ func UpdateProfile(ctx context.Context, params model.UpdateProfileInput) (*model
password, _ := utils.HashPassword(*params.NewPassword)
user.Password = password
user.Password = &password
}
hasEmailChanged := false

38
server/resolvers/update_user.go
View File

@ -35,36 +35,36 @@ func UpdateUser(ctx context.Context, params model.UpdateUserInput) (*model.User,
return res, fmt.Errorf(`User not found`)
}
if params.GivenName != nil && user.GivenName != *params.GivenName {
user.GivenName = *params.GivenName
if params.GivenName != nil && user.GivenName != params.GivenName {
user.GivenName = params.GivenName
}
if params.FamilyName != nil && user.FamilyName != *params.FamilyName {
user.FamilyName = *params.FamilyName
if params.FamilyName != nil && user.FamilyName != params.FamilyName {
user.FamilyName = params.FamilyName
}
if params.MiddleName != nil && user.MiddleName != *params.MiddleName {
user.MiddleName = *params.MiddleName
if params.MiddleName != nil && user.MiddleName != params.MiddleName {
user.MiddleName = params.MiddleName
}
if params.Nickname != nil && user.Nickname != *params.Nickname {
user.Nickname = *params.Nickname
if params.Nickname != nil && user.Nickname != params.Nickname {
user.Nickname = params.Nickname
}
if params.Birthdate != nil && user.Birthdate != *params.Birthdate {
user.Birthdate = *params.Birthdate
if params.Birthdate != nil && user.Birthdate != params.Birthdate {
user.Birthdate = params.Birthdate
}
if params.Gender != nil && user.Gender != *params.Gender {
user.Gender = *params.Gender
if params.Gender != nil && user.Gender != params.Gender {
user.Gender = params.Gender
}
if params.PhoneNumber != nil && user.PhoneNumber != *params.PhoneNumber {
user.PhoneNumber = *params.PhoneNumber
if params.PhoneNumber != nil && user.PhoneNumber != params.PhoneNumber {
user.PhoneNumber = params.PhoneNumber
}
if params.Picture != nil && user.Picture != *params.Picture {
user.Picture = *params.Picture
if params.Picture != nil && user.Picture != params.Picture {
user.Picture = params.Picture
}
if params.Email != nil && user.Email != *params.Email {
@ -137,9 +137,9 @@ func UpdateUser(ctx context.Context, params model.UpdateUserInput) (*model.User,
res = &model.User{
ID: params.ID,
Email: user.Email,
Picture: &user.Picture,
GivenName: &user.GivenName,
FamilyName: &user.FamilyName,
Picture: user.Picture,
GivenName: user.GivenName,
FamilyName: user.FamilyName,
Roles: strings.Split(user.Roles, ","),
CreatedAt: &user.CreatedAt,
UpdatedAt: &user.UpdatedAt,

23
server/router/router.go Normal file
View File

@ -0,0 +1,23 @@
package router
import (
"github.com/authorizerdev/authorizer/server/handlers"
"github.com/authorizerdev/authorizer/server/middlewares"
"github.com/gin-contrib/location"
"github.com/gin-gonic/gin"
)
func InitRouter() *gin.Engine {
router := gin.Default()
router.Use(location.Default())
router.Use(middlewares.GinContextToContextMiddleware())
router.Use(middlewares.CORSMiddleware())
router.GET("/", handlers.PlaygroundHandler())
router.POST("/graphql", handlers.GraphqlHandler())
router.GET("/verify_email", handlers.VerifyEmailHandler())
router.GET("/oauth_login/:oauth_provider", handlers.OAuthLoginHandler())
router.GET("/oauth_callback/:oauth_provider", handlers.OAuthCallbackHandler())
return router
}

25
server/integration_test/cors_test.go → server/test/cors_test.go
View File

@ -1,4 +1,4 @@
package integration_test
package test
import (
"net/http"
@ -6,32 +6,31 @@ import (
"testing"
"github.com/authorizerdev/authorizer/server/constants"
"github.com/authorizerdev/authorizer/server/db"
"github.com/authorizerdev/authorizer/server/env"
"github.com/authorizerdev/authorizer/server/middlewares"
"github.com/gin-contrib/location"
"github.com/gin-gonic/gin"
"github.com/authorizerdev/authorizer/server/router"
"github.com/authorizerdev/authorizer/server/session"
"github.com/stretchr/testify/assert"
)
func TestCors(t *testing.T) {
constants.DATABASE_TYPE = "sqlite"
constants.DATABASE_URL = "data.db"
constants.ENV_PATH = "../../.env.local"
constants.ENV_PATH = "../../.env.sample"
constants.DATABASE_URL = "../../data.db"
env.InitEnv()
r := gin.Default()
r.Use(location.Default())
r.Use(middlewares.GinContextToContextMiddleware())
r.Use(middlewares.CORSMiddleware())
db.InitDB()
session.InitSession()
router := router.InitRouter()
allowedOrigin := "http://localhost:8080" // The allowed origin that you want to check
notAllowedOrigin := "http://myapp.com"
server := httptest.NewServer(r)
server := httptest.NewServer(router)
defer server.Close()
client := &http.Client{}
req, _ := http.NewRequest(
"GET",
"http://"+server.Listener.Addr().String()+"/api",
"http://"+server.Listener.Addr().String()+"/graphql",
nil,
)
req.Header.Add("Origin", allowedOrigin)

8
server/env/env_test.go → server/test/env_test.go
View File

@ -1,4 +1,4 @@
package env
package test
import (
"testing"
@ -10,13 +10,11 @@ import (
func TestEnvs(t *testing.T) {
constants.ENV_PATH = "../../.env.sample"
constants.DATABASE_TYPE = "sqlite"
constants.DATABASE_URL = "data.db"
InitEnv()
// env.InitEnv()
assert.Equal(t, constants.ADMIN_SECRET, "admin")
assert.Equal(t, constants.ENV, "production")
assert.Equal(t, constants.DATABASE_URL, "data.db")
assert.Equal(t, constants.DATABASE_URL, "../../data.db")
assert.Equal(t, constants.DATABASE_TYPE, enum.Sqlite.String())
assert.True(t, constants.DISABLE_EMAIL_VERIFICATION)
assert.True(t, constants.DISABLE_MAGIC_LINK_LOGIN)

29
server/test/signup_test.go Normal file
View File

@ -0,0 +1,29 @@
package test
import (
"context"
"log"
"net/http/httptest"
"testing"
"github.com/authorizerdev/authorizer/server/graph/model"
"github.com/authorizerdev/authorizer/server/resolvers"
"github.com/gin-gonic/gin"
"github.com/stretchr/testify/assert"
)
func TestSQLSignUp(t *testing.T) {
w := httptest.NewRecorder()
req := httptest.NewRequest("POST", "/graphql", nil)
c, _ := gin.CreateTestContext(w)
ctx := context.WithValue(req.Context(), "GinContextKey", c)
res, err := resolvers.Signup(ctx, model.SignUpInput{
Email: "test@yopmail.com",
Password: "test",
ConfirmPassword: "test",
})
log.Println("=> signup err:", err)
log.Println("=> singup res:", res)
assert.Equal(t, "success", "success")
}

7
server/utils/urls_test.go → server/test/urls_test.go
View File

@ -1,15 +1,16 @@
package utils
package test
import (
"testing"
"github.com/authorizerdev/authorizer/server/utils"
"github.com/stretchr/testify/assert"
)
func TestGetHostName(t *testing.T) {
authorizer_url := "http://test.herokuapp.com:80"
host, port := GetHostParts(authorizer_url)
host, port := utils.GetHostParts(authorizer_url)
expectedHost := "test.herokuapp.com"
assert.Equal(t, host, expectedHost, "hostname should be equal")
@ -19,7 +20,7 @@ func TestGetHostName(t *testing.T) {
func TestGetDomainName(t *testing.T) {
authorizer_url := "http://test.herokuapp.com"
got := GetDomainName(authorizer_url)
got := utils.GetDomainName(authorizer_url)
want := "herokuapp.com"
assert.Equal(t, got, want, "domain name should be equal")

35
server/test/validator_test.go Normal file
View File

@ -0,0 +1,35 @@
package test
import (
"testing"
"github.com/authorizerdev/authorizer/server/constants"
"github.com/authorizerdev/authorizer/server/utils"
"github.com/stretchr/testify/assert"
)
func TestIsValidEmail(t *testing.T) {
validEmail := "lakhan@gmail.com"
invalidEmail1 := "lakhan"
invalidEmail2 := "lakhan.me"
assert.True(t, utils.IsValidEmail(validEmail), "it should be valid email")
assert.False(t, utils.IsValidEmail(invalidEmail1), "it should be invalid email")
assert.False(t, utils.IsValidEmail(invalidEmail2), "it should be invalid email")
}
func TestIsValidOrigin(t *testing.T) {
// don't use portocal(http/https) for ALLOWED_ORIGINS while testing,
// as we trim them off while running the main function
constants.ALLOWED_ORIGINS = []string{"localhost:8080", "*.google.com", "*.google.in", "*abc.*"}
assert.False(t, utils.IsValidOrigin("http://myapp.com"), "it should be invalid origin")
assert.False(t, utils.IsValidOrigin("http://appgoogle.com"), "it should be invalid origin")
assert.True(t, utils.IsValidOrigin("http://app.google.com"), "it should be valid origin")
assert.False(t, utils.IsValidOrigin("http://app.google.ind"), "it should be invalid origin")
assert.True(t, utils.IsValidOrigin("http://app.google.in"), "it should be valid origin")
assert.True(t, utils.IsValidOrigin("http://xyx.abc.com"), "it should be valid origin")
assert.True(t, utils.IsValidOrigin("http://xyx.abc.in"), "it should be valid origin")
assert.True(t, utils.IsValidOrigin("http://xyxabc.in"), "it should be valid origin")
assert.True(t, utils.IsValidOrigin("http://localhost:8080"), "it should be valid origin")
}

18
server/utils/get_res_user.go
View File

@ -9,22 +9,22 @@ import (
func GetResUser(user db.User) *model.User {
isEmailVerified := user.EmailVerifiedAt > 0
isPhoneVerified := user.PhoneNumberVerifiedAt > 0
isPhoneVerified := user.PhoneNumberVerifiedAt != nil
return &model.User{
ID: user.ID,
Email: user.Email,
EmailVerified: isEmailVerified,
SignupMethods: user.SignupMethods,
GivenName: &user.GivenName,
FamilyName: &user.FamilyName,
MiddleName: &user.MiddleName,
Nickname: &user.Nickname,
GivenName: user.GivenName,
FamilyName: user.FamilyName,
MiddleName: user.MiddleName,
Nickname: user.Nickname,
PreferredUsername: &user.Email,
Gender: &user.Gender,
Birthdate: &user.Birthdate,
PhoneNumber: &user.PhoneNumber,
Gender: user.Gender,
Birthdate: user.Birthdate,
PhoneNumber: user.PhoneNumber,
PhoneNumberVerified: &isPhoneVerified,
Picture: &user.Picture,
Picture: user.Picture,
Roles: strings.Split(user.Roles, ","),
CreatedAt: &user.CreatedAt,
UpdatedAt: &user.UpdatedAt,

34
server/utils/validator_test.go
View File

@ -1,34 +0,0 @@
package utils
import (
"testing"
"github.com/authorizerdev/authorizer/server/constants"
"github.com/stretchr/testify/assert"
)
func TestIsValidEmail(t *testing.T) {
validEmail := "lakhan@gmail.com"
invalidEmail1 := "lakhan"
invalidEmail2 := "lakhan.me"
assert.True(t, IsValidEmail(validEmail), "it should be valid email")
assert.False(t, IsValidEmail(invalidEmail1), "it should be invalid email")
assert.False(t, IsValidEmail(invalidEmail2), "it should be invalid email")
}
func TestIsValidOrigin(t *testing.T) {
// don't use portocal(http/https) for ALLOWED_ORIGINS while testing,
// as we trim them off while running the main function
constants.ALLOWED_ORIGINS = []string{"localhost:8080", "*.google.com", "*.google.in", "*abc.*"}
assert.False(t, IsValidOrigin("http://myapp.com"), "it should be invalid origin")
assert.False(t, IsValidOrigin("http://appgoogle.com"), "it should be invalid origin")
assert.True(t, IsValidOrigin("http://app.google.com"), "it should be valid origin")
assert.False(t, IsValidOrigin("http://app.google.ind"), "it should be invalid origin")
assert.True(t, IsValidOrigin("http://app.google.in"), "it should be valid origin")
assert.True(t, IsValidOrigin("http://xyx.abc.com"), "it should be valid origin")
assert.True(t, IsValidOrigin("http://xyx.abc.in"), "it should be valid origin")
assert.True(t, IsValidOrigin("http://xyxabc.in"), "it should be valid origin")
assert.True(t, IsValidOrigin("http://localhost:8080"), "it should be valid origin")
}