activerecord 2.3.18 → 3.0.0.beta

data/test/cases/class_inheritable_attributes_test.rb

@@ -1,32 +0,0 @@
-require 'test/unit'
-require "cases/helper"
-require 'active_support/core_ext/class/inheritable_attributes'
-
-class A
-  include ClassInheritableAttributes
-end
-
-class B < A
-  write_inheritable_array "first", [ :one, :two ]
-end
-
-class C < A
-  write_inheritable_array "first", [ :three ]
-end
-
-class D < B
-  write_inheritable_array "first", [ :four ]
-end
-
-
-class ClassInheritableAttributesTest < ActiveRecord::TestCase
-  def test_first_level
-    assert_equal [ :one, :two ], B.read_inheritable_attribute("first")
-    assert_equal [ :three ], C.read_inheritable_attribute("first")
-  end
-
-  def test_second_level
-    assert_equal [ :one, :two, :four ], D.read_inheritable_attribute("first")
-    assert_equal [ :one, :two ], B.read_inheritable_attribute("first")
-  end
-end

data/test/cases/column_alias_test.rb

@@ -1,17 +0,0 @@
-require "cases/helper"
-require 'models/topic'
-
-class TestColumnAlias < ActiveRecord::TestCase
-  fixtures :topics
-
-  QUERY = if 'Oracle' == ActiveRecord::Base.connection.adapter_name
-            'SELECT id AS pk FROM topics WHERE ROWNUM < 2'
-          else
-            'SELECT id AS pk FROM topics'
-          end
-
-  def test_column_alias
-    records = Topic.connection.select_all(QUERY)
-    assert_equal 'pk', records[0].keys[0]
-  end
-end

data/test/cases/column_definition_test.rb

@@ -1,70 +0,0 @@
-require "cases/helper"
-
-class ColumnDefinitionTest < ActiveRecord::TestCase
-  def setup
-    @adapter = ActiveRecord::ConnectionAdapters::AbstractAdapter.new(nil)
-    def @adapter.native_database_types
-      {:string => "varchar"}
-    end
-  end
-
-  # Avoid column definitions in create table statements like:
-  # `title` varchar(255) DEFAULT NULL
-  def test_should_not_include_default_clause_when_default_is_null
-    column = ActiveRecord::ConnectionAdapters::Column.new("title", nil, "varchar(20)")
-    column_def = ActiveRecord::ConnectionAdapters::ColumnDefinition.new(
-      @adapter, column.name, "string",
-      column.limit, column.precision, column.scale, column.default, column.null)
-    assert_equal "title varchar(20)", column_def.to_sql
-  end
-
-  def test_should_include_default_clause_when_default_is_present
-    column = ActiveRecord::ConnectionAdapters::Column.new("title", "Hello", "varchar(20)")
-    column_def = ActiveRecord::ConnectionAdapters::ColumnDefinition.new(
-      @adapter, column.name, "string",
-      column.limit, column.precision, column.scale, column.default, column.null)
-    assert_equal %Q{title varchar(20) DEFAULT 'Hello'}, column_def.to_sql
-  end
-
-  def test_should_specify_not_null_if_null_option_is_false
-    column = ActiveRecord::ConnectionAdapters::Column.new("title", "Hello", "varchar(20)", false)
-    column_def = ActiveRecord::ConnectionAdapters::ColumnDefinition.new(
-      @adapter, column.name, "string",
-      column.limit, column.precision, column.scale, column.default, column.null)
-    assert_equal %Q{title varchar(20) DEFAULT 'Hello' NOT NULL}, column_def.to_sql
-  end
-
-  if current_adapter?(:MysqlAdapter)
-    def test_should_set_default_for_mysql_binary_data_types
-      binary_column = ActiveRecord::ConnectionAdapters::MysqlColumn.new("title", "a", "binary(1)")
-      assert_equal "a", binary_column.default
-
-      varbinary_column = ActiveRecord::ConnectionAdapters::MysqlColumn.new("title", "a", "varbinary(1)")
-      assert_equal "a", varbinary_column.default
-    end
-
-    def test_should_not_set_default_for_blob_and_text_data_types
-      assert_raise ArgumentError do
-        ActiveRecord::ConnectionAdapters::MysqlColumn.new("title", "a", "blob")
-      end
-
-      assert_raise ArgumentError do
-        ActiveRecord::ConnectionAdapters::MysqlColumn.new("title", "Hello", "text")
-      end
-
-      text_column = ActiveRecord::ConnectionAdapters::MysqlColumn.new("title", nil, "text")
-      assert_equal nil, text_column.default
-
-      not_null_text_column = ActiveRecord::ConnectionAdapters::MysqlColumn.new("title", nil, "text", false)
-      assert_equal "", not_null_text_column.default
-    end
-
-    def test_has_default_should_return_false_for_blog_and_test_data_types
-      blob_column = ActiveRecord::ConnectionAdapters::MysqlColumn.new("title", nil, "blob")
-      assert !blob_column.has_default?
-
-      text_column = ActiveRecord::ConnectionAdapters::MysqlColumn.new("title", nil, "text")
-      assert !text_column.has_default?
-    end
-  end
-end

data/test/cases/connection_pool_test.rb

@@ -1,25 +0,0 @@
-require "cases/helper"
-
-class ConnectionManagementTest < ActiveRecord::TestCase
-  def setup
-    @env = {}
-    @app = stub('App')
-    @management = ActiveRecord::ConnectionAdapters::ConnectionManagement.new(@app)
-    
-    @connections_cleared = false
-    ActiveRecord::Base.stubs(:clear_active_connections!).with { @connections_cleared = true }
-  end
-  
-  test "clears active connections after each call" do
-    @app.expects(:call).with(@env)
-    @management.call(@env)
-    assert @connections_cleared
-  end
-  
-  test "doesn't clear active connections when running in a test case" do
-    @env['rack.test'] = true
-    @app.expects(:call).with(@env)
-    @management.call(@env)
-    assert !@connections_cleared
-  end
-end

data/test/cases/connection_test_firebird.rb

@@ -1,8 +0,0 @@
-require "cases/helper"
-
-class FirebirdConnectionTest < ActiveRecord::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/cases/connection_test_mysql.rb

@@ -1,65 +0,0 @@
-require "cases/helper"
-
-class MysqlConnectionTest < ActiveRecord::TestCase
-  def setup
-    super
-    @connection = ActiveRecord::Base.connection
-  end
-
-  def test_mysql_reconnect_attribute_after_connection_with_reconnect_true
-    run_without_connection do |orig_connection|
-      ActiveRecord::Base.establish_connection(orig_connection.merge({:reconnect => true}))
-      assert ActiveRecord::Base.connection.raw_connection.reconnect
-    end
-  end
-
-  def test_mysql_reconnect_attribute_after_connection_with_reconnect_false
-    run_without_connection do |orig_connection|
-      ActiveRecord::Base.establish_connection(orig_connection.merge({:reconnect => false}))
-      assert !ActiveRecord::Base.connection.raw_connection.reconnect
-    end
-  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!
-    assert @connection.active?
- end
-
-  # Test that MySQL allows multiple results for stored procedures
-  if Mysql.const_defined?(:CLIENT_MULTI_RESULTS)
-    def test_multi_results
-      rows = ActiveRecord::Base.connection.select_rows('CALL ten();')
-      assert_equal 10, rows[0][0].to_i, "ten() did not return 10 as expected: #{rows.inspect}"
-      assert @connection.active?, "Bad connection use by 'MysqlAdapter.select_rows'"
-    end
-  end
-
-  private
-
-  def run_without_connection
-    original_connection = ActiveRecord::Base.remove_connection
-    begin
-      yield original_connection
-    ensure
-      ActiveRecord::Base.establish_connection(original_connection)
-    end
-  end
-end

data/test/cases/copy_table_test_sqlite.rb

@@ -1,80 +0,0 @@
-require "cases/helper"
-
-class CopyTableTest < ActiveRecord::TestCase
-  fixtures :companies, :comments
-
-  def setup
-    @connection = ActiveRecord::Base.connection
-    class << @connection
-      public :copy_table, :table_structure, :indexes
-    end
-  end
-
-  def test_copy_table(from = 'customers', to = 'customers2', options = {})
-    assert_nothing_raised {copy_table(from, to, options)}
-    assert_equal row_count(from), row_count(to)
-
-    if block_given?
-      yield from, to, options
-    else
-      assert_equal column_names(from), column_names(to)
-    end
-
-    @connection.drop_table(to) rescue nil
-  end
-
-  def test_copy_table_renaming_column
-    test_copy_table('customers', 'customers2',
-        :rename => {'name' => 'person_name'}) do |from, to, options|
-      expected = column_values(from, 'name')
-      assert expected.any?, 'only nils in resultset; real values are needed'
-      assert_equal expected, column_values(to, 'person_name')
-    end
-  end
-
-  def test_copy_table_with_index
-    test_copy_table('comments', 'comments_with_index') do
-      @connection.add_index('comments_with_index', ['post_id', 'type'])
-      test_copy_table('comments_with_index', 'comments_with_index2') do
-        assert_equal table_indexes_without_name('comments_with_index'),
-                     table_indexes_without_name('comments_with_index2')
-      end
-    end
-  end
-
-  def test_copy_table_without_primary_key
-    test_copy_table('developers_projects', 'programmers_projects')
-  end
-
-  def test_copy_table_with_id_col_that_is_not_primary_key
-    test_copy_table('goofy_string_id', 'goofy_string_id2') do |from, to, options|
-      original_id = @connection.columns('goofy_string_id').detect{|col| col.name == 'id' }
-      copied_id = @connection.columns('goofy_string_id2').detect{|col| col.name == 'id' }
-      assert_equal original_id.type, copied_id.type
-      assert_equal original_id.sql_type, copied_id.sql_type
-      assert_equal original_id.limit, copied_id.limit
-      assert_equal original_id.primary, copied_id.primary
-    end
-  end
-
-protected
-  def copy_table(from, to, options = {})
-    @connection.copy_table(from, to, {:temporary => true}.merge(options))
-  end
-
-  def column_names(table)
-    @connection.table_structure(table).map {|column| column['name']}
-  end
-
-  def column_values(table, column)
-    @connection.select_all("SELECT #{column} FROM #{table} ORDER BY id").map {|row| row[column]}
-  end
-
-  def table_indexes_without_name(table)
-    @connection.indexes('comments_with_index').delete(:name)
-  end
-
-  def row_count(table)
-    @connection.select_one("SELECT COUNT(*) AS count FROM #{table}")['count']
-  end
-end

data/test/cases/counter_cache_test.rb

@@ -1,84 +0,0 @@
-require 'cases/helper'
-require 'models/topic'
-require 'models/reply'
-require 'models/category'
-require 'models/categorization'
-
-class CounterCacheTest < ActiveRecord::TestCase
-  fixtures :topics, :categories, :categorizations
-
-  class SpecialTopic < ::Topic
-    has_many :special_replies, :foreign_key => 'parent_id'
-  end
-
-  class SpecialReply < ::Reply
-    belongs_to :special_topic, :foreign_key => 'parent_id', :counter_cache => 'replies_count'
-  end
-
-  test "increment counter" do
-    topic = Topic.find(1)
-    assert_difference 'topic.reload.replies_count' do
-      Topic.increment_counter(:replies_count, topic.id)
-    end
-  end
-
-  test "decrement counter" do
-    topic = Topic.find(1)
-    assert_difference 'topic.reload.replies_count', -1 do
-      Topic.decrement_counter(:replies_count, topic.id)
-    end
-  end
-
-  test "reset counters" do
-    topic = Topic.find(1)
-    # throw the count off by 1
-    Topic.increment_counter(:replies_count, topic.id)
-
-    # check that it gets reset
-    assert_difference 'topic.reload.replies_count', -1 do
-      Topic.reset_counters(topic.id, :replies)
-    end
-  end
-  
-  test "reset counters with string argument" do
-    topic = Topic.find(1)
-    Topic.increment_counter('replies_count', topic.id)
-
-    assert_difference 'topic.reload.replies_count', -1 do
-      Topic.reset_counters(topic.id, 'replies')
-    end
-  end
-
-  test "reset counters with modularized and camelized classnames" do
-    special = SpecialTopic.create!(:title => 'Special')
-    SpecialTopic.increment_counter(:replies_count, special.id)
-
-    assert_difference 'special.reload.replies_count', -1 do
-      SpecialTopic.reset_counters(special.id, :special_replies)
-    end
-  end
-
-  test "update counter with initial null value" do
-    category = categories(:general)
-    assert_equal 2, category.categorizations.count
-    assert_nil category.categorizations_count
-
-    Category.update_counters(category.id, :categorizations_count => category.categorizations.count)
-    assert_equal 2, category.reload.categorizations_count
-  end
-
-  test "update counter for decrement" do
-    topic = Topic.find(1)
-    assert_difference 'topic.reload.replies_count', -3 do
-      Topic.update_counters(topic.id, :replies_count => -3)
-    end
-  end
-
-  test "update counters of multiple records" do
-    t1, t2 = topics(:first, :second)
-
-    assert_difference ['t1.reload.replies_count', 't2.reload.replies_count'], 2 do
-      Topic.update_counters([t1.id, t2.id], :replies_count => 2)
-    end
-  end
-end

data/test/cases/database_statements_test.rb

@@ -1,12 +0,0 @@
-require "cases/helper"
-
-class DatabaseStatementsTest < ActiveRecord::TestCase
-  def setup
-    @connection = ActiveRecord::Base.connection
-  end
-
-  def test_insert_should_return_the_inserted_id
-    id = @connection.insert("INSERT INTO accounts (firm_id,credit_limit) VALUES (42,5000)")
-    assert_not_nil id
-  end
-end

data/test/cases/datatype_test_postgresql.rb

@@ -1,204 +0,0 @@
-require "cases/helper"
-
-class PostgresqlArray < ActiveRecord::Base
-end
-
-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
-
-class PostgresqlOid < ActiveRecord::Base
-end
-
-class PostgresqlDataTypeTest < ActiveRecord::TestCase
-  self.use_transactional_fixtures = false
-
-  def setup
-    @connection = ActiveRecord::Base.connection
-    @connection.execute("set lc_monetary = 'C'")
-
-    @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'::money)")
-    @connection.execute("INSERT INTO postgresql_moneys (wealth) VALUES ('-567.89'::money)")
-    @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_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_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_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_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 = BigDecimal.new('123.45')
-    assert @first_money.wealth = new_value
-    assert @first_money.save
-    assert @first_money.reload
-    assert_equal new_value, @first_money.wealth
-  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