activerecord-jdbc-adapter-onsite 1.2.2

data/test/mssql_row_locking_test.rb

@@ -0,0 +1,9 @@
+#! /usr/bin/env jruby
+
+require 'jdbc_common'
+require 'db/mssql'
+
+class MssqlRowLockingTest < Test::Unit::TestCase
+  include MigrationSetup
+  include RowLockingTestMethods
+end

data/test/mssql_simple_test.rb

@@ -0,0 +1,55 @@
+require 'jdbc_common'
+require 'db/mssql'
+
+class MsSQLSimpleTest < Test::Unit::TestCase
+
+  include SimpleTestMethods
+
+  # MS SQL 2005 doesn't have a DATE class, only TIMESTAMP.
+  undef_method :test_save_date
+
+  # String comparisons are insensitive by default
+  undef_method :test_validates_uniqueness_of_strings_case_sensitive
+
+  def test_does_not_munge_quoted_strings
+    example_quoted_values = [%{'quoted'}, %{D\'oh!}]
+    example_quoted_values.each do |value|
+      entry = Entry.create!(:title => value)
+      entry.reload
+      assert_equal(value, entry.title)
+    end
+  end
+
+  def test_change_column_default
+
+    Entry.connection.change_column "entries", "title", :string, :default => "new default"
+    Entry.reset_column_information
+    assert_equal("new default", Entry.new.title)
+
+    Entry.connection.change_column "entries", "title", :string, :default => nil
+    Entry.reset_column_information
+    assert_equal(nil, Entry.new.title)
+
+  end
+
+  def test_change_column_nullability
+    
+    Entry.connection.change_column "entries", "title", :string, :null => true
+    Entry.reset_column_information
+    title_column = Entry.columns.find { |c| c.name == "title" }
+    assert(title_column.null)
+
+    Entry.connection.change_column "entries", "title", :string, :null => false
+    Entry.reset_column_information
+    title_column = Entry.columns.find { |c| c.name == "title" }
+    assert(!title_column.null)
+
+  end
+
+  # ACTIVERECORD_JDBC-124
+  def test_model_does_not_have_row_num_column
+    entry = Entry.first
+    assert !entry.attributes.keys.include?("_row_num")
+    assert !entry.respond_to?(:_row_num)
+  end
+end

data/test/mysql_db_create_test.rb

@@ -0,0 +1,27 @@
+require 'abstract_db_create'
+require 'db/mysql'
+
+class MysqlDbCreateTest < Test::Unit::TestCase
+  include AbstractDbCreate
+
+  def db_config
+    MYSQL_CONFIG
+  end
+
+  def test_rake_db_create
+    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
+    end
+  end
+
+  def test_rake_db_test_purge
+    Rake::Task["db:create"].invoke
+    Rake::Task["db:test:purge"].invoke
+  end
+end

data/test/mysql_index_length_test.rb

@@ -0,0 +1,58 @@
+require 'jdbc_common'
+require 'db/mysql'
+
+class MySQLIndexLengthDBSetup < ActiveRecord::Migration
+  def self.up
+    execute <<-SQL
+      CREATE TABLE index_length_test (
+        int_column INT,
+        text_column TEXT,
+        second_text_column TEXT,
+        INDEX ix_int (int_column),
+        INDEX ix_length_text (text_column(255))
+      )
+    SQL
+  end
+
+  def self.down
+    drop_table 'index_length_test'
+  end
+end
+
+class MySQLIndexLengthTest < Test::Unit::TestCase
+  def setup
+    MySQLIndexLengthDBSetup.up
+    @connection = ActiveRecord::Base.connection
+  end
+
+  def teardown
+    MySQLIndexLengthDBSetup.down
+  end
+
+  def test_index_length
+    index = @connection.indexes('index_length_test').find { |idx| idx.name == 'ix_length_text' }
+    assert_not_nil index
+    assert_equal "index_length_test", index.table
+    assert_equal "ix_length_text", index.name
+    assert !index.unique
+    assert_equal ["text_column"], index.columns
+    assert_equal [255], index.lengths
+  end
+
+  def test_add_index
+    @connection.add_index 'index_length_test', ['text_column', 'second_text_column'],
+      :name => 'added_index', :length => {'text_column' => 32, 'second_text_column' => 64}
+
+    index = @connection.indexes('index_length_test').find { |idx| idx.name == 'added_index' }
+    assert_not_nil index
+    assert_equal ['text_column', 'second_text_column'], index.columns
+    assert_equal [32, 64], index.lengths
+  end
+
+  def test_index_without_length
+    index = @connection.indexes('index_length_test').find { |idx| idx.name == 'ix_int' }
+    assert_not_nil index
+    assert_equal ['int_column'], index.columns
+    assert_equal [nil], index.lengths
+  end
+end

data/test/mysql_info_test.rb

@@ -0,0 +1,123 @@
+require 'jdbc_common'
+require 'db/mysql'
+begin; require 'active_support/core_ext/numeric/bytes'; rescue LoadError; end
+
+class DBSetup < ActiveRecord::Migration
+
+  def self.up
+    create_table :books do |t|
+      t.string :title
+      t.timestamps
+    end
+
+    create_table :cars, :primary_key => 'legacy_id' do |t|
+      t.string :name
+      t.date :production_started_on
+    end
+
+    create_table :cats, :id => false do |t|
+      t.string :name
+    end
+
+    create_table :memos do |t|
+      t.text :text, :limit => 16.megabytes
+    end
+  end
+
+  def self.down
+    drop_table :books
+    drop_table :cars
+    drop_table :cats
+    drop_table :memos
+  end
+
+end
+
+class MysqlInfoTest < Test::Unit::TestCase
+
+  def setup
+    DBSetup.up
+    @connection = ActiveRecord::Base.connection
+  end
+
+  def teardown
+    DBSetup.down
+  end
+
+  ## primary_key
+  def test_should_return_the_primary_key_of_a_table
+    assert_equal 'id', @connection.primary_key('books')
+  end
+
+  def test_should_be_able_to_return_a_custom_primary_key
+    assert_equal 'legacy_id', @connection.primary_key('cars')
+  end
+
+  def test_should_return_nil_for_a_table_without_a_primary_key
+    assert_nil @connection.primary_key('cats')
+  end
+
+  ## structure_dump
+  def test_should_include_the_tables_in_a_structure_dump
+    # TODO: Improve these tests, I added this one because no other tests exists for this method.
+    dump = @connection.structure_dump
+    assert dump.include?('CREATE TABLE `books`')
+    assert dump.include?('CREATE TABLE `cars`')
+    assert dump.include?('CREATE TABLE `cats`')
+    assert dump.include?('CREATE TABLE `memos`')
+  end
+
+  def test_should_include_longtext_in_schema_dump
+    strio = StringIO.new
+    ActiveRecord::SchemaDumper::dump(@connection, strio)
+    dump = strio.string
+    assert_match %r{t.text\s+"text",\s+:limit => 2147483647$}, dump
+  end
+
+  # JRUBY-5040
+  def test_schema_dump_should_not_have_limits_on_datetime
+    strio = StringIO.new
+    ActiveRecord::SchemaDumper::dump(@connection, strio)
+    dump = strio.string
+    dump.lines.grep(/datetime/).each {|line| assert line !~ /limit/ }
+  end
+
+  def test_schema_dump_should_not_have_limits_on_date
+    strio = StringIO.new
+    ActiveRecord::SchemaDumper::dump(@connection, strio)
+    dump = strio.string
+    dump.lines.grep(/date/).each {|line| assert line !~ /limit/ }
+  end
+
+  def test_should_include_limit
+    text_column = @connection.columns('memos').find { |c| c.name == 'text' }
+    assert_equal 2147483647, text_column.limit
+  end
+
+  def test_should_set_sqltype_to_longtext
+    text_column = @connection.columns('memos').find { |c| c.name == 'text' }
+    assert text_column.sql_type =~ /^longtext/i
+  end
+
+  def test_should_set_type_to_text
+    text_column = @connection.columns('memos').find { |c| c.name == 'text' }
+    assert_equal :text, text_column.type
+  end
+
+  def test_verify_url_has_options
+    url = @connection.config[:url]
+    assert url =~ /characterEncoding=utf8/
+    assert url =~ /useUnicode=true/
+    assert url =~ /zeroDateTimeBehavior=convertToNull/
+  end
+
+  def test_no_limits_for_some_data_types
+    DbTypeMigration.up
+    strio = StringIO.new
+    ActiveRecord::SchemaDumper.dump(@connection, strio)
+    dump_lines = strio.string
+    assert_nil dump_lines.lines.detect {|l| l =~ /\.(float|date|datetime|integer|time|timestamp) .* :limit/ && l !~ /sample_integer/ }
+  ensure
+    DbTypeMigration.down
+  end
+end

data/test/mysql_multibyte_test.rb

@@ -0,0 +1,10 @@
+require 'jdbc_common'
+require 'db/mysql'
+
+class MySQLMultibyteTest < Test::Unit::TestCase
+  include MultibyteTestMethods
+end
+
+class MySQLNonUTF8EncodingTest < Test::Unit::TestCase
+  include NonUTF8EncodingMethods
+end

data/test/mysql_nonstandard_primary_key_test.rb

@@ -0,0 +1,42 @@
+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
+
+end
+
+class MysqlNonstandardPrimaryKeyTest < Test::Unit::TestCase
+
+  def setup
+    Project.up
+  end
+
+  def teardown
+    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"
+  end
+
+end

data/test/mysql_reset_column_information_test.rb

@@ -0,0 +1,8 @@
+#! /usr/bin/env jruby
+
+require 'jdbc_common'
+require 'db/mysql'
+
+class MySQLResetColumnInformationTest < Test::Unit::TestCase
+  include ResetColumnInformationTestMethods
+end

data/test/mysql_simple_test.rb

@@ -0,0 +1,125 @@
+# 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
+
+  column_quote_char "`"
+
+  def test_column_class_instantiation
+    text_column = nil
+    assert_nothing_raised do
+      text_column = ActiveRecord::ConnectionAdapters::MysqlColumn.
+        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
+  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_1 = Entry.create :title => 'title_1', :content => 'content_1', :rating => 0,
+    :user_id => user_1.id
+    entry_2 = 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
+
+  # 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
+    old_entries_table_name = Entry.table_name
+    old_users_table_name   = User.table_name
+    begin
+      User.table_name  = "#{MYSQL_CONFIG[:database]}.users"
+      Entry.table_name = "#{MYSQL_CONFIG[:database]}.entries"
+      assert !Entry.all(:include => :user).empty?
+    ensure
+      Entry.table_name = old_entries_table_name
+      User.table_name  = old_users_table_name
+    end
+  end
+
+  def test_create_xml_column
+    assert_nothing_raised do
+      @connection.create_table :xml_testings do |t|
+        t.xml :xml_test
+      end
+    end
+
+    xml_test = @connection.columns(:xml_testings).detect do |c|
+      c.name == "xml_test"
+    end
+
+    assert_equal "text", xml_test.sql_type
+  ensure
+    @connection.drop_table :xml_testings rescue nil
+  end
+end
+
+class MysqlHasManyThroughTest < Test::Unit::TestCase
+  include HasManyThroughMethods
+end