activerecord 1.14.4 → 1.15.0

data/test/calculations_test.rb

@@ -8,19 +8,29 @@ class CalculationsTest < Test::Unit::TestCase
   fixtures :companies, :accounts, :topics
 
   def test_should_sum_field
-    assert_equal 265, Account.sum(:credit_limit)
+    assert_equal 318, Account.sum(:credit_limit)
   end
 
   def test_should_average_field
     value = Account.average(:credit_limit)
-    assert_equal 53, value
     assert_kind_of Float, value
+    assert_in_delta 53.0, value, 0.001
   end
 
   def test_should_get_maximum_of_field
     assert_equal 60, Account.maximum(:credit_limit)
   end
 
+  def test_should_get_maximum_of_field_with_include
+    assert_equal 50, Account.maximum(:credit_limit, :include => :firm, :conditions => "companies.name != 'Summit'")
+  end
+
+  def test_should_get_maximum_of_field_with_scoped_include
+    Account.with_scope :find => { :include => :firm, :conditions => "companies.name != 'Summit'" } do
+      assert_equal 50, Account.maximum(:credit_limit)
+    end
+  end
+
   def test_should_get_minimum_of_field
     assert_equal 50, Account.minimum(:credit_limit)
   end
@@ -39,13 +49,13 @@ class CalculationsTest < Test::Unit::TestCase
 
   def test_should_order_by_grouped_field
     c = Account.sum(:credit_limit, :group => :firm_id, :order => "firm_id")
-    assert_equal [1, 2, 6], c.keys.compact
+    assert_equal [1, 2, 6, 9], c.keys.compact
   end
 
   def test_should_order_by_calculation
     c = Account.sum(:credit_limit, :group => :firm_id, :order => "sum_credit_limit desc, firm_id")
-    assert_equal [105, 60, 50, 50], c.keys.collect { |k| c[k] }
-    assert_equal [6, 2, 1], c.keys.compact
+    assert_equal [105, 60, 53, 50, 50], c.keys.collect { |k| c[k] }
+    assert_equal [6, 2, 9, 1], c.keys.compact
   end
 
   def test_should_limit_calculation
@@ -104,8 +114,8 @@ class CalculationsTest < Test::Unit::TestCase
   end
   
   def test_should_calculate_with_invalid_field
-    assert_equal 5, Account.calculate(:count, '*')
-    assert_equal 5, Account.calculate(:count, :all)
+    assert_equal 6, Account.calculate(:count, '*')
+    assert_equal 6, Account.calculate(:count, :all)
   end
   
   def test_should_calculate_grouped_with_invalid_field
@@ -121,9 +131,17 @@ class CalculationsTest < Test::Unit::TestCase
     assert_equal 2, c[companies(:rails_core)]
     assert_equal 1, c[companies(:first_client)]
   end
+  
+  def test_should_not_modify_options_when_using_includes
+    options = {:conditions => 'companies.id > 1', :include => :firm}
+    options_copy = options.dup
+    
+    Account.count(:all, options)
+    assert_equal options_copy, options
+  end
 
   def test_should_calculate_grouped_by_function
-    c = Company.count(:all, :group => 'UPPER(type)')
+    c = Company.count(:all, :group => "UPPER(#{QUOTED_TYPE})")
     assert_equal 2, c[nil]
     assert_equal 1, c['DEPENDENTFIRM']
     assert_equal 3, c['CLIENT']
@@ -131,12 +149,16 @@ class CalculationsTest < Test::Unit::TestCase
   end
   
   def test_should_calculate_grouped_by_function_with_table_alias
-    c = Company.count(:all, :group => 'UPPER(companies.type)')
+    c = Company.count(:all, :group => "UPPER(companies.#{QUOTED_TYPE})")
     assert_equal 2, c[nil]
     assert_equal 1, c['DEPENDENTFIRM']
     assert_equal 3, c['CLIENT']
     assert_equal 2, c['FIRM']
   end
+  
+  def test_should_not_overshadow_enumerable_sum
+    assert_equal 6, [1, 2, 3].sum(&:abs)
+  end
 
   def test_should_sum_scoped_field
     assert_equal 15, companies(:rails_core).companies.sum(:id)
@@ -174,8 +196,24 @@ class CalculationsTest < Test::Unit::TestCase
       Company.send(:validate_calculation_options, :count, :include => true)
     end
     
-    assert_raises(ArgumentError) { Company.send(:validate_calculation_options, :sum,   :include => :posts) }
     assert_raises(ArgumentError) { Company.send(:validate_calculation_options, :sum,   :foo => :bar) }
     assert_raises(ArgumentError) { Company.send(:validate_calculation_options, :count, :foo => :bar) }
   end
+
+  def test_should_count_selected_field_with_include
+    assert_equal 6, Account.count(:distinct => true, :include => :firm)
+    assert_equal 4, Account.count(:distinct => true, :include => :firm, :select => :credit_limit)
+  end
+
+  def test_deprecated_count_with_string_parameters
+    assert_deprecated('count') { Account.count('credit_limit > 50') }
+  end
+
+  def test_count_with_no_parameters_isnt_deprecated
+    assert_not_deprecated { Account.count }
+  end
+
+  def test_count_with_too_many_parameters_raises
+    assert_raise(ArgumentError) { Account.count(1, 2, 3) }
+  end
 end

data/test/callbacks_test.rb

@@ -109,6 +109,13 @@ class ImmutableMethodDeveloper < ActiveRecord::Base
   end
 end
 
+class CallbackCancellationDeveloper < ActiveRecord::Base
+  set_table_name 'developers'
+  def before_create
+    false
+  end
+end
+
 class CallbacksTest < Test::Unit::TestCase
   fixtures :developers
 
@@ -334,6 +341,12 @@ class CallbacksTest < Test::Unit::TestCase
     assert_raises(ActiveRecord::RecordInvalid) { david.save! }
   end
 
+  def test_before_create_returning_false
+    someone = CallbackCancellationDeveloper.new
+    assert someone.valid?
+    assert !someone.save
+  end
+
   def test_before_destroy_returning_false
     david = ImmutableDeveloper.find(1)
     assert !david.destroy

data/test/connection_test_firebird.rb

@@ -0,0 +1,8 @@
+require 'abstract_unit'
+
+class ConnectionTest < Test::Unit::TestCase
+  def test_charset_properly_set
+    fb_conn = ActiveRecord::Base.connection.instance_variable_get(:@connection)
+    assert_equal 'UTF8', fb_conn.database.character_set
+  end
+end

data/test/connections/native_db2/connection.rb

@@ -4,21 +4,22 @@ require 'logger'
 
 ActiveRecord::Base.logger = Logger.new("debug.log")
 
-db1 = 'arunit'
-db2 = 'arunit2'
+ActiveRecord::Base.configurations = {
+  'arunit' => {
+    :adapter => 'db2',
+    :host => 'localhost',
+    :username => 'arunit',
+    :password => 'arunit',
+    :database => 'arunit'
+  },
+  'arunit2' => {
+    :adapter => 'db2',
+    :host => 'localhost',
+    :username => 'arunit',
+    :password => 'arunit',
+    :database => 'arunit2'
+  }
+}
 
-ActiveRecord::Base.establish_connection(
-  :adapter  => "db2",
-  :host     => "localhost",
-  :username => "arunit",
-  :password => "arunit",
-  :database => db1
-)
-
-Course.establish_connection(
-  :adapter  => "db2",
-  :host     => "localhost",
-  :username => "arunit2",
-  :password => "arunit2",
-  :database => db2
-)
+ActiveRecord::Base.establish_connection 'arunit'
+Course.establish_connection 'arunit2'

data/test/connections/native_firebird/connection.rb

@@ -4,21 +4,23 @@ require 'logger'
 
 ActiveRecord::Base.logger = Logger.new("debug.log")
 
-db1 = 'activerecord_unittest'
-db2 = 'activerecord_unittest2'
+ActiveRecord::Base.configurations = {
+  'arunit' => {
+    :adapter => 'firebird',
+    :host => 'localhost',
+    :username => 'rails',
+    :password => 'rails',
+    :database => 'activerecord_unittest',
+    :charset => 'UTF8'
+  },
+  'arunit2' => {
+    :adapter => 'firebird',
+    :host => 'localhost',
+    :username => 'rails',
+    :password => 'rails',
+    :database => '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
-)
+ActiveRecord::Base.establish_connection 'arunit'
+Course.establish_connection 'arunit2'

data/test/connections/native_frontbase/connection.rb

@@ -0,0 +1,27 @@
+puts 'Using native Frontbase'
+require_dependency 'fixtures/course'
+require 'logger'
+
+ActiveRecord::Base.logger = Logger.new("debug.log")
+
+ActiveRecord::Base.configurations = {
+  'arunit' => {
+    :adapter => 'frontbase',
+    :host => 'localhost',
+    :username => 'rails',
+    :password => '',
+    :database => 'activerecord_unittest',
+    :session_name => "unittest-#{$$}"
+  },
+  'arunit2' => {
+    :adapter => 'frontbase',
+    :host => 'localhost',
+    :username => 'rails',
+    :password => '',
+    :database => 'activerecord_unittest2',
+    :session_name => "unittest-#{$$}"
+  }
+}
+
+ActiveRecord::Base.establish_connection 'arunit'
+Course.establish_connection 'arunit2'

data/test/connections/native_mysql/connection.rb

@@ -2,20 +2,23 @@ print "Using native MySQL\n"
 require_dependency 'fixtures/course'
 require 'logger'
 
-ActiveRecord::Base.logger = Logger.new("debug.log")
+RAILS_DEFAULT_LOGGER = Logger.new('debug.log')
+RAILS_DEFAULT_LOGGER.level = Logger::DEBUG
+ActiveRecord::Base.logger = RAILS_DEFAULT_LOGGER
 
-db1 = 'activerecord_unittest'
-db2 = 'activerecord_unittest2'
+ActiveRecord::Base.configurations = {
+  'arunit' => {
+    :adapter  => 'mysql',
+    :username => 'rails',
+    :encoding => 'utf8',
+    :database => 'activerecord_unittest',
+  },
+  'arunit2' => {
+    :adapter  => 'mysql',
+    :username => 'rails',
+    :database => 'activerecord_unittest2'
+  }
+}
 
-ActiveRecord::Base.establish_connection(
-  :adapter  => "mysql",
-  :username => "rails",
-  :encoding => "utf8",
-  :database => db1
-)
-
-Course.establish_connection(
-  :adapter  => "mysql",
-  :username => "rails",
-  :database => db2
-)
+ActiveRecord::Base.establish_connection 'arunit'
+Course.establish_connection 'arunit2'

data/test/connections/native_openbase/connection.rb

@@ -4,19 +4,18 @@ require 'logger'
 
 ActiveRecord::Base.logger = Logger.new("debug.log")
 
-db1 = 'activerecord_unittest'
-db2 = 'activerecord_unittest2'
+ActiveRecord::Base.configurations = {
+  'arunit' => {
+    :adapter  => 'openbase',
+    :username => 'admin',
+    :database => 'activerecord_unittest',
+  },
+  'arunit2' => {
+    :adapter  => 'openbase',
+    :username => 'admin',
+    :database => 'activerecord_unittest2'
+  }
+}
 
-ActiveRecord::Base.establish_connection(
-  :adapter  => "openbase",
-  :username => "admin",
-  :password => "", 
-  :database => db1
-)
-
-Course.establish_connection(
-  :adapter  => "openbase",
-  :username => "admin",
-  :password => "", 
-  :database => db2
-)
+ActiveRecord::Base.establish_connection 'arunit'
+Course.establish_connection 'arunit2'

data/test/connections/native_oracle/connection.rb

@@ -8,16 +8,20 @@ ActiveRecord::Base.logger.level = Logger::WARN
 # Set these to your database connection strings
 db = ENV['ARUNIT_DB'] || 'activerecord_unittest'
 
-ActiveRecord::Base.establish_connection(
-  :adapter  => 'oracle',
-  :username => 'arunit',
-  :password => 'arunit',
-  :database => db
-)
+ActiveRecord::Base.configurations = {
+  'arunit' => {
+    :adapter  => 'oracle',
+    :username => 'arunit',
+    :password => 'arunit',
+    :database => db,
+  },
+  'arunit2' => {
+    :adapter  => 'oracle',
+    :username => 'arunit2',
+    :password => 'arunit2',
+    :database => db
+  }
+}
 
-Course.establish_connection(
-  :adapter  => 'oracle',
-  :username => 'arunit2',
-  :password => 'arunit2',
-  :database => db
-)
+ActiveRecord::Base.establish_connection 'arunit'
+Course.establish_connection 'arunit2'

data/test/connections/native_postgresql/connection.rb

@@ -4,21 +4,20 @@ require 'logger'
 
 ActiveRecord::Base.logger = Logger.new("debug.log")
 
-db1 = 'activerecord_unittest'
-db2 = 'activerecord_unittest2'
+ActiveRecord::Base.configurations = {
+  'arunit' => {
+    :adapter  => 'postgresql',
+    :username => 'postgres',
+    :database => 'activerecord_unittest',
+    :min_messages => 'warning'
+  },
+  'arunit2' => {
+    :adapter  => 'postgresql',
+    :username => 'postgres',
+    :database => 'activerecord_unittest2',
+    :min_messages => 'warning'
+  }
+}
 
-ActiveRecord::Base.establish_connection(
-  :adapter  => "postgresql",
-  :username => "postgres",
-  :password => "postgres", 
-  :database => db1,
-  :min_messages => "warning"
-)
-
-Course.establish_connection(
-  :adapter  => "postgresql",
-  :username => "postgres",
-  :password => "postgres", 
-  :database => db2,
-  :min_messages => "warning"
-)
+ActiveRecord::Base.establish_connection 'arunit'
+Course.establish_connection 'arunit2'

data/test/connections/native_sqlite/connection.rb

@@ -11,14 +11,13 @@ sqlite_test_db  = "#{BASE_DIR}/fixture_database.sqlite"
 sqlite_test_db2 = "#{BASE_DIR}/fixture_database_2.sqlite"
 
 def make_connection(clazz, db_file, db_definitions_file)
+  ActiveRecord::Base.configurations = { clazz.name => { :adapter => 'sqlite', :database => db_file } }
   unless File.exist?(db_file)
     puts "SQLite database not found at #{db_file}. Rebuilding it."
     sqlite_command = %Q{sqlite #{db_file} "create table a (a integer); drop table a;"}
     puts "Executing '#{sqlite_command}'"
     raise SqliteError.new("Seems that there is no sqlite executable available") unless system(sqlite_command)
-    clazz.establish_connection(
-        :adapter => "sqlite",
-        :database  => db_file)
+    clazz.establish_connection(clazz.name)
     script = File.read("#{BASE_DIR}/db_definitions/#{db_definitions_file}")
     # SQLite-Ruby has problems with semi-colon separated commands, so split and execute one at a time
     script.split(';').each do
@@ -26,9 +25,7 @@ def make_connection(clazz, db_file, db_definitions_file)
       clazz.connection.execute(command) unless command.strip.empty?
     end
   else
-    clazz.establish_connection(
-        :adapter => "sqlite",
-        :database  => db_file)
+    clazz.establish_connection(clazz.name)
   end
 end
 

data/test/connections/native_sqlite3/connection.rb

@@ -11,14 +11,13 @@ sqlite_test_db  = "#{BASE_DIR}/fixture_database.sqlite3"
 sqlite_test_db2 = "#{BASE_DIR}/fixture_database_2.sqlite3"
 
 def make_connection(clazz, db_file, db_definitions_file)
+  ActiveRecord::Base.configurations = { clazz.name => { :adapter => 'sqlite3', :database => db_file, :timeout => 5000 } }
   unless File.exist?(db_file)
     puts "SQLite3 database not found at #{db_file}. Rebuilding it."
     sqlite_command = %Q{sqlite3 #{db_file} "create table a (a integer); drop table a;"}
     puts "Executing '#{sqlite_command}'"
     raise SqliteError.new("Seems that there is no sqlite3 executable available") unless system(sqlite_command)
-    clazz.establish_connection(
-        :adapter => "sqlite3",
-        :database  => db_file)
+    clazz.establish_connection(clazz.name)
     script = File.read("#{BASE_DIR}/db_definitions/#{db_definitions_file}")
     # SQLite-Ruby has problems with semi-colon separated commands, so split and execute one at a time
     script.split(';').each do
@@ -26,9 +25,7 @@ def make_connection(clazz, db_file, db_definitions_file)
       clazz.connection.execute(command) unless command.strip.empty?
     end
   else
-    clazz.establish_connection(
-        :adapter => "sqlite3",
-        :database  => db_file)
+    clazz.establish_connection(clazz.name)
   end
 end