github.com/cloudreve/Cloudreve/v3@v3.0.0-20240224133659-3edb00a6484c/models/user_test.go (about) 1 package model 2 3 import ( 4 "encoding/json" 5 "testing" 6 7 "github.com/DATA-DOG/go-sqlmock" 8 "github.com/cloudreve/Cloudreve/v3/pkg/cache" 9 "github.com/jinzhu/gorm" 10 "github.com/pkg/errors" 11 "github.com/stretchr/testify/assert" 12 ) 13 14 func TestGetUserByID(t *testing.T) { 15 asserts := assert.New(t) 16 cache.Deletes([]string{"1"}, "policy_") 17 //找到用户时 18 userRows := sqlmock.NewRows([]string{"id", "deleted_at", "email", "options", "group_id"}). 19 AddRow(1, nil, "admin@cloudreve.org", "{}", 1) 20 mock.ExpectQuery("^SELECT (.+)").WillReturnRows(userRows) 21 22 groupRows := sqlmock.NewRows([]string{"id", "name", "policies"}). 23 AddRow(1, "管理员", "[1]") 24 mock.ExpectQuery("^SELECT (.+)").WillReturnRows(groupRows) 25 26 policyRows := sqlmock.NewRows([]string{"id", "name"}). 27 AddRow(1, "默认存储策略") 28 mock.ExpectQuery("^SELECT (.+)").WillReturnRows(policyRows) 29 30 user, err := GetUserByID(1) 31 asserts.NoError(err) 32 asserts.Equal(User{ 33 Model: gorm.Model{ 34 ID: 1, 35 DeletedAt: nil, 36 }, 37 Email: "admin@cloudreve.org", 38 Options: "{}", 39 GroupID: 1, 40 Group: Group{ 41 Model: gorm.Model{ 42 ID: 1, 43 }, 44 Name: "管理员", 45 Policies: "[1]", 46 PolicyList: []uint{1}, 47 }, 48 Policy: Policy{ 49 Model: gorm.Model{ 50 ID: 1, 51 }, 52 OptionsSerialized: PolicyOption{ 53 FileType: []string{}, 54 }, 55 Name: "默认存储策略", 56 }, 57 }, user) 58 59 //未找到用户时 60 mock.ExpectQuery("^SELECT (.+)").WillReturnError(errors.New("not found")) 61 user, err = GetUserByID(1) 62 asserts.Error(err) 63 asserts.Equal(User{}, user) 64 } 65 66 func TestGetActiveUserByID(t *testing.T) { 67 asserts := assert.New(t) 68 cache.Deletes([]string{"1"}, "policy_") 69 //找到用户时 70 userRows := sqlmock.NewRows([]string{"id", "deleted_at", "email", "options", "group_id"}). 71 AddRow(1, nil, "admin@cloudreve.org", "{}", 1) 72 mock.ExpectQuery("^SELECT (.+)").WillReturnRows(userRows) 73 74 groupRows := sqlmock.NewRows([]string{"id", "name", "policies"}). 75 AddRow(1, "管理员", "[1]") 76 mock.ExpectQuery("^SELECT (.+)").WillReturnRows(groupRows) 77 78 policyRows := sqlmock.NewRows([]string{"id", "name"}). 79 AddRow(1, "默认存储策略") 80 mock.ExpectQuery("^SELECT (.+)").WillReturnRows(policyRows) 81 82 user, err := GetActiveUserByID(1) 83 asserts.NoError(err) 84 asserts.Equal(User{ 85 Model: gorm.Model{ 86 ID: 1, 87 DeletedAt: nil, 88 }, 89 Email: "admin@cloudreve.org", 90 Options: "{}", 91 GroupID: 1, 92 Group: Group{ 93 Model: gorm.Model{ 94 ID: 1, 95 }, 96 Name: "管理员", 97 Policies: "[1]", 98 PolicyList: []uint{1}, 99 }, 100 Policy: Policy{ 101 Model: gorm.Model{ 102 ID: 1, 103 }, 104 OptionsSerialized: PolicyOption{ 105 FileType: []string{}, 106 }, 107 Name: "默认存储策略", 108 }, 109 }, user) 110 111 //未找到用户时 112 mock.ExpectQuery("^SELECT (.+)").WillReturnError(errors.New("not found")) 113 user, err = GetActiveUserByID(1) 114 asserts.Error(err) 115 asserts.Equal(User{}, user) 116 } 117 118 func TestUser_SetPassword(t *testing.T) { 119 asserts := assert.New(t) 120 user := User{} 121 err := user.SetPassword("Cause Sega does what nintendon't") 122 asserts.NoError(err) 123 asserts.NotEmpty(user.Password) 124 } 125 126 func TestUser_CheckPassword(t *testing.T) { 127 asserts := assert.New(t) 128 user := User{} 129 err := user.SetPassword("Cause Sega does what nintendon't") 130 asserts.NoError(err) 131 132 //密码正确 133 res, err := user.CheckPassword("Cause Sega does what nintendon't") 134 asserts.NoError(err) 135 asserts.True(res) 136 137 //密码错误 138 res, err = user.CheckPassword("Cause Sega does what Nintendon't") 139 asserts.NoError(err) 140 asserts.False(res) 141 142 //密码字段为空 143 user = User{} 144 res, err = user.CheckPassword("Cause Sega does what nintendon't") 145 asserts.Error(err) 146 asserts.False(res) 147 148 // 未知密码类型 149 user = User{} 150 user.Password = "1:2:3" 151 res, err = user.CheckPassword("Cause Sega does what nintendon't") 152 asserts.Error(err) 153 asserts.False(res) 154 155 // V2密码,错误 156 user = User{} 157 user.Password = "md5:2:3" 158 res, err = user.CheckPassword("Cause Sega does what nintendon't") 159 asserts.NoError(err) 160 asserts.False(res) 161 162 // V2密码,正确 163 user = User{} 164 user.Password = "md5:d8446059f8846a2c111a7f53515665fb:sdshare" 165 res, err = user.CheckPassword("admin") 166 asserts.NoError(err) 167 asserts.True(res) 168 169 } 170 171 func TestNewUser(t *testing.T) { 172 asserts := assert.New(t) 173 newUser := NewUser() 174 asserts.IsType(User{}, newUser) 175 asserts.Empty(newUser.Avatar) 176 } 177 178 func TestUser_AfterFind(t *testing.T) { 179 asserts := assert.New(t) 180 cache.Deletes([]string{"0"}, "policy_") 181 182 policyRows := sqlmock.NewRows([]string{"id", "name"}). 183 AddRow(144, "默认存储策略") 184 mock.ExpectQuery("^SELECT (.+)").WillReturnRows(policyRows) 185 186 newUser := NewUser() 187 err := newUser.AfterFind() 188 err = newUser.BeforeSave() 189 expected := UserOption{} 190 err = json.Unmarshal([]byte(newUser.Options), &expected) 191 192 asserts.NoError(err) 193 asserts.NoError(mock.ExpectationsWereMet()) 194 asserts.Equal(expected, newUser.OptionsSerialized) 195 asserts.Equal("默认存储策略", newUser.Policy.Name) 196 } 197 198 func TestUser_BeforeSave(t *testing.T) { 199 asserts := assert.New(t) 200 201 newUser := NewUser() 202 err := newUser.BeforeSave() 203 expected, err := json.Marshal(newUser.OptionsSerialized) 204 205 asserts.NoError(err) 206 asserts.Equal(string(expected), newUser.Options) 207 } 208 209 func TestUser_GetPolicyID(t *testing.T) { 210 asserts := assert.New(t) 211 212 newUser := NewUser() 213 newUser.Group.PolicyList = []uint{1} 214 215 asserts.EqualValues(1, newUser.GetPolicyID(0)) 216 217 newUser.Group.PolicyList = nil 218 asserts.EqualValues(0, newUser.GetPolicyID(0)) 219 220 newUser.Group.PolicyList = []uint{} 221 asserts.EqualValues(0, newUser.GetPolicyID(0)) 222 } 223 224 func TestUser_GetRemainingCapacity(t *testing.T) { 225 asserts := assert.New(t) 226 newUser := NewUser() 227 cache.Set("pack_size_0", uint64(0), 0) 228 229 newUser.Group.MaxStorage = 100 230 asserts.Equal(uint64(100), newUser.GetRemainingCapacity()) 231 232 newUser.Group.MaxStorage = 100 233 newUser.Storage = 1 234 asserts.Equal(uint64(99), newUser.GetRemainingCapacity()) 235 236 newUser.Group.MaxStorage = 100 237 newUser.Storage = 100 238 asserts.Equal(uint64(0), newUser.GetRemainingCapacity()) 239 240 newUser.Group.MaxStorage = 100 241 newUser.Storage = 200 242 asserts.Equal(uint64(0), newUser.GetRemainingCapacity()) 243 } 244 245 func TestUser_DeductionCapacity(t *testing.T) { 246 asserts := assert.New(t) 247 248 cache.Deletes([]string{"1"}, "policy_") 249 userRows := sqlmock.NewRows([]string{"id", "deleted_at", "storage", "options", "group_id"}). 250 AddRow(1, nil, 0, "{}", 1) 251 mock.ExpectQuery("^SELECT (.+)").WillReturnRows(userRows) 252 groupRows := sqlmock.NewRows([]string{"id", "name", "policies"}). 253 AddRow(1, "管理员", "[1]") 254 mock.ExpectQuery("^SELECT (.+)").WillReturnRows(groupRows) 255 256 policyRows := sqlmock.NewRows([]string{"id", "name"}). 257 AddRow(1, "默认存储策略") 258 mock.ExpectQuery("^SELECT (.+)").WillReturnRows(policyRows) 259 260 newUser, err := GetUserByID(1) 261 newUser.Group.MaxStorage = 100 262 cache.Set("pack_size_1", uint64(0), 0) 263 asserts.NoError(err) 264 asserts.NoError(mock.ExpectationsWereMet()) 265 266 asserts.Equal(false, newUser.IncreaseStorage(101)) 267 asserts.Equal(uint64(0), newUser.Storage) 268 269 asserts.Equal(true, newUser.IncreaseStorage(1)) 270 asserts.Equal(uint64(1), newUser.Storage) 271 272 asserts.Equal(true, newUser.IncreaseStorage(99)) 273 asserts.Equal(uint64(100), newUser.Storage) 274 275 asserts.Equal(false, newUser.IncreaseStorage(1)) 276 asserts.Equal(uint64(100), newUser.Storage) 277 278 asserts.True(newUser.IncreaseStorage(0)) 279 } 280 281 func TestUser_DeductionStorage(t *testing.T) { 282 asserts := assert.New(t) 283 284 // 减少零 285 { 286 user := User{Storage: 1} 287 asserts.True(user.DeductionStorage(0)) 288 asserts.Equal(uint64(1), user.Storage) 289 } 290 // 正常 291 { 292 user := User{ 293 Model: gorm.Model{ID: 1}, 294 Storage: 10, 295 } 296 mock.ExpectBegin() 297 mock.ExpectExec("UPDATE(.+)").WithArgs(5, sqlmock.AnyArg(), 1).WillReturnResult(sqlmock.NewResult(1, 1)) 298 mock.ExpectCommit() 299 300 asserts.True(user.DeductionStorage(5)) 301 asserts.NoError(mock.ExpectationsWereMet()) 302 asserts.Equal(uint64(5), user.Storage) 303 } 304 305 // 减少的超出可用的 306 { 307 user := User{ 308 Model: gorm.Model{ID: 1}, 309 Storage: 10, 310 } 311 mock.ExpectBegin() 312 mock.ExpectExec("UPDATE(.+)").WithArgs(0, sqlmock.AnyArg(), 1).WillReturnResult(sqlmock.NewResult(1, 1)) 313 mock.ExpectCommit() 314 315 asserts.False(user.DeductionStorage(20)) 316 asserts.NoError(mock.ExpectationsWereMet()) 317 asserts.Equal(uint64(0), user.Storage) 318 } 319 } 320 321 func TestUser_IncreaseStorageWithoutCheck(t *testing.T) { 322 asserts := assert.New(t) 323 324 // 增加零 325 { 326 user := User{} 327 user.IncreaseStorageWithoutCheck(0) 328 asserts.Equal(uint64(0), user.Storage) 329 } 330 331 // 减少零 332 { 333 user := User{ 334 Model: gorm.Model{ID: 1}, 335 } 336 mock.ExpectBegin() 337 mock.ExpectExec("UPDATE(.+)").WithArgs(10, sqlmock.AnyArg(), 1).WillReturnResult(sqlmock.NewResult(1, 1)) 338 mock.ExpectCommit() 339 340 user.IncreaseStorageWithoutCheck(10) 341 asserts.NoError(mock.ExpectationsWereMet()) 342 asserts.Equal(uint64(10), user.Storage) 343 } 344 } 345 346 func TestGetActiveUserByEmail(t *testing.T) { 347 asserts := assert.New(t) 348 349 mock.ExpectQuery("SELECT(.+)").WithArgs(Active, "abslant@foxmail.com").WillReturnRows(sqlmock.NewRows([]string{"id", "email"})) 350 _, err := GetActiveUserByEmail("abslant@foxmail.com") 351 352 asserts.Error(err) 353 asserts.NoError(mock.ExpectationsWereMet()) 354 } 355 356 func TestGetUserByEmail(t *testing.T) { 357 asserts := assert.New(t) 358 359 mock.ExpectQuery("SELECT(.+)").WithArgs("abslant@foxmail.com").WillReturnRows(sqlmock.NewRows([]string{"id", "email"})) 360 _, err := GetUserByEmail("abslant@foxmail.com") 361 362 asserts.Error(err) 363 asserts.NoError(mock.ExpectationsWereMet()) 364 } 365 366 func TestUser_AfterCreate(t *testing.T) { 367 asserts := assert.New(t) 368 user := User{Model: gorm.Model{ID: 1}} 369 mock.ExpectBegin() 370 mock.ExpectExec("INSERT(.+)").WillReturnResult(sqlmock.NewResult(1, 1)) 371 mock.ExpectCommit() 372 err := user.AfterCreate(DB) 373 asserts.NoError(err) 374 asserts.NoError(mock.ExpectationsWereMet()) 375 } 376 377 func TestUser_Root(t *testing.T) { 378 asserts := assert.New(t) 379 user := User{Model: gorm.Model{ID: 1}} 380 381 // 根目录存在 382 { 383 mock.ExpectQuery("SELECT(.+)").WithArgs(1).WillReturnRows(sqlmock.NewRows([]string{"id", "name"}).AddRow(1, "根目录")) 384 root, err := user.Root() 385 asserts.NoError(mock.ExpectationsWereMet()) 386 asserts.NoError(err) 387 asserts.Equal("根目录", root.Name) 388 } 389 390 // 根目录不存在 391 { 392 mock.ExpectQuery("SELECT(.+)").WithArgs(1).WillReturnRows(sqlmock.NewRows([]string{"id", "name"})) 393 _, err := user.Root() 394 asserts.NoError(mock.ExpectationsWereMet()) 395 asserts.Error(err) 396 } 397 } 398 399 func TestNewAnonymousUser(t *testing.T) { 400 asserts := assert.New(t) 401 402 mock.ExpectQuery("SELECT(.+)").WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow(3)) 403 user := NewAnonymousUser() 404 asserts.NoError(mock.ExpectationsWereMet()) 405 asserts.NotNil(user) 406 asserts.EqualValues(3, user.Group.ID) 407 } 408 409 func TestUser_IsAnonymous(t *testing.T) { 410 asserts := assert.New(t) 411 user := User{} 412 asserts.True(user.IsAnonymous()) 413 user.ID = 1 414 asserts.False(user.IsAnonymous()) 415 } 416 417 func TestUser_SetStatus(t *testing.T) { 418 asserts := assert.New(t) 419 user := User{} 420 mock.ExpectBegin() 421 mock.ExpectExec("UPDATE(.+)").WillReturnResult(sqlmock.NewResult(1, 1)) 422 mock.ExpectCommit() 423 user.SetStatus(Baned) 424 asserts.NoError(mock.ExpectationsWereMet()) 425 asserts.Equal(Baned, user.Status) 426 } 427 428 func TestUser_UpdateOptions(t *testing.T) { 429 asserts := assert.New(t) 430 user := User{} 431 432 mock.ExpectBegin() 433 mock.ExpectExec("UPDATE(.+)").WillReturnResult(sqlmock.NewResult(1, 1)) 434 mock.ExpectCommit() 435 436 asserts.NoError(user.UpdateOptions()) 437 asserts.NoError(mock.ExpectationsWereMet()) 438 }