activerecord 1.13.2 → 1.14.0

data/test/migration_test.rb

@@ -6,10 +6,22 @@ require File.dirname(__FILE__) + '/fixtures/migrations/2_we_need_reminders'
 if ActiveRecord::Base.connection.supports_migrations? 
   class Reminder < ActiveRecord::Base; end
 
+  class ActiveRecord::Migration
+    class <<self
+      attr_accessor :message_count
+      def puts(text="")
+        self.message_count ||= 0
+        self.message_count += 1
+      end
+    end
+  end
+
   class MigrationTest < Test::Unit::TestCase
     self.use_transactional_fixtures = false
 
     def setup
+      ActiveRecord::Migration.verbose = true
+      PeopleHaveLastNames.message_count = 0
     end
 
     def teardown
@@ -31,7 +43,7 @@ if ActiveRecord::Base.connection.supports_migrations?
       Person.connection.remove_column("people", "administrator") rescue nil
       Person.reset_column_information
     end
-    
+
     def test_add_index
       Person.connection.add_column "people", "last_name", :string        
       Person.connection.add_column "people", "administrator", :boolean
@@ -42,8 +54,11 @@ if ActiveRecord::Base.connection.supports_migrations?
       assert_nothing_raised { Person.connection.add_index("people", ["last_name", "first_name"]) }
       assert_nothing_raised { Person.connection.remove_index("people", "last_name") }
 
-      assert_nothing_raised { Person.connection.add_index("people", %w(last_name first_name administrator), :name => "named_admin") }
-      assert_nothing_raised { Person.connection.remove_index("people", :name => "named_admin") }
+      # Sybase adapter does not support indexes on :boolean columns
+      unless current_adapter?(:SybaseAdapter)
+        assert_nothing_raised { Person.connection.add_index("people", %w(last_name first_name administrator), :name => "named_admin") }
+        assert_nothing_raised { Person.connection.remove_index("people", :name => "named_admin") }
+      end
     end
 
     def test_create_table_adds_id
@@ -84,7 +99,7 @@ if ActiveRecord::Base.connection.supports_migrations?
       four = columns.detect { |c| c.name == "four" }
 
       assert_equal "hello", one.default
-      if current_adapter?(:OCIAdapter)
+      if current_adapter?(:OracleAdapter)
         # Oracle doesn't support native booleans
         assert_equal true, two.default == 1
         assert_equal false, three.default != 0
@@ -98,10 +113,10 @@ if ActiveRecord::Base.connection.supports_migrations?
       Person.connection.drop_table :testings rescue nil
     end
   
-    # SQL Server will not allow you to add a NOT NULL column
+    # SQL Server and Sybase will not allow you to add a NOT NULL column
     # to a table without specifying a default value, so the
     # following test must be skipped  
-    unless current_adapter?(:SQLServerAdapter)
+    unless current_adapter?(:SQLServerAdapter) || current_adapter?(:SybaseAdapter)
       def test_add_column_not_null_without_default
         Person.connection.create_table :testings do |t|
           t.column :foo, :string
@@ -153,8 +168,8 @@ if ActiveRecord::Base.connection.supports_migrations?
       assert_equal Fixnum, bob.age.class
       assert_equal Time, bob.birthday.class
 
-      if current_adapter?(:SQLServerAdapter) or current_adapter?(:OCIAdapter)
-        # SQL Server and Oracle don't differentiate between date/time
+      if current_adapter?(:SQLServerAdapter) || current_adapter?(:OracleAdapter) || current_adapter?(:SybaseAdapter)
+        # SQL Server, Sybase, and Oracle don't differentiate between date/time
         assert_equal Time, bob.favorite_day.class
       else
         assert_equal Date, bob.favorite_day.class
@@ -241,7 +256,7 @@ if ActiveRecord::Base.connection.supports_migrations?
         ActiveRecord::Base.connection.rename_table :octopuses, :octopi
 
         assert_nothing_raised do
-          if current_adapter?(:OCIAdapter)
+          if current_adapter?(:OracleAdapter)
             # Oracle requires the explicit sequence for the pk
             ActiveRecord::Base.connection.execute "INSERT INTO octopi (id, url) VALUES (octopi_seq.nextval, 'http://www.foreverflying.com/octopus-black7.jpg')"
           else
@@ -258,8 +273,15 @@ if ActiveRecord::Base.connection.supports_migrations?
     end
 
     def test_change_column
-      Person.connection.add_column "people", "bio", :string
-      assert_nothing_raised { Person.connection.change_column "people", "bio", :text }
+      Person.connection.add_column 'people', 'age', :integer
+      old_columns = Person.connection.columns(Person.table_name, "#{name} Columns")
+      assert old_columns.find { |c| c.name == 'age' and c.type == :integer }
+
+      assert_nothing_raised { Person.connection.change_column "people", "age", :string }
+      
+      new_columns = Person.connection.columns(Person.table_name, "#{name} Columns")
+      assert_nil new_columns.find { |c| c.name == 'age' and c.type == :integer }
+      assert new_columns.find { |c| c.name == 'age' and c.type == :string }
     end    
 
     def test_change_column_with_new_default
@@ -338,6 +360,24 @@ if ActiveRecord::Base.connection.supports_migrations?
       assert !Reminder.table_exists?
     end
     
+    def test_migrator_verbosity
+      ActiveRecord::Migrator.up(File.dirname(__FILE__) + '/fixtures/migrations/', 1)
+      assert PeopleHaveLastNames.message_count > 0
+      PeopleHaveLastNames.message_count = 0
+
+      ActiveRecord::Migrator.down(File.dirname(__FILE__) + '/fixtures/migrations/', 0)
+      assert PeopleHaveLastNames.message_count > 0
+      PeopleHaveLastNames.message_count = 0
+    end
+    
+    def test_migrator_verbosity_off
+      PeopleHaveLastNames.verbose = false
+      ActiveRecord::Migrator.up(File.dirname(__FILE__) + '/fixtures/migrations/', 1)
+      assert PeopleHaveLastNames.message_count.zero?
+      ActiveRecord::Migrator.down(File.dirname(__FILE__) + '/fixtures/migrations/', 0)
+      assert PeopleHaveLastNames.message_count.zero?
+    end
+    
     def test_migrator_going_down_due_to_version_target
       ActiveRecord::Migrator.up(File.dirname(__FILE__) + '/fixtures/migrations/', 1)
       ActiveRecord::Migrator.migrate(File.dirname(__FILE__) + '/fixtures/migrations/', 0)
@@ -415,6 +455,23 @@ if ActiveRecord::Base.connection.supports_migrations?
       Reminder.reset_sequence_name
     end
 
+    def test_create_table_with_binary_column
+      Person.connection.drop_table :binary_testings rescue nil
+    
+      assert_nothing_raised {
+        Person.connection.create_table :binary_testings do |t|
+          t.column "data", :binary, :default => "", :null => false
+        end
+      }
+      
+      columns = Person.connection.columns(:binary_testings)
+      data_column = columns.detect { |c| c.name == "data" }
+      
+      assert_equal "", data_column.default
+      
+      Person.connection.drop_table :binary_testings rescue nil
+    end
+
     def test_migrator_with_duplicates
       assert_raises(ActiveRecord::DuplicateMigrationVersionError) do
         ActiveRecord::Migrator.migrate(File.dirname(__FILE__) + '/fixtures/migrations_with_duplicate/', nil)

data/test/mixin_nested_set_test.rb

@@ -9,7 +9,7 @@ class MixinNestedSetTest < Test::Unit::TestCase
 	def test_mixing_in_methods
 	  ns = NestedSet.new
 		assert( ns.respond_to?( :all_children ) )
-		assert_equal( ns.scope_condition, "ROOT_ID IS NULL" )
+		assert_equal( ns.scope_condition, "root_id IS NULL" )
 		
 		check_method_mixins ns
 	end

data/test/modules_test.rb

@@ -18,6 +18,11 @@ class ModulesTest < Test::Unit::TestCase
   end
   
   def test_associations_spanning_cross_modules
-    assert MyApplication::Billing::Account.find(1).has_firm?, "37signals account should be able to backtrack"
+    account = MyApplication::Billing::Account.find(:first, :order => 'id')
+    assert_kind_of MyApplication::Business::Firm, account.firm
+    assert_kind_of MyApplication::Billing::Firm, account.qualified_billing_firm
+    assert_kind_of MyApplication::Billing::Firm, account.unqualified_billing_firm
+    assert_kind_of MyApplication::Billing::Nested::Firm, account.nested_qualified_billing_firm
+    assert_kind_of MyApplication::Billing::Nested::Firm, account.nested_unqualified_billing_firm
   end
 end

data/test/readonly_test.rb

@@ -79,7 +79,7 @@ class ReadOnlyTest < Test::Unit::TestCase
 
     # Oracle barfs on this because the join includes unqualified and
     # conflicting column names
-    unless current_adapter?(:OCIAdapter)
+    unless current_adapter?(:OracleAdapter)
       Post.with_scope(:find => { :joins => ', developers' }) do 
         assert Post.find(1).readonly?
         assert Post.find(1, :readonly => true).readonly?

data/test/reflection_test.rb

@@ -3,14 +3,21 @@ require 'fixtures/topic'
 require 'fixtures/customer'
 require 'fixtures/company'
 require 'fixtures/company_in_module'
+require 'fixtures/subscriber'
 
 class ReflectionTest < Test::Unit::TestCase
-  fixtures :topics, :customers, :companies
+  fixtures :topics, :customers, :companies, :subscribers
 
   def setup
     @first = Topic.find(1)
   end
 
+  def test_column_null_not_null
+    subscriber = Subscriber.find(:first)
+    assert subscriber.column_for_attribute("name").null
+    assert !subscriber.column_for_attribute("nick").null
+  end
+
   def test_read_attribute_names
     assert_equal(
       %w( id title author_name author_email_address bonus_time written_on last_read content approved replies_count parent_id type ).sort,
@@ -60,10 +67,9 @@ class ReflectionTest < Test::Unit::TestCase
       :composed_of, :gps_location, { }, Customer
     )
 
-    assert_equal(
-      [ reflection_for_address, reflection_for_balance, reflection_for_gps_location ],
-      Customer.reflect_on_all_aggregations
-    )
+    assert Customer.reflect_on_all_aggregations.include?(reflection_for_gps_location)
+    assert Customer.reflect_on_all_aggregations.include?(reflection_for_balance)
+    assert Customer.reflect_on_all_aggregations.include?(reflection_for_address)
 
     assert_equal reflection_for_address, Customer.reflect_on_aggregation(:address)
 
@@ -71,7 +77,7 @@ class ReflectionTest < Test::Unit::TestCase
   end
 
   def test_has_many_reflection
-    reflection_for_clients = ActiveRecord::Reflection::AssociationReflection.new(:has_many, :clients, { :order => "id", :dependent => true }, Firm)
+    reflection_for_clients = ActiveRecord::Reflection::AssociationReflection.new(:has_many, :clients, { :order => "id", :dependent => :destroy }, Firm)
 
     assert_equal reflection_for_clients, Firm.reflect_on_association(:clients)
 
@@ -83,7 +89,7 @@ class ReflectionTest < Test::Unit::TestCase
   end
 
   def test_has_one_reflection
-    reflection_for_account = ActiveRecord::Reflection::AssociationReflection.new(:has_one, :account, { :foreign_key => "firm_id", :dependent => true }, Firm)
+    reflection_for_account = ActiveRecord::Reflection::AssociationReflection.new(:has_one, :account, { :foreign_key => "firm_id", :dependent => :destroy }, Firm)
     assert_equal reflection_for_account, Firm.reflect_on_association(:account)
 
     assert_equal Account, Firm.reflect_on_association(:account).klass
@@ -91,7 +97,55 @@ class ReflectionTest < Test::Unit::TestCase
   end
 
   def test_association_reflection_in_modules
-    assert_equal MyApplication::Business::Client, MyApplication::Business::Firm.reflect_on_association(:clients_of_firm).klass
-    assert_equal MyApplication::Business::Firm, MyApplication::Billing::Account.reflect_on_association(:firm).klass
+    assert_reflection MyApplication::Business::Firm,
+      :clients_of_firm,
+      :klass      => MyApplication::Business::Client,
+      :class_name => 'Client',
+      :table_name => 'companies'
+
+    assert_reflection MyApplication::Billing::Account,
+      :firm,
+      :klass      => MyApplication::Business::Firm,
+      :class_name => 'MyApplication::Business::Firm',
+      :table_name => 'companies'
+
+    assert_reflection MyApplication::Billing::Account,
+      :qualified_billing_firm,
+      :klass      => MyApplication::Billing::Firm,
+      :class_name => 'MyApplication::Billing::Firm',
+      :table_name => 'companies'
+
+    assert_reflection MyApplication::Billing::Account,
+      :unqualified_billing_firm,
+      :klass      => MyApplication::Billing::Firm,
+      :class_name => 'Firm',
+      :table_name => 'companies'
+
+    assert_reflection MyApplication::Billing::Account,
+      :nested_qualified_billing_firm,
+      :klass      => MyApplication::Billing::Nested::Firm,
+      :class_name => 'MyApplication::Billing::Nested::Firm',
+      :table_name => 'companies'
+
+    assert_reflection MyApplication::Billing::Account,
+      :nested_unqualified_billing_firm,
+      :klass      => MyApplication::Billing::Nested::Firm,
+      :class_name => 'Nested::Firm',
+      :table_name => 'companies'
+  end
+  
+  def test_reflection_of_all_associations
+    assert_equal 13, Firm.reflect_on_all_associations.size
+    assert_equal 11, Firm.reflect_on_all_associations(:has_many).size
+    assert_equal 2, Firm.reflect_on_all_associations(:has_one).size
+    assert_equal 0, Firm.reflect_on_all_associations(:belongs_to).size
   end
+
+  private
+    def assert_reflection(klass, association, options)
+      assert reflection = klass.reflect_on_association(association)
+      options.each do |method, value|
+        assert_equal(value, reflection.send(method))
+      end
+    end
 end

data/test/schema_dumper_test.rb

@@ -14,6 +14,47 @@ if ActiveRecord::Base.connection.respond_to?(:tables)
       assert_match %r{create_table "authors"}, output
       assert_no_match %r{create_table "schema_info"}, output
     end
+    
+    def test_schema_dump_includes_not_null_columns
+      stream = StringIO.new
+      
+      ActiveRecord::SchemaDumper.ignore_tables = [/^[^s]/]
+      ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+      output = stream.string
+      assert_match %r{:null => false}, output
+    end
+
+    def test_schema_dump_with_string_ignored_table
+      stream = StringIO.new
+      
+      ActiveRecord::SchemaDumper.ignore_tables = ['accounts']      
+      ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+      output = stream.string
+      assert_no_match %r{create_table "accounts"}, output
+      assert_match %r{create_table "authors"}, output
+      assert_no_match %r{create_table "schema_info"}, output
+    end
+
+
+    def test_schema_dump_with_regexp_ignored_table
+      stream = StringIO.new
+      
+      ActiveRecord::SchemaDumper.ignore_tables = [/^account/]      
+      ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+      output = stream.string
+      assert_no_match %r{create_table "accounts"}, output
+      assert_match %r{create_table "authors"}, output
+      assert_no_match %r{create_table "schema_info"}, output
+    end
+
+
+    def test_schema_dump_illegal_ignored_table_value
+      stream = StringIO.new      
+      ActiveRecord::SchemaDumper.ignore_tables = [5]      
+      assert_raise(StandardError) do
+        ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+      end
+    end
   end
 
 end

data/test/{synonym_test_oci.rb → synonym_test_oracle.rb}

@@ -10,7 +10,7 @@ class TestOracleSynonym < Test::Unit::TestCase
 
   def test_oracle_synonym
     topic = Topic.new
-	subject = Subject.new
+    subject = Subject.new
     assert_equal(topic.attributes, subject.attributes)
   end
   

data/test/threaded_connections_test.rb

@@ -9,6 +9,16 @@ class ThreadedConnectionsTest < Test::Unit::TestCase
   def setup
     @connection = ActiveRecord::Base.remove_connection
     @connections = []
+    @allow_concurrency = ActiveRecord::Base.allow_concurrency
+  end
+  
+  def teardown
+    # clear the connection cache
+    ActiveRecord::Base.send(:clear_all_cached_connections!)
+    # set allow_concurrency to saved value
+    ActiveRecord::Base.allow_concurrency = @allow_concurrency
+    # reestablish old connection
+    ActiveRecord::Base.establish_connection(@connection)
   end
   
   def gather_connections(use_threaded_connections)

data/test/unconnected_test.rb

@@ -7,19 +7,26 @@ class TestUnconnectedAdaptor < Test::Unit::TestCase
   self.use_transactional_fixtures = false
 
   def setup
-    @connection = ActiveRecord::Base.remove_connection
+    @underlying = ActiveRecord::Base.connection
+    @specification = ActiveRecord::Base.remove_connection
   end
 
   def teardown
-    ActiveRecord::Base.establish_connection(@connection)
+    @underlying = nil
+    ActiveRecord::Base.establish_connection(@specification)
   end
 
-  def test_unconnected
+  def test_connection_no_longer_established
     assert_raise(ActiveRecord::ConnectionNotEstablished) do
-      TestRecord.find(1)   
+      TestRecord.find(1)
     end
+
     assert_raise(ActiveRecord::ConnectionNotEstablished) do
-      TestRecord.new.save   
+      TestRecord.new.save
     end
   end
+
+  def test_underlying_adapter_no_longer_active
+    assert !@underlying.active?, "Removed adapter should no longer be active"
+  end
 end

data/test/validations_test.rb

@@ -156,11 +156,11 @@ class ValidationsTest < Test::Unit::TestCase
   def test_errors_on_boundary_breaking
     developer = Developer.new("name" => "xs")
     assert !developer.save
-    assert_equal "is too short (min is 3 characters)", developer.errors.on("name")
+    assert_equal "is too short (minimum is 3 characters)", developer.errors.on("name")
 
     developer.name = "All too very long for this boundary, it really is"
     assert !developer.save
-    assert_equal "is too long (max is 20 characters)", developer.errors.on("name")
+    assert_equal "is too long (maximum is 20 characters)", developer.errors.on("name")
 
     developer.name = "Just right"
     assert developer.save
@@ -280,6 +280,30 @@ class ValidationsTest < Test::Unit::TestCase
     assert r3.valid?, "Saving r3"
   end
 
+  def test_validate_uniqueness_with_scope_array
+    Reply.validates_uniqueness_of(:author_name, :scope => [:author_email_address, :parent_id])
+
+    t = Topic.create("title" => "The earth is actually flat!")
+ 
+    r1 = t.replies.create "author_name" => "jeremy", "author_email_address" => "jeremy@rubyonrails.com", "title" => "You're crazy!", "content" => "Crazy reply"
+    assert r1.valid?, "Saving r1"
+    
+    r2 = t.replies.create "author_name" => "jeremy", "author_email_address" => "jeremy@rubyonrails.com", "title" => "You're crazy!", "content" => "Crazy reply again..."
+    assert !r2.valid?, "Saving r2. Double reply by same author." 
+    
+    r2.author_email_address = "jeremy_alt_email@rubyonrails.com"
+    assert r2.save, "Saving r2 the second time." 
+    
+    r3 = t.replies.create "author_name" => "jeremy", "author_email_address" => "jeremy_alt_email@rubyonrails.com", "title" => "You're wrong", "content" => "It's cubic"
+    assert !r3.valid?, "Saving r3"
+    
+    r3.author_name = "jj"
+    assert r3.save, "Saving r3 the second time."
+    
+    r3.author_name = "jeremy"
+    assert !r3.save, "Saving r3 the third time."
+  end
+
   def test_validate_format
     Topic.validates_format_of(:title, :content, :with => /^Validation\smacros \w+!$/, :message => "is bad data")
 
@@ -296,6 +320,34 @@ class ValidationsTest < Test::Unit::TestCase
 
     assert_raise(ArgumentError) { Topic.validates_format_of(:title, :content) }
   end
+  
+  # testing ticket #3142
+  def test_validate_format_numeric
+    Topic.validates_format_of(:title, :content, :with => /^[1-9][0-9]*$/, :message => "is bad data")
+
+    t = Topic.create("title" => "72x", "content" => "6789")
+    assert !t.valid?, "Shouldn't be valid"
+    assert !t.save, "Shouldn't save because it's invalid"
+    assert_equal "is bad data", t.errors.on(:title)
+    assert_nil t.errors.on(:content)
+
+    t.title = "-11"
+    assert !t.valid?, "Shouldn't be valid"
+
+    t.title = "03"
+    assert !t.valid?, "Shouldn't be valid"
+
+    t.title = "z44"
+    assert !t.valid?, "Shouldn't be valid"
+
+    t.title = "5v7"
+    assert !t.valid?, "Shouldn't be valid"
+
+    t.title = "1"
+
+    assert t.save
+    assert_nil t.errors.on(:title)
+  end
 
   def test_validates_inclusion_of
     Topic.validates_inclusion_of( :title, :in => %w( a b c d e f g ) )
@@ -350,17 +402,17 @@ class ValidationsTest < Test::Unit::TestCase
     t.title = "not"
     assert !t.valid?
     assert t.errors.on(:title)
-    assert_equal "is too short (min is 5 characters)", t.errors["title"]
+    assert_equal "is too short (minimum is 5 characters)", t.errors["title"]
 
     t.title = ""
     assert !t.valid?
     assert t.errors.on(:title)
-    assert_equal "is too short (min is 5 characters)", t.errors["title"]
+    assert_equal "is too short (minimum is 5 characters)", t.errors["title"]
 
     t.title = nil
     assert !t.valid?
     assert t.errors.on(:title)
-    assert_equal "is too short (min is 5 characters)", t.errors["title"]
+    assert_equal "is too short (minimum is 5 characters)", t.errors["title"]
   end
 
   def test_optionally_validates_length_of_using_minimum
@@ -382,7 +434,7 @@ class ValidationsTest < Test::Unit::TestCase
     t.title = "notvalid"
     assert !t.valid?
     assert t.errors.on(:title)
-    assert_equal "is too long (max is 5 characters)", t.errors["title"]
+    assert_equal "is too long (maximum is 5 characters)", t.errors["title"]
 
     t.title = ""
     assert t.valid?
@@ -406,14 +458,14 @@ class ValidationsTest < Test::Unit::TestCase
 
     t = Topic.new("title" => "a!", "content" => "I'm ooooooooh so very long")
     assert !t.valid?
-    assert_equal "is too short (min is 3 characters)", t.errors.on(:title)
-    assert_equal "is too long (max is 5 characters)", t.errors.on(:content)
+    assert_equal "is too short (minimum is 3 characters)", t.errors.on(:title)
+    assert_equal "is too long (maximum is 5 characters)", t.errors.on(:content)
 
     t.title = nil
     t.content = nil
     assert !t.valid?
-    assert_equal "is too short (min is 3 characters)", t.errors.on(:title)
-    assert_equal "is too short (min is 3 characters)", t.errors.on(:content)
+    assert_equal "is too short (minimum is 3 characters)", t.errors.on(:title)
+    assert_equal "is too short (minimum is 3 characters)", t.errors.on(:content)
 
     t.title = "abe"
     t.content  = "mad"
@@ -590,6 +642,141 @@ class ValidationsTest < Test::Unit::TestCase
     assert_equal "hoo 5", t.errors["title"]
   end
 
+  def kcode_scope(kcode)
+    orig_kcode = $KCODE
+    $KCODE = kcode
+    begin
+      yield
+    ensure
+      $KCODE = orig_kcode
+    end
+  end
+
+  def test_validates_length_of_using_minimum_utf8
+    kcode_scope('UTF8') do
+      Topic.validates_length_of :title, :minimum => 5
+
+      t = Topic.create("title" => "一二三四五", "content" => "whatever")
+      assert t.valid?
+
+      t.title = "一二三四"
+      assert !t.valid?
+      assert t.errors.on(:title)
+      assert_equal "is too short (minimum is 5 characters)", t.errors["title"]
+    end
+  end
+
+  def test_validates_length_of_using_maximum_utf8
+    kcode_scope('UTF8') do
+      Topic.validates_length_of :title, :maximum => 5
+
+      t = Topic.create("title" => "一二三四五", "content" => "whatever")
+      assert t.valid?
+      
+      t.title = "一二34五六"
+      assert !t.valid?
+      assert t.errors.on(:title)
+      assert_equal "is too long (maximum is 5 characters)", t.errors["title"]
+    end
+  end
+
+  def test_validates_length_of_using_within_utf8
+    kcode_scope('UTF8') do
+      Topic.validates_length_of(:title, :content, :within => 3..5)
+
+      t = Topic.new("title" => "一二", "content" => "12三四五六七")
+      assert !t.valid?
+      assert_equal "is too short (minimum is 3 characters)", t.errors.on(:title)
+      assert_equal "is too long (maximum is 5 characters)", t.errors.on(:content)
+      t.title = "一二三"
+      t.content  = "12三"
+      assert t.valid?
+    end
+  end
+
+  def test_optionally_validates_length_of_using_within_utf8
+    kcode_scope('UTF8') do
+      Topic.validates_length_of :title, :content, :within => 3..5, :allow_nil => true
+
+      t = Topic.create('title' => '一二三', 'content' => '一二三四五')
+      assert t.valid?
+
+      t.title = nil
+      assert t.valid?
+    end
+  end
+
+  def test_optionally_validates_length_of_using_within_on_create_utf8
+    kcode_scope('UTF8') do
+      Topic.validates_length_of :title, :content, :within => 5..10, :on => :create, :too_long => "長すぎます: %d"
+
+      t = Topic.create("title" => "一二三四五六七八九十A", "content" => "whatever")
+      assert !t.save
+      assert t.errors.on(:title)
+      assert_equal "長すぎます: 10", t.errors[:title]
+      
+      t.title = "一二三四五六七八九"
+      assert t.save
+      
+      t.title = "一二3"
+      assert t.save
+      
+      t.content = "一二三四五六七八九十"
+      assert t.save
+      
+      t.content = t.title = "一二三四五六"
+      assert t.save
+    end
+  end
+
+  def test_optionally_validates_length_of_using_within_on_update_utf8
+    kcode_scope('UTF8') do    
+      Topic.validates_length_of :title, :content, :within => 5..10, :on => :update, :too_short => "短すぎます: %d"
+
+      t = Topic.create("title" => "一二三4", "content" => "whatever")
+      assert !t.save
+      assert t.errors.on(:title)
+      
+      t.title = "1二三4"
+      assert !t.save
+      assert t.errors.on(:title)
+      assert_equal "短すぎます: 5", t.errors[:title]
+      
+      t.title = "valid"
+      t.content = "一二三四五六七八九十A"
+      assert !t.save
+      assert t.errors.on(:content)
+      
+      t.content = "一二345"
+      assert t.save
+    end
+  end
+
+  def test_validates_length_of_using_is_utf8
+    kcode_scope('UTF8') do
+      Topic.validates_length_of :title, :is => 5
+
+      t = Topic.create("title" => "一二345", "content" => "whatever")
+      assert t.valid?
+
+      t.title = "一二345六"
+      assert !t.valid?
+      assert t.errors.on(:title)
+      assert_equal "is the wrong length (should be 5 characters)", t.errors["title"]
+    end
+  end
+
+  def test_validates_size_of_association_utf8
+    kcode_scope('UTF8') do
+      assert_nothing_raised { Topic.validates_size_of :replies, :minimum => 1 }
+      t = Topic.new('title' => 'あいうえお', 'content' => 'かきくけこ')
+      assert !t.save
+      assert t.errors.on(:replies)
+      t.replies.create('title' => 'あいうえお', 'content' => 'かきくけこ')
+      assert t.valid?
+    end
+  end
+
   def test_validates_associated_many
     Topic.validates_associated( :replies )
     t = Topic.create("title" => "uhohuhoh", "content" => "whatever")