anodator 0.0.1

data/spec/anodator/validator/date_validator_spec.rb

@@ -0,0 +1,350 @@
+require "spec_helper"
+
+# Anodator::Validator::DateValidator
+require "anodator/validator/date_validator"
+
+include Anodator::Validator
+
+describe DateValidator, ".new" do
+  context "with no parameters" do
+    it "should raise ArgumentError" do
+      lambda {
+        DateValidator.new
+      }.should raise_error ArgumentError
+    end
+  end
+
+  context "with only target expression" do
+    before(:each) do
+      @new_proc = lambda {
+        DateValidator.new("1")
+      }
+    end
+
+    it "should not raise error" do
+      @new_proc.should_not raise_error
+    end
+
+    it { @new_proc.call.format.should == "YYYY-MM-DD" }
+  end
+
+  context "with target expression and :format option" do
+    context ":format option is valid" do
+      before(:each) do
+        @new_proc = lambda {
+          DateValidator.new("1", :format => "YYYY/MM/DD")
+        }
+      end
+
+      it "should not raise error" do
+        @new_proc.should_not raise_error
+      end
+
+      context "and :from same format" do
+        before(:each) do
+          @new_proc = lambda {
+            DateValidator.new("1", :format => "YYYY/MM/DD", :from => "2011/01/01")
+          }
+        end
+
+        it "should not raise error" do
+          @new_proc.should_not raise_error
+        end
+      end
+    end
+
+    context ":format option contains double YYYY is invalid" do
+      before(:each) do
+        @new_proc = lambda {
+          DateValidator.new("1", :format => "YYYY/MM-DD YYYY")
+        }
+      end
+
+      it "should raise ArgumentError" do
+        @new_proc.should raise_error ArgumentError
+      end
+    end
+
+    context ":format option not contains D is invalid" do
+      before(:each) do
+        @new_proc = lambda {
+          DateValidator.new("1", :format => "YY/M")
+        }
+      end
+
+      it "should raise ArgumentError" do
+        @new_proc.should raise_error ArgumentError
+      end
+    end
+
+    context "when :format option contains short year with based on 1900" do
+      before(:each) do
+        @new_proc = lambda {
+          DateValidator.new("Birthday",
+                            :format => "M/D/YY", :base_year => 1900,
+                            :from => "1/25/80", :to => Date.new(2011, 1, 1))
+        }
+      end
+
+      it "should not raise error" do
+        @new_proc.should_not raise_error
+      end
+
+      it "#from should be 1980-01-25" do
+        @new_proc.call.from.should == Date.new(1980, 1, 25)
+      end
+
+      it "#to should be 2011-01-01" do
+        @new_proc.call.to.should == Date.new(2011, 1, 1)
+      end
+    end
+  end
+
+  context "with target expression and :from option with Date object" do
+    before(:each) do
+      @new_proc = lambda {
+        DateValidator.new("1", :from => Date.new(2011, 1, 1))
+      }
+    end
+
+    it "should not raise error" do
+      @new_proc.should_not raise_error
+    end
+
+    it "#from should be date object" do
+      @new_proc.call.from.should be_a Date
+    end
+  end
+
+  context "with target expression and :from option with String object" do
+    before(:each) do
+      @new_proc = lambda {
+        DateValidator.new("1", :from => "2011-01-01")
+      }
+    end
+
+    it "should not raise error" do
+      @new_proc.should_not raise_error
+    end
+
+    it "#from should be date object" do
+      @new_proc.call.from.should be_a Date
+    end
+
+    it "#from should be same date for string expression" do
+      @new_proc.call.from.should == Date.new(2011, 1, 1)
+    end
+  end
+
+  context "with target expression and :from option with invalid format date String object" do
+    before(:each) do
+      @new_proc = lambda {
+        DateValidator.new("1", :from => "2011-01-34")
+      }
+    end
+
+    it "should raise ArgumentError" do
+      @new_proc.should raise_error ArgumentError
+    end
+  end
+
+  context "with target expression and :to option with Date object" do
+    before(:each) do
+      @new_proc = lambda {
+        DateValidator.new("1", :to => Date.new(2011, 1, 1))
+      }
+    end
+
+    it "should not raise error" do
+      @new_proc.should_not raise_error
+    end
+
+    it "#to should be date object" do
+      @new_proc.call.to.should be_a Date
+    end
+  end
+
+  context "with target expression and :to option with String object" do
+    before(:each) do
+      @new_proc = lambda {
+        DateValidator.new("1", :to => "2011-01-01")
+      }
+    end
+
+    it "should not raise error" do
+      @new_proc.should_not raise_error
+    end
+
+    it "#to should be date object" do
+      @new_proc.call.to.should be_a Date
+    end
+
+    it "#to should be same date for string expression" do
+      @new_proc.call.to.should == Date.new(2011, 1, 1)
+    end
+  end
+
+  context "with target expression and :to option with invalid format date String object" do
+    before(:each) do
+      @new_proc = lambda {
+        DateValidator.new("1", :to => "2011-01-34")
+      }
+    end
+
+    it "should raise ArgumentError" do
+      @new_proc.should raise_error ArgumentError
+    end
+  end
+end
+
+describe DateValidator, "#valid?" do
+  context "with only target expression" do
+    before(:each) do
+      @validator = DateValidator.new("1")
+    end
+
+    context "invalid date expression" do
+      before(:each) do
+        Validator::Base.values = { "1" => "2011-34-42" }
+      end
+
+      it { @validator.should_not be_valid }
+    end
+
+    context "valid date expression" do
+      before(:each) do
+        Validator::Base.values = { "1" => "2011-04-02" }
+      end
+
+      it { @validator.should be_valid }
+    end
+  end
+
+  context "with target expression and :from option" do
+    before(:each) do
+      @validator = DateValidator.new("1", :from => "2011-04-01")
+    end
+
+    context "invalid date expression" do
+      before(:each) do
+        Validator::Base.values = { "1" => "2011-34-42" }
+      end
+
+      it { @validator.should_not be_valid }
+    end
+
+    context "invalid date by :from option" do
+      before(:each) do
+        Validator::Base.values = { "1" => "2011-03-31" }
+      end
+
+      it { @validator.should_not be_valid }
+    end
+
+    context "valid date by :from option" do
+      before(:each) do
+        Validator::Base.values = { "1" => "2011-04-01" }
+      end
+
+      it { @validator.should be_valid }
+    end
+  end
+
+  context "with target expression and :to option" do
+    before(:each) do
+      @validator = DateValidator.new("1", :to => "2011-04-01")
+    end
+
+    context "invalid date expression" do
+      before(:each) do
+        Validator::Base.values = { "1" => "2011-34-42" }
+      end
+
+      it { @validator.should_not be_valid }
+    end
+
+    context "invalid date by :to option" do
+      before(:each) do
+        Validator::Base.values = { "1" => "2011-04-02" }
+      end
+
+      it { @validator.should_not be_valid }
+    end
+
+    context "valid date by :to option" do
+      before(:each) do
+        Validator::Base.values = { "1" => "2011-04-01" }
+      end
+
+      it { @validator.should be_valid }
+    end
+  end
+
+  context "with target expression and :to and :from option" do
+    before(:each) do
+      @validator = DateValidator.new("1", :from => "2010-04-01", :to => "2011-03-31")
+    end
+
+    context "invalid date expression" do
+      before(:each) do
+        Validator::Base.values = { "1" => "2011-34-42" }
+      end
+
+      it { @validator.should_not be_valid }
+    end
+
+    context "invalid date by :from option" do
+      before(:each) do
+        Validator::Base.values = { "1" => "2010-03-31" }
+      end
+
+      it { @validator.should_not be_valid }
+    end
+
+    context "invalid date by :to option" do
+      before(:each) do
+        Validator::Base.values = { "1" => "2011-04-01" }
+      end
+
+      it { @validator.should_not be_valid }
+    end
+
+    context "valid date by :from and :to option" do
+      before(:each) do
+        Validator::Base.values = { "1" => "2010-05-31" }
+      end
+
+      it { @validator.should be_valid }
+    end
+  end
+
+  context "with target expression with :allow_blank => true" do
+    before(:each) do
+      @validator = DateValidator.new("1", :allow_blank => true)
+    end
+
+    context "invalid date expression" do
+      before(:each) do
+        Validator::Base.values = { "1" => "2011-34-42" }
+      end
+
+      it { @validator.should_not be_valid }
+    end
+
+    context "valid date expression" do
+      before(:each) do
+        Validator::Base.values = { "1" => "2011-04-02" }
+      end
+
+      it { @validator.should be_valid }
+    end
+
+    context "blank value" do
+      before(:each) do
+        Validator::Base.values = { "1" => "" }
+      end
+
+      it { @validator.should be_valid }
+    end
+  end
+end

data/spec/anodator/validator/format_validator_spec.rb

@@ -0,0 +1,158 @@
+require "spec_helper"
+
+# Anodator::Validator::FormatValidator
+require "anodator/validator/format_validator"
+
+describe Anodator::Validator::FormatValidator, ".new" do
+  context "with no parameters" do
+    it "should raise ArgumentError" do
+      lambda {
+        Anodator::Validator::FormatValidator.new
+      }.should raise_error ArgumentError
+    end
+  end
+
+  context "with only target parameter" do
+    before(:each) do
+      @validator_new_proc = lambda {
+        Anodator::Validator::FormatValidator.new("1")
+      }
+    end
+
+    it "should not raise error" do
+      @validator_new_proc.should_not raise_error ArgumentError
+    end
+  end
+
+  context "with target parameter and :format option" do
+    it "should not raise error" do
+      lambda {
+        Anodator::Validator::FormatValidator.new("1", :format => /^\d+$/)
+      }.should_not raise_error
+    end
+  end
+
+  context "with target parameter and :format option by string" do
+    it "should not raise error" do
+      lambda {
+        Anodator::Validator::FormatValidator.new("1", :format => '\d+')
+      }.should_not raise_error
+    end
+
+    it "should :format to regexp option" do
+      Anodator::Validator::FormatValidator.new("1", :format => '\d+').format.should == /\d+/
+    end
+  end
+end
+
+describe Anodator::Validator::FormatValidator, "#valid?" do
+  context "without :format option" do
+    before(:each) do
+      @validator =
+        Anodator::Validator::FormatValidator.new("1", :allow_blank => false)
+    end
+
+    it "should raise error" do
+      lambda {
+        @validator.valid?
+      }.should raise_error ConfigurationError
+    end
+  end
+
+  context "for digit string with no blank" do
+    before(:each) do
+      @validator =
+        Anodator::Validator::FormatValidator.new("1",
+                                                 :format => /^\d+$/,
+                                                 :allow_blank => false)
+    end
+
+    context "target value is blank" do
+      before(:each) do
+        Anodator::Validator::Base.values = { "1" => "" }
+      end
+
+      it { @validator.should_not be_valid }
+    end
+
+    context "target value is '1'" do
+      before(:each) do
+        Anodator::Validator::Base.values = { "1" => "1" }
+      end
+
+      it { @validator.should be_valid }
+    end
+
+    context "target value is 'some message'" do
+      before(:each) do
+        Anodator::Validator::Base.values = { "1" => "some message" }
+      end
+
+      it { @validator.should_not be_valid }
+    end
+  end
+
+  context "for digit string with allow blank" do
+    before(:each) do
+      @validator =
+        Anodator::Validator::FormatValidator.new("1",
+                                                 :format => /^\d+$/,
+                                                 :allow_blank => true)
+    end
+
+    context "target value is blank" do
+      before(:each) do
+        Anodator::Validator::Base.values = { "1" => "" }
+      end
+
+      it { @validator.should be_valid }
+    end
+
+    context "target value is '1'" do
+      before(:each) do
+        Anodator::Validator::Base.values = { "1" => "1" }
+      end
+
+      it { @validator.should be_valid }
+    end
+
+    context "target value is 'some message'" do
+      before(:each) do
+        Anodator::Validator::Base.values = { "1" => "some message" }
+      end
+
+      it { @validator.should_not be_valid }
+    end
+  end
+
+  context "for postal code with not allow blank" do
+    before(:each) do
+      @validator = Anodator::Validator::FormatValidator.new("postal_code",
+                                                            :format => /^\d{3}-\d{4}$/)
+    end
+
+    context "target value is valid" do
+      before(:each) do
+        Anodator::Validator::Base.values = { "postal_code" => "123-1234" }
+      end
+
+      it { @validator.should be_valid }
+    end
+
+    context "target value is blank" do
+      before(:each) do
+        Anodator::Validator::Base.values = { "postal_code" => "" }
+      end
+
+      it { @validator.should_not be_valid }
+    end
+
+    context "target value is invalid" do
+      before(:each) do
+        Anodator::Validator::Base.values = { "postal_code" => "1234567" }
+      end
+
+      it { @validator.should_not be_valid }
+    end
+  end
+end

data/spec/anodator/validator/inclusion_validator_spec.rb

@@ -0,0 +1,77 @@
+require "spec_helper"
+
+# Anodator::Validator::InclusionValidator
+require "anodator/validator/inclusion_validator"
+
+include Anodator::Validator
+
+describe InclusionValidator, ".new" do
+  context "with no parameters" do
+    it "should raise ArgumentError" do
+      lambda {
+        InclusionValidator.new
+      }.should raise_error ArgumentError
+    end
+  end
+
+  context "with only target parameter" do
+    it "should not raise error" do
+      lambda {
+        InclusionValidator.new("1")
+      }.should_not raise_error
+    end
+  end
+
+  context "with target expression and :in paramerter" do
+    before(:each) do
+      @new_proc = lambda {
+        InclusionValidator.new("1", :in => ["A", "B", "C"])
+      }
+    end
+
+    it "should not raise error" do
+      @new_proc.should_not raise_error
+    end
+
+    it ":in option must have parameter values" do
+      validator = @new_proc.call
+      validator.options[:in].should == ["A", "B", "C"]
+    end
+  end
+end
+
+describe InclusionValidator, "#valid?" do
+  context "with only target parameter" do
+    before(:each) do
+      @validator = InclusionValidator.new("1")
+    end
+
+    it "should raise error" do
+      lambda {
+        @validator.valid?
+      }.should raise_error ConfigurationError
+    end
+  end
+
+  context "with target expression and :in paramerter" do
+    before(:each) do
+      @validator = InclusionValidator.new("1", :in => ["A", "B", "C"])
+    end
+
+    context "values for valid" do
+      before(:each) do
+        Base.values = { "1" => "A" }
+      end
+
+      it { @validator.should be_valid }
+    end
+
+    context "values for invalid" do
+      before(:each) do
+        Base.values = { "1" => "D" }
+      end
+
+      it { @validator.should_not be_valid }
+    end
+  end
+end