ad7b5efb55
commit 02d3b059608c30e98136fde78bc710928f080566 Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Mon Sep 30 15:31:39 2013 -0700 habtm works in terms of hm:t commit 71ac336bbb41f5047a4ee307883a95eca7195742 Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Mon Sep 30 15:27:07 2013 -0700 passing before_add callbacks commit d846a7bf9872a79c3aa8082917abe806278fa159 Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Fri Sep 27 17:57:53 2013 -0700 reducing diff against master commit 96bd97de47d61a71c368ae367bc59a2dbec3c9ab Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Fri Sep 27 17:52:35 2013 -0700 fixing more tests commit 0620399fc231df87c5f08664db1c37e5c1fa5a05 Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Fri Sep 27 17:32:52 2013 -0700 self-referential tables in hm:t are allowed to have the same pk commit 48eb90e27921d10b6ba3e400ab2c784ed75d5ec4 Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Fri Sep 27 17:03:19 2013 -0700 translating more options commit 5cace7b2cb546fd6b096543bfc49c4b7197ad21a Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Fri Sep 27 17:01:02 2013 -0700 handling more hm:t cases commit 69985ca2cabff2c3f58f5d0a7eb12d7b414c1a01 Merge: d417ec8 3e0a60e Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Fri Sep 27 16:57:12 2013 -0700 Merge branch 'master' into rmhbtm * master: (21 commits) adding a test to demonstrate how to use STI subclasses on the far right side of a hm:t association along with preloading. Fixed grammatical typo in configuring.md guide. Getting Started Guide: Fix code container in Chapter 5.2 [ci-skip] Getting Started Guide: Update sentence in Chapter 5.8 [ci-skip] Add new line after create action on CommentsController code example Adds template dependencies rake task from cache_digests gem. [ci skip] Update scaffold output and change some words. [ci skip] escape unintended url in docs Getting Started Guide: post.rb -> Post [ci skip] Add missing periods and update link name and some wording. quote `false` reference in querying guide. Getting Started Guide: update link_to string argument to use single-quote mark, following document style [ci skip] Fix small typo in docs changelog entry fix .find when inverse is set update changelog for #12359 Make sure inverse_of is visible on the has_many callbacks Getting Started Guide: posts_controller -> PostsController [ci skip] [ci skip] Correct the explanation of the example for find_or_create_by when used with create_with in ActiveRecord Querying guide added "id: false" to HABTM join table example ... commit d417ec82e8f83c32124d1c1a19824d023cfdf015 Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Wed Sep 25 16:49:08 2013 -0700 another case is passing commit 5c68280500962e4b2b6819dd863ebe8b398e5834 Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Wed Sep 25 16:21:22 2013 -0700 this seems to work commit e458c5e55c04a2444e96aca1ff192be42bc4ce7f Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Wed Sep 25 16:13:07 2013 -0700 add another case commit fc6203b0d49c847b8efb1cc33d358897625f2115 Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Wed Sep 25 15:51:45 2013 -0700 delete center records on habtm commit 9af5156098f6bc8f8ce8eb559a51137960b4938b Merge: 3a60b03 e2fd64f Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Wed Sep 25 11:33:13 2013 -0700 Merge branch 'master' into rmhbtm * master: (100 commits) remove initialize method extract association resetting to a method hash insertion order doesn't matter anymore, so only loop over the owners once always populate the preloaded records instance variable so we can remove the @associated_records_by_owner ivar keep preloaded records in a list rather than extract from a hash Getting Started Guide: Hello Rails! -> Hello, Rails! and wrap code tag push slice loading to it's own method so we can remove the type casting code Add CHANGELOG entry for #12344 Add regression test to #12343 Fix typo in number_to_human docs: you -> your guarantee that `klass` is not nil inside the preloader objects [Documentation] Add a missing validation to I18n docs Use the given name in html_options for the hidden field in collection_check_boxes eliminate unused ivar all records have a preloaded, so eliminate that conditional eliminate the `loaded?` conditional push preloaded test up to the factory method so we can eliminate conditionals from the individual preloaded classes assign_attributes should return if argument is blank. No need the else clause Use join to concat the both side of the AST ... commit 3a60b038a40532397b6c204dfb09d6d43a9336ac Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Wed Sep 18 17:50:11 2013 -0700 start with a clean slate commit f30d3631af11ea6144d3ae7a068a7c0072e93a82 Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Wed Sep 18 17:30:59 2013 -0700 make sure the class name goes on the rhs belongs_to commit f7516b724014504ddb2e706fea1b5438dc5332c3 Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Wed Sep 18 16:31:40 2013 -0700 remove unused variable commit 61ffc5b9854dc2fe83ee502b17ba8028270ff8a7 Merge: 6cf41cd 460eb83 Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Wed Sep 18 16:25:17 2013 -0700 Merge branch 'master' into rmhbtm * master: support objects with blank string primary keys ActiveRecord::Base#<=> has been removed. Primary keys may not be in order, or even be numbers, so sorting by id doesn't make sense. Please use `sort_by` and specify the attribute you wish to sort with. For example, change: do what the superclass does in the case that objects do not match commit 6cf41cd98a82e6f4fe6d868ad323df3d72a9748f Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Wed Sep 18 15:06:28 2013 -0700 heating up habtm cache commit d7f6c3aa491f27ba71fdb2b9d0b9d1780664f4dc Merge: c68c904 56bfd8a Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Wed Sep 18 14:07:51 2013 -0700 Merge branch 'master' into rmhbtm * master: (58 commits) Fix an issue where router can't recognize downcased url encoding path. There's no need to do this Remove tzinfo dependency from Action Pack [ci skip] Improve readability of 4.3's NOTE in migration.md. Removes unused code related to DatabaseTasks. [ci skip] Consistency wording of 9.6 in form_helpers.md [ci skip] Update plugins.md Removing ActiveSupport::Concern, it's not needed Fixing comment typo in ActionController::Base Don't require using application_name before options Collapse where constraints to one where constraint Custom flash should be defined only for the class that defines it and it's subclasses. Fix typos: the indefinite articles(a -> an) Missing destroy command Update 3_2_release_notes.md Add CHANGELOG entry for #11698 Add CHANGELOG entry for #12149 Use the Rails binary when generating task Remove unnecessary loop "generates" applies to "collection radio" so it should be singular ... commit c68c904866ef9562c3bd9b54574206a416184414 Merge: 0f5d8e0 71cf717 Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Wed Sep 11 17:45:53 2013 -0700 Merge branch 'master' into rmhbtm * master: these are not real developer objects, so counting them doesn't make sense. Let's load the object to ensure it's an array and count the array. Remove conditional adding a new method Fix inverted conditional Remove invalid comment Check if the SQL is not a prepared statement Whitespaces Revert "Add meta tag with charset information to application layout." Avoid empty transaction from setting has_one association on new record. Reduce Duration#inspect to a single series of transformations Relation#merge should not lose readonly(false) flag. Reduce allocations when extracting AR models Perf: avoid dupes add fallback logic for coders commit 0f5d8e0febd3128cf4121ff36f1764b9284d9f7d Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Wed Sep 11 11:43:29 2013 -0700 everything works with extensions commit d003c103b5908fb3a6427f39bddd1748ef2c2576 Merge: 5768c38 7e0cac1 Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Wed Sep 11 11:23:59 2013 -0700 Merge branch 'master' into rmhbtm * master: fix deleting join models with no pk remove sentence err [ci skip] 'previous version of Rails' is gramatically incorrect Add meta tag with charset information to application layout. add a comment for sanity of other people to come commit 5768c38d53fd66a97814faaea8e07c70722b310f Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Tue Sep 10 15:11:05 2013 -0700 habtms with a scope seem to be working commit 5ee9108d95c544d4befd682a72139383d0780d68 Merge: d5478e6 e64b5da Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Tue Sep 10 11:55:48 2013 -0700 Merge branch 'master' into rmhbtm * master: ask the association for records rather than calling `send` commit d5478e64bbf80337ec35462368edabb373feeb74 Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Tue Sep 10 11:54:39 2013 -0700 ask the association for records rather than calling `send` commit 93020bc1ad51363c3f400370f91c9494690dcea8 Merge: 11b3d5f d68419a Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Tue Sep 10 11:30:03 2013 -0700 Merge branch 'master' into rmhbtm * master: Use Ruby 2.0 caller_locations instead of caller if available Update Rails 3.2.x guide link [ci skip] Be sure to restore the default I18n.locale after changed its value in a test Fixes typo in Object#try! More unused associations in AR test models ✂️ [ci skip] change function def self.table_name to self.table_name Clean up unused associations in AR test model Reset ActionView::Base.logger instead of AC::Base.logger Refactor handling of action normalization Don't mutate the Base settings by merge!ing the given value Make AC standalone rendering work use assert_empty in activemodel conditional validation test cases Removed unused modules and classes Removed unnecessary require Remove helper fixtures not used in any test Back AV description in gemspec Fix order dependent test grab executable from rubygems Fixed API task file commit 11b3d5fa45b57fc4e7dddb09be583498b120b185 Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Mon Sep 9 16:19:48 2013 -0700 change query count since we are using hm:t associations commit f59daebedab3ed13f31c99244ff71a4a5d6e554b Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Mon Sep 9 15:35:07 2013 -0700 delegate compute_type to a real AR class commit c84a40d2ed76e5843b994c5a2b9e29ced3816511 Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Mon Sep 9 15:29:51 2013 -0700 define callbacks with the builder commit d08b1b6b3efc9ed8b0d5476892f048fbffb39e40 Merge: acebec1 0c5d0be Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Mon Sep 9 15:17:40 2013 -0700 Merge branch 'master' into rmhbtm * master: let the class cache object clean up user input make @bitsweat happy. ❤️ commit acebec128e108ac2b4855e540d8764629670cb83 Merge: 2de68a4 e1cbd42 Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Mon Sep 9 14:47:30 2013 -0700 Merge branch 'master' into rmhbtm * master: stop using deprecated api in the tests commit 2de68a464641f76067743957f889ac87dff395a0 Merge: 7504df9 1385ae1 Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Mon Sep 9 14:34:37 2013 -0700 Merge branch 'master' into rmhbtm * master: Remove BasicRendering tests Remove remaining coupling with AV in MimeResponds Remove BasicRendering and remove template functionality from AbsC::Rendering Improves a sentence in guides/security [ci skip] Change link name of Rails i18n wiki. Typo in Changelog. Fix fixtures regression that required table names to map to classes only, not class names Use MiniTest::Unit::TestCase instead of Minitest::Test Use Ruby on Rails Coding Conventions for code examples in the guides commit 7504df92f21ed3d5da7c2760d760f026728ed04d Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Mon Sep 9 14:34:02 2013 -0700 fake class name should be a valid class name commit 6609620ea86dc0fb7c4bbfb0db950f6e3fc75b56 Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Fri Sep 6 15:52:03 2013 -0700 move another habtm commit 2c95a36e2c3dfe92f2930f3cca44bc4452732a23 Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Fri Sep 6 15:50:18 2013 -0700 use the habtm name to generate the rhs name on the join model commit bd963f720b1db19b0bec186bc33bef9203d8b011 Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Fri Sep 6 15:47:29 2013 -0700 don't hardcode the name commit 461759e2caf66f23dca4eff988648bf769a2b533 Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Fri Sep 6 15:45:27 2013 -0700 we do not need to specify the fk commit 9c223f01db6e36adbb7570e2aa1bcaec1d142c87 Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Fri Sep 6 15:44:08 2013 -0700 just call the left side :left_side commit 5661622a82154eff877fe0993bfffad13dacad7a Author: Aaron Patterson <aaron.patterson@gmail.com> Date: Fri Sep 6 15:40:36 2013 -0700 initial habtm implementation is working
1615 lines
49 KiB
Ruby
1615 lines
49 KiB
Ruby
require "cases/helper"
|
|
require 'models/tag'
|
|
require 'models/tagging'
|
|
require 'models/post'
|
|
require 'models/topic'
|
|
require 'models/comment'
|
|
require 'models/author'
|
|
require 'models/entrant'
|
|
require 'models/developer'
|
|
require 'models/reply'
|
|
require 'models/company'
|
|
require 'models/bird'
|
|
require 'models/car'
|
|
require 'models/engine'
|
|
require 'models/tyre'
|
|
require 'models/minivan'
|
|
|
|
|
|
class RelationTest < ActiveRecord::TestCase
|
|
fixtures :authors, :topics, :entrants, :developers, :companies, :developers_projects, :accounts, :categories, :categorizations, :posts, :comments,
|
|
: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
|
|
|
|
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
|
|
|
|
def test_bind_values
|
|
relation = Post.all
|
|
assert_equal [], relation.bind_values
|
|
|
|
relation2 = relation.bind 'foo'
|
|
assert_equal %w{ foo }, relation2.bind_values
|
|
assert_equal [], relation.bind_values
|
|
end
|
|
|
|
def test_two_scopes_with_includes_should_not_drop_any_include
|
|
# heat habtm cache
|
|
car = Car.incl_engines.incl_tyres.first
|
|
car.tyres.length
|
|
car.engines.length
|
|
|
|
car = Car.incl_engines.incl_tyres.first
|
|
assert_no_queries { car.tyres.length }
|
|
assert_no_queries { car.engines.length }
|
|
end
|
|
|
|
def test_dynamic_finder
|
|
x = Post.where('author_id = ?', 1)
|
|
assert x.klass.respond_to?(:find_by_id), '@klass should handle dynamic finders'
|
|
end
|
|
|
|
def test_multivalue_where
|
|
posts = Post.where('author_id = ? AND id = ?', 1, 1)
|
|
assert_equal 1, posts.to_a.size
|
|
end
|
|
|
|
def test_scoped
|
|
topics = Topic.all
|
|
assert_kind_of ActiveRecord::Relation, topics
|
|
assert_equal 4, topics.size
|
|
end
|
|
|
|
def test_to_json
|
|
assert_nothing_raised { Bird.all.to_json }
|
|
assert_nothing_raised { Bird.all.to_a.to_json }
|
|
end
|
|
|
|
def test_to_yaml
|
|
assert_nothing_raised { Bird.all.to_yaml }
|
|
assert_nothing_raised { Bird.all.to_a.to_yaml }
|
|
end
|
|
|
|
def test_to_xml
|
|
assert_nothing_raised { Bird.all.to_xml }
|
|
assert_nothing_raised { Bird.all.to_a.to_xml }
|
|
end
|
|
|
|
def test_scoped_all
|
|
topics = Topic.all.to_a
|
|
assert_kind_of Array, topics
|
|
assert_no_queries { assert_equal 4, topics.size }
|
|
end
|
|
|
|
def test_loaded_all
|
|
topics = Topic.all
|
|
|
|
assert_queries(1) do
|
|
2.times { assert_equal 4, topics.to_a.size }
|
|
end
|
|
|
|
assert topics.loaded?
|
|
end
|
|
|
|
def test_scoped_first
|
|
topics = Topic.all.order('id ASC')
|
|
|
|
assert_queries(1) do
|
|
2.times { assert_equal "The First Topic", topics.first.title }
|
|
end
|
|
|
|
assert ! topics.loaded?
|
|
end
|
|
|
|
def test_loaded_first
|
|
topics = Topic.all.order('id ASC')
|
|
|
|
assert_queries(1) do
|
|
topics.to_a # force load
|
|
2.times { assert_equal "The First Topic", topics.first.title }
|
|
end
|
|
|
|
assert topics.loaded?
|
|
end
|
|
|
|
def test_reload
|
|
topics = Topic.all
|
|
|
|
assert_queries(1) do
|
|
2.times { topics.to_a }
|
|
end
|
|
|
|
assert topics.loaded?
|
|
|
|
original_size = topics.to_a.size
|
|
Topic.create! :title => 'fake'
|
|
|
|
assert_queries(1) { topics.reload }
|
|
assert_equal original_size + 1, topics.size
|
|
assert topics.loaded?
|
|
end
|
|
|
|
def test_finding_with_subquery
|
|
relation = Topic.where(:approved => true)
|
|
assert_equal relation.to_a, Topic.select('*').from(relation).to_a
|
|
assert_equal relation.to_a, Topic.select('subquery.*').from(relation).to_a
|
|
assert_equal relation.to_a, Topic.select('a.*').from(relation, :a).to_a
|
|
end
|
|
|
|
def test_finding_with_subquery_with_binds
|
|
relation = Post.first.comments
|
|
assert_equal relation.to_a, Comment.select('*').from(relation).to_a
|
|
assert_equal relation.to_a, Comment.select('subquery.*').from(relation).to_a
|
|
assert_equal relation.to_a, Comment.select('a.*').from(relation, :a).to_a
|
|
end
|
|
|
|
def test_finding_with_conditions
|
|
assert_equal ["David"], Author.where(:name => 'David').map(&:name)
|
|
assert_equal ['Mary'], Author.where(["name = ?", 'Mary']).map(&:name)
|
|
assert_equal ['Mary'], Author.where("name = ?", 'Mary').map(&:name)
|
|
end
|
|
|
|
def test_finding_with_order
|
|
topics = Topic.order('id')
|
|
assert_equal 4, topics.to_a.size
|
|
assert_equal topics(:first).title, topics.first.title
|
|
end
|
|
|
|
|
|
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_with_assoc_order
|
|
topics = Topic.order(:id => :desc)
|
|
assert_equal 4, topics.to_a.size
|
|
assert_equal topics(:fourth).title, topics.first.title
|
|
end
|
|
|
|
def test_finding_with_reverted_assoc_order
|
|
topics = Topic.order(:id => :asc).reverse_order
|
|
assert_equal 4, topics.to_a.size
|
|
assert_equal topics(:fourth).title, topics.first.title
|
|
end
|
|
|
|
def test_order_with_hash_and_symbol_generates_the_same_sql
|
|
assert_equal Topic.order(:id).to_sql, Topic.order(:id => :asc).to_sql
|
|
end
|
|
|
|
def test_raising_exception_on_invalid_hash_params
|
|
assert_raise(ArgumentError) { Topic.order(:name, "id DESC", :id => :DeSc) }
|
|
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
|
|
|
|
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
|
|
|
|
def test_finding_with_reorder
|
|
topics = Topic.order('author_name').order('title').reorder('id').to_a
|
|
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
|
|
|
|
def test_finding_with_order_and_take
|
|
entrants = Entrant.order("id ASC").limit(2).to_a
|
|
|
|
assert_equal 2, entrants.size
|
|
assert_equal entrants(:first).name, entrants.first.name
|
|
end
|
|
|
|
def test_finding_with_cross_table_order_and_limit
|
|
tags = Tag.includes(:taggings).
|
|
order("tags.name asc", "taggings.taggable_id asc", "REPLACE('abc', taggings.taggable_type, taggings.taggable_type)").
|
|
limit(1).to_a
|
|
assert_equal 1, tags.length
|
|
end
|
|
|
|
def test_finding_with_complex_order_and_limit
|
|
tags = Tag.includes(:taggings).references(:taggings).order("REPLACE('abc', taggings.taggable_type, taggings.taggable_type)").limit(1).to_a
|
|
assert_equal 1, tags.length
|
|
end
|
|
|
|
def test_finding_with_complex_order
|
|
tags = Tag.includes(:taggings).references(:taggings).order("REPLACE('abc', taggings.taggable_type, taggings.taggable_type)").to_a
|
|
assert_equal 3, tags.length
|
|
end
|
|
|
|
def test_finding_with_order_limit_and_offset
|
|
entrants = Entrant.order("id ASC").limit(2).offset(1)
|
|
|
|
assert_equal 2, entrants.to_a.size
|
|
assert_equal entrants(:second).name, entrants.first.name
|
|
|
|
entrants = Entrant.order("id ASC").limit(2).offset(2)
|
|
assert_equal 1, entrants.to_a.size
|
|
assert_equal entrants(:third).name, entrants.first.name
|
|
end
|
|
|
|
def test_finding_with_group
|
|
developers = Developer.group("salary").select("salary").to_a
|
|
assert_equal 4, developers.size
|
|
assert_equal 4, developers.map(&:salary).uniq.size
|
|
end
|
|
|
|
def test_select_with_block
|
|
even_ids = Developer.all.select {|d| d.id % 2 == 0 }.map(&:id)
|
|
assert_equal [2, 4, 6, 8, 10], even_ids.sort
|
|
end
|
|
|
|
def test_none
|
|
assert_no_queries do
|
|
assert_equal [], Developer.none
|
|
assert_equal [], Developer.all.none
|
|
end
|
|
end
|
|
|
|
def test_none_chainable
|
|
assert_no_queries do
|
|
assert_equal [], Developer.none.where(:name => 'David')
|
|
end
|
|
end
|
|
|
|
def test_none_chainable_to_existing_scope_extension_method
|
|
assert_no_queries do
|
|
assert_equal 1, Topic.anonymous_extension.none.one
|
|
end
|
|
end
|
|
|
|
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 0, Developer.none.calculate(:count, nil, {})
|
|
assert_equal nil, Developer.none.calculate(:average, 'salary')
|
|
end
|
|
end
|
|
|
|
def test_null_relation_metadata_methods
|
|
assert_equal "", Developer.none.to_sql
|
|
assert_equal({}, Developer.none.where_values_hash)
|
|
end
|
|
|
|
def test_null_relation_where_values_hash
|
|
assert_equal({ 'salary' => 100_000 }, Developer.none.where(salary: 100_000).where_values_hash)
|
|
end
|
|
|
|
def test_joins_with_nil_argument
|
|
assert_nothing_raised { DependentFirm.joins(nil).first }
|
|
end
|
|
|
|
def test_finding_with_hash_conditions_on_joined_table
|
|
firms = DependentFirm.joins(:account).where({:name => 'RailsCore', :accounts => { :credit_limit => 55..60 }}).to_a
|
|
assert_equal 1, firms.size
|
|
assert_equal companies(:rails_core), firms.first
|
|
end
|
|
|
|
def test_find_all_with_join
|
|
developers_on_project_one = Developer.joins('LEFT JOIN developers_projects ON developers.id = developers_projects.developer_id').
|
|
where('project_id=1').to_a
|
|
|
|
assert_equal 3, developers_on_project_one.length
|
|
developer_names = developers_on_project_one.map { |d| d.name }
|
|
assert developer_names.include?('David')
|
|
assert developer_names.include?('Jamis')
|
|
end
|
|
|
|
def test_find_on_hash_conditions
|
|
assert_equal Topic.all.merge!(:where => {:approved => false}).to_a, Topic.where({ :approved => false }).to_a
|
|
end
|
|
|
|
def test_joins_with_string_array
|
|
person_with_reader_and_post = Post.joins([
|
|
"INNER JOIN categorizations ON categorizations.post_id = posts.id",
|
|
"INNER JOIN categories ON categories.id = categorizations.category_id AND categories.type = 'SpecialCategory'"
|
|
]
|
|
).to_a
|
|
assert_equal 1, person_with_reader_and_post.size
|
|
end
|
|
|
|
def test_no_arguments_to_query_methods_raise_errors
|
|
assert_raises(ArgumentError) { Topic.references() }
|
|
assert_raises(ArgumentError) { Topic.includes() }
|
|
assert_raises(ArgumentError) { Topic.preload() }
|
|
assert_raises(ArgumentError) { Topic.group() }
|
|
assert_raises(ArgumentError) { Topic.reorder() }
|
|
end
|
|
|
|
def test_blank_like_arguments_to_query_methods_dont_raise_errors
|
|
assert_nothing_raised { Topic.references([]) }
|
|
assert_nothing_raised { Topic.includes([]) }
|
|
assert_nothing_raised { Topic.preload([]) }
|
|
assert_nothing_raised { Topic.group([]) }
|
|
assert_nothing_raised { Topic.reorder([]) }
|
|
end
|
|
|
|
def test_scoped_responds_to_delegated_methods
|
|
relation = Topic.all
|
|
|
|
["map", "uniq", "sort", "insert", "delete", "update"].each do |method|
|
|
assert_respond_to relation, method, "Topic.all should respond to #{method.inspect}"
|
|
end
|
|
end
|
|
|
|
def test_respond_to_delegates_to_relation
|
|
relation = Topic.all
|
|
fake_arel = Struct.new(:responds) {
|
|
def respond_to? method, access = false
|
|
responds << [method, access]
|
|
end
|
|
}.new []
|
|
|
|
relation.extend(Module.new { attr_accessor :arel })
|
|
relation.arel = fake_arel
|
|
|
|
relation.respond_to?(:matching_attributes)
|
|
assert_equal [:matching_attributes, false], fake_arel.responds.first
|
|
|
|
fake_arel.responds = []
|
|
relation.respond_to?(:matching_attributes, true)
|
|
assert_equal [:matching_attributes, true], fake_arel.responds.first
|
|
end
|
|
|
|
def test_respond_to_dynamic_finders
|
|
relation = Topic.all
|
|
|
|
["find_by_title", "find_by_title_and_author_name"].each do |method|
|
|
assert_respond_to relation, method, "Topic.all should respond to #{method.inspect}"
|
|
end
|
|
end
|
|
|
|
def test_respond_to_class_methods_and_scopes
|
|
assert Topic.all.respond_to?(:by_lifo)
|
|
end
|
|
|
|
def test_find_with_readonly_option
|
|
Developer.all.each { |d| assert !d.readonly? }
|
|
Developer.all.readonly.each { |d| assert d.readonly? }
|
|
end
|
|
|
|
def test_eager_association_loading_of_stis_with_multiple_references
|
|
authors = Author.eager_load(:posts => { :special_comments => { :post => [ :special_comments, :very_special_comment ] } }).
|
|
order('comments.body, very_special_comments_posts.body').where('posts.id = 4').to_a
|
|
|
|
assert_equal [authors(:david)], authors
|
|
assert_no_queries do
|
|
authors.first.posts.first.special_comments.first.post.special_comments
|
|
authors.first.posts.first.special_comments.first.post.very_special_comment
|
|
end
|
|
end
|
|
|
|
def test_find_with_preloaded_associations
|
|
assert_queries(2) do
|
|
posts = Post.preload(:comments).order('posts.id')
|
|
assert posts.first.comments.first
|
|
end
|
|
|
|
assert_queries(2) do
|
|
posts = Post.preload(:comments).order('posts.id')
|
|
assert posts.first.comments.first
|
|
end
|
|
|
|
assert_queries(2) do
|
|
posts = Post.preload(:author).order('posts.id')
|
|
assert posts.first.author
|
|
end
|
|
|
|
assert_queries(2) do
|
|
posts = Post.preload(:author).order('posts.id')
|
|
assert posts.first.author
|
|
end
|
|
|
|
assert_queries(3) do
|
|
posts = Post.preload(:author, :comments).order('posts.id')
|
|
assert posts.first.author
|
|
assert posts.first.comments.first
|
|
end
|
|
end
|
|
|
|
def test_preload_applies_to_all_chained_preloaded_scopes
|
|
assert_queries(3) do
|
|
post = Post.with_comments.with_tags.first
|
|
assert post
|
|
end
|
|
end
|
|
|
|
def test_find_with_included_associations
|
|
assert_queries(2) do
|
|
posts = Post.includes(:comments).order('posts.id')
|
|
assert posts.first.comments.first
|
|
end
|
|
|
|
assert_queries(2) do
|
|
posts = Post.all.includes(:comments).order('posts.id')
|
|
assert posts.first.comments.first
|
|
end
|
|
|
|
assert_queries(2) do
|
|
posts = Post.includes(:author).order('posts.id')
|
|
assert posts.first.author
|
|
end
|
|
|
|
assert_queries(3) do
|
|
posts = Post.includes(:author, :comments).order('posts.id')
|
|
assert posts.first.author
|
|
assert posts.first.comments.first
|
|
end
|
|
end
|
|
|
|
def test_default_scope_with_conditions_string
|
|
assert_equal Developer.where(name: 'David').map(&:id).sort, DeveloperCalledDavid.all.map(&:id).sort
|
|
assert_nil DeveloperCalledDavid.create!.name
|
|
end
|
|
|
|
def test_default_scope_with_conditions_hash
|
|
assert_equal Developer.where(name: 'Jamis').map(&:id).sort, DeveloperCalledJamis.all.map(&:id).sort
|
|
assert_equal 'Jamis', DeveloperCalledJamis.create!.name
|
|
end
|
|
|
|
def test_default_scoping_finder_methods
|
|
developers = DeveloperCalledDavid.order('id').map(&:id).sort
|
|
assert_equal Developer.where(name: 'David').map(&:id).sort, developers
|
|
end
|
|
|
|
def test_loading_with_one_association
|
|
posts = Post.preload(:comments)
|
|
post = posts.find { |p| p.id == 1 }
|
|
assert_equal 2, post.comments.size
|
|
assert post.comments.include?(comments(:greetings))
|
|
|
|
post = Post.where("posts.title = 'Welcome to the weblog'").preload(:comments).first
|
|
assert_equal 2, post.comments.size
|
|
assert post.comments.include?(comments(:greetings))
|
|
|
|
posts = Post.preload(:last_comment)
|
|
post = posts.find { |p| p.id == 1 }
|
|
assert_equal Post.find(1).last_comment, post.last_comment
|
|
end
|
|
|
|
def test_to_sql_on_eager_join
|
|
expected = assert_sql {
|
|
Post.eager_load(:last_comment).order('comments.id DESC').to_a
|
|
}.first
|
|
actual = Post.eager_load(:last_comment).order('comments.id DESC').to_sql
|
|
assert_equal expected, actual
|
|
end
|
|
|
|
def test_loading_with_one_association_with_non_preload
|
|
posts = Post.eager_load(:last_comment).order('comments.id DESC')
|
|
post = posts.find { |p| p.id == 1 }
|
|
assert_equal Post.find(1).last_comment, post.last_comment
|
|
end
|
|
|
|
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.distinct.sort_by { |t| t.id }
|
|
assert_equal expected_taggings, author.taggings.uniq.sort_by { |t| t.id }
|
|
end
|
|
|
|
authors = Author.all
|
|
assert_equal david, authors.find_by_id_and_name(david.id, david.name)
|
|
assert_equal david, authors.find_by_id_and_name!(david.id, david.name)
|
|
end
|
|
|
|
def test_dynamic_find_by_attributes_bang
|
|
author = Author.all.find_by_id!(authors(:david).id)
|
|
assert_equal "David", author.name
|
|
|
|
assert_raises(ActiveRecord::RecordNotFound) { Author.all.find_by_id_and_name!(20, 'invalid') }
|
|
end
|
|
|
|
def test_find_id
|
|
authors = Author.all
|
|
|
|
david = authors.find(authors(:david).id)
|
|
assert_equal 'David', david.name
|
|
|
|
assert_raises(ActiveRecord::RecordNotFound) { authors.where(:name => 'lifo').find('42') }
|
|
end
|
|
|
|
def test_find_ids
|
|
authors = Author.order('id ASC')
|
|
|
|
results = authors.find(authors(:david).id, authors(:mary).id)
|
|
assert_kind_of Array, results
|
|
assert_equal 2, results.size
|
|
assert_equal 'David', results[0].name
|
|
assert_equal 'Mary', results[1].name
|
|
assert_equal results, authors.find([authors(:david).id, authors(:mary).id])
|
|
|
|
assert_raises(ActiveRecord::RecordNotFound) { authors.where(:name => 'lifo').find(authors(:david).id, '42') }
|
|
assert_raises(ActiveRecord::RecordNotFound) { authors.find(['42', 43]) }
|
|
end
|
|
|
|
def test_find_in_empty_array
|
|
authors = Author.all.where(:id => [])
|
|
assert authors.to_a.blank?
|
|
end
|
|
|
|
def test_where_with_ar_object
|
|
author = Author.first
|
|
authors = Author.all.where(:id => author)
|
|
assert_equal 1, authors.to_a.length
|
|
end
|
|
|
|
def test_find_with_list_of_ar
|
|
author = Author.first
|
|
authors = Author.find([author])
|
|
assert_equal author, authors.first
|
|
end
|
|
|
|
class Mary < Author; end
|
|
|
|
def test_find_by_classname
|
|
Author.create!(:name => Mary.name)
|
|
assert_equal 1, Author.where(:name => Mary).size
|
|
end
|
|
|
|
def test_find_by_id_with_list_of_ar
|
|
author = Author.first
|
|
authors = Author.find_by_id([author])
|
|
assert_equal author, authors
|
|
end
|
|
|
|
def test_find_all_using_where_twice_should_or_the_relation
|
|
david = authors(:david)
|
|
relation = Author.unscoped
|
|
relation = relation.where(:name => david.name)
|
|
relation = relation.where(:name => 'Santiago')
|
|
relation = relation.where(:id => david.id)
|
|
assert_equal [], relation.to_a
|
|
end
|
|
|
|
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
|
|
david = authors(:david)
|
|
relation = [
|
|
{ :name => david.name },
|
|
{ :name => 'Santiago' },
|
|
{ :name => 'tenderlove' },
|
|
].inject(Author.unscoped) do |memo, param|
|
|
memo.where(param)
|
|
end
|
|
assert_equal [], relation.to_a
|
|
end
|
|
|
|
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.to_a
|
|
}
|
|
end
|
|
|
|
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.to_a
|
|
}
|
|
end
|
|
|
|
def test_find_all_using_where_with_relation_does_not_alter_select_values
|
|
david = authors(:david)
|
|
|
|
subquery = Author.where(:id => david.id)
|
|
|
|
assert_queries(1) {
|
|
relation = Author.where(:id => subquery)
|
|
assert_equal [david], relation.to_a
|
|
}
|
|
|
|
assert_equal 0, subquery.select_values.size
|
|
end
|
|
|
|
def test_find_all_using_where_with_relation_with_joins
|
|
david = authors(:david)
|
|
assert_queries(1) {
|
|
relation = Author.where(:id => Author.joins(:posts).where(:id => david.id))
|
|
assert_equal [david], relation.to_a
|
|
}
|
|
end
|
|
|
|
|
|
def test_find_all_using_where_with_relation_with_select_to_build_subquery
|
|
david = authors(:david)
|
|
assert_queries(1) {
|
|
relation = Author.where(:name => Author.where(:id => david.id).select(:name))
|
|
assert_equal [david], relation.to_a
|
|
}
|
|
end
|
|
|
|
def test_exists
|
|
davids = Author.where(:name => 'David')
|
|
assert davids.exists?
|
|
assert davids.exists?(authors(:david).id)
|
|
assert ! davids.exists?(authors(:mary).id)
|
|
assert ! davids.exists?("42")
|
|
assert ! davids.exists?(42)
|
|
assert ! davids.exists?(davids.new)
|
|
|
|
fake = Author.where(:name => 'fake author')
|
|
assert ! fake.exists?
|
|
assert ! fake.exists?(authors(:david).id)
|
|
end
|
|
|
|
def test_last
|
|
authors = Author.all
|
|
assert_equal authors(:bob), authors.last
|
|
end
|
|
|
|
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
|
|
|
|
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
|
|
|
|
def test_delete_all_limit_error
|
|
assert_raises(ActiveRecord::ActiveRecordError) { Author.limit(10).delete_all }
|
|
end
|
|
|
|
def test_select_takes_a_variable_list_of_args
|
|
david = developers(:david)
|
|
|
|
developer = Developer.where(id: david.id).select(:name, :salary).first
|
|
assert_equal david.name, developer.name
|
|
assert_equal david.salary, developer.salary
|
|
end
|
|
|
|
def test_select_argument_error
|
|
assert_raises(ArgumentError) { Developer.select }
|
|
end
|
|
|
|
def test_relation_merging
|
|
devs = Developer.where("salary >= 80000").merge(Developer.limit(2)).merge(Developer.order('id ASC').where("id < 3"))
|
|
assert_equal [developers(:david), developers(:jamis)], devs.to_a
|
|
|
|
dev_with_count = Developer.limit(1).merge(Developer.order('id DESC')).merge(Developer.select('developers.*'))
|
|
assert_equal [developers(:poor_jamis)], dev_with_count.to_a
|
|
end
|
|
|
|
def test_relation_to_sql
|
|
sql = Post.connection.unprepared_statement do
|
|
Post.first.comments.to_sql
|
|
end
|
|
assert_no_match(/\?/, sql)
|
|
end
|
|
|
|
def test_relation_merging_with_arel_equalities_keeps_last_equality
|
|
devs = Developer.where(Developer.arel_table[:salary].eq(80000)).merge(
|
|
Developer.where(Developer.arel_table[:salary].eq(9000))
|
|
)
|
|
assert_equal [developers(:poor_jamis)], devs.to_a
|
|
end
|
|
|
|
def test_relation_merging_with_arel_equalities_keeps_last_equality_with_non_attribute_left_hand
|
|
salary_attr = Developer.arel_table[:salary]
|
|
devs = Developer.where(
|
|
Arel::Nodes::NamedFunction.new('abs', [salary_attr]).eq(80000)
|
|
).merge(
|
|
Developer.where(
|
|
Arel::Nodes::NamedFunction.new('abs', [salary_attr]).eq(9000)
|
|
)
|
|
)
|
|
assert_equal [developers(:poor_jamis)], devs.to_a
|
|
end
|
|
|
|
def test_relation_merging_with_eager_load
|
|
relations = []
|
|
relations << Post.order('comments.id DESC').merge(Post.eager_load(:last_comment)).merge(Post.all)
|
|
relations << Post.eager_load(:last_comment).merge(Post.order('comments.id DESC')).merge(Post.all)
|
|
|
|
relations.each do |posts|
|
|
post = posts.find { |p| p.id == 1 }
|
|
assert_equal Post.find(1).last_comment, post.last_comment
|
|
end
|
|
end
|
|
|
|
def test_relation_merging_with_locks
|
|
devs = Developer.lock.where("salary >= 80000").order("id DESC").merge(Developer.limit(2))
|
|
assert devs.locked.present?
|
|
end
|
|
|
|
def test_relation_merging_with_preload
|
|
[Post.all.merge(Post.preload(:author)), Post.preload(:author).merge(Post.all)].each do |posts|
|
|
assert_queries(2) { assert posts.first.author }
|
|
end
|
|
end
|
|
|
|
def test_relation_merging_with_joins
|
|
comments = Comment.joins(:post).where(:body => 'Thank you for the welcome').merge(Post.where(:body => 'Such a lovely day'))
|
|
assert_equal 1, comments.count
|
|
end
|
|
|
|
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
|
|
|
|
def test_count
|
|
posts = Post.all
|
|
|
|
assert_equal 11, posts.count
|
|
assert_equal 11, posts.count(:all)
|
|
assert_equal 11, posts.count(:id)
|
|
|
|
assert_equal 1, posts.where('comments_count > 1').count
|
|
assert_equal 9, posts.where(:comments_count => 0).count
|
|
end
|
|
|
|
def test_count_with_distinct
|
|
posts = Post.all
|
|
|
|
assert_equal 3, posts.distinct(true).count(:comments_count)
|
|
assert_equal 11, posts.distinct(false).count(:comments_count)
|
|
|
|
assert_equal 3, posts.distinct(true).select(:comments_count).count
|
|
assert_equal 11, posts.distinct(false).select(:comments_count).count
|
|
end
|
|
|
|
def test_count_explicit_columns
|
|
Post.update_all(:comments_count => nil)
|
|
posts = Post.all
|
|
|
|
assert_equal [0], posts.select('comments_count').where('id is not null').group('id').order('id').count.values.uniq
|
|
assert_equal 0, posts.where('id is not null').select('comments_count').count
|
|
|
|
assert_equal 11, posts.select('comments_count').count('id')
|
|
assert_equal 0, posts.select('comments_count').count
|
|
assert_equal 0, posts.count(:comments_count)
|
|
assert_equal 0, posts.count('comments_count')
|
|
end
|
|
|
|
def test_multiple_selects
|
|
post = Post.all.select('comments_count').select('title').order("id ASC").first
|
|
assert_equal "Welcome to the weblog", post.title
|
|
assert_equal 2, post.comments_count
|
|
end
|
|
|
|
def test_size
|
|
posts = Post.all
|
|
|
|
assert_queries(1) { assert_equal 11, posts.size }
|
|
assert ! posts.loaded?
|
|
|
|
best_posts = posts.where(:comments_count => 0)
|
|
best_posts.to_a # force load
|
|
assert_no_queries { assert_equal 9, best_posts.size }
|
|
end
|
|
|
|
def test_size_with_limit
|
|
posts = Post.limit(10)
|
|
|
|
assert_queries(1) { assert_equal 10, posts.size }
|
|
assert ! posts.loaded?
|
|
|
|
best_posts = posts.where(:comments_count => 0)
|
|
best_posts.to_a # force load
|
|
assert_no_queries { assert_equal 9, best_posts.size }
|
|
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
|
|
|
|
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
|
|
|
|
def test_empty
|
|
posts = Post.all
|
|
|
|
assert_queries(1) { assert_equal false, posts.empty? }
|
|
assert ! posts.loaded?
|
|
|
|
no_posts = posts.where(:title => "")
|
|
assert_queries(1) { assert_equal true, no_posts.empty? }
|
|
assert ! no_posts.loaded?
|
|
|
|
best_posts = posts.where(:comments_count => 0)
|
|
best_posts.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")
|
|
|
|
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
|
|
|
|
def test_any
|
|
posts = Post.all
|
|
|
|
# This test was failing when run on its own (as opposed to running the entire suite).
|
|
# The second line in the assert_queries block was causing visit_Arel_Attributes_Attribute
|
|
# in Arel::Visitors::ToSql to trigger a SHOW TABLES query. Running that line here causes
|
|
# the SHOW TABLES result to be cached so we don't have to do it again in the block.
|
|
#
|
|
# This is obviously a rubbish fix but it's the best I can come up with for now...
|
|
posts.where(:id => nil).any?
|
|
|
|
assert_queries(3) do
|
|
assert posts.any? # Uses COUNT()
|
|
assert ! posts.where(:id => nil).any?
|
|
|
|
assert posts.any? {|p| p.id > 0 }
|
|
assert ! posts.any? {|p| p.id <= 0 }
|
|
end
|
|
|
|
assert posts.loaded?
|
|
end
|
|
|
|
def test_many
|
|
posts = Post.all
|
|
|
|
assert_queries(2) do
|
|
assert posts.many? # Uses COUNT()
|
|
assert posts.many? {|p| p.id > 0 }
|
|
assert ! posts.many? {|p| p.id < 2 }
|
|
end
|
|
|
|
assert posts.loaded?
|
|
end
|
|
|
|
def test_many_with_limits
|
|
posts = Post.all
|
|
|
|
assert posts.many?
|
|
assert ! posts.limit(1).many?
|
|
end
|
|
|
|
def test_build
|
|
posts = Post.all
|
|
|
|
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
|
|
|
|
def test_create
|
|
birds = Bird.all
|
|
|
|
sparrow = birds.create
|
|
assert_kind_of Bird, sparrow
|
|
assert !sparrow.persisted?
|
|
|
|
hen = birds.where(:name => 'hen').create
|
|
assert hen.persisted?
|
|
assert_equal 'hen', hen.name
|
|
end
|
|
|
|
def test_create_bang
|
|
birds = Bird.all
|
|
|
|
assert_raises(ActiveRecord::RecordInvalid) { birds.create! }
|
|
|
|
hen = birds.where(:name => 'hen').create!
|
|
assert_kind_of Bird, hen
|
|
assert hen.persisted?
|
|
assert_equal 'hen', hen.name
|
|
end
|
|
|
|
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
|
|
Bird.where(:color => 'green').first_or_create! { |bird| bird.pirate_id = 1 }
|
|
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
|
|
|
|
def test_first_or_initialize
|
|
parrot = Bird.where(:color => 'green').first_or_initialize(:name => 'parrot')
|
|
assert_kind_of Bird, parrot
|
|
assert !parrot.persisted?
|
|
assert parrot.valid?
|
|
assert parrot.new_record?
|
|
assert_equal 'parrot', parrot.name
|
|
assert_equal 'green', parrot.color
|
|
end
|
|
|
|
def test_first_or_initialize_with_no_parameters
|
|
parrot = Bird.where(:color => 'green').first_or_initialize
|
|
assert_kind_of Bird, parrot
|
|
assert !parrot.persisted?
|
|
assert !parrot.valid?
|
|
assert parrot.new_record?
|
|
assert_equal 'green', parrot.color
|
|
end
|
|
|
|
def test_first_or_initialize_with_block
|
|
parrot = Bird.where(:color => 'green').first_or_initialize { |bird| bird.name = 'parrot' }
|
|
assert_kind_of Bird, parrot
|
|
assert !parrot.persisted?
|
|
assert parrot.valid?
|
|
assert parrot.new_record?
|
|
assert_equal 'green', parrot.color
|
|
assert_equal 'parrot', parrot.name
|
|
end
|
|
|
|
def test_find_or_create_by
|
|
assert_nil Bird.find_by(name: 'bob')
|
|
|
|
bird = Bird.find_or_create_by(name: 'bob')
|
|
assert bird.persisted?
|
|
|
|
assert_equal bird, Bird.find_or_create_by(name: 'bob')
|
|
end
|
|
|
|
def test_find_or_create_by_with_create_with
|
|
assert_nil Bird.find_by(name: 'bob')
|
|
|
|
bird = Bird.create_with(color: 'green').find_or_create_by(name: 'bob')
|
|
assert bird.persisted?
|
|
assert_equal 'green', bird.color
|
|
|
|
assert_equal bird, Bird.create_with(color: 'blue').find_or_create_by(name: 'bob')
|
|
end
|
|
|
|
def test_find_or_create_by!
|
|
assert_raises(ActiveRecord::RecordInvalid) { Bird.find_or_create_by!(color: 'green') }
|
|
end
|
|
|
|
def test_find_or_initialize_by
|
|
assert_nil Bird.find_by(name: 'bob')
|
|
|
|
bird = Bird.find_or_initialize_by(name: 'bob')
|
|
assert bird.new_record?
|
|
bird.save!
|
|
|
|
assert_equal bird, Bird.find_or_initialize_by(name: 'bob')
|
|
end
|
|
|
|
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
|
|
|
|
def test_except
|
|
relation = Post.where(:author_id => 1).order('id ASC').limit(1)
|
|
assert_equal [posts(:welcome)], relation.to_a
|
|
|
|
author_posts = relation.except(:order, :limit)
|
|
assert_equal Post.where(:author_id => 1).to_a, author_posts.to_a
|
|
|
|
all_posts = relation.except(:where, :order, :limit)
|
|
assert_equal Post.all, all_posts
|
|
end
|
|
|
|
def test_only
|
|
relation = Post.where(:author_id => 1).order('id ASC').limit(1)
|
|
assert_equal [posts(:welcome)], relation.to_a
|
|
|
|
author_posts = relation.only(:where)
|
|
assert_equal Post.where(:author_id => 1).to_a, author_posts.to_a
|
|
|
|
all_posts = relation.only(:limit)
|
|
assert_equal Post.limit(1).to_a.first, all_posts.first
|
|
end
|
|
|
|
def test_anonymous_extension
|
|
relation = Post.where(:author_id => 1).order('id ASC').extending do
|
|
def author
|
|
'lifo'
|
|
end
|
|
end
|
|
|
|
assert_equal "lifo", relation.author
|
|
assert_equal "lifo", relation.limit(1).author
|
|
end
|
|
|
|
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
|
|
|
|
def test_order_by_relation_attribute
|
|
assert_equal Post.order(Post.arel_table[:title]).to_a, Post.order("title").to_a
|
|
end
|
|
|
|
def test_default_scope_order_with_scope_order
|
|
assert_equal 'zyke', CoolCar.order_using_new_style.limit(1).first.name
|
|
assert_equal 'zyke', FastCar.order_using_new_style.limit(1).first.name
|
|
end
|
|
|
|
def test_order_using_scoping
|
|
car1 = CoolCar.order('id DESC').scoping do
|
|
CoolCar.all.merge!(order: 'id asc').first
|
|
end
|
|
assert_equal 'zyke', car1.name
|
|
|
|
car2 = FastCar.order('id DESC').scoping do
|
|
FastCar.all.merge!(order: 'id asc').first
|
|
end
|
|
assert_equal 'zyke', car2.name
|
|
end
|
|
|
|
def test_unscoped_block_style
|
|
assert_equal 'honda', CoolCar.unscoped { CoolCar.order_using_new_style.limit(1).first.name}
|
|
assert_equal 'honda', FastCar.unscoped { FastCar.order_using_new_style.limit(1).first.name}
|
|
end
|
|
|
|
def test_intersection_with_array
|
|
relation = Author.where(:name => "David")
|
|
rails_author = relation.first
|
|
|
|
assert_equal [rails_author], [rails_author] & relation
|
|
assert_equal [rails_author], relation & [rails_author]
|
|
end
|
|
|
|
def test_primary_key
|
|
assert_equal "id", Post.all.primary_key
|
|
end
|
|
|
|
def test_disable_implicit_join_references_is_deprecated
|
|
assert_deprecated do
|
|
ActiveRecord::Base.disable_implicit_join_references = true
|
|
end
|
|
end
|
|
|
|
def test_ordering_with_extra_spaces
|
|
assert_equal authors(:david), Author.order('id DESC , name DESC').last
|
|
end
|
|
|
|
def test_update_all_with_blank_argument
|
|
assert_raises(ArgumentError) { Comment.update_all({}) }
|
|
end
|
|
|
|
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
|
|
|
|
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
|
|
all_comments = Comment.joins(:post).where('posts.id' => posts(:welcome).id).order('posts.id', 'comments.id')
|
|
count = all_comments.count
|
|
comments = all_comments.offset(1)
|
|
|
|
assert_equal count - 1, comments.update_all(:post_id => posts(:thinking).id)
|
|
assert_equal posts(:thinking), comments(:more_greetings).post
|
|
assert_equal posts(:welcome), comments(:greetings).post
|
|
end
|
|
|
|
def test_distinct
|
|
tag1 = Tag.create(:name => 'Foo')
|
|
tag2 = Tag.create(:name => 'Foo')
|
|
|
|
query = Tag.select(:name).where(:id => [tag1.id, tag2.id])
|
|
|
|
assert_equal ['Foo', 'Foo'], query.map(&:name)
|
|
assert_sql(/DISTINCT/) do
|
|
assert_equal ['Foo'], query.distinct.map(&:name)
|
|
assert_equal ['Foo'], query.uniq.map(&:name)
|
|
end
|
|
assert_sql(/DISTINCT/) do
|
|
assert_equal ['Foo'], query.distinct(true).map(&:name)
|
|
assert_equal ['Foo'], query.uniq(true).map(&:name)
|
|
end
|
|
assert_equal ['Foo', 'Foo'], query.distinct(true).distinct(false).map(&:name)
|
|
assert_equal ['Foo', 'Foo'], query.uniq(true).uniq(false).map(&:name)
|
|
end
|
|
|
|
def test_doesnt_add_having_values_if_options_are_blank
|
|
scope = Post.having('')
|
|
assert_equal [], scope.having_values
|
|
|
|
scope = Post.having([])
|
|
assert_equal [], scope.having_values
|
|
end
|
|
|
|
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
|
|
|
|
def test_automatically_added_where_references
|
|
scope = Post.where(:comments => { :body => "Bla" })
|
|
assert_equal ['comments'], scope.references_values
|
|
|
|
scope = Post.where('comments.body' => 'Bla')
|
|
assert_equal ['comments'], scope.references_values
|
|
end
|
|
|
|
def test_automatically_added_having_references
|
|
scope = Post.having(:comments => { :body => "Bla" })
|
|
assert_equal ['comments'], scope.references_values
|
|
|
|
scope = Post.having('comments.body' => 'Bla')
|
|
assert_equal ['comments'], scope.references_values
|
|
end
|
|
|
|
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
|
|
|
|
def test_automatically_added_reorder_references
|
|
scope = Post.reorder('comments.body')
|
|
assert_equal %w(comments), scope.references_values
|
|
|
|
scope = Post.reorder('comments.body', 'yaks.body')
|
|
assert_equal %w(comments yaks), scope.references_values
|
|
|
|
# Don't infer yaks, let's not go down that road again...
|
|
scope = Post.reorder('comments.body, yaks.body')
|
|
assert_equal %w(comments), scope.references_values
|
|
|
|
scope = Post.reorder('comments.body asc')
|
|
assert_equal %w(comments), scope.references_values
|
|
|
|
scope = Post.reorder('foo(comments.body)')
|
|
assert_equal [], scope.references_values
|
|
end
|
|
|
|
def test_presence
|
|
topics = Topic.all
|
|
|
|
# the first query is triggered because there are no topics yet.
|
|
assert_queries(1) { assert topics.present? }
|
|
|
|
# checking if there are topics is used before you actually display them,
|
|
# thus it shouldn't invoke an extra count query.
|
|
assert_no_queries { assert topics.present? }
|
|
assert_no_queries { assert !topics.blank? }
|
|
|
|
# shows count of topics and loops after loading the query should not trigger extra queries either.
|
|
assert_no_queries { topics.size }
|
|
assert_no_queries { topics.length }
|
|
assert_no_queries { topics.each }
|
|
|
|
# count always trigger the COUNT query.
|
|
assert_queries(1) { topics.count }
|
|
|
|
assert topics.loaded?
|
|
end
|
|
|
|
test "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.all.find_by("1 = 0")
|
|
end
|
|
|
|
test "find_by doesn't have implicit ordering" do
|
|
assert_sql(/^((?!ORDER).)*$/) { Post.find_by(author_id: 2) }
|
|
end
|
|
|
|
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! doesn't have implicit ordering" do
|
|
assert_sql(/^((?!ORDER).)*$/) { Post.find_by!(author_id: 2) }
|
|
end
|
|
|
|
test "find_by! raises RecordNotFound if the record is missing" do
|
|
assert_raises(ActiveRecord::RecordNotFound) do
|
|
Post.all.find_by!("1 = 0")
|
|
end
|
|
end
|
|
|
|
test "loaded relations cannot be mutated by multi value methods" do
|
|
relation = Post.all
|
|
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.all
|
|
relation.to_a
|
|
|
|
assert_raises(ActiveRecord::ImmutableRelation) do
|
|
relation.limit! 5
|
|
end
|
|
end
|
|
|
|
test "loaded relations cannot be mutated by merge!" do
|
|
relation = Post.all
|
|
relation.to_a
|
|
|
|
assert_raises(ActiveRecord::ImmutableRelation) do
|
|
relation.merge! where: 'foo'
|
|
end
|
|
end
|
|
|
|
test "loaded relations cannot be mutated by extending!" do
|
|
relation = Post.all
|
|
relation.to_a
|
|
|
|
assert_raises(ActiveRecord::ImmutableRelation) do
|
|
relation.extending! Module.new
|
|
end
|
|
end
|
|
|
|
test "relations show the records in #inspect" do
|
|
relation = Post.limit(2)
|
|
assert_equal "#<ActiveRecord::Relation [#{Post.limit(2).map(&:inspect).join(', ')}]>", relation.inspect
|
|
end
|
|
|
|
test "relations limit the records in #inspect at 10" do
|
|
relation = Post.limit(11)
|
|
assert_equal "#<ActiveRecord::Relation [#{Post.limit(10).map(&:inspect).join(', ')}, ...]>", relation.inspect
|
|
end
|
|
|
|
test "already-loaded relations don't perform a new query in #inspect" do
|
|
relation = Post.limit(2)
|
|
relation.to_a
|
|
|
|
expected = "#<ActiveRecord::Relation [#{Post.limit(2).map(&:inspect).join(', ')}]>"
|
|
|
|
assert_no_queries do
|
|
assert_equal expected, relation.inspect
|
|
end
|
|
end
|
|
|
|
test 'using a custom table affects the wheres' do
|
|
table_alias = Post.arel_table.alias('omg_posts')
|
|
|
|
relation = ActiveRecord::Relation.new Post, table_alias
|
|
relation.where!(:foo => "bar")
|
|
|
|
node = relation.arel.constraints.first.grep(Arel::Attributes::Attribute).first
|
|
assert_equal table_alias, node.relation
|
|
end
|
|
|
|
test '#load' do
|
|
relation = Post.all
|
|
assert_queries(1) do
|
|
assert_equal relation, relation.load
|
|
end
|
|
assert_no_queries { relation.to_a }
|
|
end
|
|
|
|
test 'group with select and includes' do
|
|
authors_count = Post.select('author_id, COUNT(author_id) AS num_posts').
|
|
group('author_id').order('author_id').includes(:author).to_a
|
|
|
|
assert_no_queries do
|
|
result = authors_count.map do |post|
|
|
[post.num_posts, post.author.try(:name)]
|
|
end
|
|
|
|
expected = [[1, nil], [5, "David"], [3, "Mary"], [2, "Bob"]]
|
|
assert_equal expected, result
|
|
end
|
|
end
|
|
|
|
test "delegations do not leak to other classes" do
|
|
Topic.all.by_lifo
|
|
assert Topic.all.class.method_defined?(:by_lifo)
|
|
assert !Post.all.respond_to?(:by_lifo)
|
|
end
|
|
|
|
class OMGTopic < ActiveRecord::Base
|
|
self.table_name = 'topics'
|
|
|
|
def self.__omg__
|
|
"omgtopic"
|
|
end
|
|
end
|
|
|
|
test "delegations do not clash across classes" do
|
|
begin
|
|
class ::Array
|
|
def __omg__
|
|
"array"
|
|
end
|
|
end
|
|
|
|
assert_equal "array", Topic.all.__omg__
|
|
assert_equal "omgtopic", OMGTopic.all.__omg__
|
|
ensure
|
|
Array.send(:remove_method, :__omg__)
|
|
end
|
|
end
|
|
|
|
test "merge collapses wheres from the LHS only" do
|
|
left = Post.where(title: "omg").where(comments_count: 1)
|
|
right = Post.where(title: "wtf").where(title: "bbq")
|
|
|
|
expected = [left.where_values[1]] + right.where_values
|
|
merged = left.merge(right)
|
|
|
|
assert_equal expected, merged.where_values
|
|
assert !merged.to_sql.include?("omg")
|
|
assert merged.to_sql.include?("wtf")
|
|
assert merged.to_sql.include?("bbq")
|
|
end
|
|
|
|
def test_merging_removes_rhs_bind_parameters
|
|
left = Post.where(id: Arel::Nodes::BindParam.new('?'))
|
|
column = Post.columns_hash['id']
|
|
left.bind_values += [[column, 20]]
|
|
right = Post.where(id: 10)
|
|
|
|
merged = left.merge(right)
|
|
assert_equal [], merged.bind_values
|
|
end
|
|
|
|
def test_merging_keeps_lhs_bind_parameters
|
|
column = Post.columns_hash['id']
|
|
binds = [[column, 20]]
|
|
|
|
right = Post.where(id: Arel::Nodes::BindParam.new('?'))
|
|
right.bind_values += binds
|
|
left = Post.where(id: 10)
|
|
|
|
merged = left.merge(right)
|
|
assert_equal binds, merged.bind_values
|
|
end
|
|
|
|
def test_merging_reorders_bind_params
|
|
post = Post.first
|
|
id_column = Post.columns_hash['id']
|
|
title_column = Post.columns_hash['title']
|
|
|
|
bv = Post.connection.substitute_at id_column, 0
|
|
|
|
right = Post.where(id: bv)
|
|
right.bind_values += [[id_column, post.id]]
|
|
|
|
left = Post.where(title: bv)
|
|
left.bind_values += [[title_column, post.title]]
|
|
|
|
merged = left.merge(right)
|
|
assert_equal post, merged.first
|
|
end
|
|
end
|