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

@@ -0,0 +1,137 @@
+# coding: utf-8
+require "spec_helper"
+require "active_support/i18n"
+require "test_class/all_exclusion_test"
+describe Detox::Validations::AllExclusionValidator do
+  describe "validation result" do
+    let(:test) { AllExclusionTest.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
+    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
+    end
+  end
+  describe "error message" do
+    context "when without message option" do
+      let(:test) { AllExclusionTest.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 included in the list"} do
+          expect(test.errors.full_messages.first).to eq "Values contains value that is 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) { AllExclusionTestWithMessageOption.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_format_spec.rb ADDED

@@ -0,0 +1,351 @@
+# coding: utf-8
+require "spec_helper"
+require "active_support/i18n"
+require "test_class/all_format_test"
+describe Detox::Validations::AllFormatValidator do
+  describe "validation result (pattern is /\\A\\w+\\z/)" do
+    context "when given no additional option" do# {{{
+      let(:test) { AllFormatTest.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 ['foo', 'bar', 'baz'] (valid values)" do
+          it "is valid" do
+            test.words = ["foo", "bar", "baz"]
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['foo', 'bar', 'b@z'] (contains invalid word)" do
+          it "is invalid" do
+            test.words = ["foo", "bar", "b@z"]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['foo', 'bar', nil] (contains nil)" do
+          it "is invalid" do
+            test.words = ["foo", "bar", nil]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['foo', 'bar', ''] (contains empty)" do
+          it "is invalid" do
+            test.words = ["foo", "bar", ""]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['foo', 'bar', '   '] (contains blank)" do
+          it "is invalid" do
+            test.words = ["foo", "bar", "   "]
+            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 => 'foo', :b => 'bar', :c => 'baz' } (valid values)" do
+          it "is valid" do
+            test.words = { :a => 'foo', :b => 'bar', :c => 'baz' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'bar', :c => 'b@z' } (contains invalid word)" do
+          it "is invalid" do
+            test.words = { :a => 'foo', :b => 'bar', :c => 'b@z' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'bar', :c => nil } (contains nil)" do
+          it "is invalid" do
+            test.words = { :a => 'foo', :b => 'bar', :c => nil }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'bar', :c => '' } (contains empty)" do
+          it "is invalid" do
+            test.words = { :a => 'foo', :b => 'bar', :c => '' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'bar', :c => '   ' } (contains blank)" do
+          it "is invalid" do
+            test.words = { :a => 'foo', :b => 'bar', :c => '   ' }
+            expect(test.valid?).to eq false
+          end
+        end
+      end# }}}
+    end# }}}
+    context "when given ignore_nil_value option" do# {{{
+      let(:test) { AllFormatTestWithIgnoreNilValueOption.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 ['foo', 'bar', 'baz'] (valid values)" do
+          it "is valid" do
+            test.words = ["foo", "bar", "baz"]
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['foo', 'bar', 'b@z'] (contains invalid word)" do
+          it "is invalid" do
+            test.words = ["foo", "bar", "b@z"]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['foo', 'bar', nil] (contains nil)" do
+          it "is valid" do
+            test.words = ["foo", "bar", nil]
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['foo', 'bar', ''] (contains empty)" do
+          it "is invalid" do
+            test.words = ["foo", "bar", ""]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['foo', 'bar', '   '] (contains blank)" do
+          it "is invalid" do
+            test.words = ["foo", "bar", "   "]
+            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 => 'foo', :b => 'bar', :c => 'baz' } (valid values)" do
+          it "is valid" do
+            test.words = { :a => 'foo', :b => 'bar', :c => 'baz' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'bar', :c => 'b@z' } (contains invalid word)" do
+          it "is invalid" do
+            test.words = { :a => 'foo', :b => 'bar', :c => 'b@z' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'bar', :c => nil } (contains nil)" do
+          it "is valid" do
+            test.words = { :a => 'foo', :b => 'bar', :c => nil }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'bar', :c => '' } (contains empty)" do
+          it "is invalid" do
+            test.words = { :a => 'foo', :b => 'bar', :c => '' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'bar', :c => '   ' } (contains blank)" do
+          it "is invalid" do
+            test.words = { :a => 'foo', :b => 'bar', :c => '   ' }
+            expect(test.valid?).to eq false
+          end
+        end
+      end# }}}
+    end# }}}
+    context "when given ignore_blank_value option" do# {{{
+      let(:test) { AllFormatTestWithIgnoreBlankValueOption.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 ['foo', 'bar', 'baz'] (valid values)" do
+          it "is valid" do
+            test.words = ["foo", "bar", "baz"]
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['foo', 'bar', 'b@z'] (contains invalid word)" do
+          it "is invalid" do
+            test.words = ["foo", "bar", "b@z"]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['foo', 'bar', nil] (contains nil)" do
+          it "is valid" do
+            test.words = ["foo", "bar", nil]
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['foo', 'bar', ''] (contains empty)" do
+          it "is valid" do
+            test.words = ["foo", "bar", ""]
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['foo', 'bar', '   '] (contains blank)" do
+          it "is valid" do
+            test.words = ["foo", "bar", "   "]
+            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 => 'foo', :b => 'bar', :c => 'baz' } (valid values)" do
+          it "is valid" do
+            test.words = { :a => 'foo', :b => 'bar', :c => 'baz' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'bar', :c => 'b@z' } (contains invalid word)" do
+          it "is invalid" do
+            test.words = { :a => 'foo', :b => 'bar', :c => 'b@z' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'bar', :c => nil } (contains nil)" do
+          it "is valid" do
+            test.words = { :a => 'foo', :b => 'bar', :c => nil }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'bar', :c => '' } (contains empty)" do
+          it "is valid" do
+            test.words = { :a => 'foo', :b => 'bar', :c => '' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => 'foo', :b => 'bar', :c => '   ' } (contains blank)" do
+          it "is valid" do
+            test.words = { :a => 'foo', :b => 'bar', :c => '   ' }
+            expect(test.valid?).to eq true
+          end
+        end
+      end# }}}
+    end# }}}
+  end
+  describe "error message" do
+    context "when witout message option" do# {{{
+      let(:test) { AllFormatTest.new }
+      context "when valid" do
+        before do
+          test.words = ['foo', 'bar', 'baz']
+          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 = ['foo', 'bar', 'b@z']
+          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 "error messsage is 'Words contains invalid format value'" do
+          expect(test.errors.full_messages.first).to eq "Words contains invalid format value"
+        end
+      end
+      context "when using i18n" do
+        before do
+          @base_locale = I18n.locale
+          I18n.locale = :ja
+          test.words = ['foo', 'bar', 'b@z']
+          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 には不正な形式の値が含まれています"
+        end
+      end
+    end# }}}
+    context "when given message option" do# {{{
+      let(:test) { AllFormatTestWithMessageOption.new }
+      context "when invalid" do
+        before do
+          test.words = ['foo', 'bar', 'b@z']
+          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 = ['foo', 'bar', 'b@z']
+          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