anodator 0.0.5 → 1.0.0.pre1

data/spec/anodator/rule_spec.rb

@@ -1,278 +0,0 @@
-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(ERROR_LEVELS[:error])" do
-        @rule.level.should == Rule::ERROR_LEVELS[: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::ERROR_LEVELS[: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::ERROR_LEVELS[:warning]
-      end
-    end
-  end
-
-  context "with multiple prerequisite" 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])
-        @prerequisites = [
-                          Validator::BlankValidator.new("3"),
-                          Validator::BlankValidator.new("4")
-                         ]
-        
-        Rule.new(["1", "2"], @message, @validator, @prerequisites, Rule::ERROR_LEVELS[:warning])
-      }
-    end
-
-    it "should not raise Error" do 
-      @new_proc.should_not raise_error
-    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
-
-  context "with complex prerequisite" do
-    before(:each) do
-      @input_spec = InputSpec.new([
-                                   { :number => "1", :name => "item_1" },
-                                   { :number => "2", :name => "item_2" },
-                                   { :number => "3", :name => "item_3" },
-                                   { :number => "4", :name => "item_4" },
-                                  ])
-      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)
-      @prerequisites = [
-                        Validator::BlankValidator.new("3"),
-                        Validator::BlankValidator.new("4")
-                       ]
-      @rule = Rule.new(["item_1", "2"], @message, @validator, @prerequisites)
-    end
-
-    context "when prerequisites matches and invalid" do
-      before(:each) do
-        @input_spec.source = ["1", "", "", ""]
-        Validator::Base.values = @input_spec
-      end
-
-      it { @rule.check.should be_a CheckResult }
-    end
-
-    context "when prerequisites matches and 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 prerequisites not matches and valid" do
-      before(:each) do
-        @input_spec.source = ["1", "2", "", "4"]
-        Validator::Base.values = @input_spec
-      end
-
-      it { @rule.check.should be_nil }
-    end
-
-    context "when prerequisites not matches and invalid" do
-      before(:each) do
-        @input_spec.source = ["1", "2", "", "4"]
-        Validator::Base.values = @input_spec
-      end
-
-      it { @rule.check.should be_nil }
-    end
-  end
-end
-
-describe Rule, ".add_error_level" do
-  context "when new valid error level" do
-    before(:each) do
-      @proc = lambda {
-        Rule.add_error_level(3, :fatal, "FATAL")
-      }
-    end
-
-    after(:each) do
-      Rule.remove_error_level(:fatal)
-    end
-
-    it "should not raise error" do
-      lambda {
-        @proc.call
-      }.should_not raise_error
-    end
-
-    it "should 3 error levels" do
-      lambda {
-        @proc.call
-      }.should change(Rule::ERROR_LEVELS, :size).from(2).to(3)
-    end
-
-    it "should 3 error level names" do
-      lambda {
-        @proc.call
-      }.should change(Rule::ERROR_LEVEL_NAMES, :size).from(2).to(3)
-    end
-  end
-end

data/spec/anodator/utils_spec.rb

@@ -1,48 +0,0 @@
-require "spec_helper"
-require "tempfile"
-
-# Anodator::Utils
-require "anodator"
-require "anodator/utils"
-
-include Anodator
-
-describe Utils, ".load_input_spec_from_csv_file" do 
-  context "read valid file" do 
-    before(:each) do 
-      @file = Tempfile.new(["input_spec", ".csv"])
-      
-      # Header
-      @file.puts(["id", "name", "type"].join(","))
-      # values
-      @values = [
-                 { :id => "1", :name => "Name",     :type => "STRING"  },
-                 { :id => "2", :name => "Age",      :type => "NUMERIC" },
-                 { :id => "3", :name => "Birtyday", :type => "DATE"    },
-                 { :id => "4", :name => "Sex",      :type => "NUMERIC" },
-                 { :id => "5", :name => "Email",    :type => "STRING"  },
-                ]
-      @values.each do |v|
-        @file.puts("#{v[:id]},#{v[:name]},#{v[:type]}")
-      end
-      @file.close
-
-      @proc = lambda { 
-        Utils.load_input_spec_from_csv_file(@file.path)
-      }
-    end
-
-    after(:each) do 
-      @file.unlink
-    end
-
-    it { @proc.should_not raise_error }
-
-    it "should have all items" do 
-      input_spec = @proc.call
-      @values.each do |value|
-        input_spec.spec_item_by_expression(value[:id]).should_not be_nil
-      end
-    end
-  end
-end

data/spec/anodator/validator/base_spec.rb

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

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