RubyGems - detox - Versions diffs - 1.0.0 - Mend

detox 1.0.0

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_numericality_spec.rb ADDED

@@ -0,0 +1,609 @@
+# coding: utf-8
+require "spec_helper"
+require "active_support/i18n"
+require "test_class/any_numericality_test"
+describe Detox::Validations::AnyNumericalityValidator do
+  describe "validation result" do
+    context "when given no additional option" do# {{{
+      let(:test) { AnyNumericalityTest.new }
+      context "when apply to nil" do
+        it "is valid" do
+          test.prices = 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.prices = []
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to [nil, '', '   '] (all prices are nil or empty or blank)" do
+          it "is invalid" do
+            test.prices = [nil, "", "   "]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['0', 'foo', 'foo', 'foo', 'foo'] (1 valid value)" do
+          it "is valid" do
+            test.prices = ['0', 'foo', 'foo', 'foo', 'foo']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['-1', 'foo', 'foo', 'foo', 'foo'] (negative value)" do
+          it "is valid" do
+            test.prices = ['-1', 'foo', 'foo', 'foo', 'foo']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['0.5', 'foo', 'foo', 'foo', 'foo'] (not integer)" do
+          it "is valid" do
+            test.prices = ['0.5', 'foo', 'foo', 'foo', 'foo']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['0', '0', 'foo', 'foo', 'foo'] (2 valid prices)" do
+          it "is valid" do
+            test.prices = ['0', '0', 'foo', 'foo', 'foo']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['0', '0', '0', 'foo', 'foo'] (3 valid prices)" do
+          it "is valid" do
+            test.prices = ['0', '0', '0', 'foo', 'foo']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['0', '0', '0', '0', 'foo'] (4 valid prices)" do
+          it "is valid" do
+            test.prices = ['0', '0', '0', '0', 'foo']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['0', '0', '0', '0', '0'] (all valid prices)" do
+          it "is valid" do
+            test.prices = ['0', '0', '0', '0', '0']
+            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.prices = {}
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => nil, :b => '', :c => '   ' } (all prices are nil or empty or blank)" do
+          it "is invalid" do
+            test.prices = { :a => nil, :b => "", :c => "   " }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '0', :b => 'foo', :c => 'foo', :d => 'foo' :e => 'foo' } (1 valid value)" do
+          it "is valid" do
+            test.prices = { :a => '0', :b => 'foo', :c => 'foo', :d => 'foo', :e => 'foo' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '0', :b => '0', :c => 'foo', :d => 'foo' :e => 'foo' } (2 valid prices)" do
+          it "is valid" do
+            test.prices = { :a => '0', :b => '0', :c => 'foo', :d => 'foo', :e => 'foo' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '0', :b => '0', :c => '0', :d => 'foo', :e => 'foo' } (3 valid prices)" do
+          it "is valid" do
+            test.prices = { :a => '0', :b => '0', :c => 'foo', :d => 'foo', :e => 'foo' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '0', :b => '0', :c => '0', :d => '0', :e => 'foo' } (4 valid prices)" do
+          it "is valid" do
+            test.prices = { :a => '0', :b => '0', :c => '0', :d => 'foo', :e => 'foo' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '0', :b => '0', :c => '0', :d => '0', :e => '0' } (all valid prices)" do
+          it "is valid" do
+            test.prices = { :a => '0', :b => '0', :c => '0', :d => '0', :e => '0' }
+            expect(test.valid?).to eq true
+          end
+        end
+      end# }}}
+    end# }}}
+    context "when given only :min_valid_count option" do# {{{
+      let(:test) { AnyNumericalityTestWithMinValidCountOnly.new }
+      context "when apply to nil" do
+        it "is valid" do
+          test.prices = 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.prices = []
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to [nil, '', '   '] (all prices are nil or empty or blank)" do
+          it "is invalid" do
+            test.prices = [nil, "", "   "]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['0', 'foo', 'foo', 'foo', 'foo'] (1 valid value)" do
+          it "is invalid" do
+            test.prices = ['0', 'foo', 'foo', 'foo', 'foo']
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['0', '0', 'foo', 'foo', 'foo'] (2 valid prices)" do
+          it "is valid" do
+            test.prices = ['0', '0', 'foo', 'foo', 'foo']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['0', '0', '0', 'foo', 'foo'] (3 valid prices)" do
+          it "is valid" do
+            test.prices = ['0', '0', '0', 'foo', 'foo']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['0', '0', '0', '0', 'foo'] (4 valid prices)" do
+          it "is valid" do
+            test.prices = ['0', '0', '0', '0', 'foo']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['0', '0', '0', '0', '0'] (all valid prices)" do
+          it "is valid" do
+            test.prices = ['0', '0', '0', '0', '0']
+            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.prices = {}
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => nil, :b => '', :c => '   ' } (all prices are nil or empty or blank)" do
+          it "is invalid" do
+            test.prices = { :a => nil, :b => "", :c => "   " }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '0', :b => 'foo', :c => 'foo', :d => 'foo' :e => 'foo' } (1 valid value)" do
+          it "is invalid" do
+            test.prices = { :a => '0', :b => 'foo', :c => 'foo', :d => 'foo', :e => 'foo' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '0', :b => '0', :c => 'foo', :d => 'foo' :e => 'foo' } (2 valid prices)" do
+          it "is valid" do
+            test.prices = { :a => '0', :b => '0', :c => 'foo', :d => 'foo', :e => 'foo' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '0', :b => '0', :c => '0', :d => 'foo', :e => 'foo' } (3 valid prices)" do
+          it "is valid" do
+            test.prices = { :a => '0', :b => '0', :c => '0', :d => 'foo', :e => 'foo' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '0', :b => '0', :c => '0', :d => '0', :e => 'foo' } (4 valid prices)" do
+          it "is valid" do
+            test.prices = { :a => '0', :b => '0', :c => '0', :d => '0', :e => 'foo' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '0', :b => '0', :c => '0', :d => '0', :e => '0' } (all valid prices)" do
+          it "is valid" do
+            test.prices = { :a => '0', :b => '0', :c => '0', :d => '0', :e => '0' }
+            expect(test.valid?).to eq true
+          end
+        end
+      end# }}}
+    end# }}}
+    context "when given only :max_valid_count option" do# {{{
+      let(:test) { AnyNumericalityTestWithMaxValidCountOnly.new }
+      context "when apply to nil" do
+        it "is valid" do
+          test.prices = 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.prices = []
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to [nil, '', '   '] (all prices are nil or empty or blank)" do
+          it "is invalid" do
+            test.prices = [nil, "", "   "]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['0', 'foo', 'foo', 'foo', 'foo'] (1 valid value)" do
+          it "is valid" do
+            test.prices = ['0', 'foo', 'foo', 'foo', 'foo']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['0', '0', 'foo', 'foo', 'foo'] (2 valid prices)" do
+          it "is valid" do
+            test.prices = ['0', '0', 'foo', 'foo', 'foo']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['0', '0', '0', 'foo', 'foo'] (3 valid prices)" do
+          it "is valid" do
+            test.prices = ['0', '0', '0', 'foo', 'foo']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['0', '0', '0', '0', 'foo'] (4 valid prices)" do
+          it "is invalid" do
+            test.prices = ['0', '0', '0', '0', 'foo']
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['0', '0', '0', '0', '0'] (all valid prices)" do
+          it "is invalid" do
+            test.prices = ['0', '0', '0', '0', '0']
+            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.prices = {}
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => nil, :b => '', :c => '   ' } (all prices are nil or empty or blank)" do
+          it "is invalid" do
+            test.prices = { :a => nil, :b => "", :c => "   " }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '0', :b => 'foo', :c => 'foo', :d => 'foo' :e => 'foo' } (1 valid value)" do
+          it "is valid" do
+            test.prices = { :a => '0', :b => 'foo', :c => 'foo', :d => 'foo', :e => 'foo' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '0', :b => '0', :c => 'foo', :d => 'foo' :e => 'foo' } (2 valid prices)" do
+          it "is valid" do
+            test.prices = { :a => '0', :b => '0', :c => 'foo', :d => 'foo', :e => 'foo' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '0', :b => '0', :c => '0', :d => 'foo', :e => 'foo' } (3 valid prices)" do
+          it "is valid" do
+            test.prices = { :a => '0', :b => '0', :c => '0', :d => 'foo', :e => 'foo' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '0', :b => '0', :c => '0', :d => '0', :e => 'foo' } (4 valid prices)" do
+          it "is invalid" do
+            test.prices = { :a => '0', :b => '0', :c => '0', :d => '0', :e => 'foo' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '0', :b => '0', :c => '0', :d => '0', :e => '0' } (all valid prices)" do
+          it "is invalid" do
+            test.prices = { :a => '0', :b => '0', :c => '0', :d => '0', :e => '0' }
+            expect(test.valid?).to eq false
+          end
+        end
+      end# }}}
+    end# }}}
+    context "when given :min_valid_count and :max_valid_count option" do# {{{
+      let(:test) { AnyNumericalityTestWithBothValidCount.new }
+      context "when apply to nil" do
+        it "is valid" do
+          test.prices = 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.prices = []
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to [nil, '', '   '] (all prices are nil or empty or blank)" do
+          it "is invalid" do
+            test.prices = [nil, "", "   "]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['0', 'foo', 'foo', 'foo', 'foo'] (1 valid value)" do
+          it "is invalid" do
+            test.prices = ['0', 'foo', 'foo', 'foo', 'foo']
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['0', '0', 'foo', 'foo', 'foo'] (2 valid prices)" do
+          it "is valid" do
+            test.prices = ['0', '0', 'foo', 'foo', 'foo']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['0', '0', '0', 'foo', 'foo'] (3 valid prices)" do
+          it "is valid" do
+            test.prices = ['0', '0', '0', 'foo', 'foo']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['0', '0', '0', '0', 'foo'] (4 valid prices)" do
+          it "is invalid" do
+            test.prices = ['0', '0', '0', '0', 'foo']
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['0', '0', '0', '0', '0'] (all valid prices)" do
+          it "is invalid" do
+            test.prices = ['0', '0', '0', '0', '0']
+            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.prices = {}
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => nil, :b => '', :c => '   ' } (all prices are nil or empty or blank)" do
+          it "is invalid" do
+            test.prices = { :a => nil, :b => "", :c => "   " }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '0', :b => 'foo', :c => 'foo', :d => 'foo' :e => 'foo' } (1 valid value)" do
+          it "is invalid" do
+            test.prices = { :a => '0', :b => 'foo', :c => 'foo', :d => 'foo', :e => 'foo' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '0', :b => '0', :c => 'foo', :d => 'foo' :e => 'foo' } (2 valid prices)" do
+          it "is valid" do
+            test.prices = { :a => '0', :b => '0', :c => 'foo', :d => 'foo', :e => 'foo' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '0', :b => '0', :c => '0', :d => 'foo', :e => 'foo' } (3 valid prices)" do
+          it "is valid" do
+            test.prices = { :a => '0', :b => '0', :c => '0', :d => 'foo', :e => 'foo' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '0', :b => '0', :c => '0', :d => '0', :e => 'foo' } (4 valid prices)" do
+          it "is invalid" do
+            test.prices = { :a => '0', :b => '0', :c => '0', :d => '0', :e => 'foo' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '0', :b => '0', :c => '0', :d => '0', :e => '0' } (all valid prices)" do
+          it "is invalid" do
+            test.prices = { :a => '0', :b => '0', :c => '0', :d => '0', :e => '0' }
+            expect(test.valid?).to eq false
+          end
+        end
+      end# }}}
+    end# }}}
+  end
+  describe "error message" do
+    context "when given no option" do# {{{
+      let(:test) { AnyNumericalityTest.new }
+      context "when valid" do
+        before do
+          test.prices = ['0', '0', 'foo']
+          test.valid?
+        end
+        it "has no message" do
+          expect(test.errors.present?).to eq false
+        end
+      end
+      context "when invalid" do
+        before do
+          test.prices = ['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 prices attribute" do
+          expect(test.errors.include?(:prices)).to eq true
+        end
+        it %q{error messsage is "Prices must be numeric (required number is 1-)"} do
+          expect(test.errors.full_messages.first).to eq "Prices must be numeric (required number is 1-)"
+        end
+      end
+      context "when using i18n" do
+        before do
+          @base_locale = I18n.locale
+          I18n.locale = :ja
+          test.prices = ['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 "Prices は必要数(1～)が数値でなければなりません"
+        end
+      end
+    end# }}}
+    context "when given :min_valid_count option" do# {{{
+      let(:test) { AnyNumericalityTestWithMinValidCountOnly.new }
+      context "when invalid" do
+        before do
+          test.prices = ['0', "", "   "]
+          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 prices attribute" do
+          expect(test.errors.include?(:prices)).to eq true
+        end
+        it %q{error messsage is "Prices must be numeric (required number is 2-)"} do
+          expect(test.errors.full_messages.first).to eq "Prices must be numeric (required number is 2-)"
+        end
+      end
+      context "when using i18n" do
+        before do
+          @base_locale = I18n.locale
+          I18n.locale = :ja
+          test.prices = ['0', "", "   "]
+          test.valid?
+        end
+        after do
+          I18n.locale = @base_locale
+        end
+        it "error messsage is translated" do
+          expect(test.errors.full_messages.first).to eq "Prices は必要数(2～)が数値でなければなりません"
+        end
+      end
+    end# }}}
+    context "when given :max_valid_count option" do# {{{
+      let(:test) { AnyNumericalityTestWithMaxValidCountOnly.new }
+      context "when invalid" do
+        before do
+          test.prices = ['0', '0', '0', '0', '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 prices attribute" do
+          expect(test.errors.include?(:prices)).to eq true
+        end
+        it %q{error messsage is "Prices must be numeric (required number is 1-3)"} do
+          expect(test.errors.full_messages.first).to eq "Prices must be numeric (required number is 1-3)"
+        end
+      end
+      context "when using i18n" do
+        before do
+          @base_locale = I18n.locale
+          I18n.locale = :ja
+          test.prices = ['0', '0', '0', '0', '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 "Prices は必要数(1～3)が数値でなければなりません"
+        end
+      end
+    end# }}}
+    context "when given :min_valid_count and :max_valid_count option" do# {{{
+      let(:test) { AnyNumericalityTestWithBothValidCount.new }
+      context "when invalid" do
+        before do
+          test.prices = ['0', '0', '0', '0', '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 prices attribute" do
+          expect(test.errors.include?(:prices)).to eq true
+        end
+        it %q{error messsage is "Prices must be numeric (required number is 2-3)"} do
+          expect(test.errors.full_messages.first).to eq "Prices must be numeric (required number is 2-3)"
+        end
+      end
+      context "when using i18n" do
+        before do
+          @base_locale = I18n.locale
+          I18n.locale = :ja
+          test.prices = ['0', '0', '0', '0', '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 "Prices は必要数(2～3)が数値でなければなりません"
+        end
+      end
+    end# }}}
+    context "when given message option" do# {{{
+      let(:test) { AnyNumericalityTestWithMessageOption.new }
+      context "when invalid" do
+        before do
+          test.prices = ['foo', "", "   "]
+          test.valid?
+        end
+        it "error messsage uses given message" do
+          expect(test.errors.full_messages.first).to eq 'Prices is invalid'
+        end
+      end
+      context "when using i18n" do
+        before do
+          @base_locale = I18n.locale
+          I18n.locale = :ja
+          test.prices = ['foo', "", "   "]
+          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 'Prices is invalid'
+        end
+      end
+    end# }}}
+  end
+end