activerecord 2.3.18 → 3.2.22

data/test/cases/helper.rb

@@ -1,68 +0,0 @@
-$:.unshift(File.dirname(__FILE__) + '/../../lib')
-$:.unshift(File.dirname(__FILE__) + '/../../../activesupport/lib')
-
-require 'config'
-
-require 'rubygems'
-require 'test/unit'
-require 'stringio'
-
-require 'active_record'
-require 'active_record/test_case'
-require 'active_record/fixtures'
-require 'connection'
-
-require 'cases/repair_helper'
-
-# Show backtraces for deprecated behavior for quicker cleanup.
-ActiveSupport::Deprecation.debug = true
-
-# Quote "type" if it's a reserved word for the current connection.
-QUOTED_TYPE = ActiveRecord::Base.connection.quote_column_name('type')
-
-def current_adapter?(*types)
-  types.any? do |type|
-    ActiveRecord::ConnectionAdapters.const_defined?(type) &&
-      ActiveRecord::Base.connection.is_a?(ActiveRecord::ConnectionAdapters.const_get(type))
-  end
-end
-
-ActiveRecord::Base.connection.class.class_eval do
-  IGNORED_SQL = [/^PRAGMA/, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SAVEPOINT/, /^ROLLBACK TO SAVEPOINT/, /^RELEASE SAVEPOINT/, /SHOW FIELDS/]
-
-  def execute_with_query_record(sql, name = nil, &block)
-    $queries_executed ||= []
-    $queries_executed << sql unless IGNORED_SQL.any? { |r| sql =~ r }
-    execute_without_query_record(sql, name, &block)
-  end
-
-  alias_method_chain :execute, :query_record
-end
-
-# Make with_scope public for tests
-class << ActiveRecord::Base
-  public :with_scope, :with_exclusive_scope
-end
-
-unless ENV['FIXTURE_DEBUG']
-  module ActiveRecord::TestFixtures::ClassMethods
-    def try_to_load_dependency_with_silence(*args)
-      ActiveRecord::Base.logger.silence { try_to_load_dependency_without_silence(*args)}
-    end
-
-    alias_method_chain :try_to_load_dependency, :silence
-  end
-end
-
-class ActiveSupport::TestCase
-  include ActiveRecord::TestFixtures
-  include ActiveRecord::Testing::RepairHelper
-
-  self.fixture_path = FIXTURES_ROOT
-  self.use_instantiated_fixtures  = false
-  self.use_transactional_fixtures = true
-
-  def create_fixtures(*table_names, &block)
-    Fixtures.create_fixtures(ActiveSupport::TestCase.fixture_path, table_names, {}, &block)
-  end
-end

data/test/cases/i18n_test.rb

@@ -1,46 +0,0 @@
-require "cases/helper"
-require 'models/topic'
-require 'models/reply'
-
-class ActiveRecordI18nTests < Test::Unit::TestCase
-
-  def setup
-    I18n.backend = I18n::Backend::Simple.new
-  end
-  
-  def test_translated_model_attributes
-    I18n.backend.store_translations 'en', :activerecord => {:attributes => {:topic => {:title => 'topic title attribute'} } }
-    assert_equal 'topic title attribute', Topic.human_attribute_name('title')
-  end
-  
-  def test_translated_model_attributes_with_symbols
-    I18n.backend.store_translations 'en', :activerecord => {:attributes => {:topic => {:title => 'topic title attribute'} } }
-    assert_equal 'topic title attribute', Topic.human_attribute_name(:title)
-  end
-
-  def test_translated_model_attributes_with_sti
-    I18n.backend.store_translations 'en', :activerecord => {:attributes => {:reply => {:title => 'reply title attribute'} } }
-    assert_equal 'reply title attribute', Reply.human_attribute_name('title')
-  end
-
-  def test_translated_model_attributes_with_sti_fallback
-    I18n.backend.store_translations 'en', :activerecord => {:attributes => {:topic => {:title => 'topic title attribute'} } }
-    assert_equal 'topic title attribute', Reply.human_attribute_name('title')
-  end
-
-  def test_translated_model_names
-    I18n.backend.store_translations 'en', :activerecord => {:models => {:topic => 'topic model'} }
-    assert_equal 'topic model', Topic.human_name
-  end
-
-  def test_translated_model_names_with_sti
-    I18n.backend.store_translations 'en', :activerecord => {:models => {:reply => 'reply model'} }
-    assert_equal 'reply model', Reply.human_name
-  end
-
-  def test_translated_model_names_with_sti_fallback
-    I18n.backend.store_translations 'en', :activerecord => {:models => {:topic => 'topic model'} }
-    assert_equal 'topic model', Reply.human_name
-  end
-end
-

data/test/cases/inheritance_test.rb

@@ -1,262 +0,0 @@
-require "cases/helper"
-require 'models/company'
-require 'models/project'
-require 'models/subscriber'
-
-class InheritanceTest < ActiveRecord::TestCase
-  fixtures :companies, :projects, :subscribers, :accounts
-
-  def test_class_with_store_full_sti_class_returns_full_name
-    old = ActiveRecord::Base.store_full_sti_class
-    ActiveRecord::Base.store_full_sti_class = true
-    assert_equal 'Namespaced::Company', Namespaced::Company.sti_name
-  ensure
-    ActiveRecord::Base.store_full_sti_class = old
-  end
-
-  def test_class_without_store_full_sti_class_returns_demodulized_name
-    old = ActiveRecord::Base.store_full_sti_class
-    ActiveRecord::Base.store_full_sti_class = false
-    assert_equal 'Company', Namespaced::Company.sti_name
-  ensure
-    ActiveRecord::Base.store_full_sti_class = old
-  end
-
-  def test_should_store_demodulized_class_name_with_store_full_sti_class_option_disabled
-    old = ActiveRecord::Base.store_full_sti_class
-    ActiveRecord::Base.store_full_sti_class = false
-    item = Namespaced::Company.new
-    assert_equal 'Company', item[:type]
-  ensure
-    ActiveRecord::Base.store_full_sti_class = old
-  end
-  
-  def test_should_store_full_class_name_with_store_full_sti_class_option_enabled
-    old = ActiveRecord::Base.store_full_sti_class
-    ActiveRecord::Base.store_full_sti_class = true
-    item = Namespaced::Company.new
-    assert_equal 'Namespaced::Company', item[:type]
-  ensure
-    ActiveRecord::Base.store_full_sti_class = old
-  end
-  
-  def test_different_namespace_subclass_should_load_correctly_with_store_full_sti_class_option
-    old = ActiveRecord::Base.store_full_sti_class
-    ActiveRecord::Base.store_full_sti_class = true
-    item = Namespaced::Company.create :name => "Wolverine 2"
-    assert_not_nil Company.find(item.id)
-    assert_not_nil Namespaced::Company.find(item.id)
-  ensure
-    ActiveRecord::Base.store_full_sti_class = old
-  end
-
-  def test_company_descends_from_active_record
-    assert_raise(NoMethodError) { ActiveRecord::Base.descends_from_active_record? }
-    assert AbstractCompany.descends_from_active_record?, 'AbstractCompany should descend from ActiveRecord::Base'
-    assert Company.descends_from_active_record?, 'Company should descend from ActiveRecord::Base'
-    assert !Class.new(Company).descends_from_active_record?, 'Company subclass should not descend from ActiveRecord::Base'
-  end
-
-  def test_a_bad_type_column
-    #SQLServer need to turn Identity Insert On before manually inserting into the Identity column
-    if current_adapter?(:SybaseAdapter)
-      Company.connection.execute "SET IDENTITY_INSERT companies ON"
-    end
-    Company.connection.insert "INSERT INTO companies (id, #{QUOTED_TYPE}, name) VALUES(100, 'bad_class!', 'Not happening')"
-
-    #We then need to turn it back Off before continuing.
-    if current_adapter?(:SybaseAdapter)
-      Company.connection.execute "SET IDENTITY_INSERT companies OFF"
-    end
-    assert_raise(ActiveRecord::SubclassNotFound) { Company.find(100) }
-  end
-
-  def test_inheritance_find
-    assert Company.find(1).kind_of?(Firm), "37signals should be a firm"
-    assert Firm.find(1).kind_of?(Firm), "37signals should be a firm"
-    assert Company.find(2).kind_of?(Client), "Summit should be a client"
-    assert Client.find(2).kind_of?(Client), "Summit should be a client"
-  end
-
-  def test_alt_inheritance_find
-    switch_to_alt_inheritance_column
-    test_inheritance_find
-    switch_to_default_inheritance_column
-  end
-
-  def test_inheritance_find_all
-    companies = Company.find(:all, :order => 'id')
-    assert companies[0].kind_of?(Firm), "37signals should be a firm"
-    assert companies[1].kind_of?(Client), "Summit should be a client"
-  end
-
-  def test_alt_inheritance_find_all
-    switch_to_alt_inheritance_column
-    test_inheritance_find_all
-    switch_to_default_inheritance_column
-  end
-
-  def test_inheritance_save
-    firm = Firm.new
-    firm.name = "Next Angle"
-    firm.save
-
-    next_angle = Company.find(firm.id)
-    assert next_angle.kind_of?(Firm), "Next Angle should be a firm"
-  end
-
-  def test_alt_inheritance_save
-    switch_to_alt_inheritance_column
-    test_inheritance_save
-    switch_to_default_inheritance_column
-  end
-
-  def test_inheritance_condition
-    assert_equal 9, Company.count
-    assert_equal 2, Firm.count
-    assert_equal 3, Client.count
-  end
-
-  def test_alt_inheritance_condition
-    switch_to_alt_inheritance_column
-    test_inheritance_condition
-    switch_to_default_inheritance_column
-  end
-
-  def test_finding_incorrect_type_data
-    assert_raise(ActiveRecord::RecordNotFound) { Firm.find(2) }
-    assert_nothing_raised   { Firm.find(1) }
-  end
-
-  def test_alt_finding_incorrect_type_data
-    switch_to_alt_inheritance_column
-    test_finding_incorrect_type_data
-    switch_to_default_inheritance_column
-  end
-
-  def test_update_all_within_inheritance
-    Client.update_all "name = 'I am a client'"
-    assert_equal "I am a client", Client.find(:all).first.name
-    assert_equal "37signals", Firm.find(:all).first.name
-  end
-
-  def test_alt_update_all_within_inheritance
-    switch_to_alt_inheritance_column
-    test_update_all_within_inheritance
-    switch_to_default_inheritance_column
-  end
-
-  def test_destroy_all_within_inheritance
-    Client.destroy_all
-    assert_equal 0, Client.count
-    assert_equal 2, Firm.count
-  end
-
-  def test_alt_destroy_all_within_inheritance
-    switch_to_alt_inheritance_column
-    test_destroy_all_within_inheritance
-    switch_to_default_inheritance_column
-  end
-
-  def test_find_first_within_inheritance
-    assert_kind_of Firm, Company.find(:first, :conditions => "name = '37signals'")
-    assert_kind_of Firm, Firm.find(:first, :conditions => "name = '37signals'")
-    assert_nil Client.find(:first, :conditions => "name = '37signals'")
-  end
-
-  def test_alt_find_first_within_inheritance
-    switch_to_alt_inheritance_column
-    test_find_first_within_inheritance
-    switch_to_default_inheritance_column
-  end
-
-  def test_complex_inheritance
-    very_special_client = VerySpecialClient.create("name" => "veryspecial")
-    assert_equal very_special_client, VerySpecialClient.find(:first, :conditions => "name = 'veryspecial'")
-    assert_equal very_special_client, SpecialClient.find(:first, :conditions => "name = 'veryspecial'")
-    assert_equal very_special_client, Company.find(:first, :conditions => "name = 'veryspecial'")
-    assert_equal very_special_client, Client.find(:first, :conditions => "name = 'veryspecial'")
-    assert_equal 1, Client.find(:all, :conditions => "name = 'Summit'").size
-    assert_equal very_special_client, Client.find(very_special_client.id)
-  end
-
-  def test_alt_complex_inheritance
-    switch_to_alt_inheritance_column
-    test_complex_inheritance
-    switch_to_default_inheritance_column
-  end
-
-  def test_eager_load_belongs_to_something_inherited
-    account = Account.find(1, :include => :firm)
-    assert_not_nil account.instance_variable_get("@firm"), "nil proves eager load failed"
-  end
-
-  def test_eager_load_belongs_to_primary_key_quoting
-    con = Account.connection
-    assert_sql(/\(#{con.quote_table_name('companies')}.#{con.quote_column_name('id')} = 1\)/) do
-      Account.find(1, :include => :firm)
-    end
-  end
-
-  def test_alt_eager_loading
-    switch_to_alt_inheritance_column
-    test_eager_load_belongs_to_something_inherited
-    switch_to_default_inheritance_column
-  end
-
-  def test_inheritance_without_mapping
-    assert_kind_of SpecialSubscriber, SpecialSubscriber.find("webster132")
-    assert_nothing_raised { s = SpecialSubscriber.new("name" => "And breaaaaathe!"); s.id = 'roger'; s.save }
-  end
-
-  private
-    def switch_to_alt_inheritance_column
-      # we don't want misleading test results, so get rid of the values in the type column
-      Company.find(:all, :order => 'id').each do |c|
-        c['type'] = nil
-        c.save
-      end
-      [ Company, Firm, Client].each { |klass| klass.reset_column_information }
-      Company.set_inheritance_column('ruby_type')
-    end
-    def switch_to_default_inheritance_column
-      [ Company, Firm, Client].each { |klass| klass.reset_column_information }
-      Company.set_inheritance_column('type')
-    end
-end
-
-
-class InheritanceComputeTypeTest < ActiveRecord::TestCase
-  fixtures :companies
-
-  def setup
-    ActiveSupport::Dependencies.log_activity = true
-  end
-
-  def teardown
-    ActiveSupport::Dependencies.log_activity = false
-    self.class.const_remove :FirmOnTheFly rescue nil
-    Firm.const_remove :FirmOnTheFly rescue nil
-  end
-
-  def test_instantiation_doesnt_try_to_require_corresponding_file
-    foo = Firm.find(:first).clone
-    foo.ruby_type = foo.type = 'FirmOnTheFly'
-    foo.save!
-
-    # Should fail without FirmOnTheFly in the type condition.
-    assert_raise(ActiveRecord::RecordNotFound) { Firm.find(foo.id) }
-
-    # Nest FirmOnTheFly in the test case where Dependencies won't see it.
-    self.class.const_set :FirmOnTheFly, Class.new(Firm)
-    assert_raise(ActiveRecord::SubclassNotFound) { Firm.find(foo.id) }
-
-    # Nest FirmOnTheFly in Firm where Dependencies will see it.
-    # This is analogous to nesting models in a migration.
-    Firm.const_set :FirmOnTheFly, Class.new(Firm)
-
-    # And instantiate will find the existing constant rather than trying
-    # to require firm_on_the_fly.
-    assert_nothing_raised { assert_kind_of Firm::FirmOnTheFly, Firm.find(foo.id) }
-  end
-end

data/test/cases/invalid_date_test.rb

@@ -1,24 +0,0 @@
-require 'cases/helper'
-require 'models/topic'
-
-class InvalidDateTest < Test::Unit::TestCase
-  def test_assign_valid_dates
-    valid_dates = [[2007, 11, 30], [1993, 2, 28], [2008, 2, 29]]
-
-    invalid_dates = [[2007, 11, 31], [1993, 2, 29], [2007, 2, 29]]
-
-    topic = Topic.new
-
-    valid_dates.each do |date_src|
-      topic = Topic.new("last_read(1i)" => date_src[0].to_s, "last_read(2i)" => date_src[1].to_s, "last_read(3i)" => date_src[2].to_s)
-      assert_equal(topic.last_read, Date.new(*date_src))
-    end
-
-    invalid_dates.each do |date_src|
-      assert_nothing_raised do
-        topic = Topic.new({"last_read(1i)" => date_src[0].to_s, "last_read(2i)" => date_src[1].to_s, "last_read(3i)" => date_src[2].to_s})
-        assert_equal(topic.last_read, Time.local(*date_src).to_date, "The date should be modified according to the behaviour of the Time object")
-      end
-    end
-  end
-end

data/test/cases/json_serialization_test.rb

@@ -1,219 +0,0 @@
-require "cases/helper"
-require 'models/contact'
-require 'models/post'
-require 'models/author'
-require 'models/tagging'
-require 'models/tag'
-require 'models/comment'
-
-class JsonSerializationTest < ActiveRecord::TestCase
-  class NamespacedContact < Contact
-    column :name,        :string
-  end
-
-  def setup
-    @contact = Contact.new(
-      :name        => 'Konata Izumi',
-      :age         => 16,
-      :avatar      => 'binarydata',
-      :created_at  => Time.utc(2006, 8, 1),
-      :awesome     => true,
-      :preferences => { :shows => 'anime' }
-    )
-  end
-
-  def test_should_demodulize_root_in_json
-    NamespacedContact.include_root_in_json = true
-    @contact = NamespacedContact.new :name => 'whatever'
-    json = @contact.to_json
-    assert_match %r{^\{"namespaced_contact":\{}, json
-  end
-
-  def test_should_include_root_in_json
-    Contact.include_root_in_json = true
-    json = @contact.to_json
-
-    assert_match %r{^\{"contact":\{}, json
-    assert_match %r{"name":"Konata Izumi"}, json
-    assert_match %r{"age":16}, json
-    assert json.include?(%("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
-    assert_match %r{"awesome":true}, json
-    assert_match %r{"preferences":\{"shows":"anime"\}}, json
-  ensure
-    Contact.include_root_in_json = false
-  end
-
-  def test_should_include_root_in_json
-    Contact.include_root_in_json = true
-    json = @contact.to_json(:root => 'json_contact')
-
-    assert_match %r{^\{"json_contact":\{}, json
-    assert_match %r{"name":"Konata Izumi"}, json
-    assert_match %r{"age":16}, json
-    assert json.include?(%("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
-    assert_match %r{"awesome":true}, json
-    assert_match %r{"preferences":\{"shows":"anime"\}}, json
-  ensure
-    Contact.include_root_in_json = false
-  end
-
-  def test_should_encode_all_encodable_attributes
-    json = @contact.to_json
-
-    assert_match %r{"name":"Konata Izumi"}, json
-    assert_match %r{"age":16}, json
-    assert json.include?(%("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
-    assert_match %r{"awesome":true}, json
-    assert_match %r{"preferences":\{"shows":"anime"\}}, json
-  end
-
-  def test_should_allow_attribute_filtering_with_only
-    json = @contact.to_json(:only => [:name, :age])
-
-    assert_match %r{"name":"Konata Izumi"}, json
-    assert_match %r{"age":16}, json
-    assert_no_match %r{"awesome":true}, json
-    assert !json.include?(%("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
-    assert_no_match %r{"preferences":\{"shows":"anime"\}}, json
-  end
-
-  def test_should_allow_attribute_filtering_with_except
-    json = @contact.to_json(:except => [:name, :age])
-
-    assert_no_match %r{"name":"Konata Izumi"}, json
-    assert_no_match %r{"age":16}, json
-    assert_match %r{"awesome":true}, json
-    assert json.include?(%("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
-    assert_match %r{"preferences":\{"shows":"anime"\}}, json
-  end
-
-  def test_methods_are_called_on_object
-    # Define methods on fixture.
-    def @contact.label; "Has cheezburger"; end
-    def @contact.favorite_quote; "Constraints are liberating"; end
-
-    # Single method.
-    assert_match %r{"label":"Has cheezburger"}, @contact.to_json(:only => :name, :methods => :label)
-
-    # Both methods.
-    methods_json = @contact.to_json(:only => :name, :methods => [:label, :favorite_quote])
-    assert_match %r{"label":"Has cheezburger"}, methods_json
-    assert_match %r{"favorite_quote":"Constraints are liberating"}, methods_json
-  end
-end
-
-class DatabaseConnectedJsonEncodingTest < ActiveRecord::TestCase
-  fixtures :authors, :posts, :comments, :tags, :taggings
-
-  def setup
-    @david = authors(:david)
-    @mary = authors(:mary)
-  end
-
-  def test_includes_uses_association_name
-    json = @david.to_json(:include => :posts)
-
-    assert_match %r{"posts":\[}, json
-
-    assert_match %r{"id":1}, json
-    assert_match %r{"name":"David"}, json
-
-    assert_match %r{"author_id":1}, json
-    assert_match %r{"title":"Welcome to the weblog"}, json
-    assert_match %r{"body":"Such a lovely day"}, json
-
-    assert_match %r{"title":"So I was thinking"}, json
-    assert_match %r{"body":"Like I hopefully always am"}, json
-  end
-
-  def test_includes_uses_association_name_and_applies_attribute_filters
-    json = @david.to_json(:include => { :posts => { :only => :title } })
-
-    assert_match %r{"name":"David"}, json
-    assert_match %r{"posts":\[}, json
-
-    assert_match %r{"title":"Welcome to the weblog"}, json
-    assert_no_match %r{"body":"Such a lovely day"}, json
-
-    assert_match %r{"title":"So I was thinking"}, json
-    assert_no_match %r{"body":"Like I hopefully always am"}, json
-  end
-
-  def test_includes_fetches_second_level_associations
-    json = @david.to_json(:include => { :posts => { :include => { :comments => { :only => :body } } } })
-
-    assert_match %r{"name":"David"}, json
-    assert_match %r{"posts":\[}, json
-
-    assert_match %r{"comments":\[}, json
-    assert_match %r{\{"body":"Thank you again for the welcome"\}}, json
-    assert_match %r{\{"body":"Don't think too hard"\}}, json
-    assert_no_match %r{"post_id":}, json
-  end
-
-  def test_includes_fetches_nth_level_associations
-    json = @david.to_json(
-      :include => {
-        :posts => {
-          :include => {
-            :taggings => {
-              :include => {
-                :tag => { :only => :name }
-              }
-            }
-          }
-        }
-    })
-
-    assert_match %r{"name":"David"}, json
-    assert_match %r{"posts":\[}, json
-
-    assert_match %r{"taggings":\[}, json
-    assert_match %r{"tag":\{"name":"General"\}}, json
-  end
-
-  def test_should_not_call_methods_on_associations_that_dont_respond
-    def @david.favorite_quote; "Constraints are liberating"; end
-    json = @david.to_json(:include => :posts, :methods => :favorite_quote)
-
-    assert !@david.posts.first.respond_to?(:favorite_quote)
-    assert_match %r{"favorite_quote":"Constraints are liberating"}, json
-    assert_equal %r{"favorite_quote":}.match(json).size, 1
-  end
-
-  def test_should_allow_only_option_for_list_of_authors
-    authors = [@david, @mary]
-
-    assert_equal %([{"name":"David"},{"name":"Mary"}]), ActiveSupport::JSON.encode(authors, :only => :name)
-  end
-
-  def test_should_allow_except_option_for_list_of_authors
-    authors = [@david, @mary]
-
-    assert_equal %([{"id":1},{"id":2}]), ActiveSupport::JSON.encode(authors, :except => [:name, :author_address_id, :author_address_extra_id])
-  end
-
-  def test_should_allow_includes_for_list_of_authors
-    authors = [@david, @mary]
-    json = ActiveSupport::JSON.encode(authors,
-      :only => :name,
-      :include => {
-        :posts => { :only => :id }
-      }
-    )
-
-    ['"name":"David"', '"posts":[', '{"id":1}', '{"id":2}', '{"id":4}',
-     '{"id":5}', '{"id":6}', '"name":"Mary"', '"posts":[{"id":7}]'].each do |fragment|
-      assert json.include?(fragment), json
-     end
-  end
-
-  def test_should_allow_options_for_hash_of_authors
-    authors_hash = {
-      1 => @david,
-      2 => @mary
-    }
-
-    assert_equal %({"1":{"name":"David"}}), ActiveSupport::JSON.encode(authors_hash, :only => [1, :name])
-  end
-end