anodator 0.0.5 → 1.0.0.pre1

data/spec/anodator/validator/format_validator_spec.rb

@@ -1,158 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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

data/spec/anodator/validator/length_validator_spec.rb

@@ -1,236 +0,0 @@
-require "spec_helper"
-
-# Anodator::Validator::LengthValidator
-require "anodator/validator/length_validator"
-
-include Anodator::Validator
-
-describe LengthValidator, ".new" do
-  context "with no paramerters" do
-    it "should raise error" do
-      lambda {
-        LengthValidator.new()
-      }.should raise_error
-    end
-  end
-
-  context "with only target expression" do
-    it "should not raise error" do
-      lambda {
-        LengthValidator.new("1")
-      }.should_not raise_error
-    end
-  end
-
-  context "with target expression and :maximum parameters" do
-    before(:each) do
-      @new_proc = lambda {
-        LengthValidator.new("1", :maximum => 10)
-      }
-    end
-
-    it "should not raise error" do
-      @new_proc.should_not raise_error
-    end
-
-    it "should have :maximum option value" do
-      validator = @new_proc.call
-      validator.options[:maximum].value.should == 10
-    end
-  end
-
-  context "with target expression and :minimum parameters" do
-    before(:each) do
-      @new_proc = lambda {
-        LengthValidator.new("1", :minimum => 10)
-      }
-    end
-
-    it "should not raise error" do
-      @new_proc.should_not raise_error
-    end
-
-    it "should have :minimum option value" do
-      validator = @new_proc.call
-      validator.options[:minimum].value.should == 10
-    end
-  end
-
-  context "with target expression and :is parameters" do
-    before(:each) do
-      @new_proc = lambda {
-        LengthValidator.new("1", :is => 10)
-      }
-    end
-
-    it "should not raise error" do
-      @new_proc.should_not raise_error
-    end
-
-    it "should have :is option value" do
-      validator = @new_proc.call
-      validator.options[:is].value.should == 10
-    end
-  end
-
-  context "with target expression and :in parameters" do
-    before(:each) do
-      @new_proc = lambda {
-        LengthValidator.new("1", :in => 3..6)
-      }
-    end
-
-    it "should not raise error" do
-      @new_proc.should_not raise_error
-    end
-
-    it "should have :in option value" do
-      validator = @new_proc.call
-      validator.options[:in].should == (3..6)
-    end
-  end
-end
-
-describe LengthValidator, "#valid?" do
-  context "with only target expression" do
-    before(:each) do
-      @validator = LengthValidator.new("1")
-      Base.values = {
-        "1" => "string",
-        "2" => "string",
-        "3" => "string",
-        "4" => "string",
-      }
-    end
-
-    it "should not raise error" do
-      lambda {
-        @validator.valid?
-      }.should_not raise_error
-    end
-  end
-
-  context "with target expression and :maximum parameters" do
-    before(:each) do
-      @validator = LengthValidator.new("1", :maximum => 10)
-    end
-
-    context "values for valid" do
-      before(:each) do
-        Base.values = {
-          "1" => "1234567890"
-        }
-      end
-
-      it { @validator.should be_valid }
-    end
-
-    context "values for invalid" do
-      before(:each) do
-        Base.values = {
-          "1" => "12345678901"
-        }
-      end
-
-      it { @validator.should_not be_valid }
-    end
-  end
-
-  context "with target expression and :minimum parameters" do
-    before(:each) do
-      @validator = LengthValidator.new("1", :minimum => 10)
-    end
-
-    context "values for valid" do
-      before(:each) do
-        Base.values = {
-          "1" => "1234567890"
-        }
-      end
-
-      it { @validator.should be_valid }
-    end
-
-    context "values for invalid" do
-      before(:each) do
-        Base.values = {
-          "1" => "123456789"
-        }
-      end
-
-      it { @validator.should_not be_valid }
-    end
-  end
-
-  context "with target expression and :is parameters" do
-    before(:each) do
-      @validator = LengthValidator.new("1", :is => 10)
-    end
-
-    context "values for valid" do
-      before(:each) do
-        Base.values = {
-          "1" => "1234567890"
-        }
-      end
-
-      it { @validator.should be_valid }
-    end
-
-    context "values for invalid" do
-      before(:each) do
-        Base.values = {
-          "1" => "123456789"
-        }
-      end
-
-      it { @validator.should_not be_valid }
-    end
-  end
-
-  context "with target expression and :in parameters" do
-    before(:each) do
-      @validator = LengthValidator.new("1", :in => 3..6)
-    end
-
-    context "values for minimum equal valid" do
-      before(:each) do
-        Base.values = {
-          "1" => "123"
-        }
-      end
-
-      it { @validator.should be_valid }
-    end
-
-    context "values for minimum invalid" do
-      before(:each) do
-        Base.values = {
-          "1" => "12"
-        }
-      end
-
-      it { @validator.should_not be_valid }
-    end
-
-    context "values for maximum equal valid" do
-      before(:each) do
-        Base.values = {
-          "1" => "123456"
-        }
-      end
-
-      it { @validator.should be_valid }
-    end
-
-    context "values for maximum invalid" do
-      before(:each) do
-        Base.values = {
-          "1" => "1234567"
-        }
-      end
-
-      it { @validator.should_not be_valid }
-    end
-  end
-end