RubyGems - rq - Versions diffs - 3.4.0 → 3.5.0 - Mend

rq 3.4.0 → 3.5.0

Files changed (1063) hide show

data/rails/vendor/rails/activerecord/test/inheritance_test.rb DELETED

@@ -1,205 +0,0 @@
-require 'abstract_unit'
-require 'fixtures/company'
-require 'fixtures/project'
-require 'fixtures/subscriber'
-class InheritanceTest < Test::Unit::TestCase
-  fixtures :companies, :projects, :subscribers, :accounts
-  def test_a_bad_type_column
-    #SQLServer need to turn Identity Insert On before manually inserting into the Identity column
-    if current_adapter?(:SQLServerAdapter, :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?(:SQLServerAdapter, :SybaseAdapter)
-      Company.connection.execute "SET IDENTITY_INSERT companies OFF"
-    end
-    assert_raises(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_raises(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_alt_eager_loading
-    switch_to_alt_inheritance_column
-    test_eager_load_belongs_to_something_inherited
-    switch_to_default_inheritance_column
-    ActiveRecord::Base.logger.debug "cocksucker"
-  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 < Test::Unit::TestCase
-  fixtures :companies
-  def setup
-    Dependencies.log_activity = true
-  end
-  def teardown
-    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/rails/vendor/rails/activerecord/test/lifecycle_test.rb DELETED

@@ -1,137 +0,0 @@
-require 'abstract_unit'
-require 'fixtures/topic'
-require 'fixtures/developer'
-require 'fixtures/reply'
-class Topic; def after_find() end end
-class Developer; def after_find() end end
-class SpecialDeveloper < Developer; end
-class TopicManualObserver
-  include Singleton
-  attr_reader :action, :object, :callbacks
-  def initialize
-    Topic.add_observer(self)
-    @callbacks = []
-  end
-  def update(callback_method, object)
-    @callbacks << { "callback_method" => callback_method, "object" => object }
-  end
-  def has_been_notified?
-    !@callbacks.empty?
-  end
-end
-class TopicaObserver < ActiveRecord::Observer
-  def self.observed_class() Topic end
-  attr_reader :topic
-  def after_find(topic)
-    @topic = topic
-  end
-end
-class TopicObserver < ActiveRecord::Observer
-  attr_reader :topic
-  def after_find(topic)
-    @topic = topic
-  end
-end
-class MultiObserver < ActiveRecord::Observer
-  attr_reader :record
-  def self.observed_class() [ Topic, Developer ] end
-  cattr_reader :last_inherited
-  @@last_inherited = nil
-  def observed_class_inherited_with_testing(subclass)
-    observed_class_inherited_without_testing(subclass)
-    @@last_inherited = subclass
-  end
-  alias_method_chain :observed_class_inherited, :testing
-  def after_find(record)
-    @record = record
-  end
-end
-class LifecycleTest < Test::Unit::TestCase
-  fixtures :topics, :developers
-  def test_before_destroy
-    assert_equal 2, Topic.count
-    Topic.find(1).destroy
-    assert_equal 0, Topic.count
-  end
-  def test_after_save
-    ActiveRecord::Base.observers = :topic_manual_observer
-    ActiveRecord::Base.instantiate_observers
-    topic = Topic.find(1)
-    topic.title = "hello"
-    topic.save
-    assert TopicManualObserver.instance.has_been_notified?
-    assert_equal :after_save, TopicManualObserver.instance.callbacks.last["callback_method"]
-  end
-  def test_observer_update_on_save
-    ActiveRecord::Base.observers = TopicManualObserver
-    ActiveRecord::Base.instantiate_observers
-    topic = Topic.find(1)
-    assert TopicManualObserver.instance.has_been_notified?
-    assert_equal :after_find, TopicManualObserver.instance.callbacks.first["callback_method"]
-  end
-  def test_auto_observer
-    topic_observer = TopicaObserver.instance
-    topic = Topic.find(1)
-    assert_equal topic.title, topic_observer.topic.title
-  end
-  def test_inferred_auto_observer
-    topic_observer = TopicObserver.instance
-    topic = Topic.find(1)
-    assert_equal topic.title, topic_observer.topic.title
-  end
-  def test_observing_two_classes
-    multi_observer = MultiObserver.instance
-    topic = Topic.find(1)
-    assert_equal topic.title, multi_observer.record.title
-    developer = Developer.find(1)
-    assert_equal developer.name, multi_observer.record.name
-  end
-  def test_observing_subclasses
-    multi_observer = MultiObserver.instance
-    developer = SpecialDeveloper.find(1)
-    assert_equal developer.name, multi_observer.record.name
-    klass = Class.new(Developer)
-    assert_equal klass, multi_observer.last_inherited
-    developer = klass.find(1)
-    assert_equal developer.name, multi_observer.record.name
-  end
-  def test_invalid_observer
-    assert_raise(ArgumentError) { Topic.observers = Object.new; Topic.instantiate_observers }
-  end
-end

data/rails/vendor/rails/activerecord/test/locking_test.rb DELETED

@@ -1,190 +0,0 @@
-require 'abstract_unit'
-require 'fixtures/person'
-require 'fixtures/legacy_thing'
-class LockWithoutDefault < ActiveRecord::Base; end
-class LockWithCustomColumnWithoutDefault < ActiveRecord::Base
-  set_table_name :lock_without_defaults_cust
-  set_locking_column :custom_lock_version
-end
-class OptimisticLockingTest < Test::Unit::TestCase
-  fixtures :people, :legacy_things
-  def test_lock_existing
-    p1 = Person.find(1)
-    p2 = Person.find(1)
-    assert_equal 0, p1.lock_version
-    assert_equal 0, p2.lock_version
-    p1.save!
-    assert_equal 1, p1.lock_version
-    assert_equal 0, p2.lock_version
-    assert_raises(ActiveRecord::StaleObjectError) { p2.save! }
-  end
-  def test_lock_new
-    p1 = Person.new(:first_name => 'anika')
-    assert_equal 0, p1.lock_version
-    p1.save!
-    p2 = Person.find(p1.id)
-    assert_equal 0, p1.lock_version
-    assert_equal 0, p2.lock_version
-    p1.save!
-    assert_equal 1, p1.lock_version
-    assert_equal 0, p2.lock_version
-    assert_raises(ActiveRecord::StaleObjectError) { p2.save! }
-  end
-  def test_lock_column_name_existing
-    t1 = LegacyThing.find(1)
-    t2 = LegacyThing.find(1)
-    assert_equal 0, t1.version
-    assert_equal 0, t2.version
-    t1.save!
-    assert_equal 1, t1.version
-    assert_equal 0, t2.version
-    assert_raises(ActiveRecord::StaleObjectError) { t2.save! }
-  end
-  def test_lock_column_is_mass_assignable
-    p1 = Person.create(:first_name => 'bianca')
-    assert_equal 0, p1.lock_version
-    assert_equal p1.lock_version, Person.new(p1.attributes).lock_version
-    p1.save!
-    assert_equal 1, p1.lock_version
-    assert_equal p1.lock_version, Person.new(p1.attributes).lock_version
-  end
-  def test_lock_without_default_sets_version_to_zero
-    t1 = LockWithoutDefault.new
-    assert_equal 0, t1.lock_version
-  end
-  def test_lock_with_custom_column_without_default_sets_version_to_zero
-    t1 = LockWithCustomColumnWithoutDefault.new
-    assert_equal 0, t1.custom_lock_version
-  end
-end
-# TODO: test against the generated SQL since testing locking behavior itself
-# is so cumbersome. Will deadlock Ruby threads if the underlying db.execute
-# blocks, so separate script called by Kernel#system is needed.
-# (See exec vs. async_exec in the PostgreSQL adapter.)
-# TODO: The SQL Server and Sybase adapters currently have no support for pessimistic locking
-unless current_adapter?(:SQLServerAdapter, :SybaseAdapter)
-  class PessimisticLockingTest < Test::Unit::TestCase
-    self.use_transactional_fixtures = false
-    fixtures :people, :readers
-    def setup
-      # Avoid introspection queries during tests.
-      Person.columns; Reader.columns
-      @allow_concurrency = ActiveRecord::Base.allow_concurrency
-      ActiveRecord::Base.allow_concurrency = true
-    end
-    def teardown
-      ActiveRecord::Base.allow_concurrency = @allow_concurrency
-    end
-    # Test typical find.
-    def test_sane_find_with_lock
-      assert_nothing_raised do
-        Person.transaction do
-          Person.find 1, :lock => true
-        end
-      end
-    end
-    # Test scoped lock.
-    def test_sane_find_with_scoped_lock
-      assert_nothing_raised do
-        Person.transaction do
-          Person.with_scope(:find => { :lock => true }) do
-            Person.find 1
-          end
-        end
-      end
-    end
-    # PostgreSQL protests SELECT ... FOR UPDATE on an outer join.
-    unless current_adapter?(:PostgreSQLAdapter)
-      # Test locked eager find.
-      def test_eager_find_with_lock
-        assert_nothing_raised do
-          Person.transaction do
-            Person.find 1, :include => :readers, :lock => true
-          end
-        end
-      end
-    end
-    # Locking a record reloads it.
-    def test_sane_lock_method
-      assert_nothing_raised do
-        Person.transaction do
-          person = Person.find 1
-          old, person.first_name = person.first_name, 'fooman'
-          person.lock!
-          assert_equal old, person.first_name
-        end
-      end
-    end
-    if current_adapter?(:PostgreSQLAdapter, :OracleAdapter)
-      def test_no_locks_no_wait
-        first, second = duel { Person.find 1 }
-        assert first.end > second.end
-      end
-      def test_second_lock_waits
-        assert [0.2, 1, 5].any? { |zzz|
-          first, second = duel(zzz) { Person.find 1, :lock => true }
-          second.end > first.end
-        }
-      end
-      protected
-        def duel(zzz = 5)
-          t0, t1, t2, t3 = nil, nil, nil, nil
-          a = Thread.new do
-            t0 = Time.now
-            Person.transaction do
-              yield
-              sleep zzz       # block thread 2 for zzz seconds
-            end
-            t1 = Time.now
-          end
-          b = Thread.new do
-            sleep zzz / 2.0   # ensure thread 1 tx starts first
-            t2 = Time.now
-            Person.transaction { yield }
-            t3 = Time.now
-          end
-          a.join
-          b.join
-          assert t1 > t0 + zzz
-          assert t2 > t0
-          assert t3 > t2
-          [t0.to_f..t1.to_f, t2.to_f..t3.to_f]
-        end
-    end
-  end
-end