activerecord 2.3.18 → 3.2.22

data/test/cases/pk_test.rb

@@ -1,119 +0,0 @@
-require "cases/helper"
-require 'models/topic'
-require 'models/reply'
-require 'models/subscriber'
-require 'models/movie'
-require 'models/keyboard'
-require 'models/mixed_case_monkey'
-
-class PrimaryKeysTest < ActiveRecord::TestCase
-  fixtures :topics, :subscribers, :movies, :mixed_case_monkeys
-
-  def test_integer_key
-    topic = Topic.find(1)
-    assert_equal(topics(:first).author_name, topic.author_name)
-    topic = Topic.find(2)
-    assert_equal(topics(:second).author_name, topic.author_name)
-
-    topic = Topic.new
-    topic.title = "New Topic"
-    assert_equal(nil, topic.id)
-    assert_nothing_raised { topic.save! }
-    id = topic.id
-
-    topicReloaded = Topic.find(id)
-    assert_equal("New Topic", topicReloaded.title)
-  end
-
-  def test_customized_primary_key_auto_assigns_on_save
-    Keyboard.delete_all
-    keyboard = Keyboard.new(:name => 'HHKB')
-    assert_nothing_raised { keyboard.save! }
-    assert_equal keyboard.id, Keyboard.find_by_name('HHKB').id
-  end
-
-  def test_customized_primary_key_can_be_get_before_saving
-    keyboard = Keyboard.new
-    assert_nil keyboard.id
-    assert_nothing_raised { assert_nil keyboard.key_number }
-  end
-
-  def test_customized_string_primary_key_settable_before_save
-    subscriber = Subscriber.new
-    assert_nothing_raised { subscriber.id = 'webster123' }
-    assert_equal 'webster123', subscriber.id
-    assert_equal 'webster123', subscriber.nick
-  end
-
-  def test_string_key
-    subscriber = Subscriber.find(subscribers(:first).nick)
-    assert_equal(subscribers(:first).name, subscriber.name)
-    subscriber = Subscriber.find(subscribers(:second).nick)
-    assert_equal(subscribers(:second).name, subscriber.name)
-
-    subscriber = Subscriber.new
-    subscriber.id = "jdoe"
-    assert_equal("jdoe", subscriber.id)
-    subscriber.name = "John Doe"
-    assert_nothing_raised { subscriber.save! }
-    assert_equal("jdoe", subscriber.id)
-
-    subscriberReloaded = Subscriber.find("jdoe")
-    assert_equal("John Doe", subscriberReloaded.name)
-  end
-
-  def test_find_with_more_than_one_string_key
-    assert_equal 2, Subscriber.find(subscribers(:first).nick, subscribers(:second).nick).length
-  end
-
-  def test_primary_key_prefix
-    ActiveRecord::Base.primary_key_prefix_type = :table_name
-    Topic.reset_primary_key
-    assert_equal "topicid", Topic.primary_key
-
-    ActiveRecord::Base.primary_key_prefix_type = :table_name_with_underscore
-    Topic.reset_primary_key
-    assert_equal "topic_id", Topic.primary_key
-
-    ActiveRecord::Base.primary_key_prefix_type = nil
-    Topic.reset_primary_key
-    assert_equal "id", Topic.primary_key
-  end
-
-  def test_delete_should_quote_pkey
-    assert_nothing_raised { MixedCaseMonkey.delete(1) }
-  end
-  def test_update_counters_should_quote_pkey_and_quote_counter_columns
-    assert_nothing_raised { MixedCaseMonkey.update_counters(1, :fleaCount => 99) }
-  end
-  def test_find_with_one_id_should_quote_pkey
-    assert_nothing_raised { MixedCaseMonkey.find(1) }
-  end
-  def test_find_with_multiple_ids_should_quote_pkey
-    assert_nothing_raised { MixedCaseMonkey.find([1,2]) }
-  end
-  def test_instance_update_should_quote_pkey
-    assert_nothing_raised { MixedCaseMonkey.find(1).save }
-  end
-  def test_instance_destroy_should_quote_pkey
-    assert_nothing_raised { MixedCaseMonkey.find(1).destroy }
-  end
-
-  def test_supports_primary_key
-    assert_nothing_raised NoMethodError do
-      ActiveRecord::Base.connection.supports_primary_key?
-    end
-  end
-
-  def test_primary_key_returns_value_if_it_exists
-    if ActiveRecord::Base.connection.supports_primary_key?
-      assert_equal 'id', ActiveRecord::Base.connection.primary_key('developers')
-    end
-  end
-
-  def test_primary_key_returns_nil_if_it_does_not_exist
-    if ActiveRecord::Base.connection.supports_primary_key?
-      assert_nil ActiveRecord::Base.connection.primary_key('developers_projects')
-    end
-  end
-end

data/test/cases/pooled_connections_test.rb

@@ -1,103 +0,0 @@
-require "cases/helper"
-
-class PooledConnectionsTest < ActiveRecord::TestCase
-  def setup
-    super
-    @connection = ActiveRecord::Base.remove_connection
-  end
-
-  def teardown
-    ActiveRecord::Base.clear_all_connections!
-    ActiveRecord::Base.establish_connection(@connection)
-    super
-  end
-
-  def checkout_connections
-    ActiveRecord::Base.establish_connection(@connection.merge({:pool => 2, :wait_timeout => 0.3}))
-    @connections = []
-    @timed_out = 0
-
-    4.times do
-      Thread.new do
-        begin
-          @connections << ActiveRecord::Base.connection_pool.checkout
-        rescue ActiveRecord::ConnectionTimeoutError
-          @timed_out += 1
-        end
-      end.join
-    end
-  end
-
-  # Will deadlock due to lack of Monitor timeouts in 1.9
-  if RUBY_VERSION < '1.9'
-    def test_pooled_connection_checkout
-      checkout_connections
-      assert_equal @connections.length, 2
-      assert_equal @timed_out, 2
-    end
-  end
-
-  def checkout_checkin_connections(pool_size, threads)
-    ActiveRecord::Base.establish_connection(@connection.merge({:pool => pool_size, :wait_timeout => 0.5}))
-    @connection_count = 0
-    @timed_out = 0
-    threads.times do
-      Thread.new do
-        begin
-          conn = ActiveRecord::Base.connection_pool.checkout
-          sleep 0.1
-          ActiveRecord::Base.connection_pool.checkin conn
-          @connection_count += 1
-        rescue ActiveRecord::ConnectionTimeoutError
-          @timed_out += 1
-        end
-      end.join
-    end
-  end
-
-  def test_pooled_connection_checkin_one
-    checkout_checkin_connections 1, 2
-    assert_equal 2, @connection_count
-    assert_equal 0, @timed_out
-  end
-
-  def test_pooled_connection_checkin_two
-    checkout_checkin_connections 2, 3
-    assert_equal 3, @connection_count
-    assert_equal 0, @timed_out
-  end
-
-  def test_pooled_connection_checkout_existing_first
-    ActiveRecord::Base.establish_connection(@connection.merge({:pool => 1}))
-    conn_pool = ActiveRecord::Base.connection_pool
-    conn = conn_pool.checkout
-    conn_pool.checkin(conn)
-    conn = conn_pool.checkout
-    assert ActiveRecord::ConnectionAdapters::AbstractAdapter === conn
-    conn_pool.checkin(conn)
-  end
-
-  def test_not_connected_defined_connection_returns_false
-    ActiveRecord::Base.establish_connection(@connection)
-    assert ! ActiveRecord::Base.connected?
-  end
-
-  def test_undefined_connection_returns_false
-    old_handler = ActiveRecord::Base.connection_handler
-    ActiveRecord::Base.connection_handler = ActiveRecord::ConnectionAdapters::ConnectionHandler.new
-    assert_equal false, ActiveRecord::Base.connected?
-  ensure
-    ActiveRecord::Base.connection_handler = old_handler
-  end
-end unless %w(FrontBase).include? ActiveRecord::Base.connection.adapter_name
-
-class AllowConcurrencyDeprecatedTest < ActiveRecord::TestCase
-  def test_allow_concurrency_is_deprecated
-    assert_deprecated('ActiveRecord::Base.allow_concurrency') do
-      ActiveRecord::Base.allow_concurrency
-    end
-    assert_deprecated('ActiveRecord::Base.allow_concurrency=') do
-      ActiveRecord::Base.allow_concurrency = true
-    end
-  end
-end

data/test/cases/query_cache_test.rb

@@ -1,129 +0,0 @@
-require "cases/helper"
-require 'models/topic'
-require 'models/reply'
-require 'models/task'
-require 'models/course'
-require 'models/category'
-require 'models/post'
-
-
-class QueryCacheTest < ActiveRecord::TestCase
-  fixtures :tasks, :topics, :categories, :posts, :categories_posts
-
-  def test_find_queries
-    assert_queries(2) { Task.find(1); Task.find(1) }
-  end
-
-  def test_find_queries_with_cache
-    Task.cache do
-      assert_queries(1) { Task.find(1); Task.find(1) }
-    end
-  end
-
-  def test_count_queries_with_cache
-    Task.cache do
-      assert_queries(1) { Task.count; Task.count }
-    end
-  end
-
-  def test_query_cache_dups_results_correctly
-    Task.cache do
-      now  = Time.now.utc
-      task = Task.find 1
-      assert_not_equal now, task.starting
-      task.starting = now
-      task.reload
-      assert_not_equal now, task.starting
-    end
-  end
-
-  def test_cache_is_flat
-    Task.cache do
-      Topic.columns # don't count this query
-      assert_queries(1) { Topic.find(1); Topic.find(1); }
-    end
-
-    ActiveRecord::Base.cache do
-      assert_queries(1) { Task.find(1); Task.find(1) }
-    end
-  end
-
-  def test_cache_does_not_wrap_string_results_in_arrays
-    require 'sqlite3/version' if current_adapter?(:SQLite3Adapter)
-
-    Task.cache do
-      if current_adapter?(:SQLite3Adapter) && SQLite3::Version::VERSION > '1.2.5'
-        assert_instance_of Fixnum, Task.connection.select_value("SELECT count(*) AS count_all FROM tasks")
-      else
-        assert_instance_of String, Task.connection.select_value("SELECT count(*) AS count_all FROM tasks")
-      end
-    end
-  end
-end
-
-class QueryCacheExpiryTest < ActiveRecord::TestCase
-  fixtures :tasks, :posts, :categories, :categories_posts
-
-  def test_find
-    Task.connection.expects(:clear_query_cache).times(1)
-
-    assert !Task.connection.query_cache_enabled
-    Task.cache do
-      assert Task.connection.query_cache_enabled
-      Task.find(1)
-
-      Task.uncached do
-        assert !Task.connection.query_cache_enabled
-        Task.find(1)
-      end
-
-      assert Task.connection.query_cache_enabled
-    end
-    assert !Task.connection.query_cache_enabled
-  end
-
-  def test_update
-    Task.connection.expects(:clear_query_cache).times(2)
-
-    Task.cache do
-      task = Task.find(1)
-      task.starting = Time.now.utc
-      task.save!
-    end
-  end
-
-  def test_destroy
-    Task.connection.expects(:clear_query_cache).times(2)
-
-    Task.cache do
-      Task.find(1).destroy
-    end
-  end
-
-  def test_insert
-    ActiveRecord::Base.connection.expects(:clear_query_cache).times(2)
-
-    Task.cache do
-      Task.create!
-    end
-  end
-
-  def test_cache_is_expired_by_habtm_update
-    ActiveRecord::Base.connection.expects(:clear_query_cache).times(2)
-    ActiveRecord::Base.cache do
-      c = Category.find(:first)
-      p = Post.find(:first)
-      p.categories << c
-    end
-  end
-
-  def test_cache_is_expired_by_habtm_delete
-    ActiveRecord::Base.connection.expects(:clear_query_cache).times(2)
-    ActiveRecord::Base.cache do
-      c = Category.find(1)
-      p = Post.find(1)
-      assert p.categories.any?
-      p.categories.delete_all
-    end
-  end
-end

data/test/cases/readonly_test.rb

@@ -1,107 +0,0 @@
-require "cases/helper"
-require 'models/post'
-require 'models/comment'
-require 'models/developer'
-require 'models/project'
-require 'models/reader'
-require 'models/person'
-
-# Dummy class methods to test implicit association scoping.
-def Comment.foo() find :first end
-def Project.foo() find :first end
-
-
-class ReadOnlyTest < ActiveRecord::TestCase
-  fixtures :posts, :comments, :developers, :projects, :developers_projects
-
-  def test_cant_save_readonly_record
-    dev = Developer.find(1)
-    assert !dev.readonly?
-
-    dev.readonly!
-    assert dev.readonly?
-
-    assert_nothing_raised do
-      dev.name = 'Luscious forbidden fruit.'
-      assert !dev.save
-      dev.name = 'Forbidden.'
-    end
-    assert_raise(ActiveRecord::ReadOnlyRecord) { dev.save  }
-    assert_raise(ActiveRecord::ReadOnlyRecord) { dev.save! }
-  end
-
-
-  def test_find_with_readonly_option
-    Developer.find(:all).each { |d| assert !d.readonly? }
-    Developer.find(:all, :readonly => false).each { |d| assert !d.readonly? }
-    Developer.find(:all, :readonly => true).each { |d| assert d.readonly? }
-  end
-
-
-  def test_find_with_joins_option_implies_readonly
-    # Blank joins don't count.
-    Developer.find(:all, :joins => '  ').each { |d| assert !d.readonly? }
-    Developer.find(:all, :joins => '  ', :readonly => false).each { |d| assert !d.readonly? }
-
-    # Others do.
-    Developer.find(:all, :joins => ', projects').each { |d| assert d.readonly? }
-    Developer.find(:all, :joins => ', projects', :readonly => false).each { |d| assert !d.readonly? }
-  end
-
-
-  def test_habtm_find_readonly
-    dev = Developer.find(1)
-    assert !dev.projects.empty?
-    assert dev.projects.all?(&:readonly?)
-    assert dev.projects.find(:all).all?(&:readonly?)
-    assert dev.projects.find(:all, :readonly => true).all?(&:readonly?)
-  end
-
-  def test_has_many_find_readonly
-    post = Post.find(1)
-    assert !post.comments.empty?
-    assert !post.comments.any?(&:readonly?)
-    assert !post.comments.find(:all).any?(&:readonly?)
-    assert post.comments.find(:all, :readonly => true).all?(&:readonly?)
-  end
-
-  def test_has_many_with_through_is_not_implicitly_marked_readonly
-    assert people = Post.find(1).people
-    assert !people.any?(&:readonly?)
-  end
-
-  def test_readonly_scoping
-    Post.with_scope(:find => { :conditions => '1=1' }) do
-      assert !Post.find(1).readonly?
-      assert Post.find(1, :readonly => true).readonly?
-      assert !Post.find(1, :readonly => false).readonly?
-    end
-
-    Post.with_scope(:find => { :joins => '   ' }) do
-      assert !Post.find(1).readonly?
-      assert Post.find(1, :readonly => true).readonly?
-      assert !Post.find(1, :readonly => false).readonly?
-    end
-
-    # Oracle barfs on this because the join includes unqualified and
-    # conflicting column names
-    unless current_adapter?(:OracleAdapter)
-      Post.with_scope(:find => { :joins => ', developers' }) do
-        assert Post.find(1).readonly?
-        assert Post.find(1, :readonly => true).readonly?
-        assert !Post.find(1, :readonly => false).readonly?
-      end
-    end
-
-    Post.with_scope(:find => { :readonly => true }) do
-      assert Post.find(1).readonly?
-      assert Post.find(1, :readonly => true).readonly?
-      assert !Post.find(1, :readonly => false).readonly?
-    end
-  end
-
-  def test_association_collection_method_missing_scoping_not_readonly
-    assert !Developer.find(1).projects.foo.readonly?
-    assert !Post.find(1).comments.foo.readonly?
-  end
-end

data/test/cases/reflection_test.rb

@@ -1,234 +0,0 @@
-require "cases/helper"
-require 'models/topic'
-require 'models/customer'
-require 'models/company'
-require 'models/company_in_module'
-require 'models/subscriber'
-require 'models/ship'
-require 'models/pirate'
-
-class ReflectionTest < ActiveRecord::TestCase
-  include ActiveRecord::Reflection
-
-  fixtures :topics, :customers, :companies, :subscribers
-
-  def setup
-    @first = Topic.find(1)
-  end
-
-  def test_column_null_not_null
-    subscriber = Subscriber.find(:first)
-    assert subscriber.column_for_attribute("name").null
-    assert !subscriber.column_for_attribute("nick").null
-  end
-
-  def test_read_attribute_names
-    assert_equal(
-      %w( id title author_name author_email_address bonus_time written_on last_read content group approved replies_count parent_id parent_title type ).sort,
-      @first.attribute_names
-    )
-  end
-
-  def test_columns
-    assert_equal 14, Topic.columns.length
-  end
-
-  def test_columns_are_returned_in_the_order_they_were_declared
-    column_names = Topic.columns.map { |column| column.name }
-    assert_equal %w(id title author_name author_email_address written_on bonus_time last_read content approved replies_count parent_id parent_title type group), column_names
-  end
-
-  def test_content_columns
-    content_columns        = Topic.content_columns
-    content_column_names   = content_columns.map {|column| column.name}
-    assert_equal 10, content_columns.length
-    assert_equal %w(title author_name author_email_address written_on bonus_time last_read content group approved parent_title).sort, content_column_names.sort
-  end
-
-  def test_column_string_type_and_limit
-    assert_equal :string, @first.column_for_attribute("title").type
-    assert_equal 255, @first.column_for_attribute("title").limit
-  end
-
-  def test_column_null_not_null
-    subscriber = Subscriber.find(:first)
-    assert subscriber.column_for_attribute("name").null
-    assert !subscriber.column_for_attribute("nick").null
-  end
-
-  def test_human_name_for_column
-    assert_equal "Author name", @first.column_for_attribute("author_name").human_name
-  end
-
-  def test_integer_columns
-    assert_equal :integer, @first.column_for_attribute("id").type
-  end
-
-  def test_reflection_klass_for_nested_class_name
-    reflection = MacroReflection.new(nil, nil, { :class_name => 'MyApplication::Business::Company' }, nil)
-    assert_nothing_raised do
-      assert_equal MyApplication::Business::Company, reflection.klass
-    end
-  end
-
-  def test_aggregation_reflection
-    reflection_for_address = AggregateReflection.new(
-      :composed_of, :address, { :mapping => [ %w(address_street street), %w(address_city city), %w(address_country country) ] }, Customer
-    )
-
-    reflection_for_balance = AggregateReflection.new(
-      :composed_of, :balance, { :class_name => "Money", :mapping => %w(balance amount) }, Customer
-    )
-
-    reflection_for_gps_location = AggregateReflection.new(
-      :composed_of, :gps_location, { }, Customer
-    )
-
-    assert Customer.reflect_on_all_aggregations.include?(reflection_for_gps_location)
-    assert Customer.reflect_on_all_aggregations.include?(reflection_for_balance)
-    assert Customer.reflect_on_all_aggregations.include?(reflection_for_address)
-
-    assert_equal reflection_for_address, Customer.reflect_on_aggregation(:address)
-
-    assert_equal Address, Customer.reflect_on_aggregation(:address).klass
-
-    assert_equal Money, Customer.reflect_on_aggregation(:balance).klass
-  end
-
-  def test_reflect_on_all_autosave_associations
-    expected = Pirate.reflect_on_all_associations.select { |r| r.options[:autosave] }
-    received = Pirate.reflect_on_all_autosave_associations
-
-    assert !received.empty?
-    assert_not_equal Pirate.reflect_on_all_associations.length, received.length
-    assert_equal expected, received
-  end
-
-  def test_has_many_reflection
-    reflection_for_clients = AssociationReflection.new(:has_many, :clients, { :order => "id", :dependent => :destroy }, Firm)
-
-    assert_equal reflection_for_clients, Firm.reflect_on_association(:clients)
-
-    assert_equal Client, Firm.reflect_on_association(:clients).klass
-    assert_equal 'companies', Firm.reflect_on_association(:clients).table_name
-
-    assert_equal Client, Firm.reflect_on_association(:clients_of_firm).klass
-    assert_equal 'companies', Firm.reflect_on_association(:clients_of_firm).table_name
-  end
-
-  def test_has_one_reflection
-    reflection_for_account = AssociationReflection.new(:has_one, :account, { :foreign_key => "firm_id", :dependent => :destroy }, Firm)
-    assert_equal reflection_for_account, Firm.reflect_on_association(:account)
-
-    assert_equal Account, Firm.reflect_on_association(:account).klass
-    assert_equal 'accounts', Firm.reflect_on_association(:account).table_name
-  end
-
-  def test_belongs_to_inferred_foreign_key_from_assoc_name
-    Company.belongs_to :foo
-    assert_equal "foo_id", Company.reflect_on_association(:foo).primary_key_name
-    Company.belongs_to :bar, :class_name => "Xyzzy"
-    assert_equal "bar_id", Company.reflect_on_association(:bar).primary_key_name
-    Company.belongs_to :baz, :class_name => "Xyzzy", :foreign_key => "xyzzy_id"
-    assert_equal "xyzzy_id", Company.reflect_on_association(:baz).primary_key_name
-  end
-
-  def test_association_reflection_in_modules
-    assert_reflection MyApplication::Business::Firm,
-      :clients_of_firm,
-      :klass      => MyApplication::Business::Client,
-      :class_name => 'Client',
-      :table_name => 'companies'
-
-    assert_reflection MyApplication::Billing::Account,
-      :firm,
-      :klass      => MyApplication::Business::Firm,
-      :class_name => 'MyApplication::Business::Firm',
-      :table_name => 'companies'
-
-    assert_reflection MyApplication::Billing::Account,
-      :qualified_billing_firm,
-      :klass      => MyApplication::Billing::Firm,
-      :class_name => 'MyApplication::Billing::Firm',
-      :table_name => 'companies'
-
-    assert_reflection MyApplication::Billing::Account,
-      :unqualified_billing_firm,
-      :klass      => MyApplication::Billing::Firm,
-      :class_name => 'Firm',
-      :table_name => 'companies'
-
-    assert_reflection MyApplication::Billing::Account,
-      :nested_qualified_billing_firm,
-      :klass      => MyApplication::Billing::Nested::Firm,
-      :class_name => 'MyApplication::Billing::Nested::Firm',
-      :table_name => 'companies'
-
-    assert_reflection MyApplication::Billing::Account,
-      :nested_unqualified_billing_firm,
-      :klass      => MyApplication::Billing::Nested::Firm,
-      :class_name => 'Nested::Firm',
-      :table_name => 'companies'
-  end
-
-  def test_reflection_of_all_associations
-    # FIXME these assertions bust a lot
-    assert_equal 36, Firm.reflect_on_all_associations.size
-    assert_equal 26, Firm.reflect_on_all_associations(:has_many).size
-    assert_equal 10, Firm.reflect_on_all_associations(:has_one).size
-    assert_equal 0, Firm.reflect_on_all_associations(:belongs_to).size
-  end
-
-  def test_reflection_should_not_raise_error_when_compared_to_other_object
-    assert_nothing_raised { Firm.reflections[:clients] == Object.new }
-  end
-
-  def test_has_many_through_reflection
-    assert_kind_of ThroughReflection, Subscriber.reflect_on_association(:books)
-  end
-
-  def test_collection_association
-    assert Pirate.reflect_on_association(:birds).collection?
-    assert Pirate.reflect_on_association(:parrots).collection?
-
-    assert !Pirate.reflect_on_association(:ship).collection?
-    assert !Ship.reflect_on_association(:pirate).collection?
-  end
-
-  def test_default_association_validation
-    assert AssociationReflection.new(:has_many, :clients, {}, Firm).validate?
-
-    assert !AssociationReflection.new(:has_one, :client, {}, Firm).validate?
-    assert !AssociationReflection.new(:belongs_to, :client, {}, Firm).validate?
-    assert !AssociationReflection.new(:has_and_belongs_to_many, :clients, {}, Firm).validate?
-  end
-
-  def test_always_validate_association_if_explicit
-    assert AssociationReflection.new(:has_one, :client, { :validate => true }, Firm).validate?
-    assert AssociationReflection.new(:belongs_to, :client, { :validate => true }, Firm).validate?
-    assert AssociationReflection.new(:has_many, :clients, { :validate => true }, Firm).validate?
-    assert AssociationReflection.new(:has_and_belongs_to_many, :clients, { :validate => true }, Firm).validate?
-  end
-
-  def test_validate_association_if_autosave
-    assert AssociationReflection.new(:has_one, :client, { :autosave => true }, Firm).validate?
-    assert AssociationReflection.new(:belongs_to, :client, { :autosave => true }, Firm).validate?
-    assert AssociationReflection.new(:has_many, :clients, { :autosave => true }, Firm).validate?
-    assert AssociationReflection.new(:has_and_belongs_to_many, :clients, { :autosave => true }, Firm).validate?
-  end
-
-  def test_never_validate_association_if_explicit
-    assert !AssociationReflection.new(:has_one, :client, { :autosave => true, :validate => false }, Firm).validate?
-    assert !AssociationReflection.new(:belongs_to, :client, { :autosave => true, :validate => false }, Firm).validate?
-    assert !AssociationReflection.new(:has_many, :clients, { :autosave => true, :validate => false }, Firm).validate?
-    assert !AssociationReflection.new(:has_and_belongs_to_many, :clients, { :autosave => true, :validate => false }, Firm).validate?
-  end
-
-  private
-    def assert_reflection(klass, association, options)
-      assert reflection = klass.reflect_on_association(association)
-      options.each do |method, value|
-        assert_equal(value, reflection.send(method))
-      end
-    end
-end