class EagerAssociationTest

Public Class Methods

name() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1241
def self.name; "TempAuthor"; end

Public Instance Methods

assert_equal_after_sort(item1, item2, item3 = nil) click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 922
def assert_equal_after_sort(item1, item2, item3 = nil)
  assert_equal(item1.sort { |a, b| a.id <=> b.id }, item2.sort { |a, b| a.id <=> b.id })
  assert_equal(item3.sort { |a, b| a.id <=> b.id }, item2.sort { |a, b| a.id <=> b.id }) if item3
end
find_all_ordered(className, include = nil) click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 864
def find_all_ordered(className, include = nil)
  className.all.merge!(order: "#{className.table_name}.#{className.primary_key}", includes: include).to_a
end
messages_for(name) { || ... } click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1060
def messages_for(name)
  notifications = []
  ActiveSupport::Notifications.subscribe(name) do |*args|
    notifications << args
  end
  yield
  notifications
ensure
  ActiveSupport::Notifications.unsubscribe(name)
end
test_association_loading_notification() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1035
def test_association_loading_notification
  notifications = messages_for("instantiation.active_record") do
    Developer.all.merge!(includes: "projects", where: { "developers_projects.access_level" => 1 }, limit: 5).to_a.size
  end

  message = notifications.first
  payload = message.last
  count = Developer.all.merge!(includes: "projects", where: { "developers_projects.access_level" => 1 }, limit: 5).to_a.size

  # eagerloaded row count should be greater than just developer count
  assert_operator payload[:record_count], :>, count
  assert_equal Developer.name, payload[:class_name]
end
test_associations_loaded_for_all_records() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 210
def test_associations_loaded_for_all_records
  post = Post.create!(title: "foo", body: "I like cars!")
  SpecialComment.create!(body: "Come on!", post: post)
  first_category = Category.create! name: "First!", posts: [post]
  second_category = Category.create! name: "Second!", posts: [post]

  categories = Category.where(id: [first_category.id, second_category.id]).includes(posts: :special_comments)
  assert_equal categories.map { |category| category.posts.first.special_comments.loaded? }, [true, true]
end
test_base_messages() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1049
def test_base_messages
  notifications = messages_for("instantiation.active_record") do
    Developer.all.to_a
  end
  message = notifications.first
  payload = message.last

  assert_equal Developer.all.to_a.count, payload[:record_count]
  assert_equal Developer.name, payload[:class_name]
end
test_calculate_with_string_in_from_and_eager_loading() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 106
def test_calculate_with_string_in_from_and_eager_loading
  assert_equal 10, Post.from("authors, posts").eager_load(:comments).where("posts.author_id = authors.id").count
end
test_conditions_on_join_table_with_include_and_limit() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1077
def test_conditions_on_join_table_with_include_and_limit
  assert_equal 3, Developer.all.merge!(includes: "projects", where: { "developers_projects.access_level" => 1 }, limit: 5).to_a.size
end
test_count_eager_with_has_many_and_limit_and_high_offset() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 615
def test_count_eager_with_has_many_and_limit_and_high_offset
  posts = Post.all.merge!(includes: [ :author, :comments ], limit: 2, offset: 10, where: { "authors.name" => "David" }).count(:all)
  assert_equal 0, posts
end
test_count_with_include() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1031
def test_count_with_include
  assert_equal 3, authors(:david).posts_with_comments.where("length(comments.body) > 15").references(:comments).count
end
test_deep_including_through_habtm() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1281
def test_deep_including_through_habtm
  # warm up habtm cache
  posts = Post.all.merge!(includes: { categories: :categorizations }, order: "posts.id").to_a
  posts[0].categories[0].categorizations.length

  posts = Post.all.merge!(includes: { categories: :categorizations }, order: "posts.id").to_a
  assert_no_queries { assert_equal 2, posts[0].categories[0].categorizations.length }
  assert_no_queries { assert_equal 1, posts[0].categories[1].categorizations.length }
  assert_no_queries { assert_equal 2, posts[1].categories[0].categorizations.length }
end
test_dont_create_temporary_active_record_instances() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1081
def test_dont_create_temporary_active_record_instances
  Developer.instance_count = 0
  developers = Developer.all.merge!(includes: "projects", where: { "developers_projects.access_level" => 1 }, limit: 5).to_a
  assert_equal developers.count, Developer.instance_count
end
test_duplicate_middle_objects() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 122
def test_duplicate_middle_objects
  comments = Comment.all.merge!(where: "post_id = 1", includes: [post: :author]).to_a
  assert_no_queries do
    comments.each { |comment| comment.post.author.name }
  end
end
test_eager_association_loading_with_belongs_to() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 358
def test_eager_association_loading_with_belongs_to
  comments = Comment.all.merge!(includes: :post).to_a
  assert_equal 11, comments.length
  titles = comments.map { |c| c.post.title }
  assert_includes titles, posts(:welcome).title
  assert_includes titles, posts(:sti_post_and_comments).title
end
test_eager_association_loading_with_belongs_to_and_conditions_hash() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 402
def test_eager_association_loading_with_belongs_to_and_conditions_hash
  comments = []
  assert_nothing_raised do
    comments = Comment.all.merge!(includes: :post, where: { posts: { id: 4 } }, limit: 3, order: "comments.id").to_a
  end
  assert_equal 3, comments.length
  assert_equal [5, 6, 7], comments.collect(&:id)
  assert_no_queries do
    comments.first.post
  end
end
test_eager_association_loading_with_belongs_to_and_conditions_string_with_quoted_table_name() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 414
def test_eager_association_loading_with_belongs_to_and_conditions_string_with_quoted_table_name
  quoted_posts_id = Comment.connection.quote_table_name("posts") + "." + Comment.connection.quote_column_name("id")
  assert_nothing_raised do
    Comment.includes(:post).references(:posts).where("#{quoted_posts_id} = ?", 4)
  end
end
test_eager_association_loading_with_belongs_to_and_conditions_string_with_unquoted_table_name() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 396
def test_eager_association_loading_with_belongs_to_and_conditions_string_with_unquoted_table_name
  assert_nothing_raised do
    Comment.includes(:post).references(:posts).where("posts.id = ?", 4)
  end
end
test_eager_association_loading_with_belongs_to_and_foreign_keys() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 353
def test_eager_association_loading_with_belongs_to_and_foreign_keys
  pets = Pet.all.merge!(includes: :owner).to_a
  assert_equal 4, pets.length
end
test_eager_association_loading_with_belongs_to_and_limit() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 366
def test_eager_association_loading_with_belongs_to_and_limit
  comments = Comment.all.merge!(includes: :post, limit: 5, order: "comments.id").to_a
  assert_equal 5, comments.length
  assert_equal [1, 2, 3, 5, 6], comments.collect(&:id)
end
test_eager_association_loading_with_belongs_to_and_limit_and_conditions() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 372
def test_eager_association_loading_with_belongs_to_and_limit_and_conditions
  comments = Comment.all.merge!(includes: :post, where: "post_id = 4", limit: 3, order: "comments.id").to_a
  assert_equal 3, comments.length
  assert_equal [5, 6, 7], comments.collect(&:id)
end
test_eager_association_loading_with_belongs_to_and_limit_and_multiple_associations() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 434
def test_eager_association_loading_with_belongs_to_and_limit_and_multiple_associations
  posts = Post.all.merge!(includes: [:author, :very_special_comment], limit: 1, order: "posts.id").to_a
  assert_equal 1, posts.length
  assert_equal [1], posts.collect(&:id)
end
test_eager_association_loading_with_belongs_to_and_limit_and_offset() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 378
def test_eager_association_loading_with_belongs_to_and_limit_and_offset
  comments = Comment.all.merge!(includes: :post, limit: 3, offset: 2, order: "comments.id").to_a
  assert_equal 3, comments.length
  assert_equal [3, 5, 6], comments.collect(&:id)
end
test_eager_association_loading_with_belongs_to_and_limit_and_offset_and_conditions() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 384
def test_eager_association_loading_with_belongs_to_and_limit_and_offset_and_conditions
  comments = Comment.all.merge!(includes: :post, where: "post_id = 4", limit: 3, offset: 1, order: "comments.id").to_a
  assert_equal 3, comments.length
  assert_equal [6, 7, 8], comments.collect(&:id)
end
test_eager_association_loading_with_belongs_to_and_limit_and_offset_and_conditions_array() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 390
def test_eager_association_loading_with_belongs_to_and_limit_and_offset_and_conditions_array
  comments = Comment.all.merge!(includes: :post, where: ["post_id = ?", 4], limit: 3, offset: 1, order: "comments.id").to_a
  assert_equal 3, comments.length
  assert_equal [6, 7, 8], comments.collect(&:id)
end
test_eager_association_loading_with_belongs_to_and_limit_and_offset_and_multiple_associations() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 440
def test_eager_association_loading_with_belongs_to_and_limit_and_offset_and_multiple_associations
  posts = Post.all.merge!(includes: [:author, :very_special_comment], limit: 1, offset: 1, order: "posts.id").to_a
  assert_equal 1, posts.length
  assert_equal [2], posts.collect(&:id)
end
test_eager_association_loading_with_belongs_to_and_order_string_with_quoted_table_name() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 427
def test_eager_association_loading_with_belongs_to_and_order_string_with_quoted_table_name
  quoted_posts_id = Comment.connection.quote_table_name("posts") + "." + Comment.connection.quote_column_name("id")
  assert_nothing_raised do
    Comment.includes(:post).references(:posts).order(quoted_posts_id)
  end
end
test_eager_association_loading_with_belongs_to_and_order_string_with_unquoted_table_name() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 421
def test_eager_association_loading_with_belongs_to_and_order_string_with_unquoted_table_name
  assert_nothing_raised do
    Comment.all.merge!(includes: :post, order: "posts.id").to_a
  end
end
test_eager_association_loading_with_belongs_to_inferred_foreign_key_from_association_name() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 446
def test_eager_association_loading_with_belongs_to_inferred_foreign_key_from_association_name
  author_favorite = AuthorFavorite.all.merge!(includes: :favorite_author).first
  assert_equal authors(:mary), assert_no_queries { author_favorite.favorite_author }
end
test_eager_association_loading_with_explicit_join() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 505
def test_eager_association_loading_with_explicit_join
  posts = Post.all.merge!(includes: :comments, joins: "INNER JOIN authors ON posts.author_id = authors.id AND authors.name = 'Mary'", limit: 1, order: "author_id").to_a
  assert_equal 1, posts.length
end
test_eager_association_loading_with_habtm() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 703
def test_eager_association_loading_with_habtm
  posts = Post.all.merge!(includes: :categories, order: "posts.id").to_a
  assert_equal 2, posts[0].categories.size
  assert_equal 1, posts[1].categories.size
  assert_equal 0, posts[2].categories.size
  assert_includes posts[0].categories, categories(:technology)
  assert_includes posts[1].categories, categories(:general)
end
test_eager_association_with_scope_with_joins() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 997
def test_eager_association_with_scope_with_joins
  assert_nothing_raised do
    Post.includes(:very_special_comment_with_post_with_joins).to_a
  end
end
test_eager_count_performed_on_a_has_many_association_with_multi_table_conditional() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 625
def test_eager_count_performed_on_a_has_many_association_with_multi_table_conditional
  author = authors(:david)
  author_posts_without_comments = author.posts.select { |post| post.comments.blank? }
  assert_equal author_posts_without_comments.size, author.posts.includes(:comments).where("comments.id is null").references(:comments).count
end
test_eager_count_performed_on_a_has_many_through_association_with_multi_table_conditional() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 631
def test_eager_count_performed_on_a_has_many_through_association_with_multi_table_conditional
  person = people(:michael)
  person_posts_without_comments = person.posts.select { |post| post.comments.blank? }
  assert_equal person_posts_without_comments.size, person.posts_with_no_comments.count
end
test_eager_habtm_with_association_inheritance() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 728
def test_eager_habtm_with_association_inheritance
  post = Post.all.merge!(includes: [ :special_categories ]).find(6)
  assert_equal 1, post.special_categories.size
  post.special_categories.each do |special_category|
    assert_equal "SpecialCategory", special_category.class.to_s
  end
end
test_eager_has_many_through_multiple_with_order() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 785
def test_eager_has_many_through_multiple_with_order
  tag1 = OrderedTag.create!(name: "Bar")
  tag2 = OrderedTag.create!(name: "Foo")

  post1 = Post.create!(title: "Beaches", body: "I like beaches!")
  post2 = Post.create!(title: "Pools", body: "I like pools!")

  Tagging.create!(taggable: post1, tag: tag1)
  Tagging.create!(taggable: post2, tag: tag1)
  Tagging.create!(taggable: post2, tag: tag2)
  Tagging.create!(taggable: post1, tag: tag2)

  tags_with_includes = OrderedTag.where(id: [tag1, tag2].map(&:id)).includes(:tagged_posts).order(:id).to_a
  tag1_with_includes = tags_with_includes.first
  tag2_with_includes = tags_with_includes.last

  assert_equal([post2, post1].map(&:title), tag1_with_includes.tagged_posts.map(&:title))
  assert_equal([post1, post2].map(&:title), tag2_with_includes.tagged_posts.map(&:title))
end
test_eager_has_many_through_with_order() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 773
def test_eager_has_many_through_with_order
  tag = OrderedTag.create(name: "Foo")
  post1 = Post.create!(title: "Beaches", body: "I like beaches!")
  post2 = Post.create!(title: "Pools", body: "I like pools!")

  Tagging.create!(taggable_type: "Post", taggable_id: post1.id, tag: tag)
  Tagging.create!(taggable_type: "Post", taggable_id: post2.id, tag: tag)

  tag_with_includes = OrderedTag.includes(:tagged_posts).find(tag.id)
  assert_equal(tag_with_includes.taggings.map(&:taggable).map(&:title), tag_with_includes.tagged_posts.map(&:title))
end
test_eager_has_many_with_association_inheritance() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 721
def test_eager_has_many_with_association_inheritance
  post = Post.all.merge!(includes: [ :special_comments ]).find(4)
  post.special_comments.each do |special_comment|
    assert special_comment.is_a?(SpecialComment)
  end
end
test_eager_has_one_with_association_inheritance() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 716
def test_eager_has_one_with_association_inheritance
  post = Post.all.merge!(includes: [ :very_special_comment ]).find(4)
  assert_equal "VerySpecialComment", post.very_special_comment.class.to_s
end
test_eager_load_belongs_to_quotes_table_and_column_names() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 451
def test_eager_load_belongs_to_quotes_table_and_column_names
  job = Job.includes(:ideal_reference).find jobs(:unicyclist).id
  references(:michael_unicyclist)
  assert_no_queries { assert_equal references(:michael_unicyclist), job.ideal_reference }
end
test_eager_load_belongs_to_with_string_keys() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 499
def test_eager_load_belongs_to_with_string_keys
  subscriber = subscribers(:second)
  subscription = Subscription.all.merge!(includes: :subscriber).find(subscriptions(:webster_awdr).id)
  assert_equal subscriber, subscription.subscriber
end
test_eager_load_has_many_quotes_table_and_column_names() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 463
def test_eager_load_has_many_quotes_table_and_column_names
  michael = Person.all.merge!(includes: :references).find(people(:michael).id)
  references(:michael_magician, :michael_unicyclist)
  assert_no_queries { assert_equal references(:michael_magician, :michael_unicyclist), michael.references.sort_by(&:id) }
end
test_eager_load_has_many_through_quotes_table_and_column_names() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 469
def test_eager_load_has_many_through_quotes_table_and_column_names
  michael = Person.all.merge!(includes: :jobs).find(people(:michael).id)
  jobs(:magician, :unicyclist)
  assert_no_queries { assert_equal jobs(:unicyclist, :magician), michael.jobs.sort_by(&:id) }
end
test_eager_load_has_many_through_with_string_keys() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 493
def test_eager_load_has_many_through_with_string_keys
  books = books(:awdr, :rfr)
  subscriber = Subscriber.all.merge!(includes: :books).find(subscribers(:second).id)
  assert_equal books, subscriber.books.sort_by(&:id)
end
test_eager_load_has_many_with_string_keys() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 475
def test_eager_load_has_many_with_string_keys
  subscriptions = subscriptions(:webster_awdr, :webster_rfr)
  subscriber = Subscriber.all.merge!(includes: :subscriptions).find(subscribers(:second).id)
  assert_equal subscriptions, subscriber.subscriptions.sort_by(&:id)
end
test_eager_load_has_one_quotes_table_and_column_names() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 457
def test_eager_load_has_one_quotes_table_and_column_names
  michael = Person.all.merge!(includes: :favourite_reference).find(people(:michael).id)
  references(:michael_unicyclist)
  assert_no_queries { assert_equal references(:michael_unicyclist), michael.favourite_reference }
end
test_eager_load_multiple_associations_with_references() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1292
def test_eager_load_multiple_associations_with_references
  mentor = Mentor.create!(name: "Barış Can DAYLIK")
  developer = Developer.create!(name: "Mehmet Emin İNAÇ", mentor: mentor)
  Contract.create!(developer: developer)
  project = Project.create!(name: "VNGRS", mentor: mentor)
  project.developers << developer
  projects = Project.references(:mentors).includes(mentor: { developers: :contracts }, developers: :contracts)
  assert_equal projects.last.mentor.developers.first.contracts, projects.last.developers.last.contracts
end
test_eager_loaded_has_one_association_with_references_does_not_run_additional_queries() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 99
def test_eager_loaded_has_one_association_with_references_does_not_run_additional_queries
  Post.update_all(author_id: nil)
  authors = Author.includes(:post).references(:post).to_a
  assert authors.count > 0
  assert_no_queries { authors.map(&:post) }
end
test_eager_loading_with_conditions_on_join_model_preloads() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1151
def test_eager_loading_with_conditions_on_join_model_preloads
  authors = assert_queries(2) do
    Author.all.merge!(includes: :author_address, joins: :comments, where: "posts.title like 'Welcome%'").to_a
  end
  assert_equal authors(:david), authors[0]
  assert_equal author_addresses(:david_address), authors[0].author_address
end
test_eager_loading_with_conditions_on_joined_table_preloads() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1099
def test_eager_loading_with_conditions_on_joined_table_preloads
  posts = assert_queries(2) do
    Post.all.merge!(select: "distinct posts.*", includes: :author, joins: [:comments], where: "comments.body like 'Thank you%'", order: "posts.id").to_a
  end
  assert_equal [posts(:welcome)], posts
  assert_equal authors(:david), assert_no_queries { posts[0].author }

  posts = assert_queries(2) do
    Post.all.merge!(includes: :author, joins: { taggings: :tag }, where: "tags.name = 'General'", order: "posts.id").to_a
  end
  assert_equal posts(:welcome, :thinking), posts

  posts = assert_queries(2) do
    Post.all.merge!(includes: :author, joins: { taggings: { tag: :taggings } }, where: "taggings_tags.super_tag_id=2", order: "posts.id").to_a
  end
  assert_equal posts(:welcome, :thinking), posts
end
test_eager_loading_with_conditions_on_string_joined_table_preloads() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1129
def test_eager_loading_with_conditions_on_string_joined_table_preloads
  posts = assert_queries(2) do
    Post.all.merge!(select: "distinct posts.*", includes: :author, joins: "INNER JOIN comments on comments.post_id = posts.id", where: "comments.body like 'Thank you%'", order: "posts.id").to_a
  end
  assert_equal [posts(:welcome)], posts
  assert_equal authors(:david), assert_no_queries { posts[0].author }

  posts = assert_queries(2) do
    Post.all.merge!(select: "distinct posts.*", includes: :author, joins: ["INNER JOIN comments on comments.post_id = posts.id"], where: "comments.body like 'Thank you%'", order: "posts.id").to_a
  end
  assert_equal [posts(:welcome)], posts
  assert_equal authors(:david), assert_no_queries { posts[0].author }
end
test_eager_loading_with_order_on_joined_table_preloads() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1091
def test_eager_loading_with_order_on_joined_table_preloads
  posts = assert_queries(2) do
    Post.all.merge!(joins: :comments, includes: :author, order: "comments.id DESC").to_a
  end
  assert_equal posts(:eager_other), posts[1]
  assert_equal authors(:mary), assert_no_queries { posts[1].author }
end
test_eager_loading_with_select_on_joined_table_preloads() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1143
def test_eager_loading_with_select_on_joined_table_preloads
  posts = assert_queries(2) do
    Post.all.merge!(select: "posts.*, authors.name as author_name", includes: :comments, joins: :author, order: "posts.id").to_a
  end
  assert_equal "David", posts[0].author_name
  assert_equal posts(:welcome).comments, assert_no_queries { posts[0].comments }
end
test_eager_with_default_scope() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 805
def test_eager_with_default_scope
  developer = EagerDeveloperWithDefaultScope.where(name: "David").first
  projects = Project.order(:id).to_a
  assert_no_queries do
    assert_equal(projects, developer.projects)
  end
end
test_eager_with_default_scope_as_block() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 846
def test_eager_with_default_scope_as_block
  # warm up the habtm cache
  EagerDeveloperWithBlockDefaultScope.where(name: "David").first.projects
  developer = EagerDeveloperWithBlockDefaultScope.where(name: "David").first
  projects = Project.order(:id).to_a
  assert_no_queries do
    assert_equal(projects, developer.projects)
  end
end
test_eager_with_default_scope_as_callable() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 856
def test_eager_with_default_scope_as_callable
  developer = EagerDeveloperWithCallableDefaultScope.where(name: "David").first
  projects = Project.order(:id).to_a
  assert_no_queries do
    assert_equal(projects, developer.projects)
  end
end
test_eager_with_default_scope_as_class_method() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 813
def test_eager_with_default_scope_as_class_method
  developer = EagerDeveloperWithClassMethodDefaultScope.where(name: "David").first
  projects = Project.order(:id).to_a
  assert_no_queries do
    assert_equal(projects, developer.projects)
  end
end
test_eager_with_default_scope_as_class_method_using_find_by_method() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 830
def test_eager_with_default_scope_as_class_method_using_find_by_method
  developer = EagerDeveloperWithClassMethodDefaultScope.find_by(name: "David")
  projects = Project.order(:id).to_a
  assert_no_queries do
    assert_equal(projects, developer.projects)
  end
end
test_eager_with_default_scope_as_class_method_using_find_method() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 821
def test_eager_with_default_scope_as_class_method_using_find_method
  david = developers(:david)
  developer = EagerDeveloperWithClassMethodDefaultScope.find(david.id)
  projects = Project.order(:id).to_a
  assert_no_queries do
    assert_equal(projects, developer.projects)
  end
end
test_eager_with_default_scope_as_lambda() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 838
def test_eager_with_default_scope_as_lambda
  developer = EagerDeveloperWithLambdaDefaultScope.where(name: "David").first
  projects = Project.order(:id).to_a
  assert_no_queries do
    assert_equal(projects, developer.projects)
  end
end
test_eager_with_floating_point_numbers() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 980
def test_eager_with_floating_point_numbers
  assert_queries(2) do
    # Before changes, the floating point numbers will be interpreted as table names and will cause this to run in one query
    Comment.all.merge!(where: "123.456 = 123.456", includes: :post).to_a
  end
end
test_eager_with_has_and_belongs_to_many_and_limit() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 637
def test_eager_with_has_and_belongs_to_many_and_limit
  posts = Post.all.merge!(includes: :categories, order: "posts.id", limit: 3).to_a
  assert_equal 3, posts.size
  assert_equal 2, posts[0].categories.size
  assert_equal 1, posts[1].categories.size
  assert_equal 0, posts[2].categories.size
  assert_includes posts[0].categories, categories(:technology)
  assert_includes posts[1].categories, categories(:general)
end
test_eager_with_has_many_and_limit() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 567
def test_eager_with_has_many_and_limit
  posts = Post.all.merge!(order: "posts.id asc", includes: [ :author, :comments ], limit: 2).to_a
  assert_equal 2, posts.size
  assert_equal 3, posts.inject(0) { |sum, post| sum + post.comments.size }
end
test_eager_with_has_many_and_limit_and_conditions() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 573
def test_eager_with_has_many_and_limit_and_conditions
  posts = Post.all.merge!(includes: [ :author, :comments ], limit: 2, where: "posts.body = 'hello'", order: "posts.id").to_a
  assert_equal 2, posts.size
  assert_equal [4, 5], posts.collect(&:id)
end
test_eager_with_has_many_and_limit_and_conditions_array() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 579
def test_eager_with_has_many_and_limit_and_conditions_array
  posts = Post.all.merge!(includes: [ :author, :comments ], limit: 2, where: [ "posts.body = ?", "hello" ], order: "posts.id").to_a
  assert_equal 2, posts.size
  assert_equal [4, 5], posts.collect(&:id)
end
test_eager_with_has_many_and_limit_and_conditions_array_on_the_eagers() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 585
def test_eager_with_has_many_and_limit_and_conditions_array_on_the_eagers
  posts = Post.includes(:author, :comments).limit(2).references(:author).where("authors.name = ?", "David")
  assert_equal 2, posts.size

  count = Post.includes(:author, :comments).limit(2).references(:author).where("authors.name = ?", "David").count
  assert_equal posts.size, count
end
test_eager_with_has_many_and_limit_and_conditions_on_the_eagers() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 663
def test_eager_with_has_many_and_limit_and_conditions_on_the_eagers
  posts =
    authors(:david).posts
      .includes(:comments)
      .where("comments.body like 'Normal%' OR comments.#{QUOTED_TYPE}= 'SpecialComment'")
      .references(:comments)
      .limit(2)
      .to_a
  assert_equal 2, posts.size

  count =
    Post.includes(:comments, :author)
      .where("authors.name = 'David' AND (comments.body like 'Normal%' OR comments.#{QUOTED_TYPE}= 'SpecialComment')")
      .references(:authors, :comments)
      .limit(2)
      .count
  assert_equal count, posts.size
end
test_eager_with_has_many_and_limit_and_high_offset() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 593
def test_eager_with_has_many_and_limit_and_high_offset
  posts = Post.all.merge!(includes: [ :author, :comments ], limit: 2, offset: 10, where: { "authors.name" => "David" }).to_a
  assert_equal 0, posts.size
end
test_eager_with_has_many_and_limit_and_high_offset_and_multiple_array_conditions() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 598
def test_eager_with_has_many_and_limit_and_high_offset_and_multiple_array_conditions
  assert_queries(1) do
    posts = Post.references(:authors, :comments).
      merge(includes: [ :author, :comments ], limit: 2, offset: 10,
        where: [ "authors.name = ? and comments.body = ?", "David", "go crazy" ]).to_a
    assert_equal 0, posts.size
  end
end
test_eager_with_has_many_and_limit_and_high_offset_and_multiple_hash_conditions() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 607
def test_eager_with_has_many_and_limit_and_high_offset_and_multiple_hash_conditions
  assert_queries(1) do
    posts = Post.all.merge!(includes: [ :author, :comments ], limit: 2, offset: 10,
      where: { "authors.name" => "David", "comments.body" => "go crazy" }).to_a
    assert_equal 0, posts.size
  end
end
test_eager_with_has_many_and_limit_and_scoped_conditions_on_the_eagers() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 682
def test_eager_with_has_many_and_limit_and_scoped_conditions_on_the_eagers
  posts = nil
  Post.includes(:comments)
    .where("comments.body like 'Normal%' OR comments.#{QUOTED_TYPE}= 'SpecialComment'")
    .references(:comments)
    .scoping do

    posts = authors(:david).posts.limit(2).to_a
    assert_equal 2, posts.size
  end

  Post.includes(:comments, :author)
    .where("authors.name = 'David' AND (comments.body like 'Normal%' OR comments.#{QUOTED_TYPE}= 'SpecialComment')")
    .references(:authors, :comments)
    .scoping do

    count = Post.limit(2).count
    assert_equal count, posts.size
  end
end
test_eager_with_has_many_and_limit_with_no_results() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 620
def test_eager_with_has_many_and_limit_with_no_results
  posts = Post.all.merge!(includes: [ :author, :comments ], limit: 2, where: "posts.title = 'magic forest'").to_a
  assert_equal 0, posts.size
end
test_eager_with_has_many_through() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 510
def test_eager_with_has_many_through
  posts_with_comments = people(:michael).posts.merge(includes: :comments, order: "posts.id").to_a
  posts_with_author = people(:michael).posts.merge(includes: :author, order: "posts.id").to_a
  posts_with_comments_and_author = people(:michael).posts.merge(includes: [ :comments, :author ], order: "posts.id").to_a
  assert_equal 2, posts_with_comments.inject(0) { |sum, post| sum + post.comments.size }
  assert_equal authors(:david), assert_no_queries { posts_with_author.first.author }
  assert_equal authors(:david), assert_no_queries { posts_with_comments_and_author.first.author }
end
test_eager_with_has_many_through_a_belongs_to_association() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 519
def test_eager_with_has_many_through_a_belongs_to_association
  author = authors(:mary)
  Post.create!(author: author, title: "TITLE", body: "BODY")
  author.author_favorites.create(favorite_author_id: 1)
  author.author_favorites.create(favorite_author_id: 2)
  posts_with_author_favorites = author.posts.merge(includes: :author_favorites).to_a
  assert_no_queries { posts_with_author_favorites.first.author_favorites.first.author_id }
end
test_eager_with_has_many_through_an_sti_join_model() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 528
def test_eager_with_has_many_through_an_sti_join_model
  author = Author.all.merge!(includes: :special_post_comments, order: "authors.id").first
  assert_equal [comments(:does_it_hurt)], assert_no_queries { author.special_post_comments }
end
test_eager_with_has_many_through_an_sti_join_model_with_conditions_on_both() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 533
def test_eager_with_has_many_through_an_sti_join_model_with_conditions_on_both
  author = Author.all.merge!(includes: :special_nonexistent_post_comments, order: "authors.id").first
  assert_equal [], author.special_nonexistent_post_comments
end
test_eager_with_has_many_through_join_model_ignores_default_includes() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 561
def test_eager_with_has_many_through_join_model_ignores_default_includes
  assert_nothing_raised do
    authors(:david).comments_on_posts_with_default_include.to_a
  end
end
test_eager_with_has_many_through_join_model_with_conditions() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 538
def test_eager_with_has_many_through_join_model_with_conditions
  assert_equal Author.all.merge!(includes: :hello_post_comments,
                           order: "authors.id").first.hello_post_comments.sort_by(&:id),
               Author.all.merge!(order: "authors.id").first.hello_post_comments.sort_by(&:id)
end
test_eager_with_has_many_through_join_model_with_conditions_on_top_level() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 544
def test_eager_with_has_many_through_join_model_with_conditions_on_top_level
  assert_equal comments(:more_greetings), Author.all.merge!(includes: :comments_with_order_and_conditions).find(authors(:david).id).comments_with_order_and_conditions.first
end
test_eager_with_has_many_through_join_model_with_include() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 548
def test_eager_with_has_many_through_join_model_with_include
  author_comments = Author.all.merge!(includes: :comments_with_include).find(authors(:david).id).comments_with_include.to_a
  assert_no_queries do
    author_comments.first.post.title
  end
end
test_eager_with_has_many_through_with_conditions_join_model_with_include() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 555
def test_eager_with_has_many_through_with_conditions_join_model_with_include
  post_tags = Post.find(posts(:welcome).id).misc_tags
  eager_post_tags = Post.all.merge!(includes: :misc_tags).find(1).misc_tags
  assert_equal post_tags, eager_post_tags
end
test_eager_with_has_one_dependent_does_not_destroy_dependent() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 736
def test_eager_with_has_one_dependent_does_not_destroy_dependent
  assert_not_nil companies(:first_firm).account
  f = Firm.all.merge!(includes: :account,
          where: ["companies.name = ?", "37signals"]).first
  assert_not_nil f.account
  assert_equal companies(:first_firm, :reload).account, f.account
end
test_eager_with_has_one_through_join_model_with_conditions_on_the_through() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 38
def test_eager_with_has_one_through_join_model_with_conditions_on_the_through
  member = Member.all.merge!(includes: :favourite_club).find(members(:some_other_guy).id)
  assert_nil member.favourite_club
end
test_eager_with_inheritance() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 712
def test_eager_with_inheritance
  SpecialPost.all.merge!(includes: [ :comments ]).to_a
end
test_eager_with_invalid_association_reference() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 751
def test_eager_with_invalid_association_reference
  e = assert_raise(ActiveRecord::AssociationNotFoundError) {
    Post.all.merge!(includes: :monkeys).find(6)
  }
  assert_equal("Association named 'monkeys' was not found on Post; perhaps you misspelled it?", e.message)

  e = assert_raise(ActiveRecord::AssociationNotFoundError) {
    Post.all.merge!(includes: [ :monkeys ]).find(6)
  }
  assert_equal("Association named 'monkeys' was not found on Post; perhaps you misspelled it?", e.message)

  e = assert_raise(ActiveRecord::AssociationNotFoundError) {
    Post.all.merge!(includes: [ "monkeys" ]).find(6)
  }
  assert_equal("Association named 'monkeys' was not found on Post; perhaps you misspelled it?", e.message)

  e = assert_raise(ActiveRecord::AssociationNotFoundError) {
    Post.all.merge!(includes: [ :monkeys, :elephants ]).find(6)
  }
  assert_equal("Association named 'monkeys' was not found on Post; perhaps you misspelled it?", e.message)
end
test_eager_with_multi_table_conditional_properly_counts_the_records_when_using_size() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 744
def test_eager_with_multi_table_conditional_properly_counts_the_records_when_using_size
  author = authors(:david)
  posts_with_no_comments = author.posts.select { |post| post.comments.blank? }
  assert_equal posts_with_no_comments.size, author.posts_with_no_comments.size
  assert_equal posts_with_no_comments, author.posts_with_no_comments
end
test_eager_with_multiple_associations_with_same_table_belongs_to() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 961
def test_eager_with_multiple_associations_with_same_table_belongs_to
  firm_types = [:firm, :firm_with_basic_id, :firm_with_other_name, :firm_with_condition]
  d1 = find_all_ordered(Client)
  d2 = find_all_ordered(Client, firm_types)
  d1.each_index do |i|
    assert_equal(d1[i], d2[i])
    firm_types.each do |type|
      if (expected = d1[i].send(type)).nil?
        assert_nil(d2[i].send(type))
      else
        assert_equal(expected, d2[i].send(type))
      end
    end
  end
end
test_eager_with_multiple_associations_with_same_table_has_many_and_habtm() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 920
def test_eager_with_multiple_associations_with_same_table_has_many_and_habtm
  # Eager includes of has many and habtm associations aren't necessarily sorted in the same way
  def assert_equal_after_sort(item1, item2, item3 = nil)
    assert_equal(item1.sort { |a, b| a.id <=> b.id }, item2.sort { |a, b| a.id <=> b.id })
    assert_equal(item3.sort { |a, b| a.id <=> b.id }, item2.sort { |a, b| a.id <=> b.id }) if item3
  end
  # Test regular association, association with conditions, association with
  # STI, and association with conditions assured not to be true
  post_types = [:posts, :other_posts, :special_posts]
  # test both has_many and has_and_belongs_to_many
  [Author, Category].each do |className|
    d1 = find_all_ordered(className)
    # test including all post types at once
    d2 = find_all_ordered(className, post_types)
    d1.each_index do |i|
      assert_equal(d1[i], d2[i])
      assert_equal_after_sort(d1[i].posts, d2[i].posts)
      post_types[1..-1].each do |post_type|
        # test including post_types together
        d3 = find_all_ordered(className, [:posts, post_type])
        assert_equal(d1[i], d3[i])
        assert_equal_after_sort(d1[i].posts, d3[i].posts)
        assert_equal_after_sort(d1[i].send(post_type), d2[i].send(post_type), d3[i].send(post_type))
      end
    end
  end
end
test_eager_with_multiple_associations_with_same_table_has_one() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 948
def test_eager_with_multiple_associations_with_same_table_has_one
  d1 = find_all_ordered(Firm)
  d2 = find_all_ordered(Firm, :account)
  d1.each_index do |i|
    assert_equal(d1[i], d2[i])
    if d1[i].account.nil?
      assert_nil(d2[i].account)
    else
      assert_equal(d1[i].account, d2[i].account)
    end
  end
end
test_eager_with_valid_association_as_string_not_symbol() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 976
def test_eager_with_valid_association_as_string_not_symbol
  assert_nothing_raised { Post.all.merge!(includes: "comments").to_a }
end
test_finding_with_includes_on_belongs_to_association_with_same_include_includes_only_once() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 240
def test_finding_with_includes_on_belongs_to_association_with_same_include_includes_only_once
  post = posts(:welcome)
  author = post.author
  author_address = author.author_address
  post = assert_queries(3) { Post.all.merge!(includes: { author_with_address: :author_address }).find(post.id) } # find the post, then find the author, then find the address
  assert_no_queries do
    assert_equal author, post.author_with_address
    assert_equal author_address, post.author_with_address.author_address
  end
end
test_finding_with_includes_on_empty_polymorphic_type_column() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 270
def test_finding_with_includes_on_empty_polymorphic_type_column
  sponsor = sponsors(:moustache_club_sponsor_for_groucho)
  sponsor.update!(sponsorable_type: "", sponsorable_id: nil) # sponsorable_type column might be declared NOT NULL
  sponsor = assert_queries(1) do
    assert_nothing_raised { Sponsor.all.merge!(includes: :sponsorable).find(sponsor.id) }
  end
  assert_no_queries do
    assert_nil sponsor.sponsorable
  end
end
test_finding_with_includes_on_has_many_association_with_same_include_includes_only_once() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 220
def test_finding_with_includes_on_has_many_association_with_same_include_includes_only_once
  author_id = authors(:david).id
  author = assert_queries(3) { Author.all.merge!(includes: { posts_with_comments: :comments }).find(author_id) } # find the author, then find the posts, then find the comments
  author.posts_with_comments.each do |post_with_comments|
    assert_equal post_with_comments.comments.length, post_with_comments.comments.count
    assert_nil post_with_comments.comments.to_a.uniq!
  end
end
test_finding_with_includes_on_has_one_association_with_same_include_includes_only_once() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 229
def test_finding_with_includes_on_has_one_association_with_same_include_includes_only_once
  author = authors(:david)
  post = author.post_about_thinking_with_last_comment
  last_comment = post.last_comment
  author = assert_queries(3) { Author.all.merge!(includes: { post_about_thinking_with_last_comment: :last_comment }).find(author.id) } # find the author, then find the posts, then find the comments
  assert_no_queries do
    assert_equal post, author.post_about_thinking_with_last_comment
    assert_equal last_comment, author.post_about_thinking_with_last_comment.last_comment
  end
end
test_finding_with_includes_on_null_belongs_to_association_with_same_include_includes_only_once() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 251
def test_finding_with_includes_on_null_belongs_to_association_with_same_include_includes_only_once
  post = posts(:welcome)
  post.update!(author: nil)
  post = assert_queries(1) { Post.all.merge!(includes: { author_with_address: :author_address }).find(post.id) }
  # find the post, then find the author which is null so no query for the author or address
  assert_no_queries do
    assert_nil post.author_with_address
  end
end
test_finding_with_includes_on_null_belongs_to_polymorphic_association() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 261
def test_finding_with_includes_on_null_belongs_to_polymorphic_association
  sponsor = sponsors(:moustache_club_sponsor_for_groucho)
  sponsor.update!(sponsorable: nil)
  sponsor = assert_queries(1) { Sponsor.all.merge!(includes: :sponsorable).find(sponsor.id) }
  assert_no_queries do
    assert_nil sponsor.sponsorable
  end
end
test_has_and_belongs_to_many_should_not_instantiate_same_records_multiple_times() click to toggle source

Since the preloader for habtm gets raw row hashes from the database and then instantiates them, this test ensures that it only instantiates one actual object per record from the database.

# File activerecord/test/cases/associations/eager_test.rb, line 650
def test_has_and_belongs_to_many_should_not_instantiate_same_records_multiple_times
  welcome    = posts(:welcome)
  categories = Category.includes(:posts)

  general    = categories.find { |c| c == categories(:general) }
  technology = categories.find { |c| c == categories(:technology) }

  post1 = general.posts.to_a.find { |p| p == welcome }
  post2 = technology.posts.to_a.find { |p| p == welcome }

  assert_equal post1.object_id, post2.object_id
end
test_has_many_through_with_order() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 93
def test_has_many_through_with_order
  authors = Author.includes(:favorite_authors).to_a
  assert authors.count > 0
  assert_no_queries { authors.map(&:favorite_authors) }
end
test_include_has_many_using_primary_key() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1183
def test_include_has_many_using_primary_key
  expected = Firm.find(1).clients_using_primary_key.sort_by(&:name)
  # Oracle adapter truncates alias to 30 characters
  if current_adapter?(:OracleAdapter)
    firm = Firm.all.merge!(includes: :clients_using_primary_key, order: "clients_using_primary_keys_companies"[0, 30] + ".name").find(1)
  else
    firm = Firm.all.merge!(includes: :clients_using_primary_key, order: "clients_using_primary_keys_companies.name").find(1)
  end
  assert_no_queries do
    assert_equal expected, firm.clients_using_primary_key
  end
end
test_include_has_one_using_primary_key() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1204
def test_include_has_one_using_primary_key
  expected = accounts(:signals37)
  firm = Firm.all.merge!(includes: :account_using_primary_key, order: "accounts.id").to_a.detect { |f| f.id == 1 }
  assert_no_queries do
    assert_equal expected, firm.account_using_primary_key
  end
end
test_including_duplicate_objects_from_belongs_to() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 184
def test_including_duplicate_objects_from_belongs_to
  popular_post = Post.create!(title: "foo", body: "I like cars!")
  comment = popular_post.comments.create!(body: "lol")
  popular_post.readers.create!(person: people(:michael))
  popular_post.readers.create!(person: people(:david))

  readers = Reader.all.merge!(where: ["post_id = ?", popular_post.id],
                              includes: { post: :comments }).to_a
  readers.each do |reader|
    assert_equal [comment], reader.post.comments
  end
end
test_including_duplicate_objects_from_has_many() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 197
def test_including_duplicate_objects_from_has_many
  car_post = Post.create!(title: "foo", body: "I like cars!")
  car_post.categories << categories(:general)
  car_post.categories << categories(:technology)

  comment = car_post.comments.create!(body: "hmm")
  categories = Category.all.merge!(where: { "posts.id" => car_post.id },
                               includes: { posts: :comments }).to_a
  categories.each do |category|
    assert_equal [comment], category.posts[0].comments
  end
end
test_join_eager_with_empty_order_should_generate_valid_sql() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1275
def test_join_eager_with_empty_order_should_generate_valid_sql
  assert_nothing_raised do
    Post.includes(:comments).order("").where(comments: { body: "Thank you for the welcome" }).first
  end
end
test_joins_with_includes_should_preload_via_joins() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1267
def test_joins_with_includes_should_preload_via_joins
  post = assert_queries(1) { Post.includes(:comments).joins(:comments).order("posts.id desc").to_a.first }

  assert_queries(0) do
    assert_not_equal 0, post.comments.to_a.count
  end
end
test_limited_eager_with_multiple_order_columns() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 885
def test_limited_eager_with_multiple_order_columns
  assert_equal(
    posts(:thinking, :sti_comments),
    Post.all.merge!(
      includes: [:author, :comments], where: { "authors.name" => "David" },
      order: ["UPPER(posts.title)", "posts.id"], limit: 2, offset: 1
    ).to_a
  )
  assert_equal(
    posts(:sti_post_and_comments, :sti_comments),
    Post.all.merge!(
      includes: [:author, :comments], where: { "authors.name" => "David" },
      order: ["UPPER(posts.title) DESC", "posts.id"], limit: 2, offset: 1
    ).to_a
  )
end
test_limited_eager_with_numeric_in_association() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 902
def test_limited_eager_with_numeric_in_association
  assert_equal(
    people(:david, :susan),
    Person.references(:number1_fans_people).merge(
      includes: [:readers, :primary_contact, :number1_fan],
      where: "number1_fans_people.first_name like 'M%'",
      order: "people.id", limit: 2, offset: 0
    ).to_a
  )
end
test_limited_eager_with_order() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 868
def test_limited_eager_with_order
  assert_equal(
    posts(:thinking, :sti_comments),
    Post.all.merge!(
      includes: [:author, :comments], where: { "authors.name" => "David" },
      order: "UPPER(posts.title)", limit: 2, offset: 1
    ).to_a
  )
  assert_equal(
    posts(:sti_post_and_comments, :sti_comments),
    Post.all.merge!(
      includes: [:author, :comments], where: { "authors.name" => "David" },
      order: "UPPER(posts.title) DESC", limit: 2, offset: 1
    ).to_a
  )
end
test_load_associated_records_in_one_query_when_a_few_ids_passed() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 175
def test_load_associated_records_in_one_query_when_a_few_ids_passed
  assert_called(Comment.connection, :in_clause_length, returns: 3) do
    post = posts(:welcome)
    assert_queries(2) do
      Post.includes(:comments).where(id: post.id).to_a
    end
  end
end
test_load_associated_records_in_one_query_when_adapter_has_no_limit() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 157
def test_load_associated_records_in_one_query_when_adapter_has_no_limit
  assert_called(Comment.connection, :in_clause_length, returns: nil) do
    post = posts(:welcome)
    assert_queries(2) do
      Post.includes(:comments).where(id: post.id).to_a
    end
  end
end
test_load_associated_records_in_several_queries_when_many_ids_passed() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 166
def test_load_associated_records_in_several_queries_when_many_ids_passed
  assert_called(Comment.connection, :in_clause_length, returns: 1) do
    post1, post2 = posts(:welcome), posts(:thinking)
    assert_queries(3) do
      Post.includes(:comments).where(id: [post1.id, post2.id]).to_a
    end
  end
end
test_load_with_sti_sharing_association() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1071
def test_load_with_sti_sharing_association
  assert_queries(2) do #should not do 1 query per subclass
    Comment.includes(:post).to_a
  end
end
test_loading_conditions_with_or() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 70
def test_loading_conditions_with_or
  posts = authors(:david).posts.references(:comments).merge(
    includes: :comments,
    where: "comments.body like 'Normal%' OR comments.#{QUOTED_TYPE} = 'SpecialComment'"
  ).to_a
  assert_nil posts.detect { |p| p.author_id != authors(:david).id },
    "expected to find only david's posts"
end
test_loading_from_an_association() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 281
def test_loading_from_an_association
  posts = authors(:david).posts.merge(includes: :comments, order: "posts.id").to_a
  assert_equal 2, posts.first.comments.size
end
test_loading_from_an_association_that_has_a_hash_of_conditions() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 286
def test_loading_from_an_association_that_has_a_hash_of_conditions
  assert !Author.all.merge!(includes: :hello_posts_with_hash_conditions).find(authors(:david).id).hello_posts.empty?
end
test_loading_with_multiple_associations() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 115
def test_loading_with_multiple_associations
  posts = Post.all.merge!(includes: [ :comments, :author, :categories ], order: "posts.id").to_a
  assert_equal 2, posts.first.comments.size
  assert_equal 2, posts.first.categories.size
  assert_includes posts.first.comments, comments(:greetings)
end
test_loading_with_no_associations() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 290
def test_loading_with_no_associations
  assert_nil Post.all.merge!(includes: :author).find(posts(:authorless).id).author
end
test_loading_with_one_association() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 49
def test_loading_with_one_association
  posts = Post.all.merge!(includes: :comments).to_a
  post = posts.find { |p| p.id == 1 }
  assert_equal 2, post.comments.size
  assert_includes post.comments, comments(:greetings)

  post = Post.all.merge!(includes: :comments, where: "posts.title = 'Welcome to the weblog'").first
  assert_equal 2, post.comments.size
  assert_includes post.comments, comments(:greetings)

  posts = Post.all.merge!(includes: :last_comment).to_a
  post = posts.find { |p| p.id == 1 }
  assert_equal Post.find(1).last_comment, post.last_comment
end
test_loading_with_one_association_with_non_preload() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 64
def test_loading_with_one_association_with_non_preload
  posts = Post.all.merge!(includes: :last_comment, order: "comments.id DESC").to_a
  post = posts.find { |p| p.id == 1 }
  assert_equal Post.find(1).last_comment, post.last_comment
end
test_loading_with_scope_including_joins() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 79
def test_loading_with_scope_including_joins
  assert_equal clubs(:boring_club), Member.preload(:general_club).find(1).general_club
  assert_equal clubs(:boring_club), Member.eager_load(:general_club).find(1).general_club
end
test_nested_loading_does_not_raise_exception_when_association_does_not_exist() click to toggle source

Regression test for 21c75e5

# File activerecord/test/cases/associations/eager_test.rb, line 295
def test_nested_loading_does_not_raise_exception_when_association_does_not_exist
  assert_nothing_raised do
    Post.all.merge!(includes: { author: :author_addresss }).find(posts(:authorless).id)
  end
end
test_nested_loading_through_has_one_association() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 309
def test_nested_loading_through_has_one_association
  aa = AuthorAddress.all.merge!(includes: { author: :posts }).find(author_addresses(:david_address).id)
  assert_equal aa.author.posts.count, aa.author.posts.length
end
test_nested_loading_through_has_one_association_with_conditions() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 329
def test_nested_loading_through_has_one_association_with_conditions
  aa = AuthorAddress.references(:author_addresses).merge(
    includes: { author: :posts },
    where: "author_addresses.id > 0"
  ).find author_addresses(:david_address).id
  assert_equal aa.author.posts.count, aa.author.posts.length
end
test_nested_loading_through_has_one_association_with_conditions_on_association() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 337
def test_nested_loading_through_has_one_association_with_conditions_on_association
  aa = AuthorAddress.references(:authors).merge(
    includes: { author: :posts },
    where: "authors.id > 0"
  ).find author_addresses(:david_address).id
  assert_equal aa.author.posts.count, aa.author.posts.length
end
test_nested_loading_through_has_one_association_with_conditions_on_nested_association() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 345
def test_nested_loading_through_has_one_association_with_conditions_on_nested_association
  aa = AuthorAddress.references(:posts).merge(
    includes: { author: :posts },
    where: "posts.id > 0"
  ).find author_addresses(:david_address).id
  assert_equal aa.author.posts.count, aa.author.posts.length
end
test_nested_loading_through_has_one_association_with_order() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 314
def test_nested_loading_through_has_one_association_with_order
  aa = AuthorAddress.all.merge!(includes: { author: :posts }, order: "author_addresses.id").find(author_addresses(:david_address).id)
  assert_equal aa.author.posts.count, aa.author.posts.length
end
test_nested_loading_through_has_one_association_with_order_on_association() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 319
def test_nested_loading_through_has_one_association_with_order_on_association
  aa = AuthorAddress.all.merge!(includes: { author: :posts }, order: "authors.id").find(author_addresses(:david_address).id)
  assert_equal aa.author.posts.count, aa.author.posts.length
end
test_nested_loading_through_has_one_association_with_order_on_nested_association() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 324
def test_nested_loading_through_has_one_association_with_order_on_nested_association
  aa = AuthorAddress.all.merge!(includes: { author: :posts }, order: "posts.id").find(author_addresses(:david_address).id)
  assert_equal aa.author.posts.count, aa.author.posts.length
end
test_order_on_join_table_with_include_and_limit() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1087
def test_order_on_join_table_with_include_and_limit
  assert_equal 5, Developer.all.merge!(includes: "projects", order: "developers_projects.joined_on DESC", limit: 5).to_a.size
end
test_polymorphic_type_condition() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 913
def test_polymorphic_type_condition
  post = Post.all.merge!(includes: :taggings).find(posts(:thinking).id)
  assert_includes post.taggings, taggings(:thinking_general)
  post = SpecialPost.all.merge!(includes: :taggings).find(posts(:thinking).id)
  assert_includes post.taggings, taggings(:thinking_general)
end
test_preconfigured_includes_with_belongs_to() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 987
def test_preconfigured_includes_with_belongs_to
  author = posts(:welcome).author_with_posts
  assert_no_queries { assert_equal 5, author.posts.size }
end
test_preconfigured_includes_with_habtm() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1012
def test_preconfigured_includes_with_habtm
  posts = authors(:david).posts_with_categories
  one = posts.detect { |p| p.id == 1 }
  assert_no_queries do
    assert_equal 5, posts.size
    assert_equal 2, one.categories.size
  end
end
test_preconfigured_includes_with_has_many() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1003
def test_preconfigured_includes_with_has_many
  posts = authors(:david).posts_with_comments
  one = posts.detect { |p| p.id == 1 }
  assert_no_queries do
    assert_equal 5, posts.size
    assert_equal 2, one.comments.size
  end
end
test_preconfigured_includes_with_has_many_and_habtm() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1021
def test_preconfigured_includes_with_has_many_and_habtm
  posts = authors(:david).posts_with_comments_and_categories
  one = posts.detect { |p| p.id == 1 }
  assert_no_queries do
    assert_equal 5, posts.size
    assert_equal 2, one.comments.size
    assert_equal 2, one.categories.size
  end
end
test_preconfigured_includes_with_has_one() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 992
def test_preconfigured_includes_with_has_one
  comment = posts(:sti_comments).very_special_comment_with_post
  assert_no_queries { assert_equal posts(:sti_comments), comment.post }
end
test_preload_belongs_to_uses_exclusive_scope() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1159
def test_preload_belongs_to_uses_exclusive_scope
  people = Person.males.merge(includes: :primary_contact).to_a
  assert_not_equal people.length, 0
  people.each do |person|
    assert_no_queries { assert_not_nil person.primary_contact }
    assert_equal Person.find(person.id).primary_contact, person.primary_contact
  end
end
test_preload_has_many_uses_exclusive_scope() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1168
def test_preload_has_many_uses_exclusive_scope
  people = Person.males.includes(:agents).to_a
  people.each do |person|
    assert_equal Person.find(person.id).agents, person.agents
  end
end
test_preload_has_many_using_primary_key() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1175
def test_preload_has_many_using_primary_key
  expected = Firm.first.clients_using_primary_key.to_a
  firm = Firm.includes(:clients_using_primary_key).first
  assert_no_queries do
    assert_equal expected, firm.clients_using_primary_key
  end
end
test_preload_has_many_with_association_condition_and_default_scope() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1117
def test_preload_has_many_with_association_condition_and_default_scope
  post = Post.create!(title: "Beaches", body: "I like beaches!")
  Reader.create! person: people(:david), post: post
  LazyReader.create! person: people(:susan), post: post

  assert_equal 1, post.lazy_readers.to_a.size
  assert_equal 2, post.lazy_readers_skimmers_or_not.to_a.size

  post_with_readers = Post.includes(:lazy_readers_skimmers_or_not).find(post.id)
  assert_equal 2, post_with_readers.lazy_readers_skimmers_or_not.to_a.size
end
test_preload_has_one_using_primary_key() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1196
def test_preload_has_one_using_primary_key
  expected = accounts(:signals37)
  firm = Firm.all.merge!(includes: :account_using_primary_key, order: "companies.id").first
  assert_no_queries do
    assert_equal expected, firm.account_using_primary_key
  end
end
test_preloading_empty_belongs_to() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1212
def test_preloading_empty_belongs_to
  c = Client.create!(name: "Foo", client_of: Company.maximum(:id) + 1)

  client = assert_queries(2) { Client.preload(:firm).find(c.id) }
  assert_no_queries { assert_nil client.firm }
end
test_preloading_empty_belongs_to_polymorphic() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1219
def test_preloading_empty_belongs_to_polymorphic
  t = Tagging.create!(taggable_type: "Post", taggable_id: Post.maximum(:id) + 1, tag: tags(:general))

  tagging = assert_queries(2) { Tagging.preload(:taggable).find(t.id) }
  assert_no_queries { assert_nil tagging.taggable }
end
test_preloading_habtm_in_multiple_queries_with_more_ids_than_database_can_handle() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 143
def test_preloading_habtm_in_multiple_queries_with_more_ids_than_database_can_handle
  assert_called(Comment.connection, :in_clause_length, times: 2, returns: 5) do
    posts = Post.all.merge!(includes: :categories).to_a
    assert_equal 11, posts.size
  end
end
test_preloading_habtm_in_one_queries_when_database_has_no_limit_on_ids_it_can_handle() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 150
def test_preloading_habtm_in_one_queries_when_database_has_no_limit_on_ids_it_can_handle
  assert_called(Comment.connection, :in_clause_length, times: 2, returns: nil) do
    posts = Post.all.merge!(includes: :categories).to_a
    assert_equal 11, posts.size
  end
end
test_preloading_has_many_in_multiple_queries_with_more_ids_than_database_can_handle() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 129
def test_preloading_has_many_in_multiple_queries_with_more_ids_than_database_can_handle
  assert_called(Comment.connection, :in_clause_length, returns: 5) do
    posts = Post.all.merge!(includes: :comments).to_a
    assert_equal 11, posts.size
  end
end
test_preloading_has_many_in_one_queries_when_database_has_no_limit_on_ids_it_can_handle() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 136
def test_preloading_has_many_in_one_queries_when_database_has_no_limit_on_ids_it_can_handle
  assert_called(Comment.connection, :in_clause_length, returns: nil) do
    posts = Post.all.merge!(includes: :comments).to_a
    assert_equal 11, posts.size
  end
end
test_preloading_has_many_through_with_distinct() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1233
def test_preloading_has_many_through_with_distinct
  mary = Author.includes(:unique_categorized_posts).where(id: authors(:mary).id).first
  assert_equal 1, mary.unique_categorized_posts.length
  assert_equal 1, mary.unique_categorized_post_ids.length
end
test_preloading_has_one_using_reorder() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1239
def test_preloading_has_one_using_reorder
  klass = Class.new(ActiveRecord::Base) do
    def self.name; "TempAuthor"; end
    self.table_name = "authors"
    has_one :post, class_name: "PostWithDefaultScope", foreign_key: :author_id
    has_one :reorderd_post, -> { reorder(title: :desc) }, class_name: "PostWithDefaultScope", foreign_key: :author_id
  end

  author = klass.first
  # PRECONDITION: make sure ordering results in different results
  assert_not_equal author.post, author.reorderd_post

  preloaded_reorderd_post = klass.preload(:reorderd_post).first.reorderd_post

  assert_equal author.reorderd_post, preloaded_reorderd_post
  assert_equal Post.order(title: :desc).first.title, preloaded_reorderd_post.title
end
test_preloading_polymorphic_with_custom_foreign_type() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1257
def test_preloading_polymorphic_with_custom_foreign_type
  sponsor = sponsors(:moustache_club_sponsor_for_groucho)
  groucho = members(:groucho)

  sponsor = assert_queries(2) {
    Sponsor.includes(:thing).where(id: sponsor.id).first
  }
  assert_no_queries { assert_equal groucho, sponsor.thing }
end
test_preloading_through_empty_belongs_to() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 1226
def test_preloading_through_empty_belongs_to
  c = Client.create!(name: "Foo", client_of: Company.maximum(:id) + 1)

  client = assert_queries(2) { Client.preload(:accounts).find(c.id) }
  assert_no_queries { assert client.accounts.empty? }
end
test_should_work_inverse_of_with_eager_load() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 43
def test_should_work_inverse_of_with_eager_load
  author = authors(:david)
  assert_same author, author.posts.first.author
  assert_same author, author.posts.eager_load(:comments).first.author
end
test_string_id_column_joins() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 481
def test_string_id_column_joins
  s = Subscriber.create! do |c|
    c.id = "PL"
  end

  b = Book.create!

  Subscription.create!(subscriber_id: "PL", book_id: b.id)
  s.reload
  s.book_ids = s.book_ids
end
test_three_level_nested_preloading_does_not_raise_exception_when_association_does_not_exist() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 301
def test_three_level_nested_preloading_does_not_raise_exception_when_association_does_not_exist
  post_id = Comment.where(author_id: nil).where.not(post_id: nil).first.post_id

  assert_nothing_raised do
    Post.preload(comments: [{ author: :essays }]).find(post_id)
  end
end
test_with_ordering() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 84
def test_with_ordering
  list = Post.all.merge!(includes: :comments, order: "posts.id DESC").to_a
  [:other_by_mary, :other_by_bob, :misc_by_mary, :misc_by_bob, :eager_other,
   :sti_habtm, :sti_post_and_comments, :sti_comments, :authorless, :thinking, :welcome
  ].each_with_index do |post, index|
    assert_equal posts(post), list[index]
  end
end
test_with_two_tables_in_from_without_getting_double_quoted() click to toggle source
# File activerecord/test/cases/associations/eager_test.rb, line 110
def test_with_two_tables_in_from_without_getting_double_quoted
  posts = Post.select("posts.*").from("authors, posts").eager_load(:comments).where("posts.author_id = authors.id").order("posts.id").to_a
  assert_equal 2, posts.first.comments.size
end