cmoran92-activerecord-jdbc-adapter 1.2.1

data/test/postgres_reserved_test.rb

@@ -0,0 +1,22 @@
+require 'jdbc_common'
+require 'db/postgres'
+require 'models/reserved_word'
+
+class PostgresReservedWordsTest < Test::Unit::TestCase
+  def setup
+    CreateReservedWords.up
+  end
+  def teardown
+    CreateReservedWords.down
+  end
+
+  def test_quote_reserved_word_column
+    columns = ReservedWord.column_names - ["id"]
+    ReservedWord.connection.add_index :reserved_words, columns
+    indexes = ReservedWord.connection.indexes("reserved_words")
+    assert_equal 1, indexes.size
+    columns.each do |c|
+      assert indexes[0].columns.include?(c), "#{indexes[0].columns.inspect} does not include #{c.inspect}"
+    end
+  end
+end

data/test/postgres_schema_search_path_test.rb

@@ -0,0 +1,48 @@
+require 'jdbc_common'
+require 'db/postgres'
+
+class CreateSchema < ActiveRecord::Migration
+  def self.up
+    execute "CREATE SCHEMA test"
+    execute "CREATE TABLE test.people (id serial, name text)"
+    execute "INSERT INTO test.people (name) VALUES ('Alex')"
+    execute "CREATE TABLE public.people (id serial, wrongname text)"
+  end
+
+  def self.down
+    execute "DROP SCHEMA test CASCADE"
+    execute "DROP TABLE people"
+  end
+end
+
+class Person < ActiveRecord::Base
+  establish_connection POSTGRES_CONFIG.merge(:schema_search_path => 'test,public')
+end
+
+class PostgresSchemaSearchPathTest < Test::Unit::TestCase
+  def setup
+    CreateSchema.up
+  end
+
+  def teardown
+    CreateSchema.down
+  end
+
+  def test_columns
+    assert_equal(%w{id name}, Person.column_names)
+  end
+
+  def test_find_right
+    assert_not_nil Person.find_by_name("Alex")
+  end
+
+  def test_find_wrong
+    assert_raise NoMethodError do
+      Person.find_by_wrongname("Alex")
+    end
+  end
+  def test_column_information
+    assert Person.columns.map{|col| col.name}.include?("name")
+    assert !Person.columns.map{|col| col.name}.include?("wrongname")
+  end
+end

data/test/postgres_simple_test.rb

@@ -0,0 +1,167 @@
+# To run this script, set up the following postgres user and database:
+#
+#   sudo -u postgres createuser -D -A -P blog
+#   sudo -u postgres createdb -O blog weblog_development
+#
+
+require 'jdbc_common'
+require 'db/postgres'
+
+class PostgresSimpleTest < Test::Unit::TestCase
+  include SimpleTestMethods
+  include ActiveRecord3TestMethods
+  include ColumnNameQuotingTests
+
+  def test_adapter_class_name_equals_native_adapter_class_name
+    classname = @connection.class.name[/[^:]*$/]
+    assert_equal 'PostgreSQLAdapter', classname
+  end
+
+  def test_encoding
+    assert_not_nil @connection.encoding
+  end
+
+  def test_multi_statement_support
+    results = @connection.execute "SELECT title from entries; SELECT login from users"
+    assert_equal 2, results.length
+    assert_equal ["title"], results[0].first.keys
+    assert_equal ["login"], results[1].first.keys
+  end
+
+  def test_create_xml_column
+    assert_nothing_raised do
+      @connection.create_table :xml_testings do |t|
+        t.column :xml_test, :xml
+      end
+    end
+
+    xml_test = @connection.columns(:xml_testings).detect do
+      |c| c.name == "xml_test"
+    end
+
+    assert_equal "xml", xml_test.sql_type
+  ensure
+    @connection.drop_table :xml_testings rescue nil
+  end
+
+  def test_create_table_with_limits
+    assert_nothing_raised do
+      @connection.create_table :testings do |t|
+        t.column :eleven_int, :integer, :limit => 11
+      end
+    end
+
+    columns = @connection.columns(:testings)
+    eleven = columns.detect { |c| c.name == "eleven_int" }
+    assert_equal "integer", eleven.sql_type
+  ensure
+    @connection.drop_table :testings rescue nil
+  end
+end
+
+class PostgresTimestampTest < Test::Unit::TestCase
+  def setup
+    DbTypeMigration.up
+  end
+
+  def teardown
+    DbTypeMigration.down
+  end
+
+  def test_string_is_character_varying
+    sample_string = DbType.connection.columns(:db_types).detect do |c|
+      c.name == "sample_string"
+    end
+
+    assert_match(/^character varying/, sample_string.sql_type)
+  end
+
+  # infinite timestamp tests based on rails tests for postgresql_adapter.rb
+  def test_load_infinity_and_beyond
+    d = DbType.find_by_sql("select 'infinity'::timestamp as sample_timestamp")
+    assert d.first.sample_timestamp.infinite?, 'timestamp should be infinite'
+
+    d = DbType.find_by_sql "select '-infinity'::timestamp as sample_timestamp"
+    time = d.first.sample_timestamp
+    assert time.infinite?, "timestamp should be infinte"
+    assert_operator time, :<, 0
+  end
+
+  def test_save_infinity_and_beyond
+    d = DbType.create!(:sample_timestamp => 1.0 / 0.0)
+    assert_equal(1.0 / 0.0, d.sample_timestamp)
+
+    e = DbType.create!(:sample_timestamp => -1.0 / 0.0)
+    assert_equal(-1.0 / 0.0, e.sample_timestamp)
+  end
+end
+
+class PostgresDeserializationTest < Test::Unit::TestCase
+  def setup
+    DbTypeMigration.up
+  end
+
+  def teardown
+    DbTypeMigration.down
+  end
+
+  def test_should_keep_float_precision
+    expected = DbType.create(:sample_float => 7.3)
+    actual = DbType.find(expected.id)
+
+    assert_equal expected.sample_float, actual.sample_float
+  end
+end
+
+class PostgresSchemaDumperTest < Test::Unit::TestCase
+  def setup
+    DbTypeMigration.up
+    @connection = ActiveRecord::Base.connection
+    strio = StringIO.new
+    ActiveRecord::SchemaDumper::dump(ActiveRecord::Base.connection, strio)
+    @dump = strio.string
+  end
+
+  def teardown
+    DbTypeMigration.down
+  end
+
+  # http://kenai.com/jira/browse/ACTIVERECORD_JDBC-135
+  def test_schema_dump_should_not_have_limits_on_boolean
+    lines = @dump.lines.grep(/boolean/)
+    assert !lines.empty?
+    lines.each {|line| assert line !~ /limit/ }
+  end
+
+
+  def test_schema_dump_should_not_have_limits_on_binaries
+    lines = @dump.lines.grep(/binary/)
+    assert !lines.empty?, 'no binary type definitions found'
+    lines.each {|line| assert line !~ /limit/, 'binary definition contains limit' }
+  end
+
+  # http://kenai.com/jira/browse/ACTIVERECORD_JDBC-139
+  def test_schema_dump_should_not_have_limits_on_text_or_date
+    lines = @dump.lines.grep(/date|text/)
+    assert !lines.empty?
+    lines.each {|line| assert line !~ /limit/ }
+  end
+
+  def test_schema_dump_integer_with_no_limit_should_have_no_limit
+    lines = @dump.lines.grep(/sample_integer_no_limit/)
+    assert !lines.empty?
+    lines.each {|line| assert line !~ /:limit/ }
+  end
+
+  def test_schema_dump_integer_with_limit_2_should_have_limit_2
+    lines = @dump.lines.grep(/sample_integer_with_limit_2/)
+    assert !lines.empty?
+    lines.each {|line| assert line =~ /limit => 2/ }
+  end
+
+  def test_schema_dump_integer_with_limit_8_should_have_limit_8
+    lines = @dump.lines.grep(/sample_integer_with_limit_8/)
+    assert !lines.empty?
+    lines.each {|line| assert line =~ /limit => 8/ }
+  end
+end

data/test/postgres_table_alias_length_test.rb

@@ -0,0 +1,15 @@
+require 'jdbc_common'
+require 'db/postgres'
+
+class PostgresTableAliasLengthTest < Test::Unit::TestCase
+  def test_table_alias_length
+    result = ActiveRecord::Base.connection.select_one("SELECT 1 AS " + "a" * 2048)
+
+    actual_table_alias_length = result.keys.first.size
+    actual_table_alias_length = 0 if actual_table_alias_length == 2048
+   
+    assert_equal(actual_table_alias_length,
+                 ActiveRecord::Base.connection.table_alias_length)
+  end
+end
+

data/test/postgres_type_conversion_test.rb

@@ -0,0 +1,34 @@
+require 'jdbc_common'
+require 'db/postgres'
+
+class BooleanSchema < ActiveRecord::Migration
+  def self.up
+    create_table :booleans do |t|
+      t.boolean :value, :default => false, :null => false
+    end
+  end
+
+  def self.down
+    drop_table :booleans
+  end
+end
+
+class Boolean < ActiveRecord::Base
+end
+
+class PostgresTypeConversionTest < Test::Unit::TestCase
+  def setup
+    BooleanSchema.up
+  end
+
+  def teardown
+    BooleanSchema.down
+  end
+
+  def test_should_handle_bool_conversion_with_boolean_relation
+    assert_nothing_raised do
+      ActiveRecord::Base.connection.raw_connection.set_native_database_types
+    end
+  end
+end
+

data/test/simple.rb

@@ -0,0 +1,658 @@
+# -*- coding: utf-8 -*-
+ActiveRecord::Schema.verbose = false
+ActiveRecord::Base.time_zone_aware_attributes = true if ActiveRecord::Base.respond_to?(:time_zone_aware_attributes)
+ActiveRecord::Base.default_timezone = :utc
+#just a random zone, unlikely to be local, and not utc
+Time.zone = 'Moscow' if Time.respond_to?(:zone)
+
+module MigrationSetup
+  def setup
+    DbTypeMigration.up
+    CreateStringIds.up
+    CreateEntries.up
+    CreateUsers.up
+    CreateAutoIds.up
+    CreateValidatesUniquenessOf.up
+    CreateThings.up
+    @connection = ActiveRecord::Base.connection
+  end
+
+  def teardown
+    DbTypeMigration.down
+    CreateStringIds.down
+    CreateEntries.down
+    CreateUsers.down
+    CreateAutoIds.down
+    CreateValidatesUniquenessOf.down
+    CreateThings.down
+    ActiveRecord::Base.clear_active_connections!
+  end
+end
+
+module FixtureSetup
+  include MigrationSetup
+  def setup
+    super
+    @title = "First post!"
+    @content = "Hello from JRuby on Rails!"
+    @new_title = "First post updated title"
+    @rating = 205.76
+    @user = User.create :login=>"something"
+    @entry = Entry.create :title => @title, :content => @content, :rating => @rating, :user=>@user
+    DbType.create
+  end
+end
+
+module ColumnNameQuotingTests
+  def self.included(base)
+    base.class_eval do
+      @@column_quote_char = "\""
+
+      def self.column_quote_char(char)
+        @@column_quote_char = char
+      end
+    end
+  end
+
+  def test_column_names_are_escaped
+    conn = ActiveRecord::Base.connection
+    quoted = conn.quote_column_name "foo#{column_quote_char}bar"
+    assert_equal "#{column_quote_char}foo#{column_quote_char * 2}bar#{column_quote_char}", quoted
+  end
+
+  protected
+  def column_quote_char
+    @@column_quote_char || "\""
+  end
+end
+
+module DirtyAttributeTests
+  def test_partial_update
+    entry = Entry.new(:title => 'foo')
+    old_updated_on = 1.hour.ago.beginning_of_day
+
+    with_partial_updates Entry, false do
+      assert_queries(2) { 2.times { entry.save! } }
+      Entry.update_all({ :updated_on => old_updated_on }, :id => entry.id)
+    end
+
+    with_partial_updates Entry, true do
+      assert_queries(0) { 2.times { entry.save! } }
+      assert_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
+    end
+  end
+
+  private
+  def with_partial_updates(klass, on = true)
+    old = klass.partial_updates?
+    klass.partial_updates = on
+    yield
+  ensure
+    klass.partial_updates = old
+  end
+end
+
+module SimpleTestMethods
+  include FixtureSetup
+
+  def test_substitute_binds_has_no_side_effect_on_binds_parameter
+    binds = [[Entry.columns_hash['title'], 'test1']]
+    binds2 = binds.dup
+    sql = 'select * from entries where title = ?'
+    Entry.connection.substitute_binds(sql, binds)
+    assert_equal binds2, binds
+  end
+
+  def test_entries_created
+    assert ActiveRecord::Base.connection.tables.find{|t| t =~ /^entries$/i}, "entries not created"
+  end
+
+  def test_users_created
+    assert ActiveRecord::Base.connection.tables.find{|t| t =~ /^users$/i}, "users not created"
+  end
+
+  def test_entries_empty
+    Entry.delete_all
+    assert_equal 0, Entry.count
+  end
+
+  def test_find_with_string_slug
+    new_entry = Entry.create(:title => "Blah")
+    entry = Entry.find(new_entry.to_param)
+    assert_equal new_entry.id, entry.id
+  end
+
+  def test_insert_returns_id
+    unless ActiveRecord::Base.connection.adapter_name =~ /oracle/i
+      value = ActiveRecord::Base.connection.insert("INSERT INTO entries (title, content, rating) VALUES('insert_title', 'some content', 1)")
+      assert !value.nil?
+      entry = Entry.find_by_title('insert_title')
+      assert_equal entry.id, value
+    end
+  end
+
+  def test_create_new_entry
+    Entry.delete_all
+
+    post = Entry.new
+    post.title = @title
+    post.content = @content
+    post.rating = @rating
+    post.save
+
+    assert_equal 1, Entry.count
+  end
+
+  def test_create_partial_new_entry
+    new_entry = Entry.create(:title => "Blah")
+    new_entry2 = Entry.create(:title => "Bloh")
+  end
+
+  def test_find_and_update_entry
+    post = Entry.find(:first)
+    assert_equal @title, post.title
+    assert_equal @content, post.content
+    assert_equal @rating, post.rating
+
+    post.title = @new_title
+    post.save
+
+    post = Entry.find(:first)
+    assert_equal @new_title, post.title
+  end
+
+  def test_destroy_entry
+    prev_count = Entry.count
+    post = Entry.find(:first)
+    post.destroy
+
+    assert_equal prev_count - 1, Entry.count
+  end
+
+  if Entry.respond_to?(:limit)
+    def test_limit
+      Entry.limit(10).to_a
+    end
+
+    def test_count_with_limit
+      assert_equal Entry.count, Entry.limit(10).count
+    end
+  end
+
+  if Time.respond_to?(:zone)
+    def test_save_time_with_utc
+      current_zone = Time.zone
+      default_zone = ActiveRecord::Base.default_timezone
+      ActiveRecord::Base.default_timezone = Time.zone = :utc
+      now = Time.now
+      my_time = Time.local now.year, now.month, now.day, now.hour, now.min, now.sec
+      m = DbType.create! :sample_datetime => my_time
+      m.reload
+      assert_equal my_time, m.sample_datetime
+    rescue
+      Time.zone = current_zone
+      ActiveRecord::Base.default_timezone = default_zone
+    end
+
+    def test_save_time
+      t = Time.now
+      #precision will only be expected to the second.
+      time = Time.local(t.year, t.month, t.day, t.hour, t.min, t.sec)
+      e = DbType.find(:first)
+      e.sample_datetime = time
+      e.save!
+      e = DbType.find(:first)
+      assert_equal time.in_time_zone, e.sample_datetime
+    end
+
+    def test_save_date_time
+      t = Time.now
+      #precision will only be expected to the second.
+      time = Time.local(t.year, t.month, t.day, t.hour, t.min, t.sec)
+      datetime = time.to_datetime
+      e = DbType.find(:first)
+      e.sample_datetime = datetime
+      e.save!
+      e = DbType.find(:first)
+      assert_equal time, e.sample_datetime.localtime
+    end
+
+    def test_save_time_with_zone
+      t = Time.now
+      #precision will only be expected to the second.
+      original_time = Time.local(t.year, t.month, t.day, t.hour, t.min, t.sec)
+      time = original_time.in_time_zone
+      e = DbType.find(:first)
+      e.sample_datetime = time
+      e.save!
+      e = DbType.find(:first)
+      assert_equal time, e.sample_datetime
+    end
+  end
+
+  def test_save_float
+    e = DbType.find(:first)
+    e.sample_float = 12.0
+    e.save!
+
+    e = DbType.find(:first)
+    assert_equal(12.0, e.sample_float)
+  end
+
+  def test_save_date
+    date = Date.new(2007)
+    e = DbType.find(:first)
+    e.sample_date = date
+    e.save!
+    e = DbType.find(:first)
+    if DbType.columns_hash["sample_date"].type == :datetime
+      # Oracle doesn't distinguish btw date/datetime
+      assert_equal date, e.sample_date.to_date
+    else
+      assert_equal date, e.sample_date
+    end
+  end
+
+  def test_boolean
+    # An unset boolean should default to nil
+    e = DbType.find(:first)
+    assert_equal(nil, e.sample_boolean)
+
+    e.sample_boolean = true
+    e.save!
+
+    e = DbType.find(:first)
+    assert_equal(true, e.sample_boolean)
+  end
+
+  def test_integer
+    # An unset boolean should default to nil
+    e = DbType.find(:first)
+    assert_equal(nil, e.sample_integer)
+
+    e.sample_integer = 10
+    e.save!
+
+    e = DbType.find(:first)
+    assert_equal(10, e.sample_integer)
+  end
+
+  def test_text
+    # An unset boolean should default to nil
+    e = DbType.find(:first)
+
+    # Oracle adapter initializes all CLOB fields with empty_clob() function,
+    # so they all have a initial value of an empty string ''
+    assert_equal(nil, e.sample_text) unless ActiveRecord::Base.connection.adapter_name =~ /oracle/i
+
+    e.sample_text = "ooop?"
+    e.save!
+
+    e = DbType.find(:first)
+    assert_equal("ooop?", e.sample_text)
+  end
+
+  def test_string
+    e = DbType.find(:first)
+
+    # An empty string is treated as a null value in Oracle: http://www.techonthenet.com/oracle/questions/empty_null.php
+    assert_equal('', e.sample_string) unless ActiveRecord::Base.connection.adapter_name =~ /oracle/i
+    e.sample_string = "ooop?"
+    e.save!
+
+    e = DbType.find(:first)
+    assert_equal("ooop?", e.sample_string)
+  end
+
+  def test_save_binary
+    #string is 60_000 bytes
+    binary_string = "\000ABCDEFGHIJKLMNOPQRSTUVWXYZ'\001\003"*1#2_000
+    e = DbType.find(:first)
+    e.sample_binary = binary_string
+    e.save!
+    e = DbType.find(:first)
+    assert_equal binary_string, e.sample_binary
+  end
+
+  def test_default_decimal_should_keep_fractional_part
+    expected = 7.3
+    db_type = DbType.new(:sample_small_decimal => expected)
+    assert db_type.save
+    db_type = DbType.find(db_type.id)
+    assert_equal BigDecimal.new(expected.to_s), db_type.sample_small_decimal
+  end
+
+  def test_decimal_with_scale
+    test_value = 7.3
+    db_type = DbType.new(:sample_small_decimal => test_value)
+    assert db_type.save
+    db_type = DbType.find(db_type.id)
+    assert_kind_of BigDecimal, db_type.sample_small_decimal
+    assert_equal BigDecimal.new(test_value.to_s), db_type.sample_small_decimal
+  end
+
+  def test_decimal_with_zero_scale
+    test_value = 7000.0
+    db_type = DbType.new(:sample_decimal => test_value)
+    assert db_type.save
+    db_type = DbType.find(db_type.id)
+    assert_kind_of Integer, db_type.sample_decimal
+    assert_equal test_value.to_i, db_type.sample_decimal
+  end
+
+  def test_negative_default_value
+    assert_equal(-1, DbType.columns_hash['sample_integer_neg_default'].default)
+    assert_equal(-1, DbType.new.sample_integer_neg_default)
+  end
+
+  def test_indexes
+    # Only test indexes if we have implemented it for the particular adapter
+    if @connection.respond_to?(:indexes)
+      indexes = @connection.indexes(:entries)
+      assert_equal(0, indexes.size)
+
+      index_name = "entries_index"
+      @connection.add_index(:entries, :updated_on, :name => index_name)
+
+      indexes = @connection.indexes(:entries)
+      assert_equal(1, indexes.size)
+      assert_equal "entries", indexes.first.table.to_s
+      assert_equal index_name, indexes.first.name
+      assert !indexes.first.unique
+      assert_equal ["updated_on"], indexes.first.columns
+    end
+  end
+
+  def test_remove_nonexistent_index
+    assert_raise(ArgumentError, ActiveRecord::StatementInvalid, ActiveRecord::JDBCError) do
+      @connection.remove_index :entries, :nonexistent_index
+    end
+  end
+
+  def test_add_index_with_invalid_name_length
+    index_name = 'x' * (@connection.index_name_length + 1)
+    assert_raise(ArgumentError) do
+      @connection.add_index "entries", "title", :name => index_name
+    end
+  end
+
+  def test_dumping_schema
+    require 'active_record/schema_dumper'
+    @connection.add_index :entries, :title
+    StringIO.open do |io|
+      ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, io)
+      assert_match(/add_index "entries",/, io.string)
+    end
+    @connection.remove_index :entries, :title
+
+  end
+
+  def test_nil_values
+    test = AutoId.create('value' => '')
+    assert_nil AutoId.find(test.id).value
+  end
+
+  # These should make no difference, but might due to the wacky regexp SQL rewriting we do.
+  def test_save_value_containing_sql
+    e = DbType.first
+    e.save
+
+    e.sample_string = e.sample_text = "\n\nselect from nothing where id = 'foo'"
+    e.save
+  end
+
+  def test_invalid
+    e = Entry.new(:title => @title, :content => @content, :rating => ' ')
+    assert e.valid?
+  end
+
+  def test_reconnect
+    assert_equal 1, Entry.count
+    @connection.reconnect!
+    assert_equal 1, Entry.count
+  end
+
+  if jruby?
+    def test_connection_valid
+      assert_raises(ActiveRecord::JDBCError) do
+        @connection.raw_connection.with_connection_retry_guard do |c|
+          begin
+            stmt = c.createStatement
+            stmt.execute "bogus sql"
+          ensure
+            stmt.close rescue nil
+          end
+        end
+      end
+    end
+
+    class Animal < ActiveRecord::Base; end
+
+    def test_fetching_columns_for_nonexistent_table_should_raise
+      assert_raises(ActiveRecord::ActiveRecordError,
+                    ActiveRecord::StatementInvalid, ActiveRecord::JDBCError) do
+        Animal.columns
+      end
+    end
+  end
+
+  def test_disconnect
+    assert_equal 1, Entry.count
+    ActiveRecord::Base.clear_active_connections!
+    ActiveRecord::Base.connection_pool.disconnect! if ActiveRecord::Base.respond_to?(:connection_pool)
+    assert !ActiveRecord::Base.connected?
+    assert_equal 1, Entry.count
+    assert ActiveRecord::Base.connected?
+  end
+
+  def test_add_not_null_column_to_table
+    AddNotNullColumnToTable.up
+    AddNotNullColumnToTable.down
+  end
+
+  def test_add_null_column_with_default
+    Entry.connection.add_column :entries, :color, :string, :null => false, :default => "blue"
+    created_columns = Entry.connection.columns('entries')
+
+    color = created_columns.detect { |c| c.name == 'color' }
+    assert !color.null
+  end
+
+  def test_add_null_column_with_no_default
+    # You must specify a default value with most databases
+    if ActiveRecord::Base.connection.adapter_name =~ /mysql/i
+      Entry.connection.add_column :entries, :color, :string, :null => false
+      created_columns = Entry.connection.columns('entries')
+
+      color = created_columns.detect { |c| c.name == 'color' }
+      assert !color.null
+    end
+  end
+
+  def test_add_null_column_with_nil_default
+    # You must specify a default value with most databases
+    if ActiveRecord::Base.connection.adapter_name =~ /mysql/i
+      Entry.connection.add_column :entries, :color, :string, :null => false, :default => nil
+      created_columns = Entry.connection.columns('entries')
+
+      color = created_columns.detect { |c| c.name == 'color' }
+      assert !color.null
+    end
+  end
+
+  def test_validates_uniqueness_of_strings_case_sensitive
+    name_lower = ValidatesUniquenessOfString.new(:cs_string => "name", :ci_string => '1')
+    name_lower.save!
+
+    name_upper = ValidatesUniquenessOfString.new(:cs_string => "NAME", :ci_string => '2')
+    assert_nothing_raised do
+      name_upper.save!
+    end
+
+    name_lower_collision = ValidatesUniquenessOfString.new(:cs_string => "name", :ci_string => '3')
+    assert_raise ActiveRecord::RecordInvalid do
+      name_lower_collision.save!
+    end
+
+    name_upper_collision = ValidatesUniquenessOfString.new(:cs_string => "NAME", :ci_string => '4')
+    assert_raise ActiveRecord::RecordInvalid do
+      name_upper_collision.save!
+    end
+  end
+
+  def test_validates_uniqueness_of_strings_case_insensitive
+    name_lower = ValidatesUniquenessOfString.new(:cs_string => '1', :ci_string => "name")
+    name_lower.save!
+
+    name_upper = ValidatesUniquenessOfString.new(:cs_string => '2', :ci_string => "NAME")
+    assert_raise ActiveRecord::RecordInvalid do
+      name_upper.save!
+    end
+
+    name_lower_collision = ValidatesUniquenessOfString.new(:cs_string => '3', :ci_string => "name")
+    assert_raise ActiveRecord::RecordInvalid do
+      name_lower_collision.save!
+    end
+
+    alternate_name_upper = ValidatesUniquenessOfString.new(:cs_string => '4', :ci_string => "ALTERNATE_NAME")
+    assert_nothing_raised do
+      alternate_name_upper.save!
+    end
+
+    alternate_name_upper_collision = ValidatesUniquenessOfString.new(:cs_string => '5', :ci_string => "ALTERNATE_NAME")
+    assert_raise ActiveRecord::RecordInvalid do
+      alternate_name_upper_collision.save!
+    end
+
+    alternate_name_lower = ValidatesUniquenessOfString.new(:cs_string => '6', :ci_string => "alternate_name")
+    assert_raise ActiveRecord::RecordInvalid do
+      alternate_name_lower.save!
+    end
+  end
+
+  class ChangeEntriesTable < ActiveRecord::Migration
+    def self.up
+      change_table :entries do |t|
+        t.string :author
+      end if respond_to?(:change_table)
+    end
+    def self.down
+      change_table :entries do |t|
+        t.remove :author
+      end if respond_to?(:change_table)
+    end
+  end
+  def test_change_table
+    ChangeEntriesTable.up
+    ChangeEntriesTable.down
+  end
+
+  def test_string_id
+    f = StringId.new
+    f.id = "some_string"
+    f.save
+    f = StringId.first #reload is essential
+    assert_equal "some_string", f.id
+  end
+
+  def test_model_with_no_id
+    assert_nothing_raised do
+      Thing.create! :name => "a thing"
+    end
+    assert_equal 1, Thing.find(:all).size
+  end
+end
+
+module MultibyteTestMethods
+  include MigrationSetup
+
+  if defined?(JRUBY_VERSION)
+    def setup
+      super
+      config = ActiveRecord::Base.connection.config
+      @jdbc_driver = ActiveRecord::ConnectionAdapters::JdbcDriver.new(config[:driver])
+      @java_con = @jdbc_driver.connection(config[:url], config[:username], config[:password])
+      @java_con.setAutoCommit(true)
+    end
+
+    def teardown
+      @java_con.close
+      @jdbc_driver = nil
+      super
+    end
+
+    def test_select_multibyte_string
+      @java_con.createStatement().execute("insert into entries (id, title, content) values (1, 'テスト', '本文')")
+      entry = Entry.find(:first)
+      assert_equal "テスト", entry.title
+      assert_equal "本文", entry.content
+      assert_equal entry, Entry.find_by_title("テスト")
+    end
+
+    def test_update_multibyte_string
+      Entry.create!(:title => "テスト", :content => "本文")
+      rs = @java_con.createStatement().executeQuery("select title, content from entries")
+      assert rs.next
+      assert_equal "テスト", rs.getString(1)
+      assert_equal "本文", rs.getString(2)
+    end
+  end
+
+  def test_multibyte_aliasing
+    str = "テスト"
+    quoted_alias = Entry.connection.quote_column_name(str)
+    sql = "SELECT title AS #{quoted_alias} from entries"
+    records = Entry.connection.select_all(sql)
+    records.each do |rec|
+      rec.keys.each do |key|
+        assert_equal str, key
+      end
+    end
+  end
+
+  def test_chinese_word
+    chinese_word = '中文'
+    new_entry = Entry.create(:title => chinese_word)
+    new_entry.reload
+    assert_equal chinese_word, new_entry.title
+  end
+end
+
+module NonUTF8EncodingMethods
+  def setup
+    @connection = ActiveRecord::Base.remove_connection
+    latin2_connection = @connection.dup
+    latin2_connection[:encoding] = 'latin2'
+    latin2_connection.delete(:url) # pre-gen url gets stashed; remove to re-gen
+    ActiveRecord::Base.establish_connection latin2_connection
+    CreateEntries.up
+  end
+
+  def teardown
+    CreateEntries.down
+    ActiveRecord::Base.establish_connection @connection
+  end
+
+  def test_nonutf8_encoding_in_entry
+    prague_district = 'hradčany'
+    new_entry = Entry.create :title => prague_district
+    new_entry.reload
+    assert_equal prague_district, new_entry.title
+  end
+end
+
+module ActiveRecord3TestMethods
+  def self.included(base)
+    base.send :include, Tests if ActiveRecord::VERSION::MAJOR == 3
+  end
+
+  module Tests
+    def test_where
+      entries = Entry.where(:title => @entry.title)
+      assert_equal @entry, entries.first
+    end
+  end
+end