1 files changed, 372 insertions, 0 deletions
diff --git a/spec/unit/mixin/params_validate_spec.rb b/spec/unit/mixin/params_validate_spec.rb
new file mode 100644
index 0000000000..b79156109b
--- /dev/null
+++ b/spec/unit/mixin/params_validate_spec.rb
@@ -0,0 +1,372 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Copyright:: Copyright (c) 2008 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+# 
+#     http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+
+class TinyClass
+  include Chef::Mixin::ParamsValidate
+  
+  def music(is_good=true)
+    is_good
+  end
+end
+
+describe Chef::Mixin::ParamsValidate do
+  before(:each) do
+     @vo = TinyClass.new()
+  end
+  
+  it "should allow a hash and a hash as arguments to validate" do
+    lambda { @vo.validate({:one => "two"}, {}) }.should_not raise_error(ArgumentError)
+  end
+  
+  it "should raise an argument error if validate is called incorrectly" do
+    lambda { @vo.validate("one", "two") }.should raise_error(ArgumentError)
+  end
+  
+  it "should require validation map keys to be symbols or strings" do
+    lambda { @vo.validate({:one => "two"}, { :one => true }) }.should_not raise_error(ArgumentError)
+    lambda { @vo.validate({:one => "two"}, { "one" => true }) }.should_not raise_error(ArgumentError)
+    lambda { @vo.validate({:one => "two"}, { Hash.new => true }) }.should raise_error(ArgumentError)
+  end
+  
+  it "should allow options to be required with true" do
+    lambda { @vo.validate({:one => "two"}, { :one => true }) }.should_not raise_error(ArgumentError)
+  end
+  
+  it "should allow options to be optional with false" do
+    lambda { @vo.validate({}, {:one => false})}.should_not raise_error(ArgumentError)
+  end    
+  
+  it "should allow you to check what kind_of? thing an argument is with kind_of" do
+    lambda { 
+      @vo.validate(
+        {:one => "string"}, 
+        {
+          :one => {
+            :kind_of => String
+          }
+        }
+      ) 
+    }.should_not raise_error(ArgumentError)
+    
+    lambda { 
+      @vo.validate(
+        {:one => "string"}, 
+        {
+          :one => {
+            :kind_of => Array
+          }
+        }
+      ) 
+    }.should raise_error(ArgumentError)
+  end
+  
+  it "should allow you to specify an argument is required with required" do
+    lambda { 
+      @vo.validate(
+        {:one => "string"}, 
+        {
+          :one => {
+            :required => true
+          }
+        }
+      ) 
+    }.should_not raise_error(ArgumentError)
+    
+    lambda { 
+      @vo.validate(
+        {:two => "string"}, 
+        {
+          :one => {
+            :required => true
+          }
+        }
+      ) 
+    }.should raise_error(ArgumentError)
+    
+    lambda { 
+      @vo.validate(
+        {:two => "string"}, 
+        {
+          :one => {
+            :required => false
+          }
+        }
+      ) 
+    }.should_not raise_error(ArgumentError)
+  end
+  
+  it "should allow you to specify whether an object has a method with respond_to" do
+    lambda { 
+      @vo.validate(
+        {:one => @vo}, 
+        {
+          :one => {
+            :respond_to => "validate"
+          }
+        }
+      ) 
+    }.should_not raise_error(ArgumentError)
+    
+    lambda { 
+      @vo.validate(
+        {:one => @vo}, 
+        {
+          :one => {
+            :respond_to => "monkey"
+          }
+        }
+      ) 
+    }.should raise_error(ArgumentError)
+  end
+  
+  it "should allow you to specify whether an object has all the given methods with respond_to and an array" do
+    lambda { 
+      @vo.validate(
+        {:one => @vo}, 
+        {
+          :one => {
+            :respond_to => ["validate", "music"]
+          }
+        }
+      ) 
+    }.should_not raise_error(ArgumentError)
+    
+    lambda { 
+      @vo.validate(
+        {:one => @vo}, 
+        {
+          :one => {
+            :respond_to => ["monkey", "validate"]
+          }
+        }
+      ) 
+    }.should raise_error(ArgumentError)
+  end
+  
+  it "should let you set a default value with default => value" do
+    arguments = Hash.new
+    @vo.validate(arguments, {
+      :one => {
+        :default => "is the loneliest number"
+      }
+    })
+    arguments[:one].should == "is the loneliest number"
+  end
+  
+  it "should let you check regular expressions" do
+    lambda { 
+      @vo.validate(
+        { :one => "is good" },
+        {
+          :one => {
+            :regex => /^is good$/
+          }
+        }
+      )
+    }.should_not raise_error(ArgumentError)
+    
+    lambda { 
+      @vo.validate(
+        { :one => "is good" },
+        {
+          :one => {
+            :regex => /^is bad$/
+          }
+        }
+      )
+    }.should raise_error(ArgumentError)
+  end
+  
+  it "should let you specify your own callbacks" do
+    lambda { 
+      @vo.validate(
+        { :one => "is good" },
+        {
+          :one => {
+            :callbacks => {
+              "should be equal to is good" => lambda { |a|
+                a == "is good"
+              },
+            }
+          }
+        }
+      )
+    }.should_not raise_error(ArgumentError) 
+    
+    lambda { 
+      @vo.validate(
+        { :one => "is bad" },
+        {
+          :one => {
+            :callbacks => {
+              "should be equal to 'is good'" => lambda { |a|
+                a == "is good"
+              },
+            }
+          }
+        }
+      )
+    }.should raise_error(ArgumentError)   
+  end
+  
+  it "should let you combine checks" do
+    args = { :one => "is good", :two => "is bad" }
+    lambda { 
+      @vo.validate(
+        args,
+        {
+          :one => {
+            :kind_of => String,
+            :respond_to => [ :to_s, :upcase ],
+            :regex => /^is good/,
+            :callbacks => {
+              "should be your friend" => lambda { |a|
+                a == "is good"
+              }
+            },
+            :required => true
+          },
+          :two => {
+            :kind_of => String,
+            :required => false
+          },
+          :three => { :default => "neato mosquito" }
+        }
+      )
+    }.should_not raise_error(ArgumentError)
+    args[:three].should == "neato mosquito"
+    lambda {
+      @vo.validate(
+        args,
+        {
+          :one => {
+            :kind_of => String,
+            :respond_to => [ :to_s, :upcase ],
+            :regex => /^is good/,
+            :callbacks => {
+              "should be your friend" => lambda { |a|
+                a == "is good"
+              }
+            },
+            :required => true
+          },
+          :two => {
+            :kind_of => Hash,
+            :required => false
+          },
+          :three => { :default => "neato mosquito" }
+        }
+      )
+    }.should raise_error(ArgumentError)
+  end
+  
+  it "should raise an ArgumentError if the validation map has an unknown check" do
+    lambda { @vo.validate(
+        { :one => "two" },
+        {
+          :one => {
+            :busted => "check"
+          }
+        }
+      )
+    }.should raise_error(ArgumentError)
+  end
+  
+  it "should accept keys that are strings in the options" do
+    lambda {
+      @vo.validate({ "one" => "two" }, { :one => { :regex => /^two$/ }}) 
+    }.should_not raise_error(ArgumentError)
+  end
+  
+  it "should allow an array to kind_of" do
+    lambda { 
+      @vo.validate(
+        {:one => "string"}, 
+        {
+          :one => {
+            :kind_of => [ String, Array ]
+          }
+        }
+      ) 
+    }.should_not raise_error(ArgumentError)
+    lambda { 
+      @vo.validate(
+        {:one => ["string"]}, 
+        {
+          :one => {
+            :kind_of => [ String, Array ]
+          }
+        }
+      ) 
+    }.should_not raise_error(ArgumentError)
+    lambda { 
+      @vo.validate(
+        {:one => Hash.new}, 
+        {
+          :one => {
+            :kind_of => [ String, Array ]
+          }
+        }
+      ) 
+    }.should raise_error(ArgumentError)
+  end
+
+  it "asserts that a value returns false from a predicate method" do
+    lambda do
+      @vo.validate({:not_blank => "should pass"},
+                   {:not_blank => {:cannot_be => :nil, :cannot_be => :empty}})
+    end.should_not raise_error
+    lambda do
+      @vo.validate({:not_blank => ""},
+                   {:not_blank => {:cannot_be => :nil, :cannot_be => :empty}})
+    end.should raise_error(Chef::Exceptions::ValidationFailed)
+  end
+
+  it "should set and return a value, then return the same value" do
+    value = "meow"
+    @vo.set_or_return(:test, value, {}).object_id.should == value.object_id
+    @vo.set_or_return(:test, nil, {}).object_id.should == value.object_id
+  end
+
+  it "should set and return a default value when the argument is nil, then return the same value" do
+    value = "meow"
+    @vo.set_or_return(:test, nil, { :default => value }).object_id.should == value.object_id
+    @vo.set_or_return(:test, nil, {}).object_id.should == value.object_id
+  end
+
+  it "should raise an ArgumentError when argument is nil and required is true" do
+    lambda {
+      @vo.set_or_return(:test, nil, { :required => true })
+    }.should raise_error(ArgumentError)
+  end
+
+  it "should not raise an error when argument is nil and required is false" do
+    lambda {
+      @vo.set_or_return(:test, nil, { :required => false })
+    }.should_not raise_error(ArgumentError)
+  end
+
+  it "should set and return @name, then return @name for foo when argument is nil" do
+    value = "meow"
+    @vo.set_or_return(:name, value, { }).object_id.should == value.object_id
+    @vo.set_or_return(:foo, nil, { :name_attribute => true }).object_id.should == value.object_id
+  end
+  
+end