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