activerecord 1.13.2 → 1.14.0

data/lib/active_record/version.rb

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

data/rakefile

@@ -27,7 +27,7 @@ task :default => [ :test_mysql, :test_sqlite, :test_postgresql ]
 
 # Run the unit tests
 
-for adapter in %w( mysql postgresql sqlite sqlite3 firebird sqlserver sqlserver_odbc db2 oci )
+for adapter in %w( mysql postgresql sqlite sqlite3 firebird sqlserver sqlserver_odbc db2 oracle sybase openbase )
   Rake::TestTask.new("test_#{adapter}") { |t|
     t.libs << "test" << "test/connections/native_#{adapter}"
     t.pattern = "test/*_test{,_#{adapter}}.rb"
@@ -59,7 +59,7 @@ 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')} )
+  %x( psql activerecord_unittest2 -f #{File.join(SCHEMA_PATH, 'postgresql2.sql')} )
 end
 
 desc 'Drop the PostgreSQL test databases'
@@ -76,7 +76,7 @@ task :rebuild_postgresql_databases => [:drop_postgresql_databases, :build_postgr
 Rake::RDocTask.new { |rdoc|
   rdoc.rdoc_dir = 'doc'
   rdoc.title    = "Active Record -- Object-relation mapping put on rails"
-  rdoc.options << '--line-numbers --inline-source --accessor cattr_accessor=object'
+  rdoc.options << '--line-numbers' << '--inline-source' << '-A cattr_accessor=object'
   rdoc.template = "#{ENV['template']}.rb" if ENV['template']
   rdoc.rdoc_files.include('README', 'RUNNING_UNIT_TESTS', 'CHANGELOG')
   rdoc.rdoc_files.include('lib/**/*.rb')
@@ -106,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.5' + PKG_BUILD)
+  s.add_dependency('activesupport', '= 1.3.0' + PKG_BUILD)
 
   s.files.delete "test/fixtures/fixture_database.sqlite"
   s.files.delete "test/fixtures/fixture_database_2.sqlite"

data/test/aaa_create_tables_test.rb

@@ -1,7 +1,9 @@
 # The filename begins with "aaa" to ensure this is the first test.
 require 'abstract_unit'
 
-class CreateTablesTest < Test::Unit::TestCase
+class AAACreateTablesTest < Test::Unit::TestCase
+  self.use_transactional_fixtures = false
+
   def setup
     @base_path = "#{File.dirname(__FILE__)}/fixtures/db_definitions"
   end
@@ -10,6 +12,11 @@ class CreateTablesTest < Test::Unit::TestCase
     recreate ActiveRecord::Base
     assert true
   end
+
+  def test_load_schema
+    eval(File.read("#{File.dirname(__FILE__)}/fixtures/db_definitions/schema.rb"))
+    assert true
+  end
   
   def test_drop_and_create_courses_table
     recreate Course, '2'
@@ -25,11 +32,23 @@ class CreateTablesTest < Test::Unit::TestCase
     end
 
     def execute_sql_file(path, connection)
-      File.read(path).split(';').each_with_index do |sql, i|
-        begin
-          connection.execute("\n\n-- statement ##{i}\n#{sql}\n") unless sql.blank?
-        rescue ActiveRecord::StatementInvalid
-          #$stderr.puts "warning: #{$!}"
+      # OpenBase has a different format for sql files
+      if current_adapter?(:OpenBaseAdapter) then
+          File.read(path).split("go").each_with_index do |sql, i|
+            begin
+              # OpenBase does not support comments embedded in sql
+              connection.execute(sql,"SQL statement ##{i}") unless sql.blank?
+            rescue ActiveRecord::StatementInvalid
+              #$stderr.puts "warning: #{$!}"
+            end
+          end
+      else
+        File.read(path).split(';').each_with_index do |sql, i|
+          begin
+            connection.execute("\n\n-- statement ##{i}\n#{sql}\n") unless sql.blank?
+          rescue ActiveRecord::StatementInvalid
+            #$stderr.puts "warning: #{$!}"
+          end
         end
       end
     end

data/test/abstract_unit.rb

@@ -16,7 +16,36 @@ class Test::Unit::TestCase #:nodoc:
   self.use_transactional_fixtures = (ENV['AR_NO_TX_FIXTURES'] != "yes")
 
   def create_fixtures(*table_names, &block)
-    Fixtures.create_fixtures(File.dirname(__FILE__) + "/fixtures/", table_names, &block)
+    Fixtures.create_fixtures(File.dirname(__FILE__) + "/fixtures/", table_names, {}, &block)
+  end
+  
+  def assert_date_from_db(expected, actual, message = nil)
+    # SQL Server doesn't have a separate column type just for dates, 
+    # so the time is in the string and incorrectly formatted
+    if current_adapter?(:SQLServerAdapter)
+      assert_equal expected.strftime("%Y/%m/%d 00:00:00"), actual.strftime("%Y/%m/%d 00:00:00")
+    elsif current_adapter?(:SybaseAdapter)
+      assert_equal expected.to_s, actual.to_date.to_s, message
+    else
+      assert_equal expected.to_s, actual.to_s, message
+    end
+  end
+
+  def assert_queries(num = 1)
+    ActiveRecord::Base.connection.class.class_eval do
+      self.query_count = 0
+      alias_method :execute, :execute_with_query_counting
+    end
+    yield
+  ensure
+    ActiveRecord::Base.connection.class.class_eval do
+      alias_method :execute, :execute_without_query_counting
+    end
+    assert_equal num, ActiveRecord::Base.connection.query_count, "#{ActiveRecord::Base.connection.query_count} instead of #{num} queries were executed."
+  end
+
+  def assert_no_queries(&block)
+    assert_queries(0, &block)
   end
 end
 
@@ -25,5 +54,14 @@ def current_adapter?(type)
     ActiveRecord::Base.connection.instance_of?(ActiveRecord::ConnectionAdapters.const_get(type))
 end
 
+ActiveRecord::Base.connection.class.class_eval do
+  cattr_accessor :query_count
+  alias_method :execute_without_query_counting, :execute
+  def execute_with_query_counting(sql, name = nil)
+    self.query_count += 1
+    execute_without_query_counting(sql, name)
+  end
+end
+
 #ActiveRecord::Base.logger = Logger.new(STDOUT)
 #ActiveRecord::Base.colorize_logging = false

data/test/adapter_test.rb

@@ -18,14 +18,18 @@ class AdapterTest < Test::Unit::TestCase
   end
 
   def test_indexes
+    idx_name = "accounts_idx"
+      
     if @connection.respond_to?(:indexes)
       indexes = @connection.indexes("accounts")
       assert indexes.empty?
 
-      @connection.add_index :accounts, :firm_id
+      @connection.add_index :accounts, :firm_id, :name => idx_name
       indexes = @connection.indexes("accounts")
       assert_equal "accounts", indexes.first.table
-      assert_equal "accounts_firm_id_index", indexes.first.name
+      # OpenBase does not have the concept of a named index
+      # Indexes are merely properties of columns.
+      assert_equal idx_name, indexes.first.name unless current_adapter?(:OpenBaseAdapter)
       assert !indexes.first.unique
       assert_equal ["firm_id"], indexes.first.columns
     else
@@ -33,7 +37,29 @@ class AdapterTest < Test::Unit::TestCase
     end
 
   ensure
-    @connection.remove_index :accounts, :firm_id rescue nil
+    @connection.remove_index(:accounts, :name => idx_name) rescue nil
+  end
+  
+  def test_current_database
+    if @connection.respond_to?(:current_database)
+      assert_equal "activerecord_unittest", @connection.current_database
+    end
+  end
+
+  def test_table_alias
+    def @connection.test_table_alias_length() 10; end
+    class << @connection
+      alias_method :old_table_alias_length, :table_alias_length
+      alias_method :table_alias_length,     :test_table_alias_length
+    end
+      
+    assert_equal 'posts',      @connection.table_alias_for('posts')
+    assert_equal 'posts_comm', @connection.table_alias_for('posts_comments')
+    assert_equal 'dbo_posts',  @connection.table_alias_for('dbo.posts')
+    
+    class << @connection
+      alias_method :table_alias_length, :old_table_alias_length
+    end
   end
 
   # test resetting sequences in odd tables in postgreSQL
@@ -52,7 +78,8 @@ class AdapterTest < Test::Unit::TestCase
 
       sub = Subscriber.new(:name => 'robert drake')
       sub.id = 'bob drake'
-      assert sub.save!
+      assert_nothing_raised { sub.save! }
     end
   end
+
 end

data/test/associations_cascaded_eager_loading_test.rb

@@ -0,0 +1,106 @@
+require 'abstract_unit'
+require 'active_record/acts/list'
+require 'fixtures/post'
+require 'fixtures/comment'
+require 'fixtures/author'
+require 'fixtures/category'
+require 'fixtures/categorization'
+require 'fixtures/mixin'
+require 'fixtures/company'
+require 'fixtures/topic'
+require 'fixtures/reply'
+
+class CascadedEagerLoadingTest < Test::Unit::TestCase
+  fixtures :authors, :mixins, :companies, :posts, :categorizations, :topics
+
+  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 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}
+  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 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 1, authors[0].categorizations.size
+    assert_equal 1, authors[1].categorizations.size
+  end
+
+  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 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}
+  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 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.find(:all, :include=>{:posts=>:comments}, :conditions=>"authors.id=1", :order=>"authors.id")
+    assert_equal 1, authors.size
+    assert_equal 5, authors[0].posts.size
+  end
+
+  def test_eager_association_loading_with_acts_as_tree
+    roots = TreeMixin.find(:all, :include=>"children", :conditions=>"mixins.parent_id IS NULL", :order=>"mixins.id")
+    assert_equal [mixins(:tree_1), mixins(:tree2_1), mixins(:tree3_1)], roots
+    assert_no_queries do
+      assert_equal 2, roots[0].children.size
+      assert_equal 0, roots[1].children.size
+      assert_equal 0, roots[2].children.size
+    end
+  end
+
+  def test_eager_association_loading_with_cascaded_three_levels_by_ping_pong
+    firms = Firm.find(:all, :include=>{:account=>{:firm=>:account}}, :order=>"companies.id")
+    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.find(:all, :include => :replies, :order => 'topics.id')
+    assert_equal [topics(:first), topics(:second)], topics
+    assert_no_queries do
+      assert_equal 1, topics[0].replies.size
+      assert_equal 0, topics[1].replies.size
+    end
+  end
+
+  def test_eager_association_loading_with_belongs_to_sti
+    replies = Reply.find(:all, :include => :topic, :order => 'topics.id')
+    assert_equal [topics(:second)], replies
+    assert_equal topics(:first), assert_no_queries { replies.first.topic }
+  end
+
+  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
+  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')
+    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
+end

data/test/associations_go_eager_test.rb

@@ -4,10 +4,12 @@ require 'fixtures/comment'
 require 'fixtures/author'
 require 'fixtures/category'
 require 'fixtures/company'
+require 'fixtures/person'
+require 'fixtures/reader'
 
 class EagerAssociationTest < Test::Unit::TestCase
   fixtures :posts, :comments, :authors, :categories, :categories_posts,
-            :companies, :accounts
+            :companies, :accounts, :tags, :people, :readers
 
   def test_loading_with_one_association
     posts = Post.find(:all, :include => :comments)
@@ -90,17 +92,26 @@ class EagerAssociationTest < Test::Unit::TestCase
   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)
+    posts = Post.find(:all, :include => [:author, :very_special_comment], :limit => 1, :order => 'posts.id')
     assert_equal 1, posts.length
-    assert_equal [4], posts.collect { |p| p.id }
+    assert_equal [1], posts.collect { |p| p.id }
   end
   
   def test_eager_association_loading_with_belongs_to_and_limit_and_offset_and_multiple_associations
-    posts = Post.find(:all, :include => [:author, :very_special_comment], :limit => 1, :offset => 1)
-    assert_equal 0, posts.length
-    assert_equal [], posts
+    posts = Post.find(:all, :include => [:author, :very_special_comment], :limit => 1, :offset => 1, :order => 'posts.id')
+    assert_equal 1, posts.length
+    assert_equal [2], posts.collect { |p| p.id }
   end
   
+  def test_eager_with_has_many_through
+    posts_with_comments = people(:michael).posts.find(:all, :include => :comments )
+    posts_with_author = people(:michael).posts.find(:all, :include => :author )
+    posts_with_comments_and_author = people(:michael).posts.find(:all, :include => [ :comments, :author ])
+    assert_equal 2, posts_with_comments.inject(0) { |sum, post| sum += post.comments.size }
+    assert_equal authors(:david), assert_no_queries { posts_with_author.first.author }
+    assert_equal authors(:david), assert_no_queries { posts_with_comments_and_author.first.author }
+  end
+
   def test_eager_with_has_many_and_limit
     posts = Post.find(:all, :order => 'posts.id asc', :include => [ :author, :comments ], :limit => 2)
     assert_equal 2, posts.size
@@ -120,9 +131,11 @@ class EagerAssociationTest < Test::Unit::TestCase
   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
+    posts = Post.find(:all, :include => [ :author, :comments ], :limit => 2, :conditions => [ "authors.name = ?", 'David' ])
+    assert_equal 2, posts.size
+    
+    count = Post.count(:include => [ :author, :comments ], :limit => 2, :conditions => [ "authors.name = ?", 'David' ])
+    assert_equal count, posts.size
   end
 
   def test_eager_with_has_many_and_limit_with_no_results
@@ -141,13 +154,19 @@ class EagerAssociationTest < Test::Unit::TestCase
   end
 
   def test_eager_with_has_many_and_limit_and_conditions_on_the_eagers
-    assert_raises(ArgumentError) do
-      posts = authors(:david).posts.find(:all, 
-        :include    => :comments, 
-        :conditions => "comments.body like 'Normal%' OR comments.#{QUOTED_TYPE}= 'SpecialComment'",
-        :limit      => 2
-      )
-    end
+    posts = authors(:david).posts.find(:all, 
+      :include    => :comments, 
+      :conditions => "comments.body like 'Normal%' OR comments.#{QUOTED_TYPE}= 'SpecialComment'",
+      :limit      => 2
+    )
+    assert_equal 2, posts.size
+    
+    count = Post.count(
+      :include    => [ :comments, :author ], 
+      :conditions => "authors.name = 'David' AND (comments.body like 'Normal%' OR comments.#{QUOTED_TYPE}= 'SpecialComment')",
+      :limit      => 2
+    )
+    assert_equal count, posts.size
   end
 
   def test_eager_association_loading_with_habtm
@@ -205,7 +224,57 @@ class EagerAssociationTest < Test::Unit::TestCase
       post = Post.find(6, :include=>[ :monkeys, :elephants ])
     }
   end
+  
+  def find_all_ordered(className, include=nil)
+    className.find(:all, :order=>"#{className.table_name}.#{className.primary_key}", :include=>include)
+  end
 
+  def test_eager_with_multiple_associations_with_same_table_has_many_and_habtm
+    # Eager includes of has many and habtm associations aren't necessarily sorted in the same way
+    def assert_equal_after_sort(item1, item2, item3 = nil)
+      assert_equal(item1.sort{|a,b| a.id <=> b.id}, item2.sort{|a,b| a.id <=> b.id})
+      assert_equal(item3.sort{|a,b| a.id <=> b.id}, item2.sort{|a,b| a.id <=> b.id}) if item3
+    end
+    # Test regular association, association with conditions, association with
+    # STI, and association with conditions assured not to be true
+    post_types = [:posts, :hello_posts, :special_posts, :nonexistent_posts]
+    # test both has_many and has_and_belongs_to_many
+    [Author, Category].each do |className|
+      d1 = find_all_ordered(className)
+      # test including all post types at once
+      d2 = find_all_ordered(className, post_types) 
+      d1.each_index do |i| 
+        assert_equal(d1[i], d2[i])
+        assert_equal_after_sort(d1[i].posts, d2[i].posts)
+        post_types[1..-1].each do |post_type|
+          # test including post_types together
+          d3 = find_all_ordered(className, [:posts, post_type])
+          assert_equal(d1[i], d3[i])
+          assert_equal_after_sort(d1[i].posts, d3[i].posts)
+          assert_equal_after_sort(d1[i].send(post_type), d2[i].send(post_type), d3[i].send(post_type))
+        end
+      end
+    end
+  end
+  
+  def test_eager_with_multiple_associations_with_same_table_has_one
+    d1 = find_all_ordered(Firm)
+    d2 = find_all_ordered(Firm, :account)
+    d1.each_index do |i| 
+      assert_equal(d1[i], d2[i])
+      assert_equal(d1[i].account, d2[i].account)
+    end
+  end
+  
+  def test_eager_with_multiple_associations_with_same_table_belongs_to
+    firm_types = [:firm, :firm_with_basic_id, :firm_with_other_name, :firm_with_condition]
+    d1 = find_all_ordered(Client)
+    d2 = find_all_ordered(Client, firm_types)
+    d1.each_index do |i| 
+      assert_equal(d1[i], d2[i])
+      firm_types.each { |type| assert_equal(d1[i].send(type), d2[i].send(type)) }
+    end
+  end
   def test_eager_with_valid_association_as_string_not_symbol
     assert_nothing_raised { Post.find(:all, :include => 'comments') }
   end