activerecord-jdbc-adapter 1.2.9.1 → 1.3.0.beta1

data/test/models/auto_id.rb

@@ -11,5 +11,5 @@ class CreateAutoIds < ActiveRecord::Migration
 end
 
 class AutoId < ActiveRecord::Base
-  def self.table_name () "auto_ids" end
+  def self.table_name() "auto_ids" end
 end

data/test/models/rights_and_roles.rb

@@ -0,0 +1,57 @@
+class CreateRightsAndRoles < ActiveRecord::Migration
+  def self.up
+    create_table :role_assignments do |t| 
+      t.column :role_id, :integer
+      t.column :user_id, :integer
+    end
+
+    create_table :roles do |t| 
+      t.column :name, :string
+      t.column :description, :string
+    end 
+
+    create_table :permission_groups do |t|
+      t.column :right_id, :integer, :null => false
+      t.column :role_id, :integer, :null => false
+    end 
+
+    create_table :rights do |t| 
+      t.column :name, :string
+      t.column :controller_name, :string
+      t.column :actions, :string
+      t.column :hours, :float, :null => false
+    end
+  end
+
+  def self.down
+    drop_table :role_assignments
+    drop_table :roles
+    drop_table :permission_groups
+    drop_table :rights
+  end
+end
+
+class Right < ActiveRecord::Base
+  has_many :permission_groups, :dependent => :destroy
+  has_many :roles, :through => :permission_groups
+end
+
+class Role < ActiveRecord::Base
+  has_many :permission_groups, :dependent => :destroy
+  has_many :rights, :through => :permission_groups
+  has_many :role_assignments, :dependent => :destroy
+  
+  def has_right?(right)
+    rights.include? right
+  end
+end
+
+class PermissionGroup < ActiveRecord::Base
+  belongs_to :right
+  belongs_to :role
+end
+
+class RoleAssignment < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :role
+end

data/test/row_locking.rb

@@ -1,5 +1,8 @@
 require 'thread'
 
+require 'test_helper'
+require 'models/entry'
+
 module RowLockingTestMethods
 
   # Simple SELECT ... FOR UPDATE test

data/test/schema_dump.rb

@@ -1,4 +1,6 @@
 require 'stringio'
+require 'test_helper'
+require 'simple' # due MigrationSetup
 require 'active_record/schema_dumper'
 
 module SchemaDumpTestMethods
@@ -70,9 +72,9 @@ module SchemaDumpTestMethods
 
   def test_arguments_line_up
     column_definition_lines.each do |column_set|
-      assert_line_up(column_set, /:default => /)
-      assert_line_up(column_set, /:limit => /)
-      assert_line_up(column_set, /:null => /)
+      assert_line_up(column_set, /(:default => )|(default: )/)
+      assert_line_up(column_set, /(:limit => )|(limit: )/)
+      assert_line_up(column_set, /(:null => )|(null: )/)
     end
   end
 
@@ -83,7 +85,7 @@ module SchemaDumpTestMethods
 
   def test_schema_dump_includes_not_null_columns
     output = standard_dump(StringIO.new, [/^[^u]/]) # keep users
-    assert_match %r{:null => false}, output
+    assert_match %r{(:null => false)|(null: false)}, output
   end
 
   def test_schema_dump_with_string_ignored_table
@@ -108,19 +110,27 @@ module SchemaDumpTestMethods
     output = standard_dump
     match = output.match(%r{create_table "custom_pk_names"(.*)do})
     assert_not_nil(match, "nonstandardpk table not found")
-    assert_match %r(:primary_key => "custom_id"), match[1], "non-standard primary key not preserved"
+    assert_match %r((:primary_key => "custom_id")|(primary_key: "custom_id")), match[1], "non-standard primary key not preserved"
   end
 
   def test_schema_dump_includes_decimal_options
     output = standard_dump(StringIO.new, [/^[^d]/]) # keep db_types
     # t.column :sample_small_decimal, :decimal, :precision => 3, :scale => 2, :default => 3.14
-    assert_match %r{:precision => 3,[[:space:]]+:scale => 2,[[:space:]]+:default => 3.14}, output
+    if ar_version('4.0')
+      assert_match %r{precision: 3,[[:space:]]+scale: 2,[[:space:]]+default: 3.14}, output
+    else
+      assert_match %r{:precision => 3,[[:space:]]+:scale => 2,[[:space:]]+:default => 3.14}, output
+    end
   end
 
   def test_schema_dump_keeps_large_precision_integer_columns_as_decimal
     output = standard_dump
     precision = DbTypeMigration.big_decimal_precision
-    assert_match %r{t.decimal\s+"big_decimal",\s+:precision => #{precision},\s+:scale => 0}, output
+    if ar_version('4.0')
+      assert_match %r{t.decimal\s+"big_decimal",\s+precision: #{precision},\s+scale: 0}, output
+    else
+      assert_match %r{t.decimal\s+"big_decimal",\s+:precision => #{precision},\s+:scale => 0}, output
+    end
   end if Test::Unit::TestCase.ar_version('3.0') # does not work in 2.3 :
   # t.integer  "big_decimal", :limit => 38, :precision => 38, :scale => 0
 
@@ -128,13 +138,17 @@ module SchemaDumpTestMethods
     output = standard_dump
     match = output.match(%r{create_table "string_ids"(.*)do.*\n(.*)\n})
     assert_not_nil(match, "string_ids table not found")
-    assert_match %r(:id => false), match[1], "no table id not preserved"
-    assert_match %r{t.string[[:space:]]+"id",[[:space:]]+:null => false$}, match[2], "non-primary key id column not preserved"
+    assert_match %r((:id => false)|(id: false)), match[1], "no table id not preserved"
+    if ar_version('4.0')
+      assert_match %r{t.string[[:space:]]+"id",[[:space:]]+null: false$}, match[2], "non-primary key id column not preserved"
+    else
+      assert_match %r{t.string[[:space:]]+"id",[[:space:]]+:null => false$}, match[2], "non-primary key id column not preserved"
+    end
   end
 
   def test_schema_dump_keeps_id_false_when_id_is_false_and_unique_not_null_column_added
     output = standard_dump
-    assert_match %r{create_table "things", :id => false}, output
+    assert_match %r{create_table "things", (:id => false)|(id: false)}, output
   end
   
   class CreateDogMigration < ActiveRecord::Migration

data/test/simple.rb

@@ -1,12 +1,23 @@
 # -*- coding: utf-8 -*-
+require 'test_helper'
+
+require 'set'
+
+require 'models/data_types'
+require 'models/entry'
+require 'models/auto_id'
+require 'models/string_id'
+require 'models/thing'
+require 'models/custom_pk_name'
+require 'models/validates_uniqueness_of_string'
+require 'models/add_not_null_column_to_table'
+
 ActiveRecord::Schema.verbose = false
 ActiveRecord::Base.time_zone_aware_attributes = true if ActiveRecord::Base.respond_to?(:time_zone_aware_attributes)
 ActiveRecord::Base.default_timezone = :utc
-#just a random zone, unlikely to be local, and not utc
-Time.zone = 'Moscow' if Time.respond_to?(:zone)
 
 module MigrationSetup
-
+  
   def setup 
     setup!
   end
@@ -50,19 +61,27 @@ end
 module FixtureSetup
   include MigrationSetup
 
+  @@_time_zone = Time.respond_to?(:zone) ? Time.zone : nil
+  
   def setup
     super
-    @title = "First post!"
-    @content = "Hello from JRuby on Rails!"
-    @new_title = "First post updated title"
-    @rating = 205.76
-    @user = User.create :login=>"something"
-    @entry = Entry.create :title => @title, :content => @content, :rating => @rating, :user=>@user
-    DbType.create
+    #
+    # just a random zone, unlikely to be local, and not utc
+    Time.zone = 'Moscow' if Time.respond_to?(:zone)
+    #
+    DbType.create!
+  end
+  
+  def teardown
+    super
+    #
+    Time.zone = @@_time_zone if Time.respond_to?(:zone)
   end
+  
 end
 
 module ColumnNameQuotingTests
+  
   def self.included(base)
     base.class_eval do
       @@column_quote_char = "\""
@@ -80,16 +99,16 @@ module ColumnNameQuotingTests
   end
 
   protected
+  
   def column_quote_char
     @@column_quote_char || "\""
   end
+  
 end
 
 module DirtyAttributeTests
 
   def test_partial_update_with_updated_at
-    #ActiveRecord::Base.logger.level = Logger::DEBUG
-    
     user = User.create!(:login => 'cicina')
     old_updated_at = 61.minutes.ago.in_time_zone
     
@@ -108,12 +127,9 @@ module DirtyAttributeTests
       assert_queries(1) { user.login = 'cicinbrus'; user.save! }
       assert_datetime_not_equal old_updated_at, user.reload.updated_at
     end
-  ensure
-    #ActiveRecord::Base.logger.level = Logger::WARN
   end
   
   def test_partial_update_with_updated_on
-    #ActiveRecord::Base.logger.level = Logger::DEBUG
     entry = Entry.create!(:title => 'foo')
     old_updated_on = 25.hours.ago.beginning_of_day.in_time_zone
     
@@ -121,9 +137,10 @@ module DirtyAttributeTests
 
     with_partial_updates Entry, false do
       assert_queries(2) { 2.times { entry.save! } }
-      Entry.update_all({ :updated_on => old_updated_on }, :id => entry.id)
     end
 
+    Entry.update_all({ :updated_on => old_updated_on }, :id => entry.id)
+    
     with_partial_updates Entry, true do
       assert_queries(0) { 2.times { entry.save! } }
       assert_date_equal old_updated_on, entry.reload.updated_on
@@ -131,11 +148,10 @@ module DirtyAttributeTests
       assert_queries(1) { entry.title = 'bar'; entry.save! }
       assert_date_not_equal old_updated_on, entry.reload.updated_on
     end
-  ensure
-    #ActiveRecord::Base.logger.level = Logger::WARN
   end
-
+  
   private
+  
   def with_partial_updates(klass, on = true)
     old = klass.partial_updates?
     klass.partial_updates = on
@@ -143,17 +159,22 @@ module DirtyAttributeTests
   ensure
     klass.partial_updates = old
   end
+  
 end
 
 module SimpleTestMethods
   include FixtureSetup
 
-  def test_entries_created
-    assert ActiveRecord::Base.connection.tables.find{|t| t =~ /^entries$/i}, "entries not created"
+  def test_tables
+    assert_not_empty ActiveRecord::Base.connection.tables
+    tables = ActiveRecord::Base.connection.tables
+    assert tables.find { |t| t =~ /^entries$/i }, "entries not created: #{tables.inspect}"
+    assert tables.map(&:downcase).include?('users'), "users table not found: #{tables.inspect}"
   end
 
-  def test_users_created
-    assert ActiveRecord::Base.connection.tables.find{|t| t =~ /^users$/i}, "users not created"
+  def test_table_exists?
+    assert_true  ActiveRecord::Base.connection.table_exists? 'entries'
+    assert_false ActiveRecord::Base.connection.table_exists? 'blahbls'
   end
 
   def test_entries_empty
@@ -168,33 +189,35 @@ module SimpleTestMethods
   end
 
   def test_insert_returns_id
-    unless ActiveRecord::Base.connection.adapter_name =~ /oracle/i
-      value = ActiveRecord::Base.connection.insert("INSERT INTO entries (title, content, rating) VALUES('insert_title', 'some content', 1)")
+    value = ActiveRecord::Base.connection.insert("INSERT INTO entries (title, content, rating) VALUES('insert_title', 'some content', 1)")
+    assert !value.nil?
+    entry = Entry.find_by_title('insert_title')
+    assert_equal entry.id, value
+
+    # Ensure we get the id even if the PK column is not named 'id'
+    1.upto(4) do |i|
+      cpn_name = "return id test#{i}"
+      cpn = CustomPkName.new
+      cpn.name = cpn_name
+      cpn.save
+      value = cpn.custom_id
       assert !value.nil?
-      entry = Entry.find_by_title('insert_title')
-      assert_equal entry.id, value
-
-      # Ensure we get the id even if the PK column is not named 'id'
-      1.upto(4) do |i|
-        cpn_name = "return id test#{i}"
-        cpn = CustomPkName.new
-        cpn.name = cpn_name
-        cpn.save
-        value = cpn.custom_id
-        assert !value.nil?
-        cpn = CustomPkName.find_by_name(cpn_name)
-        assert_equal cpn.custom_id, value
-      end
+      cpn = CustomPkName.find_by_name(cpn_name)
+      assert_equal cpn.custom_id, value
     end
   end
 
   def test_create_new_entry
     Entry.delete_all
 
+    title = "First post!"
+    content = "Hello from JRuby on Rails!"
+    rating = 205.76
+    
     post = Entry.new
-    post.title = @title
-    post.content = @content
-    post.rating = @rating
+    post.title = title
+    post.content = content
+    post.rating = rating
     post.save
 
     assert_equal 1, Entry.count
@@ -206,22 +229,33 @@ module SimpleTestMethods
   end
 
   def test_find_and_update_entry
+    title = "First post!"
+    content = "Hello from JRuby on Rails!"
+    new_title = "First post updated title"
+    rating = 205.76
+    user = User.create! :login => "something"
+    Entry.create! :title => title, :content => content, :rating => rating, :user => user
+    
     post = Entry.first
-    assert_equal @title, post.title
-    assert_equal @content, post.content
-    assert_equal @rating, post.rating
+    assert_equal title, post.title
+    assert_equal content, post.content
+    assert_equal rating, post.rating
 
-    post.title = @new_title
+    post.title = new_title
     post.save
 
     post = Entry.first
-    assert_equal @new_title, post.title
+    assert_equal new_title, post.title
   end
 
   def test_destroy_entry
+    user = User.create! :login => "something"
+    Entry.create! :title => '1', :content => '', :rating => 1.0, :user => user
+    Entry.create! :title => '2', :content => '', :rating => 2.0, :user => user
+    
     prev_count = Entry.count
-    post = Entry.first
-    post.destroy
+    entry = Entry.first
+    entry.destroy
 
     assert_equal prev_count - 1, Entry.count
   end
@@ -255,7 +289,7 @@ module SimpleTestMethods
 
     def test_save_time_with_zone
       t = Time.now
-      #precision will only be expected to the second.
+      # 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
@@ -268,7 +302,7 @@ module SimpleTestMethods
 
     def test_save_date_time
       t = Time.now
-      #precision will only be expected to the second.
+      # 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
@@ -326,64 +360,65 @@ module SimpleTestMethods
     e.save!
 
     e = DbType.first
-    assert_equal(12.0, e.sample_float)
+    assert_equal 12.0, e.sample_float
   end
-
+  
   def test_boolean
-    # An unset boolean should default to nil
     e = DbType.first
-    assert_equal(nil, e.sample_boolean)
+    assert_nil e.sample_boolean # unset boolean should default to nil
 
+    e.update_attributes :sample_boolean => false
+
+    e = DbType.first
+    assert_equal false, e.sample_boolean
+    
     e.sample_boolean = true
     e.save!
 
     e = DbType.first
-    assert_equal(true, e.sample_boolean)
+    assert_equal true, e.sample_boolean
   end
 
   def test_integer
-    # An unset boolean should default to nil
     e = DbType.first
-    assert_equal(nil, e.sample_integer)
+    assert_nil e.sample_integer
 
     e.sample_integer = 10
     e.save!
 
     e = DbType.first
-    assert_equal(10, e.sample_integer)
+    assert_equal 10, e.sample_integer
   end
 
   def test_text
-    # An unset boolean should default to nil
     e = DbType.first
-
     assert_null_text e.sample_text
 
     e.sample_text = "ooop?"
     e.save!
 
     e = DbType.first
-    assert_equal("ooop?", e.sample_text)
+    assert_equal "ooop?", e.sample_text
   end
 
   def test_string
     e = DbType.first
-
     assert_empty_string e.sample_string
 
     e.sample_string = "ooop?"
     e.save!
 
     e = DbType.first
-    assert_equal("ooop?", e.sample_string)
+    assert_equal "ooop?", e.sample_string
   end
 
   def test_save_binary
-    #string is 60_000 bytes
+    # string is 60_000 bytes
     binary_string = "\000ABCDEFGHIJKLMNOPQRSTUVWXYZ'\001\003" * 1 # 2_000
     e = DbType.first
     e.sample_binary = binary_string
     e.save!
+    
     e = DbType.first
     assert_equal binary_string, e.sample_binary
   end
@@ -419,23 +454,32 @@ module SimpleTestMethods
   end
 
   def test_indexes
-    # Only test indexes if we have implemented it for the particular adapter
-    if connection.respond_to?(:indexes)
-      indexes = connection.indexes(:entries)
-      assert_equal(0, indexes.size)
-
-      index_name = "entries_index"
-      connection.add_index(:entries, :updated_on, :name => index_name)
-
-      indexes = connection.indexes(:entries)
-      assert_equal(1, indexes.size)
-      assert_equal "entries", indexes.first.table.to_s
-      assert_equal index_name, indexes.first.name
-      assert !indexes.first.unique
-      assert_equal ["updated_on"], indexes.first.columns
-    else
-      puts "indexes not implemented for adapter: #{connection}"
-    end
+    indexes = connection.indexes(:entries)
+    assert_equal 0, indexes.size
+
+    connection.add_index :entries, :updated_on
+    connection.add_index :entries, [ :title, :user_id ], :unique => true, 
+                         :name => 'x_entries_on_title_and_user_id' # <= 30 chars
+
+    indexes = connection.indexes(:entries)
+    assert_equal 2, indexes.size
+    
+    assert_not_nil title_index = indexes.find { |index| index.unique }
+
+    assert_equal "entries", title_index.table.to_s
+    assert_true title_index.unique
+    assert_equal [ 'title', 'user_id' ], title_index.columns
+    
+    updated_index = (indexes - [ title_index ]).first
+    
+    assert_equal "entries", updated_index.table.to_s
+    assert_equal "index_entries_on_updated_on", updated_index.name
+    assert ! updated_index.unique
+    assert_equal [ 'updated_on' ], updated_index.columns
+    
+    connection.remove_index :entries, :updated_on
+    indexes = connection.indexes(:entries)
+    assert_equal 1, indexes.size
   end
 
   def test_nil_values
@@ -453,14 +497,20 @@ module SimpleTestMethods
   end
 
   def test_invalid
-    e = Entry.new(:title => @title, :content => @content, :rating => ' ')
+    title = "First post!"
+    content = "Hello from JRuby on Rails!"
+    rating = 205.76
+    user = User.create! :login => "something"
+    Entry.create! :title => title, :content => content, :rating => rating, :user => user
+    
+    e = Entry.new(:title => title, :content => content, :rating => ' ')
     assert e.valid?
   end
 
   def test_reconnect
-    assert_equal 1, Entry.count
+    assert_equal 1, DbType.count
     ActiveRecord::Base.connection.reconnect!
-    assert_equal 1, Entry.count
+    assert_equal 1, DbType.count
   end
 
   if defined?(JRUBY_VERSION)
@@ -480,20 +530,19 @@ module SimpleTestMethods
 
     class Animal < ActiveRecord::Base; end
 
-    def test_fetching_columns_for_nonexistent_table_should_raise
-      assert_raise(ActiveRecord::ActiveRecordError,
-                    ActiveRecord::StatementInvalid, ActiveRecord::JDBCError) do
+    def test_fetching_columns_for_nonexistent_table
+      assert_raise(ActiveRecord::ActiveRecordError, ActiveRecord::StatementInvalid, ActiveRecord::JDBCError) do
         Animal.columns
       end
     end
   end
 
   def test_disconnect
-    assert_equal 1, Entry.count
+    assert_equal 1, DbType.count
     ActiveRecord::Base.clear_active_connections!
     ActiveRecord::Base.connection_pool.disconnect! if ActiveRecord::Base.respond_to?(:connection_pool)
     assert !ActiveRecord::Base.connected?
-    assert_equal 1, Entry.count
+    assert_equal 1, DbType.count
     assert ActiveRecord::Base.connected?
   end
 
@@ -731,7 +780,150 @@ module SimpleTestMethods
 
     assert_equal content_json, post.reload.content
   end
+  
+  def test_exec_insert
+    name_column = Thing.columns.detect { |column| column.name.to_s == 'name' }
+    created_column = Thing.columns.detect { |column| column.name.to_s == 'created_at' }
+    updated_column = Thing.columns.detect { |column| column.name.to_s == 'updated_at' }
+    now = Time.zone.now
+    
+    binds = [ [ name_column, 'ferko' ], [ created_column, now ], [ updated_column, now ] ]
+    connection.exec_insert "INSERT INTO things VALUES (?,?,?)", 'INSERT_1', binds
+    assert Thing.find_by_name 'ferko'
+    # NOTE: #exec_insert accepts 5 arguments on AR-4.0 :
+    binds = [ [ name_column, 'jozko' ], [ created_column, now ], [ updated_column, now ] ]
+    connection.exec_insert "INSERT INTO things VALUES (?,?,?)", 'INSERT_2', binds, nil, nil
+    assert Thing.find_by_name 'jozko'
+  end
+  
+  def test_exec_query_result
+    Entry.delete_all
+    user1 = User.create! :login => 'user1'
+    user2 = User.create! :login => 'user2'
+    Entry.create! :title => 'user11', :user_id => user1.id
+    Entry.create! :title => 'user12', :user_id => user1.id
+    Entry.create! :title => 'user21', :user_id => user2.id
+    
+    result = Entry.connection.exec_query 'SELECT * FROM entries'
+    
+    if ar_version('3.1')
+      assert_instance_of ActiveRecord::Result, result
+      assert_not_empty result.columns
+      columns = Entry.columns.map { |column| column.name.to_s }
+      assert_equal Set.new(columns), Set.new(result.columns)
+      
+      assert_equal 3, result.rows.size
+      assert_instance_of Array, result.rows[0]
+      assert_equal 'user11', result.rows[0][1]
+      assert_equal 'user12', result.rows[1][1]
+    else
+      assert_instance_of Array, result
+      assert_equal 3, result.size
+      assert_instance_of Hash, result[0]
+      assert_equal 'user11', result[0]['title']
+      assert_equal user1.id, result[0]['user_id']
+    end
+  end
+
+  def test_exec_query_empty_result
+    Entry.delete_all; User.delete_all
+    
+    result = User.connection.exec_query 'SELECT * FROM users'
+    
+    if ar_version('3.1')
+      assert_instance_of ActiveRecord::Result, result
+      assert_not_empty result.columns
+      columns = User.columns.map { |column| column.name.to_s }
+      assert_equal Set.new(columns), Set.new(result.columns)
+      
+      assert_equal 0, result.rows.size
+    else
+      assert_instance_of Array, result
+      assert_equal 0, result.size
+    end
+  end
+  
+  def test_exec_query_raw
+    User.delete_all
+    User.create! :login => 'user1'
+    User.create! :login => 'user2'
+    
+    result = User.connection.exec_query_raw 'SELECT * FROM users'
+    
+    assert_instance_of Array, result
+    assert_equal 2, result.size
+    assert_instance_of Hash, result[0]
+    assert_equal 'user1', result[0]['login']
+    assert_equal 'user2', result[1]['login']
+  end
+  
+  def test_select
+    Entry.delete_all
+    user = User.create! :login => 'select'
+    Entry.create! :title => 'title 1', :content => 'content 1', :user_id => user.id, :rating => 1.0
+    Entry.create! :title => 'title 2', :content => 'content 2', :user_id => user.id, :rating => 2.0
+    
+    # rows = connection.execute 'SELECT * FROM entries'
+    # column_order = rows.first.keys
+    
+    result = connection.select 'SELECT * FROM entries'
+    
+    if ar_version('4.0')
+      assert_instance_of ActiveRecord::Result, result
+      assert_equal 2, result.rows.size
+    else
+      assert_instance_of Array, result
+      assert_equal 2, result.size
+    end
+  end
 
+  def test_select_rows
+    Entry.delete_all
+    user = User.create! :login => 'select_rows'
+    Entry.create! :title => 'title 1', :content => 'content 1', :user_id => user.id
+    Entry.create! :title => 'title 2', :content => 'content 2', :user_id => user.id, :rating => 1.0
+    
+    rows = connection.execute 'SELECT * FROM entries'
+    column_order = rows.first.keys
+    
+    rows = connection.select_rows 'SELECT * FROM entries'
+    assert_instance_of Array, rows
+    assert_equal 2, rows.size
+    
+    row = rows[0]
+    column_order.each_with_index do |column, i|
+      case column.to_s
+      when 'id' then assert_not_nil row[i]
+      when 'title' then assert_equal 'title 1', row[i]
+      when 'content' then assert_equal 'content 1', row[i]
+      when 'user_id' then assert_equal user.id, row[i]
+      when 'rating' then assert_nil row[i]
+      when 'updated_on' then assert_not_nil row[i]
+      else raise "unexpected entries row: #{column.inspect}"
+      end
+    end
+    
+    row = rows[1]
+    column_order.each_with_index do |column, i|
+      case column.to_s
+      when 'id' then assert_not_nil row[i]
+      when 'title' then assert_equal 'title 2', row[i]
+      when 'content' then assert_equal 'content 2', row[i]
+      when 'user_id' then assert_equal user.id, row[i]
+      when 'rating' then assert_not_nil row[i]
+      when 'updated_on' then assert_not_nil row[i]
+      else raise "unexpected entries row: #{column.inspect}"
+      end
+    end
+  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
+  end
+  
   protected
   
   def assert_date_type(value)
@@ -822,32 +1014,65 @@ end
 module XmlColumnTests
   
   def self.included(base)
-    base.send :include, Tests if ActiveRecord::VERSION::MAJOR > 3 ||
-      (ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR >= 1)
+    base.send :include, TestMethods if base.ar_version('3.1')
   end
   
-  module Tests
+  class XmlModel < ActiveRecord::Base; end
+  
+  module TestMethods
     
     def test_create_xml_column
-      connection.create_table :xml_testings do |t|
-        t.xml :xml_test
-      end
+      create_xml_models!
 
-      xml_column = connection.columns(:xml_testings).detect do |c|
-        c.name == "xml_test"
+      xml_column = connection.columns(:xml_models).detect do |c|
+        c.name == "xml_col"
       end
       
-      assert_equal xml_sql_type, xml_column.sql_type
+      assert_xml_type xml_column.sql_type
+    ensure
+      drop_xml_models! rescue false
+    end
+
+    def test_use_xml_column
+      if created = ( ( create_xml_models! || true ) rescue nil )
+
+        XmlModel.create! :xml_col => "<xml><LoVE><![CDATA[Rubyist's <3 XML!]]></LoVE></xml>"
+    
+        assert xml_model = XmlModel.first
+
+        unless xml_sql_type =~ /text/i
+          require 'rexml/document'
+          doc = REXML::Document.new xml_model.xml_col
+          assert_equal "Rubyist's <3 XML!", doc.root.elements.first.text
+        end
+          
+      else
+        puts "test_use_xml_column skipped"
+      end
     ensure
-      connection.drop_table :xml_testings rescue nil
+      drop_xml_models! if created
     end
     
     protected
     
+    def assert_xml_type sql_type
+      assert_equal xml_sql_type, sql_type
+    end
+    
     def xml_sql_type
       'text'
     end
     
+    private
+    
+    def create_xml_models!
+      connection.create_table(:xml_models) { |t| t.xml :xml_col }
+    end
+
+    def drop_xml_models!
+      connection.drop_table(:xml_models)
+    end
+    
   end
   
 end
@@ -855,10 +1080,10 @@ end
 module ActiveRecord3TestMethods
   
   def self.included(base)
-    base.send :include, Tests if ActiveRecord::VERSION::MAJOR == 3
+    base.send :include, TestMethods if base.ar_version('3.0')
   end
 
-  module Tests
+  module TestMethods
     
     def test_visitor_accessor
       adapter = Entry.connection
@@ -869,8 +1094,11 @@ module ActiveRecord3TestMethods
     end if Test::Unit::TestCase.ar_version('3.2') # >= 3.2
     
     def test_where
-      entries = Entry.where(:title => @entry.title)
-      assert_equal @entry, entries.first
+      user = User.create! :login => "blogger"
+      entry = Entry.create! :title => 'something', :content => 'JRuby on Rails !', :rating => 42.1, :user => user
+      
+      entries = Entry.where(:title => entry.title)
+      assert_equal entry, entries.first
     end
 
     def test_remove_nonexistent_index
@@ -892,6 +1120,7 @@ module ActiveRecord3TestMethods
       end
       assert_equal 1, Thing.find(:all).size
     end
+    
   end
   
 end
@@ -986,3 +1215,29 @@ module ExplainSupportTestMethods
   end
   
 end
+
+module CustomSelectTestMethods
+  
+  def test_custom_select_float
+    model = DbType.create! :sample_float => 1.42
+    if ActiveRecord::VERSION::MAJOR >= 3
+      model = DbType.where("id = #{model.id}").select('sample_float AS custom_sample_float').first
+    else
+      model = DbType.find(:first, :conditions => "id = #{model.id}", :select => 'sample_float AS custom_sample_float')
+    end
+    assert_equal 1.42, model.custom_sample_float
+    assert_instance_of Float, model.custom_sample_float
+  end
+
+  def test_custom_select_decimal
+    model = DbType.create! :sample_small_decimal => ( decimal = BigDecimal.new('5.45') )
+    if ActiveRecord::VERSION::MAJOR >= 3
+      model = DbType.where("id = #{model.id}").select('sample_small_decimal AS custom_decimal').first
+    else
+      model = DbType.find(:first, :conditions => "id = #{model.id}", :select => 'sample_small_decimal AS custom_decimal')
+    end
+    assert_equal decimal, model.custom_decimal
+    assert_instance_of BigDecimal, model.custom_decimal
+  end
+  
+end