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

data/test/sybase_jtds_simple_test.rb

@@ -1,28 +0,0 @@
-require 'jdbc_common'
-require 'db/sybase_jtds'
-
-class SybaseJtdsSimpleTest < Test::Unit::TestCase
-  include SimpleTestMethods
-end
-
-class SybaseAdapterSelectionTest < Test::Unit::TestCase
-  class MockConnection
-    def adapter=(adapt)
-    end
-  end
-
-  def test_jtds_selection_using_dialect
-    config = {
-      :driver =>  'net.sourceforge.jtds.Driver',
-      :dialect => 'sybase'
-    }
-    adapt = JdbcAdapter.new(MockConnection.new, nil, config)
-    assert adapt.kind_of?(ArJdbc::Sybase), "Should be a sybase adapter"
-  end
-
-  def test_jtds_selection_not_using_dialect
-    config = { :driver => 'net.sourceforge.jtds.Driver' }
-    adapt = JdbcAdapter.new(MockConnection.new, nil, config)
-    assert adapt.kind_of?(ArJdbc::MsSQL), "Should be a MsSQL apdater"
-  end
-end

data/test/sybase_reset_column_information_test.rb

@@ -1,6 +0,0 @@
-require 'jdbc_common'
-require 'db/sybase'
-
-class SybaseResetColumnInformationTest < Test::Unit::TestCase
-  include ResetColumnInformationTestMethods
-end

data/test/test_helper.rb

@@ -1,304 +0,0 @@
-require 'stringio'
-
-begin
-  require 'bundler'
-rescue LoadError => e
-  require('rubygems') && retry
-  raise e
-end
-Bundler.require(:default, :test)
-
-require 'test/unit'
-require 'test/unit/context'
-begin; require 'mocha/setup'; rescue LoadError; require 'mocha'; end
-
-require 'shared_helper'
-
-if ENV['COVERAGE']
-  require 'simplecov'
-  SimpleCov.start
-  puts 'started simplecov'
-end
-
-require 'arjdbc' if defined?(JRUBY_VERSION)
-
-puts "Using ActiveRecord::VERSION = #{ActiveRecord::VERSION::STRING}"
-
-# we always set-up logger (some tests fail if ActiveRecord::Base.logger is nil),
-# but level is set to "warn" unless $DEBUG or ENV['DEBUG'] is set :
-require 'logger'
-ActiveRecord::Base.logger = Logger.new($stdout)
-ActiveRecord::Base.logger.level = 
-  if level = ENV['LOG_LEVEL']
-    level.to_i.to_s == level ? level.to_i : Logger.const_get(level.upcase)
-  elsif $DEBUG || ENV['DEBUG']
-    Logger::DEBUG
-  else
-    Logger::WARN
-  end
-
-begin
-  require 'ruby-debug' if $DEBUG || ENV['DEBUG']
-rescue LoadError
-  puts "ruby-debug missing thus won't be loaded"
-end
-
-# assert_queries and SQLCounter taken from rails active_record tests
-class Test::Unit::TestCase
-
-  alias skip omit
-  
-  def self.ar_version(version)
-    match = version.match(/(\d+)\.(\d+)(?:\.(\d+))?/)
-    ActiveRecord::VERSION::MAJOR > match[1].to_i ||
-      (ActiveRecord::VERSION::MAJOR == match[1].to_i &&
-       ActiveRecord::VERSION::MINOR >= match[2].to_i)
-  end
-  
-  def ar_version(version); self.class.ar_version(version); end
-  
-  def with_java_connection(config = nil)
-    config ||= ActiveRecord::Base.connection.config
-    jdbc_driver = ActiveRecord::ConnectionAdapters::JdbcDriver.new(config[:driver])
-    begin
-      java_connection = jdbc_driver.connection(config[:url], config[:username], config[:password])
-      java_connection.setAutoCommit(true)
-      yield(java_connection)
-    ensure
-      java_connection.close rescue nil
-    end
-  end
-  
-  def connection
-    @connection ||= ActiveRecord::Base.connection
-  end
-  
-  def schema_dump
-    strio = StringIO.new
-    ActiveRecord::SchemaDumper::dump(connection, strio)
-    strio.string
-  end
-  
-  def self.disable_logger(connection, &block)
-    raise "need a block" unless block_given?
-    return disable_connection_logger(connection, &block) if connection
-    logger = ActiveRecord::Base.logger
-    begin
-      ActiveRecord::Base.logger = nil
-      yield
-    ensure
-      ActiveRecord::Base.logger = logger
-    end
-  end
-
-  def self.disable_connection_logger(connection)
-    logger = connection.send(:instance_variable_get, :@logger)
-    begin
-      connection.send(:instance_variable_set, :@logger, nil)
-      yield
-    ensure
-      connection.send(:instance_variable_set, :@logger, logger)
-    end    
-  end
-  
-  def disable_logger(connection, &block)
-    self.class.disable_logger(connection, &block)
-  end
-  
-  def clear_active_connections!
-    ActiveRecord::Base.clear_active_connections!
-  end
-  
-  protected
-  
-  def assert_queries(count, matching = nil)
-    if ActiveRecord::SQLCounter.enabled?
-      log = ActiveRecord::SQLCounter.log = []
-      begin
-        yield
-      ensure
-        queries = queries = ( matching ? log.select { |s| s =~ matching } : log )
-        assert_equal count, queries.size, 
-          "#{ queries.size } instead of #{ count } queries were executed." + 
-          "#{ queries.size == 0 ? '' : "\nQueries:\n#{queries.join("\n")}" }" 
-      end
-    else
-      warn "assert_queries skipped as SQLCounter is not enabled"
-      yield
-    end
-  end
-
-  # re-defined by Oracle
-  def assert_empty_string value
-    assert_equal '', value
-  end
-
-  # re-defined by Oracle
-  def assert_null_text value
-    assert_nil value
-  end
-
-  def assert_date_equal expected, actual
-    actual = actual_in_expected_time_zone(expected, actual)
-    actual = actual.to_date if actual.is_a?(Time)
-    assert_equal(expected.nil? ? nil : expected.to_date, actual)
-  end
-  
-  def assert_time_equal expected, actual
-    actual = actual_in_expected_time_zone(expected, actual)
-    [ :hour, :min, :sec ].each do |method|
-      assert_equal expected.send(method), actual.send(method), "<#{expected}> but was <#{actual}> (differ at #{method.inspect})"
-    end
-  end
-
-  def assert_datetime_equal expected, actual
-    assert_date_equal expected, actual
-    assert_time_equal expected, actual
-  end
-  
-  def assert_timestamp_equal expected, actual
-    e_utc = expected.utc; a_utc = actual.utc
-    [ :year, :month, :day, :hour, :min, :sec ].each do |method|
-      assert_equal e_utc.send(method), a_utc.send(method), "<#{expected}> but was <#{actual}> (differ at #{method.inspect})"
-    end
-    assert_equal e_utc.usec, a_utc.usec, "<#{expected}> but was <#{actual}> (differ at :usec)"
-    # :usec Ruby Time precision: 123_456 (although JRuby only supports ms with Time.now) :
-    #e_usec = ( e_utc.usec / 1000 ) * 1000
-    #a_usec = ( a_utc.usec / 1000 ) * 1000
-    #assert_equal e_usec, a_usec, "<#{expected}> but was <#{actual}> (differ at :usec / 1000)"
-  end
-
-  def assert_date_not_equal expected, actual
-    actual = actual_in_expected_time_zone(expected, actual)
-    actual = actual.to_date if actual.is_a?(Time)
-    assert_not_equal(expected.nil? ? nil : expected.to_date, actual)
-  end
-  
-  def assert_time_not_equal expected, actual, msg = nil
-    actual = actual_in_expected_time_zone(expected, actual)
-    equal = true
-    [ :hour, :min, :sec ].each do |method|
-      equal &&= ( expected.send(method) == actual.send(method) )
-    end
-    assert ! equal, msg || "<#{expected}> to not (time) equal to <#{actual}> but did"
-  end
-  
-  def assert_datetime_not_equal expected, actual
-    if date_equal?(expected, actual) && time_equal?(expected, actual)
-      assert false, "<#{expected}> to not (datetime) equal to <#{actual}> but did"
-    end
-  end
-  
-  private
-  
-  def date_equal?(expected, actual)
-    actual = actual_in_expected_time_zone(expected, actual)
-    actual = actual.to_date if actual.is_a?(Time)
-    (expected.nil? ? nil : expected.to_date) == actual
-  end
-  
-  def time_equal?(expected, actual)
-    actual = actual_in_expected_time_zone(expected, actual)
-    equal = true; [ :hour, :min, :sec ].each do |method|
-      equal &&= ( expected.send(method) == actual.send(method) )
-    end
-    equal
-  end
-  
-  def actual_in_expected_time_zone(expected, actual)
-    if actual.respond_to?(:in_time_zone)
-      if expected.respond_to?(:time_zone)
-        return actual.in_time_zone expected.time_zone
-      end
-      if expected.is_a?(Time) # due AR 2.3
-        #expected = expected.in_time_zone
-        #return actual.in_time_zone expected.time_zone
-        return actual.in_time_zone ActiveSupport::TimeZone[expected.zone]
-      end
-    end
-    actual
-  end
-  
-end
-
-module ActiveRecord
-  class SQLCounter
-
-    @@ignored_sql = [
-      /^PRAGMA (?!(table_info))/,
-      /^SELECT currval/,
-      /^SELECT CAST/,
-      /^SELECT @@IDENTITY/,
-      /^SELECT @@ROWCOUNT/,
-      /^SAVEPOINT/,
-      /^ROLLBACK TO SAVEPOINT/,
-      /^RELEASE SAVEPOINT/,
-      /^SHOW max_identifier_length/,
-      /^BEGIN/,
-      /^COMMIT/
-    ]
-    def self.ignored_sql; @@ignored_sql; end
-    def self.ignored_sql=(value)
-      @@ignored_sql = value || []
-    end
-    
-    # FIXME: this needs to be refactored so specific database can add their own
-    # ignored SQL.  This ignored SQL is for Oracle.
-    ignored_sql.concat [/^select .*nextval/i,
-      /^SAVEPOINT/,
-      /^ROLLBACK TO/,
-      /^\s*select .* from all_triggers/im
-    ]
-
-    @@log = []
-    def self.log; @@log; end
-    def self.log=(log); @@log = log;; end
-    
-    def initialize(ignored_sql = self.class.ignored_sql)
-      @ignored_sql = ignored_sql
-    end
-    
-    def call(name, start, finish, message_id, values)
-      return if 'CACHE' == values[:name]
-      
-      sql = values[:sql]
-      sql = sql.to_sql unless sql.is_a?(String)
-      
-      return if @ignored_sql.any? { |x| x =~ sql }
-      
-      self.class.log << sql
-    end
-    
-    @@enabled = true
-    def self.enabled?; @@enabled; end
-    
-    begin
-      require 'active_support/notifications'
-      ActiveSupport::Notifications.subscribe('sql.active_record', SQLCounter.new)
-    rescue LoadError
-      @@enabled = false
-    end
-    
-  end
-end
-
-# less (2.3) warnings otherwise the test console output is hard to read :
-if ActiveRecord::VERSION::MAJOR == 2 && ActiveRecord::VERSION::MINOR == 3
-  ActiveRecord::Migration.class_eval do
-    class << self # warning: instance variable @version not initialized
-      alias_method :_announce, :announce
-      def announce(message)
-        @version = nil unless defined?(@version)
-        _announce(message)
-      end
-    end
-  end
-  ActiveRecord::Base.class_eval do
-    def destroyed? # warning: instance variable @destroyed not initialized
-      defined?(@destroyed) && @destroyed # @destroyed
-    end
-    def new_record? # warning: instance variable @new_record not initialized
-      @new_record ||= false # @new_record || false
-    end
-  end
-end

data/test/transaction.rb

@@ -1,109 +0,0 @@
-require 'test_helper'
-require 'simple' # due MigrationSetup
-
-module TransactionTestMethods
-  include MigrationSetup
-
-  def setup!
-    CreateEntries.up
-    CreateUsers.up
-  end
-
-  def teardown!
-    CreateUsers.down
-    CreateEntries.down
-  end
-  
-  class Entry2 < ActiveRecord::Base; self.table_name = 'entries' ; end
-  
-  def setup
-    super
-    Entry.delete_all
-    config = ActiveRecord::Base.connection.config
-    Entry2.establish_connection config
-  end
-  
-  def test_supports_transaction_isolation
-    unless ActiveRecord::Base.connection.supports_transaction_isolation?
-      omit("transaction isolation not supported")
-    end
-    assert ActiveRecord::Base.connection.supports_transaction_isolation?(:read_uncommitted)
-    assert ActiveRecord::Base.connection.supports_transaction_isolation?(:read_committed)
-    assert ActiveRecord::Base.connection.supports_transaction_isolation?(:repeatable_read)
-    assert ActiveRecord::Base.connection.supports_transaction_isolation?(:serializable)
-  end
-  
-  def test_transaction_isolation_read_uncommitted
-    # It is impossible to properly test read uncommitted. The SQL standard only
-    # specifies what must not happen at a certain level, not what must happen. At
-    # the read uncommitted level, there is nothing that must not happen.
-    # test "read uncommitted" do
-    Entry.transaction(:isolation => :read_uncommitted) do
-      assert_equal 0, Entry.count
-      Entry2.create
-      assert_equal 1, Entry.count 
-    end
-  end if Test::Unit::TestCase.ar_version('4.0')
-  
-  def test_transaction_isolation_read_committed
-    unless ActiveRecord::Base.connection.supports_transaction_isolation?
-      omit("transaction isolation not supported")
-    end
-    
-    # We are testing that a dirty read does not happen
-    # test "read committed" do
-    Entry.transaction(:isolation => :read_committed) do
-      assert_equal 0, Entry.count
-
-      Entry2.transaction do
-        Entry2.create
-        assert_equal 0, Entry.count
-      end
-    end
-    assert_equal 1, Entry.count
-  end if Test::Unit::TestCase.ar_version('4.0')
-  
-  def test_transaction_isolation_repeatable_read
-    unless ActiveRecord::Base.connection.supports_transaction_isolation?
-      omit("transaction isolation not supported")
-    end
-    
-    # We are testing that a non-repeatable read does not happen
-    # test "repeatable read" do
-    entry = Entry.create(:title => '1234')
-
-    Entry.transaction(:isolation => :repeatable_read) do
-      entry.reload
-      Entry2.find(entry.id).update_attributes(:title => '567')
-
-      entry.reload
-      assert_equal '1234', entry.title
-    end
-    entry.reload
-    assert_equal '567', entry.title
-  end if Test::Unit::TestCase.ar_version('4.0')
-  
-#  def test_transaction_isolation_serializable
-#    # We are testing that a non-serializable sequence of statements will raise
-#    # an error.
-#    # test "serializable" do
-#    #if Entry2.connection.adapter_name =~ /mysql/i
-#    #  # Unfortunately it cannot be set to 0
-#    #  Entry2.connection.execute "SET innodb_lock_wait_timeout = 1"
-#    #end
-#
-#    assert_raise ActiveRecord::StatementInvalid do
-#      Entry.transaction(:isolation => :serializable) do
-#        Entry.create
-#
-#        Entry2.transaction(:isolation => :serializable) do
-#          Entry2.create
-#          Entry2.count
-#        end
-#
-#        Entry.count
-#      end
-#    end
-#  end if Test::Unit::TestCase.ar_version('4.0')
-  
-end