github.com/friesencr/pop/v6@v6.1.6/finders_test.go (about) 1 package pop 2 3 import ( 4 "testing" 5 6 "github.com/gobuffalo/nulls" 7 "github.com/gofrs/uuid/v5" 8 "github.com/stretchr/testify/require" 9 ) 10 11 func Test_Find(t *testing.T) { 12 if PDB == nil { 13 t.Skip("skipping integration tests") 14 } 15 transaction(func(tx *Connection) { 16 r := require.New(t) 17 tCases := []string{ 18 "Mark", 19 "💩", 20 } 21 22 for _, tc := range tCases { 23 user := User{Name: nulls.NewString(tc)} 24 err := tx.Create(&user) 25 r.NoError(err) 26 27 u := User{} 28 err = tx.Find(&u, user.ID) 29 r.NoError(err) 30 31 r.NotEqual(u.ID, 0) 32 r.Equal(u.Name.String, tc) 33 } 34 }) 35 } 36 37 func Test_Create_MissingID(t *testing.T) { 38 if PDB == nil { 39 t.Skip("skipping integration tests") 40 } 41 transaction(func(tx *Connection) { 42 r := require.New(t) 43 client := Client{ClientID: "client-0001"} 44 err := tx.Create(&client) 45 r.Error(err) 46 r.Contains(err.Error(), "model *pop.Client is missing required field ID") 47 }) 48 } 49 50 func Test_Find_MissingID(t *testing.T) { 51 if PDB == nil { 52 t.Skip("skipping integration tests") 53 } 54 transaction(func(tx *Connection) { 55 r := require.New(t) 56 r.NoError(tx.RawQuery("INSERT INTO clients (id) VALUES (?)", "client-0001").Exec()) 57 58 u := Client{} 59 r.EqualError(tx.Find(&u, "client-0001"), "model *pop.Client is missing required field ID") 60 }) 61 } 62 63 func Test_Find_LeadingZeros(t *testing.T) { 64 if PDB == nil { 65 t.Skip("skipping integration tests") 66 } 67 transaction(func(tx *Connection) { 68 r := require.New(t) 69 70 labels := []string{ 71 "0", 72 "01", 73 "001", 74 "123", 75 } 76 77 for _, v := range labels { 78 label := Label{ID: v} 79 err := tx.Create(&label) 80 r.NoError(err) 81 82 l := Label{} 83 err = tx.Find(&l, v) 84 r.NoError(err) 85 86 r.Equal(l.ID, v) 87 } 88 }) 89 } 90 91 func Test_Select(t *testing.T) { 92 if PDB == nil { 93 t.Skip("skipping integration tests") 94 } 95 transaction(func(tx *Connection) { 96 r := require.New(t) 97 98 user := User{Name: nulls.NewString("Mark"), Email: "mark@gobuffalo.io"} 99 err := tx.Create(&user) 100 r.NoError(err) 101 102 q := tx.Select("name", "email", "\n", "\t\n", "") 103 104 sm := NewModel(new(User), tx.Context()) 105 sql, _ := q.ToSQL(sm) 106 r.Equal(tx.Dialect.TranslateSQL("SELECT email, name FROM users AS users"), sql) 107 108 u := User{} 109 err = q.Find(&u, user.ID) 110 r.NoError(err) 111 112 r.Equal(u.Email, "mark@gobuffalo.io") 113 r.Equal(u.Name.String, "Mark") 114 r.Zero(u.ID) 115 }) 116 } 117 118 func Test_Find_Eager_Has_Many(t *testing.T) { 119 if PDB == nil { 120 t.Skip("skipping integration tests") 121 } 122 transaction(func(tx *Connection) { 123 r := require.New(t) 124 125 user := User{Name: nulls.NewString("Mark")} 126 err := tx.Create(&user) 127 r.NoError(err) 128 129 book := Book{Title: "Pop Book", Isbn: "PB1", UserID: nulls.NewInt(user.ID)} 130 err = tx.Create(&book) 131 r.NoError(err) 132 133 u := User{} 134 err = tx.Eager("Books").Find(&u, user.ID) 135 r.NoError(err) 136 137 r.NotEqual(u.ID, 0) 138 r.Equal(u.Name.String, "Mark") 139 books := u.Books 140 r.NotEqual(len(books), 0) 141 r.Equal(books[0].Title, book.Title) 142 }) 143 } 144 145 func Test_All_Eager_Preload_Mode(t *testing.T) { 146 if PDB == nil { 147 t.Skip("skipping integration tests") 148 } 149 transaction(func(tx *Connection) { 150 r := require.New(t) 151 152 for _, name := range []string{"Mark", "Joe", "Jane"} { 153 user := User{Name: nulls.NewString(name)} 154 err := tx.Create(&user) 155 r.NoError(err) 156 157 if name == "Mark" { 158 for _, title := range []string{"Pop Book", "My Pop Book", "Asociations Book"} { 159 book := Book{Title: title, Isbn: "PB1", UserID: nulls.NewInt(user.ID)} 160 err = tx.Create(&book) 161 r.NoError(err) 162 } 163 } 164 } 165 166 u := Users{} 167 err := tx.EagerPreload().All(&u) 168 r.NoError(err) 169 r.Equal(len(u), 3) 170 r.Equal(len(u[0].Books), 3) 171 r.Equal(u[0].Books[0].Title, "Asociations Book") 172 r.Equal(u[0].Books[1].Title, "My Pop Book") 173 r.Equal(u[0].Books[2].Title, "Pop Book") 174 }) 175 } 176 177 func Test_Find_Eager_Has_Many_Order_By(t *testing.T) { 178 if PDB == nil { 179 t.Skip("skipping integration tests") 180 } 181 transaction(func(tx *Connection) { 182 r := require.New(t) 183 184 user := User{Name: nulls.NewString("Mark")} 185 err := tx.Create(&user) 186 r.NoError(err) 187 188 book1 := Book{Title: "Pop Book", Isbn: "PB1", UserID: nulls.NewInt(user.ID)} 189 err = tx.Create(&book1) 190 r.NoError(err) 191 192 book2 := Book{Title: "New Pop Book", Isbn: "PB2", UserID: nulls.NewInt(user.ID)} 193 err = tx.Create(&book2) 194 r.NoError(err) 195 196 u := User{} 197 err = tx.Eager().Find(&u, user.ID) 198 r.NoError(err) 199 200 r.Equal(len(u.Books), 2) 201 r.Equal(book2.Title, u.Books[0].Title) 202 }) 203 } 204 205 func Test_Find_Eager_Belongs_To(t *testing.T) { 206 if PDB == nil { 207 t.Skip("skipping integration tests") 208 } 209 transaction(func(tx *Connection) { 210 r := require.New(t) 211 212 user := User{Name: nulls.NewString("Mark"), UserName: "mark"} 213 err := tx.Create(&user) 214 r.NoError(err) 215 216 book := Book{Title: "Pop Book", Isbn: "PB1", UserID: nulls.NewInt(user.ID)} 217 err = tx.Create(&book) 218 r.NoError(err) 219 220 b := Book{} 221 err = tx.Eager().Find(&b, book.ID) 222 r.NoError(err) 223 224 r.NotEqual(b.ID, 0) 225 r.NotEqual(b.User.ID, 0) 226 r.Equal(b.User.ID, user.ID) 227 228 userAttr := UserAttribute{UserName: "mark", NickName: "Mark Z."} 229 err = tx.Create(&userAttr) 230 r.NoError(err) 231 232 uA := UserAttribute{} 233 err = tx.Eager().Find(&uA, userAttr.ID) 234 r.NoError(err) 235 r.Equal(uA.User.ID, user.ID) 236 }) 237 } 238 239 func Test_Find_Eager_Belongs_To_Nulls(t *testing.T) { 240 if PDB == nil { 241 t.Skip("skipping integration tests") 242 } 243 transaction(func(tx *Connection) { 244 r := require.New(t) 245 246 user := User{Name: nulls.NewString("Mark")} 247 err := tx.Create(&user) 248 r.NoError(err) 249 250 book := Book{Title: "Pop Book", Isbn: "PB1"} 251 err = tx.Create(&book) 252 r.NoError(err) 253 254 b := Book{} 255 err = tx.Eager().Find(&b, book.ID) 256 r.NoError(err) 257 }) 258 } 259 260 func Test_Find_Eager_Belongs_To_Pointers(t *testing.T) { 261 if PDB == nil { 262 t.Skip("skipping integration tests") 263 } 264 transaction(func(tx *Connection) { 265 r := require.New(t) 266 267 body := Body{} 268 err := tx.Create(&body) 269 r.NoError(err) 270 271 head := Head{BodyID: body.ID} 272 err = tx.Create(&head) 273 r.NoError(err) 274 275 b := Body{} 276 err = tx.Eager().Find(&b, body.ID) 277 r.NoError(err) 278 }) 279 } 280 281 func Test_Find_Eager_Has_One(t *testing.T) { 282 if PDB == nil { 283 t.Skip("skipping integration tests") 284 } 285 transaction(func(tx *Connection) { 286 r := require.New(t) 287 288 user := User{Name: nulls.NewString("Mark")} 289 err := tx.Create(&user) 290 r.NoError(err) 291 292 coolSong := Song{Title: "Hook - Blues Traveler", UserID: user.ID} 293 err = tx.Create(&coolSong) 294 r.NoError(err) 295 296 u := User{} 297 err = tx.Eager().Find(&u, user.ID) 298 r.NoError(err) 299 300 r.NotEqual(u.ID, 0) 301 r.Equal(u.Name.String, "Mark") 302 r.Equal(u.FavoriteSong.ID, coolSong.ID) 303 304 // eager should work with rawquery 305 uid := u.ID 306 u = User{} 307 err = tx.RawQuery("select * from users where id=?", uid).First(&u) 308 r.NoError(err) 309 r.Equal(u.FavoriteSong.ID, uuid.Nil) 310 311 err = tx.RawQuery("select * from users where id=?", uid).Eager("FavoriteSong").First(&u) 312 r.NoError(err) 313 r.Equal(u.FavoriteSong.ID, coolSong.ID) 314 }) 315 } 316 317 func Test_Find_Eager_Has_One_With_Inner_Associations_Pointer(t *testing.T) { 318 if PDB == nil { 319 t.Skip("skipping integration tests") 320 } 321 transaction(func(tx *Connection) { 322 r := require.New(t) 323 324 user := UserPointerAssocs{Name: nulls.NewString("Mark")} 325 err := tx.Create(&user) 326 r.NoError(err) 327 328 coolSong := Song{Title: "Hook - Blues Traveler", UserID: user.ID} 329 err = tx.Create(&coolSong) 330 r.NoError(err) 331 332 u := UserPointerAssocs{} 333 err = tx.Eager("FavoriteSong.ComposedBy").Find(&u, user.ID) 334 r.NoError(err) 335 336 r.NotEqual(u.ID, 0) 337 r.Equal(u.Name.String, "Mark") 338 r.Equal(u.FavoriteSong.ID, coolSong.ID) 339 340 // eager should work with rawquery 341 uid := u.ID 342 u = UserPointerAssocs{} 343 err = tx.RawQuery("select * from users where id=?", uid).First(&u) 344 r.NoError(err) 345 r.Nil(u.FavoriteSong) 346 347 err = tx.RawQuery("select * from users where id=?", uid).Eager("FavoriteSong").First(&u) 348 r.NoError(err) 349 r.Equal(u.FavoriteSong.ID, coolSong.ID) 350 }) 351 } 352 353 func Test_Find_Eager_Has_One_With_Inner_Associations_Struct(t *testing.T) { 354 if PDB == nil { 355 t.Skip("skipping integration tests") 356 } 357 transaction(func(tx *Connection) { 358 r := require.New(t) 359 360 user := User{Name: nulls.NewString("Mark")} 361 err := tx.Create(&user) 362 r.NoError(err) 363 364 composer := Composer{Name: "Blues Traveler"} 365 err = tx.Create(&composer) 366 r.NoError(err) 367 368 coolSong := Song{Title: "Hook", UserID: user.ID, ComposedByID: composer.ID} 369 err = tx.Create(&coolSong) 370 r.NoError(err) 371 372 u := User{} 373 err = tx.Eager("FavoriteSong.ComposedBy").Find(&u, user.ID) 374 r.NoError(err) 375 376 r.NotEqual(u.ID, 0) 377 r.Equal(u.Name.String, "Mark") 378 r.Equal(u.FavoriteSong.ID, coolSong.ID) 379 r.Equal(u.FavoriteSong.ComposedBy.Name, composer.Name) 380 }) 381 } 382 383 func Test_Find_Eager_Has_One_With_Inner_Associations_Slice(t *testing.T) { 384 if PDB == nil { 385 t.Skip("skipping integration tests") 386 } 387 transaction(func(tx *Connection) { 388 r := require.New(t) 389 390 user := User{Name: nulls.NewString("Mark")} 391 err := tx.Create(&user) 392 r.NoError(err) 393 394 book := Book{Title: "Pop Book", Isbn: "PB1", UserID: nulls.NewInt(user.ID)} 395 err = tx.Create(&book) 396 r.NoError(err) 397 398 writer := Writer{Name: "Mark Bates", BookID: book.ID} 399 err = tx.Create(&writer) 400 r.NoError(err) 401 402 u := User{} 403 err = tx.Eager("Books.Writers").Find(&u, user.ID) 404 r.NoError(err) 405 406 r.NotEqual(u.ID, 0) 407 r.Equal(u.Name.String, "Mark") 408 r.Equal(len(u.Books), 1) 409 r.Equal(len(u.Books[0].Writers), 1) 410 411 r.Equal(u.Books[0].Title, book.Title) 412 r.Equal(u.Books[0].Writers[0].Name, writer.Name) 413 r.Zero(u.Books[0].Writers[0].Book.ID) 414 }) 415 } 416 417 func Test_Eager_Bad_Format(t *testing.T) { 418 if PDB == nil { 419 t.Skip("skipping integration tests") 420 } 421 transaction(func(tx *Connection) { 422 r := require.New(t) 423 424 user := User{Name: nulls.NewString("Mark")} 425 err := tx.Create(&user) 426 r.NoError(err) 427 428 u := User{} 429 err = tx.Eager("Books.").First(&u) 430 r.Error(err) 431 432 err = tx.Eager("Books.*").First(&u) 433 r.Error(err) 434 435 err = tx.Eager(".*").First(&u) 436 r.Error(err) 437 438 err = tx.Eager(".").First(&u) 439 r.Error(err) 440 }) 441 } 442 443 func Test_Find_Eager_Many_To_Many(t *testing.T) { 444 if PDB == nil { 445 t.Skip("skipping integration tests") 446 } 447 transaction(func(tx *Connection) { 448 r := require.New(t) 449 450 user := User{Name: nulls.NewString("Mark")} 451 err := tx.Create(&user) 452 r.NoError(err) 453 454 address := Address{Street: "Pop Avenue", HouseNumber: 1} 455 err = tx.Create(&address) 456 r.NoError(err) 457 458 ownerProperty := UsersAddress{UserID: user.ID, AddressID: address.ID} 459 err = tx.Create(&ownerProperty) 460 r.NoError(err) 461 462 u := User{} 463 err = tx.Eager("Houses").Find(&u, user.ID) 464 r.NoError(err) 465 466 r.NotEqual(u.ID, 0) 467 r.Equal(u.Name.String, "Mark") 468 469 r.Equal(len(u.Houses), 1) 470 r.Equal(u.Houses[0].Street, address.Street) 471 472 address2 := Address{Street: "Pop Avenue 2", HouseNumber: 1} 473 err = tx.Create(&address2) 474 r.NoError(err) 475 476 user2 := User{Name: nulls.NewString("Mark 2")} 477 err = tx.Create(&user2) 478 r.NoError(err) 479 480 ownerProperty2 := UsersAddress{UserID: user2.ID, AddressID: address2.ID} 481 err = tx.Create(&ownerProperty2) 482 r.NoError(err) 483 484 // eager should work with rawquery 485 uid := u.ID 486 u = User{} 487 err = tx.RawQuery("select * from users where id=?", uid).Eager("Houses").First(&u) 488 r.NoError(err) 489 r.Equal(1, len(u.Houses)) 490 491 // eager ALL 492 var users []User 493 err = tx.RawQuery("select * from users order by created_at asc").Eager("Houses").All(&users) 494 r.NoError(err) 495 r.Equal(2, len(users)) 496 497 u = users[0] 498 r.Equal(u.Name.String, "Mark") 499 r.Equal(1, len(u.Houses)) 500 r.Equal(u.Houses[0].Street, "Pop Avenue") 501 502 u = users[1] 503 r.Equal(u.Name.String, "Mark 2") 504 r.Equal(1, len(u.Houses)) 505 r.Equal(u.Houses[0].Street, "Pop Avenue 2") 506 }) 507 } 508 509 func Test_Load_Associations_Loaded_Model(t *testing.T) { 510 if PDB == nil { 511 t.Skip("skipping integration tests") 512 } 513 transaction(func(tx *Connection) { 514 r := require.New(t) 515 516 user := User{Name: nulls.NewString("Mark")} 517 err := tx.Create(&user) 518 r.NoError(err) 519 520 book := Book{Title: "Pop Book", Isbn: "PB1", UserID: nulls.NewInt(user.ID)} 521 err = tx.Create(&book) 522 r.NoError(err) 523 524 u := User{} 525 err = tx.Find(&u, user.ID) 526 527 r.NoError(err) 528 r.Zero(len(u.Books)) 529 530 err = tx.Load(&u) 531 532 r.NoError(err) 533 r.Equal(len(u.Books), 1) 534 r.Equal(u.Books[0].Title, book.Title) 535 }) 536 } 537 538 func Test_First(t *testing.T) { 539 if PDB == nil { 540 t.Skip("skipping integration tests") 541 } 542 transaction(func(tx *Connection) { 543 r := require.New(t) 544 545 first := User{Name: nulls.NewString("Mark")} 546 err := tx.Create(&first) 547 r.NoError(err) 548 549 last := User{Name: nulls.NewString("Mark")} 550 err = tx.Create(&last) 551 r.NoError(err) 552 553 u := User{} 554 err = tx.Where("name = 'Mark'").First(&u) 555 r.NoError(err) 556 557 r.Equal(first.ID, u.ID) 558 }) 559 } 560 561 func Test_Last(t *testing.T) { 562 if PDB == nil { 563 t.Skip("skipping integration tests") 564 } 565 transaction(func(tx *Connection) { 566 r := require.New(t) 567 568 first := User{Name: nulls.NewString("Mark")} 569 err := tx.Create(&first) 570 r.NoError(err) 571 572 last := User{Name: nulls.NewString("Mark")} 573 err = tx.Create(&last) 574 r.NoError(err) 575 576 u := User{} 577 err = tx.Where("name = 'Mark'").Last(&u) 578 r.NoError(err) 579 580 r.Equal(last.ID, u.ID) 581 }) 582 } 583 584 func Test_All(t *testing.T) { 585 if PDB == nil { 586 t.Skip("skipping integration tests") 587 } 588 transaction(func(tx *Connection) { 589 r := require.New(t) 590 591 for _, name := range []string{"Mark", "Joe", "Jane"} { 592 user := User{Name: nulls.NewString(name)} 593 err := tx.Create(&user) 594 r.NoError(err) 595 } 596 597 u := Users{} 598 err := tx.All(&u) 599 r.NoError(err) 600 r.Equal(len(u), 3) 601 602 u = Users{} 603 err = tx.Where("name = 'Mark'").All(&u) 604 r.NoError(err) 605 r.Equal(len(u), 1) 606 }) 607 } 608 609 func Test_All_Eager_Slice_With_All(t *testing.T) { 610 if PDB == nil { 611 t.Skip("skipping integration tests") 612 } 613 transaction(func(tx *Connection) { 614 r := require.New(t) 615 616 for _, name := range []string{"Mark", "Joe", "Jane"} { 617 user := User{Name: nulls.NewString(name)} 618 err := tx.Create(&user) 619 r.NoError(err) 620 621 book := Book{Title: "Book of " + user.Name.String, UserID: nulls.NewInt(user.ID)} 622 err = tx.Create(&book) 623 r.NoError(err) 624 } 625 626 u := Users{} 627 err := tx.Eager("Books.User").All(&u) 628 r.NoError(err) 629 r.Equal(len(u), 3) 630 631 r.Equal(u[0].ID, u[0].Books[0].User.ID) 632 r.Equal(u[1].ID, u[1].Books[0].User.ID) 633 r.Equal(u[2].ID, u[2].Books[0].User.ID) 634 }) 635 } 636 637 func Test_All_Eager(t *testing.T) { 638 if PDB == nil { 639 t.Skip("skipping integration tests") 640 } 641 transaction(func(tx *Connection) { 642 r := require.New(t) 643 644 for _, name := range []string{"Mark", "Joe", "Jane"} { 645 user := User{Name: nulls.NewString(name)} 646 err := tx.Create(&user) 647 r.NoError(err) 648 649 if name == "Mark" { 650 book := Book{Title: "Pop Book", Isbn: "PB1", UserID: nulls.NewInt(user.ID)} 651 err = tx.Create(&book) 652 r.NoError(err) 653 } 654 } 655 656 u := Users{} 657 err := tx.Eager(" Books ", " ").Where("name = 'Mark'").All(&u) 658 r.NoError(err) 659 r.Equal(len(u), 1) 660 r.Equal(len(u[0].Books), 1) 661 }) 662 } 663 664 func Test_All_Eager_For_Query(t *testing.T) { 665 if PDB == nil { 666 t.Skip("skipping integration tests") 667 } 668 transaction(func(tx *Connection) { 669 r := require.New(t) 670 671 user := User{Name: nulls.NewString("Mark")} 672 err := tx.Create(&user) 673 r.NoError(err) 674 675 book := Book{Title: "Pop Book", Isbn: "PB1", UserID: nulls.NewInt(user.ID)} 676 err = tx.Create(&book) 677 r.NoError(err) 678 679 u := Users{} 680 q := tx.Q() 681 err = q.Eager("Books").Where("name = 'Mark'").All(&u) 682 r.NoError(err) 683 r.Equal(len(u), 1) 684 r.Equal(len(u[0].Books), 1) 685 }) 686 } 687 688 func Test_All_Eager_Field_Not_Found_Error(t *testing.T) { 689 if PDB == nil { 690 t.Skip("skipping integration tests") 691 } 692 transaction(func(tx *Connection) { 693 r := require.New(t) 694 695 user := User{Name: nulls.NewString("Mark")} 696 err := tx.Create(&user) 697 r.NoError(err) 698 699 u := Users{} 700 err = tx.Eager("FieldNotFound").Where("name = 'Mark'").All(&u) 701 r.Error(err) 702 r.Equal("could not retrieve associations: field FieldNotFound does not exist in model User", err.Error()) 703 }) 704 } 705 706 func Test_All_Eager_Allow_Chain_Call(t *testing.T) { 707 if PDB == nil { 708 t.Skip("skipping integration tests") 709 } 710 transaction(func(tx *Connection) { 711 r := require.New(t) 712 713 user := User{Name: nulls.NewString("Mark")} 714 err := tx.Create(&user) 715 r.NoError(err) 716 717 coolSong := Song{Title: "Hook - Blues Traveler", UserID: user.ID} 718 err = tx.Create(&coolSong) 719 r.NoError(err) 720 721 book := Book{Title: "Pop Book", Isbn: "PB1", UserID: nulls.NewInt(user.ID)} 722 err = tx.Create(&book) 723 r.NoError(err) 724 725 u := Users{} 726 err = tx.Eager("Books").Eager("FavoriteSong").Where("name = 'Mark'").All(&u) 727 r.NoError(err) 728 r.Equal(len(u), 1) 729 r.Equal(len(u[0].Books), 1) 730 r.Equal(u[0].FavoriteSong.Title, coolSong.Title) 731 }) 732 } 733 734 func Test_Count(t *testing.T) { 735 if PDB == nil { 736 t.Skip("skipping integration tests") 737 } 738 transaction(func(tx *Connection) { 739 r := require.New(t) 740 741 user := User{Name: nulls.NewString("Mark")} 742 err := tx.Create(&user) 743 r.NoError(err) 744 c, err := tx.Count(&user) 745 r.NoError(err) 746 r.Equal(c, 1) 747 748 c, err = tx.Where("1=1").CountByField(&user, "distinct id") 749 r.NoError(err) 750 r.Equal(c, 1) 751 // should ignore order in count 752 753 c, err = tx.Order("id desc").Count(&user) 754 r.NoError(err) 755 r.Equal(c, 1) 756 757 var uAQ []UsersAddressQuery 758 _, err = Q(tx).Select("users_addresses.*").LeftJoin("users", "users.id=users_addresses.user_id").Count(&uAQ) 759 r.NoError(err) 760 761 _, err = Q(tx).Select("users_addresses.*", "users.name", "users.email").LeftJoin("users", "users.id=users_addresses.user_id").Count(&uAQ) 762 r.NoError(err) 763 }) 764 } 765 766 func Test_Count_Disregards_Pagination(t *testing.T) { 767 if PDB == nil { 768 t.Skip("skipping integration tests") 769 } 770 transaction(func(tx *Connection) { 771 r := require.New(t) 772 773 names := []string{ 774 "Jack", 775 "Hurley", 776 "Charlie", 777 "Desmond", 778 "Juliet", 779 "Locke", 780 "Sawyer", 781 "Kate", 782 "Benjamin Linus", 783 } 784 785 for _, name := range names { 786 user := User{Name: nulls.NewString(name)} 787 err := tx.Create(&user) 788 r.NoError(err) 789 } 790 791 firstUsers := Users{} 792 secondUsers := Users{} 793 794 q := tx.Paginate(1, 3) 795 r.NoError(q.All(&firstUsers)) 796 r.Equal(len(names), q.Paginator.TotalEntriesSize) // ensure paginator populates count 797 r.Equal(3, len(firstUsers)) 798 799 firstUsers = Users{} 800 q = tx.RawQuery("select * from users").Paginate(1, 3) 801 r.NoError(q.All(&firstUsers)) 802 r.Equal(1, q.Paginator.Page) 803 r.Equal(3, q.Paginator.PerPage) 804 r.Equal(len(names), q.Paginator.TotalEntriesSize) // ensure paginator populates count 805 806 r.Equal(3, len(firstUsers)) 807 totalFirstPage := q.Paginator.TotalPages 808 809 q = tx.Paginate(2, 3) 810 r.NoError(q.All(&secondUsers)) 811 812 r.Equal(3, len(secondUsers)) 813 totalSecondPage := q.Paginator.TotalPages 814 815 r.NotEqual(0, totalFirstPage) 816 r.NotEqual(0, totalSecondPage) 817 r.Equal(totalFirstPage, totalSecondPage) 818 819 firstUsers = Users{} 820 q = tx.RawQuery("select * from users limit 2").Paginate(1, 5) 821 err := q.All(&firstUsers) 822 r.NoError(err) 823 r.Equal(2, len(firstUsers)) // raw query limit applies 824 825 firstUsers = Users{} 826 q = tx.RawQuery("select * from users limit 2 offset 1").Paginate(1, 5) 827 err = q.All(&firstUsers) 828 r.NoError(err) 829 r.Equal(2, len(firstUsers)) 830 831 firstUsers = Users{} 832 q = tx.RawQuery("select * from users limit 2 offset\t1").Paginate(1, 5) 833 err = q.All(&firstUsers) 834 r.NoError(err) 835 r.Equal(2, len(firstUsers)) 836 837 firstUsers = Users{} 838 q = tx.RawQuery(`select * from users limit 2 offset 839 1`).Paginate(1, 5) 840 err = q.All(&firstUsers) 841 r.NoError(err) 842 r.Equal(2, len(firstUsers)) 843 844 firstUsers = Users{} 845 q = tx.RawQuery(`select * from users limit 2 offset 846 1 847 `).Paginate(1, 5) // ending space and tab 848 err = q.All(&firstUsers) 849 r.NoError(err) 850 r.Equal(2, len(firstUsers)) 851 852 if tx.Dialect.Name() == "sqlite" { 853 firstUsers = Users{} 854 q = tx.RawQuery("select * from users limit 2,1").Paginate(1, 5) 855 err = q.All(&firstUsers) 856 r.NoError(err) 857 r.Equal(2, len(firstUsers)) 858 859 firstUsers = Users{} 860 q = tx.RawQuery("select * from users limit 2 , 1").Paginate(1, 5) 861 err = q.All(&firstUsers) 862 r.NoError(err) 863 r.Equal(2, len(firstUsers)) 864 } 865 866 if tx.Dialect.Name() == "postgresql" { 867 firstUsers = Users{} 868 q = tx.RawQuery("select * from users FETCH FIRST 3 rows only").Paginate(1, 5) 869 err = q.All(&firstUsers) 870 r.NoError(err) 871 r.Equal(3, len(firstUsers)) // should fetch only 3 872 } 873 }) 874 } 875 876 func Test_Count_RawQuery(t *testing.T) { 877 if PDB == nil { 878 t.Skip("skipping integration tests") 879 } 880 transaction(func(tx *Connection) { 881 r := require.New(t) 882 883 user := User{Name: nulls.NewString("Mark")} 884 err := tx.Create(&user) 885 r.NoError(err) 886 887 c, err := tx.RawQuery("select * from users as users").Count(nil) 888 r.NoError(err) 889 r.Equal(c, 1) 890 891 c, err = tx.RawQuery("select * from users as users where id = -1").Count(nil) 892 r.NoError(err) 893 r.Equal(c, 0) 894 895 c, err = tx.RawQuery("select name, max(created_at) from users as users group by name").Count(nil) 896 r.NoError(err) 897 r.Equal(c, 1) 898 899 c, err = tx.RawQuery("select name from users order by name asc limit 5").Count(nil) 900 r.NoError(err) 901 r.Equal(c, 1) 902 903 c, err = tx.RawQuery("select name from users order by name asc limit 5 offset 0").Count(nil) 904 r.NoError(err) 905 r.Equal(c, 1) 906 }) 907 } 908 909 func Test_Exists(t *testing.T) { 910 if PDB == nil { 911 t.Skip("skipping integration tests") 912 } 913 transaction(func(tx *Connection) { 914 r := require.New(t) 915 916 t, _ := tx.Where("id = ?", 0).Exists("users") 917 r.False(t) 918 919 user := User{Name: nulls.NewString("Mark")} 920 err := tx.Create(&user) 921 r.NoError(err) 922 923 t, _ = tx.Where("id = ?", user.ID).Exists("users") 924 r.True(t) 925 }) 926 } 927 928 func Test_FindManyToMany(t *testing.T) { 929 if PDB == nil { 930 t.Skip("skipping integration tests") 931 } 932 transaction(func(tx *Connection) { 933 r := require.New(t) 934 parent := &Parent{} 935 r.NoError(tx.Create(parent)) 936 937 student := &Student{} 938 r.NoError(tx.Create(student)) 939 940 r.NoError(tx.RawQuery("INSERT INTO parents_students (student_id, parent_id) VALUES(?,?)", student.ID, parent.ID).Exec()) 941 942 p := &Parent{} 943 err := tx.Eager("Students").Find(p, parent.ID) 944 r.NoError(err) 945 }) 946 } 947 948 func Test_FindMultipleInnerHasMany(t *testing.T) { 949 if PDB == nil { 950 t.Skip("skipping integration tests") 951 } 952 transaction(func(tx *Connection) { 953 r := require.New(t) 954 955 user := User{Name: nulls.NewString("Mark")} 956 err := tx.Create(&user) 957 r.NoError(err) 958 959 book := Book{Title: "Pop Book", Isbn: "PB1", UserID: nulls.NewInt(user.ID)} 960 err = tx.Create(&book) 961 r.NoError(err) 962 963 writer := Writer{Name: "Jhon", BookID: book.ID} 964 err = tx.Create(&writer) 965 r.NoError(err) 966 967 friend := Friend{FirstName: "Frank", LastName: "Kafka", WriterID: writer.ID} 968 err = tx.Create(&friend) 969 r.NoError(err) 970 971 address := Address{Street: "St 27", HouseNumber: 27, WriterID: writer.ID} 972 err = tx.Create(&address) 973 r.NoError(err) 974 975 u := User{} 976 err = tx.Eager("Books.Writers.Addresses", "Books.Writers.Friends").Find(&u, user.ID) 977 r.NoError(err) 978 979 r.Len(u.Books, 1) 980 r.Len(u.Books[0].Writers, 1) 981 r.Len(u.Books[0].Writers[0].Addresses, 1) 982 r.Equal(u.Books[0].Writers[0].Addresses[0].HouseNumber, 27) 983 r.Len(u.Books[0].Writers[0].Friends, 1) 984 r.Equal(u.Books[0].Writers[0].Friends[0].FirstName, "Frank") 985 }) 986 }