RubyGems - detox - Versions diffs - 1.0.0 - Mend

detox 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (65) hide show

checksums.yaml +7 -0
data/.coveralls.yml +1 -0
data/.gitignore +19 -0
data/.travis.yml +7 -0
data/Gemfile +4 -0
data/LICENSE +20 -0
data/README.md +40 -0
data/Rakefile +11 -0
data/detox.gemspec +27 -0
data/gemfiles/activemodel_3_2_x.gemfile +5 -0
data/gemfiles/activemodel_4_0_x.gemfile +5 -0
data/lib/active_model/validations/absence.rb +19 -0
data/lib/detox.rb +11 -0
data/lib/detox/array_validity.rb +23 -0
data/lib/detox/locales/en.yml +21 -0
data/lib/detox/locales/ja.yml +21 -0
data/lib/detox/validations/all.rb +41 -0
data/lib/detox/validations/any.rb +57 -0
data/lib/detox/validations/ordering.rb +34 -0
data/lib/detox/validations/possession.rb +30 -0
data/lib/detox/validity_broker.rb +55 -0
data/lib/detox/version.rb +4 -0
data/spec/detox/array_validity_spec.rb +214 -0
data/spec/detox/validations/all_absence_spec.rb +147 -0
data/spec/detox/validations/all_acceptance_spec.rb +352 -0
data/spec/detox/validations/all_exclusion_spec.rb +137 -0
data/spec/detox/validations/all_format_spec.rb +351 -0
data/spec/detox/validations/all_inclusion_spec.rb +352 -0
data/spec/detox/validations/all_length_spec.rb +388 -0
data/spec/detox/validations/all_numericality_spec.rb +369 -0
data/spec/detox/validations/all_presence_spec.rb +159 -0
data/spec/detox/validations/any_absence_spec.rb +597 -0
data/spec/detox/validations/any_acceptance_spec.rb +597 -0
data/spec/detox/validations/any_exclusion_spec.rb +597 -0
data/spec/detox/validations/any_format_spec.rb +597 -0
data/spec/detox/validations/any_inclusion_spec.rb +597 -0
data/spec/detox/validations/any_length_spec.rb +597 -0
data/spec/detox/validations/any_numericality_spec.rb +609 -0
data/spec/detox/validations/any_presence_spec.rb +596 -0
data/spec/detox/validations/any_validator_check_validity_spec.rb +126 -0
data/spec/detox/validations/ordering_spec.rb +452 -0
data/spec/detox/validations/possession_spec.rb +263 -0
data/spec/detox/validity_broker_spec.rb +126 -0
data/spec/spec_helper.rb +24 -0
data/spec/test_class/all_absence_test.rb +14 -0
data/spec/test_class/all_acceptance_test.rb +27 -0
data/spec/test_class/all_exclusion_test.rb +15 -0
data/spec/test_class/all_format_test.rb +26 -0
data/spec/test_class/all_inclusion_test.rb +27 -0
data/spec/test_class/all_length_test.rb +28 -0
data/spec/test_class/all_numericality_test.rb +33 -0
data/spec/test_class/all_presence_test.rb +14 -0
data/spec/test_class/any_absence_test.rb +33 -0
data/spec/test_class/any_acceptance_test.rb +34 -0
data/spec/test_class/any_exclusion_test.rb +34 -0
data/spec/test_class/any_format_test.rb +34 -0
data/spec/test_class/any_inclusion_test.rb +33 -0
data/spec/test_class/any_length_test.rb +33 -0
data/spec/test_class/any_numericality_test.rb +35 -0
data/spec/test_class/any_presence_test.rb +33 -0
data/spec/test_class/array_validity_test.rb +6 -0
data/spec/test_class/model_base.rb +11 -0
data/spec/test_class/ordering_test.rb +33 -0
data/spec/test_class/possession_test.rb +22 -0
metadata +219 -0

data/spec/detox/validations/any_format_spec.rb ADDED

@@ -0,0 +1,597 @@
+# coding: utf-8
+require "spec_helper"
+require "active_support/i18n"
+require "test_class/any_format_test"
+describe Detox::Validations::AnyFormatValidator do
+  describe "validation result" do
+    context "when given no additional option" do# {{{
+      let(:test) { AnyFormatTest.new }
+      context "when apply to nil" do
+        it "is valid" do
+          test.words = nil
+          expect(test.valid?).to eq true
+        end
+      end
+      context "when apply to Array" do# {{{
+        context "when apply to [] (empty)" do
+          it "is valid" do
+            test.words = []
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to [nil, '', '   '] (all words are nil or empty or blank)" do
+          it "is invalid" do
+            test.words = [nil, "", "   "]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['foo', 'b@r', 'b@r', 'b@r', 'b@r'] (1 valid value)" do
+          it "is valid" do
+            test.words = ['foo', 'b@r', 'b@r', 'b@r', 'b@r']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['foo', 'foo', 'b@r', 'b@r', 'b@r'] (2 valid words)" do
+          it "is valid" do
+            test.words = ['foo', 'foo', 'b@r', 'b@r', 'b@r']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['foo', 'foo', 'foo', 'b@r', 'b@r'] (3 valid words)" do
+          it "is valid" do
+            test.words = ['foo', 'foo', 'foo', 'b@r', 'b@r']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['foo', 'foo', 'foo', 'foo', 'b@r'] (4 valid words)" do
+          it "is valid" do
+            test.words = ['foo', 'foo', 'foo', 'foo', 'b@r']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['foo', 'foo', 'foo', 'foo', 'foo'] (all valid words)" do
+          it "is valid" do
+            test.words = ['foo', 'foo', 'foo', 'foo', 'foo']
+            expect(test.valid?).to eq true
+          end
+        end
+      end# }}}
+      context "when apply to Hash" do# {{{
+        context "when apply to {} (empty)" do
+          it "is valid" do
+            test.words = {}
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => nil, :b => '', :c => '   ' } (all words are nil or empty or blank)" do
+          it "is invalid" do
+            test.words = { :a => nil, :b => "", :c => "   " }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'b@r', :c => 'b@r', :d => 'b@r' :e => 'b@r' } (1 valid value)" do
+          it "is valid" do
+            test.words = { :a => 'foo', :b => 'b@r', :c => 'b@r', :d => 'b@r', :e => 'b@r' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'foo', :c => 'b@r', :d => 'b@r' :e => 'b@r' } (2 valid words)" do
+          it "is valid" do
+            test.words = { :a => 'foo', :b => 'foo', :c => 'b@r', :d => 'b@r', :e => 'b@r' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'foo', :c => 'foo', :d => 'b@r', :e => 'b@r' } (3 valid words)" do
+          it "is valid" do
+            test.words = { :a => 'foo', :b => 'foo', :c => 'b@r', :d => 'b@r', :e => 'b@r' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'foo', :c => 'foo', :d => 'foo', :e => 'b@r' } (4 valid words)" do
+          it "is valid" do
+            test.words = { :a => 'foo', :b => 'foo', :c => 'foo', :d => 'b@r', :e => 'b@r' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'foo', :c => 'foo', :d => 'foo', :e => 'foo' } (all valid words)" do
+          it "is valid" do
+            test.words = { :a => 'foo', :b => 'foo', :c => 'foo', :d => 'foo', :e => 'foo' }
+            expect(test.valid?).to eq true
+          end
+        end
+      end# }}}
+    end# }}}
+    context "when given only :min_valid_count option" do# {{{
+      let(:test) { AnyFormatTestWithMinValidCountOnly.new }
+      context "when apply to nil" do
+        it "is valid" do
+          test.words = nil
+          expect(test.valid?).to eq true
+        end
+      end
+      context "when apply to Array" do# {{{
+        context "when apply to [] (empty)" do
+          it "is valid" do
+            test.words = []
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to [nil, '', '   '] (all words are nil or empty or blank)" do
+          it "is invalid" do
+            test.words = [nil, "", "   "]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['foo', 'b@r', 'b@r', 'b@r', 'b@r'] (1 valid value)" do
+          it "is invalid" do
+            test.words = ['foo', 'b@r', 'b@r', 'b@r', 'b@r']
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['foo', 'foo', 'b@r', 'b@r', 'b@r'] (2 valid words)" do
+          it "is valid" do
+            test.words = ['foo', 'foo', 'b@r', 'b@r', 'b@r']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['foo', 'foo', 'foo', 'b@r', 'b@r'] (3 valid words)" do
+          it "is valid" do
+            test.words = ['foo', 'foo', 'foo', 'b@r', 'b@r']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['foo', 'foo', 'foo', 'foo', 'b@r'] (4 valid words)" do
+          it "is valid" do
+            test.words = ['foo', 'foo', 'foo', 'foo', 'b@r']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['foo', 'foo', 'foo', 'foo', 'foo'] (all valid words)" do
+          it "is valid" do
+            test.words = ['foo', 'foo', 'foo', 'foo', 'foo']
+            expect(test.valid?).to eq true
+          end
+        end
+      end# }}}
+      context "when apply to Hash" do# {{{
+        context "when apply to {} (empty)" do
+          it "is valid" do
+            test.words = {}
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => nil, :b => '', :c => '   ' } (all words are nil or empty or blank)" do
+          it "is invalid" do
+            test.words = { :a => nil, :b => "", :c => "   " }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'b@r', :c => 'b@r', :d => 'b@r' :e => 'b@r' } (1 valid value)" do
+          it "is invalid" do
+            test.words = { :a => 'foo', :b => 'b@r', :c => 'b@r', :d => 'b@r', :e => 'b@r' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'foo', :c => 'b@r', :d => 'b@r' :e => 'b@r' } (2 valid words)" do
+          it "is valid" do
+            test.words = { :a => 'foo', :b => 'foo', :c => 'b@r', :d => 'b@r', :e => 'b@r' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'foo', :c => 'foo', :d => 'b@r', :e => 'b@r' } (3 valid words)" do
+          it "is valid" do
+            test.words = { :a => 'foo', :b => 'foo', :c => 'foo', :d => 'b@r', :e => 'b@r' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'foo', :c => 'foo', :d => 'foo', :e => 'b@r' } (4 valid words)" do
+          it "is valid" do
+            test.words = { :a => 'foo', :b => 'foo', :c => 'foo', :d => 'foo', :e => 'b@r' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'foo', :c => 'foo', :d => 'foo', :e => 'foo' } (all valid words)" do
+          it "is valid" do
+            test.words = { :a => 'foo', :b => 'foo', :c => 'foo', :d => 'foo', :e => 'foo' }
+            expect(test.valid?).to eq true
+          end
+        end
+      end# }}}
+    end# }}}
+    context "when given only :max_valid_count option" do# {{{
+      let(:test) { AnyFormatTestWithMaxValidCountOnly.new }
+      context "when apply to nil" do
+        it "is valid" do
+          test.words = nil
+          expect(test.valid?).to eq true
+        end
+      end
+      context "when apply to Array" do# {{{
+        context "when apply to [] (empty)" do
+          it "is valid" do
+            test.words = []
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to [nil, '', '   '] (all words are nil or empty or blank)" do
+          it "is invalid" do
+            test.words = [nil, "", "   "]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['foo', 'b@r', 'b@r', 'b@r', 'b@r'] (1 valid value)" do
+          it "is valid" do
+            test.words = ['foo', 'b@r', 'b@r', 'b@r', 'b@r']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['foo', 'foo', 'b@r', 'b@r', 'b@r'] (2 valid words)" do
+          it "is valid" do
+            test.words = ['foo', 'foo', 'b@r', 'b@r', 'b@r']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['foo', 'foo', 'foo', 'b@r', 'b@r'] (3 valid words)" do
+          it "is valid" do
+            test.words = ['foo', 'foo', 'foo', 'b@r', 'b@r']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['foo', 'foo', 'foo', 'foo', 'b@r'] (4 valid words)" do
+          it "is invalid" do
+            test.words = ['foo', 'foo', 'foo', 'foo', 'b@r']
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['foo', 'foo', 'foo', 'foo', 'foo'] (all valid words)" do
+          it "is invalid" do
+            test.words = ['foo', 'foo', 'foo', 'foo', 'foo']
+            expect(test.valid?).to eq false
+          end
+        end
+      end# }}}
+      context "when apply to Hash" do# {{{
+        context "when apply to {} (empty)" do
+          it "is valid" do
+            test.words = {}
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => nil, :b => '', :c => '   ' } (all words are nil or empty or blank)" do
+          it "is invalid" do
+            test.words = { :a => nil, :b => "", :c => "   " }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'b@r', :c => 'b@r', :d => 'b@r' :e => 'b@r' } (1 valid value)" do
+          it "is valid" do
+            test.words = { :a => 'foo', :b => 'b@r', :c => 'b@r', :d => 'b@r', :e => 'b@r' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'foo', :c => 'b@r', :d => 'b@r' :e => 'b@r' } (2 valid words)" do
+          it "is valid" do
+            test.words = { :a => 'foo', :b => 'foo', :c => 'b@r', :d => 'b@r', :e => 'b@r' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'foo', :c => 'foo', :d => 'b@r', :e => 'b@r' } (3 valid words)" do
+          it "is valid" do
+            test.words = { :a => 'foo', :b => 'foo', :c => 'foo', :d => 'b@r', :e => 'b@r' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'foo', :c => 'foo', :d => 'foo', :e => 'b@r' } (4 valid words)" do
+          it "is invalid" do
+            test.words = { :a => 'foo', :b => 'foo', :c => 'foo', :d => 'foo', :e => 'b@r' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'foo', :c => 'foo', :d => 'foo', :e => 'foo' } (all valid words)" do
+          it "is invalid" do
+            test.words = { :a => 'foo', :b => 'foo', :c => 'foo', :d => 'foo', :e => 'foo' }
+            expect(test.valid?).to eq false
+          end
+        end
+      end# }}}
+    end# }}}
+    context "when given :min_valid_count and :max_valid_count option" do# {{{
+      let(:test) { AnyFormatTestWithBothValidCount.new }
+      context "when apply to nil" do
+        it "is valid" do
+          test.words = nil
+          expect(test.valid?).to eq true
+        end
+      end
+      context "when apply to Array" do# {{{
+        context "when apply to [] (empty)" do
+          it "is valid" do
+            test.words = []
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to [nil, '', '   '] (all words are nil or empty or blank)" do
+          it "is invalid" do
+            test.words = [nil, "", "   "]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['foo', 'b@r', 'b@r', 'b@r', 'b@r'] (1 valid value)" do
+          it "is invalid" do
+            test.words = ['foo', 'b@r', 'b@r', 'b@r', 'b@r']
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['foo', 'foo', 'b@r', 'b@r', 'b@r'] (2 valid words)" do
+          it "is valid" do
+            test.words = ['foo', 'foo', 'b@r', 'b@r', 'b@r']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['foo', 'foo', 'foo', 'b@r', 'b@r'] (3 valid words)" do
+          it "is valid" do
+            test.words = ['foo', 'foo', 'foo', 'b@r', 'b@r']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['foo', 'foo', 'foo', 'foo', 'b@r'] (4 valid words)" do
+          it "is invalid" do
+            test.words = ['foo', 'foo', 'foo', 'foo', 'b@r']
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['foo', 'foo', 'foo', 'foo', 'foo'] (all valid words)" do
+          it "is invalid" do
+            test.words = ['foo', 'foo', 'foo', 'foo', 'foo']
+            expect(test.valid?).to eq false
+          end
+        end
+      end# }}}
+      context "when apply to Hash" do# {{{
+        context "when apply to {} (empty)" do
+          it "is valid" do
+            test.words = {}
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => nil, :b => '', :c => '   ' } (all words are nil or empty or blank)" do
+          it "is invalid" do
+            test.words = { :a => nil, :b => "", :c => "   " }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'b@r', :c => 'b@r', :d => 'b@r' :e => 'b@r' } (1 valid value)" do
+          it "is invalid" do
+            test.words = { :a => 'foo', :b => 'b@r', :c => 'b@r', :d => 'b@r', :e => 'b@r' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'foo', :c => 'b@r', :d => 'b@r' :e => 'b@r' } (2 valid words)" do
+          it "is valid" do
+            test.words = { :a => 'foo', :b => 'foo', :c => 'b@r', :d => 'b@r', :e => 'b@r' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'foo', :c => 'foo', :d => 'b@r', :e => 'b@r' } (3 valid words)" do
+          it "is valid" do
+            test.words = { :a => 'foo', :b => 'foo', :c => 'foo', :d => 'b@r', :e => 'b@r' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'foo', :c => 'foo', :d => 'foo', :e => 'b@r' } (4 valid words)" do
+          it "is invalid" do
+            test.words = { :a => 'foo', :b => 'foo', :c => 'foo', :d => 'foo', :e => 'b@r' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'foo', :c => 'foo', :d => 'foo', :e => 'foo' } (all valid words)" do
+          it "is invalid" do
+            test.words = { :a => 'foo', :b => 'foo', :c => 'foo', :d => 'foo', :e => 'foo' }
+            expect(test.valid?).to eq false
+          end
+        end
+      end# }}}
+    end# }}}
+  end
+  describe "error message" do
+    context "when given no option" do# {{{
+      let(:test) { AnyFormatTest.new }
+      context "when valid" do
+        before do
+          test.words = ['foo', 'foo', 'b@r']
+          test.valid?
+        end
+        it "has no message" do
+          expect(test.errors.present?).to eq false
+        end
+      end
+      context "when invalid" do
+        before do
+          test.words = ['b@r', "", "   "]
+          test.valid?
+        end
+        it "has 1 error message" do
+          expect(test.errors.empty?).to eq false
+          expect(test.errors.size).to eq 1
+        end
+        it "error message is associated with words attribute" do
+          expect(test.errors.include?(:words)).to eq true
+        end
+        it %q{error messsage is "Words must be valid format (required number is 1-)"} do
+          expect(test.errors.full_messages.first).to eq "Words must be valid format (required number is 1-)"
+        end
+      end
+      context "when using i18n" do
+        before do
+          @base_locale = I18n.locale
+          I18n.locale = :ja
+          test.words = ['b@r', "", "   "]
+          test.valid?
+        end
+        after do
+          I18n.locale = @base_locale
+        end
+        it "error messsage is translated" do
+          expect(test.errors.full_messages.first).to eq "Words は必要数(1～)が正しい形式でなければなりません"
+        end
+      end
+    end# }}}
+    context "when given :min_valid_count option" do# {{{
+      let(:test) { AnyFormatTestWithMinValidCountOnly.new }
+      context "when invalid" do
+        before do
+          test.words = ['foo', "", "   "]
+          test.valid?
+        end
+        it "has 1 error message" do
+          expect(test.errors.empty?).to eq false
+          expect(test.errors.size).to eq 1
+        end
+        it "error message is associated with words attribute" do
+          expect(test.errors.include?(:words)).to eq true
+        end
+        it %q{error messsage is "Words must be valid format (required number is 2-)"} do
+          expect(test.errors.full_messages.first).to eq "Words must be valid format (required number is 2-)"
+        end
+      end
+      context "when using i18n" do
+        before do
+          @base_locale = I18n.locale
+          I18n.locale = :ja
+          test.words = ['foo', "", "   "]
+          test.valid?
+        end
+        after do
+          I18n.locale = @base_locale
+        end
+        it "error messsage is translated" do
+          expect(test.errors.full_messages.first).to eq "Words は必要数(2～)が正しい形式でなければなりません"
+        end
+      end
+    end# }}}
+    context "when given :max_valid_count option" do# {{{
+      let(:test) { AnyFormatTestWithMaxValidCountOnly.new }
+      context "when invalid" do
+        before do
+          test.words = ['foo', 'foo', 'foo', 'foo', 'b@r']
+          test.valid?
+        end
+        it "has 1 error message" do
+          expect(test.errors.empty?).to eq false
+          expect(test.errors.size).to eq 1
+        end
+        it "error message is associated with words attribute" do
+          expect(test.errors.include?(:words)).to eq true
+        end
+        it %q{error messsage is "Words must be valid format (required number is 1-3)"} do
+          expect(test.errors.full_messages.first).to eq "Words must be valid format (required number is 1-3)"
+        end
+      end
+      context "when using i18n" do
+        before do
+          @base_locale = I18n.locale
+          I18n.locale = :ja
+          test.words = ['foo', 'foo', 'foo', 'foo', 'b@r']
+          test.valid?
+        end
+        after do
+          I18n.locale = @base_locale
+        end
+        it "error messsage is translated" do
+          expect(test.errors.full_messages.first).to eq "Words は必要数(1～3)が正しい形式でなければなりません"
+        end
+      end
+    end# }}}
+    context "when given :min_valid_count and :max_valid_count option" do# {{{
+      let(:test) { AnyFormatTestWithBothValidCount.new }
+      context "when invalid" do
+        before do
+          test.words = ['foo', 'foo', 'foo', 'foo', 'b@r']
+          test.valid?
+        end
+        it "has 1 error message" do
+          expect(test.errors.empty?).to eq false
+          expect(test.errors.size).to eq 1
+        end
+        it "error message is associated with words attribute" do
+          expect(test.errors.include?(:words)).to eq true
+        end
+        it %q{error messsage is "Words must be valid format (required number is 2-3)"} do
+          expect(test.errors.full_messages.first).to eq "Words must be valid format (required number is 2-3)"
+        end
+      end
+      context "when using i18n" do
+        before do
+          @base_locale = I18n.locale
+          I18n.locale = :ja
+          test.words = ['foo', 'foo', 'foo', 'foo', 'b@r']
+          test.valid?
+        end
+        after do
+          I18n.locale = @base_locale
+        end
+        it "error messsage is translated" do
+          expect(test.errors.full_messages.first).to eq "Words は必要数(2～3)が正しい形式でなければなりません"
+        end
+      end
+    end# }}}
+    context "when given message option" do# {{{
+      let(:test) { AnyFormatTestWithMessageOption.new }
+      context "when invalid" do
+        before do
+          test.words = ['b@r', "", "   "]
+          test.valid?
+        end
+        it "error messsage uses given message" do
+          expect(test.errors.full_messages.first).to eq 'Words is invalid'
+        end
+      end
+      context "when using i18n" do
+        before do
+          @base_locale = I18n.locale
+          I18n.locale = :ja
+          test.words = ['b@r', "", "   "]
+          test.valid?
+        end
+        after do
+          I18n.locale = @base_locale
+        end
+        it "error messsage is not translated" do
+          expect(test.errors.full_messages.first).to eq 'Words is invalid'
+        end
+      end
+    end# }}}
+  end
+end