activerecord 1.13.0 → 1.13.1

data/lib/active_record/version.rb

@@ -1,8 +1,8 @@
 module ActiveRecord
-  module Version #:nodoc:
+  module VERSION #:nodoc:
     MAJOR = 1
     MINOR = 13
-    TINY  = 0
+    TINY  = 1
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/rakefile

@@ -9,7 +9,7 @@ require File.join(File.dirname(__FILE__), 'lib', 'active_record', 'version')
 
 PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
 PKG_NAME      = 'activerecord'
-PKG_VERSION   = ActiveRecord::Version::STRING + PKG_BUILD
+PKG_VERSION   = ActiveRecord::VERSION::STRING + PKG_BUILD
 PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 
 RELEASE_NAME  = "REL #{PKG_VERSION}"
@@ -27,7 +27,7 @@ task :default => [ :test_mysql, :test_sqlite, :test_postgresql ]
 
 # Run the unit tests
 
-for adapter in %w( mysql postgresql sqlite sqlite3 sqlserver sqlserver_odbc db2 oci )
+for adapter in %w( mysql postgresql sqlite sqlite3 firebird sqlserver sqlserver_odbc db2 oci )
   Rake::TestTask.new("test_#{adapter}") { |t|
     t.libs << "test" << "test/connections/native_#{adapter}"
     t.pattern = "test/*_test{,_#{adapter}}.rb"
@@ -35,6 +35,41 @@ for adapter in %w( mysql postgresql sqlite sqlite3 sqlserver sqlserver_odbc db2
   }
 end
 
+SCHEMA_PATH = File.join(File.dirname(__FILE__), *%w(test fixtures db_definitions))
+
+desc 'Build the MySQL test databases'
+task :build_mysql_databases do 
+  %x( mysqladmin  create activerecord_unittest )
+  %x( mysqladmin  create activerecord_unittest2 )
+  %x( mysql  activerecord_unittest < #{File.join(SCHEMA_PATH, 'mysql.sql')} )
+  %x( mysql  activerecord_unittest < #{File.join(SCHEMA_PATH, 'mysql2.sql')} )
+end
+
+desc 'Drop the MySQL test databases'
+task :drop_mysql_databases do 
+  %x( mysqladmin -f drop activerecord_unittest )
+  %x( mysqladmin -f drop activerecord_unittest2 )
+end
+
+desc 'Rebuild the MySQL test databases'
+task :rebuild_mysql_databases => [:drop_mysql_databases, :build_mysql_databases]
+
+desc 'Build the PostgreSQL test databases'
+task :build_postgresql_databases do 
+  %x( createdb activerecord_unittest )
+  %x( createdb activerecord_unittest2 )
+  %x( psql activerecord_unittest -f #{File.join(SCHEMA_PATH, 'postgresql.sql')} )
+  %x( psql activerecord_unittest -f #{File.join(SCHEMA_PATH, 'postgresql2.sql')} )
+end
+
+desc 'Drop the PostgreSQL test databases'
+task :drop_postgresql_databases do 
+  %x( dropdb   activerecord_unittest )
+  %x( dropdb   activerecord_unittest2 )
+end
+
+desc 'Rebuild the PostgreSQL test databases'
+task :rebuild_postgresql_databases => [:drop_postgresql_databases, :build_postgresql_databases]
 
 # Generate the RDoc documentation
 
@@ -71,7 +106,7 @@ spec = Gem::Specification.new do |s|
     s.files = s.files + Dir.glob( "#{dir}/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
   end
   
-  s.add_dependency('activesupport', '= 1.2.3' + PKG_BUILD)
+  s.add_dependency('activesupport', '= 1.2.4' + PKG_BUILD)
 
   s.files.delete "test/fixtures/fixture_database.sqlite"
   s.files.delete "test/fixtures/fixture_database_2.sqlite"

data/test/abstract_unit.rb

@@ -8,6 +8,8 @@ require 'active_support/binding_of_caller'
 require 'active_support/breakpoint'
 require 'connection'
 
+QUOTED_TYPE = ActiveRecord::Base.connection.quote_column_name('type') unless Object.const_defined?(:QUOTED_TYPE)
+
 class Test::Unit::TestCase #:nodoc:
   self.fixture_path = File.dirname(__FILE__) + "/fixtures/"
   self.use_instantiated_fixtures = false
@@ -22,3 +24,6 @@ def current_adapter?(type)
   ActiveRecord::ConnectionAdapters.const_defined?(type) &&
     ActiveRecord::Base.connection.instance_of?(ActiveRecord::ConnectionAdapters.const_get(type))
 end
+
+#ActiveRecord::Base.logger = Logger.new(STDOUT)
+#ActiveRecord::Base.colorize_logging = false

data/test/aggregations_test.rb

@@ -44,4 +44,23 @@ class AggregationsTest < Test::Unit::TestCase
     assert_equal "39", customers(:david).gps_location.latitude
     assert_equal "-110", customers(:david).gps_location.longitude
   end
+
+  def test_reloaded_instance_refreshes_aggregations
+    assert_equal "35.544623640962634", customers(:david).gps_location.latitude
+    assert_equal "-105.9309951055148", customers(:david).gps_location.longitude
+
+    Customer.update_all("gps_location = '24x113'")
+    customers(:david).reload
+    assert_equal '24x113', customers(:david)['gps_location']
+
+    assert_equal GpsLocation.new('24x113'), customers(:david).gps_location 
+  end
+
+  def test_gps_equality
+    assert GpsLocation.new('39x110') == GpsLocation.new('39x110')
+  end
+
+  def test_gps_inequality
+    assert GpsLocation.new('39x110') != GpsLocation.new('39x111')
+  end
 end

data/test/associations_go_eager_test.rb

@@ -21,7 +21,7 @@ class EagerAssociationTest < Test::Unit::TestCase
   end
 
   def test_loading_conditions_with_or
-    posts = authors(:david).posts.find(:all, :include => :comments, :conditions => "comments.body like 'Normal%' OR comments.type = 'SpecialComment'")
+    posts = authors(:david).posts.find(:all, :include => :comments, :conditions => "comments.body like 'Normal%' OR comments.#{QUOTED_TYPE} = 'SpecialComment'")
     assert_nil posts.detect { |p| p.author_id != authors(:david).id },
       "expected to find only david's posts"
   end
@@ -83,6 +83,12 @@ class EagerAssociationTest < Test::Unit::TestCase
     assert_equal [6,7,8], comments.collect { |c| c.id }
   end
   
+  def test_eager_association_loading_with_belongs_to_and_limit_and_offset_and_conditions_array
+    comments = Comment.find(:all, :include => :post, :conditions => ['post_id = ?',4], :limit => 3, :offset => 1, :order => 'comments.id')
+    assert_equal 3, comments.length
+    assert_equal [6,7,8], comments.collect { |c| c.id }
+  end
+
   def test_eager_association_loading_with_belongs_to_and_limit_and_multiple_associations
     posts = Post.find(:all, :include => [:author, :very_special_comment], :limit => 1)
     assert_equal 1, posts.length
@@ -101,6 +107,24 @@ class EagerAssociationTest < Test::Unit::TestCase
     assert_equal 3, posts.inject(0) { |sum, post| sum += post.comments.size }
   end
 
+  def test_eager_with_has_many_and_limit_and_conditions
+    posts = Post.find(:all, :include => [ :author, :comments ], :limit => 2, :conditions => "posts.body = 'hello'", :order => "posts.id")
+    assert_equal 2, posts.size
+    assert_equal [4,5], posts.collect { |p| p.id }
+  end
+
+  def test_eager_with_has_many_and_limit_and_conditions_array
+    posts = Post.find(:all, :include => [ :author, :comments ], :limit => 2, :conditions => [ "posts.body = ?", 'hello' ], :order => "posts.id")
+    assert_equal 2, posts.size
+    assert_equal [4,5], posts.collect { |p| p.id }    
+  end
+
+  def test_eager_with_has_many_and_limit_and_conditions_array_on_the_eagers
+    assert_raises(ArgumentError) do
+      posts = Post.find(:all, :include => [ :author, :comments ], :limit => 2, :conditions => [ "authors.name = ?", 'David' ])
+    end
+  end
+
   def test_eager_with_has_many_and_limit_with_no_results
     posts = Post.find(:all, :include => [ :author, :comments ], :limit => 2, :conditions => "posts.title = 'magic forest'")
     assert_equal 0, posts.size
@@ -120,7 +144,7 @@ class EagerAssociationTest < Test::Unit::TestCase
     assert_raises(ArgumentError) do
       posts = authors(:david).posts.find(:all, 
         :include    => :comments, 
-        :conditions => "comments.body like 'Normal%' OR comments.type = 'SpecialComment'",
+        :conditions => "comments.body like 'Normal%' OR comments.#{QUOTED_TYPE}= 'SpecialComment'",
         :limit      => 2
       )
     end

data/test/associations_test.rb

@@ -351,7 +351,7 @@ class HasManyAssociationsTest < Test::Unit::TestCase
   def test_find_all
     firm = Firm.find_first
     assert_equal firm.clients, firm.clients.find_all
-    assert_equal 2, firm.clients.find(:all, :conditions => "type = 'Client'").length
+    assert_equal 2, firm.clients.find(:all, :conditions => "#{QUOTED_TYPE} = 'Client'").length
     assert_equal 1, firm.clients.find(:all, :conditions => "name = 'Summit'").length
   end
 
@@ -367,16 +367,16 @@ class HasManyAssociationsTest < Test::Unit::TestCase
     firm = Firm.find_first
     client2 = Client.find(2)
     assert_equal firm.clients.first, firm.clients.find_first
-    assert_equal client2, firm.clients.find_first("type = 'Client'")
-    assert_equal client2, firm.clients.find(:first, :conditions => "type = 'Client'")
+    assert_equal client2, firm.clients.find_first("#{QUOTED_TYPE} = 'Client'")
+    assert_equal client2, firm.clients.find(:first, :conditions => "#{QUOTED_TYPE} = 'Client'")
   end
 
   def test_find_first_sanitized
     firm = Firm.find_first
     client2 = Client.find(2)
-    assert_equal client2, firm.clients.find_first(["type = ?", "Client"])
-    assert_equal client2, firm.clients.find(:first, :conditions => ['type = ?', 'Client'])
-    assert_equal client2, firm.clients.find(:first, :conditions => ['type = :type', { :type => 'Client' }])
+    assert_equal client2, firm.clients.find_first(["#{QUOTED_TYPE} = ?", "Client"])
+    assert_equal client2, firm.clients.find(:first, :conditions => ["#{QUOTED_TYPE} = ?", 'Client'])
+    assert_equal client2, firm.clients.find(:first, :conditions => ["#{QUOTED_TYPE} = :type", { :type => 'Client' }])
   end
 
   def test_find_in_collection
@@ -384,6 +384,13 @@ class HasManyAssociationsTest < Test::Unit::TestCase
     assert_raises(ActiveRecord::RecordNotFound) { companies(:first_firm).clients.find(6) }
   end
 
+  def test_find_grouped
+    all_clients_of_firm1 = Client.find(:all, :conditions => "firm_id = 1")
+    grouped_clients_of_firm1 = Client.find(:all, :conditions => "firm_id = 1", :group => "firm_id", :select => 'firm_id, count(id) as clients_count')
+    assert_equal 2, all_clients_of_firm1.size
+    assert_equal 1, grouped_clients_of_firm1.size
+  end
+
   def test_adding
     force_signal37_to_load_all_clients_of_firm
     natural = Client.new("name" => "Natural Company")
@@ -1246,10 +1253,13 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
   end
 
   def test_removing_associations_on_destroy
-    Developer.find(1).destroy
-    assert Developer.connection.select_all("SELECT * FROM developers_projects WHERE developer_id = 1").empty?
+    david = DeveloperWithBeforeDestroyRaise.find(1)
+    assert !david.projects.empty?
+    assert_nothing_raised { 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
     # SQL Server doesn't have a separate column type just for dates, 
     # so the time is in the string and incorrectly formatted
@@ -1371,5 +1381,14 @@ class HasAndBelongsToManyAssociationsTest < Test::Unit::TestCase
     assert developer.special_projects.include?(special_project)
     assert !developer.special_projects.include?(other_project)
   end
-
+  
+  def test_update_attributes_after_push_without_duplicate_join_table_rows
+    developer = Developer.new("name" => "Kano")
+    project = SpecialProject.create("name" => "Special Project")
+    assert developer.save
+    developer.projects << project
+    developer.update_attribute("name", "Bruza")
+    assert_equal 1, developer.connection.select_one("SELECT count(*) FROM developers_projects WHERE 
+      project_id = #{project.id} AND developer_id = #{developer.id}")["count(*)"].to_i
+  end
 end

data/test/base_test.rb

@@ -17,6 +17,7 @@ class MasterCreditCard < ActiveRecord::Base; end
 class Post < ActiveRecord::Base; end
 class Computer < ActiveRecord::Base; end
 class NonExistentTable < ActiveRecord::Base; end
+class TestOCIDefault < ActiveRecord::Base; end
 
 class LoosePerson < ActiveRecord::Base
   attr_protected :credit_rating, :administrator
@@ -205,6 +206,40 @@ class BasicsTest < Test::Unit::TestCase
     topic = topics(:first)
     topic.approved = false
     assert !topic.approved?, "approved should be false"
+    topic.approved = "false"
+    assert !topic.approved?, "approved should be false"
+  end
+
+  def test_read_attribute_when_true
+    topic = topics(:first)
+    topic.approved = true
+    assert topic.approved?, "approved should be true"
+    topic.approved = "true"
+    assert topic.approved?, "approved should be true"
+  end
+
+  def test_read_write_boolean_attribute
+    topic = Topic.new
+    # puts ""
+    # puts "New Topic"
+    # puts topic.inspect
+    topic.approved = "false"
+    # puts "Expecting false"
+    # puts topic.inspect
+    assert !topic.approved?, "approved should be false"
+    topic.approved = "false"
+    # puts "Expecting false"
+    # puts topic.inspect
+    assert !topic.approved?, "approved should be false"
+    topic.approved = "true"
+    # puts "Expecting true"
+    # puts topic.inspect
+    assert topic.approved?, "approved should be true"
+    topic.approved = "true"
+    # puts "Expecting true"
+    # puts topic.inspect
+    assert topic.approved?, "approved should be true"
+    # puts ""
   end
 
   def test_reader_generation
@@ -220,6 +255,13 @@ class BasicsTest < Test::Unit::TestCase
     end
   end
 
+  def test_reader_for_invalid_column_names
+    # column names which aren't legal ruby ids
+    topic = Topic.find(:first)
+    topic.send(:define_read_method, "mumub-jumbo".to_sym, "mumub-jumbo", nil)
+    assert !Topic.read_methods.include?("mumub-jumbo")
+  end
+
   def test_non_attribute_access_and_assignment
     topic = Topic.new
     assert !topic.respond_to?("mumbo")
@@ -470,6 +512,15 @@ class BasicsTest < Test::Unit::TestCase
     topic = Topic.find(topic.id)
     assert topic.approved?
     assert_nil topic.last_read
+
+    # Oracle has some funky default handling, so it requires a bit of 
+    # extra testing. See ticket #2788.
+    if current_adapter?(:OCIAdapter)
+      test = TestOCIDefault.new
+      assert_equal "X", test.test_char
+      assert_equal "hello", test.test_string
+      assert_equal 3, test.test_int
+    end
   end
 
   def test_utc_as_time_zone
@@ -495,7 +546,7 @@ class BasicsTest < Test::Unit::TestCase
     assert_nil topic.last_read
     assert_nil topic.approved
   end
-  
+
   def test_equality
     assert_equal Topic.find(1), Topic.find(2).parent
   end
@@ -839,10 +890,10 @@ class BasicsTest < Test::Unit::TestCase
   def test_column_name_properly_quoted
     col_record = ColumnName.new
     col_record.references = 40
-    col_record.save
+    assert col_record.save
     col_record.references = 41
-    col_record.save
-    c2 = ColumnName.find(col_record.id)
+    assert col_record.save
+    assert_not_nil c2 = ColumnName.find(col_record.id)
     assert_equal(41, c2.references)
   end
 
@@ -993,10 +1044,10 @@ class BasicsTest < Test::Unit::TestCase
   end
 
   def test_count_with_join
-    res = Post.count_by_sql "SELECT COUNT(*) FROM posts LEFT JOIN comments ON posts.id=comments.post_id WHERE posts.type = 'Post'"
+    res = Post.count_by_sql "SELECT COUNT(*) FROM posts LEFT JOIN comments ON posts.id=comments.post_id WHERE posts.#{QUOTED_TYPE} = 'Post'"
     res2 = res + 1
     assert_nothing_raised do
-      res2 = Post.count("posts.type = 'Post'",
+      res2 = Post.count("posts.#{QUOTED_TYPE} = 'Post'",
                         "LEFT JOIN comments ON posts.id=comments.post_id")
     end
     assert_equal res, res2

data/test/binary_test.rb

@@ -18,9 +18,9 @@ class BinaryTest < Test::Unit::TestCase
   # limited to 8KB.
   #
   # Without using prepared statements, it makes no sense to test
-  # BLOB data with DB2, because the length of a statement is
-  # limited to 32KB.
-  unless %w(SQLServer DB2 OCI).include? ActiveRecord::Base.connection.adapter_name
+  # BLOB data with DB2 or Firebird, because the length of a statement
+  # is limited to 32KB.
+  unless %w(SQLServer DB2 OCI Firebird).include? ActiveRecord::Base.connection.adapter_name
     def test_load_save
       bin = Binary.new
       bin.data = @data

data/test/connections/native_db2/connection.rb

@@ -1,5 +1,5 @@
 print "Using native DB2\n"
-require 'fixtures/course'
+require_dependency 'fixtures/course'
 require 'logger'
 
 ActiveRecord::Base.logger = Logger.new("debug.log")

data/test/connections/native_firebird/connection.rb

@@ -0,0 +1,24 @@
+print "Using native Firebird\n"
+require_dependency 'fixtures/course'
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new("debug.log")
+
+db1 = 'activerecord_unittest'
+db2 = 'activerecord_unittest2'
+
+ActiveRecord::Base.establish_connection(
+  :adapter  => "firebird",
+  :host     => "localhost",
+  :username => "rails",
+  :password => "rails",
+  :database => db1
+)
+
+Course.establish_connection(
+  :adapter  => "firebird",
+  :host     => "localhost",
+  :username => "rails",
+  :password => "rails",
+  :database => db2
+)

data/test/connections/native_mysql/connection.rb

@@ -1,5 +1,5 @@
 print "Using native MySQL\n"
-require 'fixtures/course'
+require_dependency 'fixtures/course'
 require 'logger'
 
 ActiveRecord::Base.logger = Logger.new("debug.log")

data/test/connections/native_oci/connection.rb

@@ -1,5 +1,5 @@
 print "Using OCI Oracle\n"
-require 'fixtures/course'
+require_dependency 'fixtures/course'
 require 'logger'
 
 ActiveRecord::Base.logger = Logger.new STDOUT

data/test/connections/native_postgresql/connection.rb

@@ -1,5 +1,5 @@
 print "Using native PostgreSQL\n"
-require 'fixtures/course'
+require_dependency 'fixtures/course'
 require 'logger'
 
 ActiveRecord::Base.logger = Logger.new("debug.log")
@@ -9,16 +9,16 @@ db2 = 'activerecord_unittest2'
 
 ActiveRecord::Base.establish_connection(
   :adapter  => "postgresql",
-  :host     => nil, 
   :username => "postgres",
   :password => "postgres", 
-  :database => db1
+  :database => db1,
+  :min_messages => "warning"
 )
 
 Course.establish_connection(
   :adapter  => "postgresql",
-  :host     => nil, 
   :username => "postgres",
   :password => "postgres", 
-  :database => db2
-)
+  :database => db2,
+  :min_messages => "warning"
+)