activerecord 2.3.18 → 3.0.0.beta

data/test/cases/pk_test.rb

@@ -1,119 +0,0 @@
-require "cases/helper"
-require 'models/topic'
-require 'models/reply'
-require 'models/subscriber'
-require 'models/movie'
-require 'models/keyboard'
-require 'models/mixed_case_monkey'
-
-class PrimaryKeysTest < ActiveRecord::TestCase
-  fixtures :topics, :subscribers, :movies, :mixed_case_monkeys
-
-  def test_integer_key
-    topic = Topic.find(1)
-    assert_equal(topics(:first).author_name, topic.author_name)
-    topic = Topic.find(2)
-    assert_equal(topics(:second).author_name, topic.author_name)
-
-    topic = Topic.new
-    topic.title = "New Topic"
-    assert_equal(nil, topic.id)
-    assert_nothing_raised { topic.save! }
-    id = topic.id
-
-    topicReloaded = Topic.find(id)
-    assert_equal("New Topic", topicReloaded.title)
-  end
-
-  def test_customized_primary_key_auto_assigns_on_save
-    Keyboard.delete_all
-    keyboard = Keyboard.new(:name => 'HHKB')
-    assert_nothing_raised { keyboard.save! }
-    assert_equal keyboard.id, Keyboard.find_by_name('HHKB').id
-  end
-
-  def test_customized_primary_key_can_be_get_before_saving
-    keyboard = Keyboard.new
-    assert_nil keyboard.id
-    assert_nothing_raised { assert_nil keyboard.key_number }
-  end
-
-  def test_customized_string_primary_key_settable_before_save
-    subscriber = Subscriber.new
-    assert_nothing_raised { subscriber.id = 'webster123' }
-    assert_equal 'webster123', subscriber.id
-    assert_equal 'webster123', subscriber.nick
-  end
-
-  def test_string_key
-    subscriber = Subscriber.find(subscribers(:first).nick)
-    assert_equal(subscribers(:first).name, subscriber.name)
-    subscriber = Subscriber.find(subscribers(:second).nick)
-    assert_equal(subscribers(:second).name, subscriber.name)
-
-    subscriber = Subscriber.new
-    subscriber.id = "jdoe"
-    assert_equal("jdoe", subscriber.id)
-    subscriber.name = "John Doe"
-    assert_nothing_raised { subscriber.save! }
-    assert_equal("jdoe", subscriber.id)
-
-    subscriberReloaded = Subscriber.find("jdoe")
-    assert_equal("John Doe", subscriberReloaded.name)
-  end
-
-  def test_find_with_more_than_one_string_key
-    assert_equal 2, Subscriber.find(subscribers(:first).nick, subscribers(:second).nick).length
-  end
-
-  def test_primary_key_prefix
-    ActiveRecord::Base.primary_key_prefix_type = :table_name
-    Topic.reset_primary_key
-    assert_equal "topicid", Topic.primary_key
-
-    ActiveRecord::Base.primary_key_prefix_type = :table_name_with_underscore
-    Topic.reset_primary_key
-    assert_equal "topic_id", Topic.primary_key
-
-    ActiveRecord::Base.primary_key_prefix_type = nil
-    Topic.reset_primary_key
-    assert_equal "id", Topic.primary_key
-  end
-
-  def test_delete_should_quote_pkey
-    assert_nothing_raised { MixedCaseMonkey.delete(1) }
-  end
-  def test_update_counters_should_quote_pkey_and_quote_counter_columns
-    assert_nothing_raised { MixedCaseMonkey.update_counters(1, :fleaCount => 99) }
-  end
-  def test_find_with_one_id_should_quote_pkey
-    assert_nothing_raised { MixedCaseMonkey.find(1) }
-  end
-  def test_find_with_multiple_ids_should_quote_pkey
-    assert_nothing_raised { MixedCaseMonkey.find([1,2]) }
-  end
-  def test_instance_update_should_quote_pkey
-    assert_nothing_raised { MixedCaseMonkey.find(1).save }
-  end
-  def test_instance_destroy_should_quote_pkey
-    assert_nothing_raised { MixedCaseMonkey.find(1).destroy }
-  end
-
-  def test_supports_primary_key
-    assert_nothing_raised NoMethodError do
-      ActiveRecord::Base.connection.supports_primary_key?
-    end
-  end
-
-  def test_primary_key_returns_value_if_it_exists
-    if ActiveRecord::Base.connection.supports_primary_key?
-      assert_equal 'id', ActiveRecord::Base.connection.primary_key('developers')
-    end
-  end
-
-  def test_primary_key_returns_nil_if_it_does_not_exist
-    if ActiveRecord::Base.connection.supports_primary_key?
-      assert_nil ActiveRecord::Base.connection.primary_key('developers_projects')
-    end
-  end
-end

data/test/cases/pooled_connections_test.rb

@@ -1,103 +0,0 @@
-require "cases/helper"
-
-class PooledConnectionsTest < ActiveRecord::TestCase
-  def setup
-    super
-    @connection = ActiveRecord::Base.remove_connection
-  end
-
-  def teardown
-    ActiveRecord::Base.clear_all_connections!
-    ActiveRecord::Base.establish_connection(@connection)
-    super
-  end
-
-  def checkout_connections
-    ActiveRecord::Base.establish_connection(@connection.merge({:pool => 2, :wait_timeout => 0.3}))
-    @connections = []
-    @timed_out = 0
-
-    4.times do
-      Thread.new do
-        begin
-          @connections << ActiveRecord::Base.connection_pool.checkout
-        rescue ActiveRecord::ConnectionTimeoutError
-          @timed_out += 1
-        end
-      end.join
-    end
-  end
-
-  # Will deadlock due to lack of Monitor timeouts in 1.9
-  if RUBY_VERSION < '1.9'
-    def test_pooled_connection_checkout
-      checkout_connections
-      assert_equal @connections.length, 2
-      assert_equal @timed_out, 2
-    end
-  end
-
-  def checkout_checkin_connections(pool_size, threads)
-    ActiveRecord::Base.establish_connection(@connection.merge({:pool => pool_size, :wait_timeout => 0.5}))
-    @connection_count = 0
-    @timed_out = 0
-    threads.times do
-      Thread.new do
-        begin
-          conn = ActiveRecord::Base.connection_pool.checkout
-          sleep 0.1
-          ActiveRecord::Base.connection_pool.checkin conn
-          @connection_count += 1
-        rescue ActiveRecord::ConnectionTimeoutError
-          @timed_out += 1
-        end
-      end.join
-    end
-  end
-
-  def test_pooled_connection_checkin_one
-    checkout_checkin_connections 1, 2
-    assert_equal 2, @connection_count
-    assert_equal 0, @timed_out
-  end
-
-  def test_pooled_connection_checkin_two
-    checkout_checkin_connections 2, 3
-    assert_equal 3, @connection_count
-    assert_equal 0, @timed_out
-  end
-
-  def test_pooled_connection_checkout_existing_first
-    ActiveRecord::Base.establish_connection(@connection.merge({:pool => 1}))
-    conn_pool = ActiveRecord::Base.connection_pool
-    conn = conn_pool.checkout
-    conn_pool.checkin(conn)
-    conn = conn_pool.checkout
-    assert ActiveRecord::ConnectionAdapters::AbstractAdapter === conn
-    conn_pool.checkin(conn)
-  end
-
-  def test_not_connected_defined_connection_returns_false
-    ActiveRecord::Base.establish_connection(@connection)
-    assert ! ActiveRecord::Base.connected?
-  end
-
-  def test_undefined_connection_returns_false
-    old_handler = ActiveRecord::Base.connection_handler
-    ActiveRecord::Base.connection_handler = ActiveRecord::ConnectionAdapters::ConnectionHandler.new
-    assert_equal false, ActiveRecord::Base.connected?
-  ensure
-    ActiveRecord::Base.connection_handler = old_handler
-  end
-end unless %w(FrontBase).include? ActiveRecord::Base.connection.adapter_name
-
-class AllowConcurrencyDeprecatedTest < ActiveRecord::TestCase
-  def test_allow_concurrency_is_deprecated
-    assert_deprecated('ActiveRecord::Base.allow_concurrency') do
-      ActiveRecord::Base.allow_concurrency
-    end
-    assert_deprecated('ActiveRecord::Base.allow_concurrency=') do
-      ActiveRecord::Base.allow_concurrency = true
-    end
-  end
-end

data/test/cases/query_cache_test.rb

@@ -1,129 +0,0 @@
-require "cases/helper"
-require 'models/topic'
-require 'models/reply'
-require 'models/task'
-require 'models/course'
-require 'models/category'
-require 'models/post'
-
-
-class QueryCacheTest < ActiveRecord::TestCase
-  fixtures :tasks, :topics, :categories, :posts, :categories_posts
-
-  def test_find_queries
-    assert_queries(2) { Task.find(1); Task.find(1) }
-  end
-
-  def test_find_queries_with_cache
-    Task.cache do
-      assert_queries(1) { Task.find(1); Task.find(1) }
-    end
-  end
-
-  def test_count_queries_with_cache
-    Task.cache do
-      assert_queries(1) { Task.count; Task.count }
-    end
-  end
-
-  def test_query_cache_dups_results_correctly
-    Task.cache do
-      now  = Time.now.utc
-      task = Task.find 1
-      assert_not_equal now, task.starting
-      task.starting = now
-      task.reload
-      assert_not_equal now, task.starting
-    end
-  end
-
-  def test_cache_is_flat
-    Task.cache do
-      Topic.columns # don't count this query
-      assert_queries(1) { Topic.find(1); Topic.find(1); }
-    end
-
-    ActiveRecord::Base.cache do
-      assert_queries(1) { Task.find(1); Task.find(1) }
-    end
-  end
-
-  def test_cache_does_not_wrap_string_results_in_arrays
-    require 'sqlite3/version' if current_adapter?(:SQLite3Adapter)
-
-    Task.cache do
-      if current_adapter?(:SQLite3Adapter) && SQLite3::Version::VERSION > '1.2.5'
-        assert_instance_of Fixnum, Task.connection.select_value("SELECT count(*) AS count_all FROM tasks")
-      else
-        assert_instance_of String, Task.connection.select_value("SELECT count(*) AS count_all FROM tasks")
-      end
-    end
-  end
-end
-
-class QueryCacheExpiryTest < ActiveRecord::TestCase
-  fixtures :tasks, :posts, :categories, :categories_posts
-
-  def test_find
-    Task.connection.expects(:clear_query_cache).times(1)
-
-    assert !Task.connection.query_cache_enabled
-    Task.cache do
-      assert Task.connection.query_cache_enabled
-      Task.find(1)
-
-      Task.uncached do
-        assert !Task.connection.query_cache_enabled
-        Task.find(1)
-      end
-
-      assert Task.connection.query_cache_enabled
-    end
-    assert !Task.connection.query_cache_enabled
-  end
-
-  def test_update
-    Task.connection.expects(:clear_query_cache).times(2)
-
-    Task.cache do
-      task = Task.find(1)
-      task.starting = Time.now.utc
-      task.save!
-    end
-  end
-
-  def test_destroy
-    Task.connection.expects(:clear_query_cache).times(2)
-
-    Task.cache do
-      Task.find(1).destroy
-    end
-  end
-
-  def test_insert
-    ActiveRecord::Base.connection.expects(:clear_query_cache).times(2)
-
-    Task.cache do
-      Task.create!
-    end
-  end
-
-  def test_cache_is_expired_by_habtm_update
-    ActiveRecord::Base.connection.expects(:clear_query_cache).times(2)
-    ActiveRecord::Base.cache do
-      c = Category.find(:first)
-      p = Post.find(:first)
-      p.categories << c
-    end
-  end
-
-  def test_cache_is_expired_by_habtm_delete
-    ActiveRecord::Base.connection.expects(:clear_query_cache).times(2)
-    ActiveRecord::Base.cache do
-      c = Category.find(1)
-      p = Post.find(1)
-      assert p.categories.any?
-      p.categories.delete_all
-    end
-  end
-end

data/test/cases/readonly_test.rb

@@ -1,107 +0,0 @@
-require "cases/helper"
-require 'models/post'
-require 'models/comment'
-require 'models/developer'
-require 'models/project'
-require 'models/reader'
-require 'models/person'
-
-# Dummy class methods to test implicit association scoping.
-def Comment.foo() find :first end
-def Project.foo() find :first end
-
-
-class ReadOnlyTest < ActiveRecord::TestCase
-  fixtures :posts, :comments, :developers, :projects, :developers_projects
-
-  def test_cant_save_readonly_record
-    dev = Developer.find(1)
-    assert !dev.readonly?
-
-    dev.readonly!
-    assert dev.readonly?
-
-    assert_nothing_raised do
-      dev.name = 'Luscious forbidden fruit.'
-      assert !dev.save
-      dev.name = 'Forbidden.'
-    end
-    assert_raise(ActiveRecord::ReadOnlyRecord) { dev.save  }
-    assert_raise(ActiveRecord::ReadOnlyRecord) { dev.save! }
-  end
-
-
-  def test_find_with_readonly_option
-    Developer.find(:all).each { |d| assert !d.readonly? }
-    Developer.find(:all, :readonly => false).each { |d| assert !d.readonly? }
-    Developer.find(:all, :readonly => true).each { |d| assert d.readonly? }
-  end
-
-
-  def test_find_with_joins_option_implies_readonly
-    # Blank joins don't count.
-    Developer.find(:all, :joins => '  ').each { |d| assert !d.readonly? }
-    Developer.find(:all, :joins => '  ', :readonly => false).each { |d| assert !d.readonly? }
-
-    # Others do.
-    Developer.find(:all, :joins => ', projects').each { |d| assert d.readonly? }
-    Developer.find(:all, :joins => ', projects', :readonly => false).each { |d| assert !d.readonly? }
-  end
-
-
-  def test_habtm_find_readonly
-    dev = Developer.find(1)
-    assert !dev.projects.empty?
-    assert dev.projects.all?(&:readonly?)
-    assert dev.projects.find(:all).all?(&:readonly?)
-    assert dev.projects.find(:all, :readonly => true).all?(&:readonly?)
-  end
-
-  def test_has_many_find_readonly
-    post = Post.find(1)
-    assert !post.comments.empty?
-    assert !post.comments.any?(&:readonly?)
-    assert !post.comments.find(:all).any?(&:readonly?)
-    assert post.comments.find(:all, :readonly => true).all?(&:readonly?)
-  end
-
-  def test_has_many_with_through_is_not_implicitly_marked_readonly
-    assert people = Post.find(1).people
-    assert !people.any?(&:readonly?)
-  end
-
-  def test_readonly_scoping
-    Post.with_scope(:find => { :conditions => '1=1' }) do
-      assert !Post.find(1).readonly?
-      assert Post.find(1, :readonly => true).readonly?
-      assert !Post.find(1, :readonly => false).readonly?
-    end
-
-    Post.with_scope(:find => { :joins => '   ' }) do
-      assert !Post.find(1).readonly?
-      assert Post.find(1, :readonly => true).readonly?
-      assert !Post.find(1, :readonly => false).readonly?
-    end
-
-    # Oracle barfs on this because the join includes unqualified and
-    # conflicting column names
-    unless current_adapter?(:OracleAdapter)
-      Post.with_scope(:find => { :joins => ', developers' }) do
-        assert Post.find(1).readonly?
-        assert Post.find(1, :readonly => true).readonly?
-        assert !Post.find(1, :readonly => false).readonly?
-      end
-    end
-
-    Post.with_scope(:find => { :readonly => true }) do
-      assert Post.find(1).readonly?
-      assert Post.find(1, :readonly => true).readonly?
-      assert !Post.find(1, :readonly => false).readonly?
-    end
-  end
-
-  def test_association_collection_method_missing_scoping_not_readonly
-    assert !Developer.find(1).projects.foo.readonly?
-    assert !Post.find(1).comments.foo.readonly?
-  end
-end