anodator 0.0.5 → 1.0.0.pre1

data/spec/anodator/validator/complex_validator_spec.rb

@@ -1,268 +0,0 @@
-require "spec_helper"
-
-# Anodator::Validator::ComplexValidator
-require "anodator/validator/presence_validator"
-require "anodator/validator/complex_validator"
-
-include Anodator::Validator
-
-describe ComplexValidator, ".new" do
-  context "with no paramerters" do
-    it "should not raise error" do
-      lambda {
-        ComplexValidator.new
-      }.should_not raise_error
-    end
-  end
-
-  context "with :validators only, without :logic" do
-    before(:each) do
-      @new_proc = lambda {
-        validators = []
-        validators << PresenceValidator.new("1")
-        validators << PresenceValidator.new("3")
-        ComplexValidator.new(:validators => validators)
-      }
-    end
-
-    it "should not raise error" do
-      @new_proc.should_not raise_error
-    end
-
-    it ":logic should be ComplexValidator::LOGIC_AND" do
-      complex_validator = @new_proc.call
-      complex_validator.options[:logic].should == ComplexValidator::LOGIC_AND
-    end
-  end
-
-  context "with :validators and :and_or option" do
-    before(:each) do
-      @new_proc = lambda {
-        validators = []
-        validators << PresenceValidator.new("1")
-        validators << PresenceValidator.new("3")
-        ComplexValidator.new(:validators => validators,
-                             :logic => ComplexValidator::LOGIC_OR)
-      }
-    end
-
-    it "should not raise error" do
-      @new_proc.should_not raise_error
-    end
-
-    it ":logic should be ComplexValidator::LOGIC_OR" do
-      complex_validator = @new_proc.call
-      complex_validator.options[:logic].should == ComplexValidator::LOGIC_OR
-    end
-  end
-end
-
-describe ComplexValidator, "#valid?" do
-  context "no paramerters" do
-    before(:each) do
-      @validator = ComplexValidator.new
-      Base.values = {
-        "1" => "123",
-        "2" => "",
-        "3" => "message",
-        "5" => "value",
-      }
-    end
-
-    it "should raise error ConfigurationError" do
-      lambda {
-        @validator.valid?
-      }.should raise_error ConfigurationError
-    end
-  end
-
-  context "only :validators option" do
-    before(:each) do
-      @validator = ComplexValidator.new
-      validators = []
-      validators << PresenceValidator.new("1")
-      validators << PresenceValidator.new("3")
-      @validator = ComplexValidator.new(:validators => validators)
-    end
-
-    context "for values are valid" do
-      before(:each) do
-        Base.values = {
-          "1" => "1",
-          "2" => "",
-          "3" => "3",
-        }
-      end
-
-      it { @validator.should be_valid }
-    end
-
-    context "for values one valid, the other invalid" do
-      before(:each) do
-        Base.values = {
-          "1" => "1",
-          "2" => "",
-          "3" => "",
-        }
-      end
-
-      it { @validator.should_not be_valid }
-    end
-
-    context "for values are invalid at all values" do
-      before(:each) do
-        Base.values = {
-          "1" => "",
-          "2" => "3",
-          "3" => "",
-        }
-      end
-
-      it { @validator.should_not be_valid }
-    end
-  end
-
-  context ":validators and :logic OR option" do
-    before(:each) do
-      validators = []
-      validators << PresenceValidator.new("1")
-      validators << PresenceValidator.new("3")
-      @validator = ComplexValidator.new(:validators => validators,
-                                        :logic => ComplexValidator::LOGIC_OR)
-    end
-
-    context "for values are valid" do
-      before(:each) do
-        Base.values = {
-          "1" => "1",
-          "2" => "",
-          "3" => "3",
-        }
-      end
-
-      it { @validator.should be_valid }
-    end
-
-    context "for values one valid, the other invalid" do
-      before(:each) do
-        Base.values = {
-          "1" => "1",
-          "2" => "",
-          "3" => "",
-        }
-      end
-
-      it { @validator.should be_valid }
-    end
-
-    context "for values are invalid at all values" do
-      before(:each) do
-        Base.values = {
-          "1" => "",
-          "2" => "3",
-          "3" => "",
-        }
-      end
-
-      it { @validator.should_not be_valid }
-    end
-  end
-
-  context "for nested complex validator(A && (B || C))" do
-    before(:each) do
-      validators1, validators2 = [], []
-      validators2 << PresenceValidator.new("A")
-      validators1 << PresenceValidator.new("B")
-      validators1 << PresenceValidator.new("C")
-      validator1 = ComplexValidator.new(:validators => validators1,
-                                        :logic => ComplexValidator::LOGIC_OR)
-      validators2 << validator1
-      @validator = ComplexValidator.new(:validators => validators2,
-                                        :logic => ComplexValidator::LOGIC_AND)
-    end
-
-    context "for A(1),  B(1), C(1)" do
-      before(:each) do
-        Base.values = {
-          "A" => "1",
-          "B" => "1",
-          "C" => "1",
-        }
-      end
-
-      it { @validator.should be_valid }
-    end
-
-    context "for A(),  B(1), C(1)" do
-      before(:each) do
-        Base.values = {
-          "A" => "",
-          "B" => "1",
-          "C" => "1",
-        }
-      end
-
-      it { @validator.should_not be_valid }
-    end
-
-    context "for A(),  B(), C(1)" do
-      before(:each) do
-        Base.values = {
-          "A" => "",
-          "B" => "",
-          "C" => "1",
-        }
-      end
-
-      it { @validator.should_not be_valid }
-    end
-
-    context "for A(1),  B(), C()" do
-      before(:each) do
-        Base.values = {
-          "A" => "1",
-          "B" => "",
-          "C" => "",
-        }
-      end
-
-      it { @validator.should_not be_valid }
-    end
-
-    context "for A(1),  B(), C(1)" do
-      before(:each) do
-        Base.values = {
-          "A" => "1",
-          "B" => "",
-          "C" => "1",
-        }
-      end
-
-      it { @validator.should be_valid }
-    end
-
-    context "for A(1),  B(1), C()" do
-      before(:each) do
-        Base.values = {
-          "A" => "1",
-          "B" => "1",
-          "C" => "",
-        }
-      end
-
-      it { @validator.should be_valid }
-    end
-
-    context "for A(),  B(), C()" do
-      before(:each) do
-        Base.values = {
-          "A" => "",
-          "B" => "",
-          "C" => "",
-        }
-      end
-
-      it { @validator.should_not be_valid }
-    end
-  end
-end

data/spec/anodator/validator/date_validator_spec.rb

@@ -1,350 +0,0 @@
-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.value.should == Date.new(1980, 1, 25)
-      end
-
-      it "#to should be 2011-01-01" do
-        @new_proc.call.to.value.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.value.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.value.should be_a Date
-    end
-
-    it "#from should be same date for string expression" do
-      @new_proc.call.from.value.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.value.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.value.should be_a Date
-    end
-
-    it "#to should be same date for string expression" do
-      @new_proc.call.to.value.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