ibm_db 3.0.3-x86-mingw32 → 5.0.3-x86-mingw32

data/test/cases/reaper_test.rb

@@ -1,85 +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
+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

@@ -1,454 +1,509 @@
-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
+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'
+require 'models/mocktail_designer'
+require 'models/recipe'
+
+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(&: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(&: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_null_object
+    column = @first.column_for_attribute("attribute_that_doesnt_exist")
+    assert_instance_of ActiveRecord::ConnectionAdapters::NullColumn, column
+    assert_equal "attribute_that_doesnt_exist", column.name
+    assert_equal nil, column.sql_type
+    assert_equal nil, column.type
+  end
+
+  def test_non_existent_types_are_identity_types
+    type = @first.type_for_attribute("attribute_that_doesnt_exist")
+    object = Object.new
+
+    assert_equal object, type.deserialize(object)
+    assert_equal object, type.cast(object)
+    assert_equal object, type.serialize(object)
+  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_scope_chain_does_not_interfere_with_hmt_with_polymorphic_case_and_sti
+    @hotel = Hotel.create!
+    @hotel.mocktail_designers << MocktailDesigner.create!
+
+    assert_equal 1, @hotel.mocktail_designers.size
+    assert_equal 1, @hotel.mocktail_designers.count
+    assert_equal 1, @hotel.chef_lists.size
+  end
+
+  def test_scope_chain_of_polymorphic_association_does_not_leak_into_other_hmt_associations
+    hotel = Hotel.create!
+    department = hotel.departments.create!
+    drink = department.chefs.create!(employable: DrinkDesigner.create!)
+    Recipe.create!(chef_id: drink.id, hotel_id: hotel.id)
+
+    expected_sql = capture_sql { hotel.recipes.to_a }
+
+    Hotel.reflect_on_association(:recipes).clear_association_scope_cache
+    hotel.reload
+    hotel.drink_designers.to_a
+    loaded_sql = capture_sql { hotel.recipes.to_a }
+
+    assert_equal expected_sql, loaded_sql
+  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_type
+    # Normal Association
+    assert_equal :integer, Author.reflect_on_association(:posts).association_primary_key_type.type
+    assert_equal :string,  Author.reflect_on_association(:essay).association_primary_key_type.type
+
+    # Through Association
+    assert_equal :string, Author.reflect_on_association(:essay_category).association_primary_key_type.type
+  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.stub(:klass, category) do
+      assert_equal 'categories_products', reflection.join_table
+    end
+
+    reflection = ActiveRecord::Reflection.create(:has_many, :products, nil, {}, category)
+    reflection.stub(:klass, product) do
+      assert_equal 'categories_products', reflection.join_table
+    end
+  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.stub(:klass, category) do
+      assert_equal 'catalog_categories_products', reflection.join_table
+    end
+
+    reflection = ActiveRecord::Reflection.create(:has_many, :products, nil, {}, category)
+    reflection.stub(:klass, product) do
+      assert_equal 'catalog_categories_products', reflection.join_table
+    end
+  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.stub(:klass, category) do
+      assert_equal 'catalog_categories_content_pages', reflection.join_table
+    end
+
+    reflection = ActiveRecord::Reflection.create(:has_many, :pages, nil, {}, category)
+    reflection.stub(:klass, page) do
+      assert_equal 'catalog_categories_content_pages', reflection.join_table
+    end
+  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.stub(:klass, category) do
+      assert_equal 'product_categories', reflection.join_table
+    end
+
+    reflection = ActiveRecord::Reflection.create(:has_many, :products, nil, { :join_table => 'product_categories' }, category)
+    reflection.stub(:klass, product) do
+      assert_equal 'product_categories', reflection.join_table
+    end
+  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