ibm_db 3.0.0-x86-mingw32 → 3.0.1-x86-mingw32

data/test/cases/quoting_test.rb

@@ -0,0 +1,156 @@
+require "cases/helper"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class QuotingTest < ActiveRecord::TestCase
+      def setup
+        @quoter = Class.new { include Quoting }.new
+      end
+
+      def test_quoted_true
+        assert_equal "'t'", @quoter.quoted_true
+      end
+
+      def test_quoted_false
+        assert_equal "'f'", @quoter.quoted_false
+      end
+
+      def test_quote_column_name
+        assert_equal "foo", @quoter.quote_column_name('foo')
+      end
+
+      def test_quote_table_name
+        assert_equal "foo", @quoter.quote_table_name('foo')
+      end
+
+      def test_quote_table_name_calls_quote_column_name
+        @quoter.extend(Module.new {
+          def quote_column_name(string)
+            'lol'
+          end
+        })
+        assert_equal 'lol', @quoter.quote_table_name('foo')
+      end
+
+      def test_quote_string
+        assert_equal "''", @quoter.quote_string("'")
+        assert_equal "\\\\", @quoter.quote_string("\\")
+        assert_equal "hi''i", @quoter.quote_string("hi'i")
+        assert_equal "hi\\\\i", @quoter.quote_string("hi\\i")
+      end
+
+      def test_quoted_date
+        t = Date.today
+        assert_equal t.to_s(:db), @quoter.quoted_date(t)
+      end
+
+      def test_quoted_time_utc
+        with_timezone_config default: :utc do
+          t = Time.now
+          assert_equal t.getutc.to_s(:db), @quoter.quoted_date(t)
+        end
+      end
+
+      def test_quoted_time_local
+        with_timezone_config default: :local do
+          t = Time.now
+          assert_equal t.getlocal.to_s(:db), @quoter.quoted_date(t)
+        end
+      end
+
+      def test_quoted_time_crazy
+        with_timezone_config default: :asdfasdf do
+          t = Time.now
+          assert_equal t.getlocal.to_s(:db), @quoter.quoted_date(t)
+        end
+      end
+
+      def test_quoted_datetime_utc
+        with_timezone_config default: :utc do
+          t = DateTime.now
+          assert_equal t.getutc.to_s(:db), @quoter.quoted_date(t)
+        end
+      end
+
+      ###
+      # DateTime doesn't define getlocal, so make sure it does nothing
+      def test_quoted_datetime_local
+        with_timezone_config default: :local do
+          t = DateTime.now
+          assert_equal t.to_s(:db), @quoter.quoted_date(t)
+        end
+      end
+
+      def test_quote_with_quoted_id
+        assert_equal 1, @quoter.quote(Struct.new(:quoted_id).new(1), nil)
+      end
+
+      def test_quote_nil
+        assert_equal 'NULL', @quoter.quote(nil, nil)
+      end
+
+      def test_quote_true
+        assert_equal @quoter.quoted_true, @quoter.quote(true, nil)
+      end
+
+      def test_quote_false
+        assert_equal @quoter.quoted_false, @quoter.quote(false, nil)
+      end
+
+      def test_quote_float
+        float = 1.2
+        assert_equal float.to_s, @quoter.quote(float, nil)
+      end
+
+      def test_quote_fixnum
+        fixnum = 1
+        assert_equal fixnum.to_s, @quoter.quote(fixnum, nil)
+      end
+
+      def test_quote_bignum
+        bignum = 1 << 100
+        assert_equal bignum.to_s, @quoter.quote(bignum, nil)
+      end
+
+      def test_quote_bigdecimal
+        bigdec = BigDecimal.new((1 << 100).to_s)
+        assert_equal bigdec.to_s('F'), @quoter.quote(bigdec, nil)
+      end
+
+      def test_dates_and_times
+        @quoter.extend(Module.new { def quoted_date(value) 'lol' end })
+        assert_equal "'lol'", @quoter.quote(Date.today, nil)
+        assert_equal "'lol'", @quoter.quote(Time.now, nil)
+        assert_equal "'lol'", @quoter.quote(DateTime.now, nil)
+      end
+
+      def test_crazy_object
+        crazy = Class.new.new
+        expected = "'#{YAML.dump(crazy)}'"
+        assert_equal expected, @quoter.quote(crazy, nil)
+      end
+
+      def test_crazy_object_calls_quote_string
+        crazy = Class.new { def initialize; @lol = 'lo\l' end }.new
+        assert_match "lo\\\\l", @quoter.quote(crazy, nil)
+      end
+
+      def test_quote_string_no_column
+        assert_equal "'lo\\\\l'", @quoter.quote('lo\l', nil)
+      end
+
+      def test_quote_as_mb_chars_no_column
+        string = ActiveSupport::Multibyte::Chars.new('lo\l')
+        assert_equal "'lo\\\\l'", @quoter.quote(string, nil)
+      end
+
+      def test_string_with_crazy_column
+        assert_equal "'lo\\\\l'", @quoter.quote('lo\l')
+      end
+
+      def test_quote_duration
+        assert_equal "1800", @quoter.quote(30.minutes)
+      end
+    end
+  end
+end

data/test/cases/readonly_test.rb

@@ -0,0 +1,118 @@
+require "cases/helper"
+require 'models/author'
+require 'models/post'
+require 'models/comment'
+require 'models/developer'
+require 'models/computer'
+require 'models/project'
+require 'models/reader'
+require 'models/person'
+
+class ReadOnlyTest < ActiveRecord::TestCase
+  fixtures :authors, :posts, :comments, :developers, :projects, :developers_projects, :people, :readers, :author_addresses
+
+  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
+
+    e = assert_raise(ActiveRecord::ReadOnlyRecord) { dev.save  }
+    assert_equal "Developer is marked as readonly", e.message
+
+    e = assert_raise(ActiveRecord::ReadOnlyRecord) { dev.save! }
+    assert_equal "Developer is marked as readonly", e.message
+
+    e = assert_raise(ActiveRecord::ReadOnlyRecord) { dev.destroy }
+    assert_equal "Developer is marked as readonly", e.message
+  end
+
+
+  def test_find_with_readonly_option
+    Developer.all.each { |d| assert !d.readonly? }
+    Developer.readonly(false).each { |d| assert !d.readonly? }
+    Developer.readonly(true).each { |d| assert d.readonly? }
+    Developer.readonly.each { |d| assert d.readonly? }
+  end
+
+  def test_find_with_joins_option_does_not_imply_readonly
+    Developer.joins('  ').each { |d| assert_not d.readonly? }
+    Developer.joins('  ').readonly(true).each { |d| assert d.readonly? }
+
+    Developer.joins(', projects').each { |d| assert_not d.readonly? }
+    Developer.joins(', projects').readonly(true).each { |d| assert d.readonly? }
+  end
+
+  def test_has_many_find_readonly
+    post = Post.find(1)
+    assert !post.comments.empty?
+    assert !post.comments.any?(&:readonly?)
+    assert !post.comments.to_a.any?(&:readonly?)
+    assert post.comments.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_has_many_with_through_is_not_implicitly_marked_readonly_while_finding_by_id
+    assert !posts(:welcome).people.find(1).readonly?
+  end
+
+  def test_has_many_with_through_is_not_implicitly_marked_readonly_while_finding_first
+    assert !posts(:welcome).people.first.readonly?
+  end
+
+  def test_has_many_with_through_is_not_implicitly_marked_readonly_while_finding_last
+    assert !posts(:welcome).people.last.readonly?
+  end
+
+  def test_readonly_scoping
+    Post.where('1=1').scoping do
+      assert !Post.find(1).readonly?
+      assert Post.readonly(true).find(1).readonly?
+      assert !Post.readonly(false).find(1).readonly?
+    end
+
+    Post.joins('   ').scoping do
+      assert !Post.find(1).readonly?
+      assert Post.readonly.find(1).readonly?
+      assert !Post.readonly(false).find(1).readonly?
+    end
+
+    # Oracle barfs on this because the join includes unqualified and
+    # conflicting column names
+    unless current_adapter?(:OracleAdapter)
+      Post.joins(', developers').scoping do
+        assert_not Post.find(1).readonly?
+        assert Post.readonly.find(1).readonly?
+        assert !Post.readonly(false).find(1).readonly?
+      end
+    end
+
+    Post.readonly(true).scoping do
+      assert Post.find(1).readonly?
+      assert Post.readonly.find(1).readonly?
+      assert !Post.readonly(false).find(1).readonly?
+    end
+  end
+
+  def test_association_collection_method_missing_scoping_not_readonly
+    developer = Developer.find(1)
+    project   = Post.find(1)
+
+    assert !developer.projects.all_as_method.first.readonly?
+    assert !developer.projects.all_as_scope.first.readonly?
+
+    assert !project.comments.all_as_method.first.readonly?
+    assert !project.comments.all_as_scope.first.readonly?
+  end
+end

data/test/cases/reaper_test.rb

@@ -0,0 +1,85 @@
+require "cases/helper"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class ReaperTest < ActiveRecord::TestCase
+      attr_reader :pool
+
+      def setup
+        super
+        @pool = ConnectionPool.new ActiveRecord::Base.connection_pool.spec
+      end
+
+      teardown do
+        @pool.connections.each(&:close)
+      end
+
+      class FakePool
+        attr_reader :reaped
+
+        def initialize
+          @reaped = false
+        end
+
+        def reap
+          @reaped = true
+        end
+      end
+
+      # A reaper with nil time should never reap connections
+      def test_nil_time
+        fp = FakePool.new
+        assert !fp.reaped
+        reaper = ConnectionPool::Reaper.new(fp, nil)
+        reaper.run
+        assert !fp.reaped
+      end
+
+      def test_some_time
+        fp = FakePool.new
+        assert !fp.reaped
+
+        reaper = ConnectionPool::Reaper.new(fp, 0.0001)
+        reaper.run
+        until fp.reaped
+          Thread.pass
+        end
+        assert fp.reaped
+      end
+
+      def test_pool_has_reaper
+        assert pool.reaper
+      end
+
+      def test_reaping_frequency_configuration
+        spec = ActiveRecord::Base.connection_pool.spec.dup
+        spec.config[:reaping_frequency] = 100
+        pool = ConnectionPool.new spec
+        assert_equal 100, pool.reaper.frequency
+      end
+
+      def test_connection_pool_starts_reaper
+        spec = ActiveRecord::Base.connection_pool.spec.dup
+        spec.config[:reaping_frequency] = '0.0001'
+
+        pool = ConnectionPool.new spec
+
+        conn = nil
+        child = Thread.new do
+          conn = pool.checkout
+          Thread.stop
+        end
+        Thread.pass while conn.nil?
+
+        assert conn.in_use?
+
+        child.terminate
+
+        while conn.in_use?
+          Thread.pass
+        end
+        assert !conn.in_use?
+      end
+    end
+  end
+end

data/test/cases/reflection_test.rb

@@ -0,0 +1,454 @@
+require "cases/helper"
+require 'models/topic'
+require 'models/customer'
+require 'models/company'
+require 'models/company_in_module'
+require 'models/ship'
+require 'models/pirate'
+require 'models/price_estimate'
+require 'models/essay'
+require 'models/author'
+require 'models/organization'
+require 'models/post'
+require 'models/tagging'
+require 'models/category'
+require 'models/book'
+require 'models/subscriber'
+require 'models/subscription'
+require 'models/tag'
+require 'models/sponsor'
+require 'models/edge'
+require 'models/hotel'
+require 'models/chef'
+require 'models/department'
+require 'models/cake_designer'
+require 'models/drink_designer'
+
+class ReflectionTest < ActiveRecord::TestCase
+  include ActiveRecord::Reflection
+
+  fixtures :topics, :customers, :companies, :subscribers, :price_estimates
+
+  def setup
+    @first = Topic.find(1)
+  end
+
+  def test_human_name
+    assert_equal "Price estimate", PriceEstimate.model_name.human
+    assert_equal "Subscriber", Subscriber.model_name.human
+  end
+
+  def test_read_attribute_names
+    assert_equal(
+      %w( id title author_name author_email_address bonus_time written_on last_read content important group approved replies_count unique_replies_count parent_id parent_title type created_at updated_at ).sort,
+      @first.attribute_names.sort
+    )
+  end
+
+  def test_columns
+    assert_equal 18, 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 important approved replies_count unique_replies_count parent_id parent_title type group created_at updated_at), column_names
+  end
+
+  def test_content_columns
+    content_columns        = Topic.content_columns
+    content_column_names   = content_columns.map {|column| column.name}
+    assert_equal 13, content_columns.length
+    assert_equal %w(title author_name author_email_address written_on bonus_time last_read content important group approved parent_title created_at updated_at).sort, content_column_names.sort
+  end
+
+  def test_column_string_type_and_limit
+    assert_equal :string, @first.column_for_attribute("title").type
+    assert_equal 250, @first.column_for_attribute("title").limit
+  end
+
+  def test_column_null_not_null
+    subscriber = Subscriber.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_non_existent_columns_return_nil
+    assert_deprecated do
+      assert_nil @first.column_for_attribute("attribute_that_doesnt_exist")
+    end
+  end
+
+  def test_reflection_klass_for_nested_class_name
+    reflection = ActiveRecord::Reflection.create(:has_many, nil, nil, { :class_name => 'MyApplication::Business::Company' }, ActiveRecord::Base)
+    assert_nothing_raised do
+      assert_equal MyApplication::Business::Company, reflection.klass
+    end
+  end
+
+  def test_irregular_reflection_class_name
+    ActiveSupport::Inflector.inflections do |inflect|
+      inflect.irregular 'plural_irregular', 'plurales_irregulares'
+    end
+    reflection = ActiveRecord::Reflection.create(:has_many, 'plurales_irregulares', nil, {}, ActiveRecord::Base)
+    assert_equal 'PluralIrregular', reflection.class_name
+  end
+
+  def test_aggregation_reflection
+    reflection_for_address = AggregateReflection.new(
+      :address, nil, { :mapping => [ %w(address_street street), %w(address_city city), %w(address_country country) ] }, Customer
+    )
+
+    reflection_for_balance = AggregateReflection.new(
+      :balance, nil, { :class_name => "Money", :mapping => %w(balance amount) }, Customer
+    )
+
+    reflection_for_gps_location = AggregateReflection.new(
+      :gps_location, nil, { }, 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 = ActiveRecord::Reflection.create(:has_many, :clients, nil, { :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 = ActiveRecord::Reflection.create(:has_one, :account, nil, { :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).foreign_key
+    Company.belongs_to :bar, :class_name => "Xyzzy"
+    assert_equal "bar_id", Company.reflect_on_association(:bar).foreign_key
+    Company.belongs_to :baz, :class_name => "Xyzzy", :foreign_key => "xyzzy_id"
+    assert_equal "xyzzy_id", Company.reflect_on_association(:baz).foreign_key
+  end
+
+  def test_association_reflection_in_modules
+    ActiveRecord::Base.store_full_sti_class = false
+
+    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'
+  ensure
+    ActiveRecord::Base.store_full_sti_class = true
+  end
+
+  def test_reflection_should_not_raise_error_when_compared_to_other_object
+    assert_not_equal Object.new, Firm._reflections['clients']
+  end
+
+  def test_reflections_should_return_keys_as_strings
+    assert Category.reflections.keys.all? { |key| key.is_a? String }, "Model.reflections is expected to return string for keys"
+  end
+
+  def test_has_and_belongs_to_many_reflection
+    assert_equal :has_and_belongs_to_many, Category.reflections['posts'].macro
+    assert_equal :posts, Category.reflect_on_all_associations(:has_and_belongs_to_many).first.name
+  end
+
+  def test_has_many_through_reflection
+    assert_kind_of ThroughReflection, Subscriber.reflect_on_association(:books)
+  end
+
+  def test_chain
+    expected = [
+      Organization.reflect_on_association(:author_essay_categories),
+      Author.reflect_on_association(:essays),
+      Organization.reflect_on_association(:authors)
+    ]
+    actual = Organization.reflect_on_association(:author_essay_categories).chain
+
+    assert_equal expected, actual
+  end
+
+  def test_scope_chain
+    expected = [
+      [Tagging.reflect_on_association(:tag).scope, Post.reflect_on_association(:first_blue_tags).scope],
+      [Post.reflect_on_association(:first_taggings).scope],
+      [Author.reflect_on_association(:misc_posts).scope]
+    ]
+    actual = Author.reflect_on_association(:misc_post_first_blue_tags).scope_chain
+    assert_equal expected, actual
+
+    expected = [
+      [
+        Tagging.reflect_on_association(:blue_tag).scope,
+        Post.reflect_on_association(:first_blue_tags_2).scope,
+        Author.reflect_on_association(:misc_post_first_blue_tags_2).scope
+      ],
+      [],
+      []
+    ]
+    actual = Author.reflect_on_association(:misc_post_first_blue_tags_2).scope_chain
+    assert_equal expected, actual
+  end
+
+  def test_scope_chain_does_not_interfere_with_hmt_with_polymorphic_case
+    @hotel = Hotel.create!
+    @department = @hotel.departments.create!
+    @department.chefs.create!(employable: CakeDesigner.create!)
+    @department.chefs.create!(employable: DrinkDesigner.create!)
+
+    assert_equal 1, @hotel.cake_designers.size
+    assert_equal 1, @hotel.drink_designers.size
+    assert_equal 2, @hotel.chefs.size
+  end
+
+  def test_nested?
+    assert !Author.reflect_on_association(:comments).nested?
+    assert Author.reflect_on_association(:tags).nested?
+
+    # Only goes :through once, but the through_reflection is a has_and_belongs_to_many, so this is
+    # a nested through association
+    assert Category.reflect_on_association(:post_comments).nested?
+  end
+
+  def test_association_primary_key
+    # Normal association
+    assert_equal "id",   Author.reflect_on_association(:posts).association_primary_key.to_s
+    assert_equal "name", Author.reflect_on_association(:essay).association_primary_key.to_s
+    assert_equal "name", Essay.reflect_on_association(:writer).association_primary_key.to_s
+
+    # Through association (uses the :primary_key option from the source reflection)
+    assert_equal "nick", Author.reflect_on_association(:subscribers).association_primary_key.to_s
+    assert_equal "name", Author.reflect_on_association(:essay_category).association_primary_key.to_s
+    assert_equal "custom_primary_key", Author.reflect_on_association(:tags_with_primary_key).association_primary_key.to_s # nested
+  end
+
+  def test_association_primary_key_raises_when_missing_primary_key
+    reflection = ActiveRecord::Reflection.create(:has_many, :edge, nil, {}, Author)
+    assert_raises(ActiveRecord::UnknownPrimaryKey) { reflection.association_primary_key }
+
+    through = Class.new(ActiveRecord::Reflection::ThroughReflection) {
+      define_method(:source_reflection) { reflection }
+    }.new(reflection)
+    assert_raises(ActiveRecord::UnknownPrimaryKey) { through.association_primary_key }
+  end
+
+  def test_active_record_primary_key
+    assert_equal "nick", Subscriber.reflect_on_association(:subscriptions).active_record_primary_key.to_s
+    assert_equal "name", Author.reflect_on_association(:essay).active_record_primary_key.to_s
+  end
+
+  def test_active_record_primary_key_raises_when_missing_primary_key
+    reflection = ActiveRecord::Reflection.create(:has_many, :author, nil, {}, Edge)
+    assert_raises(ActiveRecord::UnknownPrimaryKey) { reflection.active_record_primary_key }
+  end
+
+  def test_foreign_type
+    assert_equal "sponsorable_type", Sponsor.reflect_on_association(:sponsorable).foreign_type.to_s
+    assert_equal "sponsorable_type", Sponsor.reflect_on_association(:thing).foreign_type.to_s
+  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 ActiveRecord::Reflection.create(:has_many, :clients, nil, {}, Firm).validate?
+
+    assert !ActiveRecord::Reflection.create(:has_one, :client, nil, {}, Firm).validate?
+    assert !ActiveRecord::Reflection.create(:belongs_to, :client, nil, {}, Firm).validate?
+  end
+
+  def test_always_validate_association_if_explicit
+    assert ActiveRecord::Reflection.create(:has_one, :client, nil, { :validate => true }, Firm).validate?
+    assert ActiveRecord::Reflection.create(:belongs_to, :client, nil, { :validate => true }, Firm).validate?
+    assert ActiveRecord::Reflection.create(:has_many, :clients, nil, { :validate => true }, Firm).validate?
+  end
+
+  def test_validate_association_if_autosave
+    assert ActiveRecord::Reflection.create(:has_one, :client, nil, { :autosave => true }, Firm).validate?
+    assert ActiveRecord::Reflection.create(:belongs_to, :client, nil, { :autosave => true }, Firm).validate?
+    assert ActiveRecord::Reflection.create(:has_many, :clients, nil, { :autosave => true }, Firm).validate?
+  end
+
+  def test_never_validate_association_if_explicit
+    assert !ActiveRecord::Reflection.create(:has_one, :client, nil, { :autosave => true, :validate => false }, Firm).validate?
+    assert !ActiveRecord::Reflection.create(:belongs_to, :client, nil, { :autosave => true, :validate => false }, Firm).validate?
+    assert !ActiveRecord::Reflection.create(:has_many, :clients, nil, { :autosave => true, :validate => false }, Firm).validate?
+  end
+
+  def test_foreign_key
+    assert_equal "author_id", Author.reflect_on_association(:posts).foreign_key.to_s
+    assert_equal "category_id", Post.reflect_on_association(:categorizations).foreign_key.to_s
+  end
+
+  def test_through_reflection_scope_chain_does_not_modify_other_reflections
+    orig_conds = Post.reflect_on_association(:first_blue_tags_2).scope_chain.inspect
+    Author.reflect_on_association(:misc_post_first_blue_tags_2).scope_chain
+    assert_equal orig_conds, Post.reflect_on_association(:first_blue_tags_2).scope_chain.inspect
+  end
+
+  def test_symbol_for_class_name
+    assert_equal Client, Firm.reflect_on_association(:unsorted_clients_with_symbol).klass
+  end
+
+  def test_join_table
+    category = Struct.new(:table_name, :pluralize_table_names).new('categories', true)
+    product = Struct.new(:table_name, :pluralize_table_names).new('products', true)
+
+    reflection = ActiveRecord::Reflection.create(:has_many, :categories, nil, {}, product)
+    reflection.stubs(:klass).returns(category)
+    assert_equal 'categories_products', reflection.join_table
+
+    reflection = ActiveRecord::Reflection.create(:has_many, :products, nil, {}, category)
+    reflection.stubs(:klass).returns(product)
+    assert_equal 'categories_products', reflection.join_table
+  end
+
+  def test_join_table_with_common_prefix
+    category = Struct.new(:table_name, :pluralize_table_names).new('catalog_categories', true)
+    product = Struct.new(:table_name, :pluralize_table_names).new('catalog_products', true)
+
+    reflection = ActiveRecord::Reflection.create(:has_many, :categories, nil, {}, product)
+    reflection.stubs(:klass).returns(category)
+    assert_equal 'catalog_categories_products', reflection.join_table
+
+    reflection = ActiveRecord::Reflection.create(:has_many, :products, nil, {}, category)
+    reflection.stubs(:klass).returns(product)
+    assert_equal 'catalog_categories_products', reflection.join_table
+  end
+
+  def test_join_table_with_different_prefix
+    category = Struct.new(:table_name, :pluralize_table_names).new('catalog_categories', true)
+    page = Struct.new(:table_name, :pluralize_table_names).new('content_pages', true)
+
+    reflection = ActiveRecord::Reflection.create(:has_many, :categories, nil, {}, page)
+    reflection.stubs(:klass).returns(category)
+    assert_equal 'catalog_categories_content_pages', reflection.join_table
+
+    reflection = ActiveRecord::Reflection.create(:has_many, :pages, nil, {}, category)
+    reflection.stubs(:klass).returns(page)
+    assert_equal 'catalog_categories_content_pages', reflection.join_table
+  end
+
+  def test_join_table_can_be_overridden
+    category = Struct.new(:table_name, :pluralize_table_names).new('categories', true)
+    product = Struct.new(:table_name, :pluralize_table_names).new('products', true)
+
+    reflection = ActiveRecord::Reflection.create(:has_many, :categories, nil, { :join_table => 'product_categories' }, product)
+    reflection.stubs(:klass).returns(category)
+    assert_equal 'product_categories', reflection.join_table
+
+    reflection = ActiveRecord::Reflection.create(:has_many, :products, nil, { :join_table => 'product_categories' }, category)
+    reflection.stubs(:klass).returns(product)
+    assert_equal 'product_categories', reflection.join_table
+  end
+
+  def test_includes_accepts_symbols
+    hotel = Hotel.create!
+    department = hotel.departments.create!
+    department.chefs.create!
+
+    assert_nothing_raised do
+      assert_equal department.chefs, Hotel.includes([departments: :chefs]).first.chefs
+    end
+  end
+
+  def test_includes_accepts_strings
+    hotel = Hotel.create!
+    department = hotel.departments.create!
+    department.chefs.create!
+
+    assert_nothing_raised do
+      assert_equal department.chefs, Hotel.includes(['departments' => 'chefs']).first.chefs
+    end
+  end
+
+  def test_reflect_on_association_accepts_symbols
+    assert_nothing_raised do
+      assert_equal Hotel.reflect_on_association(:departments).name, :departments
+    end
+  end
+
+  def test_reflect_on_association_accepts_strings
+    assert_nothing_raised do
+      assert_equal Hotel.reflect_on_association("departments").name, :departments
+    end
+  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