2 require 'models/author'
3 require 'models/categorization'
4 require 'models/comment'
5 require 'models/company'
8 require 'models/entrant'
9 require 'models/developer'
11 require 'models/customer'
13 require 'models/categorization'
15 class DynamicFinderMatchTest
< ActiveRecord
::TestCase
16 def test_find_no_match
17 assert_nil ActiveRecord
::DynamicFinderMatch.match("not_a_finder")
21 match
= ActiveRecord
::DynamicFinderMatch.match("find_by_age_and_sex_and_location")
24 assert_equal
:first, match
.finder
25 assert_equal
%w(age sex location
), match
.attribute_names
29 match
= ActiveRecord
::DynamicFinderMatch.match("find_by_age_and_sex_and_location!")
33 assert_equal
:first, match
.finder
34 assert_equal
%w(age sex location
), match
.attribute_names
38 match
= ActiveRecord
::DynamicFinderMatch.match("find_all_by_age_and_sex_and_location")
41 assert_equal
:all, match
.finder
42 assert_equal
%w(age sex location
), match
.attribute_names
45 def test_find_or_initialize_by
46 match
= ActiveRecord
::DynamicFinderMatch.match("find_or_initialize_by_age_and_sex_and_location")
49 assert match
.instantiator
?
50 assert_equal
:first, match
.finder
51 assert_equal
:new, match
.instantiator
52 assert_equal
%w(age sex location
), match
.attribute_names
55 def test_find_or_create_by
56 match
= ActiveRecord
::DynamicFinderMatch.match("find_or_create_by_age_and_sex_and_location")
59 assert match
.instantiator
?
60 assert_equal
:first, match
.finder
61 assert_equal
:create, match
.instantiator
62 assert_equal
%w(age sex location
), match
.attribute_names
66 class FinderTest
< ActiveRecord
::TestCase
67 fixtures
:companies, :topics, :entrants, :developers, :developers_projects, :posts, :comments, :accounts, :authors, :customers
70 assert_equal(topics(:first).title
, Topic
.find(1).title
)
73 # find should handle strings that come from URLs
74 # (example: Category.find(params[:id]))
75 def test_find_with_string
76 assert_equal(Topic
.find(1).title
,Topic
.find("1").title
)
80 assert Topic
.exists
?(1)
81 assert Topic
.exists
?("1")
82 assert Topic
.exists
?(:author_name => "David")
83 assert Topic
.exists
?(:author_name => "Mary", :approved => true)
84 assert Topic
.exists
?(["parent_id = ?", 1])
85 assert
!Topic
.exists
?(45)
88 assert
!Topic
.exists
?("foo")
89 rescue ActiveRecord
::StatementInvalid
90 # PostgreSQL complains about string comparison with integer field
95 assert_raise(NoMethodError
) { Topic
.exists
?([1,2]) }
98 def test_exists_with_aggregate_having_three_mappings
99 existing_address
= customers(:david).address
100 assert Customer
.exists
?(:address => existing_address
)
103 def test_exists_with_aggregate_having_three_mappings_with_one_difference
104 existing_address
= customers(:david).address
105 assert
!Customer
.exists
?(:address =>
106 Address
.new(existing_address
.street
, existing_address
.city
, existing_address
.country
+ "1"))
107 assert
!Customer
.exists
?(:address =>
108 Address
.new(existing_address
.street
, existing_address
.city
+ "1", existing_address
.country
))
109 assert
!Customer
.exists
?(:address =>
110 Address
.new(existing_address
.street
+ "1", existing_address
.city
, existing_address
.country
))
113 def test_find_by_array_of_one_id
114 assert_kind_of(Array
, Topic
.find([ 1 ]))
115 assert_equal(1, Topic
.find([ 1 ]).length
)
119 assert_equal
2, Topic
.find(1, 2).size
120 assert_equal
topics(:second).title
, Topic
.find([2]).first
.title
123 def test_find_by_ids_with_limit_and_offset
124 assert_equal
2, Entrant
.find([1,3,2], :limit => 2).size
125 assert_equal
1, Entrant
.find([1,3,2], :limit => 3, :offset => 2).size
127 # Also test an edge case: If you have 11 results, and you set a
128 # limit of 3 and offset of 9, then you should find that there
129 # will be only 2 results, regardless of the limit.
130 devs
= Developer
.find
:all
131 last_devs
= Developer
.find devs
.map(&:id), :limit => 3, :offset => 9
132 assert_equal
2, last_devs
.size
135 def test_find_an_empty_array
136 assert_equal
[], Topic
.find([])
139 def test_find_by_ids_missing_one
140 assert_raises(ActiveRecord
::RecordNotFound) { Topic
.find(1, 2, 45) }
143 def test_find_all_with_limit
144 entrants
= Entrant
.find(:all, :order => "id ASC", :limit => 2)
146 assert_equal(2, entrants
.size
)
147 assert_equal(entrants(:first).name
, entrants
.first
.name
)
150 def test_find_all_with_prepared_limit_and_offset
151 entrants
= Entrant
.find(:all, :order => "id ASC", :limit => 2, :offset => 1)
153 assert_equal(2, entrants
.size
)
154 assert_equal(entrants(:second).name
, entrants
.first
.name
)
156 entrants
= Entrant
.find(:all, :order => "id ASC", :limit => 2, :offset => 2)
157 assert_equal(1, entrants
.size
)
158 assert_equal(entrants(:third).name
, entrants
.first
.name
)
161 def test_find_all_with_limit_and_offset_and_multiple_orderings
162 developers
= Developer
.find(:all, :order => "salary ASC, id DESC", :limit => 3, :offset => 1)
163 assert_equal
["David", "fixture_10", "fixture_9"], developers
.collect
{|d
| d
.name
}
166 def test_find_with_limit_and_condition
167 developers
= Developer
.find(:all, :order => "id DESC", :conditions => "salary = 100000", :limit => 3, :offset =>7)
168 assert_equal(1, developers
.size
)
169 assert_equal("fixture_3", developers
.first
.name
)
172 def test_find_with_group
173 developers
= Developer
.find(:all, :group => "salary", :select => "salary")
174 assert_equal
4, developers
.size
175 assert_equal
4, developers
.map(&:salary).uniq
.size
178 def test_find_with_entire_select_statement
179 topics
= Topic
.find_by_sql
"SELECT * FROM topics WHERE author_name = 'Mary'"
181 assert_equal(1, topics
.size
)
182 assert_equal(topics(:second).title
, topics
.first
.title
)
185 def test_find_with_prepared_select_statement
186 topics
= Topic
.find_by_sql
["SELECT * FROM topics WHERE author_name = ?", "Mary"]
188 assert_equal(1, topics
.size
)
189 assert_equal(topics(:second).title
, topics
.first
.title
)
192 def test_find_by_sql_with_sti_on_joined_table
193 accounts
= Account
.find_by_sql("SELECT * FROM accounts INNER JOIN companies ON companies.id = accounts.firm_id")
194 assert_equal
[Account
], accounts
.collect(&:class).uniq
198 first
= Topic
.find(:first, :conditions => "title = 'The First Topic'")
199 assert_equal(topics(:first).title
, first
.title
)
202 def test_find_first_failing
203 first
= Topic
.find(:first, :conditions => "title = 'The First Topic!'")
208 assert_equal
topics(:second).title
, Topic
.first(:conditions => "title = 'The Second Topic of the day'").title
211 def test_first_failing
212 assert_nil Topic
.first(:conditions => "title = 'The Second Topic of the day!'")
215 def test_unexisting_record_exception_handling
216 assert_raises(ActiveRecord
::RecordNotFound) {
223 def test_find_only_some_columns
224 topic
= Topic
.find(1, :select => "author_name")
225 assert_raises(ActiveRecord
::MissingAttributeError) {topic
.title
}
226 assert_equal
"David", topic
.author_name
227 assert
!topic
.attribute_present
?("title")
228 #assert !topic.respond_to?("title")
229 assert topic
.attribute_present
?("author_name")
230 assert topic
.respond_to
?("author_name")
233 def test_find_on_blank_conditions
234 [nil, " ", [], {}].each
do |blank
|
235 assert_nothing_raised
{ Topic
.find(:first, :conditions => blank
) }
239 def test_find_on_blank_bind_conditions
240 [ [""], ["",{}] ].each
do |blank
|
241 assert_nothing_raised
{ Topic
.find(:first, :conditions => blank
) }
245 def test_find_on_array_conditions
246 assert Topic
.find(1, :conditions => ["approved = ?", false])
247 assert_raises(ActiveRecord
::RecordNotFound) { Topic
.find(1, :conditions => ["approved = ?", true]) }
250 def test_find_on_hash_conditions
251 assert Topic
.find(1, :conditions => { :approved => false })
252 assert_raises(ActiveRecord
::RecordNotFound) { Topic
.find(1, :conditions => { :approved => true }) }
255 def test_find_on_hash_conditions_with_explicit_table_name
256 assert Topic
.find(1, :conditions => { 'topics.approved' => false })
257 assert_raises(ActiveRecord
::RecordNotFound) { Topic
.find(1, :conditions => { 'topics.approved' => true }) }
260 def test_find_on_hash_conditions_with_hashed_table_name
261 assert Topic
.find(1, :conditions => {:topics => { :approved => false }})
262 assert_raises(ActiveRecord
::RecordNotFound) { Topic
.find(1, :conditions => {:topics => { :approved => true }}) }
265 def test_find_with_hash_conditions_on_joined_table
266 firms
= Firm
.all
:joins => :account, :conditions => {:accounts => { :credit_limit => 50 }}
267 assert_equal
1, firms
.size
268 assert_equal
companies(:first_firm), firms
.first
271 def test_find_with_hash_conditions_on_joined_table_and_with_range
272 firms
= DependentFirm
.all
:joins => :account, :conditions => {:name => 'RailsCore', :accounts => { :credit_limit => 55..60 }}
273 assert_equal
1, firms
.size
274 assert_equal
companies(:rails_core), firms
.first
277 def test_find_on_hash_conditions_with_explicit_table_name_and_aggregate
278 david
= customers(:david)
279 assert Customer
.find(david
.id
, :conditions => { 'customers.name' => david
.name
, :address => david
.address
})
280 assert_raises(ActiveRecord
::RecordNotFound) {
281 Customer
.find(david
.id
, :conditions => { 'customers.name' => david
.name
+ "1", :address => david
.address
})
285 def test_find_on_association_proxy_conditions
286 assert_equal
[1, 2, 3, 5, 6, 7, 8, 9, 10], Comment
.find_all_by_post_id(authors(:david).posts
).map(&:id).sort
289 def test_find_on_hash_conditions_with_range
290 assert_equal
[1,2], Topic
.find(:all, :conditions => { :id => 1..2 }).map(&:id).sort
291 assert_raises(ActiveRecord
::RecordNotFound) { Topic
.find(1, :conditions => { :id => 2..3 }) }
294 def test_find_on_hash_conditions_with_multiple_ranges
295 assert_equal
[1,2,3], Comment
.find(:all, :conditions => { :id => 1..3, :post_id => 1..2 }).map(&:id).sort
296 assert_equal
[1], Comment
.find(:all, :conditions => { :id => 1..1, :post_id => 1..10 }).map(&:id).sort
299 def test_find_on_multiple_hash_conditions
300 assert Topic
.find(1, :conditions => { :author_name => "David", :title => "The First Topic", :replies_count => 1, :approved => false })
301 assert_raises(ActiveRecord
::RecordNotFound) { Topic
.find(1, :conditions => { :author_name => "David", :title => "The First Topic", :replies_count => 1, :approved => true }) }
302 assert_raises(ActiveRecord
::RecordNotFound) { Topic
.find(1, :conditions => { :author_name => "David", :title => "HHC", :replies_count => 1, :approved => false }) }
303 assert_raises(ActiveRecord
::RecordNotFound) { Topic
.find(1, :conditions => { :author_name => "David", :title => "The First Topic", :replies_count => 1, :approved => true }) }
306 def test_condition_interpolation
307 assert_kind_of Firm
, Company
.find(:first, :conditions => ["name = '%s'", "37signals"])
308 assert_nil Company
.find(:first, :conditions => ["name = '%s'", "37signals!"])
309 assert_nil Company
.find(:first, :conditions => ["name = '%s'", "37signals!' OR 1=1"])
310 assert_kind_of Time
, Topic
.find(:first, :conditions => ["id = %d", 1]).written_on
313 def test_condition_array_interpolation
314 assert_kind_of Firm
, Company
.find(:first, :conditions => ["name = '%s'", "37signals"])
315 assert_nil Company
.find(:first, :conditions => ["name = '%s'", "37signals!"])
316 assert_nil Company
.find(:first, :conditions => ["name = '%s'", "37signals!' OR 1=1"])
317 assert_kind_of Time
, Topic
.find(:first, :conditions => ["id = %d", 1]).written_on
320 def test_condition_hash_interpolation
321 assert_kind_of Firm
, Company
.find(:first, :conditions => { :name => "37signals"})
322 assert_nil Company
.find(:first, :conditions => { :name => "37signals!"})
323 assert_kind_of Time
, Topic
.find(:first, :conditions => {:id => 1}).written_on
326 def test_hash_condition_find_malformed
327 assert_raises(ActiveRecord
::StatementInvalid) {
328 Company
.find(:first, :conditions => { :id => 2, :dhh => true })
332 def test_hash_condition_find_with_escaped_characters
333 Company
.create("name" => "Ain't noth'n like' \#stuff")
334 assert Company
.find(:first, :conditions => { :name => "Ain't noth'n like' \#stuff" })
337 def test_hash_condition_find_with_array
338 p1
, p2
= Post
.find(:all, :limit => 2, :order => 'id asc')
339 assert_equal
[p1
, p2
], Post
.find(:all, :conditions => { :id => [p1
, p2
] }, :order => 'id asc')
340 assert_equal
[p1
, p2
], Post
.find(:all, :conditions => { :id => [p1
, p2
.id
] }, :order => 'id asc')
343 def test_hash_condition_find_with_nil
344 topic
= Topic
.find(:first, :conditions => { :last_read => nil } )
346 assert_nil topic
.last_read
349 def test_hash_condition_find_with_aggregate_having_one_mapping
350 balance
= customers(:david).balance
351 assert_kind_of Money
, balance
352 found_customer
= Customer
.find(:first, :conditions => {:balance => balance
})
353 assert_equal
customers(:david), found_customer
356 def test_hash_condition_find_with_aggregate_attribute_having_same_name_as_field_and_key_value_being_aggregate
357 gps_location
= customers(:david).gps_location
358 assert_kind_of GpsLocation
, gps_location
359 found_customer
= Customer
.find(:first, :conditions => {:gps_location => gps_location
})
360 assert_equal
customers(:david), found_customer
363 def test_hash_condition_find_with_aggregate_having_one_mapping_and_key_value_being_attribute_value
364 balance
= customers(:david).balance
365 assert_kind_of Money
, balance
366 found_customer
= Customer
.find(:first, :conditions => {:balance => balance
.amount
})
367 assert_equal
customers(:david), found_customer
370 def test_hash_condition_find_with_aggregate_attribute_having_same_name_as_field_and_key_value_being_attribute_value
371 gps_location
= customers(:david).gps_location
372 assert_kind_of GpsLocation
, gps_location
373 found_customer
= Customer
.find(:first, :conditions => {:gps_location => gps_location
.gps_location
})
374 assert_equal
customers(:david), found_customer
377 def test_hash_condition_find_with_aggregate_having_three_mappings
378 address
= customers(:david).address
379 assert_kind_of Address
, address
380 found_customer
= Customer
.find(:first, :conditions => {:address => address
})
381 assert_equal
customers(:david), found_customer
384 def test_hash_condition_find_with_one_condition_being_aggregate_and_another_not
385 address
= customers(:david).address
386 assert_kind_of Address
, address
387 found_customer
= Customer
.find(:first, :conditions => {:address => address
, :name => customers(:david).name
})
388 assert_equal
customers(:david), found_customer
391 def test_bind_variables
392 assert_kind_of Firm
, Company
.find(:first, :conditions => ["name = ?", "37signals"])
393 assert_nil Company
.find(:first, :conditions => ["name = ?", "37signals!"])
394 assert_nil Company
.find(:first, :conditions => ["name = ?", "37signals!' OR 1=1"])
395 assert_kind_of Time
, Topic
.find(:first, :conditions => ["id = ?", 1]).written_on
396 assert_raises(ActiveRecord
::PreparedStatementInvalid) {
397 Company
.find(:first, :conditions => ["id=? AND name = ?", 2])
399 assert_raises(ActiveRecord
::PreparedStatementInvalid) {
400 Company
.find(:first, :conditions => ["id=?", 2, 3, 4])
404 def test_bind_variables_with_quotes
405 Company
.create("name" => "37signals' go'es agains")
406 assert Company
.find(:first, :conditions => ["name = ?", "37signals' go'es agains"])
409 def test_named_bind_variables_with_quotes
410 Company
.create("name" => "37signals' go'es agains")
411 assert Company
.find(:first, :conditions => ["name = :name", {:name => "37signals' go'es agains"}])
415 assert_nothing_raised
{ bind
'' }
416 assert_raises(ActiveRecord
::PreparedStatementInvalid) { bind
'', 1 }
418 assert_raises(ActiveRecord
::PreparedStatementInvalid) { bind
'?' }
419 assert_nothing_raised
{ bind
'?', 1 }
420 assert_raises(ActiveRecord
::PreparedStatementInvalid) { bind
'?', 1, 1 }
423 def test_named_bind_variables
424 assert_equal
'1', bind(':a', :a => 1) # ' ruby-mode
425 assert_equal
'1 1', bind(':a :a', :a => 1) # ' ruby-mode
427 assert_nothing_raised
{ bind("'+00:00'", :foo => "bar") }
429 assert_kind_of Firm
, Company
.find(:first, :conditions => ["name = :name", { :name => "37signals" }])
430 assert_nil Company
.find(:first, :conditions => ["name = :name", { :name => "37signals!" }])
431 assert_nil Company
.find(:first, :conditions => ["name = :name", { :name => "37signals!' OR 1=1" }])
432 assert_kind_of Time
, Topic
.find(:first, :conditions => ["id = :id", { :id => 1 }]).written_on
435 def test_bind_enumerable
436 quoted_abc
= %(#{ActiveRecord::Base.connection.quote('a')},#{ActiveRecord::Base.connection.quote('b')},#{ActiveRecord::Base.connection.quote('c')})
438 assert_equal '1,2,3', bind('?', [1, 2, 3])
439 assert_equal quoted_abc, bind('?', %w(a b c))
441 assert_equal '1,2,3', bind(':a', :a => [1, 2, 3])
442 assert_equal quoted_abc, bind(':a', :a => %w(a b c)) # '
445 assert_equal '1,2,3', bind('?', Set.new([1, 2, 3]))
446 assert_equal quoted_abc, bind('?', Set.new(%w(a b c)))
448 assert_equal '1,2,3', bind(':a', :a => Set.new([1, 2, 3]))
449 assert_equal quoted_abc, bind(':a', :a => Set.new(%w(a b c))) # '
452 def test_bind_empty_enumerable
453 quoted_nil = ActiveRecord::Base.connection.quote(nil)
454 assert_equal quoted_nil, bind('?', [])
455 assert_equal " in (#{quoted_nil})", bind(' in (?)', [])
456 assert_equal "foo in (#{quoted_nil})", bind('foo in (?)', [])
460 assert_equal ActiveRecord::Base.connection.quote(''), bind('?', '')
464 quoted_bambi = ActiveRecord::Base.connection.quote("Bambi")
465 quoted_bambi_and_thumper = ActiveRecord::Base.connection.quote("Bambi\nand\nThumper")
466 assert_equal "name=#{quoted_bambi}", bind('name=?', "Bambi")
467 assert_equal "name=#{quoted_bambi_and_thumper}", bind('name=?', "Bambi\nand\nThumper")
468 assert_equal "name=#{quoted_bambi}", bind('name=?', "Bambi".mb_chars)
469 assert_equal "name=#{quoted_bambi_and_thumper}", bind('name=?', "Bambi\nand\nThumper".mb_chars)
473 o = Struct.new(:quoted_id).new(1)
474 assert_equal '1', bind('?', o)
477 assert_equal '1,1,1', bind('?', os)
480 def test_named_bind_with_postgresql_type_casts
481 l = Proc.new { bind(":a::integer '2009-01-01'::date", :a => '10') }
482 assert_nothing_raised(&l)
483 assert_equal "#{ActiveRecord::Base.quote_value('10')}::integer '2009-01-01'::date", l.call
486 def test_string_sanitation
487 assert_not_equal "#{ActiveRecord::Base.connection.quoted_string_prefix}'something ' 1=1'", ActiveRecord::Base.sanitize("something ' 1=1")
488 assert_equal "#{ActiveRecord::Base.connection.quoted_string_prefix}'something; select table'", ActiveRecord::Base.sanitize("something; select table")
492 assert_equal(0, Entrant.count(:conditions => "id > 3"))
493 assert_equal(1, Entrant.count(:conditions => ["id > ?", 2]))
494 assert_equal(2, Entrant.count(:conditions => ["id > ?", 1]))
497 def test_count_by_sql
498 assert_equal(0, Entrant.count_by_sql("SELECT COUNT(*) FROM entrants WHERE id > 3"))
499 assert_equal(1, Entrant.count_by_sql(["SELECT COUNT(*) FROM entrants WHERE id > ?", 2]))
500 assert_equal(2, Entrant.count_by_sql(["SELECT COUNT(*) FROM entrants WHERE id > ?", 1]))
503 uses_mocha('test_dynamic_finder_should_go_through_the_find_class_method') do
504 def test_dynamic_finders_should_go_through_the_find_class_method
505 Topic.expects(:find).with(:first, :conditions => { :title => 'The First Topic!' })
506 Topic.find_by_title("The First Topic!")
508 Topic.expects(:find).with(:last, :conditions => { :title => 'The Last Topic!' })
509 Topic.find_last_by_title("The Last Topic!")
511 Topic.expects(:find).with(:all, :conditions => { :title => 'A Topic.' })
512 Topic.find_all_by_title("A Topic.")
514 Topic.expects(:find).with(:first, :conditions => { :title => 'Does not exist yet for sure!' }).times(2)
515 Topic.find_or_initialize_by_title('Does not exist yet for sure!')
516 Topic.find_or_create_by_title('Does not exist yet for sure!')
520 def test_find_by_one_attribute
521 assert_equal topics(:first), Topic.find_by_title("The First Topic")
522 assert_nil Topic.find_by_title("The First Topic!")
525 def test_find_by_one_attribute_bang
526 assert_equal topics(:first), Topic.find_by_title!("The First Topic")
527 assert_raises(ActiveRecord::RecordNotFound) { Topic.find_by_title!("The First Topic!") }
530 def test_find_by_one_attribute_caches_dynamic_finder
531 # ensure this test can run independently of order
532 class << Topic; self; end.send(:remove_method, :find_by_title) if Topic.public_methods.any? { |m| m.to_s == 'find_by_title' }
533 assert !Topic.public_methods.any? { |m| m.to_s == 'find_by_title' }
534 t = Topic.find_by_title("The First Topic")
535 assert Topic.public_methods.any? { |m| m.to_s == 'find_by_title' }
538 def test_dynamic_finder_returns_same_results_after_caching
539 # ensure this test can run independently of order
540 class << Topic; self; end.send(:remove_method, :find_by_title) if Topic.public_method_defined?(:find_by_title)
541 t = Topic.find_by_title("The First Topic")
542 assert_equal t, Topic.find_by_title("The First Topic") # find_by_title has been cached
545 def test_find_by_one_attribute_with_order_option
546 assert_equal accounts(:signals37), Account.find_by_credit_limit(50, :order => 'id')
547 assert_equal accounts(:rails_core_account), Account.find_by_credit_limit(50, :order => 'id DESC')
550 def test_find_by_one_attribute_with_conditions
551 assert_equal accounts(:rails_core_account), Account.find_by_credit_limit(50, :conditions => ['firm_id = ?', 6])
554 def test_find_by_one_attribute_that_is_an_aggregate
555 address = customers(:david).address
556 assert_kind_of Address, address
557 found_customer = Customer.find_by_address(address)
558 assert_equal customers(:david), found_customer
561 def test_find_by_one_attribute_that_is_an_aggregate_with_one_attribute_difference
562 address = customers(:david).address
563 assert_kind_of Address, address
564 missing_address = Address.new(address.street, address.city, address.country + "1")
565 assert_nil Customer.find_by_address(missing_address)
566 missing_address = Address.new(address.street, address.city + "1", address.country)
567 assert_nil Customer.find_by_address(missing_address)
568 missing_address = Address.new(address.street + "1", address.city, address.country)
569 assert_nil Customer.find_by_address(missing_address)
572 def test_find_by_two_attributes_that_are_both_aggregates
573 balance = customers(:david).balance
574 address = customers(:david).address
575 assert_kind_of Money, balance
576 assert_kind_of Address, address
577 found_customer = Customer.find_by_balance_and_address(balance, address)
578 assert_equal customers(:david), found_customer
581 def test_find_by_two_attributes_with_one_being_an_aggregate
582 balance = customers(:david).balance
583 assert_kind_of Money, balance
584 found_customer = Customer.find_by_balance_and_name(balance, customers(:david).name)
585 assert_equal customers(:david), found_customer
588 def test_dynamic_finder_on_one_attribute_with_conditions_caches_method
589 # ensure this test can run independently of order
590 class << Account; self; end.send(:remove_method, :find_by_credit_limit) if Account.public_methods.any? { |m| m.to_s == 'find_by_credit_limit' }
591 assert !Account.public_methods.any? { |m| m.to_s == 'find_by_credit_limit' }
592 a = Account.find_by_credit_limit(50, :conditions => ['firm_id = ?', 6])
593 assert Account.public_methods.any? { |m| m.to_s == 'find_by_credit_limit' }
596 def test_dynamic_finder_on_one_attribute_with_conditions_returns_same_results_after_caching
597 # ensure this test can run independently of order
598 class << Account; self; end.send(:remove_method, :find_by_credit_limit) if Account.public_methods.any? { |m| m.to_s == 'find_by_credit_limit' }
599 a = Account.find_by_credit_limit(50, :conditions => ['firm_id = ?', 6])
600 assert_equal a, Account.find_by_credit_limit(50, :conditions => ['firm_id = ?', 6]) # find_by_credit_limit has been cached
603 def test_find_by_one_attribute_with_several_options
604 assert_equal accounts(:unknown), Account.find_by_credit_limit(50, :order => 'id DESC', :conditions => ['id != ?', 3])
607 def test_find_by_one_missing_attribute
608 assert_raises(NoMethodError) { Topic.find_by_undertitle("The First Topic!") }
611 def test_find_by_invalid_method_syntax
612 assert_raises(NoMethodError) { Topic.fail_to_find_by_title("The First Topic") }
613 assert_raises(NoMethodError) { Topic.find_by_title?("The First Topic") }
614 assert_raises(NoMethodError) { Topic.fail_to_find_or_create_by_title("Nonexistent Title") }
615 assert_raises(NoMethodError) { Topic.find_or_create_by_title?("Nonexistent Title") }
618 def test_find_by_two_attributes
619 assert_equal topics(:first), Topic.find_by_title_and_author_name("The First Topic", "David")
620 assert_nil Topic.find_by_title_and_author_name("The First Topic", "Mary")
623 def test_find_last_by_one_attribute
624 assert_equal Topic.last, Topic.find_last_by_title(Topic.last.title)
625 assert_nil Topic.find_last_by_title("A title with no matches")
628 def test_find_last_by_one_attribute_caches_dynamic_finder
629 # ensure this test can run independently of order
630 class << Topic; self; end.send(:remove_method, :find_last_by_title) if Topic.public_methods.any? { |m| m.to_s == 'find_last_by_title' }
631 assert !Topic.public_methods.any? { |m| m.to_s == 'find_last_by_title' }
632 t = Topic.find_last_by_title(Topic.last.title)
633 assert Topic.public_methods.any? { |m| m.to_s == 'find_last_by_title' }
636 def test_find_last_by_invalid_method_syntax
637 assert_raises(NoMethodError) { Topic.fail_to_find_last_by_title("The First Topic") }
638 assert_raises(NoMethodError) { Topic.find_last_by_title?("The First Topic") }
641 def test_find_last_by_one_attribute_with_several_options
642 assert_equal accounts(:signals37), Account.find_last_by_credit_limit(50, :order => 'id DESC', :conditions => ['id != ?', 3])
645 def test_find_last_by_one_missing_attribute
646 assert_raises(NoMethodError) { Topic.find_last_by_undertitle("The Last Topic!") }
649 def test_find_last_by_two_attributes
651 assert_equal topic, Topic.find_last_by_title_and_author_name(topic.title, topic.author_name)
652 assert_nil Topic.find_last_by_title_and_author_name(topic.title, "Anonymous")
655 def test_find_all_by_one_attribute
656 topics = Topic.find_all_by_content("Have a nice day")
657 assert_equal 2, topics.size
658 assert topics.include?(topics(:first))
660 assert_equal [], Topic.find_all_by_title("The First Topic!!")
663 def test_find_all_by_one_attribute_that_is_an_aggregate
664 balance = customers(:david).balance
665 assert_kind_of Money, balance
666 found_customers = Customer.find_all_by_balance(balance)
667 assert_equal 1, found_customers.size
668 assert_equal customers(:david), found_customers.first
671 def test_find_all_by_two_attributes_that_are_both_aggregates
672 balance = customers(:david).balance
673 address = customers(:david).address
674 assert_kind_of Money, balance
675 assert_kind_of Address, address
676 found_customers = Customer.find_all_by_balance_and_address(balance, address)
677 assert_equal 1, found_customers.size
678 assert_equal customers(:david), found_customers.first
681 def test_find_all_by_two_attributes_with_one_being_an_aggregate
682 balance = customers(:david).balance
683 assert_kind_of Money, balance
684 found_customers = Customer.find_all_by_balance_and_name(balance, customers(:david).name)
685 assert_equal 1, found_customers.size
686 assert_equal customers(:david), found_customers.first
689 def test_find_all_by_one_attribute_with_options
690 topics = Topic.find_all_by_content("Have a nice day", :order => "id DESC")
691 assert topics(:first), topics.last
693 topics = Topic.find_all_by_content("Have a nice day", :order => "id")
694 assert topics(:first), topics.first
697 def test_find_all_by_array_attribute
698 assert_equal 2, Topic.find_all_by_title(["The First Topic", "The Second Topic of the day"]).size
701 def test_find_all_by_boolean_attribute
702 topics = Topic.find_all_by_approved(false)
703 assert_equal 1, topics.size
704 assert topics.include?(topics(:first))
706 topics = Topic.find_all_by_approved(true)
707 assert_equal 3, topics.size
708 assert topics.include?(topics(:second))
711 def test_find_by_nil_attribute
712 topic = Topic.find_by_last_read nil
714 assert_nil topic.last_read
717 def test_find_all_by_nil_attribute
718 topics = Topic.find_all_by_last_read nil
719 assert_equal 3, topics.size
720 assert topics.collect(&:last_read).all?(&:nil?)
723 def test_find_by_nil_and_not_nil_attributes
724 topic = Topic.find_by_last_read_and_author_name nil, "Mary"
725 assert_equal "Mary", topic.author_name
728 def test_find_all_by_nil_and_not_nil_attributes
729 topics = Topic.find_all_by_last_read_and_author_name nil, "Mary"
730 assert_equal 1, topics.size
731 assert_equal "Mary", topics[0].author_name
734 def test_find_or_create_from_one_attribute
735 number_of_companies = Company.count
736 sig38 = Company.find_or_create_by_name("38signals")
737 assert_equal number_of_companies + 1, Company.count
738 assert_equal sig38, Company.find_or_create_by_name("38signals")
739 assert !sig38.new_record?
742 def test_find_or_create_from_two_attributes
743 number_of_topics = Topic.count
744 another = Topic.find_or_create_by_title_and_author_name("Another topic","John")
745 assert_equal number_of_topics + 1, Topic.count
746 assert_equal another, Topic.find_or_create_by_title_and_author_name("Another topic", "John")
747 assert !another.new_record?
750 def test_find_or_create_from_two_attributes_with_one_being_an_aggregate
751 number_of_customers = Customer.count
752 created_customer = Customer.find_or_create_by_balance_and_name(Money.new(123), "Elizabeth")
753 assert_equal number_of_customers + 1, Customer.count
754 assert_equal created_customer, Customer.find_or_create_by_balance(Money.new(123), "Elizabeth")
755 assert !created_customer.new_record?
758 def test_find_or_create_from_one_attribute_and_hash
759 number_of_companies = Company.count
760 sig38 = Company.find_or_create_by_name({:name => "38signals", :firm_id => 17, :client_of => 23})
761 assert_equal number_of_companies + 1, Company.count
762 assert_equal sig38, Company.find_or_create_by_name({:name => "38signals", :firm_id => 17, :client_of => 23})
763 assert !sig38.new_record?
764 assert_equal "38signals", sig38.name
765 assert_equal 17, sig38.firm_id
766 assert_equal 23, sig38.client_of
769 def test_find_or_create_from_one_aggregate_attribute
770 number_of_customers = Customer.count
771 created_customer = Customer.find_or_create_by_balance(Money.new(123))
772 assert_equal number_of_customers + 1, Customer.count
773 assert_equal created_customer, Customer.find_or_create_by_balance(Money.new(123))
774 assert !created_customer.new_record?
777 def test_find_or_create_from_one_aggregate_attribute_and_hash
778 number_of_customers = Customer.count
779 balance = Money.new(123)
781 created_customer = Customer.find_or_create_by_balance({:balance => balance, :name => name})
782 assert_equal number_of_customers + 1, Customer.count
783 assert_equal created_customer, Customer.find_or_create_by_balance({:balance => balance, :name => name})
784 assert !created_customer.new_record?
785 assert_equal balance, created_customer.balance
786 assert_equal name, created_customer.name
789 def test_find_or_initialize_from_one_attribute
790 sig38 = Company.find_or_initialize_by_name("38signals")
791 assert_equal "38signals", sig38.name
792 assert sig38.new_record?
795 def test_find_or_initialize_from_one_aggregate_attribute
796 new_customer = Customer.find_or_initialize_by_balance(Money.new(123))
797 assert_equal 123, new_customer.balance.amount
798 assert new_customer.new_record?
801 def test_find_or_initialize_from_one_attribute_should_not_set_attribute_even_when_protected
802 c = Company.find_or_initialize_by_name({:name => "Fortune 1000", :rating => 1000})
803 assert_equal "Fortune 1000", c.name
804 assert_not_equal 1000, c.rating
809 def test_find_or_create_from_one_attribute_should_set_not_attribute_even_when_protected
810 c = Company.find_or_create_by_name({:name => "Fortune 1000", :rating => 1000})
811 assert_equal "Fortune 1000", c.name
812 assert_not_equal 1000, c.rating
814 assert !c.new_record?
817 def test_find_or_initialize_from_one_attribute_should_set_attribute_even_when_protected
818 c = Company.find_or_initialize_by_name_and_rating("Fortune 1000", 1000)
819 assert_equal "Fortune 1000", c.name
820 assert_equal 1000, c.rating
825 def test_find_or_create_from_one_attribute_should_set_attribute_even_when_protected
826 c = Company.find_or_create_by_name_and_rating("Fortune 1000", 1000)
827 assert_equal "Fortune 1000", c.name
828 assert_equal 1000, c.rating
830 assert !c.new_record?
833 def test_find_or_initialize_should_set_protected_attributes_if_given_as_block
834 c = Company.find_or_initialize_by_name(:name => "Fortune 1000") { |f| f.rating = 1000 }
835 assert_equal "Fortune 1000", c.name
836 assert_equal 1000.to_f, c.rating.to_f
841 def test_find_or_create_should_set_protected_attributes_if_given_as_block
842 c = Company.find_or_create_by_name(:name => "Fortune 1000") { |f| f.rating = 1000 }
843 assert_equal "Fortune 1000", c.name
844 assert_equal 1000.to_f, c.rating.to_f
846 assert !c.new_record?
849 def test_find_or_create_should_work_with_block_on_first_call
851 undef_method(:find_or_create_by_name) if method_defined?(:find_or_create_by_name)
853 c = Company.find_or_create_by_name(:name => "Fortune 1000") { |f| f.rating = 1000 }
854 assert_equal "Fortune 1000", c.name
855 assert_equal 1000.to_f, c.rating.to_f
857 assert !c.new_record?
860 def test_dynamic_find_or_initialize_from_one_attribute_caches_method
861 class << Company; self; end.send(:remove_method, :find_or_initialize_by_name) if Company.public_methods.any? { |m| m.to_s == 'find_or_initialize_by_name' }
862 assert !Company.public_methods.any? { |m| m.to_s == 'find_or_initialize_by_name' }
863 sig38 = Company.find_or_initialize_by_name("38signals")
864 assert Company.public_methods.any? { |m| m.to_s == 'find_or_initialize_by_name' }
867 def test_find_or_initialize_from_two_attributes
868 another = Topic.find_or_initialize_by_title_and_author_name("Another topic","John")
869 assert_equal "Another topic", another.title
870 assert_equal "John", another.author_name
871 assert another.new_record?
874 def test_find_or_initialize_from_one_aggregate_attribute_and_one_not
875 new_customer = Customer.find_or_initialize_by_balance_and_name(Money.new(123), "Elizabeth")
876 assert_equal 123, new_customer.balance.amount
877 assert_equal "Elizabeth", new_customer.name
878 assert new_customer.new_record?
881 def test_find_or_initialize_from_one_attribute_and_hash
882 sig38 = Company.find_or_initialize_by_name({:name => "38signals", :firm_id => 17, :client_of => 23})
883 assert_equal "38signals", sig38.name
884 assert_equal 17, sig38.firm_id
885 assert_equal 23, sig38.client_of
886 assert sig38.new_record?
889 def test_find_or_initialize_from_one_aggregate_attribute_and_hash
890 balance = Money.new(123)
892 new_customer = Customer.find_or_initialize_by_balance({:balance => balance, :name => name})
893 assert_equal balance, new_customer.balance
894 assert_equal name, new_customer.name
895 assert new_customer.new_record?
898 def test_find_with_bad_sql
899 assert_raises(ActiveRecord::StatementInvalid) { Topic.find_by_sql "select 1 from badtable" }
902 def test_find_with_invalid_params
903 assert_raises(ArgumentError) { Topic.find :first, :join => "It should be `joins'" }
904 assert_raises(ArgumentError) { Topic.find :first, :conditions => '1 = 1', :join => "It should be `joins'" }
907 def test_dynamic_finder_with_invalid_params
908 assert_raises(ArgumentError) { Topic.find_by_title 'No Title', :join => "It should be `joins'" }
911 def test_find_all_with_limit
912 first_five_developers = Developer.find :all, :order => 'id ASC', :limit => 5
913 assert_equal 5, first_five_developers.length
914 assert_equal 'David', first_five_developers.first.name
915 assert_equal 'fixture_5', first_five_developers.last.name
917 no_developers = Developer.find :all, :order => 'id ASC', :limit => 0
918 assert_equal 0, no_developers.length
921 def test_find_all_with_limit_and_offset
922 first_three_developers = Developer.find :all, :order => 'id ASC', :limit => 3, :offset => 0
923 second_three_developers = Developer.find :all, :order => 'id ASC', :limit => 3, :offset => 3
924 last_two_developers = Developer.find :all, :order => 'id ASC', :limit => 2, :offset => 8
926 assert_equal 3, first_three_developers.length
927 assert_equal 3, second_three_developers.length
928 assert_equal 2, last_two_developers.length
930 assert_equal 'David', first_three_developers.first.name
931 assert_equal 'fixture_4', second_three_developers.first.name
932 assert_equal 'fixture_9', last_two_developers.first.name
935 def test_find_all_with_limit_and_offset_and_multiple_order_clauses
936 first_three_posts = Post.find :all, :order => 'author_id, id', :limit => 3, :offset => 0
937 second_three_posts = Post.find :all, :order => ' author_id,id ', :limit => 3, :offset => 3
938 last_posts = Post.find :all, :order => ' author_id, id ', :limit => 3, :offset => 6
940 assert_equal [[0,3],[1,1],[1,2]], first_three_posts.map { |p| [p.author_id, p.id] }
941 assert_equal [[1,4],[1,5],[1,6]], second_three_posts.map { |p| [p.author_id, p.id] }
942 assert_equal [[2,7]], last_posts.map { |p| [p.author_id, p.id] }
945 def test_find_all_with_join
946 developers_on_project_one = Developer.find(
948 :joins => 'LEFT JOIN developers_projects ON developers.id = developers_projects.developer_id',
949 :conditions => 'project_id=1'
951 assert_equal 3, developers_on_project_one.length
952 developer_names = developers_on_project_one.map { |d| d.name }
953 assert developer_names.include?('David')
954 assert developer_names.include?('Jamis')
957 def test_joins_dont_clobber_id
960 :joins => 'INNER JOIN companies AS clients ON clients.firm_id = companies.id',
961 :conditions => 'companies.id = 1'
963 assert_equal 1, first.id
966 def test_joins_with_string_array
967 person_with_reader_and_post = Post.find(
970 "INNER JOIN categorizations ON categorizations.post_id = posts.id",
971 "INNER JOIN categories ON categories.id = categorizations.category_id AND categories.type = 'SpecialCategory'"
974 assert_equal 1, person_with_reader_and_post.size
977 def test_find_by_id_with_conditions_with_or
978 assert_nothing_raised do
980 :conditions => "posts.id <= 3 OR posts.#{QUOTED_TYPE} = 'Post'")
984 # http://dev.rubyonrails.org/ticket/6778
985 def test_find_ignores_previously_inserted_record
986 post = Post.create!(:title => 'test', :body => 'it out')
987 assert_equal [], Post.find_all_by_id(nil)
990 def test_find_by_empty_ids
991 assert_equal [], Post.find([])
994 def test_find_by_empty_in_condition
995 assert_equal [], Post.find(:all, :conditions => ['id in (?)', []])
998 def test_find_by_records
999 p1, p2 = Post.find(:all, :limit => 2, :order => 'id asc')
1000 assert_equal [p1, p2], Post.find(:all, :conditions => ['id in (?)', [p1, p2]], :order => 'id asc')
1001 assert_equal [p1, p2], Post.find(:all, :conditions => ['id in (?)', [p1, p2.id]], :order => 'id asc')
1004 def test_select_value
1005 assert_equal "37signals", Company.connection.select_value("SELECT name FROM companies WHERE id = 1")
1006 assert_nil Company.connection.select_value("SELECT name FROM companies WHERE id = -1")
1007 # make sure we didn't break count...
1008 assert_equal 0, Company.count_by_sql("SELECT COUNT(*) FROM companies WHERE name = 'Halliburton'")
1009 assert_equal 1, Company.count_by_sql("SELECT COUNT(*) FROM companies WHERE name = '37signals'")
1012 def test_select_values
1013 assert_equal ["1","2","3","4","5","6","7","8","9"], Company.connection.select_values("SELECT id FROM companies ORDER BY id").map! { |i| i.to_s }
1014 assert_equal ["37signals","Summit","Microsoft", "Flamboyant Software", "Ex Nihilo", "RailsCore", "Leetsoft", "Jadedpixel", "Odegy"], Company.connection.select_values("SELECT name FROM companies ORDER BY id")
1017 def test_select_rows
1019 [["1", nil, nil, "37signals"],
1020 ["2", "1", "2", "Summit"],
1021 ["3", "1", "1", "Microsoft"]],
1022 Company.connection.select_rows("SELECT id, firm_id, client_of, name FROM companies WHERE id IN (1,2,3) ORDER BY id").map! {|i| i.map! {|j| j.to_s unless j.nil?}})
1023 assert_equal [["1", "37signals"], ["2", "Summit"], ["3", "Microsoft"]],
1024 Company.connection.select_rows("SELECT id, name FROM companies WHERE id IN (1,2,3) ORDER BY id").map! {|i| i.map! {|j| j.to_s unless j.nil?}}
1027 def test_find_with_order_on_included_associations_with_construct_finder_sql_for_association_limiting_and_is_distinct
1028 assert_equal 2, Post.find(:all, :include => { :authors => :author_address }, :order => ' author_addresses.id DESC ', :limit => 2).size
1030 assert_equal 3, Post.find(:all, :include => { :author => :author_address, :authors => :author_address},
1031 :order => ' author_addresses_authors.id DESC ', :limit => 3).size
1034 def test_with_limiting_with_custom_select
1035 posts = Post.find(:all, :include => :author, :select => ' posts.*, authors.id as "author_id"', :limit => 3, :order => 'posts.id')
1036 assert_equal 3, posts.size
1037 assert_equal [0, 1, 1], posts.map(&:author_id).sort
1041 def bind(statement, *vars)
1042 if vars.first.is_a?(Hash)
1043 ActiveRecord::Base.send(:replace_named_bind_variables, statement, vars.first)
1045 ActiveRecord::Base.send(:replace_bind_variables, statement, vars)