detox 1.0.0

data/lib/detox/version.rb

@@ -0,0 +1,4 @@
+# coding: utf-8
+module Detox
+  VERSION = "1.0.0"
+end

data/spec/detox/array_validity_spec.rb

@@ -0,0 +1,214 @@
+# coding: utf-8
+require "spec_helper"
+require "test_class/array_validity_test"
+
+describe Detox::ArrayValidity do
+  let(:test) { ArrayValidityTest.new }
+
+  describe "#convert_to_validatee" do
+    context "without option" do# {{{
+      context "when given Array" do
+        let(:actual) { test.convert_to_validatee(["1", nil, "2", "", "3", "  "]) }
+
+        it "returns itself" do
+          expect(actual).to eq ["1", nil, "2", "", "3", "  "]
+        end
+      end
+
+      context "when given Hash" do
+        let(:actual) { test.convert_to_validatee({ :a => "1", :b => nil, :c => "2" , :d => "", :e => "3", :f => "  "}) }
+
+        it "returns Array that contains given Hash values" do
+          expect(actual).to eq ["1", nil, "2", "", "3", "  "]
+        end
+      end
+
+      context "when given nil" do
+        let(:actual) { test.convert_to_validatee(nil) }
+
+        it "returns empty Array" do
+          expect(actual).to eq []
+        end
+      end
+
+      context "when given other data" do
+        context "when data is not blank" do
+        let(:actual) { test.convert_to_validatee("data") }
+
+          it "returns Array that has given data only" do
+            expect(actual).to eq ["data"]
+          end
+        end
+        context "when data is empty" do
+          let(:actual) { test.convert_to_validatee("") }
+
+          it "returns empty Array that has empty data only" do
+            expect(actual).to eq [""]
+          end
+        end
+        context "when data is blank" do
+          let(:actual) { test.convert_to_validatee("  ") }
+
+          it "returns Array that has given blank data only" do
+            expect(actual).to eq ["  "]
+          end
+        end
+      end
+    end# }}}
+
+    context "with ignore_nil_value option" do# {{{
+      let(:options) { { :ignore_nil_value => true } }
+      context "when given Array" do
+        let(:actual) { test.convert_to_validatee(["1", nil, "2", "", "3", "  "], options) }
+
+        it "returns Array that removed nil" do
+          expect(actual).to eq ["1", "2", "", "3", "  "]
+        end
+      end
+
+      context "when given Hash" do
+        let(:actual) { test.convert_to_validatee({ :a => "1", :b => nil, :c => "2" , :d => "", :e => "3", :f => "  "}, options) }
+
+        it "returns Array that contains given Hash not nil values" do
+          expect(actual).to eq ["1", "2", "", "3", "  "]
+        end
+      end
+
+      context "when given nil" do
+        let(:actual) { test.convert_to_validatee(nil, options) }
+
+        it "returns empty Array" do
+          expect(actual).to eq []
+        end
+      end
+
+      context "when given other data" do
+        context "when data is not blank" do
+          let(:actual) { test.convert_to_validatee("data", options) }
+
+          it "returns Array that has given data only" do
+            expect(actual).to eq ["data"]
+          end
+        end
+        context "when data is empty" do
+          let(:actual) { test.convert_to_validatee("", options) }
+
+          it "returns Array that has empty data only" do
+            expect(actual).to eq [""]
+          end
+        end
+        context "when data is blank" do
+          let(:actual) { test.convert_to_validatee("  ", options) }
+
+          it "returns Array that has given blank data only" do
+            expect(actual).to eq ["  "]
+          end
+        end
+      end
+    end# }}}
+
+    context "with ignore_blank_value option" do# {{{
+      let(:options) { { :ignore_blank_value => true } }
+
+      context "when given Array" do
+        let(:actual) { test.convert_to_validatee(["1", nil, "2", "", "3", "  "], options) }
+
+        it "returns Array that removed blank values" do
+          expect(actual).to eq ["1", "2", "3"]
+        end
+      end
+
+      context "when given Hash" do
+        let(:actual) { test.convert_to_validatee({ :a => "1", :b => nil, :c => "2" , :d => "", :e => "3", :f => "  "}, options) }
+
+        it "returns Array that contains given Hash not blank values" do
+          expect(actual).to eq ["1", "2", "3"]
+        end
+      end
+
+      context "when given nil" do
+        let(:actual) { test.convert_to_validatee(nil, options) }
+
+        it "returns empty Array" do
+          expect(actual).to eq []
+        end
+      end
+
+      context "when given other data" do
+        context "when data is not blank" do
+          let(:actual) { test.convert_to_validatee("data", options) }
+
+          it "returns Array that has given data only" do
+            expect(actual).to eq ["data"]
+          end
+        end
+        context "when data is empty" do
+          let(:actual) { test.convert_to_validatee("", options) }
+
+          it "returns empty Array" do
+            expect(actual).to eq []
+          end
+        end
+        context "when data is blank" do
+          let(:actual) { test.convert_to_validatee("  ", options) }
+
+          it "returns empty Array" do
+            expect(actual).to eq []
+          end
+        end
+      end
+    end# }}}
+
+    context "with option that value is false" do# {{{
+      let(:options) { { :ignore_nil_value => false, :ignore_blank_value => false } }
+
+      context "when given Array" do
+        let(:actual) { test.convert_to_validatee(["1", nil, "2", "", "3", "  "]) }
+
+        it "returns itself" do
+          expect(actual).to eq ["1", nil, "2", "", "3", "  "]
+        end
+      end
+
+      context "when given Hash" do
+        let(:actual) { test.convert_to_validatee({ :a => "1", :b => nil, :c => "2" , :d => "", :e => "3", :f => "  "}) }
+
+        it "returns Array that contains given Hash values" do
+          expect(actual).to eq ["1", nil, "2", "", "3", "  "]
+        end
+      end
+
+      context "when given nil" do
+        let(:actual) { test.convert_to_validatee(nil) }
+
+        it "returns empty Array" do
+          expect(actual).to eq []
+        end
+      end
+
+      context "when given other data" do
+        context "when data is not blank" do
+          let(:actual) { test.convert_to_validatee("data") }
+
+          it "returns Array that has given data only" do
+            expect(actual).to eq ["data"]
+          end
+        end
+        context "when data is empty" do
+          let(:actual) { test.convert_to_validatee("") }
+
+          it "returns empty Array that has empty data only" do
+            expect(actual).to eq [""]
+          end
+        end
+        context "when data is not blank" do
+          let(:actual) { test.convert_to_validatee("  ") }
+
+          it "returns Array that has given blank data only" do
+            expect(actual).to eq ["  "]
+          end
+        end
+      end
+    end# }}}
+  end
+end

data/spec/detox/validations/all_absence_spec.rb

@@ -0,0 +1,147 @@
+# coding: utf-8
+require "spec_helper"
+require "active_support/i18n"
+require "test_class/all_absence_test"
+
+describe Detox::Validations::AllAbsenceValidator do
+  describe "validation result" do
+    let(:test) { AllAbsenceTest.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 [nil, nil, nil] (only nil)" do
+        it "is valid" do
+          test.values = [nil, nil, nil]
+          expect(test.valid?).to eq true
+        end
+      end
+      context "when apply to [nil, '', '   '] (nil, empty, blank)" do
+        it "is valid" do
+          test.values = [nil, "", "   "]
+          expect(test.valid?).to eq true
+        end
+      end
+      context "when apply to [nil, '', '   ', '4'] (contains not blank value)" do
+        it "is invalid" do
+          test.values = [nil, "", "   ", "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 => nil, :b => nil, :c => nil } (only nil)" do
+        it "is valid" do
+          test.values = { :a => nil, :b => nil, :c => nil }
+          expect(test.valid?).to eq true
+        end
+      end
+      context "when apply to { :a => nil, :b => '', :c => '   ' } (only nil)" do
+        it "is valid" do
+          test.values = { :a => nil, :b => "", :c => "   " }
+          expect(test.valid?).to eq true
+        end
+      end
+      context "when apply to { :a => nil, :b => '', :c => '   ', :d => '4' } (contains not blank value)" do
+        it "is invalid" do
+          test.values = { :a => nil, :b => "", :c => "   ", :d => "4"}
+          expect(test.valid?).to eq false
+        end
+      end
+    end
+  end
+
+  describe "error message" do
+    context "when without message option" do# {{{
+      let(:test) { AllAbsenceTest.new }
+
+      context "when valid" do
+        before do
+          test.values = [nil, "", "   "]
+          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 = [nil, "", "1"]
+          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 can't contain not blank value"} do
+          expect(test.errors.full_messages.first).to eq "Values can't contain not blank value"
+        end
+      end
+      context "when using i18n" do
+        before do
+          @base_locale = I18n.locale
+          I18n.locale = :ja
+          test.values = [nil, "", "1"]
+          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) { AllAbsenceTestWithMessageOption.new }
+
+      context "when invalid" do
+        before do
+          test.values = [nil, "", "1"]
+          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 = [nil, "", "1"]
+          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_acceptance_spec.rb

@@ -0,0 +1,352 @@
+# coding: utf-8
+require "spec_helper"
+require "active_support/i18n"
+require "test_class/all_acceptance_test"
+
+describe Detox::Validations::AllAcceptanceValidator do
+  describe "validation result" do
+    context "when given no additional option" do# {{{
+      let(:test) { AllAcceptanceTest.new }
+
+      context "when apply to nil" do
+        it "is valid" do
+          test.flags = 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.flags = []
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '1', '1'] (valid flags)" do
+          it "is valid" do
+            test.flags = ["1", "1", "1"]
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '1', '4'] (contains invalid value)" do
+          it "is invalid" do
+            test.flags = ["1", "1", "4"]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['1', '1', nil] (contains nil)" do
+          it "is valid" do
+            test.flags = ['1', '1', nil]
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '1', ''] (contains empty)" do
+          it "is invalid" do
+            test.flags = ['1', '1', '']
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['1', '1', '   '] (contains blank)" do
+          it "is invalid" do
+            test.flags = ['1', '1', '   ']
+            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.flags = {}
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '1', :c => '1' } (valid flags)" do
+          it "is valid" do
+            test.flags = { :a => '1', :b => '1', :c => '1' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '1', :c => '4' } (contains invalid value)" do
+          it "is invalid" do
+            test.flags = { :a => '1', :b => '1', :c => '4' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '1', :b => '1', :c => nil } (contains nil)" do
+          it "is valid" do
+            test.flags = { :a => '1', :b => '1', :c => nil }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '1', :c => '' } (contains empty)" do
+          it "is invalid" do
+            test.flags = { :a => '1', :b => '1', :c => '' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '1', :b => '1', :c => '   ' } (contains blank)" do
+          it "is invalid" do
+            test.flags = { :a => '1', :b => '1', :c => '   ' }
+            expect(test.valid?).to eq false
+          end
+        end
+      end# }}}
+    end# }}}
+
+    context "when given ignore_nil_value option" do# {{{
+      let(:test) { AllAcceptanceTestWithIgnoreNilValueOption.new }
+
+      context "when apply to nil" do
+        it "is valid" do
+          test.flags = 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.flags = []
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '1', '1'] (valid flags)" do
+          it "is valid" do
+            test.flags = ["1", "1", "1"]
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '1', '4'] (contains invalid flags)" do
+          it "is invalid" do
+            test.flags = ["1", "1", "4"]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['1', '1', nil] (contains nil)" do
+          it "is valid" do
+            test.flags = ['1', '1', nil]
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '1', ''] (contains empty)" do
+          it "is invalid" do
+            test.flags = ['1', '1', '']
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['1', '1', '   '] (contains blank)" do
+          it "is invalid" do
+            test.flags = ['1', '1', '   ']
+            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.flags = {}
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '1', :c => '1' } (valid flags)" do
+          it "is valid" do
+            test.flags = { :a => '1', :b => '1', :c => '1' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '1', :c => '4' } (contains invalid flags)" do
+          it "is invalid" do
+            test.flags = { :a => '1', :b => '1', :c => '4' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '1', :b => '1', :c => nil } (contains nil)" do
+          it "is valid" do
+            test.flags = { :a => '1', :b => '1', :c => nil }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '1', :c => '' } (contains empty)" do
+          it "is invalid" do
+            test.flags = { :a => '1', :b => '1', :c => '' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '1', :b => '1', :c => '   ' } (contains blank)" do
+          it "is invalid" do
+            test.flags = { :a => '1', :b => '1', :c => '   ' }
+            expect(test.valid?).to eq false
+          end
+        end
+      end# }}}
+    end# }}}
+
+    context "when given ignore_blank_value option" do# {{{
+      let(:test) { AllAcceptanceTestWithIgnoreBlankValueOption.new }
+
+      context "when apply to nil" do
+        it "is valid" do
+          test.flags = 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.flags = []
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '1', '1'] (valid flags)" do
+          it "is valid" do
+            test.flags = ["1", "1", "1"]
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '1', '4'] (contains invalid flags)" do
+          it "is invalid" do
+            test.flags = ["1", "1", "4"]
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to ['1', '1', nil] (contains nil)" do
+          it "is valid" do
+            test.flags = ['1', '1', nil]
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '1', ''] (contains empty)" do
+          it "is valid" do
+            test.flags = ['1', '1', '']
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to ['1', '1', '   '] (contains blank)" do
+          it "is valid" do
+            test.flags = ['1', '1', '   ']
+            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.flags = {}
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '1', :c => '1' } (valid flags)" do
+          it "is valid" do
+            test.flags = { :a => '1', :b => '1', :c => '1' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '1', :c => '4' } (contains invalid flags)" do
+          it "is invalid" do
+            test.flags = { :a => '1', :b => '1', :c => '4' }
+            expect(test.valid?).to eq false
+          end
+        end
+        context "when apply to { :a => '1', :b => '1', :c => nil } (contains nil)" do
+          it "is valid" do
+            test.flags = { :a => '1', :b => '1', :c => nil }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '1', :c => '' } (contains empty)" do
+          it "is valid" do
+            test.flags = { :a => '1', :b => '1', :c => '' }
+            expect(test.valid?).to eq true
+          end
+        end
+        context "when apply to { :a => '1', :b => '1', :c => '   ' } (contains blank)" do
+          it "is valid" do
+            test.flags = { :a => '1', :b => '1', :c => '   ' }
+            expect(test.valid?).to eq true
+          end
+        end
+      end# }}}
+    end# }}}
+  end
+
+  describe "error message" do
+    context "when without message option" do# {{{
+      let(:test) { AllAcceptanceTest.new }
+
+      context "when valid" do
+        before do
+          test.flags = ['1', '1', '1']
+          test.valid?
+        end
+
+        it "has no message" do
+          expect(test.errors.present?).to eq false
+        end
+      end
+      context "when invalid" do
+        before do
+          test.flags = ['1', '1', '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 flags attribute" do
+          expect(test.errors.include?(:flags)).to eq true
+        end
+        it %q{error messsage is "Flags must be all accepted"} do
+          expect(test.errors.full_messages.first).to eq "Flags must be all accepted"
+        end
+      end
+      context "when using i18n" do
+        before do
+          @base_locale = I18n.locale
+          I18n.locale = :ja
+          test.flags = ['1', '1', '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 "Flags を全て承諾してください"
+        end
+      end
+    end# }}}
+
+    context "when given message option" do# {{{
+      let(:test) { AllAcceptanceTestWithMessageOption.new }
+
+      context "when invalid" do
+        before do
+          test.flags = ['1', '1', '4']
+          test.valid?
+        end
+        it "error messsage uses given message" do
+          expect(test.errors.full_messages.first).to eq 'Flags is invalid'
+        end
+      end
+      context "when using i18n" do
+        before do
+          @base_locale = I18n.locale
+          I18n.locale = :ja
+          test.flags = ['1', '1', '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 'Flags is invalid'
+        end
+      end
+    end# }}}
+  end
+end
+