anodator 0.0.1

data/spec/anodator/rule_spec.rb

@@ -0,0 +1,169 @@
+require "spec_helper"
+
+# Anodator::Rule
+require "anodator/rule"
+
+include Anodator
+
+describe Rule, "#new" do
+  context "with no parameters" do
+    it "should raise ArgumentError" do
+      lambda {
+        Rule.new
+      }.should raise_error ArgumentError
+    end
+  end
+
+  context "with only target_expressions" do
+    it "should raise ArgumentError" do
+      lambda {
+        Rule.new(["1", "2", "3"])
+      }.should raise_error ArgumentError
+    end
+  end
+
+  context "with target_expressions and message" do
+    it "should raise ArgumentError" do
+      lambda {
+        Rule.new(["1", "2", "3"],
+                 Message.new("'[[1::name]]' cannot be blank"))
+      }.should raise_error ArgumentError
+    end
+  end
+
+  context "with target_expressions, message and validator" do
+    before(:each) do
+      @new_proc = lambda {
+        v1 = Validator::PresenceValidator.new("1")
+        v2 = Validator::PresenceValidator.new("2")
+        @validator = Validator::ComplexValidator.new(:validators => [v1, v2])
+        @message = Message.new("'[[1::name]]' and '[[2::name]]' cannot be blank")
+        Rule.new(["1", "2"], @message, @validator)
+      }
+    end
+
+    it "should not raise Error" do
+      @new_proc.should_not raise_error
+    end
+
+    context "after generated" do
+      before(:each) do
+        @rule = @new_proc.call
+      end
+
+      it "#target_expressions should equal by initialize" do
+        @rule.target_expressions.should == ["1", "2"]
+      end
+
+      it "#message should equal by initialize" do
+        @rule.message.should == @message
+      end
+
+      it "#validator should equal by initialize" do
+        @rule.validator.should == @validator
+      end
+
+      it "#prerequisite should be nil" do
+        @rule.prerequisite.should be_nil
+      end
+
+      it "#level should equal by default(LEVEL_ERROR)" do
+        @rule.level.should == Rule::LEVEL_ERROR
+      end
+    end
+  end
+
+  context "with all parameters" do
+    before(:each) do
+      @new_proc = lambda {
+        v1 = Validator::PresenceValidator.new("1")
+        v2 = Validator::PresenceValidator.new("2")
+        @message = Message.new("'[[1::name]]' and '[[2::name]]' cannot be blank")
+        @validator = Validator::ComplexValidator.new(:validators => [v1, v2])
+        @prerequisite = Validator::BlankValidator.new("3")
+        Rule.new(["1", "2"], @message, @validator, @prerequisite, Rule::LEVEL_WARNING)
+      }
+    end
+
+    it "should not raise Error" do
+      @new_proc.should_not raise_error
+    end
+
+    context "after generated" do
+      before(:each) do
+        @rule = @new_proc.call
+      end
+
+      it "#target_expressions should equal by initialize" do
+        @rule.target_expressions.should == ["1", "2"]
+      end
+
+      it "#message should equal by initialize" do
+        @rule.message.should == @message
+      end
+
+      it "#validator should equal by initialize" do
+        @rule.validator.should == @validator
+      end
+
+      it "#prerequisite should equal by initialize" do
+        @rule.prerequisite.should == @prerequisite
+      end
+
+      it "#level should equal by initialize" do
+        @rule.level.should == Rule::LEVEL_WARNING
+      end
+    end
+  end
+end
+
+describe Rule, "#check" do
+  before(:each) do
+    @input_spec = InputSpec.new([
+                                 { :number => "1", :name => "item_1" },
+                                 { :number => "2", :name => "item_2" },
+                                 { :number => "3", :name => "item_3" },
+                                ])
+    v1 = Validator::PresenceValidator.new("1")
+    v2 = Validator::PresenceValidator.new("2")
+    @message = Message.new("'[[1::name]]' and '[[2::name]]' cannot be blank")
+    @validator = Validator::ComplexValidator.new(:validators => [v1, v2], :logic => Validator::ComplexValidator::LOGIC_AND)
+    @prerequisite = Validator::BlankValidator.new("3")
+    @rule = Rule.new(["item_1", "2"], @message, @validator, @prerequisite)
+  end
+
+  context "when check rule is valid" do
+    before(:each) do
+      @input_spec.source = ["1", "2", ""]
+      Validator::Base.values = @input_spec
+    end
+
+    it { @rule.check.should be_nil }
+  end
+
+  context "when check rule is not valid" do
+    before(:each) do
+      @input_spec.source = ["1", "", ""]
+      Validator::Base.values = @input_spec
+    end
+
+    it { @rule.check.should_not be_nil }
+    it { @rule.check.should be_a CheckResult }
+
+    it "CheckResult#target_numbers must be only number expression" do
+      result = @rule.check
+      result.target_numbers.each do |number|
+        @input_spec.spec_item_by_expression(number).number.should == number
+      end
+    end
+  end
+
+  context "when prerequisite not matched" do
+    before(:each) do
+      @input_spec.source = ["1", "", "3"]
+      Validator::Base.values = @input_spec
+    end
+
+    it { @rule.check.should be_nil }
+  end
+end

data/spec/anodator/validator/base_spec.rb

@@ -0,0 +1,214 @@
+require "spec_helper"
+
+# Anodator::Validator::Base
+require "anodator/validator/base"
+
+describe Anodator::Validator::Base, "#new" do
+  context "with no parameters" do
+    it "should raise ArgumentError" do
+      lambda {
+        Anodator::Validator::Base.new
+      }.should raise_error ArgumentError
+    end
+  end
+
+  context "with only target(nil) parameter" do
+    it "should raise ArgumentError" do
+      lambda {
+        Anodator::Validator::Base.new(nil)
+      }.should raise_error ArgumentError
+    end
+  end
+
+  context "with only target("") parameter" do
+    it "should raise ArgumentError" do
+      lambda {
+        Anodator::Validator::Base.new("")
+      }.should raise_error ArgumentError
+    end
+  end
+
+  context "with only target(34) parameter" do
+    before(:each) do
+      @new_proc = lambda {
+        Anodator::Validator::Base.new("34")
+      }
+    end
+
+    it "should not raise ArgumentError" do
+      @new_proc.should_not raise_error ArgumentError
+    end
+
+    it "#allow_blank? should be false" do
+      @base = @new_proc.call
+      @base.should_not be_allow_blank
+    end
+  end
+
+  context "with target(name) parameter" do
+    context "and allow_blank(true) parameter" do
+      before(:each) do
+        @new_proc = lambda {
+          Anodator::Validator::Base.new("name", :allow_blank => true)
+        }
+      end
+
+      it "should not raise ArgumentError" do
+        @new_proc.should_not raise_error ArgumentError
+      end
+
+      it "#allow_blank? should be true" do
+        @base = @new_proc.call
+        @base.should be_allow_blank
+      end
+    end
+
+    context "and allow_blank(false) parameter" do
+      before(:each) do
+        @new_proc = lambda {
+          Anodator::Validator::Base.new("name", :allow_blank => false)
+        }
+      end
+
+      it "should not raise ArgumentError" do
+        @new_proc.should_not raise_error ArgumentError
+      end
+
+      it "#allow_blank? should be false" do
+        @base = @new_proc.call
+        @base.should_not be_allow_blank
+      end
+    end
+
+    context "and description parameter" do
+      before(:each) do
+        @new_proc = lambda {
+          Anodator::Validator::Base.new("name", :description => "description message here.")
+        }
+      end
+
+      it "should not raise ArgumentError" do
+        @new_proc.should_not raise_error ArgumentError
+      end
+
+      it "#description should be 'description message here.'" do
+        @base = @new_proc.call
+        @base.description.should == "description message here."
+      end
+    end
+
+    context "and unknown parameter" do
+      before(:each) do
+        @new_proc = lambda {
+          Anodator::Validator::Base.new("name", :unknown => "value")
+        }
+      end
+
+      it "should raise ArgumentError" do
+        @new_proc.should raise_error ArgumentError
+      end
+    end
+  end
+end
+
+describe Anodator::Validator::Base, "#validate" do
+  it "Anodator::Validator::Base#validate raise NotImplementedError" do
+    lambda {
+      Anodator::Validator::Base.new("1").validate
+    }.should raise_error NoMethodError
+  end
+end
+
+describe Anodator::Validator::Base, "create a new Validator class to inherit" do
+  before(:all) do
+    module Anodator
+      module Validator
+        class SomeValidator < Base
+          valid_option_keys :some_option
+          default_options :some_option => true
+        end
+      end
+    end
+  end
+
+  it "should have additional option" do
+    Anodator::Validator::SomeValidator.valid_option_keys.
+      should be_include(:some_option)
+  end
+
+  it "should have default option ':allow_blank'" do
+    Anodator::Validator::SomeValidator.valid_option_keys.
+      should be_include(:allow_blank)
+  end
+
+  it "should have default value is true for option 'some_option'" do
+    Anodator::Validator::SomeValidator.default_options[:some_option].
+      should be_true
+  end
+end
+
+describe Anodator::Validator::Base, "create a new Validator class with unknown defualt options" do
+  before(:all) do
+    @new_class_proc = lambda {
+      module Anodator
+        module Validator
+          class InvalidDefaultOptionValidator < Base
+            valid_option_keys :some_option
+            default_options :wrong_option => 11
+          end
+        end
+      end
+    }
+  end
+
+  it "should raise error" do
+    @new_class_proc.should raise_error ArgumentError
+  end
+end
+
+describe Anodator::Validator::Base, "set values for validation" do
+  context "for nil value" do
+    it "should raise argument error" do
+      lambda {
+        Anodator::Validator::Base.values = nil
+      }.should raise_error ArgumentError
+    end
+  end
+
+  context "for String value" do
+    it "should not raise argument error" do
+      lambda {
+        Anodator::Validator::Base.values = "value"
+      }.should_not raise_error ArgumentError
+    end
+  end
+
+  context "for Array values" do
+    it "should not raise argument error" do
+      lambda {
+        Anodator::Validator::Base.values = [1, 2, 3]
+      }.should_not raise_error ArgumentError
+    end
+  end
+
+  context "for Hash values" do
+    it "should not raise argument error" do
+      lambda {
+        Anodator::Validator::Base.values = { "1" => 1, "2" => 2, "3" => 3 }
+      }.should_not raise_error ArgumentError
+    end
+  end
+
+  context "for another values what can respond to [] method" do
+    it "should not raise argument error" do
+      lambda {
+        class Dict
+          def []
+            return ""
+          end
+        end
+        Anodator::Validator::Base.values = Dict.new
+      }.should_not raise_error ArgumentError
+    end
+  end
+end

data/spec/anodator/validator/blank_validator_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+
+# Anodator::Validator::BlankValidator
+require "anodator/validator/blank_validator"
+
+describe Anodator::Validator::BlankValidator, ".new" do
+  context "with no parameters" do
+    it "should raise ArgumentError" do
+      lambda {
+        Anodator::Validator::BlankValidator.new
+      }.should raise_error ArgumentError
+    end
+  end
+
+  context "with only target parameter" do
+    it "should not raise error" do
+      lambda {
+        Anodator::Validator::BlankValidator.new("1")
+      }.should_not raise_error
+    end
+  end
+end
+
+describe Anodator::Validator::BlankValidator, "#valid?" do
+  before(:each) do
+    @validator = Anodator::Validator::BlankValidator.new("1")
+  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_not 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

data/spec/anodator/validator/complex_validator_spec.rb

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