2011-06-06 14:17:44 -04:00
|
|
|
require "cases/helper"
|
2010-11-04 18:48:02 -04:00
|
|
|
require 'models/tag'
|
2009-12-26 16:55:29 -05:00
|
|
|
require 'models/tagging'
|
2009-07-31 15:08:22 -04:00
|
|
|
require 'models/post'
|
|
|
|
require 'models/topic'
|
2009-09-01 14:36:09 -04:00
|
|
|
require 'models/comment'
|
2009-07-31 15:08:22 -04:00
|
|
|
require 'models/author'
|
2009-10-07 10:57:59 -04:00
|
|
|
require 'models/comment'
|
2009-07-31 15:08:22 -04:00
|
|
|
require 'models/entrant'
|
|
|
|
require 'models/developer'
|
2012-02-12 03:05:50 -05:00
|
|
|
require 'models/reply'
|
2009-07-31 15:08:22 -04:00
|
|
|
require 'models/company'
|
2010-01-02 13:46:14 -05:00
|
|
|
require 'models/bird'
|
2010-08-03 17:26:59 -04:00
|
|
|
require 'models/car'
|
|
|
|
require 'models/engine'
|
|
|
|
require 'models/tyre'
|
2010-11-23 14:58:10 -05:00
|
|
|
require 'models/minivan'
|
2010-08-03 17:26:59 -04:00
|
|
|
|
2012-01-13 18:42:07 -05:00
|
|
|
|
2009-08-18 07:12:35 -04:00
|
|
|
class RelationTest < ActiveRecord::TestCase
|
2009-12-26 16:55:29 -05:00
|
|
|
fixtures :authors, :topics, :entrants, :developers, :companies, :developers_projects, :accounts, :categories, :categorizations, :posts, :comments,
|
2010-11-23 14:58:10 -05:00
|
|
|
:tags, :taggings, :cars, :minivans
|
|
|
|
|
|
|
|
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
|
2010-08-03 17:26:59 -04:00
|
|
|
|
2010-12-31 07:48:48 -05:00
|
|
|
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
|
|
|
|
|
2010-10-12 17:45:30 -04:00
|
|
|
def test_bind_values
|
|
|
|
relation = Post.scoped
|
|
|
|
assert_equal [], relation.bind_values
|
|
|
|
|
|
|
|
relation2 = relation.bind 'foo'
|
|
|
|
assert_equal %w{ foo }, relation2.bind_values
|
|
|
|
assert_equal [], relation.bind_values
|
|
|
|
end
|
|
|
|
|
2010-11-24 03:17:49 -05:00
|
|
|
def test_two_scopes_with_includes_should_not_drop_any_include
|
2010-08-03 17:26:59 -04:00
|
|
|
car = Car.incl_engines.incl_tyres.first
|
2010-08-14 01:13:00 -04:00
|
|
|
assert_no_queries { car.tyres.length }
|
|
|
|
assert_no_queries { car.engines.length }
|
2010-08-03 17:26:59 -04:00
|
|
|
end
|
2009-07-31 15:08:22 -04:00
|
|
|
|
2010-09-27 19:51:12 -04:00
|
|
|
def test_dynamic_finder
|
|
|
|
x = Post.where('author_id = ?', 1)
|
|
|
|
assert x.klass.respond_to?(:find_by_id), '@klass should handle dynamic finders'
|
|
|
|
end
|
|
|
|
|
2010-07-30 17:12:01 -04:00
|
|
|
def test_multivalue_where
|
|
|
|
posts = Post.where('author_id = ? AND id = ?', 1, 1)
|
|
|
|
assert_equal 1, posts.to_a.size
|
|
|
|
end
|
|
|
|
|
2009-12-25 15:01:11 -05:00
|
|
|
def test_scoped
|
|
|
|
topics = Topic.scoped
|
|
|
|
assert_kind_of ActiveRecord::Relation, topics
|
|
|
|
assert_equal 4, topics.size
|
|
|
|
end
|
|
|
|
|
2010-06-23 10:05:30 -04:00
|
|
|
def test_to_json
|
|
|
|
assert_nothing_raised { Bird.scoped.to_json }
|
|
|
|
assert_nothing_raised { Bird.scoped.all.to_json }
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_to_yaml
|
|
|
|
assert_nothing_raised { Bird.scoped.to_yaml }
|
|
|
|
assert_nothing_raised { Bird.scoped.all.to_yaml }
|
|
|
|
end
|
|
|
|
|
2010-06-23 11:54:38 -04:00
|
|
|
def test_to_xml
|
|
|
|
assert_nothing_raised { Bird.scoped.to_xml }
|
|
|
|
assert_nothing_raised { Bird.scoped.all.to_xml }
|
|
|
|
end
|
|
|
|
|
2009-12-26 02:09:44 -05:00
|
|
|
def test_scoped_all
|
|
|
|
topics = Topic.scoped.all
|
|
|
|
assert_kind_of Array, topics
|
|
|
|
assert_no_queries { assert_equal 4, topics.size }
|
|
|
|
end
|
|
|
|
|
2009-12-26 04:37:00 -05:00
|
|
|
def test_loaded_all
|
|
|
|
topics = Topic.scoped
|
|
|
|
|
|
|
|
assert_queries(1) do
|
|
|
|
2.times { assert_equal 4, topics.all.size }
|
|
|
|
end
|
|
|
|
|
|
|
|
assert topics.loaded?
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_scoped_first
|
2009-12-27 16:20:04 -05:00
|
|
|
topics = Topic.scoped.order('id ASC')
|
2009-12-26 04:37:00 -05:00
|
|
|
|
|
|
|
assert_queries(1) do
|
|
|
|
2.times { assert_equal "The First Topic", topics.first.title }
|
|
|
|
end
|
|
|
|
|
|
|
|
assert ! topics.loaded?
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_loaded_first
|
2009-12-27 16:20:04 -05:00
|
|
|
topics = Topic.scoped.order('id ASC')
|
2009-12-26 04:37:00 -05:00
|
|
|
|
|
|
|
assert_queries(1) do
|
|
|
|
topics.all # force load
|
|
|
|
2.times { assert_equal "The First Topic", topics.first.title }
|
|
|
|
end
|
|
|
|
|
|
|
|
assert topics.loaded?
|
|
|
|
end
|
|
|
|
|
2009-12-26 04:58:23 -05:00
|
|
|
def test_reload
|
|
|
|
topics = Topic.scoped
|
|
|
|
|
|
|
|
assert_queries(1) do
|
|
|
|
2.times { topics.to_a }
|
|
|
|
end
|
|
|
|
|
|
|
|
assert topics.loaded?
|
|
|
|
|
2010-01-16 17:55:59 -05:00
|
|
|
original_size = topics.to_a.size
|
|
|
|
Topic.create! :title => 'fake'
|
2009-12-26 04:58:23 -05:00
|
|
|
|
2010-01-16 17:55:59 -05:00
|
|
|
assert_queries(1) { topics.reload }
|
|
|
|
assert_equal original_size + 1, topics.size
|
|
|
|
assert topics.loaded?
|
2009-12-26 04:58:23 -05:00
|
|
|
end
|
|
|
|
|
2012-05-20 15:11:32 -04:00
|
|
|
def test_finding_with_subquery
|
2012-04-29 14:17:57 -04:00
|
|
|
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
|
|
|
|
|
2009-07-31 15:08:22 -04:00
|
|
|
def test_finding_with_conditions
|
2009-12-25 17:20:57 -05:00
|
|
|
assert_equal ["David"], Author.where(:name => 'David').map(&:name)
|
|
|
|
assert_equal ['Mary'], Author.where(["name = ?", 'Mary']).map(&:name)
|
2009-12-26 02:27:34 -05:00
|
|
|
assert_equal ['Mary'], Author.where("name = ?", 'Mary').map(&:name)
|
2009-07-31 15:08:22 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_finding_with_order
|
2009-12-25 16:23:10 -05:00
|
|
|
topics = Topic.order('id')
|
2009-12-29 01:45:28 -05:00
|
|
|
assert_equal 4, topics.to_a.size
|
2009-07-31 15:08:22 -04:00
|
|
|
assert_equal topics(:first).title, topics.first.title
|
|
|
|
end
|
|
|
|
|
2011-06-20 14:15:19 -04:00
|
|
|
|
|
|
|
def test_finding_with_arel_order
|
|
|
|
topics = Topic.order(Topic.arel_table[:id].asc)
|
|
|
|
assert_equal 4, topics.to_a.size
|
|
|
|
assert_equal topics(:first).title, topics.first.title
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_finding_last_with_arel_order
|
|
|
|
topics = Topic.order(Topic.arel_table[:id].asc)
|
|
|
|
assert_equal topics(:fourth).title, topics.last.title
|
|
|
|
end
|
|
|
|
|
2010-06-25 18:22:45 -04:00
|
|
|
def test_finding_with_order_concatenated
|
|
|
|
topics = Topic.order('author_name').order('title')
|
|
|
|
assert_equal 4, topics.to_a.size
|
|
|
|
assert_equal topics(:fourth).title, topics.first.title
|
|
|
|
end
|
|
|
|
|
2011-03-28 09:19:41 -04:00
|
|
|
def test_finding_with_reorder
|
|
|
|
topics = Topic.order('author_name').order('title').reorder('id').all
|
|
|
|
topics_titles = topics.map{ |t| t.title }
|
|
|
|
assert_equal ['The First Topic', 'The Second Topic of the day', 'The Third Topic of the day', 'The Fourth Topic of the day'], topics_titles
|
|
|
|
end
|
2010-06-25 18:22:45 -04:00
|
|
|
|
2009-07-31 15:08:22 -04:00
|
|
|
def test_finding_with_order_and_take
|
2009-12-25 16:23:10 -05:00
|
|
|
entrants = Entrant.order("id ASC").limit(2).to_a
|
2009-07-31 15:08:22 -04:00
|
|
|
|
2009-12-25 16:40:55 -05:00
|
|
|
assert_equal 2, entrants.size
|
|
|
|
assert_equal entrants(:first).name, entrants.first.name
|
2009-07-31 15:08:22 -04:00
|
|
|
end
|
|
|
|
|
2011-06-23 21:32:22 -04:00
|
|
|
def test_finding_with_cross_table_order_and_limit
|
2012-01-13 18:42:07 -05:00
|
|
|
tags = Tag.includes(:taggings).
|
2011-06-28 16:04:42 -04:00
|
|
|
order("tags.name asc", "taggings.taggable_id asc", "REPLACE('abc', taggings.taggable_type, taggings.taggable_type)").
|
|
|
|
limit(1).to_a
|
2011-06-23 21:32:22 -04:00
|
|
|
assert_equal 1, tags.length
|
|
|
|
end
|
|
|
|
|
2010-11-04 18:48:02 -04:00
|
|
|
def test_finding_with_complex_order_and_limit
|
2012-01-16 16:14:34 -05:00
|
|
|
tags = Tag.includes(:taggings).references(:taggings).order("REPLACE('abc', taggings.taggable_type, taggings.taggable_type)").limit(1).to_a
|
2010-11-04 18:48:02 -04:00
|
|
|
assert_equal 1, tags.length
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_finding_with_complex_order
|
2012-01-16 16:14:34 -05:00
|
|
|
tags = Tag.includes(:taggings).references(:taggings).order("REPLACE('abc', taggings.taggable_type, taggings.taggable_type)").to_a
|
2010-11-08 06:02:26 -05:00
|
|
|
assert_equal 3, tags.length
|
2010-11-04 18:48:02 -04:00
|
|
|
end
|
|
|
|
|
2009-07-31 15:08:22 -04:00
|
|
|
def test_finding_with_order_limit_and_offset
|
2009-12-25 16:23:10 -05:00
|
|
|
entrants = Entrant.order("id ASC").limit(2).offset(1)
|
2009-07-31 15:08:22 -04:00
|
|
|
|
2009-12-29 01:45:28 -05:00
|
|
|
assert_equal 2, entrants.to_a.size
|
2009-12-25 16:40:55 -05:00
|
|
|
assert_equal entrants(:second).name, entrants.first.name
|
2009-07-31 15:08:22 -04:00
|
|
|
|
2009-12-25 16:23:10 -05:00
|
|
|
entrants = Entrant.order("id ASC").limit(2).offset(2)
|
2009-12-29 01:45:28 -05:00
|
|
|
assert_equal 1, entrants.to_a.size
|
2009-12-25 16:40:55 -05:00
|
|
|
assert_equal entrants(:third).name, entrants.first.name
|
2009-07-31 15:08:22 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_finding_with_group
|
2009-12-25 16:23:10 -05:00
|
|
|
developers = Developer.group("salary").select("salary").to_a
|
2009-07-31 15:08:22 -04:00
|
|
|
assert_equal 4, developers.size
|
|
|
|
assert_equal 4, developers.map(&:salary).uniq.size
|
|
|
|
end
|
|
|
|
|
2010-06-02 09:42:25 -04:00
|
|
|
def test_select_with_block
|
|
|
|
even_ids = Developer.scoped.select {|d| d.id % 2 == 0 }.map(&:id)
|
2010-06-07 19:56:26 -04:00
|
|
|
assert_equal [2, 4, 6, 8, 10], even_ids.sort
|
2010-06-02 09:42:25 -04:00
|
|
|
end
|
|
|
|
|
2012-01-30 15:36:47 -05:00
|
|
|
def test_none
|
|
|
|
assert_no_queries do
|
|
|
|
assert_equal [], Developer.none
|
|
|
|
assert_equal [], Developer.scoped.none
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_none_chainable
|
|
|
|
assert_no_queries do
|
|
|
|
assert_equal [], Developer.none.where(:name => 'David')
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2012-05-31 03:31:35 -04:00
|
|
|
def test_none_chainable_to_existing_scope_extension_method
|
|
|
|
assert_no_queries do
|
|
|
|
assert_equal 1, Topic.anonymous_extension.none.one
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2012-04-11 09:24:23 -04:00
|
|
|
def test_none_chained_to_methods_firing_queries_straight_to_db
|
|
|
|
assert_no_queries do
|
|
|
|
assert_equal [], Developer.none.pluck(:id) # => uses select_all
|
|
|
|
assert_equal 0, Developer.none.delete_all
|
|
|
|
assert_equal 0, Developer.none.update_all(:name => 'David')
|
|
|
|
assert_equal 0, Developer.none.delete(1)
|
|
|
|
assert_equal false, Developer.none.exists?(1)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_null_relation_content_size_methods
|
|
|
|
assert_no_queries do
|
|
|
|
assert_equal 0, Developer.none.size
|
|
|
|
assert_equal 0, Developer.none.count
|
|
|
|
assert_equal true, Developer.none.empty?
|
|
|
|
assert_equal false, Developer.none.any?
|
|
|
|
assert_equal false, Developer.none.many?
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_null_relation_calculations_methods
|
|
|
|
assert_no_queries do
|
|
|
|
assert_equal 0, Developer.none.count
|
|
|
|
assert_equal nil, Developer.none.calculate(:average, 'salary')
|
|
|
|
end
|
|
|
|
end
|
2012-05-05 11:07:20 -04:00
|
|
|
|
2012-04-11 09:24:23 -04:00
|
|
|
def test_null_relation_metadata_methods
|
|
|
|
assert_equal "", Developer.none.to_sql
|
|
|
|
assert_equal({}, Developer.none.where_values_hash)
|
|
|
|
end
|
|
|
|
|
2010-12-16 16:20:42 -05:00
|
|
|
def test_joins_with_nil_argument
|
|
|
|
assert_nothing_raised { DependentFirm.joins(nil).first }
|
|
|
|
end
|
|
|
|
|
2009-07-31 15:08:22 -04:00
|
|
|
def test_finding_with_hash_conditions_on_joined_table
|
2009-12-25 17:20:57 -05:00
|
|
|
firms = DependentFirm.joins(:account).where({:name => 'RailsCore', :accounts => { :credit_limit => 55..60 }}).to_a
|
2009-07-31 15:08:22 -04:00
|
|
|
assert_equal 1, firms.size
|
|
|
|
assert_equal companies(:rails_core), firms.first
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_find_all_with_join
|
2009-12-25 16:23:10 -05:00
|
|
|
developers_on_project_one = Developer.joins('LEFT JOIN developers_projects ON developers.id = developers_projects.developer_id').
|
2009-12-25 17:20:57 -05:00
|
|
|
where('project_id=1').to_a
|
2009-07-31 15:08:22 -04:00
|
|
|
|
|
|
|
assert_equal 3, developers_on_project_one.length
|
|
|
|
developer_names = developers_on_project_one.map { |d| d.name }
|
|
|
|
assert developer_names.include?('David')
|
|
|
|
assert developer_names.include?('Jamis')
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_find_on_hash_conditions
|
2012-04-27 07:37:21 -04:00
|
|
|
assert_equal Topic.scoped(:where => {:approved => false}).all, Topic.where({ :approved => false }).to_a
|
2009-07-31 15:08:22 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_joins_with_string_array
|
2009-12-25 16:23:10 -05:00
|
|
|
person_with_reader_and_post = Post.joins([
|
2009-07-31 15:08:22 -04:00
|
|
|
"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
|
2009-08-18 15:35:33 -04:00
|
|
|
|
2009-12-25 16:23:10 -05:00
|
|
|
def test_scoped_responds_to_delegated_methods
|
|
|
|
relation = Topic.scoped
|
2009-08-18 15:35:33 -04:00
|
|
|
|
|
|
|
["map", "uniq", "sort", "insert", "delete", "update"].each do |method|
|
2010-05-19 15:14:51 -04:00
|
|
|
assert_respond_to relation, method, "Topic.scoped should respond to #{method.inspect}"
|
2009-12-29 01:57:40 -05:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2010-08-06 18:23:11 -04:00
|
|
|
def test_respond_to_delegates_to_relation
|
|
|
|
relation = Topic.scoped
|
|
|
|
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
|
|
|
|
|
|
|
|
fake_arel.responds = []
|
|
|
|
relation.respond_to?(:matching_attributes, true)
|
|
|
|
assert_equal [:matching_attributes, true], fake_arel.responds.first
|
|
|
|
end
|
|
|
|
|
2009-12-29 01:57:40 -05:00
|
|
|
def test_respond_to_dynamic_finders
|
|
|
|
relation = Topic.scoped
|
|
|
|
|
|
|
|
["find_by_title", "find_by_title_and_author_name", "find_or_create_by_title", "find_or_initialize_by_title_and_author_name"].each do |method|
|
2010-05-19 15:14:51 -04:00
|
|
|
assert_respond_to relation, method, "Topic.scoped should respond to #{method.inspect}"
|
2009-08-18 15:35:33 -04:00
|
|
|
end
|
|
|
|
end
|
2009-08-27 19:03:46 -04:00
|
|
|
|
2010-11-24 03:17:49 -05:00
|
|
|
def test_respond_to_class_methods_and_scopes
|
2010-01-22 09:44:37 -05:00
|
|
|
assert Topic.scoped.respond_to?(:by_lifo)
|
|
|
|
end
|
|
|
|
|
2009-08-27 19:03:46 -04:00
|
|
|
def test_find_with_readonly_option
|
2009-12-25 16:23:10 -05:00
|
|
|
Developer.scoped.each { |d| assert !d.readonly? }
|
|
|
|
Developer.scoped.readonly.each { |d| assert d.readonly? }
|
2009-08-27 19:03:46 -04:00
|
|
|
end
|
2009-09-01 14:36:09 -04:00
|
|
|
|
|
|
|
def test_eager_association_loading_of_stis_with_multiple_references
|
2009-12-25 16:23:10 -05:00
|
|
|
authors = Author.eager_load(:posts => { :special_comments => { :post => [ :special_comments, :very_special_comment ] } }).
|
2009-12-25 17:20:57 -05:00
|
|
|
order('comments.body, very_special_comments_posts.body').where('posts.id = 4').to_a
|
2009-12-25 16:23:10 -05:00
|
|
|
|
2009-09-01 14:36:09 -04:00
|
|
|
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
|
|
|
|
|
2010-01-02 16:54:28 -05:00
|
|
|
def test_find_with_preloaded_associations
|
2009-09-01 14:36:09 -04:00
|
|
|
assert_queries(2) do
|
2010-10-19 14:33:25 -04:00
|
|
|
posts = Post.preload(:comments).order('posts.id')
|
2009-12-26 04:10:45 -05:00
|
|
|
assert posts.first.comments.first
|
2009-09-01 14:36:09 -04:00
|
|
|
end
|
2009-12-25 16:23:10 -05:00
|
|
|
|
2012-03-01 22:10:06 -05:00
|
|
|
assert_queries(2) do
|
2011-03-18 19:14:45 -04:00
|
|
|
posts = Post.preload(:comments).order('posts.id')
|
2009-12-26 04:10:45 -05:00
|
|
|
assert posts.first.comments.first
|
2009-09-01 14:36:09 -04:00
|
|
|
end
|
2009-12-25 16:23:10 -05:00
|
|
|
|
2009-09-01 14:36:09 -04:00
|
|
|
assert_queries(2) do
|
2010-10-19 14:33:25 -04:00
|
|
|
posts = Post.preload(:author).order('posts.id')
|
2009-12-26 04:10:45 -05:00
|
|
|
assert posts.first.author
|
2009-09-01 14:36:09 -04:00
|
|
|
end
|
2009-12-25 16:23:10 -05:00
|
|
|
|
2012-03-01 22:10:06 -05:00
|
|
|
assert_queries(2) do
|
2011-03-18 19:14:45 -04:00
|
|
|
posts = Post.preload(:author).order('posts.id')
|
2009-12-26 04:10:45 -05:00
|
|
|
assert posts.first.author
|
|
|
|
end
|
|
|
|
|
2012-03-01 22:10:06 -05:00
|
|
|
assert_queries(3) do
|
2011-03-18 19:14:45 -04:00
|
|
|
posts = Post.preload(:author, :comments).order('posts.id')
|
2009-12-26 04:10:45 -05:00
|
|
|
assert posts.first.author
|
2010-01-02 16:54:28 -05:00
|
|
|
assert posts.first.comments.first
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_find_with_included_associations
|
|
|
|
assert_queries(2) do
|
2010-10-19 14:33:25 -04:00
|
|
|
posts = Post.includes(:comments).order('posts.id')
|
2010-01-02 16:54:28 -05:00
|
|
|
assert posts.first.comments.first
|
|
|
|
end
|
|
|
|
|
2012-03-01 22:10:06 -05:00
|
|
|
assert_queries(2) do
|
2011-03-18 19:14:45 -04:00
|
|
|
posts = Post.scoped.includes(:comments).order('posts.id')
|
2010-01-02 16:54:28 -05:00
|
|
|
assert posts.first.comments.first
|
|
|
|
end
|
|
|
|
|
|
|
|
assert_queries(2) do
|
2010-10-19 14:33:25 -04:00
|
|
|
posts = Post.includes(:author).order('posts.id')
|
2010-01-02 16:54:28 -05:00
|
|
|
assert posts.first.author
|
|
|
|
end
|
|
|
|
|
2012-03-01 22:10:06 -05:00
|
|
|
assert_queries(3) do
|
2011-03-18 19:14:45 -04:00
|
|
|
posts = Post.includes(:author, :comments).order('posts.id')
|
2010-01-02 16:54:28 -05:00
|
|
|
assert posts.first.author
|
2009-12-26 04:10:45 -05:00
|
|
|
assert posts.first.comments.first
|
2009-09-01 14:36:09 -04:00
|
|
|
end
|
|
|
|
end
|
2009-10-05 13:39:20 -04:00
|
|
|
|
2009-12-26 04:37:00 -05:00
|
|
|
def test_default_scope_with_conditions_string
|
2012-05-18 09:46:54 -04:00
|
|
|
assert_equal Developer.where(name: 'David').map(&:id).sort, DeveloperCalledDavid.scoped.map(&:id).sort
|
2010-05-19 15:14:51 -04:00
|
|
|
assert_nil DeveloperCalledDavid.create!.name
|
2009-10-05 13:39:20 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_default_scope_with_conditions_hash
|
2012-05-18 09:46:54 -04:00
|
|
|
assert_equal Developer.where(name: 'Jamis').map(&:id).sort, DeveloperCalledJamis.scoped.map(&:id).sort
|
2009-10-05 13:39:20 -04:00
|
|
|
assert_equal 'Jamis', DeveloperCalledJamis.create!.name
|
|
|
|
end
|
|
|
|
|
2009-12-26 08:45:05 -05:00
|
|
|
def test_default_scoping_finder_methods
|
|
|
|
developers = DeveloperCalledDavid.order('id').map(&:id).sort
|
2012-05-18 09:46:54 -04:00
|
|
|
assert_equal Developer.where(name: 'David').map(&:id).sort, developers
|
2009-12-26 08:45:05 -05:00
|
|
|
end
|
|
|
|
|
2009-12-25 16:23:10 -05:00
|
|
|
def test_loading_with_one_association
|
|
|
|
posts = Post.preload(:comments)
|
2009-10-07 10:57:59 -04:00
|
|
|
post = posts.find { |p| p.id == 1 }
|
|
|
|
assert_equal 2, post.comments.size
|
|
|
|
assert post.comments.include?(comments(:greetings))
|
|
|
|
|
2009-12-25 17:20:57 -05:00
|
|
|
post = Post.where("posts.title = 'Welcome to the weblog'").preload(:comments).first
|
2009-10-07 10:57:59 -04:00
|
|
|
assert_equal 2, post.comments.size
|
|
|
|
assert post.comments.include?(comments(:greetings))
|
|
|
|
|
2009-12-25 16:23:10 -05:00
|
|
|
posts = Post.preload(:last_comment)
|
2009-10-07 10:57:59 -04:00
|
|
|
post = posts.find { |p| p.id == 1 }
|
|
|
|
assert_equal Post.find(1).last_comment, post.last_comment
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_loading_with_one_association_with_non_preload
|
2009-12-25 16:23:10 -05:00
|
|
|
posts = Post.eager_load(:last_comment).order('comments.id DESC')
|
2009-10-07 10:57:59 -04:00
|
|
|
post = posts.find { |p| p.id == 1 }
|
|
|
|
assert_equal Post.find(1).last_comment, post.last_comment
|
|
|
|
end
|
2009-12-26 16:55:29 -05:00
|
|
|
|
|
|
|
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 { |t| t.id }
|
|
|
|
end
|
|
|
|
|
|
|
|
authors = Author.scoped
|
|
|
|
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
|
|
|
|
|
|
|
|
def test_dynamic_find_by_attributes_bang
|
|
|
|
author = Author.scoped.find_by_id!(authors(:david).id)
|
|
|
|
assert_equal "David", author.name
|
|
|
|
|
2009-12-27 16:20:04 -05:00
|
|
|
assert_raises(ActiveRecord::RecordNotFound) { Author.scoped.find_by_id_and_name!(20, 'invalid') }
|
2009-12-26 16:55:29 -05:00
|
|
|
end
|
|
|
|
|
2009-12-27 05:44:04 -05:00
|
|
|
def test_find_id
|
|
|
|
authors = Author.scoped
|
|
|
|
|
|
|
|
david = authors.find(authors(:david).id)
|
|
|
|
assert_equal 'David', david.name
|
|
|
|
|
2009-12-27 16:20:04 -05:00
|
|
|
assert_raises(ActiveRecord::RecordNotFound) { authors.where(:name => 'lifo').find('42') }
|
2009-12-27 05:44:04 -05:00
|
|
|
end
|
2009-07-31 15:08:22 -04:00
|
|
|
|
2009-12-27 05:44:04 -05:00
|
|
|
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])
|
|
|
|
|
2009-12-27 16:20:04 -05:00
|
|
|
assert_raises(ActiveRecord::RecordNotFound) { authors.where(:name => 'lifo').find(authors(:david).id, '42') }
|
|
|
|
assert_raises(ActiveRecord::RecordNotFound) { authors.find(['42', 43]) }
|
2009-12-27 05:44:04 -05:00
|
|
|
end
|
|
|
|
|
2010-01-18 02:25:23 -05:00
|
|
|
def test_find_in_empty_array
|
|
|
|
authors = Author.scoped.where(:id => [])
|
2010-08-16 21:29:57 -04:00
|
|
|
assert_blank authors.all
|
2010-01-18 02:25:23 -05:00
|
|
|
end
|
|
|
|
|
2010-11-15 17:35:28 -05:00
|
|
|
def test_where_with_ar_object
|
|
|
|
author = Author.first
|
|
|
|
authors = Author.scoped.where(:id => author)
|
|
|
|
assert_equal 1, authors.all.length
|
|
|
|
end
|
|
|
|
|
2010-11-15 18:30:05 -05:00
|
|
|
def test_find_with_list_of_ar
|
|
|
|
author = Author.first
|
|
|
|
authors = Author.find([author])
|
|
|
|
assert_equal author, authors.first
|
|
|
|
end
|
|
|
|
|
2010-11-15 23:24:58 -05:00
|
|
|
class Mary < Author; end
|
|
|
|
|
|
|
|
def test_find_by_classname
|
|
|
|
Author.create!(:name => Mary.name)
|
|
|
|
assert_equal 1, Author.where(:name => Mary).size
|
|
|
|
end
|
|
|
|
|
2010-11-15 18:30:05 -05:00
|
|
|
def test_find_by_id_with_list_of_ar
|
|
|
|
author = Author.first
|
|
|
|
authors = Author.find_by_id([author])
|
|
|
|
assert_equal author, authors
|
|
|
|
end
|
|
|
|
|
2010-05-15 16:43:35 -04:00
|
|
|
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)
|
2011-02-16 18:11:48 -05:00
|
|
|
assert_equal [], relation.all
|
2010-05-15 16:43:35 -04:00
|
|
|
end
|
|
|
|
|
2011-02-16 18:11:48 -05:00
|
|
|
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
|
|
|
|
|
|
|
|
def test_find_all_with_multiple_should_use_and
|
2010-11-18 16:39:21 -05:00
|
|
|
david = authors(:david)
|
|
|
|
relation = [
|
|
|
|
{ :name => david.name },
|
|
|
|
{ :name => 'Santiago' },
|
|
|
|
{ :name => 'tenderlove' },
|
|
|
|
].inject(Author.unscoped) do |memo, param|
|
|
|
|
memo.where(param)
|
|
|
|
end
|
2011-02-16 18:11:48 -05:00
|
|
|
assert_equal [], relation.all
|
2010-11-18 16:39:21 -05:00
|
|
|
end
|
2011-02-16 14:08:01 -05:00
|
|
|
|
2011-02-11 03:39:58 -05:00
|
|
|
def test_find_all_using_where_with_relation
|
|
|
|
david = authors(:david)
|
|
|
|
# switching the lines below would succeed in current rails
|
|
|
|
# assert_queries(2) {
|
|
|
|
assert_queries(1) {
|
|
|
|
relation = Author.where(:id => Author.where(:id => david.id))
|
|
|
|
assert_equal [david], relation.all
|
|
|
|
}
|
|
|
|
end
|
|
|
|
|
2011-08-20 13:00:26 -04:00
|
|
|
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 rails
|
|
|
|
# assert_queries(2) {
|
|
|
|
assert_queries(1) {
|
|
|
|
relation = Minivan.where(:minivan_id => Minivan.where(:name => cool_first.name))
|
|
|
|
assert_equal [cool_first], relation.all
|
|
|
|
}
|
|
|
|
end
|
|
|
|
|
2011-08-20 13:16:39 -04:00
|
|
|
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.all
|
|
|
|
}
|
|
|
|
|
|
|
|
assert_equal 0, subquery.select_values.size
|
|
|
|
end
|
|
|
|
|
2011-02-11 03:39:58 -05:00
|
|
|
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.all
|
|
|
|
}
|
|
|
|
end
|
|
|
|
|
2011-02-16 14:08:01 -05:00
|
|
|
|
2011-02-11 03:39:58 -05:00
|
|
|
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.all
|
|
|
|
}
|
2010-11-18 16:39:21 -05:00
|
|
|
end
|
|
|
|
|
2009-12-27 07:30:49 -05:00
|
|
|
def test_exists
|
|
|
|
davids = Author.where(:name => 'David')
|
|
|
|
assert davids.exists?
|
|
|
|
assert davids.exists?(authors(:david).id)
|
|
|
|
assert ! davids.exists?(authors(:mary).id)
|
2009-12-27 16:20:04 -05:00
|
|
|
assert ! davids.exists?("42")
|
|
|
|
assert ! davids.exists?(42)
|
2012-05-10 18:16:40 -04:00
|
|
|
assert ! davids.exists?(davids.new)
|
2009-12-27 07:30:49 -05:00
|
|
|
|
|
|
|
fake = Author.where(:name => 'fake author')
|
|
|
|
assert ! fake.exists?
|
|
|
|
assert ! fake.exists?(authors(:david).id)
|
|
|
|
end
|
2009-12-27 08:34:30 -05:00
|
|
|
|
|
|
|
def test_last
|
|
|
|
authors = Author.scoped
|
2010-10-03 06:56:32 -04:00
|
|
|
assert_equal authors(:bob), authors.last
|
2009-12-27 08:34:30 -05:00
|
|
|
end
|
|
|
|
|
2009-12-27 09:05:55 -05:00
|
|
|
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
|
|
|
|
|
2009-12-29 01:06:40 -05:00
|
|
|
def test_delete_all
|
|
|
|
davids = Author.where(:name => 'David')
|
|
|
|
|
|
|
|
assert_difference('Author.count', -1) { davids.delete_all }
|
|
|
|
assert ! davids.loaded?
|
|
|
|
end
|
|
|
|
|
|
|
|
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
|
|
|
|
|
2012-04-30 11:49:20 -04:00
|
|
|
def test_delete_all_limit_error
|
|
|
|
assert_raises(ActiveRecord::ActiveRecordError) { Author.limit(10).delete_all }
|
|
|
|
end
|
|
|
|
|
2010-09-07 13:48:14 -04:00
|
|
|
def test_select_argument_error
|
|
|
|
assert_raises(ArgumentError) { Developer.select }
|
|
|
|
end
|
|
|
|
|
2009-12-27 14:38:34 -05:00
|
|
|
def test_relation_merging
|
2011-02-10 14:03:25 -05:00
|
|
|
devs = Developer.where("salary >= 80000").merge(Developer.limit(2)).merge(Developer.order('id ASC').where("id < 3"))
|
2009-12-27 14:38:34 -05:00
|
|
|
assert_equal [developers(:david), developers(:jamis)], devs.to_a
|
|
|
|
|
2011-02-10 14:03:25 -05:00
|
|
|
dev_with_count = Developer.limit(1).merge(Developer.order('id DESC')).merge(Developer.select('developers.*'))
|
2009-12-27 14:38:34 -05:00
|
|
|
assert_equal [developers(:poor_jamis)], dev_with_count.to_a
|
2009-12-27 15:03:20 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_relation_merging_with_eager_load
|
|
|
|
relations = []
|
2011-02-10 14:03:25 -05:00
|
|
|
relations << Post.order('comments.id DESC').merge(Post.eager_load(:last_comment)).merge(Post.scoped)
|
|
|
|
relations << Post.eager_load(:last_comment).merge(Post.order('comments.id DESC')).merge(Post.scoped)
|
2009-12-29 14:42:38 -05:00
|
|
|
|
2009-12-27 15:03:20 -05:00
|
|
|
relations.each do |posts|
|
|
|
|
post = posts.find { |p| p.id == 1 }
|
|
|
|
assert_equal Post.find(1).last_comment, post.last_comment
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2010-01-03 10:54:09 -05:00
|
|
|
def test_relation_merging_with_locks
|
2011-02-10 14:03:25 -05:00
|
|
|
devs = Developer.lock.where("salary >= 80000").order("id DESC").merge(Developer.limit(2))
|
2010-08-16 21:29:57 -04:00
|
|
|
assert_present devs.locked
|
2010-01-03 10:54:09 -05:00
|
|
|
end
|
|
|
|
|
2009-12-27 15:03:20 -05:00
|
|
|
def test_relation_merging_with_preload
|
2012-03-01 22:10:06 -05:00
|
|
|
[Post.scoped.merge(Post.preload(:author)), Post.preload(:author).merge(Post.scoped)].each do |posts|
|
|
|
|
assert_queries(2) { assert posts.first.author }
|
2010-08-28 12:47:39 -04:00
|
|
|
end
|
2009-12-27 14:38:34 -05:00
|
|
|
end
|
2009-12-28 03:54:52 -05:00
|
|
|
|
2010-10-30 15:26:38 -04:00
|
|
|
def test_relation_merging_with_joins
|
2011-02-10 14:03:25 -05:00
|
|
|
comments = Comment.joins(:post).where(:body => 'Thank you for the welcome').merge(Post.where(:body => 'Such a lovely day'))
|
2010-10-30 15:26:38 -04:00
|
|
|
assert_equal 1, comments.count
|
|
|
|
end
|
|
|
|
|
2012-03-28 23:10:25 -04:00
|
|
|
def test_relation_merging_with_association
|
|
|
|
assert_queries(2) do # one for loading post, and another one merged query
|
|
|
|
post = Post.where(:body => 'Such a lovely day').first
|
|
|
|
comments = Comment.where(:body => 'Thank you for the welcome').merge(post.comments)
|
|
|
|
assert_equal 1, comments.count
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2009-12-28 08:08:28 -05:00
|
|
|
def test_count
|
|
|
|
posts = Post.scoped
|
|
|
|
|
2010-10-18 19:27:40 -04:00
|
|
|
assert_equal 11, posts.count
|
|
|
|
assert_equal 11, posts.count(:all)
|
|
|
|
assert_equal 11, posts.count(:id)
|
2009-12-28 08:08:28 -05:00
|
|
|
|
|
|
|
assert_equal 1, posts.where('comments_count > 1').count
|
2010-10-18 19:27:40 -04:00
|
|
|
assert_equal 9, posts.where(:comments_count => 0).count
|
2009-12-28 08:08:28 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_count_with_distinct
|
|
|
|
posts = Post.scoped
|
|
|
|
|
|
|
|
assert_equal 3, posts.count(:comments_count, :distinct => true)
|
2010-10-18 19:27:40 -04:00
|
|
|
assert_equal 11, posts.count(:comments_count, :distinct => false)
|
2009-12-28 08:08:28 -05:00
|
|
|
|
|
|
|
assert_equal 3, posts.select(:comments_count).count(:distinct => true)
|
2010-10-18 19:27:40 -04:00
|
|
|
assert_equal 11, posts.select(:comments_count).count(:distinct => false)
|
2009-12-28 08:08:28 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_count_explicit_columns
|
|
|
|
Post.update_all(:comments_count => nil)
|
|
|
|
posts = Post.scoped
|
|
|
|
|
2009-12-30 00:11:30 -05:00
|
|
|
assert_equal [0], posts.select('comments_count').where('id is not null').group('id').order('id').count.values.uniq
|
2010-09-01 09:04:33 -04:00
|
|
|
assert_equal 0, posts.where('id is not null').select('comments_count').count
|
2009-12-29 14:42:38 -05:00
|
|
|
|
2010-10-18 19:27:40 -04:00
|
|
|
assert_equal 11, posts.select('comments_count').count('id')
|
2009-12-28 08:08:28 -05:00
|
|
|
assert_equal 0, posts.select('comments_count').count
|
|
|
|
assert_equal 0, posts.count(:comments_count)
|
|
|
|
assert_equal 0, posts.count('comments_count')
|
|
|
|
end
|
2009-12-29 01:45:28 -05:00
|
|
|
|
2010-06-24 21:52:15 -04:00
|
|
|
def test_multiple_selects
|
|
|
|
post = Post.scoped.select('comments_count').select('title').order("id ASC").first
|
|
|
|
assert_equal "Welcome to the weblog", post.title
|
|
|
|
assert_equal 2, post.comments_count
|
|
|
|
end
|
|
|
|
|
2009-12-29 01:45:28 -05:00
|
|
|
def test_size
|
|
|
|
posts = Post.scoped
|
|
|
|
|
2010-10-18 19:27:40 -04:00
|
|
|
assert_queries(1) { assert_equal 11, posts.size }
|
2009-12-29 01:45:28 -05:00
|
|
|
assert ! posts.loaded?
|
|
|
|
|
|
|
|
best_posts = posts.where(:comments_count => 0)
|
|
|
|
best_posts.to_a # force load
|
2010-10-18 19:27:40 -04:00
|
|
|
assert_no_queries { assert_equal 9, best_posts.size }
|
2009-12-29 01:45:28 -05:00
|
|
|
end
|
|
|
|
|
2011-03-03 23:26:45 -05:00
|
|
|
def test_size_with_limit
|
2011-03-24 15:09:24 -04:00
|
|
|
posts = Post.limit(10)
|
2011-03-03 23:26:45 -05:00
|
|
|
|
2011-03-24 15:09:24 -04:00
|
|
|
assert_queries(1) { assert_equal 10, posts.size }
|
2011-03-03 23:26:45 -05:00
|
|
|
assert ! posts.loaded?
|
|
|
|
|
|
|
|
best_posts = posts.where(:comments_count => 0)
|
|
|
|
best_posts.to_a # force load
|
2011-03-24 15:09:24 -04:00
|
|
|
assert_no_queries { assert_equal 9, best_posts.size }
|
2011-03-03 23:26:45 -05:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_size_with_zero_limit
|
|
|
|
posts = Post.limit(0)
|
|
|
|
|
|
|
|
assert_no_queries { assert_equal 0, posts.size }
|
|
|
|
assert ! posts.loaded?
|
|
|
|
|
|
|
|
posts.to_a # force load
|
|
|
|
assert_no_queries { assert_equal 0, posts.size }
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_empty_with_zero_limit
|
|
|
|
posts = Post.limit(0)
|
|
|
|
|
|
|
|
assert_no_queries { assert_equal true, posts.empty? }
|
|
|
|
assert ! posts.loaded?
|
|
|
|
end
|
|
|
|
|
2009-12-29 14:42:38 -05:00
|
|
|
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
|
|
|
|
|
2011-03-11 17:13:44 -05:00
|
|
|
def test_empty
|
|
|
|
posts = Post.scoped
|
|
|
|
|
|
|
|
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.to_a # force load
|
|
|
|
assert_no_queries { assert_equal false, best_posts.empty? }
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_empty_complex_chained_relations
|
|
|
|
posts = Post.select("comments_count").where("id is not null").group("author_id").where("comments_count > 0")
|
2011-03-13 04:37:16 -04:00
|
|
|
|
2011-03-11 17:13:44 -05:00
|
|
|
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
|
|
|
|
|
2009-12-30 01:30:26 -05:00
|
|
|
def test_any
|
|
|
|
posts = Post.scoped
|
|
|
|
|
2011-01-02 12:56:26 -05:00
|
|
|
# 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?
|
|
|
|
|
2009-12-30 01:30:26 -05:00
|
|
|
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
|
|
|
|
|
|
|
|
def test_many
|
|
|
|
posts = Post.scoped
|
2010-06-22 09:46:12 -04:00
|
|
|
|
2009-12-30 01:30:26 -05:00
|
|
|
assert_queries(2) do
|
|
|
|
assert posts.many? # Uses COUNT()
|
|
|
|
assert posts.many? {|p| p.id > 0 }
|
|
|
|
assert ! posts.many? {|p| p.id < 2 }
|
|
|
|
end
|
2010-06-22 09:46:12 -04:00
|
|
|
|
2009-12-30 01:30:26 -05:00
|
|
|
assert posts.loaded?
|
|
|
|
end
|
|
|
|
|
2009-12-30 01:43:55 -05:00
|
|
|
def test_many_with_limits
|
|
|
|
posts = Post.scoped
|
|
|
|
|
|
|
|
assert posts.many?
|
|
|
|
assert ! posts.limit(1).many?
|
|
|
|
end
|
2010-01-02 13:38:59 -05:00
|
|
|
|
|
|
|
def test_build
|
|
|
|
posts = Post.scoped
|
|
|
|
|
|
|
|
post = posts.new
|
|
|
|
assert_kind_of Post, post
|
|
|
|
end
|
|
|
|
|
|
|
|
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
|
|
|
|
|
2010-01-02 13:46:14 -05:00
|
|
|
def test_create
|
|
|
|
birds = Bird.scoped
|
|
|
|
|
|
|
|
sparrow = birds.create
|
|
|
|
assert_kind_of Bird, sparrow
|
2010-11-07 09:05:18 -05:00
|
|
|
assert !sparrow.persisted?
|
2010-01-02 13:46:14 -05:00
|
|
|
|
|
|
|
hen = birds.where(:name => 'hen').create
|
2010-11-07 09:05:18 -05:00
|
|
|
assert hen.persisted?
|
2010-01-02 13:46:14 -05:00
|
|
|
assert_equal 'hen', hen.name
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_create_bang
|
|
|
|
birds = Bird.scoped
|
|
|
|
|
|
|
|
assert_raises(ActiveRecord::RecordInvalid) { birds.create! }
|
|
|
|
|
|
|
|
hen = birds.where(:name => 'hen').create!
|
|
|
|
assert_kind_of Bird, hen
|
2010-11-07 09:05:18 -05:00
|
|
|
assert hen.persisted?
|
2010-01-02 13:46:14 -05:00
|
|
|
assert_equal 'hen', hen.name
|
|
|
|
end
|
2010-01-03 09:12:29 -05:00
|
|
|
|
2011-08-28 00:10:25 -04:00
|
|
|
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
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
|
def test_first_or_create_bang_with_invalid_options
|
|
|
|
assert_raises(ActiveRecord::RecordInvalid) { Bird.where(:color => 'green').first_or_create!(:pirate_id => 1) }
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_first_or_create_bang_with_no_parameters
|
|
|
|
assert_raises(ActiveRecord::RecordInvalid) { Bird.where(:color => 'green').first_or_create! }
|
|
|
|
end
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
|
def test_first_or_create_bang_with_invalid_block
|
|
|
|
assert_raise(ActiveRecord::RecordInvalid) do
|
2011-09-09 14:41:35 -04:00
|
|
|
Bird.where(:color => 'green').first_or_create! { |bird| bird.pirate_id = 1 }
|
2011-08-28 00:10:25 -04:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
|
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
|
|
|
|
|
2011-09-13 14:09:01 -04:00
|
|
|
def test_first_or_initialize
|
|
|
|
parrot = Bird.where(:color => 'green').first_or_initialize(:name => 'parrot')
|
2011-08-28 00:10:25 -04:00
|
|
|
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
|
|
|
|
|
2011-09-13 14:09:01 -04:00
|
|
|
def test_first_or_initialize_with_no_parameters
|
|
|
|
parrot = Bird.where(:color => 'green').first_or_initialize
|
2011-08-28 00:10:25 -04:00
|
|
|
assert_kind_of Bird, parrot
|
|
|
|
assert !parrot.persisted?
|
|
|
|
assert !parrot.valid?
|
|
|
|
assert parrot.new_record?
|
|
|
|
assert_equal 'green', parrot.color
|
|
|
|
end
|
|
|
|
|
2011-09-13 14:09:01 -04:00
|
|
|
def test_first_or_initialize_with_block
|
|
|
|
parrot = Bird.where(:color => 'green').first_or_initialize { |bird| bird.name = 'parrot' }
|
2011-08-28 00:10:25 -04:00
|
|
|
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
|
|
|
|
|
2010-01-03 17:20:16 -05:00
|
|
|
def test_explicit_create_scope
|
|
|
|
hens = Bird.where(:name => 'hen')
|
|
|
|
assert_equal 'hen', hens.new.name
|
|
|
|
|
|
|
|
hens = hens.create_with(:name => 'cock')
|
|
|
|
assert_equal 'cock', hens.new.name
|
|
|
|
end
|
|
|
|
|
2010-01-03 09:12:29 -05:00
|
|
|
def test_except
|
|
|
|
relation = Post.where(:author_id => 1).order('id ASC').limit(1)
|
|
|
|
assert_equal [posts(:welcome)], relation.all
|
|
|
|
|
|
|
|
author_posts = relation.except(:order, :limit)
|
|
|
|
assert_equal Post.where(:author_id => 1).all, author_posts.all
|
|
|
|
|
|
|
|
all_posts = relation.except(:where, :order, :limit)
|
|
|
|
assert_equal Post.all, all_posts.all
|
|
|
|
end
|
|
|
|
|
2010-09-09 14:27:10 -04:00
|
|
|
def test_only
|
|
|
|
relation = Post.where(:author_id => 1).order('id ASC').limit(1)
|
|
|
|
assert_equal [posts(:welcome)], relation.all
|
|
|
|
|
|
|
|
author_posts = relation.only(:where)
|
|
|
|
assert_equal Post.where(:author_id => 1).all, author_posts.all
|
|
|
|
|
|
|
|
all_posts = relation.only(:limit)
|
|
|
|
assert_equal Post.limit(1).all.first, all_posts.first
|
|
|
|
end
|
|
|
|
|
2010-04-02 12:34:48 -04:00
|
|
|
def test_anonymous_extension
|
2010-06-29 11:18:55 -04:00
|
|
|
relation = Post.where(:author_id => 1).order('id ASC').extending do
|
2010-04-02 12:34:48 -04:00
|
|
|
def author
|
|
|
|
'lifo'
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
assert_equal "lifo", relation.author
|
|
|
|
assert_equal "lifo", relation.limit(1).author
|
|
|
|
end
|
|
|
|
|
|
|
|
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
|
2010-06-22 09:46:12 -04:00
|
|
|
|
|
|
|
def test_order_by_relation_attribute
|
|
|
|
assert_equal Post.order(Post.arel_table[:title]).all, Post.order("title").all
|
|
|
|
end
|
2010-06-23 12:10:53 -04:00
|
|
|
|
2010-11-24 03:17:49 -05:00
|
|
|
def test_default_scope_order_with_scope_order
|
2010-09-07 13:08:03 -04:00
|
|
|
assert_equal 'zyke', CoolCar.order_using_new_style.limit(1).first.name
|
|
|
|
assert_equal 'zyke', FastCar.order_using_new_style.limit(1).first.name
|
2010-09-01 12:04:29 -04:00
|
|
|
end
|
|
|
|
|
|
|
|
def test_order_using_scoping
|
2010-09-07 13:08:03 -04:00
|
|
|
car1 = CoolCar.order('id DESC').scoping do
|
2012-04-27 06:42:22 -04:00
|
|
|
CoolCar.scoped(:order => 'id asc').first
|
2010-09-01 12:04:29 -04:00
|
|
|
end
|
2010-09-07 13:08:03 -04:00
|
|
|
assert_equal 'zyke', car1.name
|
|
|
|
|
|
|
|
car2 = FastCar.order('id DESC').scoping do
|
2012-04-27 06:42:22 -04:00
|
|
|
FastCar.scoped(:order => 'id asc').first
|
2010-09-07 13:08:03 -04:00
|
|
|
end
|
|
|
|
assert_equal 'zyke', car2.name
|
|
|
|
end
|
|
|
|
|
|
|
|
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}
|
2010-09-01 12:04:29 -04:00
|
|
|
end
|
|
|
|
|
2010-09-08 20:53:58 -04:00
|
|
|
def test_intersection_with_array
|
|
|
|
relation = Author.where(:name => "David")
|
|
|
|
rails_author = relation.first
|
2010-09-01 12:04:29 -04:00
|
|
|
|
2010-09-08 20:53:58 -04:00
|
|
|
assert_equal [rails_author], [rails_author] & relation
|
|
|
|
assert_equal [rails_author], relation & [rails_author]
|
|
|
|
end
|
2011-01-02 15:33:18 -05:00
|
|
|
|
2011-01-03 17:47:07 -05:00
|
|
|
def test_primary_key
|
|
|
|
assert_equal "id", Post.scoped.primary_key
|
|
|
|
end
|
2011-03-06 19:04:06 -05:00
|
|
|
|
|
|
|
def test_eager_loading_with_conditions_on_joins
|
|
|
|
scope = Post.includes(:comments)
|
|
|
|
|
|
|
|
# This references the comments table, and so it should cause the comments to be eager
|
|
|
|
# loaded via a JOIN, rather than by subsequent queries.
|
|
|
|
scope = scope.joins(
|
|
|
|
Post.arel_table.create_join(
|
|
|
|
Post.arel_table,
|
|
|
|
Post.arel_table.create_on(Comment.arel_table[:id].eq(3))
|
|
|
|
)
|
|
|
|
)
|
|
|
|
|
2012-01-16 16:14:34 -05:00
|
|
|
assert_deprecated do
|
|
|
|
assert scope.eager_loading?
|
|
|
|
end
|
2011-03-06 19:04:06 -05:00
|
|
|
end
|
2011-07-24 02:17:36 -04:00
|
|
|
|
|
|
|
def test_ordering_with_extra_spaces
|
2011-07-26 05:36:18 -04:00
|
|
|
assert_equal authors(:david), Author.order('id DESC , name DESC').last
|
2011-07-24 02:17:36 -04:00
|
|
|
end
|
2011-08-08 19:12:53 -04:00
|
|
|
|
|
|
|
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
|
2011-08-09 19:03:49 -04:00
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
|
def test_update_all_with_joins_and_offset_and_order
|
2011-08-30 13:37:16 -04:00
|
|
|
all_comments = Comment.joins(:post).where('posts.id' => posts(:welcome).id).order('posts.id', 'comments.id')
|
2011-08-09 19:03:49 -04:00
|
|
|
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
|
2011-11-04 12:10:18 -04:00
|
|
|
|
|
|
|
def test_uniq
|
|
|
|
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.uniq.map(&:name)
|
|
|
|
end
|
|
|
|
assert_sql(/DISTINCT/) do
|
|
|
|
assert_equal ['Foo'], query.uniq(true).map(&:name)
|
|
|
|
end
|
|
|
|
assert_equal ['Foo', 'Foo'], query.uniq(true).uniq(false).map(&:name)
|
|
|
|
end
|
2012-01-13 19:17:39 -05:00
|
|
|
|
|
|
|
def test_references_triggers_eager_loading
|
|
|
|
scope = Post.includes(:comments)
|
|
|
|
assert !scope.eager_loading?
|
|
|
|
assert scope.references(:comments).eager_loading?
|
|
|
|
end
|
|
|
|
|
|
|
|
def test_references_doesnt_trigger_eager_loading_if_reference_not_included
|
|
|
|
scope = Post.references(:comments)
|
|
|
|
assert !scope.eager_loading?
|
|
|
|
end
|
2012-01-14 12:53:52 -05:00
|
|
|
|
2012-01-14 16:28:57 -05:00
|
|
|
def test_automatically_added_where_references
|
2012-01-14 12:53:52 -05:00
|
|
|
scope = Post.where(:comments => { :body => "Bla" })
|
2012-01-14 16:14:21 -05:00
|
|
|
assert_equal ['comments'], scope.references_values
|
2012-01-14 12:53:52 -05:00
|
|
|
|
|
|
|
scope = Post.where('comments.body' => 'Bla')
|
2012-01-14 16:14:21 -05:00
|
|
|
assert_equal ['comments'], scope.references_values
|
2012-01-14 16:28:57 -05:00
|
|
|
end
|
2012-01-14 12:53:52 -05:00
|
|
|
|
2012-01-14 16:28:57 -05:00
|
|
|
def test_automatically_added_having_references
|
2012-01-14 12:53:52 -05:00
|
|
|
scope = Post.having(:comments => { :body => "Bla" })
|
2012-01-14 16:14:21 -05:00
|
|
|
assert_equal ['comments'], scope.references_values
|
2012-01-14 12:53:52 -05:00
|
|
|
|
|
|
|
scope = Post.having('comments.body' => 'Bla')
|
2012-01-14 16:14:21 -05:00
|
|
|
assert_equal ['comments'], scope.references_values
|
2012-01-14 12:53:52 -05:00
|
|
|
end
|
2012-01-14 16:28:57 -05:00
|
|
|
|
|
|
|
def test_automatically_added_order_references
|
|
|
|
scope = Post.order('comments.body')
|
|
|
|
assert_equal ['comments'], scope.references_values
|
|
|
|
|
|
|
|
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
|
2012-03-16 10:04:24 -04:00
|
|
|
|
|
|
|
def test_presence
|
|
|
|
topics = Topic.scoped
|
|
|
|
|
2012-03-17 13:22:54 -04:00
|
|
|
# the first query is triggered because there are no topics yet.
|
2012-03-16 16:05:35 -04:00
|
|
|
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 }
|
2012-03-16 10:04:24 -04:00
|
|
|
|
|
|
|
assert topics.loaded?
|
|
|
|
end
|
2012-03-30 07:44:45 -04:00
|
|
|
|
|
|
|
test "find_by with hash conditions returns the first matching record" do
|
|
|
|
assert_equal posts(:eager_other), Post.order(:id).find_by(author_id: 2)
|
|
|
|
end
|
|
|
|
|
|
|
|
test "find_by with non-hash conditions returns the first matching record" do
|
|
|
|
assert_equal posts(:eager_other), Post.order(:id).find_by("author_id = 2")
|
|
|
|
end
|
|
|
|
|
|
|
|
test "find_by with multi-arg conditions returns the first matching record" do
|
|
|
|
assert_equal posts(:eager_other), Post.order(:id).find_by('author_id = ?', 2)
|
|
|
|
end
|
|
|
|
|
|
|
|
test "find_by returns nil if the record is missing" do
|
|
|
|
assert_equal nil, Post.scoped.find_by("1 = 0")
|
|
|
|
end
|
|
|
|
|
2012-05-05 11:07:20 -04:00
|
|
|
test "find_by doesn't have implicit ordering" do
|
|
|
|
assert_sql(/^((?!ORDER).)*$/) { Post.find_by(author_id: 2) }
|
|
|
|
end
|
|
|
|
|
2012-03-30 07:44:45 -04:00
|
|
|
test "find_by! with hash conditions returns the first matching record" do
|
|
|
|
assert_equal posts(:eager_other), Post.order(:id).find_by!(author_id: 2)
|
|
|
|
end
|
|
|
|
|
|
|
|
test "find_by! with non-hash conditions returns the first matching record" do
|
|
|
|
assert_equal posts(:eager_other), Post.order(:id).find_by!("author_id = 2")
|
|
|
|
end
|
|
|
|
|
|
|
|
test "find_by! with multi-arg conditions returns the first matching record" do
|
|
|
|
assert_equal posts(:eager_other), Post.order(:id).find_by!('author_id = ?', 2)
|
|
|
|
end
|
|
|
|
|
2012-05-05 11:07:20 -04:00
|
|
|
test "find_by! doesn't have implicit ordering" do
|
|
|
|
assert_sql(/^((?!ORDER).)*$/) { Post.find_by!(author_id: 2) }
|
|
|
|
end
|
|
|
|
|
2012-03-30 07:44:45 -04:00
|
|
|
test "find_by! raises RecordNotFound if the record is missing" do
|
|
|
|
assert_raises(ActiveRecord::RecordNotFound) do
|
|
|
|
Post.scoped.find_by!("1 = 0")
|
|
|
|
end
|
|
|
|
end
|
2012-06-22 05:29:32 -04:00
|
|
|
|
|
|
|
test "loaded relations cannot be mutated by multi value methods" do
|
|
|
|
relation = Post.scoped
|
|
|
|
relation.to_a
|
|
|
|
|
|
|
|
assert_raises(ActiveRecord::ImmutableRelation) do
|
|
|
|
relation.where! 'foo'
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
test "loaded relations cannot be mutated by single value methods" do
|
|
|
|
relation = Post.scoped
|
|
|
|
relation.to_a
|
|
|
|
|
|
|
|
assert_raises(ActiveRecord::ImmutableRelation) do
|
|
|
|
relation.limit! 5
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
test "loaded relations cannot be mutated by merge!" do
|
|
|
|
relation = Post.scoped
|
|
|
|
relation.to_a
|
|
|
|
|
|
|
|
assert_raises(ActiveRecord::ImmutableRelation) do
|
|
|
|
relation.merge! where: 'foo'
|
|
|
|
end
|
|
|
|
end
|
2009-12-27 05:44:04 -05:00
|
|
|
end
|