activerecord 1.15.6 → 2.0.0

data/test/binary_test.rb

@@ -1,37 +1,32 @@
 require 'abstract_unit'
-require 'fixtures/binary'
 
-class BinaryTest < Test::Unit::TestCase
-  BINARY_FIXTURE_PATH = File.dirname(__FILE__) + '/fixtures/flowers.jpg'
+# Without using prepared statements, it makes no sense to test
+# BLOB data with SQL Server, because the length of a statement is
+# limited to 8KB.
+#
+# Without using prepared statements, it makes no sense to test
+# BLOB data with DB2 or Firebird, because the length of a statement
+# is limited to 32KB.
+unless current_adapter?(:SQLServerAdapter, :SybaseAdapter, :DB2Adapter, :FirebirdAdapter)
+  require 'fixtures/binary'
 
-  def setup
-    Binary.connection.execute 'DELETE FROM binaries'
-    @data = File.read(BINARY_FIXTURE_PATH).freeze
-  end
-  
-  def test_truth
-    assert true
-  end
+  class BinaryTest < Test::Unit::TestCase
+    FIXTURES = %w(flowers.jpg example.log)
 
-  # Without using prepared statements, it makes no sense to test
-  # BLOB data with SQL Server, because the length of a statement is
-  # limited to 8KB.
-  #
-  # Without using prepared statements, it makes no sense to test
-  # BLOB data with DB2 or Firebird, because the length of a statement
-  # is limited to 32KB.
-  unless %w(SQLServer Sybase DB2 Oracle Firebird).include? ActiveRecord::Base.connection.adapter_name
     def test_load_save
-      bin = Binary.new
-      bin.data = @data
+      Binary.delete_all
+
+      FIXTURES.each do |filename|
+        data = File.read("#{File.dirname(__FILE__)}/fixtures/#{filename}").freeze
+
+        bin = Binary.new(:data => data)
+        assert_equal data, bin.data, 'Newly assigned data differs from original'
 
-      assert @data == bin.data, 'Newly assigned data differs from original'
-          
-      bin.save
-      assert @data == bin.data, 'Data differs from original after save'
+        bin.save!
+        assert_equal data, bin.data, 'Data differs from original after save'
 
-      db_bin = Binary.find(bin.id)
-      assert @data == db_bin.data, 'Reloaded data differs from original'
+        assert_equal data, bin.reload.data, 'Reloaded data differs from original'
+      end
     end
   end
 end

data/test/calculations_test.rb

@@ -4,6 +4,10 @@ require 'fixtures/topic'
 
 Company.has_many :accounts
 
+class NumericData < ActiveRecord::Base
+  self.table_name = 'numeric_data'
+end
+
 class CalculationsTest < Test::Unit::TestCase
   fixtures :companies, :accounts, :topics
 
@@ -17,6 +21,10 @@ class CalculationsTest < Test::Unit::TestCase
     assert_in_delta 53.0, value, 0.001
   end
 
+  def test_should_return_nil_as_average
+    assert_nil NumericData.average(:bank_balance)
+  end
+
   def test_should_get_maximum_of_field
     assert_equal 60, Account.maximum(:credit_limit)
   end
@@ -131,6 +139,26 @@ class CalculationsTest < Test::Unit::TestCase
     assert_equal 2, c[companies(:rails_core)]
     assert_equal 1, c[companies(:first_client)]
   end
+
+  uses_mocha 'group_by_non_numeric_foreign_key_association' do
+    def test_should_group_by_association_with_non_numeric_foreign_key
+      ActiveRecord::Base.connection.expects(:select_all).returns([{"count_all" => 1, "firm_id" => "ABC"}])
+
+      firm = mock()
+      firm.expects(:id).returns("ABC")
+      firm.expects(:class).returns(Firm)
+      Company.expects(:find).with(["ABC"]).returns([firm])
+
+      column = mock()
+      column.expects(:name).at_least_once.returns(:firm_id)
+      column.expects(:type_cast).with("ABC").returns("ABC")
+      Account.expects(:columns).at_least_once.returns([column])
+
+      c = Account.count(:all, :group => :firm)
+      assert_equal Firm, c.first.first.class
+      assert_equal 1, c.first.last
+    end
+  end
   
   def test_should_not_modify_options_when_using_includes
     options = {:conditions => 'companies.id > 1', :include => :firm}
@@ -199,16 +227,20 @@ class CalculationsTest < Test::Unit::TestCase
     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') }
+  
+  def test_count_with_column_parameter
+    assert_equal 5, Account.count(:firm_id)
   end
-
+  
+  def test_count_with_column_and_options_parameter
+    assert_equal 2, Account.count(:firm_id, :conditions => "credit_limit = 50")
+  end
+  
   def test_count_with_no_parameters_isnt_deprecated
     assert_not_deprecated { Account.count }
   end

data/test/callbacks_test.rb

@@ -49,6 +49,16 @@ class CallbackDeveloper < ActiveRecord::Base
   end
 end
 
+class ParentDeveloper < ActiveRecord::Base
+  set_table_name 'developers'
+  attr_accessor :after_save_called
+  before_validation {|record| record.after_save_called = true}
+end
+
+class ChildDeveloper < ParentDeveloper
+  
+end
+
 class RecursiveCallbackDeveloper < ActiveRecord::Base
   set_table_name 'developers'
 
@@ -374,4 +384,17 @@ class CallbacksTest < Test::Unit::TestCase
       [ :before_validation, :returning_false  ]
     ], david.history
   end
+  
+  def test_inheritence_of_callbacks
+    parent = ParentDeveloper.new
+    assert !parent.after_save_called
+    parent.save
+    assert parent.after_save_called
+    
+    child = ChildDeveloper.new
+    assert !child.after_save_called
+    child.save
+    assert child.after_save_called
+  end
+  
 end

data/test/connection_test_firebird.rb

@@ -1,6 +1,6 @@
-require 'abstract_unit'
+require "#{File.dirname(__FILE__)}/abstract_unit"
 
-class ConnectionTest < Test::Unit::TestCase
+class FirebirdConnectionTest < 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

data/test/connection_test_mysql.rb

@@ -0,0 +1,30 @@
+require "#{File.dirname(__FILE__)}/abstract_unit"
+
+class MysqlConnectionTest < Test::Unit::TestCase
+  def setup
+    @connection = ActiveRecord::Base.connection
+  end
+
+  def test_no_automatic_reconnection_after_timeout
+    assert @connection.active?
+    @connection.update('set @@wait_timeout=1')
+    sleep 2
+    assert !@connection.active?
+  end
+
+  def test_successful_reconnection_after_timeout_with_manual_reconnect
+    assert @connection.active?
+    @connection.update('set @@wait_timeout=1')
+    sleep 2
+    @connection.reconnect!
+    assert @connection.active?
+  end
+
+  def test_successful_reconnection_after_timeout_with_verify
+    assert @connection.active?
+    @connection.update('set @@wait_timeout=1')
+    sleep 2
+    @connection.verify!(0)
+    assert @connection.active?
+  end
+end

data/test/connections/native_mysql/connection.rb

@@ -6,6 +6,9 @@ RAILS_DEFAULT_LOGGER = Logger.new('debug.log')
 RAILS_DEFAULT_LOGGER.level = Logger::DEBUG
 ActiveRecord::Base.logger = RAILS_DEFAULT_LOGGER
 
+# GRANT ALL PRIVILEGES ON activerecord_unittest.* to 'rails'@'localhost';
+# GRANT ALL PRIVILEGES ON activerecord_unittest2.* to 'rails'@'localhost';
+
 ActiveRecord::Base.configurations = {
   'arunit' => {
     :adapter  => 'mysql',

data/test/connections/native_sqlite/connection.rb

@@ -10,25 +10,16 @@ BASE_DIR = File.expand_path(File.dirname(__FILE__) + '/../../fixtures')
 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)
+def make_connection(clazz, db_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;"}
+    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(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
-      |command|
-      clazz.connection.execute(command) unless command.strip.empty?
-    end
-  else
-    clazz.establish_connection(clazz.name)
   end
+  clazz.establish_connection(clazz.name)
 end
 
-make_connection(ActiveRecord::Base, sqlite_test_db, 'sqlite.sql')
-make_connection(Course, sqlite_test_db2, 'sqlite2.sql')
-load(File.join(BASE_DIR, 'db_definitions', 'schema.rb'))
+make_connection(ActiveRecord::Base, sqlite_test_db)
+make_connection(Course, sqlite_test_db2)

data/test/connections/native_sqlite3/connection.rb

@@ -10,25 +10,16 @@ BASE_DIR = File.expand_path(File.dirname(__FILE__) + '/../../fixtures')
 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)
+def make_connection(clazz, db_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;"}
+    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(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
-      |command|
-      clazz.connection.execute(command) unless command.strip.empty?
-    end
-  else
-    clazz.establish_connection(clazz.name)
   end
+  clazz.establish_connection(clazz.name)
 end
 
-make_connection(ActiveRecord::Base, sqlite_test_db, 'sqlite.sql')
-make_connection(Course, sqlite_test_db2, 'sqlite2.sql')
-load(File.join(BASE_DIR, 'db_definitions', 'schema.rb'))
+make_connection(ActiveRecord::Base, sqlite_test_db)
+make_connection(Course, sqlite_test_db2)

data/test/connections/native_sqlite3/in_memory_connection.rb

@@ -15,4 +15,4 @@ end
 
 make_connection(ActiveRecord::Base, 'sqlite.sql')
 make_connection(Course, 'sqlite2.sql')
-  load("#{File.dirname(__FILE__)}/../../fixtures/db_definitions/schema.rb"))
+load("#{File.dirname(__FILE__)}/../../fixtures/db_definitions/schema.rb")

data/test/{copy_table_sqlite.rb → copy_table_test_sqlite.rb}

@@ -26,8 +26,9 @@ class CopyTableTest < Test::Unit::TestCase
   def test_copy_table_renaming_column
     test_copy_table('companies', 'companies2', 
         :rename => {'client_of' => 'fan_of'}) do |from, to, options|
-      assert_equal column_values(from, 'client_of').compact.sort, 
-                   column_values(to, 'fan_of').compact.sort
+      expected = column_values(from, 'client_of')
+      assert expected.any?, 'only nils in resultset; real values are needed'
+      assert_equal expected, column_values(to, 'fan_of')
     end
   end
   
@@ -41,6 +42,10 @@ class CopyTableTest < Test::Unit::TestCase
     end
   end
   
+  def test_copy_table_without_primary_key
+    test_copy_table('developers_projects', 'programmers_projects')
+  end
+  
 protected
   def copy_table(from, to, options = {})
     @connection.copy_table(from, to, {:temporary => true}.merge(options))
@@ -51,7 +56,7 @@ protected
   end
   
   def column_values(table, column)
-    @connection.select_all("SELECT #{column} FROM #{table}").map {|row| row[column]}
+    @connection.select_all("SELECT #{column} FROM #{table} ORDER BY id").map {|row| row[column]}
   end
 
   def table_indexes_without_name(table)

data/test/datatype_test_postgresql.rb

@@ -1,52 +1,203 @@
 require 'abstract_unit'
 
-class PostgresqlDatatype < ActiveRecord::Base
+class PostgresqlArray < ActiveRecord::Base
 end
 
-class PGDataTypeTest < Test::Unit::TestCase
-  self.use_transactional_fixtures = false
+class PostgresqlMoney < ActiveRecord::Base
+end
+
+class PostgresqlNumber < ActiveRecord::Base
+end
+
+class PostgresqlTime < ActiveRecord::Base
+end
+
+class PostgresqlNetworkAddress < ActiveRecord::Base
+end
+
+class PostgresqlBitString < ActiveRecord::Base
+end
 
-  TABLE_NAME = 'postgresql_datatypes'
-  COLUMNS = [
-    'id SERIAL PRIMARY KEY',
-    'commission_by_quarter INTEGER[]',
-    'nicknames TEXT[]'
-  ]
+class PostgresqlOid < ActiveRecord::Base
+end
+
+class PostgresqlDataTypeTest < Test::Unit::TestCase
+  self.use_transactional_fixtures = false
 
   def setup
     @connection = ActiveRecord::Base.connection
-    @connection.execute "CREATE TABLE #{TABLE_NAME} (#{COLUMNS.join(',')})"
-    @connection.execute "INSERT INTO #{TABLE_NAME} (commission_by_quarter, nicknames) VALUES ( '{35000,21000,18000,17000}', '{foo,bar,baz}' )"
-    @first = PostgresqlDatatype.find( 1 )
-  end
 
-  def teardown
-    @connection.execute "DROP TABLE #{TABLE_NAME}"
+    @connection.execute("INSERT INTO postgresql_arrays (commission_by_quarter, nicknames) VALUES ( '{35000,21000,18000,17000}', '{foo,bar,baz}' )")
+    @first_array = PostgresqlArray.find(1)
+
+    @connection.execute("INSERT INTO postgresql_moneys (wealth) VALUES ('$567.89')")
+    @connection.execute("INSERT INTO postgresql_moneys (wealth) VALUES ('-$567.89')")
+    @first_money = PostgresqlMoney.find(1)
+    @second_money = PostgresqlMoney.find(2)
+
+    @connection.execute("INSERT INTO postgresql_numbers (single, double) VALUES (123.456, 123456.789)")
+    @first_number = PostgresqlNumber.find(1)
+
+    @connection.execute("INSERT INTO postgresql_times (time_interval) VALUES ('1 year 2 days ago')")
+    @first_time = PostgresqlTime.find(1)
+
+    @connection.execute("INSERT INTO postgresql_network_addresses (cidr_address, inet_address, mac_address) VALUES('192.168.0/24', '172.16.1.254/32', '01:23:45:67:89:0a')")
+    @first_network_address = PostgresqlNetworkAddress.find(1)
+    
+    @connection.execute("INSERT INTO postgresql_bit_strings (bit_string, bit_string_varying) VALUES (B'00010101', X'15')")
+    @first_bit_string = PostgresqlBitString.find(1)
+    
+    @connection.execute("INSERT INTO postgresql_oids (obj_id) VALUES (1234)")
+    @first_oid = PostgresqlOid.find(1)
   end
 
   def test_data_type_of_array_types
-    assert_equal :string, @first.column_for_attribute("commission_by_quarter").type
-    assert_equal :string, @first.column_for_attribute("nicknames").type
+    assert_equal :string, @first_array.column_for_attribute(:commission_by_quarter).type
+    assert_equal :string, @first_array.column_for_attribute(:nicknames).type
+  end
+
+  def test_data_type_of_money_types
+    assert_equal :decimal, @first_money.column_for_attribute(:wealth).type
+  end
+
+  def test_data_type_of_number_types
+    assert_equal :float, @first_number.column_for_attribute(:single).type
+    assert_equal :float, @first_number.column_for_attribute(:double).type
+  end
+
+  def test_data_type_of_time_types
+    assert_equal :string, @first_time.column_for_attribute(:time_interval).type
+  end
+
+  def test_data_type_of_network_address_types
+    assert_equal :string, @first_network_address.column_for_attribute(:cidr_address).type
+    assert_equal :string, @first_network_address.column_for_attribute(:inet_address).type
+    assert_equal :string, @first_network_address.column_for_attribute(:mac_address).type
+  end
+
+  def test_data_type_of_bit_string_types
+    assert_equal :string, @first_bit_string.column_for_attribute(:bit_string).type
+    assert_equal :string, @first_bit_string.column_for_attribute(:bit_string_varying).type
+  end
+
+  def test_data_type_of_oid_types
+    assert_equal :integer, @first_oid.column_for_attribute(:obj_id).type
   end
 
   def test_array_values
-    assert_equal '{35000,21000,18000,17000}', @first.commission_by_quarter
-    assert_equal '{foo,bar,baz}', @first.nicknames
+   assert_equal '{35000,21000,18000,17000}', @first_array.commission_by_quarter
+   assert_equal '{foo,bar,baz}', @first_array.nicknames
+  end
+
+  def test_money_values
+    assert_equal 567.89, @first_money.wealth
+    assert_equal -567.89, @second_money.wealth
+  end
+
+  def test_number_values
+    assert_equal 123.456, @first_number.single
+    assert_equal 123456.789, @first_number.double
+  end
+
+  def test_time_values
+    assert_equal '-1 years -2 days', @first_time.time_interval
+  end
+
+  def test_network_address_values
+    assert_equal '192.168.0.0/24', @first_network_address.cidr_address
+    assert_equal '172.16.1.254', @first_network_address.inet_address
+    assert_equal '01:23:45:67:89:0a', @first_network_address.mac_address
+  end
+
+  def test_bit_string_values
+    assert_equal '00010101', @first_bit_string.bit_string
+    assert_equal '00010101', @first_bit_string.bit_string_varying
+  end
+
+  def test_oid_values
+    assert_equal 1234, @first_oid.obj_id
   end
 
   def test_update_integer_array
     new_value = '{32800,95000,29350,17000}'
-    assert @first.commission_by_quarter = new_value
-    assert @first.save
-    assert @first.reload
-    assert_equal @first.commission_by_quarter, new_value
+    assert @first_array.commission_by_quarter = new_value
+    assert @first_array.save
+    assert @first_array.reload
+    assert_equal @first_array.commission_by_quarter, new_value
+    assert @first_array.commission_by_quarter = new_value
+    assert @first_array.save
+    assert @first_array.reload
+    assert_equal @first_array.commission_by_quarter, new_value
   end
 
   def test_update_text_array
     new_value = '{robby,robert,rob,robbie}'
-    assert @first.nicknames = new_value
-    assert @first.save
-    assert @first.reload
-    assert_equal @first.nicknames, new_value
+    assert @first_array.nicknames = new_value
+    assert @first_array.save
+    assert @first_array.reload
+    assert_equal @first_array.nicknames, new_value
+    assert @first_array.nicknames = new_value
+    assert @first_array.save
+    assert @first_array.reload
+    assert_equal @first_array.nicknames, new_value
+  end
+
+  def test_update_money
+    new_value = 123.45
+    assert @first_money.wealth = new_value
+    assert @first_money.save
+    assert @first_money.reload
+    assert_equal @first_money.wealth, new_value
+  end
+
+  def test_update_number
+    new_single = 789.012
+    new_double = 789012.345
+    assert @first_number.single = new_single
+    assert @first_number.double = new_double
+    assert @first_number.save
+    assert @first_number.reload
+    assert_equal @first_number.single, new_single
+    assert_equal @first_number.double, new_double
+  end
+
+  def test_update_time
+    assert @first_time.time_interval = '2 years 3 minutes'
+    assert @first_time.save
+    assert @first_time.reload
+    assert_equal @first_time.time_interval, '2 years 00:03:00'
+  end
+
+  def test_update_network_address
+    new_cidr_address = '10.1.2.3/32'
+    new_inet_address = '10.0.0.0/8'
+    new_mac_address = 'bc:de:f0:12:34:56'
+    assert @first_network_address.cidr_address = new_cidr_address
+    assert @first_network_address.inet_address = new_inet_address
+    assert @first_network_address.mac_address = new_mac_address
+    assert @first_network_address.save
+    assert @first_network_address.reload
+    assert_equal @first_network_address.cidr_address, new_cidr_address
+    assert_equal @first_network_address.inet_address, new_inet_address
+    assert_equal @first_network_address.mac_address, new_mac_address
+  end
+
+  def test_update_bit_string
+    new_bit_string = '11111111'
+    new_bit_string_varying = 'FF'
+    assert @first_bit_string.bit_string = new_bit_string
+    assert @first_bit_string.bit_string_varying = new_bit_string_varying
+    assert @first_bit_string.save
+    assert @first_bit_string.reload
+    assert_equal @first_bit_string.bit_string, new_bit_string
+    assert_equal @first_bit_string.bit_string, @first_bit_string.bit_string_varying
+  end
+
+  def test_update_oid
+    new_value = 567890
+    assert @first_oid.obj_id = new_value
+    assert @first_oid.save
+    assert @first_oid.reload
+    assert_equal @first_oid.obj_id, new_value
   end
 end