rq 3.4.0 → 3.5.0

data/rails/vendor/rails/activerecord/test/abstract_unit.rb

@@ -1,77 +0,0 @@
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-$:.unshift(File.dirname(__FILE__) + '/../../activesupport/lib')
-
-require 'test/unit'
-require 'active_record'
-require 'active_record/fixtures'
-require 'active_support/binding_of_caller'
-require 'active_support/breakpoint'
-require 'connection'
-
-# Show backtraces for deprecated behavior for quicker cleanup.
-ActiveSupport::Deprecation.debug = true
-
-
-QUOTED_TYPE = ActiveRecord::Base.connection.quote_column_name('type') unless Object.const_defined?(:QUOTED_TYPE)
-
-class Test::Unit::TestCase #:nodoc:
-  self.fixture_path = File.dirname(__FILE__) + "/fixtures/"
-  self.use_instantiated_fixtures = false
-  self.use_transactional_fixtures = (ENV['AR_NO_TX_FIXTURES'] != "yes")
-
-  def create_fixtures(*table_names, &block)
-    Fixtures.create_fixtures(File.dirname(__FILE__) + "/fixtures/", table_names, {}, &block)
-  end
-
-  def assert_date_from_db(expected, actual, message = nil)
-    # SQL Server doesn't have a separate column type just for dates,
-    # so the time is in the string and incorrectly formatted
-    if current_adapter?(:SQLServerAdapter)
-      assert_equal expected.strftime("%Y/%m/%d 00:00:00"), actual.strftime("%Y/%m/%d 00:00:00")
-    elsif current_adapter?(:SybaseAdapter)
-      assert_equal expected.to_s, actual.to_date.to_s, message
-    else
-      assert_equal expected.to_s, actual.to_s, message
-    end
-  end
-
-  def assert_queries(num = 1)
-    ActiveRecord::Base.connection.class.class_eval do
-      self.query_count = 0
-      alias_method :execute, :execute_with_query_counting
-    end
-    yield
-  ensure
-    ActiveRecord::Base.connection.class.class_eval do
-      alias_method :execute, :execute_without_query_counting
-    end
-    assert_equal num, ActiveRecord::Base.connection.query_count, "#{ActiveRecord::Base.connection.query_count} instead of #{num} queries were executed."
-  end
-
-  def assert_no_queries(&block)
-    assert_queries(0, &block)
-  end
-end
-
-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
-  cattr_accessor :query_count
-
-  # Array of regexes of queries that are not counted against query_count
-  @@ignore_list = [/^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/]
-
-  alias_method :execute_without_query_counting, :execute
-  def execute_with_query_counting(sql, name = nil, &block)
-    self.query_count += 1 unless @@ignore_list.any? { |r| sql =~ r }
-    execute_without_query_counting(sql, name, &block)
-  end
-end
-
-#ActiveRecord::Base.logger = Logger.new(STDOUT)
-#ActiveRecord::Base.colorize_logging = false

data/rails/vendor/rails/activerecord/test/active_schema_test_mysql.rb

@@ -1,31 +0,0 @@
-require 'abstract_unit'
-
-class ActiveSchemaTest < Test::Unit::TestCase
-  def setup
-    ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do
-      alias_method :real_execute, :execute
-      def execute(sql, name = nil) return sql end
-    end    
-  end
-  
-  def teardown
-    ActiveRecord::ConnectionAdapters::MysqlAdapter.send(:alias_method, :execute, :real_execute)
-  end
-
-  def test_drop_table
-    assert_equal "DROP TABLE people", drop_table(:people)
-  end
-  
-  def test_add_column
-    assert_equal "ALTER TABLE people ADD `last_name` varchar(255)", add_column(:people, :last_name, :string)
-  end
-  
-  def test_add_column_with_limit
-    assert_equal "ALTER TABLE people ADD `key` varchar(32)", add_column(:people, :key, :string, :limit => 32)
-  end
-  
-  private
-    def method_missing(method_symbol, *arguments)
-      ActiveRecord::Base.connection.send(method_symbol, *arguments)
-    end
-end

data/rails/vendor/rails/activerecord/test/adapter_test.rb

@@ -1,87 +0,0 @@
-require 'abstract_unit'
-
-class AdapterTest < Test::Unit::TestCase
-  def setup
-    @connection = ActiveRecord::Base.connection
-  end
-
-  def test_tables
-    if @connection.respond_to?(:tables)
-      tables = @connection.tables
-      assert tables.include?("accounts")
-      assert tables.include?("authors")
-      assert tables.include?("tasks")
-      assert tables.include?("topics")
-    else
-      warn "#{@connection.class} does not respond to #tables"
-    end
-  end
-
-  def test_indexes
-    idx_name = "accounts_idx"
-      
-    if @connection.respond_to?(:indexes)
-      indexes = @connection.indexes("accounts")
-      assert indexes.empty?
-
-      @connection.add_index :accounts, :firm_id, :name => idx_name
-      indexes = @connection.indexes("accounts")
-      assert_equal "accounts", indexes.first.table
-      # OpenBase does not have the concept of a named index
-      # Indexes are merely properties of columns.
-      assert_equal idx_name, indexes.first.name unless current_adapter?(:OpenBaseAdapter)
-      assert !indexes.first.unique
-      assert_equal ["firm_id"], indexes.first.columns
-    else
-      warn "#{@connection.class} does not respond to #indexes"
-    end
-
-  ensure
-    @connection.remove_index(:accounts, :name => idx_name) rescue nil
-  end
-  
-  def test_current_database
-    if @connection.respond_to?(:current_database)
-      assert_equal ENV['ARUNIT_DB_NAME'] || "activerecord_unittest", @connection.current_database
-    end
-  end
-
-  def test_table_alias
-    def @connection.test_table_alias_length() 10; end
-    class << @connection
-      alias_method :old_table_alias_length, :table_alias_length
-      alias_method :table_alias_length,     :test_table_alias_length
-    end
-      
-    assert_equal 'posts',      @connection.table_alias_for('posts')
-    assert_equal 'posts_comm', @connection.table_alias_for('posts_comments')
-    assert_equal 'dbo_posts',  @connection.table_alias_for('dbo.posts')
-    
-    class << @connection
-      alias_method :table_alias_length, :old_table_alias_length
-    end
-  end
-
-  # test resetting sequences in odd tables in postgreSQL
-  if ActiveRecord::Base.connection.respond_to?(:reset_pk_sequence!)
-    require 'fixtures/movie'
-    require 'fixtures/subscriber'
-    
-    def test_reset_empty_table_with_custom_pk
-      Movie.delete_all
-      Movie.connection.reset_pk_sequence! 'movies'
-      assert_equal 1, Movie.create(:name => 'fight club').id
-    end
-
-    if ActiveRecord::Base.connection.adapter_name != "FrontBase"
-      def test_reset_table_with_non_integer_pk
-        Subscriber.delete_all
-        Subscriber.connection.reset_pk_sequence! 'subscribers'
-        sub = Subscriber.new(:name => 'robert drake')
-        sub.id = 'bob drake'
-        assert_nothing_raised { sub.save! }
-      end
-    end
-  end
-
-end

data/rails/vendor/rails/activerecord/test/adapter_test_sqlserver.rb

@@ -1,81 +0,0 @@
-require 'abstract_unit'
-require 'fixtures/default'
-require 'fixtures/post'
-require 'fixtures/task'
-
-class SqlServerAdapterTest < Test::Unit::TestCase
-  fixtures :posts, :tasks
-
-  def setup
-    @connection = ActiveRecord::Base.connection
-  end
-
-  def teardown
-    @connection.execute("SET LANGUAGE us_english")
-  end
-
-  # SQL Server 2000 has a bug where some unambiguous date formats are not 
-  # correctly identified if the session language is set to german
-  def test_date_insertion_when_language_is_german
-    @connection.execute("SET LANGUAGE deutsch")
-
-    assert_nothing_raised do
-      Task.create(:starting => Time.utc(2000, 1, 31, 5, 42, 0), :ending => Date.new(2006, 12, 31))
-    end
-  end
-
-  def test_execute_without_block_closes_statement
-    assert_all_statements_used_are_closed do
-      @connection.execute("SELECT 1")
-    end
-  end
-  
-  def test_execute_with_block_closes_statement
-    assert_all_statements_used_are_closed do
-      @connection.execute("SELECT 1") do |sth|
-        assert !sth.finished?, "Statement should still be alive within block"
-      end
-    end
-  end
-  
-  def test_insert_with_identity_closes_statement
-    assert_all_statements_used_are_closed do
-      @connection.insert("INSERT INTO accounts ([id], [firm_id],[credit_limit]) values (999, 1, 50)")
-    end
-  end
-  
-  def test_insert_without_identity_closes_statement
-    assert_all_statements_used_are_closed do
-      @connection.insert("INSERT INTO accounts ([firm_id],[credit_limit]) values (1, 50)")
-    end
-  end
-  
-  def test_active_closes_statement
-    assert_all_statements_used_are_closed do
-      @connection.active?
-    end
-  end 
-
-  def assert_all_statements_used_are_closed(&block)
-    existing_handles = []
-    ObjectSpace.each_object(DBI::StatementHandle) {|handle| existing_handles << handle}
-    GC.disable
-    
-    yield
-    
-    used_handles = []
-    ObjectSpace.each_object(DBI::StatementHandle) {|handle| used_handles << handle unless existing_handles.include? handle}
-         
-    assert_block "No statements were used within given block" do
-      used_handles.size > 0
-    end
-    
-    ObjectSpace.each_object(DBI::StatementHandle) do |handle|
-      assert_block "Statement should have been closed within given block" do 
-        handle.finished?
-      end      
-    end
-  ensure
-    GC.enable
-  end
-end

data/rails/vendor/rails/activerecord/test/aggregations_test.rb

@@ -1,95 +0,0 @@
-require 'abstract_unit'
-require 'fixtures/customer'
-
-class AggregationsTest < Test::Unit::TestCase
-  fixtures :customers
-
-  def test_find_single_value_object
-    assert_equal 50, customers(:david).balance.amount
-    assert_kind_of Money, customers(:david).balance
-    assert_equal 300, customers(:david).balance.exchange_to("DKK").amount
-  end
-  
-  def test_find_multiple_value_object
-    assert_equal customers(:david).address_street, customers(:david).address.street
-    assert(
-      customers(:david).address.close_to?(Address.new("Different Street", customers(:david).address_city, customers(:david).address_country))
-    )
-  end
-  
-  def test_change_single_value_object
-    customers(:david).balance = Money.new(100)
-    customers(:david).save
-    assert_equal 100, Customer.find(1).balance.amount
-  end
-  
-  def test_immutable_value_objects
-    customers(:david).balance = Money.new(100)
-    assert_raises(TypeError) {  customers(:david).balance.instance_eval { @amount = 20 } }
-  end  
-  
-  def test_inferred_mapping
-    assert_equal "35.544623640962634", customers(:david).gps_location.latitude
-    assert_equal "-105.9309951055148", customers(:david).gps_location.longitude
-    
-    customers(:david).gps_location = GpsLocation.new("39x-110")
-
-    assert_equal "39", customers(:david).gps_location.latitude
-    assert_equal "-110", customers(:david).gps_location.longitude
-    
-    customers(:david).save
-    
-    customers(:david).reload
-
-    assert_equal "39", customers(:david).gps_location.latitude
-    assert_equal "-110", customers(:david).gps_location.longitude
-  end
-
-  def test_reloaded_instance_refreshes_aggregations
-    assert_equal "35.544623640962634", customers(:david).gps_location.latitude
-    assert_equal "-105.9309951055148", customers(:david).gps_location.longitude
-
-    Customer.update_all("gps_location = '24x113'")
-    customers(:david).reload
-    assert_equal '24x113', customers(:david)['gps_location']
-
-    assert_equal GpsLocation.new('24x113'), customers(:david).gps_location 
-  end
-
-  def test_gps_equality
-    assert GpsLocation.new('39x110') == GpsLocation.new('39x110')
-  end
-
-  def test_gps_inequality
-    assert GpsLocation.new('39x110') != GpsLocation.new('39x111')
-  end
-  
-  def test_allow_nil_gps_is_nil
-    assert_equal nil, customers(:zaphod).gps_location
-  end
-  
-  def test_allow_nil_gps_set_to_nil
-    customers(:david).gps_location = nil
-    customers(:david).save
-    customers(:david).reload
-    assert_equal nil, customers(:david).gps_location
-  end
-  
-  def test_allow_nil_set_address_attributes_to_nil
-    customers(:zaphod).address = nil
-    assert_equal nil, customers(:zaphod).attributes[:address_street]
-    assert_equal nil, customers(:zaphod).attributes[:address_city]
-    assert_equal nil, customers(:zaphod).attributes[:address_country]
-  end
-  
-  def test_allow_nil_address_set_to_nil
-    customers(:zaphod).address = nil
-    customers(:zaphod).save
-    customers(:zaphod).reload
-    assert_equal nil, customers(:zaphod).address
-  end
-  
-  def test_nil_raises_error_when_allow_nil_is_false
-    assert_raises(NoMethodError) { customers(:david).balance = nil }
-  end
-end

data/rails/vendor/rails/activerecord/test/all.sh

@@ -1,8 +0,0 @@
-#!/bin/sh
-
-if [ -z "$1" ]; then
-	echo "Usage: $0 connections/<db_library>" 1>&2
-	exit 1
-fi
-
-ruby -I $1 -e 'Dir.foreach(".") { |file| require file if file =~ /_test.rb$/ }'

data/rails/vendor/rails/activerecord/test/ar_schema_test.rb

@@ -1,33 +0,0 @@
-require 'abstract_unit'
-require "#{File.dirname(__FILE__)}/../lib/active_record/schema"
-
-if ActiveRecord::Base.connection.supports_migrations? 
-
-  class ActiveRecordSchemaTest < Test::Unit::TestCase
-    self.use_transactional_fixtures = false
-
-    def setup
-      @connection = ActiveRecord::Base.connection
-    end
-
-    def teardown
-      @connection.drop_table :fruits rescue nil
-    end
-
-    def test_schema_define
-      ActiveRecord::Schema.define(:version => 7) do
-        create_table :fruits do |t|
-          t.column :color, :string
-          t.column :fruit_size, :string  # NOTE: "size" is reserved in Oracle
-          t.column :texture, :string
-          t.column :flavor, :string
-        end
-      end
-
-      assert_nothing_raised { @connection.select_all "SELECT * FROM fruits" }
-      assert_nothing_raised { @connection.select_all "SELECT * FROM schema_info" }
-      assert_equal 7, @connection.select_one("SELECT version FROM schema_info")['version'].to_i
-    end
-  end
-
-end

data/rails/vendor/rails/activerecord/test/association_inheritance_reload.rb

@@ -1,14 +0,0 @@
-require 'abstract_unit'
-require 'fixtures/company'
-
-class AssociationInheritanceReloadTest < Test::Unit::TestCase
-  fixtures :companies
-
-  def test_set_attributes
-    assert_equal ["errors.add_on_empty('name', \"can't be empty\")"], Firm.read_inheritable_attribute("validate"), "Second run"
-    # ActiveRecord::Base.reset_column_information_and_inheritable_attributes_for_all_subclasses
-    remove_subclass_of(ActiveRecord::Base)
-    load 'fixtures/company.rb'
-    assert_equal ["errors.add_on_empty('name', \"can't be empty\")"], Firm.read_inheritable_attribute("validate"), "Second run"
-  end
-end

data/rails/vendor/rails/activerecord/test/associations/callbacks_test.rb

@@ -1,126 +0,0 @@
-require 'abstract_unit'
-require 'fixtures/post'
-require 'fixtures/comment'
-require 'fixtures/author'
-require 'fixtures/category'
-require 'fixtures/project'
-require 'fixtures/developer'
-
-class AssociationCallbacksTest < Test::Unit::TestCase
-  fixtures :posts, :authors, :projects, :developers
-
-  def setup
-    @david = authors(:david)
-    @thinking = posts(:thinking)
-    @authorless = posts(:authorless)
-    assert @david.post_log.empty?
-  end
-  
-  def test_adding_macro_callbacks
-    @david.posts_with_callbacks << @thinking
-    assert_equal ["before_adding#{@thinking.id}", "after_adding#{@thinking.id}"], @david.post_log
-    @david.posts_with_callbacks << @thinking
-    assert_equal ["before_adding#{@thinking.id}", "after_adding#{@thinking.id}", "before_adding#{@thinking.id}", 
-                  "after_adding#{@thinking.id}"], @david.post_log
-  end
-  
-  def test_adding_with_proc_callbacks
-    @david.posts_with_proc_callbacks << @thinking
-    assert_equal ["before_adding#{@thinking.id}", "after_adding#{@thinking.id}"], @david.post_log
-    @david.posts_with_proc_callbacks << @thinking
-    assert_equal ["before_adding#{@thinking.id}", "after_adding#{@thinking.id}", "before_adding#{@thinking.id}", 
-                  "after_adding#{@thinking.id}"], @david.post_log
-  end
-  
-  def test_removing_with_macro_callbacks
-    first_post, second_post = @david.posts_with_callbacks[0, 2]
-    @david.posts_with_callbacks.delete(first_post)
-    assert_equal ["before_removing#{first_post.id}", "after_removing#{first_post.id}"], @david.post_log
-    @david.posts_with_callbacks.delete(second_post)
-    assert_equal ["before_removing#{first_post.id}", "after_removing#{first_post.id}", "before_removing#{second_post.id}", 
-                  "after_removing#{second_post.id}"], @david.post_log
-  end
-
-  def test_removing_with_proc_callbacks
-    first_post, second_post = @david.posts_with_callbacks[0, 2]
-    @david.posts_with_proc_callbacks.delete(first_post)
-    assert_equal ["before_removing#{first_post.id}", "after_removing#{first_post.id}"], @david.post_log
-    @david.posts_with_proc_callbacks.delete(second_post)
-    assert_equal ["before_removing#{first_post.id}", "after_removing#{first_post.id}", "before_removing#{second_post.id}", 
-                  "after_removing#{second_post.id}"], @david.post_log
-  end
-  
-  def test_multiple_callbacks
-    @david.posts_with_multiple_callbacks << @thinking
-    assert_equal ["before_adding#{@thinking.id}", "before_adding_proc#{@thinking.id}", "after_adding#{@thinking.id}", 
-                  "after_adding_proc#{@thinking.id}"], @david.post_log
-    @david.posts_with_multiple_callbacks << @thinking
-    assert_equal ["before_adding#{@thinking.id}", "before_adding_proc#{@thinking.id}", "after_adding#{@thinking.id}", 
-                  "after_adding_proc#{@thinking.id}", "before_adding#{@thinking.id}", "before_adding_proc#{@thinking.id}", 
-                  "after_adding#{@thinking.id}", "after_adding_proc#{@thinking.id}"], @david.post_log
-  end
-  
-  def test_has_and_belongs_to_many_add_callback
-    david = developers(:david)
-    ar = projects(:active_record)
-    assert ar.developers_log.empty?
-    ar.developers_with_callbacks << david
-    assert_equal ["before_adding#{david.id}", "after_adding#{david.id}"], ar.developers_log
-    ar.developers_with_callbacks << david
-    assert_equal ["before_adding#{david.id}", "after_adding#{david.id}", "before_adding#{david.id}", 
-                  "after_adding#{david.id}"], ar.developers_log
-  end
-  
-  def test_has_and_belongs_to_many_remove_callback
-    david = developers(:david)
-    jamis = developers(:jamis)
-    activerecord = projects(:active_record)
-    assert activerecord.developers_log.empty?
-    activerecord.developers_with_callbacks.delete(david)
-    assert_equal ["before_removing#{david.id}", "after_removing#{david.id}"], activerecord.developers_log
-    
-    activerecord.developers_with_callbacks.delete(jamis)
-    assert_equal ["before_removing#{david.id}", "after_removing#{david.id}", "before_removing#{jamis.id}", 
-                  "after_removing#{jamis.id}"], activerecord.developers_log
-  end
-
-  def test_has_and_belongs_to_many_remove_callback_on_clear
-    activerecord = projects(:active_record)
-    assert activerecord.developers_log.empty?
-    if activerecord.developers_with_callbacks.size == 0
-      activerecord.developers << developers(:david)
-      activerecord.developers << developers(:jamis)
-      activerecord.reload
-      assert activerecord.developers_with_callbacks.size == 2
-    end
-    log_array = activerecord.developers_with_callbacks.collect {|d| ["before_removing#{d.id}","after_removing#{d.id}"]}.flatten.sort
-    assert activerecord.developers_with_callbacks.clear
-    assert_equal log_array, activerecord.developers_log.sort
-  end
-  
-  def test_dont_add_if_before_callback_raises_exception
-    assert !@david.unchangable_posts.include?(@authorless)
-    begin
-      @david.unchangable_posts << @authorless
-    rescue Exception => e
-    end
-    assert @david.post_log.empty?
-    assert !@david.unchangable_posts.include?(@authorless)
-    @david.reload
-    assert !@david.unchangable_posts.include?(@authorless)
-  end
-  
-  def test_push_with_attributes
-    assert_deprecated 'push_with_attributes' do
-      david = developers(:david)
-      activerecord = projects(:active_record)
-      assert activerecord.developers_log.empty?
-      activerecord.developers_with_callbacks.push_with_attributes(david, {})
-      assert_equal ["before_adding#{david.id}", "after_adding#{david.id}"], activerecord.developers_log
-      activerecord.developers_with_callbacks.push_with_attributes(david, {})
-      assert_equal ["before_adding#{david.id}", "after_adding#{david.id}", "before_adding#{david.id}", 
-                    "after_adding#{david.id}"], activerecord.developers_log
-    end
-  end
-end
-