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

data/test/db/mysql/serialize_test.rb

@@ -1,6 +0,0 @@
-require 'db/mysql'
-require 'serialize'
-
-class MySQLSerializeTest < Test::Unit::TestCase
-  include SerializeTestMethods
-end

data/test/db/mysql/simple_test.rb

@@ -1,187 +0,0 @@
-# To run this script, run the following in a mysql instance:
-#
-#   drop database if exists weblog_development;
-#   create database weblog_development;
-#   grant all on weblog_development.* to blog@localhost;
-#   flush privileges;
-
-require 'jdbc_common'
-require 'db/mysql'
-
-class MysqlSimpleTest < Test::Unit::TestCase
-  include SimpleTestMethods
-  include ActiveRecord3TestMethods
-  include ColumnNameQuotingTests
-  include DirtyAttributeTests
-  include XmlColumnTests
-  include CustomSelectTestMethods
-
-  column_quote_char "`"
-
-  def test_column_class_instantiation
-    text_column = nil
-    assert_nothing_raised do
-      text_column = ActiveRecord::ConnectionAdapters::MysqlAdapter::Column.new("title", nil, "text")
-    end
-    assert_not_nil text_column
-  end
-
-  def test_string_quoting_oddity
-    s = "0123456789a'a"
-    assert_equal "'0123456789a\\'a'", ActiveRecord::Base.connection.quote(s)
-
-    s2 = s[10,3]
-    assert_equal "a'a", s2
-    assert_equal "'a\\'a'", ActiveRecord::Base.connection.quote(s2)
-  end
-
-  def test_table_name_quoting_with_dot
-    s = "#{MYSQL_CONFIG[:database]}.posts"
-    assert_equal "`#{MYSQL_CONFIG[:database]}`.`posts`", ActiveRecord::Base.connection.quote_table_name(s)
-  end
-
-  def test_update_all_with_limit
-    assert_nothing_raised { Entry.update_all({:title => "test"}, {}, {:limit => 1}) }
-  end
-
-  # from rails active record tests, only meant to work in AR 3.2 and higher
-  def test_update_all_with_joins_and_offset_and_order
-    user_1 = User.create :login => 'user_1'
-    user_2 = User.create :login => 'user_2'
-
-    Entry.create :title => 'title_1', :content => 'content_1', :rating => 0,
-    :user_id => user_1.id
-    Entry.create :title => 'title_2', :content => 'content_2', :rating => 1,
-    :user_id => user_2.id
-
-    all_entries = Entry.joins(:user).where('users.id' => user_1.id).
-      order('users.id', 'entries.id')
-    count   = all_entries.count
-    entries = all_entries.offset(1)
-
-    assert_equal count - 1, entries.update_all(:user_id => user_2.id)
-    assert_equal user_2, Entry.find_by_title('title_2').user
-  end if ar_version("3.2")
-
-  # from rails active record tests
-  def test_caching_of_columns
-    user = User.create :login => 'test'
-
-    # clear cache possibly created by other tests
-    user.entries.reset_column_information
-
-    assert_queries(1, /SHOW FIELDS/) { user.entries.columns; user.entries.columns }
-
-    ## and again to verify that reset_column_information clears the cache correctly
-    user.entries.reset_column_information
-    assert_queries(1, /SHOW FIELDS/) { user.entries.columns; user.entries.columns }
-  end
-
-  # from rails active record tests
-  def test_drop_index_from_table_named_values
-    connection = Entry.connection
-    connection.create_table :values, :force => true do |t|
-      t.integer :value
-    end
-
-    assert_nothing_raised do
-      connection.add_index :values, :value
-      connection.remove_index :values, :column => :value
-    end
-
-    connection.drop_table :values rescue nil
-  end
-
-  def test_find_in_other_schema_with_include
-    user_1 = User.create :login => 'user1'
-    user_2 = User.create :login => 'user2'
-    Entry.create :title => 'title1', :content => '', :rating => 0, :user_id => user_1.id
-    Entry.create :title => 'title2', :content => '', :rating => 1, :user_id => user_2.id
-    
-    old_entries_table_name = Entry.table_name
-    old_users_table_name   = User.table_name
-    database = MYSQL_CONFIG[:database]
-    begin
-      User.table_name  = "#{database}.users"
-      Entry.table_name = "#{database}.entries"
-      if ar_version('4.0')
-        assert_not_empty Entry.includes(:user).to_a
-      else
-        assert_not_empty Entry.all(:include => :user)
-      end
-    ensure
-      Entry.table_name = old_entries_table_name
-      User.table_name  = old_users_table_name
-    end
-  end
-
-  include ExplainSupportTestMethods if ar_version("3.1")
-  
-  def test_reports_server_version
-    assert_instance_of Array, ActiveRecord::Base.connection.send(:version)
-    assert_equal 3, ActiveRecord::Base.connection.send(:version).size
-  end
-  
-  def test_update_sql_public_and_returns_rows_affected
-    ActiveRecord::Base.connection.update_sql "UPDATE entries SET title = NULL"
-    
-    e1 = Entry.create! :title => 'a some', :content => 'brrrr', :rating => 10.8
-    e2 = Entry.create! :title => 'another', :content => 'meee', :rating => 40.2
-    rows_affected = ActiveRecord::Base.connection.update_sql "UPDATE entries " + 
-      "SET content='updated content' WHERE rating > 10 AND title IS NOT NULL"
-    assert_equal 2, rows_affected
-    assert_equal 'updated content', e1.reload.content
-    assert_equal 'updated content', e2.reload.content
-  end
-  
-  # NOTE: expected escape processing to be disabled by default for non-prepared statements
-  def test_quoting_braces
-    e = Entry.create! :title => '{'
-    assert_equal "{", e.reload.title
-    e = Entry.create! :title => '{}'
-    assert_equal "{}", e.reload.title
-    
-    e = Entry.create! :title => "\\'{}{"
-    assert_equal "\\'{}{", e.reload.title
-    
-    e = Entry.create! :title => '}{"\'}  \''
-    assert_equal "}{\"'}  '", e.reload.title
-  end
-
-  def test_emulates_booleans_by_default
-    assert connection.class.emulate_booleans
-    assert_true ArJdbc::MySQL.emulate_booleans
-    assert_true ActiveRecord::ConnectionAdapters::MysqlAdapter.emulate_booleans
-  end if ar_version('3.0')
-
-  def test_boolean_emulation_can_be_disabled
-    db_type = DbType.create! :sample_boolean => true
-    column = DbType.columns.find { |col| col.name.to_s == 'sample_boolean' }
-    assert_equal :boolean, column.type
-    ActiveRecord::ConnectionAdapters::MysqlAdapter.emulate_booleans = false
-    
-    DbType.reset_column_information
-    column = DbType.columns.find { |col| col.name.to_s == 'sample_boolean' }
-    assert_equal :integer, column.type
-    
-    assert_equal 1, db_type.reload.sample_boolean
-  ensure
-    ArJdbc::MySQL.emulate_booleans = true
-    DbType.reset_column_information
-  end if ar_version('3.0')
-  
-  def test_pk_and_sequence_for
-    assert_equal [ 'id', nil ], connection.pk_and_sequence_for('entries')
-  end
-  
-  def test_mysql_indexes
-    if ar_version('4.0')
-      assert connection.class.const_defined?(:INDEX_TYPES)
-    end
-  end
-  
-end
-
-class MysqlHasManyThroughTest < Test::Unit::TestCase
-  include HasManyThroughMethods
-end

data/test/db/mysql/statement_escaping_test.rb

@@ -1,46 +0,0 @@
-require 'jdbc_common'
-require 'db/mysql'
-
-class StatementEscapingTest < Test::Unit::TestCase
-  include FixtureSetup
-
-  def setup
-    super
-    ActiveRecord::Base.clear_active_connections!
-    @config = ActiveRecord::Base.connection.config
-  end
-
-  def teardown
-    ActiveRecord::Base.clear_active_connections!
-    ActiveRecord::Base.establish_connection @config
-    super
-  end
-
-  def test_false
-    set_escape_processing false
-    e1 = Entry.create! :title => "\\'{}{"
-    e2 = Entry.find(e1.id)
-    assert_equal "\\'{}{", e2.title
-  end
-
-  def set_escape_processing(value)
-    ActiveRecord::Base.establish_connection @config.merge(:statement_escape_processing => value)
-  end
-
-  def test_not_set
-    set_escape_processing nil
-    verify_escaped
-  end
-
-  def verify_escaped
-    e = Entry.create! :title => 'abc'
-    rs = ActiveRecord::Base.connection.execute(
-        "SELECT {fn concat(title, 'xyz')} AS title from entries WHERE id = #{e.id}")
-    assert_equal 'abcxyz', rs.first['title']
-  end
-
-  def test_true
-    set_escape_processing true
-    verify_escaped
-  end
-end

data/test/db/mysql/transaction_test.rb

@@ -1,6 +0,0 @@
-require 'db/mysql'
-require 'transaction'
-
-class MySQLTransactionTest < Test::Unit::TestCase
-  include TransactionTestMethods
-end

data/test/db/mysql/types_test.rb

@@ -1,30 +0,0 @@
-require 'db/mysql'
-
-class MySQLTypesTest < Test::Unit::TestCase
-  
-  def test_binary_types
-    assert_equal 'varbinary(64)', type_to_sql(:binary, 64)
-    assert_equal 'varbinary(4095)', type_to_sql(:binary, 4095)
-    assert_equal 'blob(4096)', type_to_sql(:binary, 4096)
-    assert_equal 'blob', type_to_sql(:binary)
-  end
-
-  def type_to_sql(*args)
-    ActiveRecord::Base.connection.type_to_sql(*args)
-  end
-
-  def self.startup
-    ActiveRecord::Base.connection.execute "CREATE TABLE enum_tests ( enum_column ENUM('true','false') )"
-  end
-  
-  def self.shutdown
-    ActiveRecord::Base.connection.execute "DROP TABLE IF EXISTS enum_tests;"
-  end
-  
-  class EnumTest < ActiveRecord::Base; end
-
-  def test_enum_limit
-    assert_equal 5, EnumTest.columns.first.limit
-  end
-  
-end 

data/test/db/mysql/unit_test.rb

@@ -1,93 +0,0 @@
-# encoding: ASCII-8BIT
-require 'test_helper'
-
-class MySQLUnitTest < Test::Unit::TestCase
-
-  class MySQLImpl
-    include ArJdbc::MySQL
-    def initialize; end
-  end
-  mySQL = MySQLImpl.new
-  
-  test "quotes string value" do
-    { 
-      "\x00" => "\\0", 
-      "\n" => "\\n", 
-      "\r" => "\\r",  
-      "\x1A" => "\\Z", 
-      '"' => "\\\"", 
-      "'" => "\\'", 
-      "\\" => "\\\\", 
-    }.each do |s, q|
-      assert_equal q, mySQL.quote_string(s)
-      assert_equal "string #{q}", mySQL.quote_string(v = "string #{s}"), "while quoting #{v.inspect}"
-      assert_equal " #{q}", mySQL.quote_string(v = " #{s}"), "while quoting #{v.inspect}"
-      assert_equal "#{q}str", mySQL.quote_string(v = "#{s}str"), "while quoting #{v.inspect}"
-    end
-  end
-  
-  test "quote string (with encoding mysql2 style)" do
-    s = "'' \\| \" \x00 \x01 \x1A \xA1 \r \n \\nOiZe \r\n'\x01\X\xA1\xA1\n"
-    q = "\\'\\' \\\\| \\\" \\0 \x01 \\Z \xA1 \\r \\n \\\\nOiZe \\r\\n\\'\x01X\xA1\xA1\\n"
-    if RUBY_VERSION > '1.9' # mysql2 compatibility
-      q2 = q.dup.force_encoding 'UTF-8'
-      assert_equal q2, mySQL.quote_string(s)
-    else
-      assert_equal q, mySQL.quote_string(s)
-    end
-    
-    if s.respond_to?(:force_encoding)
-      s.force_encoding('UTF-8')
-      q.force_encoding('UTF-8')
-      v = mySQL.quote_string(s)
-      assert_equal q, v
-      assert_equal q.encoding, v.encoding
-      
-      s.force_encoding('ASCII-8BIT')
-      v = mySQL.quote_string(s)
-      assert_equal q, v
-      # Mysql2::Client.new(...).escape(s) compatible :
-      assert_equal 'UTF-8', v.encoding.name
-      # Mysql.escape_string(s) returns ASCII-8BIT
-    end
-  end
-  
-  test "quote string (utf-8)" do
-    s = "\x1Akôň ůň löw9876\r\nqűáéőú\n.éáű-mehehehehehehe0 \x01\x00\x00\\\x02\\'"
-    q = "\\Zkôň ůň löw9876\\r\\nqűáéőú\\n.éáű-mehehehehehehe0 \x01\\0\\0\\\\\x02\\\\\\'"
-    if RUBY_VERSION > '1.9' # mysql2 compatibility
-      q2 = q.dup.force_encoding 'UTF-8'
-      assert_equal q2, mySQL.quote_string(s.dup)
-      
-      q.force_encoding('UTF-8')
-      s.force_encoding('UTF-8')
-      assert_equal q, mySQL.quote_string(s)
-    else
-      assert_equal q, mySQL.quote_string(s.dup)
-    end
-    assert_equal q, mySQL.quote_string(s)
-  end
-  
-  test "quote string keeps original string" do
-    s = "mehehehehehehe0 \x01 \x02 nothing-to-quote-here ..."
-    assert_equal s, mySQL.quote_string(s.dup)
-    
-    if s.respond_to?(:force_encoding)
-      s.force_encoding('UTF-8')
-      assert_equal s, mySQL.quote_string(s.dup)
-    end
-    assert_equal s, mySQL.quote_string(s)
-  end
-
-  test "quote string keeps original (utf-8)" do
-    s = "kôň ůň löw9876qűáéőú.éáű-mehehehehehehe0 \x01 \x02 nothing-to-quote"
-    assert_equal s, mySQL.quote_string(s.dup)
-    
-    if s.respond_to?(:force_encoding)
-      s.force_encoding('UTF-8')
-      assert_equal s, mySQL.quote_string(s.dup)
-    end
-    assert_equal s, mySQL.quote_string(s)
-  end
-  
-end

data/test/db/mysql_config.rb

@@ -1,7 +0,0 @@
-MYSQL_CONFIG = {
-  :username => 'arjdbc',
-  :password => 'arjdbc',
-  :adapter  => 'mysql',
-  :database => 'arjdbc_test',
-  :host     => 'localhost'
-}

data/test/db/oracle.rb

@@ -1,27 +0,0 @@
-require 'test_helper'
-
-config = {
-  :adapter  => 'oracle',
-  :username => ENV["ORACLE_USER"] || 'blog',
-  :password => ENV["ORACLE_PASS"] || 'blog',
-  :host => ENV["ORACLE_HOST"] || 'localhost',
-  :database => ENV["ORACLE_SID"] || 'XE'
-}
-
-ActiveRecord::Base.establish_connection(config)
-
-require 'jdbc/oracle'
-# Download JDBC driverfrom :
-# http://www.oracle.com/technetwork/database/enterprise-edition/jdbc-112010-090769.html
-begin
-  Java::JavaClass.for_name(Jdbc::Oracle.driver_name)
-rescue NameError
-  begin
-    Jdbc::Oracle.load_driver
-  rescue LoadError => e
-    puts "Please setup a JDBC driver to run the Oracle tests !"
-    raise e
-  end
-end
-
-ActiveRecord::Base.establish_connection(config)

data/test/db/oracle/binary_test.rb

@@ -1,6 +0,0 @@
-require 'db/oracle'
-require 'binary'
-
-class OracleBinaryTest < Test::Unit::TestCase
-  include BinaryTestMethods
-end

data/test/db/oracle/limit_test.rb

@@ -1,24 +0,0 @@
-require 'jdbc_common'
-require 'db/oracle'
-
-class OracleLimitTest < Test::Unit::TestCase
-  include FixtureSetup
-
-  def setup
-    super
-
-    1010.times do |n|
-      Entry.create!(:user => User.create!(:login => "Test User#{n}"),
-                    :title => "Entry #{n}", 
-                    :rating => n, 
-                    :content => "Testing Content #{n}")
-    end  
-  end
-   
-  def test_oracle_limit_properly_handled
-    assert_nothing_thrown do 
-      Entry.includes(:user).all
-    end
-  end if ar_version('3.1') # in_clause_limit not supported in AR <= 3.0
-  
-end