activerecord-jdbc-adapter 1.2.8 → 1.2.9

data/test/{mssql_row_locking_sql_test.rb → mssql_test.rb}

@@ -1,8 +1,100 @@
-require 'arjdbc/mssql/adapter'
-require 'test/unit'
+require 'test_helper'
+require 'arjdbc/mssql'
+
+class MSSQLTest < Test::Unit::TestCase
+  
+  # NOTE: lot of tests kindly borrowed from __activerecord-sqlserver-adapter__
+  
+  test "get table name" do
+    insert_sql = "INSERT INTO [funny_jokes] ([name]) VALUES('Knock knock')"
+    update_sql = "UPDATE [customers] SET [address_street] = NULL WHERE [id] = 2"
+    select_sql = "SELECT * FROM [customers] WHERE ([customers].[id] = 1)"
+    
+    connection = new_adapter_stub
+    assert_equal 'funny_jokes', connection.send(:get_table_name, insert_sql)
+    assert_equal 'customers', connection.send(:get_table_name, update_sql)
+    assert_equal 'customers', connection.send(:get_table_name, select_sql)
+
+    assert_equal '[funny_jokes]', connection.send(:get_table_name, insert_sql, true)
+    assert_equal '[customers]', connection.send(:get_table_name, update_sql, true)
+    assert_equal '[customers]', connection.send(:get_table_name, select_sql, true)
+    
+    select_sql = " SELECT * FROM  customers  WHERE ( customers.id = 1 ) "
+    assert_equal 'customers', connection.send(:get_table_name, select_sql)
+    assert_equal 'customers', connection.send(:get_table_name, select_sql, true)
+    
+    assert_nil connection.send(:get_table_name, 'SELECT 1')
+    # NOTE: this has been failing even before refactoring - not sure if it's needed :
+    #assert_nil connection.send(:get_table_name, 'SELECT * FROM someFunction()')
+    #assert_nil connection.send(:get_table_name, 'SELECT * FROM someFunction() WHERE 1 > 2')
+  end
+  
+  context "Utils" do
+    
+    setup do
+      @expected_table_name = 'baz'
+      @expected_db_name = 'foo'
+      @first_second_table_names = ['[baz]','baz','[bar].[baz]','bar.baz']
+      @third_table_names = ['[foo].[bar].[baz]','foo.bar.baz']
+      @qualifed_table_names = @first_second_table_names + @third_table_names
+    end
+
+    test 'return clean table_name from Utils.unqualify_table_name' do
+      @qualifed_table_names.each do |qtn|
+        assert_equal @expected_table_name,
+          ArJdbc::MSSQL::Utils.send(:unqualify_table_name, qtn),
+          "This qualifed_table_name #{qtn} did not unqualify correctly."
+      end
+    end
+
+    test 'return nil from Utils.unqualify_db_name when table_name is less than 2 qualified' do
+      @first_second_table_names.each do |qtn|
+        assert_equal nil, ArJdbc::MSSQL::Utils.send(:unqualify_db_name, qtn),
+          "This qualifed_table_name #{qtn} did not return nil."
+      end
+    end
+
+    test 'return clean db_name from Utils.unqualify_db_name when table is thrid level qualified' do
+      @third_table_names.each do |qtn|
+        assert_equal @expected_db_name,
+          ArJdbc::MSSQL::Utils.send(:unqualify_db_name, qtn),
+          "This qualifed_table_name #{qtn} did not unqualify the db_name correctly."
+      end
+    end
+    
+  end
+  
+  test "quote column name" do
+    connection = new_adapter_stub
+    assert_equal "[foo]", connection.quote_column_name("foo")
+    assert_equal "[bar]", connection.quote_column_name("[bar]")
+    assert_equal "[foo]]bar]", connection.quote_column_name("foo]bar")
+    
+    assert_equal "[dbo].[foo]", connection.quote_column_name("dbo.foo")
+    assert_equal "[dbo].[bar]", connection.quote_column_name("[dbo].[bar]")
+    assert_equal "[foo].[bar]", connection.quote_column_name("[foo].bar")
+    assert_equal "[foo].[bar]", connection.quote_column_name("foo.[bar]")
+  end
+  
+  private
+  
+  def new_adapter_stub(config = {})
+    config = config.merge({ 
+        :adapter => 'jdbc', 
+        :adapter_spec => ArJdbc::MSSQL, 
+        :sqlserver_version => 2008
+    })
+    connection = stub('connection'); logger = nil
+    connection.stub_everything
+    adapter = ActiveRecord::ConnectionAdapters::JdbcAdapter.new connection, logger, config
+    yield(adapter) if block_given?
+    adapter
+  end
+  
+end
 
-# This tests ArJdbc::MsSQL#add_lock! without actually connecting to the database.
-class MssqlRowLockingSqlTest < Test::Unit::TestCase
+# This tests ArJdbc::MSSQL#add_lock! without actually connecting to the database.
+class MSSQLRowLockingSqlTest < Test::Unit::TestCase
 
   def test_find_all
     add_lock_test "Appointment.find(:all)",
@@ -136,22 +228,22 @@ class MssqlRowLockingSqlTest < Test::Unit::TestCase
       }
   end
 
+  class Dummy
+    include ::ArJdbc::MSSQL::LockHelpers::SqlServerAddLock
+  end
 
   private
 
-    class Dummy
-      include ::ArJdbc::MsSQL::LockHelpers::SqlServerAddLock
-    end
-
-    def add_lock!(sql, options={})
-      result = sql.dup
-      Dummy.new.add_lock!(result, {:lock=>true}.merge(options))
-      result
-    end
+  def add_lock!(sql, options={})
+    result = sql.dup
+    Dummy.new.add_lock!(result, {:lock=>true}.merge(options))
+    result
+  end
 
-    def add_lock_test(message, before, after, options={})
-      before = before.gsub(/\s*\n\s*/m, " ").strip
-      after = after.gsub(/\s*\n\s*/m, " ").strip
-      assert_equal after, add_lock!(before, options).strip, message
-    end
+  def add_lock_test(message, before, after, options={})
+    before = before.gsub(/\s*\n\s*/m, " ").strip
+    after = after.gsub(/\s*\n\s*/m, " ").strip
+    assert_equal after, add_lock!(before, options).strip, message
+  end
+  
 end

data/test/mysql_db_create_test.rb

@@ -9,14 +9,12 @@ class MysqlDbCreateTest < Test::Unit::TestCase
   end
 
   def test_rake_db_create
+    omit_unless find_executable?("mysql")
     Rake::Task["db:create"].invoke
-    if find_executable?("mysql")
-      output = nil
-      IO.popen("mysql -u #{MYSQL_CONFIG[:username]} --password=#{MYSQL_CONFIG[:password]}", "r+") do |mysql|
-        mysql << "show databases where `Database` = '#{@db_name}';"
-        mysql.close_write
-        assert mysql.read =~ /#{@db_name}/m
-      end
+    with_mysql do |mysql|
+      mysql << "show databases where `Database` = '#{@db_name}';"
+      mysql.close_write
+      assert mysql.read =~ /#{@db_name}/m      
     end
   end
 
@@ -24,4 +22,12 @@ class MysqlDbCreateTest < Test::Unit::TestCase
     Rake::Task["db:create"].invoke
     Rake::Task["db:test:purge"].invoke
   end
+  
+  private
+  
+  def with_mysql(args = nil)
+    exec = "mysql -u #{db_config[:username]} --password=#{db_config[:password]} #{args}"
+    IO.popen(exec, "r+") { |mysql| yield(mysql) }
+  end
+  
 end

data/test/oracle_simple_test.rb

@@ -32,6 +32,24 @@ class OracleSimpleTest < Test::Unit::TestCase
     assert entries.first.login
   end
   
+  # @override
+  def test_exec_insert_bind_param_with_q_mark
+    sql = "INSERT INTO entries(id, title) VALUES (?, ?)"
+    connection.exec_insert sql, 'INSERT(with_q_mark)', [ [ nil, 1000 ], [ nil, "bar?!?" ] ]
+    
+    entries = Entry.find_by_sql "SELECT * FROM entries WHERE title = 'bar?!?'"
+    assert entries.first
+  end
+
+  # @override
+  def test_raw_insert_bind_param_with_q_mark
+    sql = "INSERT INTO entries(id, title) VALUES (?, ?)"
+    name = "INSERT(raw_with_q_mark)"
+    pk = nil; id_value = 1001; sequence_name = nil
+    connection.insert sql, name, pk, id_value, sequence_name, [ [ nil, id_value ], [ nil, "?!huu!?" ] ]
+    assert Entry.exists?([ 'title LIKE ?', "%?!huu!?%" ])
+  end if Test::Unit::TestCase.ar_version('3.1') # no binds argument for <= 3.0
+  
   include ExplainSupportTestMethods if ar_version("3.1")
   
   protected

data/test/postgres_db_create_test.rb

@@ -1,4 +1,5 @@
 require 'abstract_db_create'
+require 'db/postgres'
 
 class PostgresDbCreateTest < Test::Unit::TestCase
   include AbstractDbCreate
@@ -7,20 +8,18 @@ class PostgresDbCreateTest < Test::Unit::TestCase
     POSTGRES_CONFIG
   end
 
-  if find_executable?("psql")
-    def test_rake_db_create
-      Rake::Task["db:create"].invoke
-      output = `psql -d template1 -c '\\l'`
-      assert output =~ /#{@db_name}/m
-    end
+  PSQL_EXECUTABLE = find_executable?("psql")
+  
+  def test_rake_db_create
+    omit_unless PSQL_EXECUTABLE
+    Rake::Task["db:create"].invoke
+    assert_match /#{@db_name}/m, psql("-d template1 -c '\\\l'")
+  end
 
-    def test_rake_db_test_purge
-      Rake::Task["db:create"].invoke
-      Rake::Task["db:test:purge"].invoke
-    end
-  else
-    def test_skipped
-    end
+  def test_rake_db_test_purge
+    # omit_unless PSQL_EXECUTABLE
+    Rake::Task["db:create"].invoke
+    Rake::Task["db:test:purge"].invoke
   end
 
   def test_rake_db_create_does_not_load_full_environment
@@ -28,4 +27,18 @@ class PostgresDbCreateTest < Test::Unit::TestCase
     assert @rails_env_set
     assert !defined?(@full_environment_loaded) || !@full_environment_loaded
   end
+  
+  private
+  
+  def psql(args)
+    args = args.join(' ') unless args.is_a?(String)
+    if db_config[:host] != 'localhost'
+      args = "--host=#{db_config[:host]} #{args}"
+    end
+    if username = ENV['PSQL_USERNAME']
+      args = "--username=#{username} #{args}"
+    end
+    `psql #{args}`
+  end
+  
 end

data/test/simple.rb

@@ -86,9 +86,38 @@ module ColumnNameQuotingTests
 end
 
 module DirtyAttributeTests
-  def test_partial_update
-    entry = Entry.new(:title => 'foo')
-    old_updated_on = 1.hour.ago.beginning_of_day
+
+  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
+    
+    User.update_all({ :updated_at => old_updated_at }, :login => user.login)
+
+    with_partial_updates User, false do
+      assert_queries(1) { user.save! }
+    end
+
+    User.update_all({ :updated_at => old_updated_at }, :login => user.login)
+    
+    with_partial_updates User, true do
+      assert_queries(0) { user.save! }
+      assert_datetime_equal old_updated_at, user.reload.updated_at
+
+      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
+    
+    Entry.update_all({ :updated_on => old_updated_on }, :id => entry.id)
 
     with_partial_updates Entry, false do
       assert_queries(2) { 2.times { entry.save! } }
@@ -97,11 +126,13 @@ module DirtyAttributeTests
 
     with_partial_updates Entry, true do
       assert_queries(0) { 2.times { entry.save! } }
-      assert_datetime_equal old_updated_on, entry.reload.updated_on
+      assert_date_equal old_updated_on, entry.reload.updated_on
 
       assert_queries(1) { entry.title = 'bar'; entry.save! }
-      assert_not_equal old_updated_on, entry.reload.updated_on
+      assert_date_not_equal old_updated_on, entry.reload.updated_on
     end
+  ensure
+    #ActiveRecord::Base.logger.level = Logger::WARN
   end
 
   private
@@ -828,16 +859,15 @@ module ActiveRecord3TestMethods
   end
 
   module Tests
-    if ActiveRecord::VERSION::MINOR == 2
-      def test_visitor_accessor
-        adapter = Entry.connection
-        expected_visitors = adapter.config[:adapter_spec].
-          arel2_visitors(adapter).values
-        assert !adapter.visitor.nil?
-        assert expected_visitors.include?(adapter.visitor.class)
-      end
-    end
-
+    
+    def test_visitor_accessor
+      adapter = Entry.connection
+      adapter_spec = adapter.config[:adapter_spec]
+      expected_visitors = adapter_spec.arel2_visitors(adapter.config).values
+      assert_not_nil adapter.visitor
+      assert expected_visitors.include?(adapter.visitor.class)
+    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

data/test/sqlite3_schema_dump_test.rb

@@ -0,0 +1,6 @@
+require 'db/sqlite3'
+require 'schema_dump'
+
+class SQLite3SchemaDumpTest < Test::Unit::TestCase
+  include SchemaDumpTestMethods
+end

data/test/sqlite3_type_conversion_test.rb

@@ -9,38 +9,41 @@ class SQLite3TypeConversionTest < Test::Unit::TestCase
   else
     JInteger = Fixnum
     class Fixnum
-      # Arbitrary value...we could pick
-      MAX_VALUE = 2
+      MAX_VALUE = 1024 * 1024 # arbitrary value ... we could pick
     end
   end
   
-  TEST_TIME = Time.at(1169964202)
-  TEST_BINARY = "Some random binary data % \0 and then some"
-  
   def self.startup; DbTypeMigration.up; end
   def self.shutdown; DbTypeMigration.down; end
   
-  def setup
-    super
+  TEST_BINARY = "Some random binary data % \0 and then some"
+  
+  @@time_zone = Time.zone
+  
+  setup do
+    Time.zone = ActiveSupport::TimeZone['UTC']
     DbType.delete_all
-    DbType.create(
-      :sample_timestamp => TEST_TIME,
-      :sample_datetime => TEST_TIME,
-      :sample_time => TEST_TIME,
-      :sample_date => TEST_TIME,
+    some_time = Time.now
+    DbType.create!(
+      :sample_timestamp => some_time,
+      :sample_datetime => some_time.to_datetime,
+      :sample_time => some_time.to_time,
+      :sample_date => some_time.to_date,
       :sample_decimal => JInteger::MAX_VALUE + 1,
       :sample_small_decimal => 3.14,
       :sample_binary => TEST_BINARY)
-    DbType.create(
-      :sample_timestamp => TEST_TIME,
-      :sample_datetime => TEST_TIME,
-      :sample_time => TEST_TIME,
-      :sample_date => TEST_TIME,
+    DbType.create!(
+      :sample_timestamp => some_time,
+      :sample_datetime => some_time.to_datetime,
+      :sample_time => some_time.to_time,
+      :sample_date => some_time.to_date,
       :sample_decimal => JInteger::MAX_VALUE + 1,
       :sample_small_decimal => 1.0,
       :sample_binary => TEST_BINARY)
   end
 
+  teardown { Time.zone = @@time_zone; DbType.delete_all }
+  
   def test_decimal
     types = DbType.first
     assert_equal((JInteger::MAX_VALUE + 1), types.sample_decimal)

data/test/test_helper.rb

@@ -135,11 +135,53 @@ class Test::Unit::TestCase
     #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.is_a?(Time) && expected.respond_to?(:time_zone)
-      return actual.in_time_zone expected.time_zone
+    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