activerecord-jdbc-adapter 1.2.9.1 → 1.3.0.beta1

data/test/db/sqlite3/has_many_though_test.rb

@@ -0,0 +1,6 @@
+require 'db/sqlite3'
+require 'has_many_through'
+
+class SQLite3HasManyThroughTest < Test::Unit::TestCase
+  include HasManyThroughMethods
+end

data/test/{sqlite3_simple_test.rb → db/sqlite3/simple_test.rb}

@@ -1,13 +1,8 @@
-require 'jdbc_common'
 require 'db/sqlite3'
 require 'models/data_types'
 require 'models/validates_uniqueness_of_string'
-
-#module Rails
-#  def self.logger
-#    ActiveRecord::Base.logger
-#  end
-#end
+require 'simple'
+require 'jdbc_common'
 
 class SQLite3SimpleTest < Test::Unit::TestCase
   include SimpleTestMethods
@@ -15,7 +10,9 @@ class SQLite3SimpleTest < Test::Unit::TestCase
   include ColumnNameQuotingTests
   include DirtyAttributeTests
   include XmlColumnTests
-
+  include ExplainSupportTestMethods if ar_version("3.1")
+  include CustomSelectTestMethods
+  
   def test_recreate_database
     assert connection.tables.include?(Entry.table_name)
     db = connection.database_name
@@ -25,6 +22,9 @@ class SQLite3SimpleTest < Test::Unit::TestCase
   end
 
   def test_execute_insert
+    user = User.create! :login => 'user1'
+    Entry.create! :title => 'E1', :user_id => user.id
+    
     assert_equal 1, Entry.count
     id = connection.execute "INSERT INTO entries (title, content) VALUES ('Execute Insert', 'This now works with SQLite3')"
     assert_equal Entry.last.id, id
@@ -32,6 +32,9 @@ class SQLite3SimpleTest < Test::Unit::TestCase
   end
 
   def test_execute_update
+    user = User.create! :login => 'user1'
+    Entry.create! :title => 'E1', :user_id => user.id
+    
     affected_rows = connection.execute "UPDATE entries SET title = 'Execute Update' WHERE id = #{Entry.first.id}"
     assert_equal 1, affected_rows
     assert_equal 'Execute Update', Entry.first.title
@@ -85,21 +88,26 @@ class SQLite3SimpleTest < Test::Unit::TestCase
   end
 
   def test_rename_column_preserves_content
-    post = Entry.first
-    assert_equal @title, post.title
-    assert_equal @content, post.content
-    assert_equal @rating, post.rating
-
-    assert_nothing_raised do
-      ActiveRecord::Schema.define do
-        rename_column "entries", "title", "name"
-      end
+    title = "First post!"
+    content = "Hello from JRuby on Rails!"
+    rating = 205.76
+    user = User.create! :login => "something"
+    entry = Entry.create! :title => title, :content => content, :rating => rating, :user => user
+    
+    entry.reload
+    #assert_equal title, entry.title
+    #assert_equal content, entry.content
+    #assert_equal rating, entry.rating
+
+    ActiveRecord::Schema.define do
+      rename_column "entries", "title", "name"
+      rename_column "entries", "rating", "popularity"
     end
-
-    post = Entry.first
-    assert_equal @title, post.name
-    assert_equal @content, post.content
-    assert_equal @rating, post.rating
+    
+    entry = Entry.find(entry.id)
+    assert_equal title, entry.name
+    assert_equal content, entry.content
+    assert_equal rating, entry.popularity
   end
 
   def test_rename_column_preserves_index
@@ -107,30 +115,26 @@ class SQLite3SimpleTest < Test::Unit::TestCase
 
     index_name = "entries_index"
 
-    assert_nothing_raised do
-      ActiveRecord::Schema.define do
-        add_index "entries", "title", :name => index_name
-      end
+    ActiveRecord::Schema.define do
+      add_index "entries", "title", :name => index_name
     end
 
     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 ! indexes.first.unique
     assert_equal ["title"], indexes.first.columns
 
-    assert_nothing_raised do
-      ActiveRecord::Schema.define do
-        rename_column "entries", "title", "name"
-      end
+    ActiveRecord::Schema.define do
+      rename_column "entries", "title", "name"
     end
 
     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 ! indexes.first.unique
     assert_equal ["name"], indexes.first.columns
   end
 
@@ -141,11 +145,9 @@ class SQLite3SimpleTest < Test::Unit::TestCase
       end
     end
 
-    cols = ActiveRecord::Base.connection.columns("entries")
-    col = cols.find{|col| col.name == "test_column_default"}
-    assert col
-    assert_equal col.default, nil
-
+    columns = ActiveRecord::Base.connection.columns("entries")
+    assert column = columns.find{ |c| c.name == "test_column_default" }
+    assert_equal column.default, nil
   end
 
   def test_change_column_default
@@ -155,10 +157,9 @@ class SQLite3SimpleTest < Test::Unit::TestCase
       end
     end
 
-    cols = ActiveRecord::Base.connection.columns("entries")
-    col = cols.find{|col| col.name == "test_change_column_default"}
-    assert col
-    assert_equal col.default, 'unchanged'
+    columns = ActiveRecord::Base.connection.columns("entries")
+    assert column = columns.find{ |c| c.name == "test_change_column_default" }
+    assert_equal column.default, 'unchanged'
 
     assert_nothing_raised do
       ActiveRecord::Schema.define do
@@ -166,10 +167,9 @@ class SQLite3SimpleTest < Test::Unit::TestCase
       end
     end
 
-    cols = ActiveRecord::Base.connection.columns("entries")
-    col = cols.find{|col| col.name == "test_change_column_default"}
-    assert col
-    assert_equal col.default, 'changed'
+    columns = ActiveRecord::Base.connection.columns("entries")
+    assert column = columns.find{ |c| c.name == "test_change_column_default" }
+    assert_equal column.default, 'changed'
   end
 
   def test_change_column
@@ -179,10 +179,9 @@ class SQLite3SimpleTest < Test::Unit::TestCase
       end
     end
 
-    cols = ActiveRecord::Base.connection.columns("entries")
-    col = cols.find{|col| col.name == "test_change_column"}
-    assert col
-    assert_equal col.type, :string
+    columns = ActiveRecord::Base.connection.columns("entries")
+    assert column = columns.find{ |c| c.name == "test_change_column" }
+    assert_equal column.type, :string
 
     assert_nothing_raised do
       ActiveRecord::Schema.define do
@@ -190,10 +189,9 @@ class SQLite3SimpleTest < Test::Unit::TestCase
       end
     end
 
-    cols = ActiveRecord::Base.connection.columns("entries")
-    col = cols.find{|col| col.name == "test_change_column"}
-    assert col
-    assert_equal col.type, :integer
+    columns = ActiveRecord::Base.connection.columns("entries")
+    assert column = columns.find{ |c| c.name == "test_change_column" }
+    assert_equal column.type, :integer
   end
 
   def test_change_column_with_new_precision_and_scale
@@ -233,10 +231,8 @@ class SQLite3SimpleTest < Test::Unit::TestCase
     assert Entry.all.empty?
   end
   
-  # #override
+  # @override
   def test_big_decimal
-    #ActiveRecord::Base.logger.level = Logger::DEBUG
-
     test_value = 1234567890.0 # FINE just like native adapter
     db_type = DbType.create!(:big_decimal => test_value)
     db_type = DbType.find(db_type.id)
@@ -255,14 +251,18 @@ class SQLite3SimpleTest < Test::Unit::TestCase
     # TODO native gets us 12345678901234567000.0 JDBC gets us 1
     #assert_equal test_value, db_type.big_decimal
     #super
-  ensure
-    #ActiveRecord::Base.logger.level = Logger::WARN
   end
   
-  include ExplainSupportTestMethods if ar_version("3.1")
+  # @override SQLite3 returns FLOAT (JDBC type) for DECIMAL columns
+  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
-
-class SQLite3HasManyThroughTest < Test::Unit::TestCase
-  include HasManyThroughMethods
-end

data/test/db/sqlite3/transaction_test.rb

@@ -0,0 +1,32 @@
+require 'db/sqlite3'
+require 'transaction'
+
+class SQLite3TransactionTest < Test::Unit::TestCase
+  include TransactionTestMethods
+  
+  def test_supports_transaction_isolation
+    assert ActiveRecord::Base.connection.supports_transaction_isolation?
+    # NOTE: adapter tell us it supports but JDBC meta-data API returns false ?!
+    #assert ActiveRecord::Base.connection.supports_transaction_isolation?(:read_uncommitted)
+    assert ActiveRecord::Base.connection.supports_transaction_isolation?(:serializable)
+  end
+  
+  # supports only TRANSACTION_SERIALIZABLE and TRANSACTION_READ_UNCOMMITTED
+  
+  def test_transaction_isolation_read_committed
+    assert ! ActiveRecord::Base.connection.supports_transaction_isolation?(:read_committed)
+    
+    assert_raise ActiveRecord::TransactionIsolationError do
+      super
+    end
+  end if Test::Unit::TestCase.ar_version('4.0')
+  
+  def test_transaction_isolation_repeatable_read
+    assert ! ActiveRecord::Base.connection.supports_transaction_isolation?(:repeatable_read)
+    
+    assert_raise ActiveRecord::TransactionIsolationError do
+      super
+    end
+  end if Test::Unit::TestCase.ar_version('4.0')
+  
+end

data/test/has_many_through.rb

@@ -1,78 +1,25 @@
-class CreateRbac < 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
+require 'models/rights_and_roles'
 
 module HasManyThroughMethods
+  
   def setup
-    CreateRbac.up
+    CreateRightsAndRoles.up
   end
 
   def teardown
-    CreateRbac.down
+    CreateRightsAndRoles.down
   end
 
   def test_has_many_through
-    admin_role    = Role.create( {:name => "Administrator", :description => "System defined super user - access to right and role management."} )
-    admin_role.save!
+    admin_role = Role.create! :name => "Administrator", 
+      :description => "super user - access to right and role management"
 
     assert_equal(0, admin_role.rights.sum(:hours))
 
-    role_rights   = Right.create( {:name => "Administrator - Full Access To Roles", :actions => "*", :controller_name => "Admin::RolesController", :hours => 0} )
-    right_rights  = Right.create( {:name => "Administrator - Full Access To Rights", :actions => "*", :controller_name => "Admin::RightsController", :hours => 1.5} )
+    role_rights  = Right.create :name => "Administrator - Full Access To Roles", 
+      :actions => "*", :controller_name => "Admin::RolesController", :hours => 0
+    right_rights = Right.create :name => "Administrator - Full Access To Rights", 
+      :actions => "*", :controller_name => "Admin::RightsController", :hours => 1.5
 
     admin_role.rights << role_rights
     admin_role.rights << right_rights
@@ -80,7 +27,8 @@ module HasManyThroughMethods
 
     assert_equal(1.5, admin_role.rights.sum(:hours))
     
-    rights_only_role = Role.create!(:name => "Rights Manager", :description => "access to rights management")
+    rights_only_role = Role.create! :name => "Rights Manager", 
+      :description => "access to rights management"
     rights_only_role.rights << right_rights
     rights_only_role.save!
     rights_only_role.reload
@@ -90,4 +38,21 @@ module HasManyThroughMethods
     assert admin_role.reload.has_right?(role_rights)
     assert ! rights_only_role.has_right?(role_rights)
   end
+  
+  def test_has_many_select_rows_with_relation
+    role = Role.create! :name => "main", :description => "main role"
+    Role.create! :name => "user", :description => "user role"
+    
+    Right.create! :name => "r0", :hours => 0
+    r1 = Right.create! :name => "r1", :hours => 1
+    r2 = Right.create! :name => "r2", :hours => 2
+    Right.create! :name => "r3", :hours => 3
+    
+    role.permission_groups.create! :right => r1.reload
+    role.permission_groups.create! :right => r2.reload
+    
+    groups = role.reload.permission_groups.select('right_id')
+    assert_equal [ [ r1.id ], [ r2.id ] ], role.connection.select_rows(groups)
+  end if Test::Unit::TestCase.ar_version('3.0')
+  
 end

data/test/jdbc/oracle.rb

@@ -8,8 +8,19 @@ module Jdbc
       end
     end
 
+    def self.optional_jars
+      [ 'xdb6.jar', 'orai18n.jar' ] # 'xmlparserv2.jar'
+    end
+    
     def self.load_driver(method = :load)
       send method, driver_jar
+      optional_jars.each do |optional_jar|
+        begin
+          send method, optional_jar
+        rescue LoadError => e
+          puts "failed to load optional driver jar: #{optional_jar} (#{e})"
+        end
+      end
     end
 
     def self.driver_name

data/test/jndi_test.rb

@@ -8,10 +8,19 @@ require 'db/jndi_config'
 class DerbyJndiTest < Test::Unit::TestCase
   include SimpleTestMethods
 
+  # Derby specifics :
+  DbTypeMigration.big_decimal_precision = 31
+  ALIVE_SQL = 'SELECT 1 FROM SYS.SYSSCHEMAS'
+  
   def self.startup
-    ActiveRecord::Base.establish_connection JNDI_CONFIG
+    ActiveRecord::Base.establish_connection( {
+        :connection_alive_sql => ALIVE_SQL 
+    }.merge(JNDI_CONFIG) )
   end
 
+  # @override
+  #def test_connection_alive_sql; end
+  
   test "(raw) connection is a jndi connection" do
     connection = ActiveRecord::Base.connection.raw_connection
     assert_true connection.jndi_connection?
@@ -37,13 +46,16 @@ require 'db/jndi_pooled_config'
 
 class DerbyJndiPooledTest < Test::Unit::TestCase
   include SimpleTestMethods
-
-  DbTypeMigration.big_decimal_precision = 31
   
   def self.startup
-    ActiveRecord::Base.establish_connection JNDI_POOLED_CONFIG
+    ActiveRecord::Base.establish_connection( {
+        :connection_alive_sql => DerbyJndiTest::ALIVE_SQL 
+    }.merge(JNDI_POOLED_CONFIG) )
   end
 
+  # @override
+  #def test_connection_alive_sql; end
+  
   test "(raw) connection is a jndi connection" do
     connection = ActiveRecord::Base.connection.raw_connection
     assert_true connection.jndi_connection?