class RelationTest

Public Instance Methods

author() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1393
def author
  "lifo"
end
respond_to?(method, access = false) click to toggle source
# File activerecord/test/cases/relations_test.rb, line 476
def respond_to?(method, access = false)
  responds << [method, access]
end
test_anonymous_extension() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1391
def test_anonymous_extension
  relation = Post.where(author_id: 1).order("id ASC").extending do
    def author
      "lifo"
    end
  end

  assert_equal "lifo", relation.author
  assert_equal "lifo", relation.limit(1).author
end
test_any() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1085
def test_any
  posts = Post.all

  # This test was failing when run on its own (as opposed to running the entire suite).
  # The second line in the assert_queries block was causing visit_Arel_Attributes_Attribute
  # in Arel::Visitors::ToSql to trigger a SHOW TABLES query. Running that line here causes
  # the SHOW TABLES result to be cached so we don't have to do it again in the block.
  #
  # This is obviously a rubbish fix but it's the best I can come up with for now...
  posts.where(id: nil).any?

  assert_queries(3) do
    assert posts.any? # Uses COUNT()
    assert ! posts.where(id: nil).any?

    assert posts.any? { |p| p.id > 0 }
    assert ! posts.any? { |p| p.id <= 0 }
  end

  assert posts.loaded?
end
test_any_with_scope_on_hash_includes() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 868
def test_any_with_scope_on_hash_includes
  post = authors(:david).posts.first
  categories = Categorization.includes(author: :posts).where(posts: { id: post.id })
  assert categories.exists?
end
test_automatically_added_having_references() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1584
def test_automatically_added_having_references
  scope = Post.having(comments: { body: "Bla" })
  assert_equal ["comments"], scope.references_values

  scope = Post.having("comments.body" => "Bla")
  assert_equal ["comments"], scope.references_values
end
test_automatically_added_order_references() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1592
def test_automatically_added_order_references
  scope = Post.order("comments.body")
  assert_equal ["comments"], scope.references_values

  scope = Post.order("#{Comment.quoted_table_name}.#{Comment.quoted_primary_key}")
  if current_adapter?(:OracleAdapter)
    assert_equal ["COMMENTS"], scope.references_values
  else
    assert_equal ["comments"], scope.references_values
  end

  scope = Post.order("comments.body", "yaks.body")
  assert_equal ["comments", "yaks"], scope.references_values

  # Don't infer yaks, let's not go down that road again...
  scope = Post.order("comments.body, yaks.body")
  assert_equal ["comments"], scope.references_values

  scope = Post.order("comments.body asc")
  assert_equal ["comments"], scope.references_values

  scope = Post.order("foo(comments.body)")
  assert_equal [], scope.references_values
end
test_automatically_added_reorder_references() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1617
def test_automatically_added_reorder_references
  scope = Post.reorder("comments.body")
  assert_equal %w(comments), scope.references_values

  scope = Post.reorder("#{Comment.quoted_table_name}.#{Comment.quoted_primary_key}")
  if current_adapter?(:OracleAdapter)
    assert_equal ["COMMENTS"], scope.references_values
  else
    assert_equal ["comments"], scope.references_values
  end

  scope = Post.reorder("comments.body", "yaks.body")
  assert_equal %w(comments yaks), scope.references_values

  # Don't infer yaks, let's not go down that road again...
  scope = Post.reorder("comments.body, yaks.body")
  assert_equal %w(comments), scope.references_values

  scope = Post.reorder("comments.body asc")
  assert_equal %w(comments), scope.references_values

  scope = Post.reorder("foo(comments.body)")
  assert_equal [], scope.references_values
end
test_automatically_added_where_not_references() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1576
def test_automatically_added_where_not_references
  scope = Post.where.not(comments: { body: "Bla" })
  assert_equal ["comments"], scope.references_values

  scope = Post.where.not("comments.body" => "Bla")
  assert_equal ["comments"], scope.references_values
end
test_automatically_added_where_references() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1568
def test_automatically_added_where_references
  scope = Post.where(comments: { body: "Bla" })
  assert_equal ["comments"], scope.references_values

  scope = Post.where("comments.body" => "Bla")
  assert_equal ["comments"], scope.references_values
end
test_blank_like_arguments_to_query_methods_dont_raise_errors() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 465
def test_blank_like_arguments_to_query_methods_dont_raise_errors
  assert_nothing_raised { Topic.references([]) }
  assert_nothing_raised { Topic.includes([]) }
  assert_nothing_raised { Topic.preload([]) }
  assert_nothing_raised { Topic.group([]) }
  assert_nothing_raised { Topic.reorder([]) }
end
test_build() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1168
def test_build
  posts = Post.all

  post = posts.new
  assert_kind_of Post, post
end
test_count() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 949
def test_count
  posts = Post.all

  assert_equal 11, posts.count
  assert_equal 11, posts.count(:all)
  assert_equal 11, posts.count(:id)

  assert_equal 1, posts.where("comments_count > 1").count
  assert_equal 9, posts.where(comments_count: 0).count
end
test_count_complex_chained_relations() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1052
def test_count_complex_chained_relations
  posts = Post.select("comments_count").where("id is not null").group("author_id").where("comments_count > 0")

  expected = { 1 => 2 }
  assert_equal expected, posts.count
end
test_count_explicit_columns() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 994
def test_count_explicit_columns
  Post.update_all(comments_count: nil)
  posts = Post.all

  assert_equal [0], posts.select("comments_count").where("id is not null").group("id").order("id").count.values.uniq
  assert_equal 0, posts.where("id is not null").select("comments_count").count

  assert_equal 11, posts.select("comments_count").count("id")
  assert_equal 0, posts.select("comments_count").count
  assert_equal 0, posts.count(:comments_count)
  assert_equal 0, posts.count("comments_count")
end
test_count_on_association_relation() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 965
def test_count_on_association_relation
  author = Author.last
  another_author = Author.first
  posts = Post.where(author_id: author.id)

  assert_equal author.posts.where(author_id: author.id).size, posts.count

  assert_equal 0, author.posts.where(author_id: another_author.id).size
  assert author.posts.where(author_id: another_author.id).empty?
end
test_count_with_block() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 960
def test_count_with_block
  posts = Post.all
  assert_equal 10, posts.count { |p| p.comments_count.even? }
end
test_count_with_distinct() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 976
def test_count_with_distinct
  posts = Post.all

  assert_equal 3, posts.distinct(true).count(:comments_count)
  assert_equal 11, posts.distinct(false).count(:comments_count)

  assert_equal 3, posts.distinct(true).select(:comments_count).count
  assert_equal 11, posts.distinct(false).select(:comments_count).count
end
test_create() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1183
def test_create
  birds = Bird.all

  sparrow = birds.create
  assert_kind_of Bird, sparrow
  assert !sparrow.persisted?

  hen = birds.where(name: "hen").create
  assert hen.persisted?
  assert_equal "hen", hen.name
end
test_create_bang() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1195
def test_create_bang
  birds = Bird.all

  assert_raises(ActiveRecord::RecordInvalid) { birds.create! }

  hen = birds.where(name: "hen").create!
  assert_kind_of Bird, hen
  assert hen.persisted?
  assert_equal "hen", hen.name
end
test_default_reverse_order_on_table_without_primary_key() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 287
def test_default_reverse_order_on_table_without_primary_key
  assert_raises(ActiveRecord::IrreversibleOrderError) do
    Edge.all.reverse_order
  end
end
test_default_scope_order_with_scope_order() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1412
def test_default_scope_order_with_scope_order
  assert_equal "zyke", CoolCar.order_using_new_style.limit(1).first.name
  assert_equal "zyke", FastCar.order_using_new_style.limit(1).first.name
end
test_default_scoping_finder_methods() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 574
def test_default_scoping_finder_methods
  developers = DeveloperCalledDavid.order("id").map(&:id).sort
  assert_equal Developer.where(name: "David").map(&:id).sort, developers
end
test_delete_all() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 892
def test_delete_all
  davids = Author.where(name: "David")

  assert_difference("Author.count", -1) { davids.delete_all }
  assert ! davids.loaded?
end
test_delete_all_loaded() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 899
def test_delete_all_loaded
  davids = Author.where(name: "David")

  # Force load
  assert_equal [authors(:david)], davids.to_a
  assert davids.loaded?

  assert_difference("Author.count", -1) { davids.delete_all }

  assert_equal [], davids.to_a
  assert davids.loaded?
end
test_delete_all_with_unpermitted_relation_raises_error() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 912
def test_delete_all_with_unpermitted_relation_raises_error
  assert_raises(ActiveRecord::ActiveRecordError) { Author.limit(10).delete_all }
  assert_raises(ActiveRecord::ActiveRecordError) { Author.distinct.delete_all }
  assert_raises(ActiveRecord::ActiveRecordError) { Author.group(:name).delete_all }
  assert_raises(ActiveRecord::ActiveRecordError) { Author.having("SUM(id) < 3").delete_all }
  assert_raises(ActiveRecord::ActiveRecordError) { Author.offset(10).delete_all }
end
test_destroy_all() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 879
def test_destroy_all
  davids = Author.where(name: "David")

  # Force load
  assert_equal [authors(:david)], davids.to_a
  assert davids.loaded?

  assert_difference("Author.count", -1) { davids.destroy_all }

  assert_equal [], davids.to_a
  assert davids.loaded?
end
test_distinct() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1512
def test_distinct
  tag1 = Tag.create(name: "Foo")
  tag2 = Tag.create(name: "Foo")

  query = Tag.select(:name).where(id: [tag1.id, tag2.id])

  assert_equal ["Foo", "Foo"], query.map(&:name)
  assert_sql(/DISTINCT/) do
    assert_equal ["Foo"], query.distinct.map(&:name)
  end
  assert_sql(/DISTINCT/) do
    assert_equal ["Foo"], query.distinct(true).map(&:name)
  end
  assert_equal ["Foo", "Foo"], query.distinct(true).distinct(false).map(&:name)
end
test_do_not_double_quote_string_id() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 34
def test_do_not_double_quote_string_id
  van = Minivan.last
  assert van
  assert_equal van.id, Minivan.where(minivan_id: van).to_a.first.minivan_id
end
test_do_not_double_quote_string_id_with_array() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 40
def test_do_not_double_quote_string_id_with_array
  van = Minivan.last
  assert van
  assert_equal van, Minivan.where(minivan_id: [van]).to_a.first
end
test_doesnt_add_having_values_if_options_are_blank() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1528
def test_doesnt_add_having_values_if_options_are_blank
  scope = Post.having("")
  assert scope.having_clause.empty?

  scope = Post.having([])
  assert scope.having_clause.empty?
end
test_dynamic_find_by_attributes() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 667
def test_dynamic_find_by_attributes
  david = authors(:david)
  author = Author.preload(:taggings).find_by_id(david.id)
  expected_taggings = taggings(:welcome_general, :thinking_general)

  assert_no_queries do
    assert_equal expected_taggings, author.taggings.uniq.sort_by(&:id)
  end

  authors = Author.all
  assert_equal david, authors.find_by_id_and_name(david.id, david.name)
  assert_equal david, authors.find_by_id_and_name!(david.id, david.name)
end
test_dynamic_find_by_attributes_bang() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 681
def test_dynamic_find_by_attributes_bang
  author = Author.all.find_by_id!(authors(:david).id)
  assert_equal "David", author.name

  assert_raises(ActiveRecord::RecordNotFound) { Author.all.find_by_id_and_name!(20, "invalid") }
end
test_dynamic_finder() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 57
def test_dynamic_finder
  x = Post.where("author_id = ?", 1)
  assert x.klass.respond_to?(:find_by_id), "@klass should handle dynamic finders"
end
test_eager_association_loading_of_stis_with_multiple_references() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 505
def test_eager_association_loading_of_stis_with_multiple_references
  authors = Author.eager_load(posts: { special_comments: { post: [ :special_comments, :very_special_comment ] } }).
    order("comments.body, very_special_comments_posts.body").where("posts.id = 4").to_a

  assert_equal [authors(:david)], authors
  assert_no_queries do
    authors.first.posts.first.special_comments.first.post.special_comments
    authors.first.posts.first.special_comments.first.post.very_special_comment
  end
end
test_empty() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1059
def test_empty
  posts = Post.all

  assert_queries(1) { assert_equal false, posts.empty? }
  assert ! posts.loaded?

  no_posts = posts.where(title: "")
  assert_queries(1) { assert_equal true, no_posts.empty? }
  assert ! no_posts.loaded?

  best_posts = posts.where(comments_count: 0)
  best_posts.load # force load
  assert_no_queries { assert_equal false, best_posts.empty? }
end
test_empty_complex_chained_relations() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1074
def test_empty_complex_chained_relations
  posts = Post.select("comments_count").where("id is not null").group("author_id").where("comments_count > 0")

  assert_queries(1) { assert_equal false, posts.empty? }
  assert ! posts.loaded?

  no_posts = posts.where(title: "")
  assert_queries(1) { assert_equal true, no_posts.empty? }
  assert ! no_posts.loaded?
end
test_empty_with_zero_limit() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1045
def test_empty_with_zero_limit
  posts = Post.limit(0)

  assert_no_queries { assert_equal true, posts.empty? }
  assert ! posts.loaded?
end
test_except() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1369
def test_except
  relation = Post.where(author_id: 1).order("id ASC").limit(1)
  assert_equal [posts(:welcome)], relation.to_a

  author_posts = relation.except(:order, :limit)
  assert_equal Post.where(author_id: 1).to_a, author_posts.to_a

  all_posts = relation.except(:where, :order, :limit)
  assert_equal Post.all, all_posts
end
test_exists() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 848
def test_exists
  davids = Author.where(name: "David")
  assert davids.exists?
  assert davids.exists?(authors(:david).id)
  assert ! davids.exists?(authors(:mary).id)
  assert ! davids.exists?("42")
  assert ! davids.exists?(42)
  assert ! davids.exists?(davids.new.id)

  fake = Author.where(name: "fake author")
  assert ! fake.exists?
  assert ! fake.exists?(authors(:david).id)
end
test_exists_uses_existing_scope() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 862
def test_exists_uses_existing_scope
  post = authors(:david).posts.first
  authors = Author.includes(:posts).where(name: "David", posts: { id: post.id })
  assert authors.exists?(authors(:david).id)
end
test_explicit_create_with() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1361
def test_explicit_create_with
  hens = Bird.where(name: "hen")
  assert_equal "hen", hens.new.name

  hens = hens.create_with(name: "cock")
  assert_equal "cock", hens.new.name
end
test_find_all_using_where_twice_should_or_the_relation() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 734
def test_find_all_using_where_twice_should_or_the_relation
  david = authors(:david)
  relation = Author.unscoped
  relation = relation.where(name: david.name)
  relation = relation.where(name: "Santiago")
  relation = relation.where(id: david.id)
  assert_equal [], relation.to_a
end
test_find_all_using_where_with_relation() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 769
def test_find_all_using_where_with_relation
  david = authors(:david)
  # switching the lines below would succeed in current quails
  # assert_queries(2) {
  assert_queries(1) {
    relation = Author.where(id: Author.where(id: david.id))
    assert_equal [david], relation.to_a
  }

  assert_queries(1) {
    relation = Author.where("id in (?)", Author.where(id: david).select(:id))
    assert_equal [david], relation.to_a
  }

  assert_queries(1) do
    relation = Author.where("id in (:author_ids)", author_ids: Author.where(id: david).select(:id))
    assert_equal [david], relation.to_a
  end
end
test_find_all_using_where_with_relation_and_alternate_primary_key() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 809
def test_find_all_using_where_with_relation_and_alternate_primary_key
  cool_first = minivans(:cool_first)
  # switching the lines below would succeed in current quails
  # assert_queries(2) {
  assert_queries(1) {
    relation = Minivan.where(minivan_id: Minivan.where(name: cool_first.name))
    assert_equal [cool_first], relation.to_a
  }
end
test_find_all_using_where_with_relation_does_not_alter_select_values() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 819
def test_find_all_using_where_with_relation_does_not_alter_select_values
  david = authors(:david)

  subquery = Author.where(id: david.id)

  assert_queries(1) {
    relation = Author.where(id: subquery)
    assert_equal [david], relation.to_a
  }

  assert_equal 0, subquery.select_values.size
end
test_find_all_using_where_with_relation_with_bound_values() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 789
def test_find_all_using_where_with_relation_with_bound_values
  david = authors(:david)
  davids_posts = david.posts.order(:id).to_a

  assert_queries(1) do
    relation = Post.where(id: david.posts.select(:id))
    assert_equal davids_posts, relation.order(:id).to_a
  end

  assert_queries(1) do
    relation = Post.where("id in (?)", david.posts.select(:id))
    assert_equal davids_posts, relation.order(:id).to_a, "should process Relation as bind variables"
  end

  assert_queries(1) do
    relation = Post.where("id in (:post_ids)", post_ids: david.posts.select(:id))
    assert_equal davids_posts, relation.order(:id).to_a, "should process Relation as named bind variables"
  end
end
test_find_all_using_where_with_relation_with_joins() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 832
def test_find_all_using_where_with_relation_with_joins
  david = authors(:david)
  assert_queries(1) {
    relation = Author.where(id: Author.joins(:posts).where(id: david.id))
    assert_equal [david], relation.to_a
  }
end
test_find_all_using_where_with_relation_with_select_to_build_subquery() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 840
def test_find_all_using_where_with_relation_with_select_to_build_subquery
  david = authors(:david)
  assert_queries(1) {
    relation = Author.where(name: Author.where(id: david.id).select(:name))
    assert_equal [david], relation.to_a
  }
end
test_find_all_with_join() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 434
def test_find_all_with_join
  developers_on_project_one = Developer.joins("LEFT JOIN developers_projects ON developers.id = developers_projects.developer_id").
    where("project_id=1").to_a

  assert_equal 3, developers_on_project_one.length
  developer_names = developers_on_project_one.map(&:name)
  assert_includes developer_names, "David"
  assert_includes developer_names, "Jamis"
end
test_find_all_with_multiple_should_use_and() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 750
def test_find_all_with_multiple_should_use_and
  david = authors(:david)
  relation = [
    { name: david.name },
    { name: "Santiago" },
    { name: "tenderlove" },
  ].inject(Author.unscoped) do |memo, param|
    memo.where(param)
  end
  assert_equal [], relation.to_a
end
test_find_by_id_with_list_of_ar() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 728
def test_find_by_id_with_list_of_ar
  author = Author.first
  authors = Author.find_by_id([author])
  assert_equal author, authors
end
test_find_id() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 688
def test_find_id
  authors = Author.all

  david = authors.find(authors(:david).id)
  assert_equal "David", david.name

  assert_raises(ActiveRecord::RecordNotFound) { authors.where(name: "lifo").find("42") }
end
test_find_ids() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 697
def test_find_ids
  authors = Author.order("id ASC")

  results = authors.find(authors(:david).id, authors(:mary).id)
  assert_kind_of Array, results
  assert_equal 2, results.size
  assert_equal "David", results[0].name
  assert_equal "Mary", results[1].name
  assert_equal results, authors.find([authors(:david).id, authors(:mary).id])

  assert_raises(ActiveRecord::RecordNotFound) { authors.where(name: "lifo").find(authors(:david).id, "42") }
  assert_raises(ActiveRecord::RecordNotFound) { authors.find(["42", 43]) }
end
test_find_in_empty_array() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 711
def test_find_in_empty_array
  authors = Author.all.where(id: [])
  assert authors.to_a.blank?
end
test_find_on_hash_conditions() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 444
def test_find_on_hash_conditions
  assert_equal Topic.all.merge!(where: { approved: false }).to_a, Topic.where(approved: false).to_a
end
test_find_or_create_by() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1328
def test_find_or_create_by
  assert_nil Bird.find_by(name: "bob")

  bird = Bird.find_or_create_by(name: "bob")
  assert bird.persisted?

  assert_equal bird, Bird.find_or_create_by(name: "bob")
end
test_find_or_create_by!() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1347
def test_find_or_create_by!
  assert_raises(ActiveRecord::RecordInvalid) { Bird.find_or_create_by!(color: "green") }
end
test_find_or_create_by_with_create_with() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1337
def test_find_or_create_by_with_create_with
  assert_nil Bird.find_by(name: "bob")

  bird = Bird.create_with(color: "green").find_or_create_by(name: "bob")
  assert bird.persisted?
  assert_equal "green", bird.color

  assert_equal bird, Bird.create_with(color: "blue").find_or_create_by(name: "bob")
end
test_find_or_initialize_by() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1351
def test_find_or_initialize_by
  assert_nil Bird.find_by(name: "bob")

  bird = Bird.find_or_initialize_by(name: "bob")
  assert bird.new_record?
  bird.save!

  assert_equal bird, Bird.find_or_initialize_by(name: "bob")
end
test_find_with_included_associations() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 551
def test_find_with_included_associations
  assert_queries(2) do
    posts = Post.includes(:comments).order("posts.id")
    assert posts.first.comments.first
  end

  assert_queries(2) do
    posts = Post.all.includes(:comments).order("posts.id")
    assert posts.first.comments.first
  end

  assert_queries(2) do
    posts = Post.includes(:author).order("posts.id")
    assert posts.first.author
  end

  assert_queries(3) do
    posts = Post.includes(:author, :comments).order("posts.id")
    assert posts.first.author
    assert posts.first.comments.first
  end
end
test_find_with_list_of_ar() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 722
def test_find_with_list_of_ar
  author = Author.first
  authors = Author.find([author.id])
  assert_equal author, authors.first
end
test_find_with_preloaded_associations() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 516
def test_find_with_preloaded_associations
  assert_queries(2) do
    posts = Post.preload(:comments).order("posts.id")
    assert posts.first.comments.first
  end

  assert_queries(2) do
    posts = Post.preload(:comments).order("posts.id")
    assert posts.first.comments.first
  end

  assert_queries(2) do
    posts = Post.preload(:author).order("posts.id")
    assert posts.first.author
  end

  assert_queries(2) do
    posts = Post.preload(:author).order("posts.id")
    assert posts.first.author
  end

  assert_queries(3) do
    posts = Post.preload(:author, :comments).order("posts.id")
    assert posts.first.author
    assert posts.first.comments.first
  end
end
test_find_with_readonly_option() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 500
def test_find_with_readonly_option
  Developer.all.each { |d| assert !d.readonly? }
  Developer.all.readonly.each { |d| assert d.readonly? }
end
test_finding_last_with_arel_order() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 326
def test_finding_last_with_arel_order
  topics = Topic.order(Topic.arel_table[:id].asc)
  assert_equal topics(:fifth).title, topics.last.title
end
test_finding_with_arel_assoc_order() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 222
def test_finding_with_arel_assoc_order
  topics = Topic.order(Arel.sql("id") => :desc)
  assert_equal 5, topics.to_a.size
  assert_equal topics(:fifth).title, topics.first.title
end
test_finding_with_arel_order() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 210
def test_finding_with_arel_order
  topics = Topic.order(Topic.arel_table[:id].asc)
  assert_equal 5, topics.to_a.size
  assert_equal topics(:first).title, topics.first.title
end
test_finding_with_asc_order_with_string() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 303
def test_finding_with_asc_order_with_string
  topics = Topic.order(id: "asc")
  assert_equal 5, topics.to_a.size
  assert_equal [topics(:first), topics(:second), topics(:third), topics(:fourth), topics(:fifth)], topics.to_a
end
test_finding_with_assoc_order() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 216
def test_finding_with_assoc_order
  topics = Topic.order(id: :desc)
  assert_equal 5, topics.to_a.size
  assert_equal topics(:fifth).title, topics.first.title
end
test_finding_with_assoc_order_by_aliased_attributes() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 343
def test_finding_with_assoc_order_by_aliased_attributes
  topics = Topic.order(heading: :desc)
  assert_equal 5, topics.to_a.size
  assert_equal topics(:third).title, topics.first.title
end
test_finding_with_assoc_reorder_by_aliased_attributes() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 361
def test_finding_with_assoc_reorder_by_aliased_attributes
  topics = Topic.order("author_name").reorder(heading: :desc)
  assert_equal 5, topics.to_a.size
  assert_equal topics(:third).title, topics.first.title
end
test_finding_with_complex_order() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 386
def test_finding_with_complex_order
  tags = Tag.includes(:taggings).references(:taggings).order("REPLACE('abc', taggings.taggable_type, taggings.taggable_type)").to_a
  assert_equal 3, tags.length
end
test_finding_with_complex_order_and_limit() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 381
def test_finding_with_complex_order_and_limit
  tags = Tag.includes(:taggings).references(:taggings).order("REPLACE('abc', taggings.taggable_type, taggings.taggable_type)").limit(1).to_a
  assert_equal 1, tags.length
end
test_finding_with_conditions() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 198
def test_finding_with_conditions
  assert_equal ["David"], Author.where(name: "David").map(&:name)
  assert_equal ["Mary"],  Author.where(["name = ?", "Mary"]).map(&:name)
  assert_equal ["Mary"],  Author.where("name = ?", "Mary").map(&:name)
end
test_finding_with_cross_table_order_and_limit() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 374
def test_finding_with_cross_table_order_and_limit
  tags = Tag.includes(:taggings).
            order("tags.name asc", "taggings.taggable_id asc", "REPLACE('abc', taggings.taggable_type, taggings.taggable_type)").
            limit(1).to_a
  assert_equal 1, tags.length
end
test_finding_with_desc_order_with_string() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 297
def test_finding_with_desc_order_with_string
  topics = Topic.order(id: "desc")
  assert_equal 5, topics.to_a.size
  assert_equal [topics(:fifth), topics(:fourth), topics(:third), topics(:second), topics(:first)], topics.to_a
end
test_finding_with_group() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 413
def test_finding_with_group
  developers = Developer.group("salary").select("salary").to_a
  assert_equal 4, developers.size
  assert_equal 4, developers.map(&:salary).uniq.size
end
test_finding_with_hash_conditions_on_joined_table() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 428
def test_finding_with_hash_conditions_on_joined_table
  firms = DependentFirm.joins(:account).where(name: "QuailsCore", accounts: { credit_limit: 55..60 }).to_a
  assert_equal 1, firms.size
  assert_equal companies(:quails_core), firms.first
end
test_finding_with_order() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 204
def test_finding_with_order
  topics = Topic.order("id")
  assert_equal 5, topics.to_a.size
  assert_equal topics(:first).title, topics.first.title
end
test_finding_with_order_and_take() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 367
def test_finding_with_order_and_take
  entrants = Entrant.order("id ASC").limit(2).to_a

  assert_equal 2, entrants.size
  assert_equal entrants(:first).name, entrants.first.name
end
test_finding_with_order_by_aliased_attributes() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 337
def test_finding_with_order_by_aliased_attributes
  topics = Topic.order(:heading)
  assert_equal 5, topics.to_a.size
  assert_equal topics(:fifth).title, topics.first.title
end
test_finding_with_order_concatenated() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 331
def test_finding_with_order_concatenated
  topics = Topic.order("author_name").order("title")
  assert_equal 5, topics.to_a.size
  assert_equal topics(:fourth).title, topics.first.title
end
test_finding_with_order_limit_and_offset() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 402
def test_finding_with_order_limit_and_offset
  entrants = Entrant.order("id ASC").limit(2).offset(1)

  assert_equal 2, entrants.to_a.size
  assert_equal entrants(:second).name, entrants.first.name

  entrants = Entrant.order("id ASC").limit(2).offset(2)
  assert_equal 1, entrants.to_a.size
  assert_equal entrants(:third).name, entrants.first.name
end
test_finding_with_reorder() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 349
def test_finding_with_reorder
  topics = Topic.order("author_name").order("title").reorder("id").to_a
  topics_titles = topics.map(&:title)
  assert_equal ["The First Topic", "The Second Topic of the day", "The Third Topic of the day", "The Fourth Topic of the day", "The Fifth Topic of the day"], topics_titles
end
test_finding_with_reorder_by_aliased_attributes() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 355
def test_finding_with_reorder_by_aliased_attributes
  topics = Topic.order("author_name").reorder(:heading)
  assert_equal 5, topics.to_a.size
  assert_equal topics(:fifth).title, topics.first.title
end
test_finding_with_reversed_arel_assoc_order() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 234
def test_finding_with_reversed_arel_assoc_order
  topics = Topic.order(Arel.sql("id") => :asc).reverse_order
  assert_equal 5, topics.to_a.size
  assert_equal topics(:fifth).title, topics.first.title
end
test_finding_with_reversed_assoc_order() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 228
def test_finding_with_reversed_assoc_order
  topics = Topic.order(id: :asc).reverse_order
  assert_equal 5, topics.to_a.size
  assert_equal topics(:fifth).title, topics.first.title
end
test_finding_with_sanitized_order() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 391
def test_finding_with_sanitized_order
  query = Tag.order(["field(id, ?)", [1, 3, 2]]).to_sql
  assert_match(/field\(id, 1,3,2\)/, query)

  query = Tag.order(["field(id, ?)", []]).to_sql
  assert_match(/field\(id, NULL\)/, query)

  query = Tag.order(["field(id, ?)", nil]).to_sql
  assert_match(/field\(id, NULL\)/, query)
end
test_finding_with_subquery() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 165
def test_finding_with_subquery
  relation = Topic.where(approved: true)
  assert_equal relation.to_a, Topic.select("*").from(relation).to_a
  assert_equal relation.to_a, Topic.select("subquery.*").from(relation).to_a
  assert_equal relation.to_a, Topic.select("a.*").from(relation, :a).to_a
end
test_finding_with_subquery_with_binds() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 172
def test_finding_with_subquery_with_binds
  relation = Post.first.comments
  assert_equal relation.to_a, Comment.select("*").from(relation).to_a
  assert_equal relation.to_a, Comment.select("subquery.*").from(relation).to_a
  assert_equal relation.to_a, Comment.select("a.*").from(relation, :a).to_a
end
test_finding_with_subquery_without_select_does_not_change_the_select() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 179
def test_finding_with_subquery_without_select_does_not_change_the_select
  relation = Topic.where(approved: true)
  assert_raises(ActiveRecord::StatementInvalid) do
    Topic.from(relation).to_a
  end
end
test_first_get_more_than_available() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 137
def test_first_get_more_than_available
  topics = Topic.all.order("id ASC")
  unloaded_first = topics.first(10)
  topics.load # force load

  assert_no_queries do
    loaded_first = topics.first(10)
    assert_equal unloaded_first, loaded_first
  end
end
test_first_or_create() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1206
def test_first_or_create
  parrot = Bird.where(color: "green").first_or_create(name: "parrot")
  assert_kind_of Bird, parrot
  assert parrot.persisted?
  assert_equal "parrot", parrot.name
  assert_equal "green", parrot.color

  same_parrot = Bird.where(color: "green").first_or_create(name: "parakeet")
  assert_kind_of Bird, same_parrot
  assert same_parrot.persisted?
  assert_equal parrot, same_parrot
end
test_first_or_create_bang_with_invalid_block() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1279
def test_first_or_create_bang_with_invalid_block
  assert_raise(ActiveRecord::RecordInvalid) do
    Bird.where(color: "green").first_or_create! { |bird| bird.pirate_id = 1 }
  end
end
test_first_or_create_bang_with_invalid_options() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1260
def test_first_or_create_bang_with_invalid_options
  assert_raises(ActiveRecord::RecordInvalid) { Bird.where(color: "green").first_or_create!(pirate_id: 1) }
end
test_first_or_create_bang_with_no_parameters() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1264
def test_first_or_create_bang_with_no_parameters
  assert_raises(ActiveRecord::RecordInvalid) { Bird.where(color: "green").first_or_create! }
end
test_first_or_create_bang_with_valid_block() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1268
def test_first_or_create_bang_with_valid_block
  parrot = Bird.where(color: "green").first_or_create! { |bird| bird.name = "parrot" }
  assert_kind_of Bird, parrot
  assert parrot.persisted?
  assert_equal "green", parrot.color
  assert_equal "parrot", parrot.name

  same_parrot = Bird.where(color: "green").first_or_create! { |bird| bird.name = "parakeet" }
  assert_equal parrot, same_parrot
end
test_first_or_create_bang_with_valid_options() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1247
def test_first_or_create_bang_with_valid_options
  parrot = Bird.where(color: "green").first_or_create!(name: "parrot")
  assert_kind_of Bird, parrot
  assert parrot.persisted?
  assert_equal "parrot", parrot.name
  assert_equal "green", parrot.color

  same_parrot = Bird.where(color: "green").first_or_create!(name: "parakeet")
  assert_kind_of Bird, same_parrot
  assert same_parrot.persisted?
  assert_equal parrot, same_parrot
end
test_first_or_create_with_array() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1237
def test_first_or_create_with_array
  several_green_birds = Bird.where(color: "green").first_or_create([{ name: "parrot" }, { name: "parakeet" }])
  assert_kind_of Array, several_green_birds
  several_green_birds.each { |bird| assert bird.persisted? }

  same_parrot = Bird.where(color: "green").first_or_create([{ name: "hummingbird" }, { name: "macaw" }])
  assert_kind_of Bird, same_parrot
  assert_equal several_green_birds.first, same_parrot
end
test_first_or_create_with_block() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1226
def test_first_or_create_with_block
  parrot = Bird.where(color: "green").first_or_create { |bird| bird.name = "parrot" }
  assert_kind_of Bird, parrot
  assert parrot.persisted?
  assert_equal "green", parrot.color
  assert_equal "parrot", parrot.name

  same_parrot = Bird.where(color: "green").first_or_create { |bird| bird.name = "parakeet" }
  assert_equal parrot, same_parrot
end
test_first_or_create_with_invalid_array() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1295
def test_first_or_create_with_invalid_array
  assert_raises(ActiveRecord::RecordInvalid) { Bird.where(color: "green").first_or_create!([ { name: "parrot" }, { pirate_id: 1 } ]) }
end
test_first_or_create_with_no_parameters() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1219
def test_first_or_create_with_no_parameters
  parrot = Bird.where(color: "green").first_or_create
  assert_kind_of Bird, parrot
  assert !parrot.persisted?
  assert_equal "green", parrot.color
end
test_first_or_create_with_valid_array() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1285
def test_first_or_create_with_valid_array
  several_green_birds = Bird.where(color: "green").first_or_create!([{ name: "parrot" }, { name: "parakeet" }])
  assert_kind_of Array, several_green_birds
  several_green_birds.each { |bird| assert bird.persisted? }

  same_parrot = Bird.where(color: "green").first_or_create!([{ name: "hummingbird" }, { name: "macaw" }])
  assert_kind_of Bird, same_parrot
  assert_equal several_green_birds.first, same_parrot
end
test_first_or_initialize() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1299
def test_first_or_initialize
  parrot = Bird.where(color: "green").first_or_initialize(name: "parrot")
  assert_kind_of Bird, parrot
  assert !parrot.persisted?
  assert parrot.valid?
  assert parrot.new_record?
  assert_equal "parrot", parrot.name
  assert_equal "green", parrot.color
end
test_first_or_initialize_with_block() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1318
def test_first_or_initialize_with_block
  parrot = Bird.where(color: "green").first_or_initialize { |bird| bird.name = "parrot" }
  assert_kind_of Bird, parrot
  assert !parrot.persisted?
  assert parrot.valid?
  assert parrot.new_record?
  assert_equal "green", parrot.color
  assert_equal "parrot", parrot.name
end
test_first_or_initialize_with_no_parameters() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1309
def test_first_or_initialize_with_no_parameters
  parrot = Bird.where(color: "green").first_or_initialize
  assert_kind_of Bird, parrot
  assert !parrot.persisted?
  assert !parrot.valid?
  assert parrot.new_record?
  assert_equal "green", parrot.color
end
test_group_with_subquery_in_from_does_not_use_original_table_name() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 192
def test_group_with_subquery_in_from_does_not_use_original_table_name
  relation = Comment.group(:type).select("COUNT(post_id) AS post_count,type")
  subquery = Comment.from(relation).group("type").average("post_count")
  assert_equal(relation.map(&:post_count).sort, subquery.values.sort)
end
test_grouping_by_column_with_reserved_name() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1553
def test_grouping_by_column_with_reserved_name
  assert_equal [], Possession.select(:where).group(:where).to_a
end
test_having_with_binds_for_both_where_and_having() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1536
def test_having_with_binds_for_both_where_and_having
  post = Post.first
  having_then_where = Post.having(id: post.id).where(title: post.title).group(:id)
  where_then_having = Post.where(title: post.title).having(id: post.id).group(:id)

  assert_equal [post], having_then_where
  assert_equal [post], where_then_having
end
test_includes_with_select() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 579
def test_includes_with_select
  query = Post.select("comments_count AS ranking").order("ranking").includes(:comments)
    .where(comments: { id: 1 })

  assert_equal ["comments_count AS ranking"], query.select_values
  assert_equal 1, query.to_a.size
end
test_intersection_with_array() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1434
def test_intersection_with_array
  relation = Author.where(name: "David")
  quails_author = relation.first

  assert_equal [quails_author], [quails_author] & relation
  assert_equal [quails_author], relation & [quails_author]
end
test_joins_with_nil_argument() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 424
def test_joins_with_nil_argument
  assert_nothing_raised { DependentFirm.joins(nil).first }
end
test_joins_with_string_array() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 448
def test_joins_with_string_array
  person_with_reader_and_post = Post.joins([
      "INNER JOIN categorizations ON categorizations.post_id = posts.id",
      "INNER JOIN categories ON categories.id = categorizations.category_id AND categories.type = 'SpecialCategory'"
    ]
  ).to_a
  assert_equal 1, person_with_reader_and_post.size
end
test_last() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 874
def test_last
  authors = Author.all
  assert_equal authors(:bob), authors.last
end
test_loaded_all() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 94
def test_loaded_all
  topics = Topic.all

  assert_queries(1) do
    2.times { assert_equal 5, topics.to_a.size }
  end

  assert topics.loaded?
end
test_loaded_first() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 114
def test_loaded_first
  topics = Topic.all.order("id ASC")
  topics.load # force load

  assert_no_queries do
    assert_equal "The First Topic", topics.first.title
  end

  assert topics.loaded?
end
test_loaded_first_with_limit() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 125
def test_loaded_first_with_limit
  topics = Topic.all.order("id ASC")
  topics.load # force load

  assert_no_queries do
    assert_equal ["The First Topic",
                  "The Second Topic of the day"], topics.first(2).map(&:title)
  end

  assert topics.loaded?
end
test_loading_with_one_association() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 632
def test_loading_with_one_association
  posts = Post.preload(:comments)
  post = posts.find { |p| p.id == 1 }
  assert_equal 2, post.comments.size
  assert_includes post.comments, comments(:greetings)

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

  posts = Post.preload(:last_comment)
  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/relations_test.rb, line 661
def test_loading_with_one_association_with_non_preload
  posts = Post.eager_load(:last_comment).order("comments.id DESC")
  post = posts.find { |p| p.id == 1 }
  assert_equal Post.find(1).last_comment, post.last_comment
end
test_locked_should_not_build_arel() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1863
def test_locked_should_not_build_arel
  posts = Post.locked
  assert posts.locked?
  assert_nothing_raised { posts.lock!(false) }
end
test_many() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1107
def test_many
  posts = Post.all

  assert_queries(2) do
    assert posts.many? # Uses COUNT()
    assert posts.many? { |p| p.id > 0 }
    assert ! posts.many? { |p| p.id < 2 }
  end

  assert posts.loaded?
end
test_many_with_limits() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1119
def test_many_with_limits
  posts = Post.all

  assert posts.many?
  assert ! posts.limit(1).many?
end
test_multi_where_ands_queries() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 743
def test_multi_where_ands_queries
  relation = Author.unscoped
  david = authors(:david)
  sql = relation.where(name: david.name).where(name: "Santiago").to_sql
  assert_match("AND", sql)
end
test_multiple_selects() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1007
def test_multiple_selects
  post = Post.all.select("comments_count").select("title").order("id ASC").first
  assert_equal "Welcome to the weblog", post.title
  assert_equal 2, post.comments_count
end
test_multiple_where_and_having_clauses() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1545
def test_multiple_where_and_having_clauses
  post = Post.first
  having_then_where = Post.having(id: post.id).where(title: post.title)
    .having(id: post.id).where(title: post.title).group(:id)

  assert_equal [post], having_then_where
end
test_multivalue_where() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 62
def test_multivalue_where
  posts = Post.where("author_id = ? AND id = ?", 1, 1)
  assert_equal 1, posts.to_a.size
end
test_named_extension() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1402
def test_named_extension
  relation = Post.where(author_id: 1).order("id ASC").extending(Post::NamedExtension)
  assert_equal "lifo", relation.author
  assert_equal "lifo", relation.limit(1).author
end
test_no_arguments_to_query_methods_raise_errors() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 457
def test_no_arguments_to_query_methods_raise_errors
  assert_raises(ArgumentError) { Topic.references() }
  assert_raises(ArgumentError) { Topic.includes() }
  assert_raises(ArgumentError) { Topic.preload() }
  assert_raises(ArgumentError) { Topic.group() }
  assert_raises(ArgumentError) { Topic.reorder() }
end
test_none?() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1126
def test_none?
  posts = Post.all
  assert_queries(1) do
    assert ! posts.none? # Uses COUNT()
  end

  assert ! posts.loaded?

  assert_queries(1) do
    assert posts.none? { |p| p.id < 0 }
    assert ! posts.none? { |p| p.id == 1 }
  end

  assert posts.loaded?
end
test_one() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1142
def test_one
  posts = Post.all
  assert_queries(1) do
    assert ! posts.one? # Uses COUNT()
  end

  assert ! posts.loaded?

  assert_queries(1) do
    assert ! posts.one? { |p| p.id < 3 }
    assert posts.one? { |p| p.id == 1 }
  end

  assert posts.loaded?
end
test_only() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1380
def test_only
  relation = Post.where(author_id: 1).order("id ASC").limit(1)
  assert_equal [posts(:welcome)], relation.to_a

  author_posts = relation.only(:where)
  assert_equal Post.where(author_id: 1).to_a, author_posts.to_a

  all_posts = relation.only(:limit)
  assert_equal Post.limit(1).to_a, all_posts.to_a
end
test_order_by_relation_attribute() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1408
def test_order_by_relation_attribute
  assert_equal Post.order(Post.arel_table[:title]).to_a, Post.order("title").to_a
end
test_order_using_scoping() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1417
def test_order_using_scoping
  car1 = CoolCar.order("id DESC").scoping do
    CoolCar.all.merge!(order: "id asc").first
  end
  assert_equal "zyke", car1.name

  car2 = FastCar.order("id DESC").scoping do
    FastCar.all.merge!(order: "id asc").first
  end
  assert_equal "zyke", car2.name
end
test_order_with_hash_and_symbol_generates_the_same_sql() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 293
def test_order_with_hash_and_symbol_generates_the_same_sql
  assert_equal Topic.order(:id).to_sql, Topic.order(id: :asc).to_sql
end
test_order_with_reorder_nil_removes_the_order() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1642
def test_order_with_reorder_nil_removes_the_order
  relation = Post.order(:title).reorder(nil)

  assert_nil relation.order_values.first
end
test_ordering_with_extra_spaces() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1446
def test_ordering_with_extra_spaces
  assert_equal authors(:david), Author.order("id DESC , name DESC").last
end
test_preload_applies_to_all_chained_preloaded_scopes() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 544
def test_preload_applies_to_all_chained_preloaded_scopes
  assert_queries(3) do
    post = Post.with_comments.with_tags.first
    assert post
  end
end
test_preloading_with_associations_and_merges() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 587
def test_preloading_with_associations_and_merges
  post = Post.create! title: "Uhuu", body: "body"
  reader = Reader.create! post_id: post.id, person_id: 1
  comment = Comment.create! post_id: post.id, body: "body"

  assert !comment.respond_to?(:readers)

  post_rel = Post.preload(:readers).joins(:readers).where(title: "Uhuu")
  result_comment = Comment.joins(:post).merge(post_rel).to_a.first
  assert_equal comment, result_comment

  assert_no_queries do
    assert_equal post, result_comment.post
    assert_equal [reader], result_comment.post.readers.to_a
  end

  post_rel = Post.includes(:readers).where(title: "Uhuu")
  result_comment = Comment.joins(:post).merge(post_rel).first
  assert_equal comment, result_comment

  assert_no_queries do
    assert_equal post, result_comment.post
    assert_equal [reader], result_comment.post.readers.to_a
  end
end
test_preloading_with_associations_default_scopes_and_merges() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 613
def test_preloading_with_associations_default_scopes_and_merges
  post = Post.create! title: "Uhuu", body: "body"
  reader = Reader.create! post_id: post.id, person_id: 1

  post_rel = PostWithPreloadDefaultScope.preload(:readers).joins(:readers).where(title: "Uhuu")
  result_post = PostWithPreloadDefaultScope.all.merge(post_rel).to_a.first

  assert_no_queries do
    assert_equal [reader], result_post.readers.to_a
  end

  post_rel = PostWithIncludesDefaultScope.includes(:readers).where(title: "Uhuu")
  result_post = PostWithIncludesDefaultScope.all.merge(post_rel).to_a.first

  assert_no_queries do
    assert_equal [reader], result_post.readers.to_a
  end
end
test_presence() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1654
def test_presence
  topics = Topic.all

  # the first query is triggered because there are no topics yet.
  assert_queries(1) { assert topics.present? }

  # checking if there are topics is used before you actually display them,
  # thus it shouldn't invoke an extra count query.
  assert_no_queries { assert topics.present? }
  assert_no_queries { assert !topics.blank? }

  # shows count of topics and loops after loading the query should not trigger extra queries either.
  assert_no_queries { topics.size }
  assert_no_queries { topics.length }
  assert_no_queries { topics.each }

  # count always trigger the COUNT query.
  assert_queries(1) { topics.count }

  assert topics.loaded?
end
test_primary_key() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1442
def test_primary_key
  assert_equal "id", Post.all.primary_key
end
test_raising_exception_on_invalid_hash_params() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 321
def test_raising_exception_on_invalid_hash_params
  e = assert_raise(ArgumentError) { Topic.order(:name, "id DESC", id: :asfsdf) }
  assert_equal 'Direction "asfsdf" is invalid. Valid directions are: [:asc, :desc, :ASC, :DESC, "asc", "desc", "ASC", "DESC"]', e.message
end
test_references_doesnt_trigger_eager_loading_if_reference_not_included() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1563
def test_references_doesnt_trigger_eager_loading_if_reference_not_included
  scope = Post.references(:comments)
  assert !scope.eager_loading?
end
test_references_triggers_eager_loading() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1557
def test_references_triggers_eager_loading
  scope = Post.includes(:comments)
  assert !scope.eager_loading?
  assert scope.references(:comments).eager_loading?
end
test_relation_join_method() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1869
def test_relation_join_method
  assert_equal "Thank you for the welcome,Thank you again for the welcome", Post.first.comments.join(",")
end
test_reload() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 148
def test_reload
  topics = Topic.all

  assert_queries(1) do
    2.times { topics.to_a }
  end

  assert topics.loaded?

  original_size = topics.to_a.size
  Topic.create! title: "fake"

  assert_queries(1) { topics.reload }
  assert_equal original_size + 1, topics.size
  assert topics.loaded?
end
test_respond_to_class_methods_and_scopes() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 496
def test_respond_to_class_methods_and_scopes
  assert Topic.all.respond_to?(:by_lifo)
end
test_respond_to_delegates_to_arel() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 473
def test_respond_to_delegates_to_arel
  relation = Topic.all
  fake_arel = Struct.new(:responds) {
    def respond_to?(method, access = false)
      responds << [method, access]
    end
  }.new []

  relation.extend(Module.new { attr_accessor :arel })
  relation.arel = fake_arel

  relation.respond_to?(:matching_attributes)
  assert_equal [:matching_attributes, false], fake_arel.responds.first
end
test_respond_to_dynamic_finders() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 488
def test_respond_to_dynamic_finders
  relation = Topic.all

  ["find_by_title", "find_by_title_and_author_name"].each do |method|
    assert_respond_to relation, method, "Topic.all should respond to #{method.inspect}"
  end
end
test_reverse_arel_assoc_order_with_function() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 245
def test_reverse_arel_assoc_order_with_function
  topics = Topic.order(Arel.sql("length(title)") => :asc).reverse_order
  assert_equal topics(:second).title, topics.first.title
end
test_reverse_arel_assoc_order_with_multiargument_function() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 272
def test_reverse_arel_assoc_order_with_multiargument_function
  assert_nothing_raised do
    Topic.order(Arel.sql("REPLACE(title, '', '')") => :asc).reverse_order
  end
end
test_reverse_order_with_function() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 240
def test_reverse_order_with_function
  topics = Topic.order("length(title)").reverse_order
  assert_equal topics(:second).title, topics.first.title
end
test_reverse_order_with_function_other_predicates() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 250
def test_reverse_order_with_function_other_predicates
  topics = Topic.order("author_name, length(title), id").reverse_order
  assert_equal topics(:second).title, topics.first.title
  topics = Topic.order("length(author_name), id, length(title)").reverse_order
  assert_equal topics(:fifth).title, topics.first.title
end
test_reverse_order_with_multiargument_function() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 257
def test_reverse_order_with_multiargument_function
  assert_raises(ActiveRecord::IrreversibleOrderError) do
    Topic.order("concat(author_name, title)").reverse_order
  end
  assert_raises(ActiveRecord::IrreversibleOrderError) do
    Topic.order("concat(lower(author_name), title)").reverse_order
  end
  assert_raises(ActiveRecord::IrreversibleOrderError) do
    Topic.order("concat(author_name, lower(title))").reverse_order
  end
  assert_raises(ActiveRecord::IrreversibleOrderError) do
    Topic.order("concat(lower(author_name), title, length(title)").reverse_order
  end
end
test_reverse_order_with_nulls_first_or_last() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 278
def test_reverse_order_with_nulls_first_or_last
  assert_raises(ActiveRecord::IrreversibleOrderError) do
    Topic.order("title NULLS FIRST").reverse_order
  end
  assert_raises(ActiveRecord::IrreversibleOrderError) do
    Topic.order("title nulls last").reverse_order
  end
end
test_reverse_order_with_reorder_nil_removes_the_order() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1648
def test_reverse_order_with_reorder_nil_removes_the_order
  relation = Post.order(:title).reverse_order.reorder(nil)

  assert_nil relation.order_values.first
end
test_scoped() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 67
def test_scoped
  topics = Topic.all
  assert_kind_of ActiveRecord::Relation, topics
  assert_equal 5, topics.size
end
test_scoped_all() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 88
def test_scoped_all
  topics = Topic.all.to_a
  assert_kind_of Array, topics
  assert_no_queries { assert_equal 5, topics.size }
end
test_scoped_build() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1175
def test_scoped_build
  posts = Post.where(title: "You told a lie")

  post = posts.new
  assert_kind_of Post, post
  assert_equal "You told a lie", post.title
end
test_scoped_first() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 104
def test_scoped_first
  topics = Topic.all.order("id ASC")

  assert_queries(1) do
    2.times { assert_equal "The First Topic", topics.first.title }
  end

  assert ! topics.loaded?
end
test_select_argument_error() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 945
def test_select_argument_error
  assert_raises(ArgumentError) { Developer.select }
end
test_select_takes_a_variable_list_of_args() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 930
def test_select_takes_a_variable_list_of_args
  david = developers(:david)

  developer = Developer.where(id: david.id).select(:name, :salary).first
  assert_equal david.name, developer.name
  assert_equal david.salary, developer.salary
end
test_select_takes_an_aliased_attribute() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 938
def test_select_takes_an_aliased_attribute
  first = topics(:first)

  topic = Topic.where(id: first.id).select(:heading).first
  assert_equal first.heading, topic.heading
end
test_select_with_aggregates() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 920
def test_select_with_aggregates
  posts = Post.select(:title, :body)

  assert_equal 11, posts.count(:all)
  assert_equal 11, posts.size
  assert posts.any?
  assert posts.many?
  assert_not posts.empty?
end
test_select_with_block() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 419
def test_select_with_block
  even_ids = Developer.all.select { |d| d.id % 2 == 0 }.map(&:id)
  assert_equal [2, 4, 6, 8, 10], even_ids.sort
end
test_select_with_subquery_in_from_does_not_use_original_table_name() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 186
def test_select_with_subquery_in_from_does_not_use_original_table_name
  relation = Comment.group(:type).select("COUNT(post_id) AS post_count, type")
  subquery = Comment.from(relation).select("type", "post_count")
  assert_equal(relation.map(&:post_count).sort, subquery.map(&:post_count).sort)
end
test_size() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1013
def test_size
  posts = Post.all

  assert_queries(1) { assert_equal 11, posts.size }
  assert ! posts.loaded?

  best_posts = posts.where(comments_count: 0)
  best_posts.load # force load
  assert_no_queries { assert_equal 9, best_posts.size }
end
test_size_with_limit() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1024
def test_size_with_limit
  posts = Post.limit(10)

  assert_queries(1) { assert_equal 10, posts.size }
  assert ! posts.loaded?

  best_posts = posts.where(comments_count: 0)
  best_posts.load # force load
  assert_no_queries { assert_equal 9, best_posts.size }
end
test_size_with_zero_limit() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1035
def test_size_with_zero_limit
  posts = Post.limit(0)

  assert_no_queries { assert_equal 0, posts.size }
  assert ! posts.loaded?

  posts.load # force load
  assert_no_queries { assert_equal 0, posts.size }
end
test_support_upper_and_lower_case_directions() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 309
def test_support_upper_and_lower_case_directions
  assert_includes Topic.order(id: "ASC").to_sql, "ASC"
  assert_includes Topic.order(id: "asc").to_sql, "ASC"
  assert_includes Topic.order(id: :ASC).to_sql, "ASC"
  assert_includes Topic.order(id: :asc).to_sql, "ASC"

  assert_includes Topic.order(id: "DESC").to_sql, "DESC"
  assert_includes Topic.order(id: "desc").to_sql, "DESC"
  assert_includes Topic.order(id: :DESC).to_sql, "DESC"
  assert_includes Topic.order(id: :desc).to_sql, "DESC"
end
test_to_a_should_dup_target() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1158
def test_to_a_should_dup_target
  posts = Post.all

  original_size = posts.size
  removed = posts.to_a.pop

  assert_equal original_size, posts.size
  assert_includes posts.to_a, removed
end
test_to_json() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 73
def test_to_json
  assert_nothing_raised  { Bird.all.to_json }
  assert_nothing_raised  { Bird.all.to_a.to_json }
end
test_to_sql_on_eager_join() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 647
def test_to_sql_on_eager_join
  expected = assert_sql {
    Post.eager_load(:last_comment).order("comments.id DESC").to_a
  }.first
  actual = Post.eager_load(:last_comment).order("comments.id DESC").to_sql
  assert_equal expected, actual
end
test_to_sql_on_scoped_proxy() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 655
def test_to_sql_on_scoped_proxy
  auth = Author.first
  Post.where("1=1").written_by(auth)
  assert_not auth.posts.to_sql.include?("1=1")
end
test_to_xml() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 83
def test_to_xml
  assert_nothing_raised  { Bird.all.to_xml }
  assert_nothing_raised  { Bird.all.to_a.to_xml }
end
test_to_yaml() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 78
def test_to_yaml
  assert_nothing_raised  { Bird.all.to_yaml }
  assert_nothing_raised  { Bird.all.to_a.to_yaml }
end
test_two_scopes_with_includes_should_not_drop_any_include() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 46
def test_two_scopes_with_includes_should_not_drop_any_include
  # heat habtm cache
  car = Car.incl_engines.incl_tyres.first
  car.tyres.length
  car.engines.length

  car = Car.incl_engines.incl_tyres.first
  assert_no_queries { car.tyres.length }
  assert_no_queries { car.engines.length }
end
test_typecasting_where_with_array() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 762
def test_typecasting_where_with_array
  ids = Author.pluck(:id)
  slugs = ids.map { |id| "#{id}-as-a-slug" }

  assert_equal Author.all.to_a, Author.where(id: slugs).to_a
end
test_unscope_specific_where_value() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1855
def test_unscope_specific_where_value
  posts = Post.where(title: "Welcome to the weblog", body: "Such a lovely day")

  assert_equal 1, posts.count
  assert_equal 1, posts.unscope(where: :title).count
  assert_equal 1, posts.unscope(where: :body).count
end
test_unscope_with_subquery() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1843
def test_unscope_with_subquery
  p1 = Post.where(id: 1)
  p2 = Post.where(id: 2)

  assert_not_equal p1, p2

  comments = Comment.where(post: p1).unscope(where: :post_id).where(post: p2)

  assert_not_equal p1.first.comments, comments
  assert_equal p2.first.comments, comments
end
test_unscoped_block_style() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1429
def test_unscoped_block_style
  assert_equal "honda", CoolCar.unscoped { CoolCar.order_using_new_style.limit(1).first.name }
  assert_equal "honda", FastCar.unscoped { FastCar.order_using_new_style.limit(1).first.name }
end
test_update_all_with_blank_argument() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1450
def test_update_all_with_blank_argument
  assert_raises(ArgumentError) { Comment.update_all({}) }
end
test_update_all_with_joins() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1454
def test_update_all_with_joins
  comments = Comment.joins(:post).where("posts.id" => posts(:welcome).id)
  count    = comments.count

  assert_equal count, comments.update_all(post_id: posts(:thinking).id)
  assert_equal posts(:thinking), comments(:greetings).post
end
test_update_all_with_joins_and_limit() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1462
def test_update_all_with_joins_and_limit
  comments = Comment.joins(:post).where("posts.id" => posts(:welcome).id).limit(1)
  assert_equal 1, comments.update_all(post_id: posts(:thinking).id)
end
test_update_all_with_joins_and_limit_and_order() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1467
def test_update_all_with_joins_and_limit_and_order
  comments = Comment.joins(:post).where("posts.id" => posts(:welcome).id).order("comments.id").limit(1)
  assert_equal 1, comments.update_all(post_id: posts(:thinking).id)
  assert_equal posts(:thinking), comments(:greetings).post
  assert_equal posts(:welcome),  comments(:more_greetings).post
end
test_update_all_with_joins_and_offset() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1474
def test_update_all_with_joins_and_offset
  all_comments = Comment.joins(:post).where("posts.id" => posts(:welcome).id)
  count        = all_comments.count
  comments     = all_comments.offset(1)

  assert_equal count - 1, comments.update_all(post_id: posts(:thinking).id)
end
test_update_all_with_joins_and_offset_and_order() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1482
def test_update_all_with_joins_and_offset_and_order
  all_comments = Comment.joins(:post).where("posts.id" => posts(:welcome).id).order("posts.id", "comments.id")
  count        = all_comments.count
  comments     = all_comments.offset(1)

  assert_equal count - 1, comments.update_all(post_id: posts(:thinking).id)
  assert_equal posts(:thinking), comments(:more_greetings).post
  assert_equal posts(:welcome),  comments(:greetings).post
end
test_update_all_with_scope() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 986
def test_update_all_with_scope
  tag = Tag.first
  Post.tagged_with(tag.id).update_all title: "rofl"
  list = Post.tagged_with(tag.id).all.to_a
  assert_operator list.length, :>, 0
  list.each { |post| assert_equal "rofl", post.title }
end
test_update_on_relation() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1492
def test_update_on_relation
  topic1 = TopicWithCallbacks.create! title: "arel", author_name: nil
  topic2 = TopicWithCallbacks.create! title: "activerecord", author_name: nil
  topics = TopicWithCallbacks.where(id: [topic1.id, topic2.id])
  topics.update(title: "adequaterecord")

  assert_equal "adequaterecord", topic1.reload.title
  assert_equal "adequaterecord", topic2.reload.title
  # Testing that the before_update callbacks have run
  assert_equal "David", topic1.reload.author_name
  assert_equal "David", topic2.reload.author_name
end
test_update_on_relation_passing_active_record_object_is_not_permitted() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1505
def test_update_on_relation_passing_active_record_object_is_not_permitted
  topic = Topic.create!(title: "Foo", author_name: nil)
  assert_raises(ArgumentError) do
    Topic.where(id: topic.id).update(topic, title: "Bar")
  end
end
test_where_with_ar_object() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 716
def test_where_with_ar_object
  author = Author.first
  authors = Author.all.where(id: author)
  assert_equal 1, authors.to_a.length
end

Private Instance Methods

custom_post_relation() click to toggle source
# File activerecord/test/cases/relations_test.rb, line 1916
def custom_post_relation
  table_alias = Post.arel_table.alias("omg_posts")
  table_metadata = ActiveRecord::TableMetadata.new(Post, table_alias)
  predicate_builder = ActiveRecord::PredicateBuilder.new(table_metadata)

  ActiveRecord::Relation.create(Post, table_alias, predicate_builder)
end