ibm_db 2.5.9 → 2.5.10

data/test/cases/associations/belongs_to_associations_test.rb

@@ -13,6 +13,7 @@ require 'models/comment'
 require 'models/sponsor'
 require 'models/member'
 require 'models/essay'
+require 'models/toy'
 
 class BelongsToAssociationsTest < ActiveRecord::TestCase
   fixtures :accounts, :companies, :developers, :projects, :topics,
@@ -300,6 +301,15 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_equal 1, Topic.find(topic.id)[:replies_count]
   end
 
+  def test_belongs_to_counter_when_update_column
+    topic = Topic.create!(:title => "37s")
+    topic.replies.create!(:title => "re: 37s", :content => "rails")
+    assert_equal 1, Topic.find(topic.id)[:replies_count]
+
+    topic.update_column(:content, "rails is wonderfull")
+    assert_equal 1, Topic.find(topic.id)[:replies_count]
+  end
+
   def test_assignment_before_child_saved
     final_cut = Client.new("name" => "Final Cut")
     firm = Firm.find(1)
@@ -347,6 +357,12 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_equal members(:groucho), sponsor.sponsorable
   end
 
+  def test_dont_find_target_when_foreign_key_is_null
+    tagging = taggings(:thinking_general)
+    queries = assert_sql { tagging.super_tag }
+    assert_equal 0, queries.length
+  end
+
   def test_field_name_same_as_foreign_key
     computer = Computer.find(1)
     assert_not_nil computer.developer, ":foreign key == attribute didn't lock up" # '
@@ -685,4 +701,11 @@ class BelongsToAssociationsTest < ActiveRecord::TestCase
     assert_equal nil, comment.reload.parent
     assert_equal 0, comments(:greetings).reload.children_count
   end
+
+  def test_polymorphic_with_custom_primary_key
+    toy = Toy.create!
+    sponsor = Sponsor.create!(:sponsorable => toy)
+
+    assert_equal toy, sponsor.reload.sponsorable
+  end
 end

data/test/cases/associations/cascaded_eager_loading_test.rb

@@ -8,10 +8,12 @@ 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
+           :categorizations, :people, :categories, :edges, :vertices
 
   def test_eager_association_loading_with_cascaded_two_levels
     authors = Author.find(:all, :include=>{:posts=>:comments}, :order=>"authors.id")
@@ -166,12 +168,6 @@ class CascadedEagerLoadingTest < ActiveRecord::TestCase
       authors[2].post_about_thinking.comments.first
     end
   end
-end
-
-require 'models/vertex'
-require 'models/edge'
-class CascadedEagerLoadingTest < ActiveRecord::TestCase
-  fixtures :edges, :vertices
 
   def test_eager_association_loading_with_recursive_cascading_four_levels_has_many_through
     source = Vertex.find(:first, :include=>{:sinks=>{:sinks=>{:sinks=>:sinks}}}, :order => 'vertices.id')

data/test/cases/associations/has_and_belongs_to_many_associations_test.rb

@@ -23,7 +23,7 @@ require 'models/treaty'
 require 'active_support/core_ext/string/conversions'
 
 class ProjectWithAfterCreateHook < ActiveRecord::Base
-  set_table_name 'projects'
+  self.table_name = 'projects'
   has_and_belongs_to_many :developers,
     :class_name => "DeveloperForProjectWithAfterCreateHook",
     :join_table => "developers_projects",
@@ -39,7 +39,7 @@ class ProjectWithAfterCreateHook < ActiveRecord::Base
 end
 
 class DeveloperForProjectWithAfterCreateHook < ActiveRecord::Base
-  set_table_name 'developers'
+  self.table_name = 'developers'
   has_and_belongs_to_many :projects,
     :class_name => "ProjectWithAfterCreateHook",
     :join_table => "developers_projects",
@@ -48,7 +48,7 @@ class DeveloperForProjectWithAfterCreateHook < ActiveRecord::Base
 end
 
 class ProjectWithSymbolsForKeys < ActiveRecord::Base
-  set_table_name 'projects'
+  self.table_name = 'projects'
   has_and_belongs_to_many :developers,
     :class_name => "DeveloperWithSymbolsForKeys",
     :join_table => :developers_projects,
@@ -57,7 +57,7 @@ class ProjectWithSymbolsForKeys < ActiveRecord::Base
 end
 
 class DeveloperWithSymbolsForKeys < ActiveRecord::Base
-  set_table_name 'developers'
+  self.table_name = 'developers'
   has_and_belongs_to_many :projects,
     :class_name => "ProjectWithSymbolsForKeys",
     :join_table => :developers_projects,
@@ -66,7 +66,7 @@ class DeveloperWithSymbolsForKeys < ActiveRecord::Base
 end
 
 class DeveloperWithCounterSQL < ActiveRecord::Base
-  set_table_name 'developers'
+  self.table_name = 'developers'
   has_and_belongs_to_many :projects,
     :class_name => "DeveloperWithCounterSQL",
     :join_table => "developers_projects",
@@ -77,7 +77,7 @@ end
 
 class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
   fixtures :accounts, :companies, :categories, :posts, :categories_posts, :developers, :projects, :developers_projects,
-           :parrots, :pirates, :treasures, :price_estimates, :tags, :taggings
+           :parrots, :pirates, :parrots_pirates, :treasures, :price_estimates, :tags, :taggings
 
   def setup_data_for_habtm_case
     ActiveRecord::Base.connection.execute('delete from countries_treaties')
@@ -100,10 +100,13 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert_equal 'c1', record[0]
     assert_equal 't1', record[1]
   end
-  
+
   def test_proper_usage_of_primary_keys_and_join_table
     setup_data_for_habtm_case
 
+    assert_equal 'country_id', Country.primary_key
+    assert_equal 'treaty_id', Treaty.primary_key
+
     country = Country.first
     assert_equal 1, country.treaties.count
   end
@@ -442,6 +445,26 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert david.projects(true).empty?
   end
 
+  def test_destroy_associations_destroys_multiple_associations
+    george = parrots(:george)
+    assert !george.pirates.empty?
+    assert !george.treasures.empty?
+
+    assert_no_difference "Pirate.count" do
+      assert_no_difference "Treasure.count" do
+        george.destroy_associations
+      end
+    end
+
+    join_records = Parrot.connection.select_all("SELECT * FROM parrots_pirates WHERE parrot_id = #{george.id}")
+    assert join_records.empty?
+    assert george.pirates(true).empty?
+
+    join_records = Parrot.connection.select_all("SELECT * FROM parrots_treasures WHERE parrot_id = #{george.id}")
+    assert join_records.empty?
+    assert george.treasures(true).empty?
+  end
+
   def test_deprecated_push_with_attributes_was_removed
     jamis = developers(:jamis)
     assert_raise(NoMethodError) do
@@ -647,6 +670,14 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     assert_respond_to categories(:technology).select_testing_posts.find(:first), :correctness_marker
   end
 
+  def test_habtm_selects_all_columns_by_default
+    assert_equal Project.column_names.sort, developers(:david).projects.first.attributes.keys.sort
+  end
+
+  def test_habtm_respects_select_query_method
+    assert_equal ['id'], developers(:david).projects.select(:id).first.attributes.keys
+  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
@@ -794,12 +825,11 @@ class HasAndBelongsToManyAssociationsTest < ActiveRecord::TestCase
     # clear cache possibly created by other tests
     david.projects.reset_column_information
 
-    # One query for columns, one for primary key
-    assert_queries(2) { david.projects.columns; david.projects.columns }
+    assert_queries(1) { 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(2) { david.projects.columns; david.projects.columns }
+    assert_queries(1) { david.projects.columns; david.projects.columns }
   end
 
   def test_attributes_are_being_set_when_initialized_from_habm_association_with_where_clause

data/test/cases/associations/join_model_test.rb

@@ -403,7 +403,7 @@ 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).tagging
+    assert_equal Tagging.find(1,2).sort_by { |t| t.id }, authors(:david).tagging.order(:id)
   end
 
   def test_has_many_through_polymorphic_has_many
@@ -455,7 +455,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_has_many_through_uses_conditions_specified_on_the_has_many_association
-    author = Author.find(:first)
+    author = Author.order(:id).first
     assert_present author.comments
     assert_blank author.nonexistant_comments
   end
@@ -652,7 +652,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
   end
 
   def test_preload_polymorph_many_types
-    taggings = Tagging.find :all, :include => :taggable, :conditions => ['taggable_type != ?', 'FakeModel']
+    taggings = Tagging.find :all, :include => :taggable, :conditions => ['taggable_type != ?', 'FakeModel'], :order => 'id'
     assert_no_queries do
       taggings.first.taggable.id
       taggings[1].taggable.id
@@ -736,7 +736,7 @@ class AssociationsJoinModelTest < ActiveRecord::TestCase
       class_name = "PostWith#{association.to_s.classify}#{dependency.to_s.classify}"
       Post.find(post_id).update_column :type, class_name
       klass = Object.const_set(class_name, Class.new(ActiveRecord::Base))
-      klass.set_table_name 'posts'
+      klass.table_name = 'posts'
       klass.send(association, association_name, :as => :taggable, :dependent => dependency)
       klass.find(post_id)
     end

data/test/cases/attribute_methods_test.rb

@@ -30,9 +30,36 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     t = Topic.new
     t.title = "hello there!"
     t.written_on = Time.now
+    t.author_name = ""
     assert t.attribute_present?("title")
     assert t.attribute_present?("written_on")
     assert !t.attribute_present?("content")
+    assert !t.attribute_present?("author_name")
+    
+  end
+
+  def test_attribute_present_with_booleans
+    b1 = Boolean.new
+    b1.value = false
+    assert b1.attribute_present?(:value)
+
+    b2 = Boolean.new
+    b2.value = true
+    assert b2.attribute_present?(:value)
+
+    b3 = Boolean.new
+    assert !b3.attribute_present?(:value)
+
+    b4 = Boolean.new
+    b4.value = false
+    b4.save!
+    assert Boolean.find(b4.id).attribute_present?(:value)
+  end
+
+  def test_caching_nil_primary_key
+    klass = Class.new(Minimalistic)
+    klass.expects(:reset_primary_key).returns(nil).once
+    2.times { klass.primary_key }
   end
 
   def test_attribute_keys_on_new_instance
@@ -90,6 +117,11 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert !topic.respond_to?(:nothingness)
   end
 
+  def test_deprecated_underscore_method
+    topic = Topic.find(1)
+    assert_equal topic.title, assert_deprecated { topic._title }
+  end
+
   def test_respond_to_with_custom_primary_key
     keyboard = Keyboard.create
     assert_not_nil keyboard.key_number
@@ -109,6 +141,15 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_respond_to topic, :title
   end
 
+  # IRB inspects the return value of "MyModel.allocate"
+  # by inspecting it.
+  def test_allocated_object_can_be_inspected
+    topic = Topic.allocate
+    topic.instance_eval { @attributes = nil }
+    assert_nothing_raised { topic.inspect }
+    assert topic.inspect, "#<Topic not initialized>"
+  end
+
   def test_array_content
     topic = Topic.new
     topic.content = %w( one two three )
@@ -228,8 +269,14 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     topic.send(:write_attribute, :title, "Still another topic")
     assert_equal "Still another topic", topic.title
 
-    topic.send(:write_attribute, "title", "Still another topic: part 2")
+    topic[:title] = "Still another topic: part 2"
     assert_equal "Still another topic: part 2", topic.title
+
+    topic.send(:write_attribute, "title", "Still another topic: part 3")
+    assert_equal "Still another topic: part 3", topic.title
+
+    topic["title"] = "Still another topic: part 4"
+    assert_equal "Still another topic: part 4", topic.title
   end
 
   def test_read_attribute
@@ -282,6 +329,39 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     # puts ""
   end
 
+  def test_overridden_write_attribute
+    topic = Topic.new
+    def topic.write_attribute(attr_name, value)
+      super(attr_name, value.downcase)
+    end
+
+    topic.send(:write_attribute, :title, "Yet another topic")
+    assert_equal "yet another topic", topic.title
+
+    topic[:title] = "Yet another topic: part 2"
+    assert_equal "yet another topic: part 2", topic.title
+
+    topic.send(:write_attribute, "title", "Yet another topic: part 3")
+    assert_equal "yet another topic: part 3", topic.title
+
+    topic["title"] = "Yet another topic: part 4"
+    assert_equal "yet another topic: part 4", topic.title
+  end
+
+  def test_overridden_read_attribute
+    topic = Topic.new
+    topic.title = "Stop changing the topic"
+    def topic.read_attribute(attr_name)
+      super(attr_name).upcase
+    end
+
+    assert_equal "STOP CHANGING THE TOPIC", topic.send(:read_attribute, "title")
+    assert_equal "STOP CHANGING THE TOPIC", topic["title"]
+
+    assert_equal "STOP CHANGING THE TOPIC", topic.send(:read_attribute, :title)
+    assert_equal "STOP CHANGING THE TOPIC", topic[:title]
+  end
+
   def test_read_overridden_attribute
     topic = Topic.new(:title => 'a')
     def topic.title() 'b' end
@@ -422,30 +502,6 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert topic.is_test?
   end
 
-  def test_kernel_methods_not_implemented_in_activerecord
-    %w(test name display y).each do |method|
-      assert !ActiveRecord::Base.instance_method_already_implemented?(method), "##{method} is defined"
-    end
-  end
-
-  def test_defined_kernel_methods_implemented_in_model
-    %w(test name display y).each do |method|
-      klass = Class.new ActiveRecord::Base
-      klass.class_eval "def #{method}() 'defined #{method}' end"
-      assert klass.instance_method_already_implemented?(method), "##{method} is not defined"
-    end
-  end
-
-  def test_defined_kernel_methods_implemented_in_model_abstract_subclass
-    %w(test name display y).each do |method|
-      abstract = Class.new ActiveRecord::Base
-      abstract.class_eval "def #{method}() 'defined #{method}' end"
-      abstract.abstract_class = true
-      klass = Class.new abstract
-      assert klass.instance_method_already_implemented?(method), "##{method} is not defined"
-    end
-  end
-
   def test_raises_dangerous_attribute_error_when_defining_activerecord_method_in_model
     %w(save create_or_update).each do |method|
       klass = Class.new ActiveRecord::Base
@@ -539,6 +595,17 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     end
   end
 
+  def test_setting_time_zone_aware_read_attribute
+    utc_time = Time.utc(2008, 1, 1)
+    cst_time = utc_time.in_time_zone("Central Time (US & Canada)")
+    in_time_zone "Pacific Time (US & Canada)" do
+      record = @target.create(:written_on => cst_time).reload
+      assert_equal utc_time, record[:written_on]
+      assert_equal ActiveSupport::TimeZone["Pacific Time (US & Canada)"], record[:written_on].time_zone
+      assert_equal Time.utc(2007, 12, 31, 16), record[:written_on].time
+    end
+  end
+
   def test_setting_time_zone_aware_attribute_with_string
     utc_time = Time.utc(2008, 1, 1)
     (-11..13).each do |timezone_offset|
@@ -558,6 +625,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
       record   = @target.new
       record.written_on = ' '
       assert_nil record.written_on
+      assert_nil record[:written_on]
     end
   end
 
@@ -599,7 +667,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     topic = @target.new(:title => "The pros and cons of programming naked.")
     assert !topic.respond_to?(:title)
     exception = assert_raise(NoMethodError) { topic.title }
-    assert_match %r(^Attempt to call private method), exception.message
+    assert exception.message.include?("private method")
     assert_equal "I'm private", topic.send(:title)
   end
 
@@ -609,7 +677,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     topic = @target.new
     assert !topic.respond_to?(:title=)
     exception = assert_raise(NoMethodError) { topic.title = "Pants"}
-    assert_match %r(^Attempt to call private method), exception.message
+    assert exception.message.include?("private method")
     topic.send(:title=, "Very large pants")
   end
 
@@ -619,7 +687,7 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     topic = @target.new(:title => "Isaac Newton's pants")
     assert !topic.respond_to?(:title?)
     exception = assert_raise(NoMethodError) { topic.title? }
-    assert_match %r(^Attempt to call private method), exception.message
+    assert exception.message.include?("private method")
     assert topic.send(:title?)
   end
 
@@ -650,19 +718,87 @@ class AttributeMethodsTest < ActiveRecord::TestCase
     assert_equal %w(preferences), Contact.serialized_attributes.keys
   end
 
+  def test_instance_method_should_be_defined_on_the_base_class
+    subklass = Class.new(Topic)
+
+    Topic.define_attribute_methods
+
+    instance = subklass.new
+    instance.id = 5
+    assert_equal 5, instance.id
+    assert subklass.method_defined?(:id), "subklass is missing id method"
+
+    Topic.undefine_attribute_methods
+
+    assert_equal 5, instance.id
+    assert subklass.method_defined?(:id), "subklass is missing id method"
+  end
+
+  def test_dispatching_column_attributes_through_method_missing_deprecated
+    Topic.define_attribute_methods
+
+    topic = Topic.new(:id => 5)
+    topic.id = 5
+
+    topic.method(:id).owner.send(:undef_method, :id)
+
+    assert_deprecated do
+      assert_equal 5, topic.id
+    end
+  ensure
+    Topic.undefine_attribute_methods
+  end
+
+  def test_read_attribute_with_nil_should_not_asplode
+    assert_equal nil, Topic.new.read_attribute(nil)
+  end
+
+  # If B < A, and A defines an accessor for 'foo', we don't want to override
+  # that by defining a 'foo' method in the generated methods module for B.
+  # (That module will be inserted between the two, e.g. [B, <GeneratedAttributes>, A].)
+  def test_inherited_custom_accessors
+    klass = Class.new(ActiveRecord::Base) do
+      self.table_name = "topics"
+      self.abstract_class = true
+      def title; "omg"; end
+      def title=(val); self.author_name = val; end
+    end
+    subklass = Class.new(klass)
+    [klass, subklass].each(&:define_attribute_methods)
+
+    topic = subklass.find(1)
+    assert_equal "omg", topic.title
+
+    topic.title = "lol"
+    assert_equal "lol", topic.author_name
+  end
+
+  def test_inherited_hook_removed
+    parent = Class.new(ActiveRecord::Base)
+    parent.table_name = "posts"
+    def parent.inherited(k)
+    end
+
+    klass = Class.new(parent)
+    assert_deprecated { klass.define_attribute_methods }
+  end
+
+  def test_setting_new_attributes_deprecated
+    t = Topic.new
+    assert_deprecated { t[:foo] = "bar" }
+    assert_equal "bar", t.foo
+    assert_equal "bar", t[:foo]
+  end
+
   private
   def cached_columns
-    @cached_columns ||= (time_related_columns_on_topic + serialized_columns_on_topic).map(&:name)
+    @cached_columns ||= time_related_columns_on_topic.map(&:name)
   end
 
   def time_related_columns_on_topic
     Topic.columns.select { |c| c.type.in?([:time, :date, :datetime, :timestamp]) }
   end
 
-  def serialized_columns_on_topic
-    Topic.columns.select { |c| Topic.serialized_attributes.include?(c.name) }
-  end
-
   def in_time_zone(zone)
     old_zone  = Time.zone
     old_tz    = ActiveRecord::Base.time_zone_aware_attributes