class ActiveRecord::RelationTest

Public Class Methods

sanitize_sql(args) click to toggle source
# File activerecord/test/cases/relation_test.rb, line 188
def self.sanitize_sql(args)
  raise unless args == ["foo = ?", "bar"]
  "foo = bar"
end

Public Instance Methods

test_bad_constants_raise_errors() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 111
def test_bad_constants_raise_errors
  assert_raises(NameError) do
    ActiveRecord::Relation::HelloWorld
  end
end
test_construction() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 13
def test_construction
  relation = Relation.new(FakeKlass, :b, nil)
  assert_equal FakeKlass, relation.klass
  assert_equal :b, relation.table
  assert !relation.loaded, "relation is not loaded"
end
test_create_with_value() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 86
def test_create_with_value
  relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
  relation.create_with_value = { hello: "world" }
  assert_equal({ "hello" => "world" }, relation.scope_for_create)
end
test_create_with_value_with_wheres() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 92
def test_create_with_value_with_wheres
  relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
  assert_equal({}, relation.scope_for_create)

  relation.where!(id: 10)
  assert_equal({ "id" => 10 }, relation.scope_for_create)

  relation.create_with_value = { hello: "world" }
  assert_equal({ "hello" => "world", "id" => 10 }, relation.scope_for_create)
end
test_eager_load_values() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 122
def test_eager_load_values
  relation = Relation.new(FakeKlass, :b, nil)
  relation.eager_load! :b
  assert relation.eager_loading?
end
test_empty_eager_loading?() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 117
def test_empty_eager_loading?
  relation = Relation.new(FakeKlass, :b, nil)
  assert !relation.eager_loading?
end
test_empty_scope() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 103
def test_empty_scope
  relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
  assert relation.empty_scope?

  relation.merge!(relation)
  assert relation.empty_scope?
end
test_empty_where_values_hash() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 50
def test_empty_where_values_hash
  relation = Relation.new(FakeKlass, :b, nil)
  assert_equal({}, relation.where_values_hash)
end
test_extensions() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 45
def test_extensions
  relation = Relation.new(FakeKlass, :b, nil)
  assert_equal [], relation.extensions
end
test_has_values() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 55
def test_has_values
  relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
  relation.where!(id: 10)
  assert_equal({ "id" => 10 }, relation.where_values_hash)
end
test_initialize_single_values() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 25
def test_initialize_single_values
  relation = Relation.new(FakeKlass, :b, nil)
  (Relation::SINGLE_VALUE_METHODS - [:create_with, :readonly]).each do |method|
    assert_nil relation.send("#{method}_value"), method.to_s
  end
  assert_equal false, relation.readonly_value
  value = relation.create_with_value
  assert_equal({}, value)
  assert_predicate value, :frozen?
end
test_merge_raises_with_invalid_argument() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 242
def test_merge_raises_with_invalid_argument
  assert_raises ArgumentError do
    relation = Relation.new(FakeKlass, :b, nil)
    relation.merge(true)
  end
end
test_merging_readonly_false() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 199
def test_merging_readonly_false
  relation = Relation.new(FakeKlass, :b, nil)
  readonly_false_relation = relation.readonly(false)
  # test merging in both directions
  assert_equal false, relation.merge(readonly_false_relation).readonly_value
  assert_equal false, readonly_false_relation.merge(relation).readonly_value
end
test_multi_value_initialize() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 36
def test_multi_value_initialize
  relation = Relation.new(FakeKlass, :b, nil)
  Relation::MULTI_VALUE_METHODS.each do |method|
    values = relation.send("#{method}_values")
    assert_equal [], values, method.to_s
    assert_predicate values, :frozen?, method.to_s
  end
end
test_references_values() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 128
def test_references_values
  relation = Relation.new(FakeKlass, :b, nil)
  assert_equal [], relation.references_values
  relation = relation.references(:foo).references(:omg, :lol)
  assert_equal ["foo", "omg", "lol"], relation.references_values
end
test_references_values_dont_duplicate() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 135
def test_references_values_dont_duplicate
  relation = Relation.new(FakeKlass, :b, nil)
  relation = relation.references(:foo).references(:foo)
  assert_equal ["foo"], relation.references_values
end
test_relation_merging_with_joins_as_join_dependency_pick_proper_parent() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 232
def test_relation_merging_with_joins_as_join_dependency_pick_proper_parent
  post = Post.create!(title: "haha", body: "huhu")
  comment = post.comments.create!(body: "hu")
  3.times { comment.ratings.create! }

  relation = Post.joins(:comments).merge Comment.joins(:ratings)

  assert_equal 3, relation.where(id: post.id).pluck(:id).size
end
test_relation_merging_with_merged_joins_as_strings() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 275
def test_relation_merging_with_merged_joins_as_strings
  join_string = "LEFT OUTER JOIN #{Rating.quoted_table_name} ON #{SpecialComment.quoted_table_name}.id = #{Rating.quoted_table_name}.comment_id"
  special_comments_with_ratings = SpecialComment.joins join_string
  posts_with_special_comments_with_ratings = Post.group("posts.id").joins(:special_comments).merge(special_comments_with_ratings)
  assert_equal({ 2 => 1, 4 => 3, 5 => 1 }, authors(:david).posts.merge(posts_with_special_comments_with_ratings).count)
end
test_relation_merging_with_merged_joins_as_symbols() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 207
def test_relation_merging_with_merged_joins_as_symbols
  special_comments_with_ratings = SpecialComment.joins(:ratings)
  posts_with_special_comments_with_ratings = Post.group("posts.id").joins(:special_comments).merge(special_comments_with_ratings)
  assert_equal({ 4 => 2 }, authors(:david).posts.merge(posts_with_special_comments_with_ratings).count)
end
test_relation_merging_with_merged_symbol_joins_has_correct_size_and_count() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 221
def test_relation_merging_with_merged_symbol_joins_has_correct_size_and_count
  # Has one entry per comment
  merged_authors_with_commented_posts_relation = Author.joins(:posts).merge(Post.joins(:comments))

  post_ids_with_author = Post.joins(:author).pluck(:id)
  manual_comments_on_post_that_have_author = Comment.where(post_id: post_ids_with_author).pluck(:id)

  assert_equal manual_comments_on_post_that_have_author.size, merged_authors_with_commented_posts_relation.count
  assert_equal manual_comments_on_post_that_have_author.size, merged_authors_with_commented_posts_relation.to_a.size
end
test_relation_merging_with_merged_symbol_joins_keeps_inner_joins() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 213
def test_relation_merging_with_merged_symbol_joins_keeps_inner_joins
  queries = capture_sql { Author.joins(:posts).merge(Post.joins(:comments)).to_a }

  nb_inner_join = queries.sum { |sql| sql.scan(/INNER\s+JOIN/i).size }
  assert_equal 2, nb_inner_join, "Wrong amount of INNER JOIN in query"
  assert queries.none? { |sql| /LEFT\s+(OUTER)?\s+JOIN/i.match?(sql) }, "Shouldn't have any LEFT JOIN in query"
end
test_respond_to_for_non_selected_element() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 249
def test_respond_to_for_non_selected_element
  post = Post.select(:title).first
  assert_equal false, post.respond_to?(:body), "post should not respond_to?(:body) since invoking it raises exception"

  silence_warnings { post = Post.select("'title' as post_title").first }
  assert_equal false, post.respond_to?(:title), "post should not respond_to?(:body) since invoking it raises exception"
end
test_responds_to_model_and_returns_klass() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 20
def test_responds_to_model_and_returns_klass
  relation = Relation.new(FakeKlass, :b, nil)
  assert_equal FakeKlass, relation.model
end
test_scope_for_create() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 81
def test_scope_for_create
  relation = Relation.new(FakeKlass, :b, nil)
  assert_equal({}, relation.scope_for_create)
end
test_select_quotes_when_using_from_clause() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 257
def test_select_quotes_when_using_from_clause
  skip_if_sqlite3_version_includes_quoting_bug
  quoted_join = ActiveRecord::Base.connection.quote_table_name("join")
  selected = Post.select(:join).from(Post.select("id as #{quoted_join}")).map(&:join)
  assert_equal Post.pluck(:id), selected
end
test_selecting_aliased_attribute_quotes_column_name_when_from_is_used() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 264
def test_selecting_aliased_attribute_quotes_column_name_when_from_is_used
  skip_if_sqlite3_version_includes_quoting_bug
  klass = Class.new(ActiveRecord::Base) do
    self.table_name = :test_with_keyword_column_name
    alias_attribute :description, :desc
  end
  klass.create!(description: "foo")

  assert_equal ["foo"], klass.select(:description).from(klass.all).map(&:desc)
end
test_table_name_delegates_to_klass() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 76
def test_table_name_delegates_to_klass
  relation = Relation.new(FakeKlass, :b, Post.predicate_builder)
  assert_equal "posts", relation.table_name
end
test_tree_is_not_traversed() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 67
def test_tree_is_not_traversed
  relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
  left     = relation.table[:id].eq(10)
  right    = relation.table[:id].eq(10)
  combine  = left.and right
  relation.where! combine
  assert_equal({}, relation.where_values_hash)
end
test_update_all_goes_through_normal_type_casting() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 304
def test_update_all_goes_through_normal_type_casting
  UpdateAllTestModel.update_all(body: "value from user", type: nil) # No STI

  assert_equal "type cast from database", UpdateAllTestModel.first.body
end
test_values_wrong_table() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 61
def test_values_wrong_table
  relation = Relation.new(Post, Post.arel_table, Post.predicate_builder)
  relation.where! Comment.arel_table[:id].eq(10)
  assert_equal({}, relation.where_values_hash)
end

Private Instance Methods

skip_if_sqlite3_version_includes_quoting_bug() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 312
      def skip_if_sqlite3_version_includes_quoting_bug
        if sqlite3_version_includes_quoting_bug?
          skip <<-ERROR.squish
            You are using an outdated version of SQLite3 which has a bug in
            quoted column names. Please update SQLite3 and rebuild the sqlite3
            ruby gem
          ERROR
        end
      end
sqlite3_version_includes_quoting_bug?() click to toggle source
# File activerecord/test/cases/relation_test.rb, line 322
def sqlite3_version_includes_quoting_bug?
  if current_adapter?(:SQLite3Adapter)
    selected_quoted_column_names = ActiveRecord::Base.connection.exec_query(
      'SELECT "join" FROM (SELECT id AS "join" FROM posts) subquery'
    ).columns
    ["join"] != selected_quoted_column_names
  end
end