activerecord-jdbc-adapter-onsite 1.2.2

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/row_locking.rb

@@ -0,0 +1,90 @@
+#! /usr/bin/env jruby
+
+require 'thread'
+
+module RowLockingTestMethods
+
+  def test_row_locking
+    row_locking_test_template
+  end
+
+  def test_row_locking_with_limit
+    row_locking_test_template(:limit => 1)
+  end
+
+  private
+
+    def row_locking_test_template(options={})
+      # Create two rows that we will work with
+      @row1_id = Entry.create!(:title => "row1").id
+      @row2_id = Entry.create!(:title => "row2").id
+
+      @result_queue = Queue.new
+      signal_queue = Queue.new
+      t1 = Thread.new { thread_helper { thread1_main(signal_queue, options) } }
+      t2 = Thread.new { thread_helper { thread2_main(signal_queue, options) } }
+      t1.join
+      t2.join
+
+      result = []
+      result << @result_queue.shift until @result_queue.empty?    # Convert the queue into an array
+
+      expected = [
+        :t1_locking_row2,
+        :t1_locked_row2,
+
+        :t2_locking_row1,
+        :t2_locked_row1,
+
+        :t2_locking_row2,     # thread 2 tries to lock row2 ...
+        :t1_committed,
+        :t2_locked_row2,      # ... but it doesn't succeed until after thread 1 commits its transaction
+
+        :t2_committed,
+      ]
+
+      assert_equal expected, result, "thread2 should lock row1 immediately but wait for thread1 to commit before getting the lock on row2"
+    end
+
+    def thread1_main(signal_queue, options={})
+      Entry.transaction do
+        @result_queue << :t1_locking_row2
+        Entry.find(@row2_id, {:lock=>true}.merge(options))   # acquire a row lock on r2
+        @result_queue << :t1_locked_row2
+        signal_queue << :go               # signal thread2 to start
+        sleep 2.0                         # Wait for a few seconds, to allow the other thread to race with this thread.
+        @result_queue << :t1_committed
+      end
+    end
+
+    def thread2_main(signal_queue, options={})
+      Entry.transaction do
+        signal_queue.shift   # wait until we get the signal from thread1
+        @result_queue << :t2_locking_row1
+        Entry.find(@row1_id, {:lock=>true}.merge(options))   # should return immediately
+        @result_queue << :t2_locked_row1
+        @result_queue << :t2_locking_row2
+        Entry.find(@row2_id, {:lock=>true}.merge(options))   # should block until thread1 commits its transaction
+        @result_queue << :t2_locked_row2
+        @result_queue << :t2_committed
+      end
+    end
+
+    def thread_helper
+      yield
+    rescue Exception => exc
+      # Output backtrace, since otherwise we won't see anything until the main thread joins this thread.
+      display_exception(exc)
+      raise
+    ensure
+      # This is needed.  Otherwise, the database connections aren't returned to the pool and things break.
+      ActiveRecord::Base.connection_handler.clear_active_connections!
+    end
+
+    def display_exception(exception)
+      lines = []
+      lines << "#{exception.class.name}: #{exception.message}\n"
+      lines += exception.backtrace.map{|line| "\tfrom #{line}"}
+      $stderr.puts lines.join("\n")
+    end
+end

data/test/simple.rb

@@ -0,0 +1,731 @@
+# -*- 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
+    CreateCustomPkName.up
+    @connection = ActiveRecord::Base.connection
+  end
+
+  def teardown
+    DbTypeMigration.down
+    CreateStringIds.down
+    CreateEntries.down
+    CreateUsers.down
+    CreateAutoIds.down
+    CreateValidatesUniquenessOf.down
+    CreateThings.down
+    CreateCustomPkName.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
+
+      # Ensure we get the id even if the PK column is not named 'id'
+      1.upto(4) do |i|
+        cpn_name = "return id test#{i}"
+        cpn = CustomPkName.new
+        cpn.name = cpn_name
+        cpn.save
+        value = cpn.custom_id
+        assert !value.nil?
+        cpn = CustomPkName.find_by_name(cpn_name)
+        assert_equal cpn.custom_id, value
+      end
+    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
+    if ActiveRecord::VERSION::MINOR == 2
+      def test_visitor_accessor
+        adapter = Entry.connection
+        expected_visitors = adapter.config[:adapter_spec].
+          arel2_visitors(adapter).values
+        assert !adapter.visitor.nil?
+        assert expected_visitors.include?(adapter.visitor.class)
+      end
+    end
+
+    def test_where
+      entries = Entry.where(:title => @entry.title)
+      assert_equal @entry, entries.first
+    end
+  end
+end
+
+module ResetColumnInformationTestMethods
+  class Fhqwhgad < ActiveRecord::Base
+  end
+
+  def test_reset_column_information
+    drop_fhqwhgads_table!
+    create_fhqwhgads_table_1!
+    Fhqwhgad.reset_column_information
+    assert_equal ["id", "come_on"].sort, Fhqwhgad.columns.map{|c| c.name}.sort, "columns should be correct the first time"
+
+    drop_fhqwhgads_table!
+    create_fhqwhgads_table_2!
+    Fhqwhgad.reset_column_information
+    assert_equal ["id", "to_the_limit"].sort, Fhqwhgad.columns.map{|c| c.name}.sort, "columns should be correct the second time"
+  ensure
+    drop_fhqwhgads_table!
+  end
+
+  private
+
+    def drop_fhqwhgads_table!
+      ActiveRecord::Schema.define do
+        suppress_messages do
+          drop_table :fhqwhgads if table_exists? :fhqwhgads
+        end
+      end
+    end
+
+    def create_fhqwhgads_table_1!
+      ActiveRecord::Schema.define do
+        suppress_messages do
+          create_table :fhqwhgads do |t|
+            t.string :come_on
+          end
+        end
+      end
+    end
+
+    def create_fhqwhgads_table_2!
+      ActiveRecord::Schema.define do
+        suppress_messages do
+          create_table :fhqwhgads do |t|
+            t.string :to_the_limit, :null=>false, :default=>'everybody'
+          end
+        end
+      end
+    end
+end