cmoran92-activerecord-jdbc-adapter 1.2.1

data/test/mssql_limit_offset_test.rb

@@ -0,0 +1,136 @@
+require 'jdbc_common'
+require 'db/mssql'
+
+ActiveRecord::Schema.verbose = false
+
+class CreateLongShips < ActiveRecord::Migration
+
+  def self.up
+    create_table "long_ships", :force => true do |t|
+      t.string "name", :limit => 50, :null => false
+      t.integer "width", :default => 123
+      t.integer "length", :default => 456
+    end
+  end
+
+  def self.down
+    drop_table "long_ships"
+  end
+
+end
+
+class LongShip < ActiveRecord::Base
+  has_many :vikings
+end
+
+class CreateVikings < ActiveRecord::Migration
+
+  def self.up
+    create_table "vikings", :force => true do |t|
+      t.integer "long_ship_id", :null => false
+      t.string "name", :limit => 50, :default => "Sven"
+    end
+  end
+
+  def self.down
+    drop_table "vikings"
+  end
+
+end
+
+class Viking < ActiveRecord::Base
+  belongs_to :long_ship
+end
+
+
+class CreateNoIdVikings < ActiveRecord::Migration
+  def self.up
+    create_table "no_id_vikings", :force => true do |t|
+      t.string "name", :limit => 50, :default => "Sven"
+    end
+    remove_column "no_id_vikings", "id"
+  end
+
+  def self.down
+    drop_table "no_id_vikings"
+  end
+end
+
+class NoIdViking < ActiveRecord::Base
+end
+
+
+
+class MsSQLLimitOffsetTest < Test::Unit::TestCase
+
+  def setup
+    CreateLongShips.up
+    CreateVikings.up
+    CreateNoIdVikings.up
+    @connection = ActiveRecord::Base.connection
+  end
+
+  def teardown
+    CreateVikings.down
+    CreateLongShips.down
+    CreateNoIdVikings.down
+    ActiveRecord::Base.clear_active_connections!
+  end
+
+  def test_limit_with_no_id_column_available
+    NoIdViking.create!(:name => 'Erik')
+    assert_nothing_raised(ActiveRecord::StatementInvalid) do 
+      NoIdViking.find(:first)
+    end
+  end
+
+  def test_limit_and_offset
+    %w(one two three four five six seven eight).each do |name|
+      LongShip.create!(:name => name)
+    end
+    ship_names = LongShip.find(:all, :offset => 2, :limit => 3).map(&:name)
+    assert_equal(%w(three four five), ship_names)
+  end
+
+  def test_limit_and_offset_with_order
+    %w(one two three four five six seven eight).each do |name|
+      LongShip.create!(:name => name)
+    end
+    ship_names = LongShip.find(:all, :order => "name", :offset => 4, :limit => 2).map(&:name)
+    assert_equal(%w(seven six), ship_names)
+  end
+
+  # TODO: work out how to fix DISTINCT support without breaking :include
+  # def test_limit_and_offset_with_distinct
+  #   %w(c a b a b a c d c d).each do |name|
+  #     LongShip.create!(:name => name)
+  #   end
+  #   ship_names = LongShip.find(:all, :select => "DISTINCT name", :order => "name", :offset => 1, :limit => 2).map(&:name)
+  #   assert_equal(%w(b c), ship_names)
+  # end
+
+  def test_limit_and_offset_with_include
+    skei = LongShip.create!(:name => "Skei")
+    skei.vikings.create!(:name => "Bob")
+    skei.vikings.create!(:name => "Ben")
+    skei.vikings.create!(:name => "Basil")
+    ships = Viking.find(:all, :include => :long_ship, :offset => 1, :limit => 2)
+    assert_equal(2, ships.size)
+  end
+
+  def test_limit_and_offset_with_include_and_order
+
+    boat1 = LongShip.create!(:name => "1-Skei")
+    boat2 = LongShip.create!(:name => "2-Skei")
+
+    boat1.vikings.create!(:name => "Adam")
+    boat2.vikings.create!(:name => "Ben")
+    boat1.vikings.create!(:name => "Carl")
+    boat2.vikings.create!(:name => "Donald")
+  
+    vikings = Viking.find(:all, :include => :long_ship, :order => "long_ships.name, vikings.name", :offset => 0, :limit => 3)
+    assert_equal(["Adam", "Carl", "Ben"], vikings.map(&:name))
+
+  end
+  
+end

data/test/mssql_multibyte_test.rb

@@ -0,0 +1,18 @@
+#! /usr/bin/env jruby
+
+require 'jdbc_common'
+require 'db/mssql'
+
+class MsSQLMultibyteTest < Test::Unit::TestCase
+  
+  include MultibyteTestMethods
+
+  def test_select_multibyte_string
+    Entry.create!(:title => 'テスト', :content => '本文')
+    entry = Entry.find(:last)
+    assert_equal "テスト", entry.title
+    assert_equal "本文", entry.content
+    assert_equal entry, Entry.find_by_title("テスト")
+  end
+    
+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