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

data/test/db/mysql/nonstandard_primary_key_test.rb

@@ -1,24 +1,24 @@
 require 'jdbc_common'
 require 'db/mysql'
 
-class Project < ActiveRecord::Migration
-  def self.up
-    create_table :project, :primary_key => "project_id" do |t|
-      t.string      :projectType, :limit => 31
-      t.boolean     :published
-      t.datetime    :created_date
-      t.text        :abstract, :title
-    end
-  end
-
-  def self.down
-    drop_table :project
-  end
+class MysqlNonstandardPrimaryKeyTest < Test::Unit::TestCase
 
-end
+  class Project < ActiveRecord::Migration
+    def self.up
+      create_table :project, :primary_key => "project_id" do |t|
+        t.string      :projectType, :limit => 31
+        t.boolean     :published
+        t.datetime    :created_date
+        t.text        :abstract, :title
+      end
+    end
 
-class MysqlNonstandardPrimaryKeyTest < Test::Unit::TestCase
+    def self.down
+      drop_table :project
+    end
 
+  end
+  
   def setup
     Project.up
   end
@@ -27,16 +27,13 @@ class MysqlNonstandardPrimaryKeyTest < Test::Unit::TestCase
     Project.down
   end
 
-  def standard_dump
-    stream = StringIO.new
-    ActiveRecord::SchemaDumper.ignore_tables = []
-    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
-    stream.string
-  end
-
   def test_nonstandard_primary_key
-    output = standard_dump
-    assert_match %r(:primary_key => "project_id"), output, "non-standard primary key not preserved"
+    output = schema_dump
+    if ar_version('4.0')
+      assert_match %r(primary_key: "project_id"), output, "non-standard primary key not preserved"
+    else
+      assert_match %r(:primary_key => "project_id"), output, "non-standard primary key not preserved"
+    end
   end
 
 end

data/test/db/mysql/rake_test.rb

@@ -0,0 +1,97 @@
+require 'rake_test_support'
+require 'db/mysql'
+
+class MySQLRakeTest < Test::Unit::TestCase
+  include RakeTestSupport
+
+  def db_config
+    MYSQL_CONFIG
+  end
+
+  def do_teardown
+    drop_rake_test_database(:silence)
+  end
+  
+  test 'rake db:create (and db:drop)' do
+    # omit_unless find_executable?("mysql")
+    Rake::Task["db:create"].invoke
+    with_mysql do |mysql|
+      mysql << "show databases where `Database` = '#{db_name}';"
+      mysql.close_write
+      output = mysql.read
+      assert output =~ /#{db_name}/m, "db name: #{db_name.inspect} not matched in:\n#{output}"
+    end if find_executable?("mysql")
+    
+    Rake::Task["db:drop"].invoke
+    with_mysql do |mysql|
+      mysql << "show databases where `Database` = '#{db_name}';"
+      mysql.close_write
+      output = mysql.read
+      assert_nil output =~ /#{db_name}/m, "db name: #{db_name.inspect} matched in:\n#{output}"
+    end if find_executable?("mysql")
+  end
+
+  test 'rake db:test:purge' do
+    # Rake::Task["db:create"].invoke
+    create_rake_test_database do |connection|
+      connection.create_table('users') { |t| t.string :name }
+    end
+    
+    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
+    # Rake::Task["db:create"].invoke
+    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
+      drop_rake_test_database(:silence)
+      create_rake_test_database
+      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
+  
+  setup { rm_r 'db' if File.exist?('db') }
+  
+  test 'rake db:charset' do
+    create_rake_test_database
+    expect_rake_output 'utf8'
+    Rake::Task["db:charset"].invoke
+  end
+
+  test 'rake db:collation' do
+    create_rake_test_database
+    expect_rake_output /utf8_.*?_ci/
+    Rake::Task["db:collation"].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/db/mysql/schema_dump_test.rb

@@ -39,19 +39,19 @@ class MysqlSchemaDumpTest < Test::Unit::TestCase
   
   def test_schema_dump_should_not_add_default_value_for_mysql_text_field
     output = standard_dump
-    assert_match %r{t.text\s+"just_text",\s+:null => false$}, output
+    assert_match %r{t.text\s+"just_text",[\s|:]+null[\s\:\=\>]+false$}, output
   end
   
   def test_schema_dump_includes_length_for_mysql_blob_and_text_fields
     output = standard_dump   
-    assert_match %r{t.binary\s+"tiny_blob",\s+:limit => 255$}, output
+    assert_match %r{t.binary\s+"tiny_blob",[\s|:]+limit[\s\:\=\>]+255$}, output
     assert_match %r{t.binary\s+"normal_blob"$}, output
-    assert_match %r{t.binary\s+"medium_blob",\s+:limit => 16777215$}, output
-    assert_match %r{t.binary\s+"long_blob",\s+:limit => 2147483647$}, output
-    assert_match %r{t.text\s+"tiny_text",\s+:limit => 255$}, output
+    assert_match %r{t.binary\s+"medium_blob",[\s|:]+limit[\s\:\=\>]+16777215$}, output
+    assert_match %r{t.binary\s+"long_blob",[\s|:]+limit[\s\:\=\>]+2147483647$}, output
+    assert_match %r{t.text\s+"tiny_text",[\s|:]+limit[\s\:\=\>]+255$}, output
     assert_match %r{t.text\s+"normal_text"$}, output
-    assert_match %r{t.text\s+"medium_text",\s+:limit => 16777215$}, output
-    assert_match %r{t.text\s+"long_text",\s+:limit => 2147483647$}, output
+    assert_match %r{t.text\s+"medium_text",[\s|:]+limit[\s\:\=\>]+16777215$}, output
+    assert_match %r{t.text\s+"long_text",[\s|:]+limit[\s\:\=\>]+2147483647$}, output
   end
   
   def test_schema_dump_includes_length_for_mysql_binary_fields
@@ -132,18 +132,18 @@ class MysqlInfoTest < Test::Unit::TestCase
     strio = StringIO.new
     ActiveRecord::SchemaDumper::dump(connection, strio)
     dump = strio.string
-    assert_match %r{t.text\s+"text",\s+:limit => 2147483647$}, dump
+    assert_match %r{t.text\s+"text",[\s|:]+limit[\s\:\=\>]+2147483647$}, dump
   end
 
   # JRUBY-5040
   def test_schema_dump_should_not_have_limits_on_datetime
     dump = schema_dump
-    dump.lines.grep(/datetime/).each {|line| assert line !~ /limit/ }
+    dump.lines.grep(/datetime/).each { |line| assert line !~ /limit/ }
   end
 
   def test_schema_dump_should_not_have_limits_on_date
     dump = schema_dump
-    dump.lines.grep(/date/).each {|line| assert line !~ /limit/ }
+    dump.lines.grep(/date/).each { |line| assert line !~ /limit/ }
   end
 
   def test_should_include_limit
@@ -153,7 +153,7 @@ class MysqlInfoTest < Test::Unit::TestCase
 
   def test_should_set_sqltype_to_longtext
     text_column = connection.columns('memos').find { |c| c.name == 'text' }
-    assert text_column.sql_type =~ /^longtext/i
+    assert text_column.sql_type =~ /^longtext/i, "longtext sql type expected for: #{text_column.inspect}"
   end
 
   def test_should_set_type_to_text

data/test/db/mysql/simple_test.rb

@@ -21,8 +21,7 @@ class MysqlSimpleTest < Test::Unit::TestCase
   def test_column_class_instantiation
     text_column = nil
     assert_nothing_raised do
-      text_column = ActiveRecord::ConnectionAdapters::MysqlColumn.
-        new("title", nil, "text")
+      text_column = ActiveRecord::ConnectionAdapters::MysqlAdapter::Column.new("title", nil, "text")
     end
     assert_not_nil text_column
   end
@@ -105,7 +104,11 @@ class MysqlSimpleTest < Test::Unit::TestCase
     begin
       User.table_name  = "#{database}.users"
       Entry.table_name = "#{database}.entries"
-      assert_not_empty Entry.all(:include => :user)
+      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
@@ -131,6 +134,52 @@ class MysqlSimpleTest < Test::Unit::TestCase
     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

data/test/db/mysql/statement_escaping_test.rb

@@ -0,0 +1,46 @@
+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/oracle/rake_test.rb

@@ -0,0 +1,100 @@
+require 'rake_test_support'
+require 'db/oracle'
+
+class OracleRakeDbCreateTest < Test::Unit::TestCase
+  include RakeTestSupport
+  
+  def db_name; nil; end # using same Oracle DB
+  
+  test 'rake db:drop' do
+    create_rake_test_database do |connection|
+      connection.create_table('oraclers_test') { |t| t.string :name }
+    end
+    
+    Rake::Task["db:drop"].invoke
+
+    establish_test_connection
+    assert_false ActiveRecord::Base.connection.table_exists?('oraclers_test')
+    ActiveRecord::Base.connection.disconnect!
+  end
+  
+  test 'rake db:test:purge' do
+    # Rake::Task["db:create"].invoke
+    create_rake_test_database do |connection|
+      create_schema_migrations_table(connection)
+      connection.create_table('oraclers_test') { |t| t.string :name }
+    end
+    
+    Rake::Task["db:test:purge"].invoke
+
+    establish_test_connection
+    assert_false ActiveRecord::Base.connection.table_exists?('oraclers_test')
+    ActiveRecord::Base.connection.disconnect!
+  end
+
+  test 'rake db:structure:dump (and db:structure:load)' do
+    # Rake::Task["db:create"].invoke
+    create_rake_test_database do |connection|
+      drop_all_database_tables(connection)
+      create_schema_migrations_table(connection)
+      connection.create_table('oraclers') { |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 \"?ORACLERS\"?/i, File.read(structure_sql)
+      
+      # db:structure:load
+      drop_all_database_tables
+      create_rake_test_database
+      Rake::Task["db:structure:load"].invoke
+      
+      establish_test_connection
+      assert ActiveRecord::Base.connection.table_exists?('oraclers')
+      ActiveRecord::Base.connection.disconnect!
+    ensure
+      File.delete(structure_sql) if File.exists?(structure_sql)
+      Dir.rmdir 'db'
+    end
+  end
+  
+  setup { rm_r 'db' if File.exist?('db') }
+
+  test 'rake db:charset' do
+    create_rake_test_database
+    expect_rake_output 'AL32UTF8'
+    Rake::Task["db:charset"].invoke
+  end
+
+  test 'rake db:collation' do
+    create_rake_test_database
+    expect_rake_output /BINARY/
+    Rake::Task["db:collation"].invoke
+  end
+  
+  private
+  
+  def establish_test_connection
+    config = db_config.dup
+    config.merge! :database => db_name if db_name
+    ActiveRecord::Base.establish_connection config
+  end
+  
+  def drop_all_database_tables(connection = nil)
+    established = nil
+    connection ||= begin 
+      ActiveRecord::Base.connection
+    rescue
+      ActiveRecord::Base.establish_connection db_config
+      established = true
+      ActiveRecord::Base.connection
+    end
+    connection.tables.each { |table| connection.drop_table(table) }
+    ActiveRecord::Base.connection.disconnect! if established
+  end
+  
+end

data/test/db/oracle/simple_test.rb

@@ -63,6 +63,54 @@ class OracleSimpleTest < Test::Unit::TestCase
   end if Test::Unit::TestCase.ar_version('3.1') # no binds argument for <= 3.0
   
   include ExplainSupportTestMethods if ar_version("3.1")
+
+  def test_quotes_reserved_word_column
+    connection.create_table 'lusers', :force => true do |t|
+      t.string :file
+      t.text "desc", :limit => 16777216
+      t.date :'date', :null => false
+    end
+  ensure
+    connection.drop_table('lusers') rescue nil
+  end
+  
+  def test_emulates_booleans_by_default
+    assert_true ArJdbc::Oracle.emulate_booleans
+    # assert_true ActiveRecord::ConnectionAdapters::OracleAdapter.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
+    ArJdbc::Oracle.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::Oracle.emulate_booleans = true
+    DbType.reset_column_information
+  end if ar_version('3.0')
+  
+  def test_set_table_name_prefixed_with_schema
+    schema = connection.config[:username]
+    activity = Class.new(ActiveRecord::Base) do # class Activity
+      if respond_to?(:table_name=)
+        self.table_name = "#{schema}.activities"
+        self.sequence_name = "#{schema}.activities_seq"
+      else
+        set_table_name "#{schema}.activities"
+        set_sequence_name "#{schema}.activities_seq"
+      end
+    end
+    connection.create_table(:activities) { |t| t.string :name }
+    assert activity.create! :name => 'an-activity' # Activity.create! ...
+  ensure
+    connection.drop_table(:activities) rescue nil
+  end
   
   protected