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

data/test/has_many_through.rb

@@ -1,61 +0,0 @@
-require 'models/rights_and_roles'
-
-module HasManyThroughMethods
-  
-  def setup
-    CreateRightsAndRoles.up
-  end
-
-  def teardown
-    CreateRightsAndRoles.down
-  end
-
-  def test_has_many_through
-    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
-
-    admin_role.rights << role_rights
-    admin_role.rights << right_rights
-    admin_role.save!
-
-    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.rights << right_rights
-    rights_only_role.save!
-    rights_only_role.reload
-    
-    assert admin_role.has_right?(right_rights)
-    assert rights_only_role.has_right?(right_rights)
-    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
-    
-    connection = ActiveRecord::Base.connection
-    groups = role.reload.permission_groups.select('right_id')
-    
-    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/informix_simple_test.rb

@@ -1,48 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# To run this script, run the following:
-#
-#   CREATE DATABASE weblog_development;
-#
-# TODO: Finish the explanation.
-
-require 'jdbc_common'
-require 'db/informix'
-
-class InformixSimpleTest < Test::Unit::TestCase
-  include SimpleTestMethods
-
-  # Informix does not like "= NULL".
-  def test_equals_null
-    Entry.create!(:title => "Foo")
-    entry = Entry.find(:first, :conditions => ["content = NULL"])
-    assert_equal "Foo", entry.title
-  end
-
-  # Informix does not like "!= NULL" or "<> NULL".
-  def test_not_equals_null
-    Entry.create!(:title => "Foo", :content => "Bar")
-    entry = Entry.find_by_title("Foo", :conditions => ["content != NULL"])
-    assert_equal "Foo", entry.title
-    entry = Entry.find_by_title("Foo", :conditions => ["content <> NULL"])
-    assert_equal "Foo", entry.title
-  end
-end
-
-class InformixMultibyteTest < Test::Unit::TestCase
-  include MultibyteTestMethods
-
-  # Overriding the included test since we can't create text fields via a
-  # simple insert in Informix.
-  def test_select_multibyte_string
-    Entry.create!(:title => 'テスト', :content => '本文')
-    entry = Entry.first
-    assert_equal "テスト", entry.title
-    assert_equal "本文", entry.content
-    assert_equal entry, Entry.find_by_title("テスト")
-  end
-end
-
-class InformixHasManyThroughTest < Test::Unit::TestCase
-  include HasManyThroughMethods
-end

data/test/jdbc/db2.rb

@@ -1,36 +0,0 @@
-module Jdbc
-  module DB2
-    def self.driver_jar
-      if const_defined?(:VERSION)
-        "db2jcc-#{VERSION}.jar"
-      else
-        "db2jcc4.jar"
-      end
-    end
-
-    def self.load_driver(method = :load)
-      send method, driver_jar
-    end
-
-    def self.driver_name
-      '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
-
-# NOTE: just put the db2jcc4.jar into the test/jars directory ...
-jars = File.expand_path('../jars', File.dirname(__FILE__))
-$LOAD_PATH << jars unless $LOAD_PATH.include?(jars)

data/test/jdbc/oracle.rb

@@ -1,34 +0,0 @@
-module Jdbc
-  module Oracle
-    def self.driver_jar
-      if const_defined?(:VERSION)
-        "ojdbc-#{VERSION}.jar"
-      else
-        "ojdbc6.jar"
-      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
-      'oracle.jdbc.driver.OracleDriver'
-    end
-  end
-end
-
-# NOTE: just put the ojdbc6.jar into the test/jars directory ...
-jars = File.expand_path('../jars', File.dirname(__FILE__))
-$LOAD_PATH << jars unless $LOAD_PATH.include?(jars)

data/test/jdbc_column_test.rb

@@ -1,23 +0,0 @@
-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/jdbc_common.rb

@@ -1,16 +0,0 @@
-# Simple method to reduce the boilerplate
-
-require 'test_helper'
-
-require 'models/auto_id'
-require 'models/entry'
-require 'models/data_types'
-require 'models/add_not_null_column_to_table'
-require 'models/validates_uniqueness_of_string'
-require 'models/string_id'
-require 'models/thing'
-require 'models/custom_pk_name'
-
-require 'simple'
-require 'has_many_through'
-require 'row_locking'

data/test/jdbc_connection_test.rb

@@ -1,196 +0,0 @@
-require 'jdbc_common'
-require 'db/jdbc'
-
-class JdbcConnectionTest < Test::Unit::TestCase
-
-  def test_connection_available_through_jdbc_adapter
-     ActiveRecord::Base.connection.execute("show databases") # MySQL
-     assert ActiveRecord::Base.connected?
-  end
-
-  test 'configures driver/connection properties' do
-    config = JDBC_CONFIG.dup
-    config[:properties] = {
-      'autoDeserialize' => true,
-      'maxAllowedPacket' => 128,
-      'metadataCacheSize' => '5'
-    }
-    ActiveRecord::Base.remove_connection
-    begin
-      ActiveRecord::Base.establish_connection config
-      connection = ActiveRecord::Base.connection.jdbc_connection
-      # assuming MySQL internals :
-      assert_equal 'true', connection.getProperties['autoDeserialize']
-      assert_equal '128', connection.getProperties['maxAllowedPacket']
-      assert_equal '5', connection.getProperties['metadataCacheSize']
-    ensure
-      ActiveRecord::Base.establish_connection JDBC_CONFIG
-    end
-  end
-
-  test 'driver runtime errors do not get swallowed' do
-    config = JDBC_CONFIG.dup
-    config[:properties] = Java::JavaUtil::Properties.new
-    config[:properties]['invalid_property'] = java.lang.Object.new
-    ActiveRecord::Base.remove_connection
-    begin
-      ActiveRecord::Base.establish_connection config
-      ActiveRecord::Base.connection.jdbc_connection
-      fail "exception not thrown"
-    rescue Java::JavaLang::NullPointerException # OK :
-      # java.util.Hashtable.put(Hashtable.java:394)
-      # java.util.Properties.setProperty(Properties.java:143)
-      # com.mysql.jdbc.NonRegisteringDriver.parseURL(NonRegisteringDriver.java:849)
-      # com.mysql.jdbc.NonRegisteringDriver.connect(NonRegisteringDriver.java:325)
-    ensure
-      ActiveRecord::Base.establish_connection JDBC_CONFIG
-    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 
-      include Java::JavaSql::Driver
-      
-      def connect(url, info)
-        if url =~ /invalid_authorization_spec/i
-          raise Java::JavaSql::SQLInvalidAuthorizationSpecException.new
-        else
-          reason = "#{url} connect with #{info.inspect} failed"
-          raise Java::JavaSql::SQLException.new(reason, '42000', 1042)
-        end
-      end
-      
-    end
-    
-    def driver_class; DriverImpl; end
-    
-  end
-  
-  test 'driver sql exceptions are wrapped into jdbc errors' do
-    config = JDBC_CONFIG.dup
-    config[:driver_instance] = MockDriver.new('MockDriver')
-    ActiveRecord::Base.remove_connection
-    begin
-      ActiveRecord::Base.establish_connection config
-      ActiveRecord::Base.connection.jdbc_connection
-      fail "jdbc error not thrown"
-    rescue  ActiveRecord::JDBCError => e
-      assert_match /connect with {"user"=>"arjdbc", "password"=>"arjdbc"} failed/, e.to_s
-      assert_equal 1042, e.errno
-      assert_kind_of Java::JavaSql::SQLException, e.sql_exception
-    ensure
-      ActiveRecord::Base.establish_connection JDBC_CONFIG
-    end
-  end
-
-  test 'driver sql exceptions without message and sql state' do
-    config = JDBC_CONFIG.dup
-    config[:url] = 'jdbc:mysql://127.0.0.1:1234/invalid_authorization_spec'
-    config[:driver_instance] = MockDriver.new('MockDriver')
-    ActiveRecord::Base.remove_connection
-    begin
-      ActiveRecord::Base.establish_connection config
-      ActiveRecord::Base.connection.jdbc_connection
-      fail "jdbc error not thrown"
-    rescue  ActiveRecord::JDBCError => e
-      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
-  
-  context 'configuration' do
-
-    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(: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(:jdbc_url)
-    end
-
-    test 'connection fails without driver and url' do
-      with_connection_removed do
-        ActiveRecord::Base.establish_connection :adapter => 'jdbc'
-        assert_raise ActiveRecord::ConnectionNotEstablished do
-          ActiveRecord::Base.connection
-        end
-      end
-    end
-
-    test 'connection fails without driver' do
-      with_connection_removed do
-        ActiveRecord::Base.establish_connection :adapter => 'jdbc', :url => 'jdbc:derby:test.derby;create=true'
-        assert_raise ActiveRecord::ConnectionNotEstablished do
-          ActiveRecord::Base.connection
-        end
-      end
-    end
-    
-    test 'connection does not fail with driver_instance and url' do
-      load_derby_driver
-      with_connection_removed do
-        driver_instance = ActiveRecord::ConnectionAdapters::JdbcDriver.new('org.apache.derby.jdbc.EmbeddedDriver')
-        ActiveRecord::Base.establish_connection :adapter => 'jdbc', 
-          :url => 'jdbc:derby:memory:TestDB;create=true', :driver_instance => driver_instance
-        assert_nothing_raised do
-          ActiveRecord::Base.connection
-        end
-
-        assert ActiveRecord::Base.connected?
-        assert_nothing_raised do
-          connection = ActiveRecord::Base.connection
-          connection.execute("create table my_table(x int)")
-          #connection.execute("insert into my_table values 42")
-          #connection.execute("select * from my_table")
-        end
-      end
-    end
-    
-    test 'configures driver instance' do
-      load_derby_driver
-      with_connection_removed do
-        ActiveRecord::Base.establish_connection :adapter => 'jdbc', 
-          :url => 'jdbc:derby:memory:TestDB;create=true', :driver => 'org.apache.derby.jdbc.EmbeddedDriver'
-        assert_nothing_raised do
-          ActiveRecord::Base.connection
-        end
-        assert config = ActiveRecord::Base.connection.config
-        assert_instance_of ActiveRecord::ConnectionAdapters::JdbcDriver, config[:driver_instance]
-        assert_equal 'org.apache.derby.jdbc.EmbeddedDriver', config[:driver_instance].name
-      end
-    end
-    
-    private
-
-    def with_connection_removed
-      connection = ActiveRecord::Base.remove_connection
-      begin
-        yield
-      ensure
-        ActiveRecord::Base.establish_connection connection
-      end
-    end
-
-    def load_derby_driver
-      require 'jdbc/derby'
-      Jdbc::Derby.load_driver(:require)
-    end
-
-  end
-
-end

data/test/jndi_callbacks_test.rb

@@ -1,33 +0,0 @@
-require 'test_helper'
-require 'db/jndi_config'
-
-class JndiConnectionPoolCallbacksTest < Test::Unit::TestCase
-  
-  class Dummy < ActiveRecord::Base; end
-  
-  setup do
-    Dummy.establish_connection JNDI_CONFIG.dup
-  end
-  
-  teardown do
-    Dummy.remove_connection
-  end
-  
-  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