github.com/cloudreve/Cloudreve/v3@v3.0.0-20240224133659-3edb00a6484c/models/folder_test.go (about) 1 package model 2 3 import ( 4 "errors" 5 "testing" 6 "time" 7 8 "github.com/DATA-DOG/go-sqlmock" 9 "github.com/cloudreve/Cloudreve/v3/pkg/conf" 10 "github.com/jinzhu/gorm" 11 "github.com/stretchr/testify/assert" 12 ) 13 14 func TestFolder_Create(t *testing.T) { 15 asserts := assert.New(t) 16 folder := &Folder{ 17 Name: "new folder", 18 } 19 20 // 不存在,插入成功 21 mock.ExpectQuery("SELECT(.+)folders(.+)").WillReturnRows(sqlmock.NewRows([]string{"id"})) 22 mock.ExpectBegin() 23 mock.ExpectExec("INSERT(.+)").WillReturnResult(sqlmock.NewResult(5, 1)) 24 mock.ExpectCommit() 25 fid, err := folder.Create() 26 asserts.NoError(err) 27 asserts.Equal(uint(5), fid) 28 asserts.NoError(mock.ExpectationsWereMet()) 29 30 // 插入失败 31 mock.ExpectQuery("SELECT(.+)folders(.+)").WillReturnRows(sqlmock.NewRows([]string{"id"})) 32 mock.ExpectBegin() 33 mock.ExpectExec("INSERT(.+)").WillReturnError(errors.New("error")) 34 mock.ExpectRollback() 35 mock.ExpectQuery("SELECT(.+)folders(.+)").WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow(1)) 36 fid, err = folder.Create() 37 asserts.NoError(err) 38 asserts.Equal(uint(1), fid) 39 asserts.NoError(mock.ExpectationsWereMet()) 40 41 // 存在,直接返回 42 mock.ExpectQuery("SELECT(.+)folders(.+)").WillReturnRows(sqlmock.NewRows([]string{"id"}).AddRow(5)) 43 fid, err = folder.Create() 44 asserts.NoError(err) 45 asserts.Equal(uint(5), fid) 46 asserts.NoError(mock.ExpectationsWereMet()) 47 } 48 49 func TestFolder_GetChild(t *testing.T) { 50 asserts := assert.New(t) 51 folder := Folder{ 52 Model: gorm.Model{ID: 5}, 53 OwnerID: 1, 54 Name: "/", 55 } 56 57 // 目录存在 58 { 59 mock.ExpectQuery("SELECT(.+)"). 60 WithArgs(5, 1, "sub"). 61 WillReturnRows(sqlmock.NewRows([]string{"id", "name"}).AddRow(1, "sub")) 62 sub, err := folder.GetChild("sub") 63 asserts.NoError(mock.ExpectationsWereMet()) 64 asserts.NoError(err) 65 asserts.Equal(sub.Name, "sub") 66 asserts.Equal("/", sub.Position) 67 } 68 69 // 目录不存在 70 { 71 mock.ExpectQuery("SELECT(.+)"). 72 WithArgs(5, 1, "sub"). 73 WillReturnRows(sqlmock.NewRows([]string{"id", "name"})) 74 sub, err := folder.GetChild("sub") 75 asserts.NoError(mock.ExpectationsWereMet()) 76 asserts.Error(err) 77 asserts.Equal(uint(0), sub.ID) 78 79 } 80 } 81 82 func TestFolder_GetChildFolder(t *testing.T) { 83 asserts := assert.New(t) 84 folder := &Folder{ 85 Model: gorm.Model{ 86 ID: 1, 87 }, 88 Position: "/123", 89 Name: "456", 90 } 91 92 // 找不到 93 mock.ExpectQuery("SELECT(.+)parent_id(.+)").WithArgs(1).WillReturnError(errors.New("error")) 94 files, err := folder.GetChildFolder() 95 asserts.Error(err) 96 asserts.Len(files, 0) 97 asserts.NoError(mock.ExpectationsWereMet()) 98 99 // 找到了 100 mock.ExpectQuery("SELECT(.+)parent_id(.+)").WithArgs(1).WillReturnRows(sqlmock.NewRows([]string{"name", "id"}).AddRow("1.txt", 1).AddRow("2.txt", 2)) 101 files, err = folder.GetChildFolder() 102 asserts.NoError(err) 103 asserts.Len(files, 2) 104 asserts.Equal("/123/456", files[0].Position) 105 asserts.NoError(mock.ExpectationsWereMet()) 106 } 107 108 func TestGetRecursiveChildFolderSQLite(t *testing.T) { 109 conf.DatabaseConfig.Type = "sqlite" 110 asserts := assert.New(t) 111 112 // 测试目录结构 113 // 1 114 // 2 3 115 // 4 5 6 116 117 // 查询第一层 118 mock.ExpectQuery("SELECT(.+)"). 119 WithArgs(1, 1). 120 WillReturnRows( 121 sqlmock.NewRows([]string{"id", "name"}). 122 AddRow(1, "folder1"), 123 ) 124 // 查询第二层 125 mock.ExpectQuery("SELECT(.+)"). 126 WithArgs(1, 1). 127 WillReturnRows( 128 sqlmock.NewRows([]string{"id", "name"}). 129 AddRow(2, "folder2"). 130 AddRow(3, "folder3"), 131 ) 132 // 查询第三层 133 mock.ExpectQuery("SELECT(.+)"). 134 WithArgs(1, 2, 3). 135 WillReturnRows( 136 sqlmock.NewRows([]string{"id", "name"}). 137 AddRow(4, "folder4"). 138 AddRow(5, "folder5"). 139 AddRow(6, "folder6"), 140 ) 141 // 查询第四层 142 mock.ExpectQuery("SELECT(.+)"). 143 WithArgs(1, 4, 5, 6). 144 WillReturnRows( 145 sqlmock.NewRows([]string{"id", "name"}), 146 ) 147 148 folders, err := GetRecursiveChildFolder([]uint{1}, 1, true) 149 asserts.NoError(err) 150 asserts.NoError(mock.ExpectationsWereMet()) 151 asserts.Len(folders, 6) 152 } 153 154 func TestDeleteFolderByIDs(t *testing.T) { 155 asserts := assert.New(t) 156 157 // 出错 158 { 159 mock.ExpectBegin() 160 mock.ExpectExec("DELETE(.+)"). 161 WillReturnError(errors.New("error")) 162 mock.ExpectRollback() 163 err := DeleteFolderByIDs([]uint{1, 2, 3}) 164 asserts.NoError(mock.ExpectationsWereMet()) 165 asserts.Error(err) 166 } 167 // 成功 168 { 169 mock.ExpectBegin() 170 mock.ExpectExec("DELETE(.+)"). 171 WillReturnResult(sqlmock.NewResult(0, 3)) 172 mock.ExpectCommit() 173 err := DeleteFolderByIDs([]uint{1, 2, 3}) 174 asserts.NoError(mock.ExpectationsWereMet()) 175 asserts.NoError(err) 176 } 177 } 178 179 func TestGetFoldersByIDs(t *testing.T) { 180 asserts := assert.New(t) 181 182 // 出错 183 { 184 mock.ExpectQuery("SELECT(.+)"). 185 WithArgs(1, 2, 3, 1). 186 WillReturnError(errors.New("error")) 187 folders, err := GetFoldersByIDs([]uint{1, 2, 3}, 1) 188 asserts.NoError(mock.ExpectationsWereMet()) 189 asserts.Error(err) 190 asserts.Len(folders, 0) 191 } 192 193 // 部分找到 194 { 195 mock.ExpectQuery("SELECT(.+)"). 196 WithArgs(1, 2, 3, 1). 197 WillReturnRows(sqlmock.NewRows([]string{"id", "name"}).AddRow(1, "1")) 198 folders, err := GetFoldersByIDs([]uint{1, 2, 3}, 1) 199 asserts.NoError(mock.ExpectationsWereMet()) 200 asserts.NoError(err) 201 asserts.Len(folders, 1) 202 } 203 } 204 205 func TestFolder_MoveOrCopyFileTo(t *testing.T) { 206 asserts := assert.New(t) 207 // 当前目录 208 folder := Folder{ 209 Model: gorm.Model{ID: 1}, 210 OwnerID: 1, 211 Name: "test", 212 } 213 // 目标目录 214 dstFolder := Folder{ 215 Model: gorm.Model{ID: 10}, 216 Name: "dst", 217 } 218 219 // 复制文件 220 { 221 mock.ExpectQuery("SELECT(.+)"). 222 WithArgs( 223 1, 224 2, 225 3, 226 1, 227 1, 228 ).WillReturnRows( 229 sqlmock.NewRows([]string{"id", "size", "upload_session_id"}). 230 AddRow(1, 10, nil). 231 AddRow(2, 20, nil). 232 AddRow(2, 20, &folder.Name), 233 ) 234 mock.ExpectBegin() 235 mock.ExpectExec("INSERT(.+)").WillReturnResult(sqlmock.NewResult(1, 1)) 236 mock.ExpectCommit() 237 mock.ExpectBegin() 238 mock.ExpectExec("INSERT(.+)").WillReturnResult(sqlmock.NewResult(1, 1)) 239 mock.ExpectCommit() 240 storage, err := folder.MoveOrCopyFileTo( 241 []uint{1, 2, 3}, 242 &dstFolder, 243 true, 244 ) 245 asserts.NoError(err) 246 asserts.NoError(mock.ExpectationsWereMet()) 247 asserts.Equal(uint64(30), storage) 248 } 249 250 // 复制文件, 检索文件出错 251 { 252 mock.ExpectQuery("SELECT(.+)"). 253 WithArgs( 254 1, 255 2, 256 1, 257 1, 258 ).WillReturnError(errors.New("error")) 259 260 storage, err := folder.MoveOrCopyFileTo( 261 []uint{1, 2}, 262 &dstFolder, 263 true, 264 ) 265 asserts.Error(err) 266 asserts.NoError(mock.ExpectationsWereMet()) 267 asserts.Equal(uint64(0), storage) 268 } 269 270 // 复制文件,第二个文件插入出错 271 { 272 mock.ExpectQuery("SELECT(.+)"). 273 WithArgs( 274 1, 275 2, 276 1, 277 1, 278 ).WillReturnRows( 279 sqlmock.NewRows([]string{"id", "size"}). 280 AddRow(1, 10). 281 AddRow(2, 20), 282 ) 283 mock.ExpectBegin() 284 mock.ExpectExec("INSERT(.+)").WillReturnResult(sqlmock.NewResult(1, 1)) 285 mock.ExpectCommit() 286 mock.ExpectBegin() 287 mock.ExpectExec("INSERT(.+)").WillReturnError(errors.New("error")) 288 mock.ExpectRollback() 289 storage, err := folder.MoveOrCopyFileTo( 290 []uint{1, 2}, 291 &dstFolder, 292 true, 293 ) 294 asserts.Error(err) 295 asserts.NoError(mock.ExpectationsWereMet()) 296 asserts.Equal(uint64(10), storage) 297 } 298 299 // 移动文件 成功 300 { 301 mock.ExpectBegin() 302 mock.ExpectExec("UPDATE(.+)"). 303 WithArgs(10, sqlmock.AnyArg(), 1, 2, 1, 1). 304 WillReturnResult(sqlmock.NewResult(1, 2)) 305 mock.ExpectCommit() 306 storage, err := folder.MoveOrCopyFileTo( 307 []uint{1, 2}, 308 &dstFolder, 309 false, 310 ) 311 asserts.NoError(mock.ExpectationsWereMet()) 312 asserts.NoError(err) 313 asserts.Equal(uint64(0), storage) 314 } 315 316 // 移动文件 出错 317 { 318 mock.ExpectBegin() 319 mock.ExpectExec("UPDATE(.+)"). 320 WithArgs(10, sqlmock.AnyArg(), 1, 2, 1, 1). 321 WillReturnError(errors.New("error")) 322 mock.ExpectRollback() 323 storage, err := folder.MoveOrCopyFileTo( 324 []uint{1, 2}, 325 &dstFolder, 326 false, 327 ) 328 asserts.NoError(mock.ExpectationsWereMet()) 329 asserts.Error(err) 330 asserts.Equal(uint64(0), storage) 331 } 332 } 333 334 func TestFolder_CopyFolderTo(t *testing.T) { 335 conf.DatabaseConfig.Type = "mysql" 336 asserts := assert.New(t) 337 // 父目录 338 parFolder := Folder{ 339 Model: gorm.Model{ID: 9}, 340 OwnerID: 1, 341 } 342 // 目标目录 343 dstFolder := Folder{ 344 Model: gorm.Model{ID: 10}, 345 } 346 347 // 测试复制目录结构 348 // test(2)(5) 349 // 1(3)(6) 2.txt 350 // 3(4)(7) 4.txt 5.txt(上传中) 351 352 // 正常情况 成功 353 { 354 // GetRecursiveChildFolder 355 mock.ExpectQuery("SELECT(.+)").WithArgs(1, 2).WillReturnRows(sqlmock.NewRows([]string{"id", "parent_id"}).AddRow(2, 9)) 356 mock.ExpectQuery("SELECT(.+)").WithArgs(1, 2).WillReturnRows(sqlmock.NewRows([]string{"id", "parent_id"}).AddRow(3, 2)) 357 mock.ExpectQuery("SELECT(.+)").WithArgs(1, 3).WillReturnRows(sqlmock.NewRows([]string{"id", "parent_id"}).AddRow(4, 3)) 358 mock.ExpectQuery("SELECT(.+)").WithArgs(1, 4).WillReturnRows(sqlmock.NewRows([]string{"id", "parent_id"})) 359 360 // 复制目录 361 mock.ExpectBegin() 362 mock.ExpectExec("INSERT(.+)").WillReturnResult(sqlmock.NewResult(5, 1)) 363 mock.ExpectCommit() 364 mock.ExpectBegin() 365 mock.ExpectExec("INSERT(.+)").WillReturnResult(sqlmock.NewResult(6, 1)) 366 mock.ExpectCommit() 367 mock.ExpectBegin() 368 mock.ExpectExec("INSERT(.+)").WillReturnResult(sqlmock.NewResult(7, 1)) 369 mock.ExpectCommit() 370 371 // 查找子文件 372 mock.ExpectQuery("SELECT(.+)"). 373 WithArgs(1, 2, 3, 4). 374 WillReturnRows( 375 sqlmock.NewRows([]string{"id", "name", "folder_id", "size", "upload_session_id"}). 376 AddRow(1, "2.txt", 2, 10, nil). 377 AddRow(2, "3.txt", 3, 20, nil). 378 AddRow(3, "5.txt", 3, 20, &dstFolder.Name), 379 ) 380 381 // 复制子文件 382 mock.ExpectBegin() 383 mock.ExpectExec("INSERT(.+)").WillReturnResult(sqlmock.NewResult(5, 1)) 384 mock.ExpectCommit() 385 mock.ExpectBegin() 386 mock.ExpectExec("INSERT(.+)").WillReturnResult(sqlmock.NewResult(6, 1)) 387 mock.ExpectCommit() 388 389 size, err := parFolder.CopyFolderTo(2, &dstFolder) 390 asserts.NoError(mock.ExpectationsWereMet()) 391 asserts.NoError(err) 392 asserts.Equal(uint64(30), size) 393 } 394 395 // 递归查询失败 396 { 397 // GetRecursiveChildFolder 398 mock.ExpectQuery("SELECT(.+)").WithArgs(1, 2).WillReturnError(errors.New("error")) 399 400 size, err := parFolder.CopyFolderTo(2, &dstFolder) 401 asserts.NoError(mock.ExpectationsWereMet()) 402 asserts.Error(err) 403 asserts.Equal(uint64(0), size) 404 } 405 406 // 父目录ID不存在 407 { 408 // GetRecursiveChildFolder 409 mock.ExpectQuery("SELECT(.+)").WithArgs(1, 2).WillReturnRows(sqlmock.NewRows([]string{"id", "parent_id"}).AddRow(2, 9)) 410 mock.ExpectQuery("SELECT(.+)").WithArgs(1, 2).WillReturnRows(sqlmock.NewRows([]string{"id", "parent_id"}).AddRow(3, 99)) 411 mock.ExpectQuery("SELECT(.+)").WithArgs(1, 3).WillReturnRows(sqlmock.NewRows([]string{"id", "parent_id"}).AddRow(4, 3)) 412 mock.ExpectQuery("SELECT(.+)").WithArgs(1, 4).WillReturnRows(sqlmock.NewRows([]string{"id", "parent_id"})) 413 414 // 复制目录 415 mock.ExpectBegin() 416 mock.ExpectExec("INSERT(.+)").WillReturnResult(sqlmock.NewResult(5, 1)) 417 mock.ExpectCommit() 418 419 size, err := parFolder.CopyFolderTo(2, &dstFolder) 420 asserts.NoError(mock.ExpectationsWereMet()) 421 asserts.Error(err) 422 asserts.Equal(uint64(0), size) 423 } 424 425 // 查询子文件失败 426 { 427 // GetRecursiveChildFolder 428 mock.ExpectQuery("SELECT(.+)").WithArgs(1, 2).WillReturnRows(sqlmock.NewRows([]string{"id", "parent_id"}).AddRow(2, 9)) 429 mock.ExpectQuery("SELECT(.+)").WithArgs(1, 2).WillReturnRows(sqlmock.NewRows([]string{"id", "parent_id"}).AddRow(3, 2)) 430 mock.ExpectQuery("SELECT(.+)").WithArgs(1, 3).WillReturnRows(sqlmock.NewRows([]string{"id", "parent_id"}).AddRow(4, 3)) 431 mock.ExpectQuery("SELECT(.+)").WithArgs(1, 4).WillReturnRows(sqlmock.NewRows([]string{"id", "parent_id"})) 432 433 // 复制目录 434 mock.ExpectBegin() 435 mock.ExpectExec("INSERT(.+)").WillReturnResult(sqlmock.NewResult(5, 1)) 436 mock.ExpectCommit() 437 mock.ExpectBegin() 438 mock.ExpectExec("INSERT(.+)").WillReturnResult(sqlmock.NewResult(6, 1)) 439 mock.ExpectCommit() 440 mock.ExpectBegin() 441 mock.ExpectExec("INSERT(.+)").WillReturnResult(sqlmock.NewResult(7, 1)) 442 mock.ExpectCommit() 443 444 // 查找子文件 445 mock.ExpectQuery("SELECT(.+)"). 446 WithArgs(1, 2, 3, 4). 447 WillReturnError(errors.New("error")) 448 449 size, err := parFolder.CopyFolderTo(2, &dstFolder) 450 asserts.NoError(mock.ExpectationsWereMet()) 451 asserts.Error(err) 452 asserts.Equal(uint64(0), size) 453 } 454 455 // 复制文件 一个失败 456 { 457 // GetRecursiveChildFolder 458 mock.ExpectQuery("SELECT(.+)").WithArgs(1, 2).WillReturnRows(sqlmock.NewRows([]string{"id", "parent_id"}).AddRow(2, 9)) 459 mock.ExpectQuery("SELECT(.+)").WithArgs(1, 2).WillReturnRows(sqlmock.NewRows([]string{"id", "parent_id"}).AddRow(3, 2)) 460 mock.ExpectQuery("SELECT(.+)").WithArgs(1, 3).WillReturnRows(sqlmock.NewRows([]string{"id", "parent_id"}).AddRow(4, 3)) 461 mock.ExpectQuery("SELECT(.+)").WithArgs(1, 4).WillReturnRows(sqlmock.NewRows([]string{"id", "parent_id"})) 462 463 // 复制目录 464 mock.ExpectBegin() 465 mock.ExpectExec("INSERT(.+)").WillReturnResult(sqlmock.NewResult(5, 1)) 466 mock.ExpectCommit() 467 mock.ExpectBegin() 468 mock.ExpectExec("INSERT(.+)").WillReturnResult(sqlmock.NewResult(6, 1)) 469 mock.ExpectCommit() 470 mock.ExpectBegin() 471 mock.ExpectExec("INSERT(.+)").WillReturnResult(sqlmock.NewResult(7, 1)) 472 mock.ExpectCommit() 473 474 // 查找子文件 475 mock.ExpectQuery("SELECT(.+)"). 476 WithArgs(1, 2, 3, 4). 477 WillReturnRows( 478 sqlmock.NewRows([]string{"id", "name", "folder_id", "size"}). 479 AddRow(1, "2.txt", 2, 10). 480 AddRow(2, "3.txt", 3, 20), 481 ) 482 483 // 复制子文件 484 mock.ExpectBegin() 485 mock.ExpectExec("INSERT(.+)").WillReturnResult(sqlmock.NewResult(5, 1)) 486 mock.ExpectCommit() 487 mock.ExpectBegin() 488 mock.ExpectExec("INSERT(.+)").WillReturnError(errors.New("error")) 489 mock.ExpectRollback() 490 491 size, err := parFolder.CopyFolderTo(2, &dstFolder) 492 asserts.NoError(mock.ExpectationsWereMet()) 493 asserts.Error(err) 494 asserts.Equal(uint64(10), size) 495 } 496 497 } 498 499 func TestFolder_MoveOrCopyFolderTo_Move(t *testing.T) { 500 conf.DatabaseConfig.Type = "mysql" 501 asserts := assert.New(t) 502 // 父目录 503 parFolder := Folder{ 504 Model: gorm.Model{ID: 9}, 505 OwnerID: 1, 506 } 507 // 目标目录 508 dstFolder := Folder{ 509 Model: gorm.Model{ID: 10}, 510 OwnerID: 1, 511 } 512 513 // 成功 514 { 515 mock.ExpectBegin() 516 mock.ExpectExec("UPDATE(.+)"). 517 WithArgs(10, sqlmock.AnyArg(), 1, 2, 1, 9). 518 WillReturnResult(sqlmock.NewResult(1, 1)) 519 mock.ExpectCommit() 520 err := parFolder.MoveFolderTo([]uint{1, 2}, &dstFolder) 521 asserts.NoError(mock.ExpectationsWereMet()) 522 asserts.NoError(err) 523 } 524 525 // 移动自己到自己内部,失败 526 { 527 err := parFolder.MoveFolderTo([]uint{10, 2}, &dstFolder) 528 asserts.Error(err) 529 } 530 } 531 532 func TestFolder_FileInfoInterface(t *testing.T) { 533 asserts := assert.New(t) 534 folder := Folder{ 535 Model: gorm.Model{ 536 UpdatedAt: time.Date(2019, 12, 21, 12, 40, 0, 0, time.UTC), 537 }, 538 Name: "test_name", 539 OwnerID: 0, 540 Position: "/test", 541 } 542 543 name := folder.GetName() 544 asserts.Equal("test_name", name) 545 546 size := folder.GetSize() 547 asserts.Equal(uint64(0), size) 548 549 asserts.Equal(time.Date(2019, 12, 21, 12, 40, 0, 0, time.UTC), folder.ModTime()) 550 asserts.True(folder.IsDir()) 551 asserts.Equal("/test", folder.GetPosition()) 552 } 553 554 func TestTraceRoot(t *testing.T) { 555 asserts := assert.New(t) 556 var parentId uint 557 parentId = 5 558 folder := Folder{ 559 ParentID: &parentId, 560 OwnerID: 1, 561 Name: "test_name", 562 } 563 564 // 成功 565 { 566 mock.ExpectQuery("SELECT(.+)").WithArgs(5, 1). 567 WillReturnRows(sqlmock.NewRows([]string{"id", "name", "parent_id"}).AddRow(5, "parent", 1)) 568 mock.ExpectQuery("SELECT(.+)").WithArgs(1, 0). 569 WillReturnRows(sqlmock.NewRows([]string{"id", "name"}).AddRow(5, "/")) 570 asserts.NoError(folder.TraceRoot()) 571 asserts.Equal("/parent", folder.Position) 572 asserts.NoError(mock.ExpectationsWereMet()) 573 } 574 575 // 出现错误 576 // 成功 577 { 578 mock.ExpectQuery("SELECT(.+)").WithArgs(5, 1). 579 WillReturnRows(sqlmock.NewRows([]string{"id", "name", "parent_id"}).AddRow(5, "parent", 1)) 580 mock.ExpectQuery("SELECT(.+)").WithArgs(1, 0). 581 WillReturnError(errors.New("error")) 582 asserts.Error(folder.TraceRoot()) 583 asserts.Equal("parent", folder.Position) 584 asserts.NoError(mock.ExpectationsWereMet()) 585 } 586 } 587 588 func TestFolder_Rename(t *testing.T) { 589 asserts := assert.New(t) 590 folder := Folder{ 591 Model: gorm.Model{ 592 ID: 1, 593 }, 594 Name: "test_name", 595 OwnerID: 1, 596 Position: "/test", 597 } 598 599 // 成功 600 { 601 mock.ExpectBegin() 602 mock.ExpectExec("UPDATE(.+)folders(.+)SET(.+)"). 603 WithArgs("test_name_new", 1). 604 WillReturnResult(sqlmock.NewResult(1, 1)) 605 mock.ExpectCommit() 606 err := folder.Rename("test_name_new") 607 asserts.NoError(mock.ExpectationsWereMet()) 608 asserts.NoError(err) 609 } 610 611 // 出现错误 612 { 613 mock.ExpectBegin() 614 mock.ExpectExec("UPDATE(.+)folders(.+)SET(.+)"). 615 WithArgs("test_name_new", 1). 616 WillReturnError(errors.New("error")) 617 mock.ExpectRollback() 618 err := folder.Rename("test_name_new") 619 asserts.NoError(mock.ExpectationsWereMet()) 620 asserts.Error(err) 621 } 622 }