activerecord 2.0.5 → 2.1.0

data/lib/active_record/version.rb

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

data/test/cases/aaa_create_tables_test.rb

@@ -0,0 +1,24 @@
+# The filename begins with "aaa" to ensure this is the first test.
+require "cases/helper"
+
+class AAACreateTablesTest < ActiveRecord::TestCase
+  self.use_transactional_fixtures = false
+
+  def test_load_schema
+    eval(File.read(SCHEMA_ROOT + "/schema.rb"))
+    if File.exists?(adapter_specific_schema_file)
+      eval(File.read(adapter_specific_schema_file))
+    end
+    assert true
+  end
+
+  def test_drop_and_create_courses_table
+    eval(File.read(SCHEMA_ROOT + "/schema2.rb"))
+    assert true
+  end
+
+  private
+  def adapter_specific_schema_file
+    SCHEMA_ROOT + '/' + ActiveRecord::Base.connection.adapter_name.downcase + '_specific_schema.rb'
+  end
+end

data/test/cases/active_schema_test_mysql.rb

@@ -0,0 +1,95 @@
+require "cases/helper"
+
+class ActiveSchemaTest < ActiveRecord::TestCase
+  def setup
+    ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do
+      alias_method :execute_without_stub, :execute
+      def execute(sql, name = nil) return sql end
+    end
+  end
+
+  def teardown
+    ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do
+      remove_method :execute
+      alias_method :execute, :execute_without_stub
+    end
+  end
+
+  def test_drop_table
+    assert_equal "DROP TABLE `people`", drop_table(:people)
+  end
+
+  if current_adapter?(:MysqlAdapter)
+    def test_create_mysql_database_with_encoding
+      assert_equal "CREATE DATABASE `matt` DEFAULT CHARACTER SET `utf8`", create_database(:matt)
+      assert_equal "CREATE DATABASE `aimonetti` DEFAULT CHARACTER SET `latin1`", create_database(:aimonetti, {:charset => 'latin1'})
+      assert_equal "CREATE DATABASE `matt_aimonetti` DEFAULT CHARACTER SET `big5` COLLATE `big5_chinese_ci`", create_database(:matt_aimonetti, {:charset => :big5, :collation => :big5_chinese_ci})
+    end
+  end
+
+  def test_add_column
+    assert_equal "ALTER TABLE `people` ADD `last_name` varchar(255)", add_column(:people, :last_name, :string)
+  end
+
+  def test_add_column_with_limit
+    assert_equal "ALTER TABLE `people` ADD `key` varchar(32)", add_column(:people, :key, :string, :limit => 32)
+  end
+
+  def test_drop_table_with_specific_database
+    assert_equal "DROP TABLE `otherdb`.`people`", drop_table('otherdb.people')
+  end
+
+  def test_add_timestamps 
+    with_real_execute do
+      begin
+        ActiveRecord::Base.connection.create_table :delete_me do |t|
+        end
+        ActiveRecord::Base.connection.add_timestamps :delete_me
+        assert column_present?('delete_me', 'updated_at', 'datetime')
+        assert column_present?('delete_me', 'created_at', 'datetime')
+      ensure
+        ActiveRecord::Base.connection.drop_table :delete_me rescue nil
+      end
+    end
+  end
+  
+  def test_remove_timestamps 
+    with_real_execute do
+      begin
+        ActiveRecord::Base.connection.create_table :delete_me do |t|
+          t.timestamps
+        end
+        ActiveRecord::Base.connection.remove_timestamps :delete_me
+        assert !column_present?('delete_me', 'updated_at', 'datetime')
+        assert !column_present?('delete_me', 'created_at', 'datetime')
+      ensure
+        ActiveRecord::Base.connection.drop_table :delete_me rescue nil
+      end
+    end
+  end
+
+  private
+    def with_real_execute
+      #we need to actually modify some data, so we make execute point to the original method
+      ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do
+        alias_method :execute_with_stub, :execute
+        alias_method :execute, :execute_without_stub
+      end
+      yield
+    ensure
+      #before finishing, we restore the alias to the mock-up method
+      ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do
+        alias_method :execute, :execute_with_stub
+      end
+    end
+
+
+    def method_missing(method_symbol, *arguments)
+      ActiveRecord::Base.connection.send(method_symbol, *arguments)
+    end
+
+    def column_present?(table_name, column_name, type)
+      results = ActiveRecord::Base.connection.select_all("SHOW FIELDS FROM #{table_name} LIKE '#{column_name}'")
+      results.first && results.first['Type'] == type
+    end
+end

data/test/cases/active_schema_test_postgresql.rb

@@ -0,0 +1,24 @@
+require 'cases/helper'
+
+class PostgresqlActiveSchemaTest < Test::Unit::TestCase
+  def setup
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.class_eval do
+      alias_method :real_execute, :execute
+      def execute(sql, name = nil) sql end
+    end
+  end
+
+  def teardown
+    ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send(:alias_method, :execute, :real_execute)
+  end
+
+  def test_create_database_with_encoding
+    assert_equal "CREATE DATABASE matt ENCODING = 'utf8'", create_database(:matt)
+    assert_equal "CREATE DATABASE aimonetti ENCODING = 'latin1'", create_database(:aimonetti, :encoding => :latin1)
+  end
+
+  private
+    def method_missing(method_symbol, *arguments)
+      ActiveRecord::Base.connection.send(method_symbol, *arguments)
+    end
+end

data/test/{adapter_test.rb → cases/adapter_test.rb}

@@ -1,20 +1,21 @@
-require 'abstract_unit'
+require "cases/helper"
 
-class AdapterTest < Test::Unit::TestCase
+class AdapterTest < ActiveRecord::TestCase
   def setup
     @connection = ActiveRecord::Base.connection
   end
 
   def test_tables
-    if @connection.respond_to?(:tables)
-      tables = @connection.tables
-      assert tables.include?("accounts")
-      assert tables.include?("authors")
-      assert tables.include?("tasks")
-      assert tables.include?("topics")
-    else
-      warn "#{@connection.class} does not respond to #tables"
-    end
+    tables = @connection.tables
+    assert tables.include?("accounts")
+    assert tables.include?("authors")
+    assert tables.include?("tasks")
+    assert tables.include?("topics")
+  end
+
+  def test_table_exists?
+    assert @connection.table_exists?("accounts")
+    assert !@connection.table_exists?("nonexistingtable")
   end
 
   def test_indexes
@@ -83,8 +84,8 @@ class AdapterTest < Test::Unit::TestCase
 
   # test resetting sequences in odd tables in postgreSQL
   if ActiveRecord::Base.connection.respond_to?(:reset_pk_sequence!)
-    require 'fixtures/movie'
-    require 'fixtures/subscriber'
+    require 'models/movie'
+    require 'models/subscriber'
 
     def test_reset_empty_table_with_custom_pk
       Movie.delete_all
@@ -117,7 +118,7 @@ class AdapterTest < Test::Unit::TestCase
     sql_inject = "1, 7 procedure help()"
     if current_adapter?(:MysqlAdapter)
       assert_equal " LIMIT 1,7", @connection.add_limit_offset!("", :limit=>sql_inject)
-      assert_equal " LIMIT 7, 1", @connection.add_limit_offset!("", :limit=> '1 ; DROP TABLE USERS', :offset=>7)
+      assert_equal " LIMIT 7, 1", @connection.add_limit_offset!("", :limit=>sql_inject, :offset=>7)
     else
       assert_equal " LIMIT 1,7", @connection.add_limit_offset!("", :limit=>sql_inject)
       assert_equal " LIMIT 1,7 OFFSET 7", @connection.add_limit_offset!("", :limit=>sql_inject, :offset=>7)

data/test/{adapter_test_sqlserver.rb → cases/adapter_test_sqlserver.rb}

@@ -1,95 +1,95 @@
-require 'abstract_unit'
-require 'fixtures/default'
-require 'fixtures/post'
-require 'fixtures/task'
-
-class SqlServerAdapterTest < Test::Unit::TestCase
-  class TableWithRealColumn < ActiveRecord::Base; end
-
-  fixtures :posts, :tasks
-
-  def setup
-    @connection = ActiveRecord::Base.connection
-  end
-
-  def teardown
-    @connection.execute("SET LANGUAGE us_english") rescue nil
-  end
-
-  def test_real_column_has_float_type
-    assert_equal :float, TableWithRealColumn.columns_hash["real_number"].type
-  end
-
-  # SQL Server 2000 has a bug where some unambiguous date formats are not 
-  # correctly identified if the session language is set to german
-  def test_date_insertion_when_language_is_german
-    @connection.execute("SET LANGUAGE deutsch")
-
-    assert_nothing_raised do
-      Task.create(:starting => Time.utc(2000, 1, 31, 5, 42, 0), :ending => Date.new(2006, 12, 31))
-    end
-  end
-
-  def test_indexes_with_descending_order
-    # Make sure we have an index with descending order
-    @connection.execute "CREATE INDEX idx_credit_limit ON accounts (credit_limit DESC)" rescue nil
-    assert_equal ["credit_limit"], @connection.indexes('accounts').first.columns
-  ensure
-    @connection.execute "DROP INDEX accounts.idx_credit_limit"
-  end
-
-  def test_execute_without_block_closes_statement
-    assert_all_statements_used_are_closed do
-      @connection.execute("SELECT 1")
-    end
-  end
-  
-  def test_execute_with_block_closes_statement
-    assert_all_statements_used_are_closed do
-      @connection.execute("SELECT 1") do |sth|
-        assert !sth.finished?, "Statement should still be alive within block"
-      end
-    end
-  end
-  
-  def test_insert_with_identity_closes_statement
-    assert_all_statements_used_are_closed do
-      @connection.insert("INSERT INTO accounts ([id], [firm_id],[credit_limit]) values (999, 1, 50)")
-    end
-  end
-  
-  def test_insert_without_identity_closes_statement
-    assert_all_statements_used_are_closed do
-      @connection.insert("INSERT INTO accounts ([firm_id],[credit_limit]) values (1, 50)")
-    end
-  end
-  
-  def test_active_closes_statement
-    assert_all_statements_used_are_closed do
-      @connection.active?
-    end
-  end 
-
-  def assert_all_statements_used_are_closed(&block)
-    existing_handles = []
-    ObjectSpace.each_object(DBI::StatementHandle) {|handle| existing_handles << handle}
-    GC.disable
-    
-    yield
-    
-    used_handles = []
-    ObjectSpace.each_object(DBI::StatementHandle) {|handle| used_handles << handle unless existing_handles.include? handle}
-         
-    assert_block "No statements were used within given block" do
-      used_handles.size > 0
-    end
-    
-    ObjectSpace.each_object(DBI::StatementHandle) do |handle|
-      assert_block "Statement should have been closed within given block" do 
-        handle.finished?
-      end      
-    end
-  ensure
-    GC.enable
-  end
-end
+require "cases/helper"
+require 'models/default'
+require 'models/post'
+require 'models/task'
+
+class SqlServerAdapterTest < ActiveRecord::TestCase
+  class TableWithRealColumn < ActiveRecord::Base; end
+
+  fixtures :posts, :tasks
+
+  def setup
+    @connection = ActiveRecord::Base.connection
+  end
+
+  def teardown
+    @connection.execute("SET LANGUAGE us_english") rescue nil
+  end
+
+  def test_real_column_has_float_type
+    assert_equal :float, TableWithRealColumn.columns_hash["real_number"].type
+  end
+
+  # SQL Server 2000 has a bug where some unambiguous date formats are not
+  # correctly identified if the session language is set to german
+  def test_date_insertion_when_language_is_german
+    @connection.execute("SET LANGUAGE deutsch")
+
+    assert_nothing_raised do
+      Task.create(:starting => Time.utc(2000, 1, 31, 5, 42, 0), :ending => Date.new(2006, 12, 31))
+    end
+  end
+
+  def test_indexes_with_descending_order
+    # Make sure we have an index with descending order
+    @connection.execute "CREATE INDEX idx_credit_limit ON accounts (credit_limit DESC)" rescue nil
+    assert_equal ["credit_limit"], @connection.indexes('accounts').first.columns
+  ensure
+    @connection.execute "DROP INDEX accounts.idx_credit_limit"
+  end
+
+  def test_execute_without_block_closes_statement
+    assert_all_statements_used_are_closed do
+      @connection.execute("SELECT 1")
+    end
+  end
+
+  def test_execute_with_block_closes_statement
+    assert_all_statements_used_are_closed do
+      @connection.execute("SELECT 1") do |sth|
+        assert !sth.finished?, "Statement should still be alive within block"
+      end
+    end
+  end
+
+  def test_insert_with_identity_closes_statement
+    assert_all_statements_used_are_closed do
+      @connection.insert("INSERT INTO accounts ([id], [firm_id],[credit_limit]) values (999, 1, 50)")
+    end
+  end
+
+  def test_insert_without_identity_closes_statement
+    assert_all_statements_used_are_closed do
+      @connection.insert("INSERT INTO accounts ([firm_id],[credit_limit]) values (1, 50)")
+    end
+  end
+
+  def test_active_closes_statement
+    assert_all_statements_used_are_closed do
+      @connection.active?
+    end
+  end
+
+  def assert_all_statements_used_are_closed(&block)
+    existing_handles = []
+    ObjectSpace.each_object(DBI::StatementHandle) {|handle| existing_handles << handle}
+    GC.disable
+
+    yield
+
+    used_handles = []
+    ObjectSpace.each_object(DBI::StatementHandle) {|handle| used_handles << handle unless existing_handles.include? handle}
+
+    assert_block "No statements were used within given block" do
+      used_handles.size > 0
+    end
+
+    ObjectSpace.each_object(DBI::StatementHandle) do |handle|
+      assert_block "Statement should have been closed within given block" do
+        handle.finished?
+      end
+    end
+  ensure
+    GC.enable
+  end
+end

data/test/{aggregations_test.rb → cases/aggregations_test.rb}

@@ -1,7 +1,7 @@
-require 'abstract_unit'
-require 'fixtures/customer'
+require "cases/helper"
+require 'models/customer'
 
-class AggregationsTest < Test::Unit::TestCase
+class AggregationsTest < ActiveRecord::TestCase
   fixtures :customers
 
   def test_find_single_value_object
@@ -9,36 +9,36 @@ class AggregationsTest < Test::Unit::TestCase
     assert_kind_of Money, customers(:david).balance
     assert_equal 300, customers(:david).balance.exchange_to("DKK").amount
   end
-  
+
   def test_find_multiple_value_object
     assert_equal customers(:david).address_street, customers(:david).address.street
     assert(
       customers(:david).address.close_to?(Address.new("Different Street", customers(:david).address_city, customers(:david).address_country))
     )
   end
-  
+
   def test_change_single_value_object
     customers(:david).balance = Money.new(100)
     customers(:david).save
     assert_equal 100, customers(:david).reload.balance.amount
   end
-  
+
   def test_immutable_value_objects
     customers(:david).balance = Money.new(100)
-    assert_raises(TypeError) {  customers(:david).balance.instance_eval { @amount = 20 } }
-  end  
-  
+    assert_raise(ActiveSupport::FrozenObjectError) { customers(:david).balance.instance_eval { @amount = 20 } }
+  end
+
   def test_inferred_mapping
     assert_equal "35.544623640962634", customers(:david).gps_location.latitude
     assert_equal "-105.9309951055148", customers(:david).gps_location.longitude
-    
+
     customers(:david).gps_location = GpsLocation.new("39x-110")
 
     assert_equal "39", customers(:david).gps_location.latitude
     assert_equal "-110", customers(:david).gps_location.longitude
-    
+
     customers(:david).save
-    
+
     customers(:david).reload
 
     assert_equal "39", customers(:david).gps_location.latitude
@@ -53,7 +53,7 @@ class AggregationsTest < Test::Unit::TestCase
     customers(:david).reload
     assert_equal '24x113', customers(:david)['gps_location']
 
-    assert_equal GpsLocation.new('24x113'), customers(:david).gps_location 
+    assert_equal GpsLocation.new('24x113'), customers(:david).gps_location
   end
 
   def test_gps_equality
@@ -63,34 +63,34 @@ class AggregationsTest < Test::Unit::TestCase
   def test_gps_inequality
     assert GpsLocation.new('39x110') != GpsLocation.new('39x111')
   end
-  
+
   def test_allow_nil_gps_is_nil
     assert_equal nil, customers(:zaphod).gps_location
   end
-  
+
   def test_allow_nil_gps_set_to_nil
     customers(:david).gps_location = nil
     customers(:david).save
     customers(:david).reload
     assert_equal nil, customers(:david).gps_location
   end
-  
+
   def test_allow_nil_set_address_attributes_to_nil
     customers(:zaphod).address = nil
     assert_equal nil, customers(:zaphod).attributes[:address_street]
     assert_equal nil, customers(:zaphod).attributes[:address_city]
     assert_equal nil, customers(:zaphod).attributes[:address_country]
   end
-  
+
   def test_allow_nil_address_set_to_nil
     customers(:zaphod).address = nil
     customers(:zaphod).save
     customers(:zaphod).reload
     assert_equal nil, customers(:zaphod).address
   end
-  
+
   def test_nil_raises_error_when_allow_nil_is_false
-    assert_raises(NoMethodError) { customers(:david).balance = nil }
+    assert_raise(NoMethodError) { customers(:david).balance = nil }
   end
 
   def test_allow_nil_address_loaded_when_only_some_attributes_are_nil
@@ -109,7 +109,7 @@ class AggregationsTest < Test::Unit::TestCase
   end
 end
 
-class OverridingAggregationsTest < Test::Unit::TestCase
+class OverridingAggregationsTest < ActiveRecord::TestCase
   class Name; end
   class DifferentName; end