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

data/test/db/sqlite3/rake_test.rb

@@ -0,0 +1,71 @@
+require 'rake_test_support'
+require 'db/sqlite3'
+
+class SQLite3RakeTest < Test::Unit::TestCase
+  include RakeTestSupport
+  
+  def db_name; 'rake_test.sqlite3'; end
+  
+  def do_setup
+    File.delete('rake_test.sqlite3') if File.exists?('rake_test.sqlite3')
+  end
+  
+  def do_teardown
+    File.delete('rake_test.sqlite3') if File.exists?('rake_test.sqlite3')
+  end
+
+  test 'rake db:create (and db:drop)' do
+    Rake::Task["db:create"].invoke
+    assert_true File.exists?('rake_test.sqlite3')
+    
+    Rake::Task["db:drop"].invoke
+    assert_false File.exists?('rake_test.sqlite3')
+  end
+  
+  test 'rake db:test:purge' do
+    # Rake::Task["db:create"].invoke
+    ActiveRecord::Base.establish_connection db_config.merge :database => db_name
+    ActiveRecord::Base.connection.create_table('users') { |t| t.string :name }
+    ActiveRecord::Base.connection.disconnect!
+    
+    Rake::Task["db:test:purge"].invoke
+    
+    ActiveRecord::Base.establish_connection db_config.merge :database => db_name
+    assert_false ActiveRecord::Base.connection.table_exists?('users')
+    ActiveRecord::Base.connection.disconnect!
+  end
+  
+  test 'rake db:structure:dump (and db:structure:load)' do
+    omit('sqlite3 not available') unless self.class.find_executable?('sqlite3')
+    create_rake_test_database do |connection|
+      create_schema_migrations_table(connection)
+      connection.create_table('users') { |t| t.string :name; t.timestamps }
+    end
+    
+    structure_sql = File.join('db', structure_sql_filename)
+    begin
+      Dir.mkdir 'db' # db/structure.sql
+      Rake::Task["db:structure:dump"].invoke
+      
+      assert File.exists?(structure_sql)
+      assert_match /CREATE TABLE .*?users/, File.read(structure_sql)
+      
+      # db:structure:load
+      File.delete('rake_test.sqlite3')
+      Rake::Task["db:structure:load"].invoke
+      
+      ActiveRecord::Base.establish_connection db_config.merge :database => db_name
+      assert ActiveRecord::Base.connection.table_exists?('users')
+      ActiveRecord::Base.connection.disconnect!
+    ensure
+      File.delete(structure_sql) if File.exists?(structure_sql)
+      Dir.rmdir 'db'
+    end
+  end
+  
+  test 'rake db:charset' do
+    expect_rake_output('UTF-8')
+    Rake::Task["db:charset"].invoke
+  end
+  
+end

data/test/db/sqlite3/simple_test.rb

@@ -55,26 +55,26 @@ class SQLite3SimpleTest < Test::Unit::TestCase
     cols = ActiveRecord::Base.connection.columns("entries")
     assert cols.find {|col| col.name == "test_remove_column"}
 
-    assert_nothing_raised do
+    #assert_nothing_raised do
       ActiveRecord::Schema.define do
         remove_column "entries", "test_remove_column"
       end
-    end
+    #end
 
     cols = ActiveRecord::Base.connection.columns("entries")
-    assert !cols.find {|col| col.name == "test_remove_column"}
+    assert_nil cols.find {|col| col.name == "test_remove_column"}
   end
 
   def test_rename_column
-    assert_nothing_raised do
+    #assert_nothing_raised do
       ActiveRecord::Schema.define do
         rename_column "entries", "title", "name"
       end
-    end
+    #end
 
     cols = ActiveRecord::Base.connection.columns("entries")
-    assert cols.find {|col| col.name == "name"}
-    assert !cols.find {|col| col.name == "title"}
+    assert_not_nil cols.find {|col| col.name == "name"}
+    assert_nil cols.find {|col| col.name == "title"}
 
     assert_nothing_raised do
       ActiveRecord::Schema.define do
@@ -83,8 +83,8 @@ class SQLite3SimpleTest < Test::Unit::TestCase
     end
 
     cols = ActiveRecord::Base.connection.columns("entries")
-    assert cols.find {|col| col.name == "title"}
-    assert !cols.find {|col| col.name == "name"}
+    assert_not_nil cols.find {|col| col.name == "title"}
+    assert_nil cols.find {|col| col.name == "name"}
   end
 
   def test_rename_column_preserves_content

data/test/has_many_through.rb

@@ -51,8 +51,11 @@ module HasManyThroughMethods
     role.permission_groups.create! :right => r1.reload
     role.permission_groups.create! :right => r2.reload
     
+    connection = ActiveRecord::Base.connection
     groups = role.reload.permission_groups.select('right_id')
-    assert_equal [ [ r1.id ], [ r2.id ] ], role.connection.select_rows(groups)
+    
+    pend 'todo: is this really supposed to work ?!' if ar_version('4.0')
+    assert_equal [ [ r1.id ], [ r2.id ] ], connection.select_rows(groups)
   end if Test::Unit::TestCase.ar_version('3.0')
   
 end

data/test/jdbc/db2.rb

@@ -13,7 +13,20 @@ module Jdbc
     end
 
     def self.driver_name
-      'com.ibm.db2.jcc.DB2Driver'
+      'com.ibm.db2.jcc.DB2Driver' # ArJdbc::DB2::DRIVER_NAME
+    end
+  end
+  module AS400
+    def self.driver_jar
+      "jt400.jar"
+    end
+
+    def self.load_driver(method = :load)
+      send method, driver_jar
+    end
+
+    def self.driver_name
+      'com.ibm.as400.access.AS400JDBCDriver' # ArJdbc::AS400::DRIVER_NAME
     end
   end
 end

data/test/jdbc_column_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+require 'arjdbc/jdbc'
+
+require 'arjdbc/mysql'
+require 'arjdbc/postgresql'
+require 'arjdbc/sqlite3'
+
+class JdbcColumnTest < Test::Unit::TestCase
+
+  test 'modules' do
+    assert_include ArJdbc.modules, ArJdbc::MySQL
+    assert_include ArJdbc.modules, ArJdbc::PostgreSQL
+    assert_include ArJdbc.modules, ArJdbc::SQLite3
+  end
+
+  test 'column types' do
+    types = ActiveRecord::ConnectionAdapters::JdbcColumn.column_types
+    assert_kind_of Proc, types[ /mysql/i ]
+    assert_kind_of Proc, types[ /sqlite/i ]
+  end
+  
+end

data/test/{generic_jdbc_connection_test.rb → jdbc_connection_test.rb}

@@ -1,7 +1,7 @@
 require 'jdbc_common'
 require 'db/jdbc'
 
-class GenericJdbcConnectionTest < Test::Unit::TestCase
+class JdbcConnectionTest < Test::Unit::TestCase
 
   def test_connection_available_through_jdbc_adapter
      ActiveRecord::Base.connection.execute("show databases") # MySQL
@@ -47,6 +47,16 @@ class GenericJdbcConnectionTest < Test::Unit::TestCase
     end
   end
 
+  test 'calls configure_connection on reconnect!' do
+    connection = ActiveRecord::Base.connection
+    unless connection.respond_to?(:configure_connection)
+      fail "no configure_connection for #{connection} can not test"
+    end
+    ActiveRecord::Base.connection.disconnect!
+    ActiveRecord::Base.connection.expects(:configure_connection).once
+    ActiveRecord::Base.connection.reconnect!
+  end
+  
   class MockDriver < ActiveRecord::ConnectionAdapters::JdbcDriver
     
     class DriverImpl 
@@ -94,29 +104,29 @@ class GenericJdbcConnectionTest < Test::Unit::TestCase
       ActiveRecord::Base.connection.jdbc_connection
       fail "jdbc error not thrown"
     rescue  ActiveRecord::JDBCError => e
-      assert_match /driver encountered an unknown error: java.sql.SQLInvalidAuthorizationSpecException/, e.to_s
+      assert_match /java.sql.SQLInvalidAuthorizationSpecException/, e.to_s
       assert_kind_of Java::JavaSql::SQLNonTransientException, e.sql_exception
     ensure
       ActiveRecord::Base.establish_connection JDBC_CONFIG
     end
   end
   
-  class ConfigHelperTest < Test::Unit::TestCase
+  context 'configuration' do
 
-    test 'configure connection url' do
-      connection = Object.new
-      connection.extend ActiveRecord::ConnectionAdapters::JdbcConnection::ConfigHelper
+    test 'connection url' do
+      adapter = ActiveRecord::Base.connection
+      connection = adapter.raw_connection # JdbcConnection
       connection.config = { :url => "jdbc://somehost", :options => { :hoge => "true", :fuya => "false" } }
-      assert_equal "jdbc://somehost?hoge=true&fuya=false", connection.send(:configure_url)
+      assert_equal "jdbc://somehost?hoge=true&fuya=false", connection.send(:jdbc_url)
 
       connection.config = { :url => "jdbc://somehost?param=0", :options => { :hoge => "true", :fuya => false } }
-      assert_equal "jdbc://somehost?param=0&hoge=true&fuya=false", connection.send(:configure_url)
+      assert_equal "jdbc://somehost?param=0&hoge=true&fuya=false", connection.send(:jdbc_url)
     end
 
     test 'connection fails without driver and url' do
       with_connection_removed do
         ActiveRecord::Base.establish_connection :adapter => 'jdbc'
-        assert_raises(ActiveRecord::ConnectionNotEstablished) do
+        assert_raise ActiveRecord::ConnectionNotEstablished do
           ActiveRecord::Base.connection
         end
       end
@@ -125,7 +135,7 @@ class GenericJdbcConnectionTest < Test::Unit::TestCase
     test 'connection fails without driver' do
       with_connection_removed do
         ActiveRecord::Base.establish_connection :adapter => 'jdbc', :url => 'jdbc:derby:test.derby;create=true'
-        assert_raises(ActiveRecord::ConnectionNotEstablished) do
+        assert_raise ActiveRecord::ConnectionNotEstablished do
           ActiveRecord::Base.connection
         end
       end
@@ -176,14 +186,9 @@ class GenericJdbcConnectionTest < Test::Unit::TestCase
       end
     end
 
-    @@derby_driver_loaded = nil
-
     def load_derby_driver
-      @@derby_driver_loaded ||= begin
-        require 'jdbc/derby'
-        Jdbc::Derby.load_driver
-        true
-      end
+      require 'jdbc/derby'
+      Jdbc::Derby.load_driver(:require)
     end
 
   end

data/test/jndi_callbacks_test.rb

@@ -1,35 +1,33 @@
-require 'jdbc_common'
+require 'test_helper'
 require 'db/jndi_config'
 
 class JndiConnectionPoolCallbacksTest < Test::Unit::TestCase
-
-  def self.startup
-    ActiveRecord::Base.establish_connection JNDI_CONFIG
-  end
-
-  def setup
-    @logger = stub_everything "logger"
-    @config = JNDI_CONFIG
-    @connection = ActiveRecord::ConnectionAdapters::JdbcConnection.new @config
-    Entry.connection_pool.disconnect!
-    assert !Entry.connection_pool.connected?
-    class << Entry.connection_pool; public :instance_variable_set; end
+  
+  class Dummy < ActiveRecord::Base; end
+  
+  setup do
+    Dummy.establish_connection JNDI_CONFIG.dup
   end
-
-  def teardown
-    Entry.connection_pool.disconnect!
+  
+  teardown do
+    Dummy.remove_connection
   end
-
-  def test_should_call_hooks_on_checkout_and_checkin
-    @adapter = ActiveRecord::ConnectionAdapters::JdbcAdapter.new @connection, @logger, @config
-    Entry.connection_pool.instance_variable_set "@connections", [@adapter]
-    assert !@connection.active?
-
-    Entry.connection_pool.checkout
-    assert @connection.active?
-
-    Entry.connection_pool.checkin @adapter
-    assert !@connection.active?
+  
+  test 'calls hooks on checkout and checkin' do
+    connection = Dummy.connection_pool.checkout
+    assert_true connection.active?
+
+    # connection = Dummy.connection
+    Dummy.connection_pool.checkin connection
+    assert_false connection.active?
+    
+    pool = Dummy.connection_pool
+    assert_false pool.active_connection? if pool.respond_to?(:active_connection?)
+    assert_true pool.connection.active? # checks out
+    assert_true pool.active_connection? if pool.respond_to?(:active_connection?)
+    assert_true connection.active?
+    Dummy.connection_pool.disconnect!
+    assert_false connection.active?
   end
 
-end if ActiveRecord::Base.respond_to?(:connection_pool)
+end

data/test/jndi_test.rb

@@ -1,9 +1,5 @@
-# To support the connection pooling in the test, you'll need
-# commons-dbcp, commons-pool, and commons-collections.
-
-require 'jdbc_common'
-
 require 'db/jndi_config'
+require 'simple'
 
 class DerbyJndiTest < Test::Unit::TestCase
   include SimpleTestMethods
@@ -12,23 +8,20 @@ class DerbyJndiTest < Test::Unit::TestCase
   DbTypeMigration.big_decimal_precision = 31
   ALIVE_SQL = 'SELECT 1 FROM SYS.SYSSCHEMAS'
   
-  def self.startup
-    ActiveRecord::Base.establish_connection( {
-        :connection_alive_sql => ALIVE_SQL 
-    }.merge(JNDI_CONFIG) )
+  def setup
+    config = { :connection_alive_sql => ALIVE_SQL }.merge(JNDI_CONFIG)
+    ActiveRecord::Base.establish_connection config
+    super
   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?
     assert_true connection.jndi_connection?
   end
 
   test "fills username from data source meta-data if missing" do
     connection = ActiveRecord::Base.connection.raw_connection
-    assert_true connection.jndi_connection?
 
     config = { :jndi => JNDI_CONFIG[:jndi] }
     ArJdbc::Derby.adapter_matcher('Derby', config)
@@ -52,12 +45,10 @@ class DerbyJndiPooledTest < Test::Unit::TestCase
         :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?
     assert_true connection.jndi_connection?
   end
 

data/test/models/data_types.rb

@@ -23,9 +23,10 @@ class DbTypeMigration < ActiveRecord::Migration
       t.column :sample_integer, :integer, :limit => 5
       t.column :sample_integer_with_limit_2, :integer, :limit => 2
       t.column :sample_integer_with_limit_8, :integer, :limit => 8
-      t.column :sample_integer_no_limit, :integer
+      t.column :sample_integer_no_limit, :integer, :default => 42
       t.column :sample_integer_neg_default, :integer, :default => -1
       t.column :sample_text, :text
+      t.decimal :decimal_with_scale, :precision => 15, :scale => 3
       t.decimal :big_decimal, :precision => big_decimal_precision, :scale => 0
     end
   end

data/test/models/thing.rb

@@ -5,6 +5,7 @@ class CreateThings < ActiveRecord::Migration
       t.timestamps
     end
     add_index :things, :name, :unique => true
+    add_index :things, :created_at, :where => 'name IS NOT NULL', :name => "thing_partial_index"
   end
 
   def self.down

data/test/rails/mysql.rb

@@ -0,0 +1,13 @@
+module Mysql # :nodoc:
+  # remove_const(:Error) if const_defined?(:Error)
+  class Error < StandardError; end
+
+  def self.client_version
+    50400 # faked out for AR tests
+  end
+  
+  #module GemVersion
+  #  VERSION = '2.8.2'
+  #end
+  
+end

data/test/rails/sqlite3/version.rb

@@ -0,0 +1,6 @@
+# activerecord/test/cases/query_cache_test.rb requires this file
+module SQLite3 # gem 'sqlite3' (native)
+  module Version
+    VERSION = '1.3.7' # SQLite3::Version::VERSION > '1.2.5'
+  end
+end

data/test/rails_stub.rb

@@ -0,0 +1,31 @@
+require 'pathname'
+
+module Rails
+  class Configuration; end unless const_defined?(:Configuration)
+  Configuration.class_eval do
+    def root
+      defined?(RAILS_ROOT) ? Pathname.new(RAILS_ROOT).realpath : raise("Rails.root not set")
+    end
+  end
+  class Application
+    def self.config
+      @config ||= Configuration.new
+    end
+    def self.paths
+      @paths ||= Hash.new { [] }
+    end
+  end
+  def self.application
+    Rails::Application
+  end
+  def self.configuration
+    application.config
+  end
+  def self.root
+    application && application.config.root
+  end
+  def self.env
+    env = defined?(RAILS_ENV) ? RAILS_ENV : ( ENV["RAILS_ENV"] || "development" )
+    ActiveSupport::StringInquirer.new(env)
+  end
+end