ibm_db 3.0.3 → 5.0.3

data/test/cases/associations/has_one_through_associations_test.rb

@@ -15,6 +15,7 @@ require 'models/essay'
 require 'models/owner'
 require 'models/post'
 require 'models/comment'
+require 'models/categorization'
 require 'models/customer'
 require 'models/carrier'
 require 'models/shop_account'
@@ -22,7 +23,7 @@ require 'models/customer_carrier'
 
 class HasOneThroughAssociationsTest < ActiveRecord::TestCase
   fixtures :member_types, :members, :clubs, :memberships, :sponsors, :organizations, :minivans,
-           :dashboards, :speedometers, :authors, :posts, :comments, :categories, :essays, :owners, :author_addresses
+           :dashboards, :speedometers, :authors, :posts, :comments, :categories, :essays, :owners
 
   def setup
     @member = members(:groucho)
@@ -248,12 +249,14 @@ class HasOneThroughAssociationsTest < ActiveRecord::TestCase
     assert_not_nil @member_detail.member_type
     @member_detail.destroy
     assert_queries(1) do
-      assert_not_nil @member_detail.member_type(true)
+      @member_detail.association(:member_type).reload
+      assert_not_nil @member_detail.member_type
     end
 
     @member_detail.member.destroy
     assert_queries(1) do
-      assert_nil @member_detail.member_type(true)
+      @member_detail.association(:member_type).reload
+      assert_nil @member_detail.member_type
     end
   end
 

data/test/cases/associations/inner_join_association_test.rb

@@ -11,7 +11,7 @@ require 'models/tag'
 
 class InnerJoinAssociationTest < ActiveRecord::TestCase
   fixtures :authors, :essays, :posts, :comments, :categories, :categories_posts, :categorizations,
-           :taggings, :tags, :author_addresses
+           :taggings, :tags
 
   def test_construct_finder_sql_applies_aliases_tables_on_association_conditions
     result = Author.joins(:thinking_posts, :welcome_posts).to_a
@@ -54,7 +54,7 @@ class InnerJoinAssociationTest < ActiveRecord::TestCase
   def test_find_with_implicit_inner_joins_without_select_does_not_imply_readonly
     authors = Author.joins(:posts)
     assert_not authors.empty?, "expected authors to be non-empty"
-    assert authors.none? {|a| a.readonly? }, "expected no authors to be readonly"
+    assert authors.none?(&:readonly?), "expected no authors to be readonly"
   end
 
   def test_find_with_implicit_inner_joins_honors_readonly_with_select
@@ -102,7 +102,7 @@ class InnerJoinAssociationTest < ActiveRecord::TestCase
 
   def test_find_with_conditions_on_reflection
     assert !posts(:welcome).comments.empty?
-    assert Post.joins(:nonexistant_comments).where(:id => posts(:welcome).id).empty? # [sic!]
+    assert Post.joins(:nonexistent_comments).where(:id => posts(:welcome).id).empty? # [sic!]
   end
 
   def test_find_with_conditions_on_through_reflection

data/test/cases/associations/inverse_associations_test.rb

@@ -13,6 +13,9 @@ require 'models/mixed_case_monkey'
 require 'models/admin'
 require 'models/admin/account'
 require 'models/admin/user'
+require 'models/developer'
+require 'models/company'
+require 'models/project'
 
 class AutomaticInverseFindingTests < ActiveRecord::TestCase
   fixtures :ratings, :comments, :cars
@@ -80,10 +83,10 @@ class AutomaticInverseFindingTests < ActiveRecord::TestCase
 
     assert_equal rating.comment, comment, "The Rating's comment should be the original Comment"
 
-    rating.comment.body = "Brogramming is the act of programming, like a bro."
+    rating.comment.body = "Fennec foxes are the smallest of the foxes."
     assert_equal rating.comment.body, comment.body, "Changing the Comment's body on the association should change the original Comment's body"
 
-    comment.body = "Broseiden is the king of the sea of bros."
+    comment.body = "Kittens are adorable."
     assert_equal comment.body, rating.comment.body, "Changing the original Comment's body should change the Comment's body on the association"
   end
 
@@ -94,10 +97,10 @@ class AutomaticInverseFindingTests < ActiveRecord::TestCase
 
     assert_equal rating.comment, comment, "The Rating's comment should be the original Comment"
 
-    rating.comment.body = "Brogramming is the act of programming, like a bro."
+    rating.comment.body = "Fennec foxes are the smallest of the foxes."
     assert_equal rating.comment.body, comment.body, "Changing the Comment's body on the association should change the original Comment's body"
 
-    comment.body = "Broseiden is the king of the sea of bros."
+    comment.body = "Kittens are adorable."
     assert_equal comment.body, rating.comment.body, "Changing the original Comment's body should change the Comment's body on the association"
   end
 
@@ -127,15 +130,15 @@ end
 
 class InverseAssociationTests < ActiveRecord::TestCase
   def test_should_allow_for_inverse_of_options_in_associations
-    assert_nothing_raised(ArgumentError, 'ActiveRecord should allow the inverse_of options on has_many') do
+    assert_nothing_raised do
       Class.new(ActiveRecord::Base).has_many(:wheels, :inverse_of => :car)
     end
 
-    assert_nothing_raised(ArgumentError, 'ActiveRecord should allow the inverse_of options on has_one') do
+    assert_nothing_raised do
       Class.new(ActiveRecord::Base).has_one(:engine, :inverse_of => :car)
     end
 
-    assert_nothing_raised(ArgumentError, 'ActiveRecord should allow the inverse_of options on belongs_to') do
+    assert_nothing_raised do
       Class.new(ActiveRecord::Base).belongs_to(:car, :inverse_of => :driver)
     end
   end
@@ -198,6 +201,16 @@ class InverseAssociationTests < ActiveRecord::TestCase
     belongs_to_ref = Sponsor.reflect_on_association(:sponsor_club)
     assert_nil belongs_to_ref.inverse_of
   end
+
+  def test_this_inverse_stuff
+    firm = Firm.create!(name: 'Adequate Holdings')
+    Project.create!(name: 'Project 1', firm: firm)
+    Developer.create!(name: 'Gorbypuff', firm: firm)
+
+    new_project = Project.last
+    assert Project.reflect_on_association(:lead_developer).inverse_of.present?, "Expected inverse of to be present"
+    assert new_project.lead_developer.present?, "Expected lead developer to be present on the project"
+  end
 end
 
 class InverseHasOneTests < ActiveRecord::TestCase
@@ -482,6 +495,33 @@ class InverseHasManyTests < ActiveRecord::TestCase
 
     assert !man.persisted?
   end
+
+  def test_inverse_instance_should_be_set_before_find_callbacks_are_run
+    reset_callbacks(Interest, :find) do
+      Interest.after_find { raise unless association(:man).loaded? && man.present? }
+
+      assert Man.first.interests.reload.any?
+      assert Man.includes(:interests).first.interests.any?
+      assert Man.joins(:interests).includes(:interests).first.interests.any?
+    end
+  end
+
+  def test_inverse_instance_should_be_set_before_initialize_callbacks_are_run
+    reset_callbacks(Interest, :initialize) do
+      Interest.after_initialize { raise unless association(:man).loaded? && man.present? }
+
+      assert Man.first.interests.reload.any?
+      assert Man.includes(:interests).first.interests.any?
+      assert Man.joins(:interests).includes(:interests).first.interests.any?
+    end
+  end
+
+  def reset_callbacks(target, type)
+    old_callbacks = target.send(:get_callbacks, type).deep_dup
+    yield
+  ensure
+    target.send(:set_callbacks, type, old_callbacks) if old_callbacks
+  end
 end
 
 class InverseBelongsToTests < ActiveRecord::TestCase
@@ -653,7 +693,7 @@ class InversePolymorphicBelongsToTests < ActiveRecord::TestCase
 
   def test_trying_to_access_inverses_that_dont_exist_shouldnt_raise_an_error
     # Ideally this would, if only for symmetry's sake with other association types
-    assert_nothing_raised(ActiveRecord::InverseOfAssociationNotFoundError) { Face.first.horrible_polymorphic_man }
+    assert_nothing_raised { Face.first.horrible_polymorphic_man }
   end
 
   def test_trying_to_set_polymorphic_inverses_that_dont_exist_at_all_should_raise_an_error
@@ -663,7 +703,7 @@ class InversePolymorphicBelongsToTests < ActiveRecord::TestCase
 
   def test_trying_to_set_polymorphic_inverses_that_dont_exist_on_the_instance_being_set_should_raise_an_error
     # passes because Man does have the correct inverse_of
-    assert_nothing_raised(ActiveRecord::InverseOfAssociationNotFoundError) { Face.first.polymorphic_man = Man.first }
+    assert_nothing_raised { Face.first.polymorphic_man = Man.first }
     # fails because Interest does have the correct inverse_of
     assert_raise(ActiveRecord::InverseOfAssociationNotFoundError) { Face.first.polymorphic_man = Interest.first }
   end
@@ -675,7 +715,7 @@ class InverseMultipleHasManyInversesForSameModel < ActiveRecord::TestCase
   fixtures :men, :interests, :zines
 
   def test_that_we_can_load_associations_that_have_the_same_reciprocal_name_from_different_models
-    assert_nothing_raised(ActiveRecord::AssociationTypeMismatch) do
+    assert_nothing_raised do
       i = Interest.first
       i.zine
       i.man
@@ -683,7 +723,7 @@ class InverseMultipleHasManyInversesForSameModel < ActiveRecord::TestCase
   end
 
   def test_that_we_can_create_associations_that_have_the_same_reciprocal_name_from_different_models
-    assert_nothing_raised(ActiveRecord::AssociationTypeMismatch) do
+    assert_nothing_raised do
       i = Interest.first
       i.build_zine(:title => 'Get Some in Winter! 2008')
       i.build_man(:name => 'Gordon')

data/test/cases/associations/join_model_test.rb

@@ -17,9 +17,9 @@ require 'models/engine'
 require 'models/car'
 
 class AssociationsJoinModelTest < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false unless supports_savepoints?
+  self.use_transactional_tests = false unless supports_savepoints?
 
-  fixtures :posts, :authors, :categories, :categorizations, :comments, :tags, :taggings, :author_favorites, :vertices, :items, :books, :author_addresses,
+  fixtures :posts, :authors, :categories, :categorizations, :comments, :tags, :taggings, :author_favorites, :vertices, :items, :books,
     # Reload edges table from fixtures as otherwise repeated test was failing
     :edges
 
@@ -35,12 +35,12 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     assert categories(:sti_test).authors.include?(authors(:mary))
   end
 
-  def test_has_many_uniq_through_join_model
+  def test_has_many_distinct_through_join_model
     assert_equal 2, authors(:mary).categorized_posts.size
     assert_equal 1, authors(:mary).unique_categorized_posts.size
   end
 
-  def test_has_many_uniq_through_count
+  def test_has_many_distinct_through_count
     author = authors(:mary)
     assert !authors(:mary).unique_categorized_posts.loaded?
     assert_queries(1) { assert_equal 1, author.unique_categorized_posts.count }
@@ -49,7 +49,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     assert !authors(:mary).unique_categorized_posts.loaded?
   end
 
-  def test_has_many_uniq_through_find
+  def test_has_many_distinct_through_find
     assert_equal 1, authors(:mary).unique_categorized_posts.to_a.size
   end
 
@@ -88,7 +88,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
   def test_polymorphic_has_many_going_through_join_model_with_custom_select_and_joins
     assert_equal tags(:general), tag = posts(:welcome).tags.add_joins_and_select.first
-    assert_nothing_raised(NoMethodError) { tag.author_id }
+    assert_nothing_raised { tag.author_id }
   end
 
   def test_polymorphic_has_many_going_through_join_model_with_custom_foreign_key
@@ -213,7 +213,8 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     old_count = Tagging.count
     post.destroy
     assert_equal old_count-1, Tagging.count
-    assert_nil posts(:welcome).tagging(true)
+    posts(:welcome).association(:tagging).reload
+    assert_nil posts(:welcome).tagging
   end
 
   def test_delete_polymorphic_has_one_with_nullify
@@ -224,7 +225,8 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     old_count = Tagging.count
     post.destroy
     assert_equal old_count, Tagging.count
-    assert_nil posts(:welcome).tagging(true)
+    posts(:welcome).association(:tagging).reload
+    assert_nil posts(:welcome).tagging
   end
 
   def test_has_many_with_piggyback
@@ -361,6 +363,13 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     assert_equal posts(:welcome, :thinking).sort_by(&:id), tags(:general).tagged_posts.sort_by(&:id)
   end
 
+  def test_has_many_polymorphic_associations_merges_through_scope
+    Tag.has_many :null_taggings, -> { none }, class_name: :Tagging
+    Tag.has_many :null_tagged_posts, :through => :null_taggings, :source => 'taggable', :source_type => 'Post'
+    assert_equal [], tags(:general).null_tagged_posts
+    refute_equal [], tags(:general).tagged_posts
+  end
+
   def test_eager_has_many_polymorphic_with_source_type
     tag_with_include = Tag.all.merge!(:includes => :tagged_posts).find(tags(:general).id)
     desired = posts(:welcome, :thinking)
@@ -393,32 +402,29 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_has_many_through_polymorphic_has_one
-    assert_equal Tagging.find(1,2).sort_by { |t| t.id }, authors(:david).taggings_2
+    assert_equal Tagging.find(1,2).sort_by(&:id), authors(:david).taggings_2
   end
 
   def test_has_many_through_polymorphic_has_many
-    assert_equal taggings(:welcome_general, :thinking_general), authors(:david).taggings.distinct.sort_by { |t| t.id }
+    assert_equal taggings(:welcome_general, :thinking_general), authors(:david).taggings.distinct.sort_by(&:id)
   end
 
   def test_include_has_many_through_polymorphic_has_many
     author            = Author.includes(:taggings).find authors(: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.distinct.sort_by(&:id)
     end
   end
 
-  unless current_adapter?(:IBM_DBAdapter)
-    # DB2 throws SQL0214N
-    def test_eager_load_has_many_through_has_many
-      author = Author.all.merge!(:where => ['name = ?', 'David'], :includes => :comments, :order => 'comments.id').first
-      SpecialComment.new; VerySpecialComment.new
-      assert_no_queries do
-        assert_equal [1,2,3,5,6,7,8,9,10,12], author.comments.collect(&:id)
-      end
+  def test_eager_load_has_many_through_has_many
+    author = Author.all.merge!(:where => ['name = ?', 'David'], :includes => :comments, :order => 'comments.id').first
+    SpecialComment.new; VerySpecialComment.new
+    assert_no_queries do
+      assert_equal [1,2,3,5,6,7,8,9,10,12], author.comments.collect(&:id)
     end
   end
-	
+
   def test_eager_load_has_many_through_has_many_with_conditions
     post = Post.all.merge!(:includes => :invalid_tags).first
     assert_no_queries do
@@ -447,7 +453,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   def test_has_many_through_uses_conditions_specified_on_the_has_many_association
     author = Author.first
     assert author.comments.present?
-    assert author.nonexistant_comments.blank?
+    assert author.nonexistent_comments.blank?
   end
 
   def test_has_many_through_uses_correct_attributes
@@ -464,7 +470,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     assert saved_post.tags.include?(new_tag)
 
     assert new_tag.persisted?
-    assert saved_post.reload.tags(true).include?(new_tag)
+    assert saved_post.reload.tags.reload.include?(new_tag)
 
 
     new_post = Post.new(:title => "Association replacement works!", :body => "You best believe it.")
@@ -477,7 +483,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
 
     new_post.save!
     assert new_post.persisted?
-    assert new_post.reload.tags(true).include?(saved_tag)
+    assert new_post.reload.tags.reload.include?(saved_tag)
 
     assert !posts(:thinking).tags.build.persisted?
     assert !posts(:thinking).tags.new.persisted?
@@ -493,7 +499,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     assert_nil( wrong = post_thinking.taggings.detect { |t| t.class != Tagging },
                 message = "Expected a Tagging in taggings collection, got #{wrong.class}.")
     assert_equal(count + 1, post_thinking.reload.tags.size)
-    assert_equal(count + 1, post_thinking.tags(true).size)
+    assert_equal(count + 1, post_thinking.tags.reload.size)
 
     assert_kind_of Tag, post_thinking.tags.create!(:name => 'foo')
     assert_nil( wrong = post_thinking.tags.detect { |t| t.class != Tag },
@@ -501,7 +507,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     assert_nil( wrong = post_thinking.taggings.detect { |t| t.class != Tagging },
                 message = "Expected a Tagging in taggings collection, got #{wrong.class}.")
     assert_equal(count + 2, post_thinking.reload.tags.size)
-    assert_equal(count + 2, post_thinking.tags(true).size)
+    assert_equal(count + 2, post_thinking.tags.reload.size)
 
     assert_nothing_raised { post_thinking.tags.concat(Tag.create!(:name => 'abc'), Tag.create!(:name => 'def')) }
     assert_nil( wrong = post_thinking.tags.detect { |t| t.class != Tag },
@@ -509,7 +515,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     assert_nil( wrong = post_thinking.taggings.detect { |t| t.class != Tagging },
                 message = "Expected a Tagging in taggings collection, got #{wrong.class}.")
     assert_equal(count + 4, post_thinking.reload.tags.size)
-    assert_equal(count + 4, post_thinking.tags(true).size)
+    assert_equal(count + 4, post_thinking.tags.reload.size)
 
     # Raises if the wrong reflection name is used to set the Edge belongs_to
     assert_nothing_raised { vertices(:vertex_1).sinks << vertices(:vertex_5) }
@@ -547,11 +553,11 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     book = Book.create!(:name => 'Getting Real')
     book_awdr = books(:awdr)
     book_awdr.references << book
-    assert_equal(count + 1, book_awdr.references(true).size)
+    assert_equal(count + 1, book_awdr.references.reload.size)
 
     assert_nothing_raised { book_awdr.references.delete(book) }
     assert_equal(count, book_awdr.references.size)
-    assert_equal(count, book_awdr.references(true).size)
+    assert_equal(count, book_awdr.references.reload.size)
     assert_equal(references_before.sort, book_awdr.references.sort)
   end
 
@@ -561,14 +567,14 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     tag = Tag.create!(:name => 'doomed')
     post_thinking = posts(:thinking)
     post_thinking.tags << tag
-    assert_equal(count + 1, post_thinking.taggings(true).size)
-    assert_equal(count + 1, post_thinking.reload.tags(true).size)
+    assert_equal(count + 1, post_thinking.taggings.reload.size)
+    assert_equal(count + 1, post_thinking.reload.tags.reload.size)
     assert_not_equal(tags_before, post_thinking.tags.sort)
 
     assert_nothing_raised { post_thinking.tags.delete(tag) }
     assert_equal(count, post_thinking.tags.size)
-    assert_equal(count, post_thinking.tags(true).size)
-    assert_equal(count, post_thinking.taggings(true).size)
+    assert_equal(count, post_thinking.tags.reload.size)
+    assert_equal(count, post_thinking.taggings.reload.size)
     assert_equal(tags_before, post_thinking.tags.sort)
   end
 
@@ -580,11 +586,11 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     quaked = Tag.create!(:name => 'quaked')
     post_thinking = posts(:thinking)
     post_thinking.tags << doomed << doomed2
-    assert_equal(count + 2, post_thinking.reload.tags(true).size)
+    assert_equal(count + 2, post_thinking.reload.tags.reload.size)
 
     assert_nothing_raised { post_thinking.tags.delete(doomed, doomed2, quaked) }
     assert_equal(count, post_thinking.tags.size)
-    assert_equal(count, post_thinking.tags(true).size)
+    assert_equal(count, post_thinking.tags.reload.size)
     assert_equal(tags_before, post_thinking.tags.sort)
   end
 
@@ -592,7 +598,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     assert_raise(ActiveRecord::AssociationTypeMismatch) { posts(:thinking).tags.delete(Object.new) }
   end
 
-  def test_deleting_by_fixnum_id_from_has_many_through
+  def test_deleting_by_integer_id_from_has_many_through
     post = posts(:thinking)
 
     assert_difference 'post.tags.count', -1 do
@@ -628,7 +634,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     assert_equal [comments(:does_it_hurt)], authors(:david).special_post_comments
   end
 
-  def test_uniq_has_many_through_should_retain_order
+  def test_distinct_has_many_through_should_retain_order
     comment_ids = authors(:david).comments.map(&:id)
     assert_equal comment_ids.sort, authors(:david).ordered_uniq_comments.map(&:id)
     assert_equal comment_ids.sort.reverse, authors(:david).ordered_uniq_comments_desc.map(&:id)
@@ -741,6 +747,23 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
     assert_equal aircraft.engines, [engine]
   end
 
+  def test_proper_error_message_for_eager_load_and_includes_association_errors
+    includes_error = assert_raises(ActiveRecord::ConfigurationError) {
+      Post.includes(:nonexistent_relation).where(nonexistent_relation: {name: 'Rochester'}).find(1)
+    }
+    assert_equal("Can't join 'Post' to association named 'nonexistent_relation'; perhaps you misspelled it?", includes_error.message)
+
+    eager_load_error = assert_raises(ActiveRecord::ConfigurationError) {
+      Post.eager_load(:nonexistent_relation).where(nonexistent_relation: {name: 'Rochester'}).find(1)
+    }
+    assert_equal("Can't join 'Post' to association named 'nonexistent_relation'; perhaps you misspelled it?", eager_load_error.message)
+
+    includes_and_eager_load_error = assert_raises(ActiveRecord::ConfigurationError) {
+      Post.eager_load(:nonexistent_relation).includes(:nonexistent_relation).where(nonexistent_relation: {name: 'Rochester'}).find(1)
+    }
+    assert_equal("Can't join 'Post' to association named 'nonexistent_relation'; perhaps you misspelled it?", includes_and_eager_load_error.message)
+  end
+
   private
     # create dynamic Post models to allow different dependency options
     def find_post_with_dependency(post_id, association, association_name, dependency)