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/all_inclusion_spec.rb ADDED

@@ -0,0 +1,352 @@
+# coding: utf-8
+require "spec_helper"
+require "active_support/i18n"
+require "test_class/all_inclusion_test"
+describe Detox::Validations::AllInclusionValidator do
+  describe "validation result" do
+    context "when given no additional option" do# {{{
+      let(:test) { AllInclusionTest.new }
+      context "when apply to nil" do
+        it "is valid" do
+          test.values = 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.values = []
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '2', '3'] (valid values)" do
+          it "is valid" do
+            test.values = ["1", "2", "3"]
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '2', '4'] (contains invalid values)" do
+          it "is invalid" do
+            test.values = ["1", "2", "4"]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['1', '2', nil] (contains nil)" do
+          it "is invalid" do
+            test.values = ['1', '2', nil]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['1', '2', ''] (contains empty)" do
+          it "is invalid" do
+            test.values = ['1', '2', '']
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['1', '2', '   '] (contains blank)" do
+          it "is invalid" do
+            test.values = ['1', '2', '   ']
+            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.values = {}
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => '3' } (valid values)" do
+          it "is valid" do
+            test.values = { :a => '1', :b => '2', :c => '3' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => '4' } (contains invalid values)" do
+          it "is invalid" do
+            test.values = { :a => '1', :b => '2', :c => '4' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => nil } (contains nil)" do
+          it "is invalid" do
+            test.values = { :a => '1', :b => '2', :c => nil }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => '' } (contains empty)" do
+          it "is invalid" do
+            test.values = { :a => '1', :b => '2', :c => '' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => '   ' } (contains blank)" do
+          it "is invalid" do
+            test.values = { :a => '1', :b => '2', :c => '   ' }
+            expect(test.valid?).to eq false
+          end
+        end
+      end# }}}
+    end# }}}
+    context "when given ignore_nil_value option" do# {{{
+      let(:test) { AllInclusionTestWithIgnoreNilValueOption.new }
+      context "when apply to nil" do
+        it "is valid" do
+          test.values = 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.values = []
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '2', '3'] (valid values)" do
+          it "is valid" do
+            test.values = ["1", "2", "3"]
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '2', '4'] (contains invalid values)" do
+          it "is invalid" do
+            test.values = ["1", "2", "4"]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['1', '2', nil] (contains nil)" do
+          it "is valid" do
+            test.values = ['1', '2', nil]
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '2', ''] (contains empty)" do
+          it "is invalid" do
+            test.values = ['1', '2', '']
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['1', '2', '   '] (contains blank)" do
+          it "is invalid" do
+            test.values = ['1', '2', '   ']
+            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.values = {}
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => '3' } (valid values)" do
+          it "is valid" do
+            test.values = { :a => '1', :b => '2', :c => '3' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => '4' } (contains invalid values)" do
+          it "is invalid" do
+            test.values = { :a => '1', :b => '2', :c => '4' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => nil } (contains nil)" do
+          it "is valid" do
+            test.values = { :a => '1', :b => '2', :c => nil }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => '' } (contains empty)" do
+          it "is invalid" do
+            test.values = { :a => '1', :b => '2', :c => '' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => '   ' } (contains blank)" do
+          it "is invalid" do
+            test.values = { :a => '1', :b => '2', :c => '   ' }
+            expect(test.valid?).to eq false
+          end
+        end
+      end# }}}
+    end# }}}
+    context "when given ignore_blank_value option" do# {{{
+      let(:test) { AllInclusionTestWithIgnoreBlankValueOption.new }
+      context "when apply to nil" do
+        it "is valid" do
+          test.values = 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.values = []
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '2', '3'] (valid values)" do
+          it "is valid" do
+            test.values = ["1", "2", "3"]
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '2', '4'] (contains invalid values)" do
+          it "is invalid" do
+            test.values = ["1", "2", "4"]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['1', '2', nil] (contains nil)" do
+          it "is valid" do
+            test.values = ['1', '2', nil]
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '2', ''] (contains empty)" do
+          it "is valid" do
+            test.values = ['1', '2', '']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '2', '   '] (contains blank)" do
+          it "is valid" do
+            test.values = ['1', '2', '   ']
+            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.values = {}
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => '3' } (valid values)" do
+          it "is valid" do
+            test.values = { :a => '1', :b => '2', :c => '3' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => '4' } (contains invalid values)" do
+          it "is invalid" do
+            test.values = { :a => '1', :b => '2', :c => '4' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => nil } (contains nil)" do
+          it "is valid" do
+            test.values = { :a => '1', :b => '2', :c => nil }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => '' } (contains empty)" do
+          it "is valid" do
+            test.values = { :a => '1', :b => '2', :c => '' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '2', :c => '   ' } (contains blank)" do
+          it "is valid" do
+            test.values = { :a => '1', :b => '2', :c => '   ' }
+            expect(test.valid?).to eq true
+          end
+        end
+      end# }}}
+    end# }}}
+  end
+  describe "error message" do
+    context "when without message option" do# {{{
+      let(:test) { AllInclusionTest.new }
+      context "when valid" do
+        before do
+          test.values = ['1', '2', '3']
+          test.valid?
+        end
+        it "has no message" do
+          expect(test.errors.present?).to eq false
+        end
+      end
+      context "when invalid" do
+        before do
+          test.values = ['1', '2', '4']
+          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 values attribute" do
+          expect(test.errors.include?(:values)).to eq true
+        end
+        it %q{error messsage is "Values contains value that is not included in the list"} do
+          expect(test.errors.full_messages.first).to eq "Values contains value that is not included in the list"
+        end
+      end
+      context "when using i18n" do
+        before do
+          @base_locale = I18n.locale
+          I18n.locale = :ja
+          test.values = ['1', '2', '4']
+          test.valid?
+        end
+        after do
+          I18n.locale = @base_locale
+        end
+        it "error messsage is translated" do
+          expect(test.errors.full_messages.first).to eq "Values にはリストに含まれていない値が含まれています"
+        end
+      end
+    end# }}}
+    context "when given message option" do# {{{
+      let(:test) { AllInclusionTestWithMessageOption.new }
+      context "when invalid" do
+        before do
+          test.values = ['1', '2', '4']
+          test.valid?
+        end
+        it "error messsage uses given message" do
+          expect(test.errors.full_messages.first).to eq 'Values is invalid'
+        end
+      end
+      context "when using i18n" do
+        before do
+          @base_locale = I18n.locale
+          I18n.locale = :ja
+          test.values = ['1', '2', '4']
+          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 'Values is invalid'
+        end
+      end
+    end# }}}
+  end
+end

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

@@ -0,0 +1,388 @@
+# coding: utf-8
+require "spec_helper"
+require "active_support/i18n"
+require "test_class/all_length_test"
+describe Detox::Validations::AllLengthValidator do
+  describe "validation result (3 <= length <= 6)" do
+    context "when given no additional option" do# {{{
+      let(:test) { AllLengthTest.new }
+      context "when apply to nil" do
+        it "is valid" do
+          test.values = 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.values = []
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['12345', '123', '123456'] (valid values)" do
+          it "is valid" do
+            test.values = ["12345", "123", "123456"]
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['12345', '123', '1234567'] (contains longer value)" do
+          it "is invalid" do
+            test.values = ["12345", "123", "1234567"]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['12345', '123', '123'] (contains shorter value)" do
+          it "is invalid" do
+            test.values = ["12345", "123", "12"]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['12345', '123', nil] (contains nil)" do
+          it "is invalid" do
+            test.values = ["12345", "123", nil]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['12345', '123', ''] (contains empty)" do
+          it "is invalid" do
+            test.values = ["12345", "123", ""]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['12345', '123', '  '] (contains invalid length blank)" do
+          it "is invalid" do
+            test.values = ["12345", "123", "  "]
+            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.values = {}
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '12345', :b => '123', :c => '123456' } (valid values)" do
+          it "is valid" do
+            test.values = { :a => '12345', :b => '123', :c => '123456' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '12345', :b => '123', :c => '1234567' } (contains longer value)" do
+          it "is invalid" do
+            test.values = { :a => '12345', :b => '123', :c => '1234567' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '12345', :b => '123', :c => '12' } (contains shorter value)" do
+          it "is invalid" do
+            test.values = { :a => '12345', :b => '123', :c => '12' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '12345', :b => '123', :c => nil } (contains nil)" do
+          it "is invalid" do
+            test.values = { :a => '12345', :b => '123', :c => nil }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '12345', :b => '123', :c => '' } (contains empty)" do
+          it "is invalid" do
+            test.values = { :a => '12345', :b => '123', :c => '' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '12345', :b => '123', :c => '  ' } (contains invalid length blank)" do
+          it "is invalid" do
+            test.values = { :a => '12345', :b => '123', :c => '  ' }
+            expect(test.valid?).to eq false
+          end
+        end
+      end# }}}
+    end# }}}
+    context "when given ignore_nil_value option" do# {{{
+      let(:test) { AllLengthTestWithIgnoreNilValueOption.new }
+      context "when apply to nil" do
+        it "is valid" do
+          test.values = 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.values = []
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['12345', '123', '123456'] (valid values)" do
+          it "is valid" do
+            test.values = ["12345", "123", "123456"]
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['12345', '123', '1234567'] (contains longer value)" do
+          it "is invalid" do
+            test.values = ["12345", "123", "1234567"]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['12345', '123', '12'] (contains shorter value)" do
+          it "is invalid" do
+            test.values = ["12345", "123", "12"]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['12345', '123', nil] (contains nil)" do
+          it "is valid" do
+            test.values = ["12345", "123", nil]
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['12345', '123', ''] (contains empty)" do
+          it "is invalid" do
+            test.values = ["12345", "123", ""]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['12345', '123', '  '] (contains invalid length blank)" do
+          it "is invalid" do
+            test.values = ["12345", "123", "  "]
+            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.values = {}
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '12345', :b => '123', :c => '123456' } (valid values)" do
+          it "is valid" do
+            test.values = { :a => '12345', :b => '123', :c => '123456' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '12345', :b => '123', :c => '1234567' } (contains longer value)" do
+          it "is invalid" do
+            test.values = { :a => '12345', :b => '123', :c => '1234567' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '12345', :b => '123', :c => '12' } (contains shorter value)" do
+          it "is invalid" do
+            test.values = { :a => '12345', :b => '123', :c => '12' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '12345', :b => '123', :c => nil } (contains nil)" do
+          it "is valid" do
+            test.values = { :a => '12345', :b => '123', :c => nil }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '12345', :b => '123', :c => '' } (contains empty)" do
+          it "is invalid" do
+            test.values = { :a => '12345', :b => '123', :c => '' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '12345', :b => '123', :c => '  ' } (contains invalid length blank)" do
+          it "is invalid" do
+            test.values = { :a => '12345', :b => '123', :c => '  ' }
+            expect(test.valid?).to eq false
+          end
+        end
+      end# }}}
+    end# }}}
+    context "when given ignore_blank_value option" do# {{{
+      let(:test) { AllLengthTestWithIgnoreBlankValueOption.new }
+      context "when apply to nil" do
+        it "is valid" do
+          test.values = 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.values = []
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['12345', '123', '123456'] (valid values)" do
+          it "is valid" do
+            test.values = ["12345", "123", "123456"]
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['12345', '123', '1234567'] (contains longer length)" do
+          it "is invalid" do
+            test.values = ["12345", "123", "1234567"]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['12345', '123', '12'] (contains shorter length)" do
+          it "is invalid" do
+            test.values = ["12345", "123", "12"]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['12345', '123', nil] (contains nil)" do
+          it "is valid" do
+            test.values = ["12345", "123", nil]
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['12345', '123', ''] (contains empty)" do
+          it "is valid" do
+            test.values = ["12345", "123", ""]
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['12345', '123', '  '] (contains invalid length blank)" do
+          it "is valid" do
+            test.values = ["12345", "123", "  "]
+            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.values = {}
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '12345', :b => '123', :c => '123456' } (valid values)" do
+          it "is valid" do
+            test.values = { :a => '12345', :b => '123', :c => '123456' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '12345', :b => '123', :c => '1234567' } (contains longer value)" do
+          it "is invalid" do
+            test.values = { :a => '12345', :b => '123', :c => '1234567' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '12345', :b => '123', :c => '12' } (contains shorter value)" do
+          it "is invalid" do
+            test.values = { :a => '12345', :b => '123', :c => '12' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '12345', :b => '123', :c => nil } (contains nil)" do
+          it "is valid" do
+            test.values = { :a => '12345', :b => '123', :c => nil }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '12345', :b => '123', :c => '' } (contains empty)" do
+          it "is valid" do
+            test.values = { :a => '12345', :b => '123', :c => '' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '12345', :b => '123', :c => '  ' } (contains invalid length blank)" do
+          it "is valid" do
+            test.values = { :a => '12345', :b => '123', :c => '  ' }
+            expect(test.valid?).to eq true
+          end
+        end
+      end# }}}
+    end# }}}
+  end
+  describe "error message" do
+    context "when witout message option" do# {{{
+      let(:test) { AllLengthTest.new }
+      context "when valid" do
+        before do
+          test.values = ['12345', '123', '123456']
+          test.valid?
+        end
+        it "has no message" do
+          expect(test.errors.present?).to eq false
+        end
+      end
+      context "when invalid" do
+        before do
+          test.values = ['12345', '123', '1234567']
+          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 values attribute" do
+          expect(test.errors.include?(:values)).to eq true
+        end
+        it "error messsage is 'Values contains invalid length value'" do
+          expect(test.errors.full_messages.first).to eq "Values contains invalid length value"
+        end
+      end
+      context "when using i18n" do
+        before do
+          @base_locale = I18n.locale
+          I18n.locale = :ja
+          test.values = ['12345', '123', '1234567']
+          test.valid?
+        end
+        after do
+          I18n.locale = @base_locale
+        end
+        it "error messsage is translated" do
+          expect(test.errors.full_messages.first).to eq "Values には長さが不正な値が含まれています"
+        end
+      end
+    end# }}}
+    context "when given message option" do# {{{
+      let(:test) { AllLengthTestWithMessageOption.new }
+      context "when invalid" do
+        before do
+          test.values = ['12345', '123', '1234567']
+          test.valid?
+        end
+        it "error messsage uses given message" do
+          expect(test.errors.full_messages.first).to eq 'Values is invalid'
+        end
+      end
+      context "when using i18n" do
+        before do
+          @base_locale = I18n.locale
+          I18n.locale = :ja
+          test.values = ['12345', '123', '1234567']
+          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 'Values is invalid'
+        end
+      end
+    end# }}}
+  end
+end