class RelationTest
Public Instance Methods
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