github.com/jxgolibs/go-oauth2-server@v1.0.1/oauth/user_test.go (about)

     1  package oauth_test
     2  
     3  import (
     4  	"time"
     5  
     6  	"github.com/RichardKnop/go-oauth2-server/models"
     7  	"github.com/RichardKnop/go-oauth2-server/oauth"
     8  	"github.com/RichardKnop/go-oauth2-server/oauth/roles"
     9  	"github.com/RichardKnop/go-oauth2-server/util"
    10  	pass "github.com/RichardKnop/go-oauth2-server/util/password"
    11  	"github.com/RichardKnop/uuid"
    12  	"github.com/stretchr/testify/assert"
    13  )
    14  
    15  func (suite *OauthTestSuite) TestUserExistsFindsValidUser() {
    16  	validUsername := suite.users[0].Username
    17  	assert.True(suite.T(), suite.service.UserExists(validUsername))
    18  }
    19  
    20  func (suite *OauthTestSuite) TestUserExistsDoesntFindInvalidUser() {
    21  	invalidUsername := "bogus_name"
    22  	assert.False(suite.T(), suite.service.UserExists(invalidUsername))
    23  }
    24  
    25  func (suite *OauthTestSuite) TestUpdateUsernameWorksWithValidEntry() {
    26  	user, err := suite.service.CreateUser(
    27  		roles.User,      // role ID
    28  		"test@newuser",  // username
    29  		"test_password", // password
    30  	)
    31  
    32  	assert.NoError(suite.T(), err)
    33  	assert.NotNil(suite.T(), user)
    34  	assert.Equal(suite.T(), "test@newuser", user.Username)
    35  
    36  	newUsername := "mynew@email"
    37  
    38  	err = suite.service.UpdateUsername(user, newUsername)
    39  
    40  	assert.NoError(suite.T(), err)
    41  
    42  	assert.Equal(suite.T(), newUsername, user.Username)
    43  }
    44  
    45  func (suite *OauthTestSuite) TestUpdateUsernameTxWorksWithValidEntry() {
    46  	user, err := suite.service.CreateUser(
    47  		roles.User,      // role ID
    48  		"test@newuser",  // username
    49  		"test_password", // password
    50  	)
    51  
    52  	assert.NoError(suite.T(), err)
    53  	assert.NotNil(suite.T(), user)
    54  	assert.Equal(suite.T(), "test@newuser", user.Username)
    55  
    56  	newUsername := "mynew@email"
    57  
    58  	err = suite.service.UpdateUsernameTx(suite.db, user, newUsername)
    59  
    60  	assert.NoError(suite.T(), err)
    61  
    62  	assert.Equal(suite.T(), newUsername, user.Username)
    63  }
    64  
    65  func (suite *OauthTestSuite) TestUpdateUsernameFailsWithABlankEntry() {
    66  	user, err := suite.service.CreateUser(
    67  		roles.User,      // role ID
    68  		"test@newuser",  // username
    69  		"test_password", // password
    70  	)
    71  
    72  	assert.NoError(suite.T(), err)
    73  	assert.NotNil(suite.T(), user)
    74  	assert.Equal(suite.T(), "test@newuser", user.Username)
    75  
    76  	newUsername := ""
    77  
    78  	err = suite.service.UpdateUsername(user, newUsername)
    79  
    80  	assert.EqualError(suite.T(), err, oauth.ErrCannotSetEmptyUsername.Error())
    81  
    82  	assert.NotEqual(suite.T(), newUsername, user.Username)
    83  }
    84  
    85  func (suite *OauthTestSuite) TestFindUserByUsername() {
    86  	var (
    87  		user *models.OauthUser
    88  		err  error
    89  	)
    90  
    91  	// When we try to find a user with a bogus username
    92  	user, err = suite.service.FindUserByUsername("bogus")
    93  
    94  	// User object should be nil
    95  	assert.Nil(suite.T(), user)
    96  
    97  	// Correct error should be returned
    98  	if assert.NotNil(suite.T(), err) {
    99  		assert.Equal(suite.T(), oauth.ErrUserNotFound, err)
   100  	}
   101  
   102  	// When we try to find a user with a valid username
   103  	user, err = suite.service.FindUserByUsername("test@user")
   104  
   105  	// Error should be nil
   106  	assert.Nil(suite.T(), err)
   107  
   108  	// Correct user object should be returned
   109  	if assert.NotNil(suite.T(), user) {
   110  		assert.Equal(suite.T(), "test@user", user.Username)
   111  	}
   112  
   113  	// Test username case insensitiviness
   114  	user, err = suite.service.FindUserByUsername("TeSt@UsEr")
   115  
   116  	// Error should be nil
   117  	assert.Nil(suite.T(), err)
   118  
   119  	// Correct user object should be returned
   120  	if assert.NotNil(suite.T(), user) {
   121  		assert.Equal(suite.T(), "test@user", user.Username)
   122  	}
   123  }
   124  
   125  func (suite *OauthTestSuite) TestCreateUser() {
   126  	var (
   127  		user *models.OauthUser
   128  		err  error
   129  	)
   130  
   131  	// We try to insert a non unique user
   132  	user, err = suite.service.CreateUser(
   133  		roles.User,      // role ID
   134  		"test@user",     // username
   135  		"test_password", // password
   136  	)
   137  
   138  	// User object should be nil
   139  	assert.Nil(suite.T(), user)
   140  
   141  	// Correct error should be returned
   142  	if assert.NotNil(suite.T(), err) {
   143  		assert.Equal(suite.T(), oauth.ErrUsernameTaken.Error(), err.Error())
   144  	}
   145  
   146  	// We try to insert a unique user
   147  	user, err = suite.service.CreateUser(
   148  		roles.User,      // role ID
   149  		"test@newuser",  // username
   150  		"test_password", // password
   151  	)
   152  
   153  	// Error should be nil
   154  	assert.Nil(suite.T(), err)
   155  
   156  	// Correct user object should be returned
   157  	if assert.NotNil(suite.T(), user) {
   158  		assert.Equal(suite.T(), "test@newuser", user.Username)
   159  	}
   160  
   161  	// Test username case insensitivity
   162  	user, err = suite.service.CreateUser(
   163  		roles.User,      // role ID
   164  		"TeSt@NeWuSeR2", // username
   165  		"test_password", // password
   166  	)
   167  
   168  	// Error should be nil
   169  	assert.Nil(suite.T(), err)
   170  
   171  	// Correct user object should be returned
   172  	if assert.NotNil(suite.T(), user) {
   173  		assert.Equal(suite.T(), "test@newuser2", user.Username)
   174  	}
   175  }
   176  
   177  func (suite *OauthTestSuite) TestSetPassword() {
   178  	var (
   179  		user *models.OauthUser
   180  		err  error
   181  	)
   182  
   183  	// Insert a test user without a password
   184  	user = &models.OauthUser{
   185  		MyGormModel: models.MyGormModel{
   186  			ID:        uuid.New(),
   187  			CreatedAt: time.Now().UTC(),
   188  		},
   189  		RoleID:   util.StringOrNull(roles.User),
   190  		Username: "test@user_nopass",
   191  		Password: util.StringOrNull(""),
   192  	}
   193  	err = suite.db.Create(user).Error
   194  	assert.NoError(suite.T(), err, "Inserting test data failed")
   195  
   196  	// Try to set an empty password
   197  	err = suite.service.SetPassword(user, "")
   198  
   199  	// Correct error should be returned
   200  	if assert.NotNil(suite.T(), err) {
   201  		assert.Equal(suite.T(), oauth.ErrPasswordTooShort, err)
   202  	}
   203  
   204  	// Try changing the password
   205  	err = suite.service.SetPassword(user, "test_password")
   206  
   207  	// Error should be nil
   208  	assert.Nil(suite.T(), err)
   209  
   210  	// User object should have been updated
   211  	assert.Equal(suite.T(), "test@user_nopass", user.Username)
   212  	assert.Nil(suite.T(), pass.VerifyPassword(user.Password.String, "test_password"))
   213  }
   214  
   215  func (suite *OauthTestSuite) TestAuthUser() {
   216  	var (
   217  		user *models.OauthUser
   218  		err  error
   219  	)
   220  
   221  	// Insert a test user without a password
   222  	err = suite.db.Create(&models.OauthUser{
   223  		MyGormModel: models.MyGormModel{
   224  			ID:        uuid.New(),
   225  			CreatedAt: time.Now().UTC(),
   226  		},
   227  		RoleID:   util.StringOrNull(roles.User),
   228  		Username: "test@user_nopass",
   229  		Password: util.StringOrNull(""),
   230  	}).Error
   231  	assert.NoError(suite.T(), err, "Inserting test data failed")
   232  
   233  	// When we try to authenticate a user without a password
   234  	user, err = suite.service.AuthUser("test@user_nopass", "bogus")
   235  
   236  	// User object should be nil
   237  	assert.Nil(suite.T(), user)
   238  
   239  	// Correct error should be returned
   240  	if assert.NotNil(suite.T(), err) {
   241  		assert.Equal(suite.T(), oauth.ErrUserPasswordNotSet, err)
   242  	}
   243  
   244  	// When we try to authenticate with a bogus username
   245  	user, err = suite.service.AuthUser("bogus", "test_password")
   246  
   247  	// User object should be nil
   248  	assert.Nil(suite.T(), user)
   249  
   250  	// Correct error should be returned
   251  	if assert.NotNil(suite.T(), err) {
   252  		assert.Equal(suite.T(), oauth.ErrUserNotFound, err)
   253  	}
   254  
   255  	// When we try to authenticate with an invalid password
   256  	user, err = suite.service.AuthUser("test@user", "bogus")
   257  
   258  	// User object should be nil
   259  	assert.Nil(suite.T(), user)
   260  
   261  	// Correct error should be returned
   262  	if assert.NotNil(suite.T(), err) {
   263  		assert.Equal(suite.T(), oauth.ErrInvalidUserPassword, err)
   264  	}
   265  
   266  	// When we try to authenticate with valid username and password
   267  	user, err = suite.service.AuthUser("test@user", "test_password")
   268  
   269  	// Error should be nil
   270  	assert.Nil(suite.T(), err)
   271  
   272  	// Correct user object should be returned
   273  	if assert.NotNil(suite.T(), user) {
   274  		assert.Equal(suite.T(), "test@user", user.Username)
   275  	}
   276  
   277  	// Test username case insensitivity
   278  	user, err = suite.service.AuthUser("TeSt@UsEr", "test_password")
   279  
   280  	// Error should be nil
   281  	assert.Nil(suite.T(), err)
   282  
   283  	// Correct user object should be returned
   284  	if assert.NotNil(suite.T(), user) {
   285  		assert.Equal(suite.T(), "test@user", user.Username)
   286  	}
   287  }
   288  
   289  func (suite *OauthTestSuite) TestBlankPassword() {
   290  	var (
   291  		user *models.OauthUser
   292  		err  error
   293  	)
   294  
   295  	user, err = suite.service.CreateUser(
   296  		roles.User,         // role ID
   297  		"test@user_nopass", // username
   298  		"",                 // password
   299  	)
   300  
   301  	// Error should be nil
   302  	assert.Nil(suite.T(), err)
   303  
   304  	// Correct user object should be returned
   305  	if assert.NotNil(suite.T(), user) {
   306  		assert.Equal(suite.T(), "test@user_nopass", user.Username)
   307  	}
   308  
   309  	// When we try to authenticate
   310  	user, err = suite.service.AuthUser("test@user_nopass", "")
   311  
   312  	// User object should be nil
   313  	assert.Nil(suite.T(), user)
   314  
   315  	// Correct error should be returned
   316  	if assert.NotNil(suite.T(), err) {
   317  		assert.Equal(suite.T(), oauth.ErrUserPasswordNotSet, err)
   318  	}
   319  }