waw 0.2.2

data/test/spec/validation/array_validator_spec.rb

@@ -0,0 +1,17 @@
+require "waw"
+describe ::Waw::Validation::ArrayValidations::ArrayValidator do
+  
+  def arrayval(subvalidator)
+    ::Waw::Validation::ArrayValidations::ArrayValidator.new(subvalidator)
+  end
+  
+  it "should correctly validate non empty arrays" do
+    arrayval(String).validate(["hop", "hello"]).should be_true
+    arrayval(String).validate(["world"]).should be_true
+  end
+  
+  it "should correctly validate empty arrays" do
+    arrayval(String).validate([]).should be_true
+  end
+  
+end

data/test/spec/validation/date_validation_spec.rb

@@ -0,0 +1,35 @@
+require 'waw'
+describe "date proposed validation" do
+
+  # Creates a signature
+  def date
+    @date_validator ||= ::Waw::Validation.signature {
+      validation :date, date, :bad_date
+    }
+  end
+  
+  it "should block missing values" do
+    date.blocks?(:date => nil).should be_true
+    date.blocks?(:date => "").should be_true
+    date.blocks?(:date => "   ").should be_true
+  end
+
+  it "should be robust to strange values" do
+    date.blocks?(:date => nil).should be_true
+    date.blocks?(:date => 12).should be_true
+    date.blocks?(:date => self).should be_true
+    date.blocks?(:date => Class).should be_true
+    date.blocks?(:date => self).should be_true
+  end
+
+  it "should allow valid dates" do
+    date.allows?(:date => "2010/04/25").should be_true
+    date.allows?(:date => "25/04/2010").should be_true
+  end
+
+  it "should block invalid dates" do
+    date.allows?(:date => "2010/33/75").should be_false
+    date.allows?(:date => "2010/02/31").should be_false
+  end
+
+end

data/test/spec/validation/default_validation_spec.rb

@@ -0,0 +1,37 @@
+require 'waw'
+describe ::Waw::Validation::DefaultValidator do
+  
+  def default(*args, &block)
+    ::Waw::Validation::DefaultValidator.new(*args, &block)
+  end
+  
+  it "should be correct about missing values when calling validate" do
+    default(8).validate(1).should == false
+    default(8).validate(1, nil).should == false
+    default(8).validate(nil).should == true
+    default(8).validate("").should == true
+    default(8).validate("  ").should == true
+    default(8).validate("", nil).should == true
+  end
+  
+  it "should be correct about missing values when calling convert_and_validate" do
+    default(8).convert_and_validate(1).should == [false, [1]]
+    default(8).convert_and_validate(nil).should == [true, [8]]
+    default(8).convert_and_validate(nil, nil).should == [true, [8, 8]]
+  end
+  
+  it "should support passing a block (feature #305)" do
+    default{8}.convert_and_validate(1).should == [false, [1]]
+    default{8}.convert_and_validate(nil).should == [true, [8]]
+    default{8}.convert_and_validate(nil, nil).should == [true, [8, 8]]
+  end
+  
+  it "should also work when used in signature (feature #{306})" do
+    signature = ::Waw::Validation.signature {
+      validation :time, String | default{Time.now}, :time
+    }
+    signature.allows?(:time => nil).should == true
+    Time.should === signature.first_converted(:time => nil)
+  end
+  
+end

data/test/spec/validation/disjuctive_validation_spec.rb

@@ -0,0 +1,33 @@
+require 'waw'
+describe 'Disjunctive validators' do
+  
+  it "should be ok to put Integer|missing" do
+    signature = Waw::Validation.signature {
+      validation :id, Integer | missing, :bad_id
+    }
+  end
+  
+  it "Integer|missing should correctly accept missings" do
+    signature = Waw::Validation.signature {
+      validation :id, Integer | missing, :bad_id
+    }
+    signature.allows?(:id => nil).should be_true
+    signature.allows?(:id => "").should be_true
+  end
+  
+  it "Integer|missing should correctly accept integers as well" do
+    signature = Waw::Validation.signature {
+      validation :id, Integer | missing, :bad_id
+    }
+    signature.allows?(:id => 12).should be_true
+    signature.allows?(:id => "12").should be_true
+  end
+  
+  it "Integer|missing should correctly handle bulk conversions" do
+    validator = (Waw::Validation.integer | Waw::Validation.missing)
+    ok, values = validator.convert_and_validate(1, nil, 12, "1", "2", "")
+    ok.should be_true
+    values.should == [1, nil, 12, 1, 2, nil]
+  end
+
+end

data/test/spec/validation/errors_spec.rb

@@ -0,0 +1,37 @@
+require "waw"
+describe Waw::Validation::Error do
+
+  it "should be raisable easily" do
+    begin
+      raise Waw::Validation::Error, [:bad_user, :bad_age]
+      false.should be_true
+    rescue Waw::Validation::Error => ex
+      ex.failed.should == [:bad_user, :bad_age]
+      ex.message.should_not be_nil
+      ex.message.is_a?(String).should be_true
+    end
+  end
+  
+  it "should allow catching subclasses with Error" do
+    begin
+      raise Waw::Validation::KO, [:bad_user, :bad_age]
+      false.should be_true
+    rescue Waw::Validation::Error => ex
+      ex.failed.should == [:bad_user, :bad_age]
+      ex.message.should_not be_nil
+      ex.message.is_a?(String).should be_true
+    end
+  end
+
+  it "should allow catching exact subclasses" do
+    begin
+      raise Waw::Validation::KO, [:bad_user, :bad_age]
+      false.should be_true
+    rescue Waw::Validation::KO => ex
+      ex.failed.should == [:bad_user, :bad_age]
+      ex.message.should_not be_nil
+      ex.message.is_a?(String).should be_true
+    end
+  end
+
+end

data/test/spec/validation/file_validator_spec.rb

@@ -0,0 +1,34 @@
+require 'waw'
+require 'fileutils'
+describe ::Waw::Validation::FileValidator do
+  
+  def file
+    ::Waw::Validation::FileValidator.new
+  end
+  
+  def sandbox_file_with_spaces
+    File.join(File.dirname(__FILE__), 'issue 360.txt')
+  end
+  
+  before(:all) do
+    File.open(sandbox_file_with_spaces, 'w'){|io| io << "hello world!"}
+    File.read(sandbox_file_with_spaces).should == "hello world!"
+  end
+  
+  after(:all) do
+    FileUtils.rm sandbox_file_with_spaces
+  end
+
+  it "should recognize real files" do
+    (file === __FILE__).should be_true
+  end
+  
+  it "should support file names containing spaces (see #360)" do
+    (file === sandbox_file_with_spaces).should be_true
+  end
+  
+  it "should not decode html paths itself (see #360)" do
+    (file === sandbox_file_with_spaces.gsub(/\s/,"%20")).should be_false
+  end
+    
+end

data/test/spec/validation/mail_validation_spec.rb

@@ -0,0 +1,51 @@
+require 'waw'
+describe "mail proposed validation" do
+
+  # Creates a signature
+  def mail
+    @mail_validator ||= ::Waw::Validation.signature {
+      validation :mail, mail, :bad_mail
+    }
+  end
+  
+  it "should block missing values" do
+    mail.blocks?(:mail => nil).should be_true
+    mail.blocks?(:mail => "").should be_true
+    mail.blocks?(:mail => "   ").should be_true
+  end
+
+  it "should be robust to strange values" do
+    mail.blocks?(:mail => nil).should be_true
+    mail.blocks?(:mail => 12).should be_true
+    mail.blocks?(:mail => self).should be_true
+    mail.blocks?(:mail => Class).should be_true
+    mail.blocks?(:mail => self).should be_true
+  end
+
+  it "should allow valid mails" do
+    mail.allows?(:mail => "blambeau@gmail.com").should be_true
+    mail.allows?(:mail => "blambeau@acm-sc.be").should be_true
+  end
+
+  it "should support mails with dots" do
+    mail.allows?(:mail => "bernard.lambeau@gmail.com").should be_true
+  end
+
+  it "should support mails with numbers" do
+    mail.allows?(:mail => "bernard007@gmail.com").should be_true
+  end
+
+  it "should support trailing spaces" do
+    mail.allows?(:mail => "blambeau@gmail.com   ").should be_true
+    mail.allows?(:mail => "   blambeau@acm-sc.be").should be_true
+    mail.allows?(:mail => "   blambeau@acm-sc.be    ").should be_true
+  end
+  
+  it "should not support spaces inside the mail" do
+    mail.blocks?(:mail => "blamb gmail.com").should be_true
+    mail.blocks?(:mail => "blambeau@gmail.com  and something here").should be_true
+    mail.blocks?(:mail => "something here blambeau@gmail.com").should be_true
+    mail.blocks?(:mail => "something here blambeau@gmail.com and also here").should be_true
+  end
+  
+end

data/test/spec/validation/missing_validation_spec.rb

@@ -0,0 +1,43 @@
+require 'waw'
+describe "missing validation" do
+
+  # Creates a signature
+  def missing(&block)
+    if block
+      ::Waw::Validation.signature(&block)
+    else
+      @missing_validator ||= ::Waw::Validation.signature {
+        validation :mail, missing, :bad_mail
+      }
+    end
+  end
+  
+  it "should allow missing values" do
+    missing.allows?(:mail => nil).should be_true
+    missing.allows?(:mail => "").should be_true
+    missing.allows?(:mail => "   ").should be_true
+  end
+  
+  it "should block non missing values" do
+    missing.blocks?(:mail => "blambeau@gmail.com").should be_true
+  end
+  
+  it "should be robust to strange values" do
+    missing.blocks?(:mail => 1234567).should be_true
+    missing.blocks?(:mail => self).should be_true
+    missing.blocks?(:mail => Object.new).should be_true
+    missing.blocks?(:mail => Class).should be_true
+  end
+  
+  it "should correctly convert missings to nil" do
+    missing.first_converted(:mail => "").should be_nil
+    missing.first_converted(:mail => nil).should be_nil
+    missing.first_converted(:mail => "    ").should be_nil
+  end
+
+  it "should never change non missings" do
+    missing.first_converted(:mail => "bla").should == "bla"
+    missing.first_converted(:mail => 12).should == 12
+  end
+  
+end

data/test/spec/validation/same_validation_spec.rb

@@ -0,0 +1,24 @@
+require 'waw'
+describe "same proposed validation" do
+
+  # Creates a signature
+  def mail
+    @same_validator ||= ::Waw::Validation.signature {
+      validation [:pass, :confirm], mandatory & same, :bad_mail
+    }
+  end
+  
+  it "should block invalid combinations" do
+    mail.blocks?(:pass => nil).should be_true
+    mail.blocks?(:confirm => "").should be_true
+    mail.blocks?(:pass => "", :confirm => "").should be_true
+    mail.blocks?(:pass => nil, :confirm => "blambeau").should be_true
+    mail.blocks?(:pass => "blambeau", :confirm => "").should be_true
+  end
+
+  it "should not block valid combinations" do
+    mail.blocks?(:pass => "blambeau", :confirm => "blambeau").should be_false
+  end
+
+  
+end

data/test/spec/validation/signature_intuition_spec.rb

@@ -0,0 +1,37 @@
+require 'waw'
+describe ::Waw::Validation::Signature do
+
+  # Creates a signature
+  def signature(&block)
+    ::Waw::Validation.signature(&block)
+  end
+  
+  it "should not be disjunction sensitive on missing" do
+    signature = signature {
+      validation :mail, mail | missing, :bad_mail
+    }
+    signature.first_converted(:mail => "blambeau@hotmail.com").should == "blambeau@hotmail.com"
+    signature.first_converted().should be_nil
+
+    signature = signature {
+      validation :mail, missing | mail, :bad_mail
+    }
+    signature.first_converted(:mail => "blambeau@hotmail.com").should == "blambeau@hotmail.com"
+    signature.first_converted().should be_nil
+  end
+  
+  it "should not be disjunction sensitive on default" do
+    signature = signature {
+      validation :mail, mail | default("info@hotmail.com"), :bad_mail
+    }
+    signature.first_converted(:mail => "blambeau@hotmail.com").should == "blambeau@hotmail.com"
+    signature.first_converted().should == "info@hotmail.com"
+
+    signature = signature {
+      validation :mail, default("info@hotmail.com") | mail, :bad_mail
+    }
+    signature.first_converted(:mail => "blambeau@hotmail.com").should == "blambeau@hotmail.com"
+    signature.first_converted().should == "info@hotmail.com"
+  end
+  
+end

data/test/spec/validation/signature_spec.rb

@@ -0,0 +1,164 @@
+require 'waw'
+
+describe ::Waw::Validation::Signature do
+  
+  # Creates a signature
+  def signature(&block)
+    ::Waw::Validation.signature(&block)
+  end
+  
+  it "should allow user-friendly DSL" do
+    signature {
+      validation :mail, mandatory & mail, :bad_email
+      validation [:password, :confirm], mandatory & equal, :password_dont_match
+    }.should_not be_nil
+  end
+  
+  it "should have allows? and blocks? with opposite answers" do
+    signature = signature {
+      validation :age, is >= 18, :bad_age
+    }
+    signature.allows?().should be_false
+    signature.blocks?().should be_true
+  end
+  
+  it "should allow valid data" do
+    signature = signature {
+      validation :age, is >= 18, :bad_age
+    }
+    signature.allows?(:age => 18).should be_true
+    signature.allows?(:age => 20).should be_true
+  end
+  
+  it "should block invalid data" do
+    signature = signature {
+      validation :age, is >= 18, :bad_age
+    }
+    signature.blocks?().should be_true
+    signature.blocks?(:age => "").should be_true
+    signature.blocks?(:age => "   ").should be_true
+    signature.blocks?(:age => nil).should be_true
+    signature.blocks?(:age => -10).should be_true
+    signature.blocks?(:age => 17).should be_true
+    signature.blocks?(:age => 17.99999).should be_true
+  end
+  
+  it "should support missing in disjunction" do
+    signature = signature {
+      validation :mail, mail | missing, :bad_mail
+    }
+    signature.allows?(:mail => "blambeau@hotmail.com").should be_true
+    signature.blocks?(:mail => "blambeau@hotmail.com").should be_false
+    signature.allows?(:mail => "").should be_true
+    signature.allows?(:mail => "   ").should be_true
+    signature.allows?(:mail => nil).should be_true
+  end
+  
+  it "should allow Boolean to be like a ruby class" do
+    signature = signature {
+      validation :newsletter, Boolean, :bad_newsletter
+    }
+    signature.allows?(:newsletter => true).should be_true
+    signature.allows?(:newsletter => false).should be_true
+    signature.allows?(:newsletter => "true").should be_true
+    signature.allows?(:newsletter => "false").should be_true
+  end
+  
+  it "should allow String ruby class as validator" do
+    signature = signature {
+      validation :name, String, :bad_name
+    }
+    signature.allows?(:name => "blambeau").should be_true
+    signature.allows?(:name => "").should be_true
+    signature.blocks?(:name => nil).should be_true
+    signature.blocks?().should be_true
+  end
+  
+  it "should allow Integer ruby class as validator" do
+    signature = signature {
+      validation :age, Integer, :bad_age
+    }
+    signature.allows?(:age => 12).should be_true
+    signature.allows?(:age => "12").should be_true
+    signature.blocks?(:age => "hello").should be_true
+    signature.blocks?().should be_true
+  end
+  
+  it "should allow Float ruby class as validator" do
+    signature = signature {
+      validation :temperature, Float, :bad_temperature
+    }
+    signature.allows?(:temperature => 12).should be_true
+    signature.allows?(:temperature => 12.0).should be_true
+    signature.allows?(:temperature => "12").should be_true
+    signature.allows?(:temperature => "12.0").should be_true
+    signature.blocks?(:temperature => "hello").should be_true
+    signature.blocks?().should be_true
+  end
+  
+  it "should allow ruby classes as left part of a disjunction" do
+    signature = signature {
+      validation :age, missing | Integer, :bad_age
+    }
+    signature.allows?(:age => 12).should be_true
+    signature.allows?(:age => "").should be_true
+    signature.allows?(:age => nil).should be_true
+    signature.blocks?(:age => "hello").should be_true
+  end
+  
+  it "should allow ruby classes as right part of a disjunction" do
+    signature = signature {
+      validation :age, Integer | missing, :bad_age
+    }
+    signature.allows?(:age => 12).should be_true
+    signature.allows?(:age => "").should be_true
+    signature.allows?(:age => nil).should be_true
+    signature.blocks?(:age => "hello").should be_true
+  end
+  
+  it "should allow ruby classes as left part of a conjunction" do
+    signature = signature {
+      validation :age, (is > 10) & Integer, :bad_age
+    }
+    signature.allows?(:age => 12).should be_true
+    signature.allows?(:age => "").should be_false
+    signature.allows?(:age => nil).should be_false
+    signature.blocks?(:age => 7).should be_true
+    signature.blocks?(:age => "hello").should be_true
+  end
+  
+  it "should allow ruby classes as right part of a conjunction" do
+    signature = signature {
+      validation :age, Integer & (is > 10), :bad_age
+    }
+    signature.allows?(:age => 12).should be_true
+    signature.allows?(:age => "").should be_false
+    signature.allows?(:age => nil).should be_false
+    signature.blocks?(:age => 7).should be_true
+    signature.blocks?(:age => "hello").should be_true
+  end
+  
+  it "should provide a utility to get default data" do
+    signature = signature {
+      validation :name, String  | default("hello"), :bad_name
+      validation :age, Integer | default(12),      :bad_age
+    }
+    signature.default.should == {:name => "hello", :age => 12}
+  end
+  
+  it "should support multiple args when computing defaults" do
+    signature = signature {
+      validation :name, String  | default("hello"), :bad_name
+      validation [:age, :support], Integer | default(12),      :bad_age
+    }
+    signature.default.should == {:name => "hello", :age => 12, :support => 12}
+  end
+  
+  it "should support non defaults when computing defaults" do
+    signature = signature {
+      validation [:name1, :name2], String, :bad_name
+    }
+    signature.default.should == {:name1 => nil, :name2 => nil}
+  end
+  
+end