ibm_db 3.0.5-x86-mingw32 → 4.0.0-x86-mingw32

data/test/cases/associations/bidirectional_destroy_dependencies_test.rb

@@ -0,0 +1,41 @@
+require 'cases/helper'
+require 'models/content'
+
+class BidirectionalDestroyDependenciesTest < ActiveRecord::TestCase
+  fixtures :content, :content_positions
+
+  def setup
+    Content.destroyed_ids.clear
+    ContentPosition.destroyed_ids.clear
+  end
+
+  def test_bidirectional_dependence_when_destroying_item_with_belongs_to_association
+    content_position = ContentPosition.find(1)
+    content = content_position.content
+    assert_not_nil content
+
+    content_position.destroy
+
+    assert_equal [content_position.id], ContentPosition.destroyed_ids
+    assert_equal [content.id], Content.destroyed_ids
+  end
+
+  def test_bidirectional_dependence_when_destroying_item_with_has_one_association
+    content = Content.find(1)
+    content_position = content.content_position
+    assert_not_nil content_position
+
+    content.destroy
+
+    assert_equal [content.id], Content.destroyed_ids
+    assert_equal [content_position.id], ContentPosition.destroyed_ids
+  end
+
+  def test_bidirectional_dependence_when_destroying_item_with_has_one_association_fails_first_time
+    content = ContentWhichRequiresTwoDestroyCalls.find(1)
+
+    2.times { content.destroy }
+
+    assert_equal content.destroyed?, true
+  end
+end

data/test/cases/associations/callbacks_test.rb

@@ -1,192 +1,190 @@
-require "cases/helper"
-require 'models/post'
-require 'models/author'
-require 'models/project'
-require 'models/developer'
-require 'models/computer'
-require 'models/company'
-
-class AssociationCallbacksTest < ActiveRecord::TestCase
-  fixtures :posts, :authors, :projects, :developers, :author_addresses
-
-  def setup
-    @david = authors(:david)
-    @thinking = posts(:thinking)
-    @authorless = posts(:authorless)
-    assert @david.post_log.empty?
-  end
-  
-
-  def test_adding_macro_callbacks
-    @david.posts_with_callbacks << @thinking
-    assert_equal ["before_adding#{@thinking.id}", "after_adding#{@thinking.id}"], @david.post_log
-    @david.posts_with_callbacks << @thinking
-    assert_equal ["before_adding#{@thinking.id}", "after_adding#{@thinking.id}", "before_adding#{@thinking.id}",
-                  "after_adding#{@thinking.id}"], @david.post_log
-  end
-
-  
-  def test_adding_with_proc_callbacks
-    @david.posts_with_proc_callbacks << @thinking
-    assert_equal ["before_adding#{@thinking.id}", "after_adding#{@thinking.id}"], @david.post_log
-    @david.posts_with_proc_callbacks << @thinking
-    assert_equal ["before_adding#{@thinking.id}", "after_adding#{@thinking.id}", "before_adding#{@thinking.id}",
-                  "after_adding#{@thinking.id}"], @david.post_log
-  end
-
-  def test_removing_with_macro_callbacks
-    first_post, second_post = @david.posts_with_callbacks[0, 2]
-    @david.posts_with_callbacks.delete(first_post)
-    assert_equal ["before_removing#{first_post.id}", "after_removing#{first_post.id}"], @david.post_log
-    @david.posts_with_callbacks.delete(second_post)
-    assert_equal ["before_removing#{first_post.id}", "after_removing#{first_post.id}", "before_removing#{second_post.id}",
-                  "after_removing#{second_post.id}"], @david.post_log
-  end
-
-  def test_removing_with_proc_callbacks
-    first_post, second_post = @david.posts_with_callbacks[0, 2]
-    @david.posts_with_proc_callbacks.delete(first_post)
-    assert_equal ["before_removing#{first_post.id}", "after_removing#{first_post.id}"], @david.post_log
-    @david.posts_with_proc_callbacks.delete(second_post)
-    assert_equal ["before_removing#{first_post.id}", "after_removing#{first_post.id}", "before_removing#{second_post.id}",
-                  "after_removing#{second_post.id}"], @david.post_log
-  end
-
-  def test_multiple_callbacks
-    @david.posts_with_multiple_callbacks << @thinking
-    assert_equal ["before_adding#{@thinking.id}", "before_adding_proc#{@thinking.id}", "after_adding#{@thinking.id}",
-                  "after_adding_proc#{@thinking.id}"], @david.post_log
-    @david.posts_with_multiple_callbacks << @thinking
-    assert_equal ["before_adding#{@thinking.id}", "before_adding_proc#{@thinking.id}", "after_adding#{@thinking.id}",
-                  "after_adding_proc#{@thinking.id}", "before_adding#{@thinking.id}", "before_adding_proc#{@thinking.id}",
-                  "after_adding#{@thinking.id}", "after_adding_proc#{@thinking.id}"], @david.post_log
-  end
-
-  def test_has_many_callbacks_with_create
-    morten = Author.create :name => "Morten"
-    post = morten.posts_with_proc_callbacks.create! :title => "Hello", :body => "How are you doing?"
-    assert_equal ["before_adding<new>", "after_adding#{post.id}"], morten.post_log
-  end
-
-  def test_has_many_callbacks_with_create!
-    morten = Author.create! :name => "Morten"
-    post = morten.posts_with_proc_callbacks.create :title => "Hello", :body => "How are you doing?"
-    assert_equal ["before_adding<new>", "after_adding#{post.id}"], morten.post_log
-  end
-
-  def test_has_many_callbacks_for_save_on_parent
-    jack = Author.new :name => "Jack"
-    jack.posts_with_callbacks.build :title => "Call me back!", :body => "Before you wake up and after you sleep"
-
-    callback_log = ["before_adding<new>", "after_adding#{jack.posts_with_callbacks.first.id}"]
-    assert_equal callback_log, jack.post_log
-    assert jack.save
-    assert_equal 1, jack.posts_with_callbacks.count
-    assert_equal callback_log, jack.post_log
-  end
-
-  def test_has_many_callbacks_for_destroy_on_parent
-    firm = Firm.create! :name => "Firm"
-    client = firm.clients.create! :name => "Client"
-    firm.destroy
-
-    assert_equal ["before_remove#{client.id}", "after_remove#{client.id}"], firm.log
-  end
-
-  def test_has_and_belongs_to_many_add_callback
-    david = developers(:david)
-    ar = projects(:active_record)
-    assert ar.developers_log.empty?
-    ar.developers_with_callbacks << david
-    assert_equal ["before_adding#{david.id}", "after_adding#{david.id}"], ar.developers_log
-    ar.developers_with_callbacks << david
-    assert_equal ["before_adding#{david.id}", "after_adding#{david.id}", "before_adding#{david.id}",
-                  "after_adding#{david.id}"], ar.developers_log
-  end
-
-  def test_has_and_belongs_to_many_before_add_called_before_save
-    dev     = nil
-    new_dev = nil
-    klass = Class.new(Project) do
-      def self.name; Project.name; end
-      has_and_belongs_to_many :developers_with_callbacks,
-                                :class_name => "Developer",
-                                :before_add => lambda { |o,r|
-        dev     = r
-        new_dev = r.new_record?
-      }
-    end
-    rec = klass.create!
-    alice = Developer.new(:name => 'alice')
-    rec.developers_with_callbacks << alice
-    assert_equal alice, dev
-    assert_not_nil new_dev
-    assert new_dev, "record should not have been saved"
-    assert_not alice.new_record?
-  end
-
-  def test_has_and_belongs_to_many_after_add_called_after_save
-    ar = projects(:active_record)
-    assert ar.developers_log.empty?
-    alice = Developer.new(:name => 'alice')
-    ar.developers_with_callbacks << alice
-    assert_equal"after_adding#{alice.id}", ar.developers_log.last
-
-    bob = ar.developers_with_callbacks.create(:name => 'bob')
-    assert_equal "after_adding#{bob.id}", ar.developers_log.last
-
-    ar.developers_with_callbacks.build(:name => 'charlie')
-    assert_equal "after_adding<new>", ar.developers_log.last
-  end
-
-
-  def test_has_and_belongs_to_many_remove_callback
-    david = developers(:david)
-    jamis = developers(:jamis)
-    activerecord = projects(:active_record)
-    assert activerecord.developers_log.empty?
-    activerecord.developers_with_callbacks.delete(david)
-    assert_equal ["before_removing#{david.id}", "after_removing#{david.id}"], activerecord.developers_log
-
-    activerecord.developers_with_callbacks.delete(jamis)
-    assert_equal ["before_removing#{david.id}", "after_removing#{david.id}", "before_removing#{jamis.id}",
-                  "after_removing#{jamis.id}"], activerecord.developers_log
-  end
-
-  def test_has_and_belongs_to_many_does_not_fire_callbacks_on_clear
-    activerecord = projects(:active_record)
-    assert activerecord.developers_log.empty?
-    if activerecord.developers_with_callbacks.size == 0
-      activerecord.developers << developers(:david)
-      activerecord.developers << developers(:jamis)
-      activerecord.reload
-      assert activerecord.developers_with_callbacks.size == 2
-    end
-    activerecord.developers_with_callbacks.flat_map {|d| ["before_removing#{d.id}","after_removing#{d.id}"]}.sort
-    assert activerecord.developers_with_callbacks.clear
-    assert_predicate activerecord.developers_log, :empty?
-  end
-
-  def test_has_many_and_belongs_to_many_callbacks_for_save_on_parent
-    project = Project.new :name => "Callbacks"
-    project.developers_with_callbacks.build :name => "Jack", :salary => 95000
-
-    callback_log = ["before_adding<new>", "after_adding<new>"]
-    assert_equal callback_log, project.developers_log
-    assert project.save
-    assert_equal 1, project.developers_with_callbacks.size
-    assert_equal callback_log, project.developers_log
-  end
-
-  def test_dont_add_if_before_callback_raises_exception
-    assert !@david.unchangable_posts.include?(@authorless)
-    begin
-      @david.unchangable_posts << @authorless
-    rescue Exception
-    end
-    assert @david.post_log.empty?
-    assert !@david.unchangable_posts.include?(@authorless)
-    @david.reload
-    assert !@david.unchangable_posts.include?(@authorless)
-  end
-end
+require "cases/helper"
+require 'models/post'
+require 'models/author'
+require 'models/project'
+require 'models/developer'
+require 'models/computer'
+require 'models/company'
+
+class AssociationCallbacksTest < ActiveRecord::TestCase
+  fixtures :posts, :authors, :projects, :developers
+
+  def setup
+    @david = authors(:david)
+    @thinking = posts(:thinking)
+    @authorless = posts(:authorless)
+    assert @david.post_log.empty?
+  end
+
+  def test_adding_macro_callbacks
+    @david.posts_with_callbacks << @thinking
+    assert_equal ["before_adding#{@thinking.id}", "after_adding#{@thinking.id}"], @david.post_log
+    @david.posts_with_callbacks << @thinking
+    assert_equal ["before_adding#{@thinking.id}", "after_adding#{@thinking.id}", "before_adding#{@thinking.id}",
+                  "after_adding#{@thinking.id}"], @david.post_log
+  end
+
+  def test_adding_with_proc_callbacks
+    @david.posts_with_proc_callbacks << @thinking
+    assert_equal ["before_adding#{@thinking.id}", "after_adding#{@thinking.id}"], @david.post_log
+    @david.posts_with_proc_callbacks << @thinking
+    assert_equal ["before_adding#{@thinking.id}", "after_adding#{@thinking.id}", "before_adding#{@thinking.id}",
+                  "after_adding#{@thinking.id}"], @david.post_log
+  end
+
+  def test_removing_with_macro_callbacks
+    first_post, second_post = @david.posts_with_callbacks[0, 2]
+    @david.posts_with_callbacks.delete(first_post)
+    assert_equal ["before_removing#{first_post.id}", "after_removing#{first_post.id}"], @david.post_log
+    @david.posts_with_callbacks.delete(second_post)
+    assert_equal ["before_removing#{first_post.id}", "after_removing#{first_post.id}", "before_removing#{second_post.id}",
+                  "after_removing#{second_post.id}"], @david.post_log
+  end
+
+  def test_removing_with_proc_callbacks
+    first_post, second_post = @david.posts_with_callbacks[0, 2]
+    @david.posts_with_proc_callbacks.delete(first_post)
+    assert_equal ["before_removing#{first_post.id}", "after_removing#{first_post.id}"], @david.post_log
+    @david.posts_with_proc_callbacks.delete(second_post)
+    assert_equal ["before_removing#{first_post.id}", "after_removing#{first_post.id}", "before_removing#{second_post.id}",
+                  "after_removing#{second_post.id}"], @david.post_log
+  end
+
+  def test_multiple_callbacks
+    @david.posts_with_multiple_callbacks << @thinking
+    assert_equal ["before_adding#{@thinking.id}", "before_adding_proc#{@thinking.id}", "after_adding#{@thinking.id}",
+                  "after_adding_proc#{@thinking.id}"], @david.post_log
+    @david.posts_with_multiple_callbacks << @thinking
+    assert_equal ["before_adding#{@thinking.id}", "before_adding_proc#{@thinking.id}", "after_adding#{@thinking.id}",
+                  "after_adding_proc#{@thinking.id}", "before_adding#{@thinking.id}", "before_adding_proc#{@thinking.id}",
+                  "after_adding#{@thinking.id}", "after_adding_proc#{@thinking.id}"], @david.post_log
+  end
+
+  def test_has_many_callbacks_with_create
+    morten = Author.create :name => "Morten"
+    post = morten.posts_with_proc_callbacks.create! :title => "Hello", :body => "How are you doing?"
+    assert_equal ["before_adding<new>", "after_adding#{post.id}"], morten.post_log
+  end
+
+  def test_has_many_callbacks_with_create!
+    morten = Author.create! :name => "Morten"
+    post = morten.posts_with_proc_callbacks.create :title => "Hello", :body => "How are you doing?"
+    assert_equal ["before_adding<new>", "after_adding#{post.id}"], morten.post_log
+  end
+
+  def test_has_many_callbacks_for_save_on_parent
+    jack = Author.new :name => "Jack"
+    jack.posts_with_callbacks.build :title => "Call me back!", :body => "Before you wake up and after you sleep"
+
+    callback_log = ["before_adding<new>", "after_adding#{jack.posts_with_callbacks.first.id}"]
+    assert_equal callback_log, jack.post_log
+    assert jack.save
+    assert_equal 1, jack.posts_with_callbacks.count
+    assert_equal callback_log, jack.post_log
+  end
+
+  def test_has_many_callbacks_for_destroy_on_parent
+    firm = Firm.create! :name => "Firm"
+    client = firm.clients.create! :name => "Client"
+    firm.destroy
+
+    assert_equal ["before_remove#{client.id}", "after_remove#{client.id}"], firm.log
+  end
+
+  def test_has_and_belongs_to_many_add_callback
+    david = developers(:david)
+    ar = projects(:active_record)
+    assert ar.developers_log.empty?
+    ar.developers_with_callbacks << david
+    assert_equal ["before_adding#{david.id}", "after_adding#{david.id}"], ar.developers_log
+    ar.developers_with_callbacks << david
+    assert_equal ["before_adding#{david.id}", "after_adding#{david.id}", "before_adding#{david.id}",
+                  "after_adding#{david.id}"], ar.developers_log
+  end
+
+  def test_has_and_belongs_to_many_before_add_called_before_save
+    dev     = nil
+    new_dev = nil
+    klass = Class.new(Project) do
+      def self.name; Project.name; end
+      has_and_belongs_to_many :developers_with_callbacks,
+                                :class_name => "Developer",
+                                :before_add => lambda { |o,r|
+        dev     = r
+        new_dev = r.new_record?
+      }
+    end
+    rec = klass.create!
+    alice = Developer.new(:name => 'alice')
+    rec.developers_with_callbacks << alice
+    assert_equal alice, dev
+    assert_not_nil new_dev
+    assert new_dev, "record should not have been saved"
+    assert_not alice.new_record?
+  end
+
+  def test_has_and_belongs_to_many_after_add_called_after_save
+    ar = projects(:active_record)
+    assert ar.developers_log.empty?
+    alice = Developer.new(:name => 'alice')
+    ar.developers_with_callbacks << alice
+    assert_equal"after_adding#{alice.id}", ar.developers_log.last
+
+    bob = ar.developers_with_callbacks.create(:name => 'bob')
+    assert_equal "after_adding#{bob.id}", ar.developers_log.last
+
+    ar.developers_with_callbacks.build(:name => 'charlie')
+    assert_equal "after_adding<new>", ar.developers_log.last
+  end
+
+
+  def test_has_and_belongs_to_many_remove_callback
+    david = developers(:david)
+    jamis = developers(:jamis)
+    activerecord = projects(:active_record)
+    assert activerecord.developers_log.empty?
+    activerecord.developers_with_callbacks.delete(david)
+    assert_equal ["before_removing#{david.id}", "after_removing#{david.id}"], activerecord.developers_log
+
+    activerecord.developers_with_callbacks.delete(jamis)
+    assert_equal ["before_removing#{david.id}", "after_removing#{david.id}", "before_removing#{jamis.id}",
+                  "after_removing#{jamis.id}"], activerecord.developers_log
+  end
+
+  def test_has_and_belongs_to_many_does_not_fire_callbacks_on_clear
+    activerecord = projects(:active_record)
+    assert activerecord.developers_log.empty?
+    if activerecord.developers_with_callbacks.size == 0
+      activerecord.developers << developers(:david)
+      activerecord.developers << developers(:jamis)
+      activerecord.reload
+      assert activerecord.developers_with_callbacks.size == 2
+    end
+    activerecord.developers_with_callbacks.flat_map {|d| ["before_removing#{d.id}","after_removing#{d.id}"]}.sort
+    assert activerecord.developers_with_callbacks.clear
+    assert_predicate activerecord.developers_log, :empty?
+  end
+
+  def test_has_many_and_belongs_to_many_callbacks_for_save_on_parent
+    project = Project.new :name => "Callbacks"
+    project.developers_with_callbacks.build :name => "Jack", :salary => 95000
+
+    callback_log = ["before_adding<new>", "after_adding<new>"]
+    assert_equal callback_log, project.developers_log
+    assert project.save
+    assert_equal 1, project.developers_with_callbacks.size
+    assert_equal callback_log, project.developers_log
+  end
+
+  def test_dont_add_if_before_callback_raises_exception
+    assert !@david.unchangeable_posts.include?(@authorless)
+    begin
+      @david.unchangeable_posts << @authorless
+    rescue Exception
+    end
+    assert @david.post_log.empty?
+    assert !@david.unchangeable_posts.include?(@authorless)
+    @david.reload
+    assert !@david.unchangeable_posts.include?(@authorless)
+  end
+end

data/test/cases/associations/cascaded_eager_loading_test.rb

@@ -1,188 +1,188 @@
-require "cases/helper"
-require 'models/post'
-require 'models/comment'
-require 'models/author'
-require 'models/categorization'
-require 'models/category'
-require 'models/company'
-require 'models/topic'
-require 'models/reply'
-require 'models/person'
-require 'models/vertex'
-require 'models/edge'
-
-class CascadedEagerLoadingTest < ActiveRecord::TestCase
-  fixtures :authors, :mixins, :companies, :posts, :topics, :accounts, :comments,
-           :categorizations, :people, :categories, :edges, :vertices, :author_addresses
-
-  def test_eager_association_loading_with_cascaded_two_levels
-    authors = Author.all.merge!(:includes=>{:posts=>:comments}, :order=>"authors.id").to_a
-    assert_equal 3, authors.size
-    assert_equal 5, authors[0].posts.size
-    assert_equal 3, authors[1].posts.size
-    assert_equal 10, authors[0].posts.collect{|post| post.comments.size }.inject(0){|sum,i| sum+i}
-  end
-
-  def test_eager_association_loading_with_cascaded_two_levels_and_one_level
-    authors = Author.all.merge!(:includes=>[{:posts=>:comments}, :categorizations], :order=>"authors.id").to_a
-    assert_equal 3, authors.size
-    assert_equal 5, authors[0].posts.size
-    assert_equal 3, authors[1].posts.size
-    assert_equal 10, authors[0].posts.collect{|post| post.comments.size }.inject(0){|sum,i| sum+i}
-    assert_equal 1, authors[0].categorizations.size
-    assert_equal 2, authors[1].categorizations.size
-  end
-
-  def test_eager_association_loading_with_hmt_does_not_table_name_collide_when_joining_associations
-    assert_nothing_raised do
-      Author.joins(:posts).eager_load(:comments).where(:posts => {:tags_count => 1}).to_a
-    end
-    authors = Author.joins(:posts).eager_load(:comments).where(:posts => {:tags_count => 1}).to_a
-    assert_equal 1, assert_no_queries { authors.size }
-    assert_equal 10, assert_no_queries { authors[0].comments.size }
-  end
-
-  def test_eager_association_loading_grafts_stashed_associations_to_correct_parent
-    assert_nothing_raised do
-      Person.eager_load(:primary_contact => :primary_contact).where('primary_contacts_people_2.first_name = ?', 'Susan').order('people.id').to_a
-    end
-    assert_equal people(:michael), Person.eager_load(:primary_contact => :primary_contact).where('primary_contacts_people_2.first_name = ?', 'Susan').order('people.id').first
-  end
-
-  def test_cascaded_eager_association_loading_with_join_for_count
-    categories = Category.joins(:categorizations).includes([{:posts=>:comments}, :authors])
-
-    assert_equal 4, categories.count
-    assert_equal 4, categories.to_a.count
-    assert_equal 3, categories.distinct.count
-    assert_equal 3, categories.to_a.uniq.size # Must uniq since instantiating with inner joins will get dupes
-  end
-
-  def test_cascaded_eager_association_loading_with_duplicated_includes
-    categories = Category.includes(:categorizations).includes(:categorizations => :author).where("categorizations.id is not null").references(:categorizations)
-    assert_nothing_raised do
-      assert_equal 3, categories.count
-      assert_equal 3, categories.to_a.size
-    end
-  end
-
-  def test_cascaded_eager_association_loading_with_twice_includes_edge_cases
-    categories = Category.includes(:categorizations => :author).includes(:categorizations => :post).where("posts.id is not null").references(:posts)
-    assert_nothing_raised do
-      assert_equal 3, categories.count
-      assert_equal 3, categories.to_a.size
-    end
-  end
-
-  def test_eager_association_loading_with_join_for_count
-    authors = Author.joins(:special_posts).includes([:posts, :categorizations])
-
-    assert_nothing_raised { authors.count }
-    assert_queries(3) { authors.to_a }
-  end
-
-  def test_eager_association_loading_with_cascaded_two_levels_with_two_has_many_associations
-    authors = Author.all.merge!(:includes=>{:posts=>[:comments, :categorizations]}, :order=>"authors.id").to_a
-    assert_equal 3, authors.size
-    assert_equal 5, authors[0].posts.size
-    assert_equal 3, authors[1].posts.size
-    assert_equal 10, authors[0].posts.collect{|post| post.comments.size }.inject(0){|sum,i| sum+i}
-  end
-
-  def test_eager_association_loading_with_cascaded_two_levels_and_self_table_reference
-    authors = Author.all.merge!(:includes=>{:posts=>[:comments, :author]}, :order=>"authors.id").to_a
-    assert_equal 3, authors.size
-    assert_equal 5, authors[0].posts.size
-    assert_equal authors(:david).name, authors[0].name
-    assert_equal [authors(:david).name], authors[0].posts.collect{|post| post.author.name}.uniq
-  end
-
-  def test_eager_association_loading_with_cascaded_two_levels_with_condition
-    authors = Author.all.merge!(:includes=>{:posts=>:comments}, :where=>"authors.id=1", :order=>"authors.id").to_a
-    assert_equal 1, authors.size
-    assert_equal 5, authors[0].posts.size
-  end
-
-  def test_eager_association_loading_with_cascaded_three_levels_by_ping_pong
-    firms = Firm.all.merge!(:includes=>{:account=>{:firm=>:account}}, :order=>"companies.id").to_a
-    assert_equal 2, firms.size
-    assert_equal firms.first.account, firms.first.account.firm.account
-    assert_equal companies(:first_firm).account, assert_no_queries { firms.first.account.firm.account }
-    assert_equal companies(:first_firm).account.firm.account, assert_no_queries { firms.first.account.firm.account }
-  end
-
-  def test_eager_association_loading_with_has_many_sti
-    topics = Topic.all.merge!(:includes => :replies, :order => 'topics.id').to_a
-    first, second, = topics(:first).replies.size, topics(:second).replies.size
-    assert_no_queries do
-      assert_equal first, topics[0].replies.size
-      assert_equal second, topics[1].replies.size
-    end
-  end
-
-  def test_eager_association_loading_with_has_many_sti_and_subclasses
-    silly = SillyReply.new(:title => "gaga", :content => "boo-boo", :parent_id => 1)
-    silly.parent_id = 1
-    assert silly.save
-
-    topics = Topic.all.merge!(:includes => :replies, :order => ['topics.id', 'replies_topics.id']).to_a
-    assert_no_queries do
-      assert_equal 2, topics[0].replies.size
-      assert_equal 0, topics[1].replies.size
-    end
-  end
-
-  def test_eager_association_loading_with_belongs_to_sti
-    replies = Reply.all.merge!(:includes => :topic, :order => 'topics.id').to_a
-    assert replies.include?(topics(:second))
-    assert !replies.include?(topics(:first))
-    assert_equal topics(:first), assert_no_queries { replies.first.topic }
-  end
-
-  def test_eager_association_loading_with_multiple_stis_and_order
-    author = Author.all.merge!(:includes => { :posts => [ :special_comments , :very_special_comment ] }, :order => ['authors.name', 'comments.body', 'very_special_comments_posts.body'], :where => 'posts.id = 4').first
-    assert_equal authors(:david), author
-    assert_no_queries do
-      author.posts.first.special_comments
-      author.posts.first.very_special_comment
-    end
-  end
-
-  def test_eager_association_loading_of_stis_with_multiple_references
-    authors = Author.all.merge!(:includes => { :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_eager_association_loading_where_first_level_returns_nil
-    authors = Author.all.merge!(:includes => {:post_about_thinking => :comments}, :order => 'authors.id DESC').to_a
-    assert_equal [authors(:bob), authors(:mary), authors(:david)], authors
-    assert_no_queries do
-      authors[2].post_about_thinking.comments.first
-    end
-  end
-
-  def test_eager_association_loading_with_recursive_cascading_four_levels_has_many_through
-    source = Vertex.all.merge!(:includes=>{:sinks=>{:sinks=>{:sinks=>:sinks}}}, :order => 'vertices.id').first
-    assert_equal vertices(:vertex_4), assert_no_queries { source.sinks.first.sinks.first.sinks.first }
-  end
-
-  def test_eager_association_loading_with_recursive_cascading_four_levels_has_and_belongs_to_many
-    sink = Vertex.all.merge!(:includes=>{:sources=>{:sources=>{:sources=>:sources}}}, :order => 'vertices.id DESC').first
-    assert_equal vertices(:vertex_1), assert_no_queries { sink.sources.first.sources.first.sources.first.sources.first }
-  end
-
-  def test_eager_association_loading_with_cascaded_interdependent_one_level_and_two_levels
-    authors_relation = Author.all.merge!(includes: [:comments, { posts: :categorizations }], order: "authors.id")
-    authors = authors_relation.to_a
-    assert_equal 3, authors.size
-    assert_equal 10, authors[0].comments.size
-    assert_equal 1, authors[1].comments.size
-    assert_equal 5, authors[0].posts.size
-    assert_equal 3, authors[1].posts.size
-    assert_equal 3, authors[0].posts.collect { |post| post.categorizations.size }.inject(0) { |sum, i| sum+i }
-  end
-end
+require "cases/helper"
+require 'models/post'
+require 'models/comment'
+require 'models/author'
+require 'models/categorization'
+require 'models/category'
+require 'models/company'
+require 'models/topic'
+require 'models/reply'
+require 'models/person'
+require 'models/vertex'
+require 'models/edge'
+
+class CascadedEagerLoadingTest < ActiveRecord::TestCase
+  fixtures :authors, :mixins, :companies, :posts, :topics, :accounts, :comments,
+           :categorizations, :people, :categories, :edges, :vertices
+
+  def test_eager_association_loading_with_cascaded_two_levels
+    authors = Author.all.merge!(:includes=>{:posts=>:comments}, :order=>"authors.id").to_a
+    assert_equal 3, authors.size
+    assert_equal 5, authors[0].posts.size
+    assert_equal 3, authors[1].posts.size
+    assert_equal 10, authors[0].posts.collect{|post| post.comments.size }.inject(0){|sum,i| sum+i}
+  end
+
+  def test_eager_association_loading_with_cascaded_two_levels_and_one_level
+    authors = Author.all.merge!(:includes=>[{:posts=>:comments}, :categorizations], :order=>"authors.id").to_a
+    assert_equal 3, authors.size
+    assert_equal 5, authors[0].posts.size
+    assert_equal 3, authors[1].posts.size
+    assert_equal 10, authors[0].posts.collect{|post| post.comments.size }.inject(0){|sum,i| sum+i}
+    assert_equal 1, authors[0].categorizations.size
+    assert_equal 2, authors[1].categorizations.size
+  end
+
+  def test_eager_association_loading_with_hmt_does_not_table_name_collide_when_joining_associations
+    assert_nothing_raised do
+      Author.joins(:posts).eager_load(:comments).where(:posts => {:tags_count => 1}).to_a
+    end
+    authors = Author.joins(:posts).eager_load(:comments).where(:posts => {:tags_count => 1}).to_a
+    assert_equal 1, assert_no_queries { authors.size }
+    assert_equal 10, assert_no_queries { authors[0].comments.size }
+  end
+
+  def test_eager_association_loading_grafts_stashed_associations_to_correct_parent
+    assert_nothing_raised do
+      Person.eager_load(:primary_contact => :primary_contact).where('primary_contacts_people_2.first_name = ?', 'Susan').order('people.id').to_a
+    end
+    assert_equal people(:michael), Person.eager_load(:primary_contact => :primary_contact).where('primary_contacts_people_2.first_name = ?', 'Susan').order('people.id').first
+  end
+
+  def test_cascaded_eager_association_loading_with_join_for_count
+    categories = Category.joins(:categorizations).includes([{:posts=>:comments}, :authors])
+
+    assert_equal 4, categories.count
+    assert_equal 4, categories.to_a.count
+    assert_equal 3, categories.distinct.count
+    assert_equal 3, categories.to_a.uniq.size # Must uniq since instantiating with inner joins will get dupes
+  end
+
+  def test_cascaded_eager_association_loading_with_duplicated_includes
+    categories = Category.includes(:categorizations).includes(:categorizations => :author).where("categorizations.id is not null").references(:categorizations)
+    assert_nothing_raised do
+      assert_equal 3, categories.count
+      assert_equal 3, categories.to_a.size
+    end
+  end
+
+  def test_cascaded_eager_association_loading_with_twice_includes_edge_cases
+    categories = Category.includes(:categorizations => :author).includes(:categorizations => :post).where("posts.id is not null").references(:posts)
+    assert_nothing_raised do
+      assert_equal 3, categories.count
+      assert_equal 3, categories.to_a.size
+    end
+  end
+
+  def test_eager_association_loading_with_join_for_count
+    authors = Author.joins(:special_posts).includes([:posts, :categorizations])
+
+    assert_nothing_raised { authors.count }
+    assert_queries(3) { authors.to_a }
+  end
+
+  def test_eager_association_loading_with_cascaded_two_levels_with_two_has_many_associations
+    authors = Author.all.merge!(:includes=>{:posts=>[:comments, :categorizations]}, :order=>"authors.id").to_a
+    assert_equal 3, authors.size
+    assert_equal 5, authors[0].posts.size
+    assert_equal 3, authors[1].posts.size
+    assert_equal 10, authors[0].posts.collect{|post| post.comments.size }.inject(0){|sum,i| sum+i}
+  end
+
+  def test_eager_association_loading_with_cascaded_two_levels_and_self_table_reference
+    authors = Author.all.merge!(:includes=>{:posts=>[:comments, :author]}, :order=>"authors.id").to_a
+    assert_equal 3, authors.size
+    assert_equal 5, authors[0].posts.size
+    assert_equal authors(:david).name, authors[0].name
+    assert_equal [authors(:david).name], authors[0].posts.collect{|post| post.author.name}.uniq
+  end
+
+  def test_eager_association_loading_with_cascaded_two_levels_with_condition
+    authors = Author.all.merge!(:includes=>{:posts=>:comments}, :where=>"authors.id=1", :order=>"authors.id").to_a
+    assert_equal 1, authors.size
+    assert_equal 5, authors[0].posts.size
+  end
+
+  def test_eager_association_loading_with_cascaded_three_levels_by_ping_pong
+    firms = Firm.all.merge!(:includes=>{:account=>{:firm=>:account}}, :order=>"companies.id").to_a
+    assert_equal 2, firms.size
+    assert_equal firms.first.account, firms.first.account.firm.account
+    assert_equal companies(:first_firm).account, assert_no_queries { firms.first.account.firm.account }
+    assert_equal companies(:first_firm).account.firm.account, assert_no_queries { firms.first.account.firm.account }
+  end
+
+  def test_eager_association_loading_with_has_many_sti
+    topics = Topic.all.merge!(:includes => :replies, :order => 'topics.id').to_a
+    first, second, = topics(:first).replies.size, topics(:second).replies.size
+    assert_no_queries do
+      assert_equal first, topics[0].replies.size
+      assert_equal second, topics[1].replies.size
+    end
+  end
+
+  def test_eager_association_loading_with_has_many_sti_and_subclasses
+    silly = SillyReply.new(:title => "gaga", :content => "boo-boo", :parent_id => 1)
+    silly.parent_id = 1
+    assert silly.save
+
+    topics = Topic.all.merge!(:includes => :replies, :order => ['topics.id', 'replies_topics.id']).to_a
+    assert_no_queries do
+      assert_equal 2, topics[0].replies.size
+      assert_equal 0, topics[1].replies.size
+    end
+  end
+
+  def test_eager_association_loading_with_belongs_to_sti
+    replies = Reply.all.merge!(:includes => :topic, :order => 'topics.id').to_a
+    assert replies.include?(topics(:second))
+    assert !replies.include?(topics(:first))
+    assert_equal topics(:first), assert_no_queries { replies.first.topic }
+  end
+
+  def test_eager_association_loading_with_multiple_stis_and_order
+    author = Author.all.merge!(:includes => { :posts => [ :special_comments , :very_special_comment ] }, :order => ['authors.name', 'comments.body', 'very_special_comments_posts.body'], :where => 'posts.id = 4').first
+    assert_equal authors(:david), author
+    assert_no_queries do
+      author.posts.first.special_comments
+      author.posts.first.very_special_comment
+    end
+  end
+
+  def test_eager_association_loading_of_stis_with_multiple_references
+    authors = Author.all.merge!(:includes => { :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_eager_association_loading_where_first_level_returns_nil
+    authors = Author.all.merge!(:includes => {:post_about_thinking => :comments}, :order => 'authors.id DESC').to_a
+    assert_equal [authors(:bob), authors(:mary), authors(:david)], authors
+    assert_no_queries do
+      authors[2].post_about_thinking.comments.first
+    end
+  end
+
+  def test_eager_association_loading_with_recursive_cascading_four_levels_has_many_through
+    source = Vertex.all.merge!(:includes=>{:sinks=>{:sinks=>{:sinks=>:sinks}}}, :order => 'vertices.id').first
+    assert_equal vertices(:vertex_4), assert_no_queries { source.sinks.first.sinks.first.sinks.first }
+  end
+
+  def test_eager_association_loading_with_recursive_cascading_four_levels_has_and_belongs_to_many
+    sink = Vertex.all.merge!(:includes=>{:sources=>{:sources=>{:sources=>:sources}}}, :order => 'vertices.id DESC').first
+    assert_equal vertices(:vertex_1), assert_no_queries { sink.sources.first.sources.first.sources.first.sources.first }
+  end
+
+  def test_eager_association_loading_with_cascaded_interdependent_one_level_and_two_levels
+    authors_relation = Author.all.merge!(includes: [:comments, { posts: :categorizations }], order: "authors.id")
+    authors = authors_relation.to_a
+    assert_equal 3, authors.size
+    assert_equal 10, authors[0].comments.size
+    assert_equal 1, authors[1].comments.size
+    assert_equal 5, authors[0].posts.size
+    assert_equal 3, authors[1].posts.size
+    assert_equal 3, authors[0].posts.collect { |post| post.categorizations.size }.inject(0) { |sum, i| sum+i }
+  end
+end