activerecord-jdbc-adapter 1.3.0.beta1 → 1.3.0.beta2

data/test/rake_test_support.rb

@@ -0,0 +1,298 @@
+require 'test_helper'
+require 'pathname'
+require 'stringio'
+
+module RakeTestSupport
+  
+  def self.included(base)
+    require 'rake'
+    base.module_eval { include Rake::DSL } # if defined?(Rake::DSL)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    
+    def startup
+      super
+      load 'rails_stub.rb'
+    end
+    
+    def shutdown
+      Object.send(:remove_const, :Rails)
+      super
+    end
+    
+  end
+  
+  def setup
+    @_prev_application = Rake.application
+    @_prev_configurations = ActiveRecord::Base.configurations
+    @_prev_connection_config = current_connection_config
+    db_config # if not re-defined initialize from current connection's config
+
+    @db_name = db_name unless @db_name ||= nil
+    @rails_env = rails_env unless @rails_env ||= nil
+    
+    setup_rails
+    set_rails_env(@rails_env)
+    set_rails_root(".")
+    
+    Rake.application = new_application
+    ActiveRecord::Base.connection.disconnect!
+    
+    verbose(true)
+    
+    load_tasks
+    
+    do_setup
+  end
+
+  def do_setup
+  end
+
+  RAILS_4x = ActiveRecord::VERSION::MAJOR >= 4
+  
+  def load_tasks
+    if ActiveRecord::VERSION::MAJOR >= 3
+      load "active_record/railties/databases.rake"
+    else # we still support AR-2.3
+      load "tasks/databases.rake" # from rails/railties
+    end
+    load 'arjdbc/tasks.rb' if defined?(JRUBY_VERSION)
+
+    namespace :db do
+      task :load_config do
+        # 4.0 :
+        # ActiveRecord::Base.configurations = ActiveRecord::Tasks::DatabaseTasks.database_configuration || {}
+        # ActiveRecord::Migrator.migrations_paths = ActiveRecord::Tasks::DatabaseTasks.migrations_paths
+        # 3.2 :
+        # ActiveRecord::Base.configurations = Rails.application.config.database_configuration
+        # ActiveRecord::Migrator.migrations_paths = Rails.application.paths['db/migrate'].to_a
+        # 2.3 :
+        # ActiveRecord::Base.configurations = Rails::Configuration.new.database_configuration
+        ActiveRecord::Base.configurations = configurations
+      end
+    end
+
+    task :environment do
+      ActiveRecord::Base.configurations = configurations
+      ActiveRecord::Base.establish_connection @rails_env
+      @full_env_loaded = true
+    end
+    
+    if RAILS_4x
+      ActiveRecord::Tasks::DatabaseTasks.env = @rails_env
+      ActiveRecord::Tasks::DatabaseTasks.db_dir = 'db'
+    else
+      task(:rails_env) { @rails_env_set = true }
+    end
+  end
+  
+  def teardown
+    verify_and_restore_stdout
+    error = nil
+    begin
+      do_teardown
+    rescue => e
+      error = e
+    end
+    Rake.application = @_prev_application
+    restore_rails
+    ActiveRecord::Base.configurations = @_prev_configurations
+    ActiveRecord::Base.establish_connection @_prev_connection_config
+    @rails_env_set = nil
+    @full_env_loaded = nil
+    raise error if error
+  end
+
+  def do_teardown
+  end
+  
+  def new_application
+    Rake::Application.new
+  end
+  
+  # (Test) Helpers :
+  
+  def create_schema_migrations_table(connection = ActiveRecord::Base.connection)
+    schema_migration = ActiveRecord::Migrator.schema_migrations_table_name
+    return if connection.table_exists?(schema_migration)
+    connection.create_table(schema_migration, :id => false) do |t|
+      t.column :version, :string, :null => false
+    end
+  end
+  
+  def create_rake_test_database
+    ActiveRecord::Base.establish_connection db_config
+    connection = ActiveRecord::Base.connection
+    connection.create_database(db_name, db_config) if connection.respond_to?(:create_database)
+    if block_given?
+      if db_name
+        config = db_config.merge :database => db_name
+        ActiveRecord::Base.establish_connection config
+      end
+      yield ActiveRecord::Base.connection
+    end
+    ActiveRecord::Base.connection.disconnect!
+  end
+  
+  def drop_rake_test_database(silence = false)
+    ActiveRecord::Base.establish_connection db_config
+    begin
+      ActiveRecord::Base.connection.drop_database(db_name)
+    rescue => e
+      raise e unless silence
+    end
+    ActiveRecord::Base.connection.disconnect!
+  end
+  
+  def structure_sql_filename
+    ar_version('3.2') ? 'structure.sql' : "#{@rails_env}_structure.sql"
+  end
+  
+  def expect_rake_output(matcher)
+    @_stdout, @_stdout_matcher = $stdout, matcher
+    $stdout = StringIO.new
+  end
+  
+  def verify_and_restore_stdout
+    if @_stdout ||= nil
+      _stdout = $stdout
+      $stdout = @_stdout
+      
+      output = _stdout.string
+      if @_stdout_matcher.is_a?(String)
+        unless @_stdout_matcher.index("\n")
+          output = output.rstrip
+        end
+        assert_equal @_stdout_matcher, output
+      else
+        assert_match @_stdout_matcher, output
+      end
+    end
+  end
+  private :verify_and_restore_stdout
+  
+  def rails_env
+    'unittest'
+  end
+  
+  def db_name
+    'test_rake_db'
+  end
+  
+  @@db_config = nil
+  
+  def db_config
+    @@db_config ||= current_connection_config.reject { |key, val| val && key.to_s == 'url' }
+  end
+  
+  def current_connection_config
+    if ActiveRecord::Base.respond_to?(:connection_config)
+      ActiveRecord::Base.connection_config
+    else
+      ActiveRecord::Base.connection_pool.spec.config
+    end
+  end
+  
+  def configurations
+    @configurations ||= begin
+      db_config = self.db_config.dup
+      db_config.merge!(:database => @db_name) if @db_name ||= nil
+      db_config.stringify_keys!
+      raise "Rails.env not set" unless @rails_env ||= nil
+      configurations = { @rails_env => db_config }
+      configurations['test'] = db_config.dup
+      configurations
+    end
+  end
+  
+  private
+
+  RAILS_2x = ActiveRecord::VERSION::MAJOR < 3
+  
+  def setup_rails
+    RAILS_2x ? setup_rails2 : setup_rails3
+  end
+
+  def setup_rails2
+    test = self
+    Rails::Configuration.module_eval do
+      define_method(:database_configuration) { test.configurations }
+    end
+  end
+
+  def setup_rails3
+    test = self
+    (class << Rails::Application.config; self ; end).instance_eval do
+      define_method(:database_configuration) { test.configurations }
+    end
+  end
+
+  def set_rails_env(env); set_rails_constant("env", env); end
+
+  def set_rails_root(root = '.'); set_rails_constant("root", root); end
+
+  NO_VALUE = Java::JavaLang::Void rescue NilClass
+  
+  def set_rails_constant(name, value)
+    name = name.to_s
+    
+    @rails_constants ||= {}
+    begin
+      @rails_constants[name] = Object.const_get(rails_constant_name(name))
+    rescue NameError
+      @rails_constants[name] = NO_VALUE
+    end
+    silence_warnings { Object.const_set(rails_constant_name(name), value) } if RAILS_2x
+    
+    case name
+    when 'env'
+      unless value.is_a?(ActiveSupport::StringInquirer)
+        value = ActiveSupport::StringInquirer.new(value)
+      end
+    when 'root'
+      unless value.is_a?(Pathname)
+        value = Pathname.new(value).realpath
+      end
+    end
+    
+    Rails.instance_eval do
+      if methods(false).map(&:to_s).include?(name)
+        singleton_class = (class << self; self; end)
+        singleton_class.send(:alias_method, "orig_#{name}", name)
+        singleton_class.send(:define_method, name) { value }
+      end
+    end
+  end
+
+  def restore_rails
+    ( @rails_constants ||= {} ).each do |name, value|
+      
+      if value == NO_VALUE
+        Object.send(:remove_const, rails_constant_name(name)) if RAILS_2x
+      else
+        silence_warnings { Object.const_set(rails_constant_name(name), value) }
+      end
+      
+      Rails.instance_eval do
+        if methods(false).map(&:to_s).include?(name)
+          singleton_class = (class << self; self; end)
+          singleton_class.send :remove_method, name
+          singleton_class.send :alias_method, name, "orig_#{name}"
+        end
+      end
+      
+    end
+  end
+
+  def rails_constant_name(name); "RAILS_#{name.upcase}"; end
+  
+  def silence_warnings
+    prev, $VERBOSE = $VERBOSE, nil
+    yield
+  ensure
+    $VERBOSE = prev
+  end
+  
+end

data/test/serialize.rb

@@ -257,10 +257,8 @@ module SerializeTestMethods
     myobj = MyObject.new('value1', 'value2')
     topic = Topic.create(:content => myobj)
 
-    ActiveRecord::IdentityMap.without do
-      assert_equal(myobj, Topic.select(:content).find(topic.id).content)
-      assert_raise(ActiveModel::MissingAttributeError) { Topic.select(:id).find(topic.id).content }
-    end
+    assert_equal myobj, Topic.select(:content).find(topic.id).content
+    assert_raise(ActiveModel::MissingAttributeError) { Topic.select(:id).find(topic.id).content }
   ensure
     ActiveRecord::Base.time_zone_aware_attributes = false
   end if Test::Unit::TestCase.ar_version('3.2')

data/test/simple.rb

@@ -66,10 +66,8 @@ module FixtureSetup
   def setup
     super
     #
-    # just a random zone, unlikely to be local, and not utc
+    # just a random zone, unlikely to be local, and not UTC
     Time.zone = 'Moscow' if Time.respond_to?(:zone)
-    #
-    DbType.create!
   end
   
   def teardown
@@ -112,13 +110,13 @@ module DirtyAttributeTests
     user = User.create!(:login => 'cicina')
     old_updated_at = 61.minutes.ago.in_time_zone
     
-    User.update_all({ :updated_at => old_updated_at }, :login => user.login)
+    do_update_all(User, { :updated_at => old_updated_at }, :login => user.login)
 
     with_partial_updates User, false do
       assert_queries(1) { user.save! }
     end
 
-    User.update_all({ :updated_at => old_updated_at }, :login => user.login)
+    do_update_all(User, { :updated_at => old_updated_at }, :login => user.login)
     
     with_partial_updates User, true do
       assert_queries(0) { user.save! }
@@ -133,13 +131,13 @@ module DirtyAttributeTests
     entry = Entry.create!(:title => 'foo')
     old_updated_on = 25.hours.ago.beginning_of_day.in_time_zone
     
-    Entry.update_all({ :updated_on => old_updated_on }, :id => entry.id)
+    do_update_all(Entry, { :updated_on => old_updated_on }, :id => entry.id)
 
     with_partial_updates Entry, false do
       assert_queries(2) { 2.times { entry.save! } }
     end
 
-    Entry.update_all({ :updated_on => old_updated_on }, :id => entry.id)
+    do_update_all(Entry, { :updated_on => old_updated_on }, :id => entry.id)
     
     with_partial_updates Entry, true do
       assert_queries(0) { 2.times { entry.save! } }
@@ -152,12 +150,34 @@ module DirtyAttributeTests
   
   private
   
-  def with_partial_updates(klass, on = true)
-    old = klass.partial_updates?
-    klass.partial_updates = on
-    yield
-  ensure
-    klass.partial_updates = old
+  if ActiveRecord::VERSION::MAJOR > 3
+    
+    def with_partial_updates(klass, on = true)
+      old = klass.partial_writes?
+      klass.partial_writes = on
+      yield
+    ensure
+      klass.partial_writes = old
+    end
+    
+  else
+    
+    def with_partial_updates(klass, on = true)
+      old = klass.partial_updates?
+      klass.partial_updates = on
+      yield
+    ensure
+      klass.partial_updates = old
+    end
+    
+  end
+  
+  def do_update_all(model, values, conditions)
+    if ar_version('3.2')
+      model.where(conditions).update_all(values)
+    else # User.update_all values, conditions deprecated on 4.0
+      model.update_all(values, conditions)
+    end
   end
   
 end
@@ -292,24 +312,16 @@ module SimpleTestMethods
       # precision will only be expected to the second :
       original_time = Time.local(t.year, t.month, t.day, t.hour, t.min, t.sec)
       time = original_time.in_time_zone
-      e = DbType.first
-      e.sample_datetime = time
-      e.save!
-      e = DbType.first
-
-      assert_equal time, e.sample_datetime
+      e = DbType.create! :sample_datetime => time
+      assert_equal time, e.reload.sample_datetime
     end
 
     def test_save_date_time
       t = Time.now
       # precision will only be expected to the second :
       time = Time.local(t.year, t.month, t.day, t.hour, t.min, t.sec)
-      datetime = time.to_datetime
-      e = DbType.first
-      e.sample_datetime = datetime
-      e.save!
-      e = DbType.first
-      assert_equal time, e.sample_datetime.localtime
+      e = DbType.create! :sample_datetime => time.to_datetime
+      assert_equal time, e.reload.sample_datetime.localtime
     end
     
   end
@@ -317,110 +329,89 @@ module SimpleTestMethods
   def test_save_time
     # Ruby doesn't have a plain Time class without a date.
     time = Time.utc(2012, 12, 18, 21, 10, 15, 0)
-    e = DbType.first
+    e = DbType.new
     e.sample_time = time
     e.save!
-    e = DbType.first
 
-    assert_time_equal time, e.sample_time
+    assert_time_equal time, e.reload.sample_time
   end
   
   def test_save_timestamp
     timestamp = Time.utc(2012, 12, 18, 21, 10, 15, 0)
-    e = DbType.first
+    e = DbType.create! :sample_datetime => Time.now
     e.sample_timestamp = timestamp
     e.save!
-    e = DbType.first
-    assert_timestamp_equal timestamp, e.sample_timestamp
+    assert_timestamp_equal timestamp, e.reload.sample_timestamp
   end
   
-  # TODO we do not support precision beyond seconds !
-  # def test_save_timestamp_with_usec
-  #   timestamp = Time.utc(1942, 11, 30, 01, 53, 59, 123_456)
-  #   e = DbType.first
-  #   e.sample_timestamp = timestamp
-  #   e.save!
-  #   e = DbType.first
-  #   assert_timestamp_equal timestamp, e.sample_timestamp
-  # end
+  def test_save_timestamp_with_usec
+    pend 'todo: support precision beyond seconds !?'
+    timestamp = Time.utc(1942, 11, 30, 01, 53, 59, 123_456)
+    e = DbType.create! :sample_timestamp => timestamp
+    assert_timestamp_equal timestamp, e.reload.sample_timestamp
+  end
 
   def test_save_date
     date = Date.new(2007)
-    e = DbType.first
+    e = DbType.new
     e.sample_date = date
-    e.save!
-    e = DbType.first
+    e.save!; e.reload
     assert_date_type e.sample_date
     assert_date_equal date, e.sample_date
   end
 
   def test_save_float
-    e = DbType.first
-    e.sample_float = 12.0
+    e = DbType.new :sample_float => 12.0
     e.save!
-
-    e = DbType.first
-    assert_equal 12.0, e.sample_float
+    assert_equal 12.0, e.reload.sample_float
   end
   
   def test_boolean
-    e = DbType.first
-    assert_nil e.sample_boolean # unset boolean should default to nil
+    e = DbType.create! :sample_float => 0
+    assert_nil e.reload.sample_boolean # unset boolean should default to nil
 
     e.update_attributes :sample_boolean => false
-
-    e = DbType.first
-    assert_equal false, e.sample_boolean
+    assert_equal false, e.reload.sample_boolean
     
     e.sample_boolean = true
     e.save!
-
-    e = DbType.first
-    assert_equal true, e.sample_boolean
+    assert_equal true, e.reload.sample_boolean
   end
 
   def test_integer
-    e = DbType.first
-    assert_nil e.sample_integer
+    e = DbType.create! :sample_boolean => false
+    assert_nil e.reload.sample_integer
 
     e.sample_integer = 10
     e.save!
-
-    e = DbType.first
-    assert_equal 10, e.sample_integer
+    assert_equal 10, e.reload.sample_integer
   end
 
   def test_text
-    e = DbType.first
-    assert_null_text e.sample_text
+    e = DbType.create! :sample_boolean => false
+    assert_null_text e.reload.sample_text
 
     e.sample_text = "ooop?"
     e.save!
-
-    e = DbType.first
-    assert_equal "ooop?", e.sample_text
+    assert_equal "ooop?", e.reload.sample_text
   end
 
   def test_string
-    e = DbType.first
-    assert_empty_string e.sample_string
+    e = DbType.create! :sample_boolean => false
+    assert_empty_string e.reload.sample_string
 
     e.sample_string = "ooop?"
     e.save!
-
-    e = DbType.first
-    assert_equal "ooop?", e.sample_string
+    assert_equal "ooop?", e.reload.sample_string
   end
 
   def test_save_binary
     # string is 60_000 bytes
     binary_string = "\000ABCDEFGHIJKLMNOPQRSTUVWXYZ'\001\003" * 1 # 2_000
-    e = DbType.first
+    e = DbType.new
     e.sample_binary = binary_string
     e.save!
-    
-    e = DbType.first
-    assert_equal binary_string, e.sample_binary
+    assert_equal binary_string, e.reload.sample_binary
   end
 
   def test_small_decimal
@@ -430,6 +421,14 @@ module SimpleTestMethods
     db_type = DbType.find(db_type.id)
     assert_kind_of BigDecimal, db_type.sample_small_decimal
     assert_equal BigDecimal.new(test_value.to_s), db_type.sample_small_decimal
+
+    test_value = BigDecimal('1.23')
+    db_type = DbType.create!(:sample_small_decimal => test_value)
+    if ar_version('3.0')
+      assert_equal 1, DbType.where("sample_small_decimal < ?", 1.5).count
+    else
+      assert_equal 1, DbType.find(:all, :conditions => ["sample_small_decimal < ?", 1.5]).size
+    end
   end
 
   def test_decimal # _with_zero_scale
@@ -440,6 +439,12 @@ module SimpleTestMethods
     assert_equal test_value.to_i, db_type.sample_decimal
   end
 
+  def test_decimal_with_scale
+    test_value = BigDecimal("100023400056.795")
+    db_type = DbType.create!(:decimal_with_scale => test_value)
+    assert_equal test_value, db_type.reload.decimal_with_scale
+  end
+  
   def test_big_decimal
     test_value = 9876543210_9876543210_9876543210.0
     db_type = DbType.create!(:big_decimal => test_value)
@@ -448,6 +453,13 @@ module SimpleTestMethods
     assert_equal test_value, db_type.big_decimal
   end
   
+  # NOTE: relevant on 4.0 as it started using empty_insert_statement_value
+  def test_empty_insert_statement
+    DbType.create!
+    assert DbType.first
+    assert_not_nil DbType.first.id
+  end
+  
   def test_negative_default_value
     assert_equal(-1, DbType.columns_hash['sample_integer_neg_default'].default)
     assert_equal(-1, DbType.new.sample_integer_neg_default)
@@ -483,17 +495,17 @@ module SimpleTestMethods
   end
 
   def test_nil_values
-    test = AutoId.create('value' => '')
-    assert_nil AutoId.find(test.id).value
+    e = DbType.create! :sample_integer => '', :sample_string => 'sample'
+    assert_nil e.reload.sample_integer
   end
 
   # These should make no difference, but might due to the wacky regexp SQL rewriting we do.
   def test_save_value_containing_sql
-    e = DbType.first
-    e.save
+    e = DbType.new :sample_string => 'sample'
+    e.save!
 
     e.sample_string = e.sample_text = "\n\nselect from nothing where id = 'foo'"
-    e.save
+    e.save!
   end
 
   def test_invalid
@@ -508,6 +520,7 @@ module SimpleTestMethods
   end
 
   def test_reconnect
+    DbType.create! :sample_string => 'sample'
     assert_equal 1, DbType.count
     ActiveRecord::Base.connection.reconnect!
     assert_equal 1, DbType.count
@@ -531,13 +544,16 @@ module SimpleTestMethods
     class Animal < ActiveRecord::Base; end
 
     def test_fetching_columns_for_nonexistent_table
-      assert_raise(ActiveRecord::ActiveRecordError, ActiveRecord::StatementInvalid, ActiveRecord::JDBCError) do
-        Animal.columns
+      disable_logger(Animal.connection) do
+        assert_raise(ActiveRecord::StatementInvalid, ActiveRecord::JDBCError) do
+          Animal.columns
+        end
       end
     end
   end
 
   def test_disconnect
+    DbType.create! :sample_string => 'sample'
     assert_equal 1, DbType.count
     ActiveRecord::Base.clear_active_connections!
     ActiveRecord::Base.connection_pool.disconnect! if ActiveRecord::Base.respond_to?(:connection_pool)
@@ -702,7 +718,8 @@ module SimpleTestMethods
     
     sql = "UPDATE entries SET title = ? WHERE id = #{entry.id}"
     name = "UPDATE(raw_with_q_mark)"
-    connection.update sql, name, [ [ nil, "bar?" ] ]
+    title_column = Entry.columns.find { |n| n.to_s == 'title' }
+    connection.update sql, name, [ [ title_column, "bar?" ] ]
     assert_equal 'bar?', entry.reload.title
     
     sql = "UPDATE entries SET title = ? WHERE id = ?"
@@ -856,6 +873,27 @@ module SimpleTestMethods
     assert_equal 'user1', result[0]['login']
     assert_equal 'user2', result[1]['login']
   end
+
+  def test_exec_query_raw_yields
+    User.create! :login => 'user3'
+    User.create! :login => 'user4'
+    
+    arel = User.select('id, login, created_at').where("login = 'user3' or login = 'user4'")
+    yielded = 0
+    ActiveRecord::Base.connection.exec_query_raw(arel) do |*args| # id, login, created_at
+      assert_equal 3, args.size
+      yielded += 1
+      case yielded
+      when 1
+        assert_equal 'user3', args[1]
+      when 2
+        assert_equal 'user4', args[1]
+      else 
+        fail "yielded 3 times"
+      end
+    end
+    assert yielded == 2
+  end if Test::Unit::TestCase.ar_version('3.0')
   
   def test_select
     Entry.delete_all
@@ -917,11 +955,40 @@ module SimpleTestMethods
     end
   end
   
+  def test_update
+    user = User.create! :login => 'update'
+    
+    User.update(user.id, :login => 'UPDATEd')
+    assert_equal 'UPDATEd', user.reload.login
+  end
+
   def test_connection_alive_sql
     connection = ActiveRecord::Base.connection
-    alive_sql = connection.config[:connection_alive_sql]
-    assert_not_nil alive_sql, "no :connection_alive_sql for #{connection}"
-    connection.execute alive_sql
+    if alive_sql = connection.config[:connection_alive_sql]
+      connection.execute alive_sql
+    end
+    # if no alive SQL than JDBC 4.0 driver's "alive" test will be used
+  end
+  
+  def test_connection_valid
+    connection = ActiveRecord::Base.connection
+    assert connection.active? # JDBC connection.isValid (if alive_sql not set)
+  end
+  
+  def test_query_cache
+    user_1 = User.create! :login => 'query_cache_1'
+    user_2 = User.create! :login => 'query_cache_2'
+    user_3 = User.create! :login => 'query_cache_3'
+    # NOTE: on 3.1 AR::Base.cache does not cache if AR not configured, 
+    # due : `if ActiveRecord::Base.configurations.blank?; yield ...`
+    User.connection.cache do # instead of simply `User.cache`
+      id1 = user_1.id; id2 = user_2.id
+      assert_queries(2) { User.find(id1); User.find(id1); User.find(id2); User.find(id1) }
+    end
+    User.connection.uncached do
+      id1 = user_1.id; id3 = user_3.id
+      assert_queries(3) { User.find(id3); User.find(id1); User.find(id3) }
+    end
   end
   
   protected
@@ -1022,7 +1089,9 @@ module XmlColumnTests
   module TestMethods
     
     def test_create_xml_column
-      create_xml_models!
+      create_xml_models! do |t|
+        skip('TableDefinition#xml not-implemented') unless t.respond_to?(:xml)
+      end
 
       xml_column = connection.columns(:xml_models).detect do |c|
         c.name == "xml_col"
@@ -1047,7 +1116,7 @@ module XmlColumnTests
         end
           
       else
-        puts "test_use_xml_column skipped"
+        skip('TableDefinition#xml not-implemented')
       end
     ensure
       drop_xml_models! if created
@@ -1066,11 +1135,16 @@ module XmlColumnTests
     private
     
     def create_xml_models!
-      connection.create_table(:xml_models) { |t| t.xml :xml_col }
+      connection.create_table(:xml_models) do |t| 
+        yield(t) if block_given?
+        t.xml :xml_col
+      end
     end
 
     def drop_xml_models!
-      connection.drop_table(:xml_models)
+      disable_logger(connection) do
+        connection.drop_table(:xml_models)
+      end
     end
     
   end
@@ -1088,9 +1162,9 @@ module ActiveRecord3TestMethods
     def test_visitor_accessor
       adapter = Entry.connection
       adapter_spec = adapter.config[:adapter_spec]
-      expected_visitors = adapter_spec.arel2_visitors(adapter.config).values
+      visitor_type = adapter_spec.arel2_visitors(adapter.config).values.first
       assert_not_nil adapter.visitor
-      assert expected_visitors.include?(adapter.visitor.class)
+      assert_kind_of visitor_type, adapter.visitor
     end if Test::Unit::TestCase.ar_version('3.2') # >= 3.2
     
     def test_where
@@ -1118,7 +1192,7 @@ module ActiveRecord3TestMethods
       assert_nothing_raised do
         Thing.create! :name => "a thing"
       end
-      assert_equal 1, Thing.find(:all).size
+      assert_equal 1, Thing.count
     end
     
   end