c3-activerecord-jdbc-adapter 1.1.3

data/test/postgres_mixed_case_test.rb

@@ -0,0 +1,29 @@
+require 'jdbc_common'
+require 'models/entry'
+require 'models/mixed_case'
+
+class MixedCaseTest < Test::Unit::TestCase
+  def setup
+    Migration::MixedCase.up
+    @table_name = User.table_name
+    User.table_name = 'tblUsers'
+    User.reset_column_information
+  end
+
+  def teardown
+    User.table_name = @table_name
+    User.reset_column_information
+    Migration::MixedCase.down
+  end
+
+  def test_create
+    mixed_case = MixedCase.create :SOME_value => 'some value'
+    assert_equal 'some value', mixed_case.SOME_value
+  end
+
+  def test_find_mixed_table_name
+    User.create :firstName => "Nick", :lastName => "Sieger"
+    u = User.find :first
+    assert_equal "Nick Sieger", "#{u.firstName} #{u.lastName}"
+  end
+end

data/test/postgres_native_type_mapping_test.rb

@@ -0,0 +1,84 @@
+require 'jdbc_common'
+require 'db/postgres'
+
+class CreateNativeTypeMappingTestSchema < ActiveRecord::Migration
+  def self.up
+    execute "DROP SEQUENCE IF EXISTS seq_pk_customers"
+    execute "CREATE SEQUENCE seq_pk_customers"
+    execute %q{
+      CREATE TABLE customers (
+          bigint_serial_should_be_integer bigint default nextval('seq_pk_customers'),
+          integer_serial_should_be_integer integer default nextval('seq_pk_customers'),
+          varchar_should_be_string varchar(2),
+          timestamp_should_be_datetime timestamp,
+          bytea_should_be_binary bytea,
+          double_precision_should_be_float double precision,
+          real_should_be_float real,
+          bool_should_be_boolean bool,
+          interval_should_be_string interval,
+          bigint_should_be_integer bigint
+      )}
+  end
+
+  def self.down
+    execute "DROP TABLE customers"
+    execute "DROP SEQUENCE IF EXISTS seq_pk_customers"
+  end
+end
+
+class Customer < ActiveRecord::Base
+end
+
+class PostgresNativeTypeMappingTest < Test::Unit::TestCase
+  def setup
+    CreateNativeTypeMappingTestSchema.up
+  end
+
+  def teardown
+    CreateNativeTypeMappingTestSchema.down
+  end
+
+  def column_type(column_name)
+    Customer.columns.detect { |c| c.name == column_name }.type
+  end
+
+  def test_bigint_serial_should_be_mapped_to_integer
+    assert_equal :integer, column_type("bigint_serial_should_be_integer")
+  end
+
+  def test_integer_serial_should_be_mapped_to_integer
+    assert_equal :integer, column_type("integer_serial_should_be_integer")
+  end
+
+  def test_varchar_should_be_mapped_to_string
+    assert_equal :string, column_type("varchar_should_be_string")
+  end
+
+  def test_timestamp_should_be_mapped_to_datetime
+    assert_equal :datetime, column_type("timestamp_should_be_datetime")
+  end
+
+  def test_bytea_should_be_mapped_to_binary
+    assert_equal :binary, column_type("bytea_should_be_binary")
+  end
+
+  def test_double_precision_should_be_mapped_to_float
+    assert_equal :float, column_type("double_precision_should_be_float")
+  end
+
+  def test_real_should_be_mapped_to_float
+    assert_equal :float, column_type("real_should_be_float")
+  end
+
+  def test_bool_should_be_mapped_to_boolean
+    assert_equal :boolean, column_type("bool_should_be_boolean")
+  end
+
+  def test_interval_should_be_mapped_to_string
+    assert_equal :string, column_type("interval_should_be_string")
+  end
+
+  def test_bigint_should_be_mapped_to_integer
+    assert_equal :integer, column_type("bigint_should_be_integer")
+  end
+end

data/test/postgres_nonseq_pkey_test.rb

@@ -0,0 +1,38 @@
+require 'jdbc_common'
+require 'db/postgres'
+
+class CreateUrls < ActiveRecord::Migration
+  def self.up
+    create_table 'urls', :id => false do |t|
+      t.text :uhash, :null => false
+      t.text :url,  :null => false
+    end
+    execute "ALTER TABLE urls ADD PRIMARY KEY (uhash)"
+  end
+  def self.down
+    drop_table 'urls'
+  end
+end
+
+class Url < ActiveRecord::Base
+  set_primary_key :uhash
+  #Shouldn't be needed: set_sequence_name nil
+end
+
+class PostgresNonSeqPKey < Test::Unit::TestCase
+  def setup
+    CreateUrls.up
+  end
+
+  def teardown
+    CreateUrls.down
+  end
+
+  def test_create
+    url = Url.create! do |u|
+      u.uhash = 'uhash'
+      u.url = 'http://url'
+    end
+    assert_equal( 'uhash', url.uhash )
+  end
+end

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,90 @@
+# 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
+
+  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
+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.grep(/boolean/)
+    assert !lines.empty?
+    lines.each {|line| assert line !~ /limit/ }
+  end
+
+
+  def test_schema_dump_should_not_have_limits_on_binaries
+    lines = @dump.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.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.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.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.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/simple.rb

@@ -0,0 +1,557 @@
+# -*- 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
+
+    @connection = ActiveRecord::Base.connection
+  end
+
+  def teardown
+    DbTypeMigration.down
+    CreateStringIds.down
+    CreateEntries.down
+    CreateUsers.down
+    CreateAutoIds.down
+    CreateValidatesUniquenessOf.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 SimpleTestMethods
+  include FixtureSetup
+
+  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
+    actual = DbType.create(:sample_default_decimal => expected).sample_default_decimal
+    assert_equal expected, actual
+  end
+
+  def test_negative_default_value
+    assert_equal -1, DbType.columns_hash['sample_integer_negative_default'].default
+    assert_equal -1, DbType.new.sample_integer_negative_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_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
+
+    # ENEBO: Is this really ar-jdbc-specific or a bug in our adapter?
+    def test_fetching_columns_for_nonexistent_table_should_raise
+      assert_raises(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
+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