ibm_db 2.5.6 → 2.5.7

data/test/cases/associations/cascaded_eager_loading_test.rb

@@ -15,18 +15,18 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
 
   def test_eager_association_loading_with_cascaded_two_levels
     authors = Author.find(:all, :include=>{:posts=>:comments}, :order=>"authors.id")
-    assert_equal 2, authors.size
+    assert_equal 3, authors.size
     assert_equal 5, authors[0].posts.size
-    assert_equal 1, authors[1].posts.size
-    assert_equal 9, authors[0].posts.collect{|post| post.comments.size }.inject(0){|sum,i| sum+i}
+    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.find(:all, :include=>[{:posts=>:comments}, :categorizations], :order=>"authors.id")
-    assert_equal 2, authors.size
+    assert_equal 3, authors.size
     assert_equal 5, authors[0].posts.size
-    assert_equal 1, authors[1].posts.size
-    assert_equal 9, authors[0].posts.collect{|post| post.comments.size }.inject(0){|sum,i| sum+i}
+    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
@@ -37,7 +37,7 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
     end
     authors = Author.joins(:posts).eager_load(:comments).where(:posts => {:taggings_count => 1}).all
     assert_equal 1, assert_no_queries { authors.size }
-    assert_equal 9, assert_no_queries { authors[0].comments.size }
+    assert_equal 10, assert_no_queries { authors[0].comments.size }
   end
 
   def test_eager_association_loading_grafts_stashed_associations_to_correct_parent
@@ -51,24 +51,26 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
     categories = Category.joins(:categorizations).includes([{:posts=>:comments}, :authors])
 
     assert_nothing_raised do
-      assert_equal 2, categories.count
-      assert_equal 2, categories.all.uniq.size # Must uniq since instantiating with inner joins will get dupes
+      assert_equal 4, categories.count
+      assert_equal 4, categories.all.count
+      assert_equal 3, categories.count(:distinct => true)
+      assert_equal 3, categories.all.uniq.size # Must uniq since instantiating with inner joins will get dupes
     end
   end
 
   def test_cascaded_eager_association_loading_with_duplicated_includes
     categories = Category.includes(:categorizations).includes(:categorizations => :author).where("categorizations.id is not null")
     assert_nothing_raised do
-      assert_equal 2, categories.count
-      assert_equal 2, categories.all.size
+      assert_equal 3, categories.count
+      assert_equal 3, categories.all.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")
     assert_nothing_raised do
-      assert_equal 2, categories.count
-      assert_equal 2, categories.all.size
+      assert_equal 3, categories.count
+      assert_equal 3, categories.all.size
     end
   end
 
@@ -81,15 +83,15 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
 
   def test_eager_association_loading_with_cascaded_two_levels_with_two_has_many_associations
     authors = Author.find(:all, :include=>{:posts=>[:comments, :categorizations]}, :order=>"authors.id")
-    assert_equal 2, authors.size
+    assert_equal 3, authors.size
     assert_equal 5, authors[0].posts.size
-    assert_equal 1, authors[1].posts.size
-    assert_equal 9, authors[0].posts.collect{|post| post.comments.size }.inject(0){|sum,i| sum+i}
+    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.find(:all, :include=>{:posts=>[:comments, :author]}, :order=>"authors.id")
-    assert_equal 2, authors.size
+    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
@@ -139,14 +141,14 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
 
   unless current_adapter?(:IBM_DBAdapter)
     def test_eager_association_loading_with_multiple_stis_and_order
-     author = Author.find(:first, :include => { :posts => [ :special_comments , :very_special_comment ] }, :order => 'authors.name, comments.body, very_special_comments_posts.body', :conditions => 'posts.id = 4')
-     assert_equal authors(:david), author
-     assert_no_queries do
-       author.posts.first.special_comments
-       author.posts.first.very_special_comment
-     end
+      author = Author.find(:first, :include => { :posts => [ :special_comments , :very_special_comment ] }, :order => ['authors.name', 'comments.body', 'very_special_comments_posts.body'], :conditions => 'posts.id = 4')
+      assert_equal authors(:david), author
+      assert_no_queries do
+        author.posts.first.special_comments
+        author.posts.first.very_special_comment
+      end
     end
-  end 
+  end
 
   def test_eager_association_loading_of_stis_with_multiple_references
     authors = Author.find(:all, :include => { :posts => { :special_comments => { :post => [ :special_comments, :very_special_comment ] } } }, :order => 'comments.body, very_special_comments_posts.body', :conditions => 'posts.id = 4')
@@ -159,9 +161,9 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
 
   def test_eager_association_loading_where_first_level_returns_nil
     authors = Author.find(:all, :include => {:post_about_thinking => :comments}, :order => 'authors.id DESC')
-    assert_equal [authors(:mary), authors(:david)], authors
+    assert_equal [authors(:bob), authors(:mary), authors(:david)], authors
     assert_no_queries do
-      authors[1].post_about_thinking.comments.first
+      authors[2].post_about_thinking.comments.first
     end
   end
 end

data/test/cases/associations/has_and_belongs_to_many_associations_test.rb

@@ -72,22 +72,7 @@ class DeveloperWithCounterSQL < ActiveRecord::Base
     :join_table => "developers_projects",
     :association_foreign_key => "project_id",
     :foreign_key => "developer_id",
-    :counter_sql => 'SELECT COUNT(*) AS count_all FROM projects INNER JOIN developers_projects ON projects.id = developers_projects.project_id WHERE developers_projects.developer_id =#{id}'
-end
-
-if current_adapter?(:IBM_DBAdapter)
-  class Novel < ActiveRecord::Base
-    has_and_belongs_to_many :writers
-  end
-  
-  class Writer < ActiveRecord::Base
-    has_and_belongs_to_many :novels
-  end
-  
-  class NovelsWriter < ActiveRecord::Base
-    belongs_to :writers
-    belongs_to :novels
-  end
+    :counter_sql => proc { "SELECT COUNT(*) AS count_all FROM projects INNER JOIN developers_projects ON projects.id = developers_projects.project_id WHERE developers_projects.developer_id =#{id}" }
 end
 
 class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
@@ -115,37 +100,12 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert_equal 'c1', record[0]
     assert_equal 't1', record[1]
   end
-
-  def test_should_record_timestamp_for_join_table
+  
+  def test_proper_usage_of_primary_keys_and_join_table
     setup_data_for_habtm_case
 
-    con = ActiveRecord::Base.connection
-    sql = 'select * from countries_treaties'
-    record = con.select_rows(sql).last
-    assert_not_nil record[2]
-    assert_not_nil record[3]
-    if current_adapter?(:Mysql2Adapter, :OracleAdapter)
-      assert_match %r{\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}}, record[2].to_s(:db)
-      assert_match %r{\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}}, record[3].to_s(:db)
-    else
-      assert_match %r{\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}}, record[2]
-      assert_match %r{\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}}, record[3]
-    end
-  end
-
-  def test_should_record_timestamp_for_join_table_only_if_timestamp_should_be_recorded
-    begin
-      Treaty.record_timestamps = false
-      setup_data_for_habtm_case
-
-      con = ActiveRecord::Base.connection
-      sql = 'select * from countries_treaties'
-      record = con.select_rows(sql).last
-      assert_nil record[2]
-      assert_nil record[3]
-    ensure
-      Treaty.record_timestamps = true
-    end
+    country = Country.first
+    assert_equal 1, country.treaties.count
   end
 
   def test_has_and_belongs_to_many
@@ -233,34 +193,6 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert_equal 2, aredridel.projects(true).size
   end
 
-  def test_adding_uses_default_values_on_join_table
-    ac = projects(:action_controller)
-    assert !developers(:jamis).projects.include?(ac)
-    developers(:jamis).projects << ac
-
-    assert developers(:jamis, :reload).projects.include?(ac)
-    project = developers(:jamis).projects.detect { |p| p == ac }
-    assert_equal 1, project.access_level.to_i
-  end
-
-  def test_habtm_attribute_access_and_respond_to
-    project = developers(:jamis).projects[0]
-    assert project.has_attribute?("name")
-    assert project.has_attribute?("joined_on")
-    assert project.has_attribute?("access_level")
-    assert project.respond_to?("name")
-    assert project.respond_to?("name=")
-    assert project.respond_to?("name?")
-    assert project.respond_to?("joined_on")
-    # given that the 'join attribute' won't be persisted, I don't
-    # think we should define the mutators
-    #assert project.respond_to?("joined_on=")
-    assert project.respond_to?("joined_on?")
-    assert project.respond_to?("access_level")
-    #assert project.respond_to?("access_level=")
-    assert project.respond_to?("access_level?")
-  end
-
   def test_habtm_adding_before_save
     no_of_devels = Developer.count
     no_of_projects = Project.count
@@ -310,9 +242,24 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert_equal Developer.find(1).projects.sort_by(&:id).last, proj  # prove join table is updated
   end
 
+  def test_new_aliased_to_build
+    devel = Developer.find(1)
+    proj = assert_no_queries { devel.projects.new("name" => "Projekt") }
+    assert !devel.projects.loaded?
+
+    assert_equal devel.projects.last, proj
+    assert devel.projects.loaded?
+
+    assert !proj.persisted?
+    devel.save
+    assert proj.persisted?
+    assert_equal devel.projects.last, proj
+    assert_equal Developer.find(1).projects.sort_by(&:id).last, proj  # prove join table is updated
+  end
+
   def test_build_by_new_record
     devel = Developer.new(:name => "Marcel", :salary => 75000)
-    proj1 = devel.projects.build(:name => "Make bed")
+    devel.projects.build(:name => "Make bed")
     proj2 = devel.projects.build(:name => "Lie in it")
     assert_equal devel.projects.last, proj2
     assert !proj2.persisted?
@@ -335,42 +282,9 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert_equal Developer.find(1).projects.sort_by(&:id).last, proj  # prove join table is updated
   end
 
-  if current_adapter?(:IBM_DBAdapter)
-    def test_lob_handling
-      assert_nothing_raised do
-        Novel.connection.create_table 'novels' do |t|
-          t.text :story
-          t.string :title
-        end
-        Writer.connection.create_table 'writers' do |t|
-          t.string :name
-        end
-        NovelsWriter.connection.create_table 'novels_writers' do |t|
-          t.belongs_to :novels
-          t.belongs_to :writers
-        end
-      end
-    
-      w = Writer.new :name => 'Praveen'
-      w.save!
-    
-      novel_story = "This is a short and sweet story"
-    
-      novel = Novel.new :story => novel_story,:title => "Cool isn't it"
-      novel.writers << w
-      novel.save!
-    
-      assert_equal novel_story,Novel.find(novel.id).story
-    ensure
-      Novel.connection.drop_table 'novels' rescue nil
-      Writer.connection.drop_table 'writers' rescue nil
-      NovelsWriter.connection.drop_table 'novels_writers' rescue nil    
-    end  
-  end
-  
   def test_create_by_new_record
     devel = Developer.new(:name => "Marcel", :salary => 75000)
-    proj1 = devel.projects.build(:name => "Make bed")
+    devel.projects.build(:name => "Make bed")
     proj2 = devel.projects.build(:name => "Lie in it")
     assert_equal devel.projects.last, proj2
     assert !proj2.persisted?
@@ -473,38 +387,41 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   def test_removing_associations_on_destroy
     david = DeveloperWithBeforeDestroyRaise.find(1)
     assert !david.projects.empty?
-    assert_raise(RuntimeError) { david.destroy }
+    david.destroy
     assert david.projects.empty?
     assert DeveloperWithBeforeDestroyRaise.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = 1").empty?
   end
 
-  def test_additional_columns_from_join_table
-    assert_date_from_db Date.new(2004, 10, 10), Developer.find(1).projects.first.joined_on.to_date
-  end
-
   def test_destroying
     david = Developer.find(1)
-    active_record = Project.find(1)
+    project = Project.find(1)
     david.projects.reload
     assert_equal 2, david.projects.size
-    assert_equal 3, active_record.developers.size
+    assert_equal 3, project.developers.size
 
-    assert_difference "Project.count", -1 do
-      david.projects.destroy(active_record)
+    assert_no_difference "Project.count" do
+      david.projects.destroy(project)
     end
 
+    join_records = Developer.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = #{david.id} AND project_id = #{project.id}")
+    assert join_records.empty?
+
     assert_equal 1, david.reload.projects.size
     assert_equal 1, david.projects(true).size
   end
 
-  def test_destroying_array
+  def test_destroying_many
     david = Developer.find(1)
     david.projects.reload
+    projects = Project.all
 
-    assert_difference "Project.count", -Project.count do
-      david.projects.destroy(Project.find(:all))
+    assert_no_difference "Project.count" do
+      david.projects.destroy(*projects)
     end
 
+    join_records = Developer.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = #{david.id}")
+    assert join_records.empty?
+
     assert_equal 0, david.reload.projects.size
     assert_equal 0, david.projects(true).size
   end
@@ -513,7 +430,14 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     david = Developer.find(1)
     david.projects.reload
     assert !david.projects.empty?
-    david.projects.destroy_all
+
+    assert_no_difference "Project.count" do
+      david.projects.destroy_all
+    end
+
+    join_records = Developer.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = #{david.id}")
+    assert join_records.empty?
+
     assert david.projects.empty?
     assert david.projects(true).empty?
   end
@@ -607,8 +531,6 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
 
   def test_dynamic_find_should_respect_association_order
     # Developers are ordered 'name DESC, id DESC'
-    low_id_jamis = developers(:jamis)
-    middle_id_jamis = developers(:poor_jamis)
     high_id_jamis = projects(:active_record).developers.create(:name => 'Jamis')
 
     assert_equal high_id_jamis, projects(:active_record).developers.find(:first, :conditions => "name = 'Jamis'")
@@ -704,7 +626,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     project = SpecialProject.create("name" => "Special Project")
     assert developer.save
     developer.projects << project
-    developer.update_attribute("name", "Bruza")
+    developer.update_column("name", "Bruza")
     assert_equal 1, Developer.connection.select_value(<<-end_sql).to_i
       SELECT count(*) FROM developers_projects
       WHERE project_id = #{project.id}
@@ -725,25 +647,6 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert_respond_to categories(:technology).select_testing_posts.find(:first), :correctness_marker
   end
 
-  def test_updating_attributes_on_rich_associations
-    david = projects(:action_controller).developers.first
-    david.name = "DHH"
-    assert_raise(ActiveRecord::ReadOnlyRecord) { david.save! }
-  end
-
-  def test_updating_attributes_on_rich_associations_with_limited_find_from_reflection
-    david = projects(:action_controller).selected_developers.first
-    david.name = "DHH"
-    assert_nothing_raised { david.save! }
-  end
-
-
-  def test_updating_attributes_on_rich_associations_with_limited_find
-    david = projects(:action_controller).developers.find(:all, :select => "developers.*").first
-    david.name = "DHH"
-    assert david.save!
-  end
-
   def test_join_table_alias
     assert_equal 3, Developer.find(:all, :include => {:projects => :developers}, :conditions => 'developers_projects_join.joined_on IS NOT NULL').size
   end
@@ -761,12 +664,12 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   def test_find_grouped
     all_posts_from_category1 = Post.find(:all, :conditions => "category_id = 1", :joins => :categories)
     grouped_posts_of_category1 = Post.find(:all, :conditions => "category_id = 1", :group => "author_id", :select => 'count(posts.id) as posts_count', :joins => :categories)
-    assert_equal 4, all_posts_from_category1.size
-    assert_equal 1, grouped_posts_of_category1.size
+    assert_equal 5, all_posts_from_category1.size
+    assert_equal 2, grouped_posts_of_category1.size
   end
 
   def test_find_scoped_grouped
-    assert_equal 4, categories(:general).posts_grouped_by_title.size
+    assert_equal 5, categories(:general).posts_grouped_by_title.size
     assert_equal 1, categories(:technology).posts_grouped_by_title.size
   end
 
@@ -846,12 +749,10 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     }
   end
 
-  unless current_adapter?(:IBM_DBAdapter) #refer SQL214n
-    def test_dynamic_find_should_respect_association_include
-      # SQL error in sort clause if :include is not included
-      # due to Unknown column 'authors.id'
-      assert Category.find(1).posts_with_authors_sorted_by_author_id.find_by_title('Welcome to the weblog')
-    end
+  def test_dynamic_find_should_respect_association_include
+    # SQL error in sort clause if :include is not included
+    # due to Unknown column 'authors.id'
+    assert Category.find(1).posts_with_authors_sorted_by_author_id.find_by_title('Welcome to the weblog')
   end
 
   def test_counting_on_habtm_association_and_not_array
@@ -874,7 +775,7 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert_equal 1, developer.projects.count
   end
 
-  unless current_adapter?(:PostgreSQLAdapter)
+  unless current_adapter?(:PostgreSQLAdapter, :IBM_DBAdapter)
     def test_count_with_finder_sql
       assert_equal 3, projects(:active_record).developers_with_finder_sql.count
       assert_equal 3, projects(:active_record).developers_with_multiline_finder_sql.count
@@ -892,10 +793,13 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     david = Developer.find(1)
     # clear cache possibly created by other tests
     david.projects.reset_column_information
-    assert_queries(0) { david.projects.columns; david.projects.columns }
-    # and again to verify that reset_column_information clears the cache correctly
+
+    # One query for columns, one for primary key
+    assert_queries(2) { david.projects.columns; david.projects.columns }
+
+    ## and again to verify that reset_column_information clears the cache correctly
     david.projects.reset_column_information
-    assert_queries(0) { david.projects.columns; david.projects.columns }
+    assert_queries(2) { david.projects.columns; david.projects.columns }
   end
 
   def test_attributes_are_being_set_when_initialized_from_habm_association_with_where_clause