chef 11.10.0.rc.0-x86-mingw32 → 11.10.0.rc.1-x86-mingw32

data/spec/unit/mixin/params_validate_spec.rb

@@ -32,7 +32,7 @@ describe Chef::Mixin::ParamsValidate do
   end
 
   it "should allow a hash and a hash as arguments to validate" do
-    lambda { @vo.validate({:one => "two"}, {}) }.should_not raise_error(ArgumentError)
+    lambda { @vo.validate({:one => "two"}, {}) }.should_not raise_error
   end
 
   it "should raise an argument error if validate is called incorrectly" do
@@ -40,17 +40,17 @@ describe Chef::Mixin::ParamsValidate do
   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"}, { :one => true }) }.should_not raise_error
+    lambda { @vo.validate({:one => "two"}, { "one" => true }) }.should_not raise_error
     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)
+    lambda { @vo.validate({:one => "two"}, { :one => true }) }.should_not raise_error
   end
 
   it "should allow options to be optional with false" do
-    lambda { @vo.validate({}, {:one => false})}.should_not raise_error(ArgumentError)
+    lambda { @vo.validate({}, {:one => false})}.should_not raise_error
   end
 
   it "should allow you to check what kind_of? thing an argument is with kind_of" do
@@ -63,7 +63,7 @@ describe Chef::Mixin::ParamsValidate do
           }
         }
       )
-    }.should_not raise_error(ArgumentError)
+    }.should_not raise_error
 
     lambda {
       @vo.validate(
@@ -87,7 +87,7 @@ describe Chef::Mixin::ParamsValidate do
           }
         }
       )
-    }.should_not raise_error(ArgumentError)
+    }.should_not raise_error
 
     lambda {
       @vo.validate(
@@ -109,7 +109,7 @@ describe Chef::Mixin::ParamsValidate do
           }
         }
       )
-    }.should_not raise_error(ArgumentError)
+    }.should_not raise_error
   end
 
   it "should allow you to specify whether an object has a method with respond_to" do
@@ -122,7 +122,7 @@ describe Chef::Mixin::ParamsValidate do
           }
         }
       )
-    }.should_not raise_error(ArgumentError)
+    }.should_not raise_error
 
     lambda {
       @vo.validate(
@@ -146,7 +146,7 @@ describe Chef::Mixin::ParamsValidate do
           }
         }
       )
-    }.should_not raise_error(ArgumentError)
+    }.should_not raise_error
 
     lambda {
       @vo.validate(
@@ -180,7 +180,7 @@ describe Chef::Mixin::ParamsValidate do
           }
         }
       )
-    }.should_not raise_error(ArgumentError)
+    }.should_not raise_error
 
     lambda {
       @vo.validate(
@@ -208,7 +208,7 @@ describe Chef::Mixin::ParamsValidate do
           }
         }
       )
-    }.should_not raise_error(ArgumentError)
+    }.should_not raise_error
 
     lambda {
       @vo.validate(
@@ -250,7 +250,7 @@ describe Chef::Mixin::ParamsValidate do
           :three => { :default => "neato mosquito" }
         }
       )
-    }.should_not raise_error(ArgumentError)
+    }.should_not raise_error
     args[:three].should == "neato mosquito"
     lambda {
       @vo.validate(
@@ -292,7 +292,7 @@ describe Chef::Mixin::ParamsValidate do
   it "should accept keys that are strings in the options" do
     lambda {
       @vo.validate({ "one" => "two" }, { :one => { :regex => /^two$/ }})
-    }.should_not raise_error(ArgumentError)
+    }.should_not raise_error
   end
 
   it "should allow an array to kind_of" do
@@ -305,7 +305,7 @@ describe Chef::Mixin::ParamsValidate do
           }
         }
       )
-    }.should_not raise_error(ArgumentError)
+    }.should_not raise_error
     lambda {
       @vo.validate(
         {:one => ["string"]},
@@ -315,7 +315,7 @@ describe Chef::Mixin::ParamsValidate do
           }
         }
       )
-    }.should_not raise_error(ArgumentError)
+    }.should_not raise_error
     lambda {
       @vo.validate(
         {:one => Hash.new},
@@ -360,7 +360,7 @@ describe Chef::Mixin::ParamsValidate do
   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)
+    }.should_not raise_error
   end
 
   it "should set and return @name, then return @name for foo when argument is nil" do

data/spec/unit/mixin/path_sanity_spec.rb

@@ -33,9 +33,9 @@ describe Chef::Mixin::PathSanity do
       Chef::Config[:enforce_path_sanity] = true
       @ruby_bindir = '/some/ruby/bin'
       @gem_bindir = '/some/gem/bin'
-      Gem.stub!(:bindir).and_return(@gem_bindir)
-      RbConfig::CONFIG.stub!(:[]).with('bindir').and_return(@ruby_bindir)
-      Chef::Platform.stub!(:windows?).and_return(false)
+      Gem.stub(:bindir).and_return(@gem_bindir)
+      RbConfig::CONFIG.stub(:[]).with('bindir').and_return(@ruby_bindir)
+      Chef::Platform.stub(:windows?).and_return(false)
     end
 
     it "adds all useful PATHs even if environment is an empty hash" do
@@ -65,8 +65,8 @@ describe Chef::Mixin::PathSanity do
     it "does not create entries for Ruby/Gem bindirs if they exist in SANE_PATH or PATH" do
       ruby_bindir = '/usr/bin'
       gem_bindir = '/yo/gabba/gabba'
-      Gem.stub!(:bindir).and_return(gem_bindir)
-      RbConfig::CONFIG.stub!(:[]).with('bindir').and_return(ruby_bindir)
+      Gem.stub(:bindir).and_return(gem_bindir)
+      RbConfig::CONFIG.stub(:[]).with('bindir').and_return(ruby_bindir)
       env = {"PATH" => gem_bindir}
       @sanity.enforce_path_sanity(env)
       env["PATH"].should == "/yo/gabba/gabba:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
@@ -75,9 +75,9 @@ describe Chef::Mixin::PathSanity do
     it "builds a valid windows path" do
       ruby_bindir = 'C:\ruby\bin'
       gem_bindir = 'C:\gems\bin'
-      Gem.stub!(:bindir).and_return(gem_bindir)
-      RbConfig::CONFIG.stub!(:[]).with('bindir').and_return(ruby_bindir)
-      Chef::Platform.stub!(:windows?).and_return(true)
+      Gem.stub(:bindir).and_return(gem_bindir)
+      RbConfig::CONFIG.stub(:[]).with('bindir').and_return(ruby_bindir)
+      Chef::Platform.stub(:windows?).and_return(true)
       env = {"PATH" => 'C:\Windows\system32;C:\mr\softie'}
       @sanity.enforce_path_sanity(env)
       env["PATH"].should == "C:\\Windows\\system32;C:\\mr\\softie;#{ruby_bindir};#{gem_bindir}"

data/spec/unit/mixin/securable_spec.rb

@@ -28,14 +28,14 @@ describe Chef::Mixin::Securable do
   end
 
   it "should accept a group name or id for group" do
-    lambda { @securable.group "root" }.should_not raise_error(ArgumentError)
-    lambda { @securable.group 123 }.should_not raise_error(ArgumentError)
+    lambda { @securable.group "root" }.should_not raise_error
+    lambda { @securable.group 123 }.should_not raise_error
     lambda { @securable.group "+bad:group" }.should raise_error(ArgumentError)
   end
 
   it "should accept a user name or id for owner" do
-    lambda { @securable.owner "root" }.should_not raise_error(ArgumentError)
-    lambda { @securable.owner 123 }.should_not raise_error(ArgumentError)
+    lambda { @securable.owner "root" }.should_not raise_error
+    lambda { @securable.owner 123 }.should_not raise_error
     lambda { @securable.owner "+bad:owner" }.should raise_error(ArgumentError)
   end
 
@@ -55,30 +55,30 @@ describe Chef::Mixin::Securable do
     end
 
     it "should accept group/owner names with spaces and backslashes" do
-      lambda { @securable.group 'test\ group' }.should_not raise_error(ArgumentError)
-      lambda { @securable.owner 'test\ group' }.should_not raise_error(ArgumentError)
+      lambda { @securable.group 'test\ group' }.should_not raise_error
+      lambda { @securable.owner 'test\ group' }.should_not raise_error
     end
 
     it "should accept group/owner names that are a single character or digit" do
-      lambda { @securable.group 'v' }.should_not raise_error(ArgumentError)
-      lambda { @securable.group '1' }.should_not raise_error(ArgumentError)
-      lambda { @securable.owner 'v' }.should_not raise_error(ArgumentError)
-      lambda { @securable.owner '1' }.should_not raise_error(ArgumentError)
+      lambda { @securable.group 'v' }.should_not raise_error
+      lambda { @securable.group '1' }.should_not raise_error
+      lambda { @securable.owner 'v' }.should_not raise_error
+      lambda { @securable.owner '1' }.should_not raise_error
     end
 
     it "should not accept group/owner names starting with '-', '+', or '~'" do
       lambda { @securable.group '-test' }.should raise_error(ArgumentError)
       lambda { @securable.group '+test' }.should raise_error(ArgumentError)
       lambda { @securable.group '~test' }.should raise_error(ArgumentError)
-      lambda { @securable.group 'te-st' }.should_not raise_error(ArgumentError)
-      lambda { @securable.group 'te+st' }.should_not raise_error(ArgumentError)
-      lambda { @securable.group 'te~st' }.should_not raise_error(ArgumentError)
+      lambda { @securable.group 'te-st' }.should_not raise_error
+      lambda { @securable.group 'te+st' }.should_not raise_error
+      lambda { @securable.group 'te~st' }.should_not raise_error
       lambda { @securable.owner '-test' }.should raise_error(ArgumentError)
       lambda { @securable.owner '+test' }.should raise_error(ArgumentError)
       lambda { @securable.owner '~test' }.should raise_error(ArgumentError)
-      lambda { @securable.owner 'te-st' }.should_not raise_error(ArgumentError)
-      lambda { @securable.owner 'te+st' }.should_not raise_error(ArgumentError)
-      lambda { @securable.owner 'te~st' }.should_not raise_error(ArgumentError)
+      lambda { @securable.owner 'te-st' }.should_not raise_error
+      lambda { @securable.owner 'te+st' }.should_not raise_error
+      lambda { @securable.owner 'te~st' }.should_not raise_error
     end
 
     it "should not accept group/owner names containing ':', ',' or non-space whitespace" do
@@ -109,11 +109,11 @@ describe Chef::Mixin::Securable do
     end
 
     it "should accept Active Directory-style domain names pulled in via LDAP (on unix hosts)" do
-      lambda { @securable.owner "domain\@user" }.should_not raise_error(ArgumentError)
-      lambda { @securable.owner "domain\\user" }.should_not raise_error(ArgumentError)
-      lambda { @securable.group "domain\@group" }.should_not raise_error(ArgumentError)
-      lambda { @securable.group "domain\\group" }.should_not raise_error(ArgumentError)
-      lambda { @securable.group "domain\\group^name" }.should_not raise_error(ArgumentError)
+      lambda { @securable.owner "domain\@user" }.should_not raise_error
+      lambda { @securable.owner "domain\\user" }.should_not raise_error
+      lambda { @securable.group "domain\@group" }.should_not raise_error
+      lambda { @securable.group "domain\\group" }.should_not raise_error
+      lambda { @securable.group "domain\\group^name" }.should_not raise_error
     end
 
     it "should not accept group/owner names containing embedded carriage returns" do
@@ -125,22 +125,22 @@ describe Chef::Mixin::Securable do
     end
 
     it "should accept group/owner names in UTF-8" do
-      lambda { @securable.group 'tëst' }.should_not raise_error(ArgumentError)
-      lambda { @securable.group 'ë' }.should_not raise_error(ArgumentError)
-      lambda { @securable.owner 'tëst' }.should_not raise_error(ArgumentError)
-      lambda { @securable.owner 'ë' }.should_not raise_error(ArgumentError)
+      lambda { @securable.group 'tëst' }.should_not raise_error
+      lambda { @securable.group 'ë' }.should_not raise_error
+      lambda { @securable.owner 'tëst' }.should_not raise_error
+      lambda { @securable.owner 'ë' }.should_not raise_error
     end
 
     it "should accept a unix file mode in string form as an octal number" do
-      lambda { @securable.mode "0" }.should_not raise_error(ArgumentError)
-      lambda { @securable.mode "0000" }.should_not raise_error(ArgumentError)
-      lambda { @securable.mode "0111" }.should_not raise_error(ArgumentError)
-      lambda { @securable.mode "0444" }.should_not raise_error(ArgumentError)
+      lambda { @securable.mode "0" }.should_not raise_error
+      lambda { @securable.mode "0000" }.should_not raise_error
+      lambda { @securable.mode "0111" }.should_not raise_error
+      lambda { @securable.mode "0444" }.should_not raise_error
 
-      lambda { @securable.mode "111" }.should_not raise_error(ArgumentError)
-      lambda { @securable.mode "444" }.should_not raise_error(ArgumentError)
-      lambda { @securable.mode "7777" }.should_not raise_error(ArgumentError)
-      lambda { @securable.mode "07777" }.should_not raise_error(ArgumentError)
+      lambda { @securable.mode "111" }.should_not raise_error
+      lambda { @securable.mode "444" }.should_not raise_error
+      lambda { @securable.mode "7777" }.should_not raise_error
+      lambda { @securable.mode "07777" }.should_not raise_error
 
       lambda { @securable.mode "-01" }.should raise_error(ArgumentError)
       lambda { @securable.mode "010000" }.should raise_error(ArgumentError)
@@ -156,17 +156,17 @@ describe Chef::Mixin::Securable do
     end
 
     it "should accept a unix file mode in numeric form as a ruby-interpreted integer" do
-      lambda { @securable.mode 0 }.should_not raise_error(ArgumentError)
-      lambda { @securable.mode 0000 }.should_not raise_error(ArgumentError)
-      lambda { @securable.mode 444 }.should_not raise_error(ArgumentError)
-      lambda { @securable.mode 0444 }.should_not raise_error(ArgumentError)
-      lambda { @securable.mode 07777 }.should_not raise_error(ArgumentError)
+      lambda { @securable.mode 0 }.should_not raise_error
+      lambda { @securable.mode 0000 }.should_not raise_error
+      lambda { @securable.mode 444 }.should_not raise_error
+      lambda { @securable.mode 0444 }.should_not raise_error
+      lambda { @securable.mode 07777 }.should_not raise_error
 
-      lambda { @securable.mode 292 }.should_not raise_error(ArgumentError)
-      lambda { @securable.mode 4095 }.should_not raise_error(ArgumentError)
+      lambda { @securable.mode 292 }.should_not raise_error
+      lambda { @securable.mode 4095 }.should_not raise_error
 
-      lambda { @securable.mode 0111 }.should_not raise_error(ArgumentError)
-      lambda { @securable.mode 73 }.should_not raise_error(ArgumentError)
+      lambda { @securable.mode 0111 }.should_not raise_error
+      lambda { @securable.mode 73 }.should_not raise_error
 
       lambda { @securable.mode -01 }.should raise_error(ArgumentError)
       lambda { @securable.mode 010000 }.should raise_error(ArgumentError)
@@ -193,13 +193,13 @@ describe Chef::Mixin::Securable do
     end
 
     it "should accept a unix file mode in string form as an octal number" do
-      lambda { @securable.mode "0" }.should_not raise_error(ArgumentError)
-      lambda { @securable.mode "0000" }.should_not raise_error(ArgumentError)
-      lambda { @securable.mode "0111" }.should_not raise_error(ArgumentError)
-      lambda { @securable.mode "0444" }.should_not raise_error(ArgumentError)
+      lambda { @securable.mode "0" }.should_not raise_error
+      lambda { @securable.mode "0000" }.should_not raise_error
+      lambda { @securable.mode "0111" }.should_not raise_error
+      lambda { @securable.mode "0444" }.should_not raise_error
 
-      lambda { @securable.mode "111" }.should_not raise_error(ArgumentError)
-      lambda { @securable.mode "444" }.should_not raise_error(ArgumentError)
+      lambda { @securable.mode "111" }.should_not raise_error
+      lambda { @securable.mode "444" }.should_not raise_error
       lambda { @securable.mode "7777" }.should raise_error(ArgumentError)
       lambda { @securable.mode "07777" }.should raise_error(ArgumentError)
 
@@ -217,17 +217,17 @@ describe Chef::Mixin::Securable do
     end
 
     it "should accept a unix file mode in numeric form as a ruby-interpreted integer" do
-      lambda { @securable.mode 0 }.should_not raise_error(ArgumentError)
-      lambda { @securable.mode 0000 }.should_not raise_error(ArgumentError)
-      lambda { @securable.mode 444 }.should_not raise_error(ArgumentError)
-      lambda { @securable.mode 0444 }.should_not raise_error(ArgumentError)
+      lambda { @securable.mode 0 }.should_not raise_error
+      lambda { @securable.mode 0000 }.should_not raise_error
+      lambda { @securable.mode 444 }.should_not raise_error
+      lambda { @securable.mode 0444 }.should_not raise_error
       lambda { @securable.mode 07777 }.should raise_error(ArgumentError)
 
-      lambda { @securable.mode 292 }.should_not raise_error(ArgumentError)
+      lambda { @securable.mode 292 }.should_not raise_error
       lambda { @securable.mode 4095 }.should raise_error(ArgumentError)
 
-      lambda { @securable.mode 0111 }.should_not raise_error(ArgumentError)
-      lambda { @securable.mode 73 }.should_not raise_error(ArgumentError)
+      lambda { @securable.mode 0111 }.should_not raise_error
+      lambda { @securable.mode 73 }.should_not raise_error
 
       lambda { @securable.mode -01 }.should raise_error(ArgumentError)
       lambda { @securable.mode 010000 }.should raise_error(ArgumentError)
@@ -236,46 +236,46 @@ describe Chef::Mixin::Securable do
     end
 
     it "should allow you to specify :full_control, :modify, :read_execute, :read, and :write rights" do
-      lambda { @securable.rights :full_control, "The Dude" }.should_not raise_error(ArgumentError)
-      lambda { @securable.rights :modify, "The Dude" }.should_not raise_error(ArgumentError)
-      lambda { @securable.rights :read_execute, "The Dude" }.should_not raise_error(ArgumentError)
-      lambda { @securable.rights :read, "The Dude" }.should_not raise_error(ArgumentError)
-      lambda { @securable.rights :write, "The Dude" }.should_not raise_error(ArgumentError)
+      lambda { @securable.rights :full_control, "The Dude" }.should_not raise_error
+      lambda { @securable.rights :modify, "The Dude" }.should_not raise_error
+      lambda { @securable.rights :read_execute, "The Dude" }.should_not raise_error
+      lambda { @securable.rights :read, "The Dude" }.should_not raise_error
+      lambda { @securable.rights :write, "The Dude" }.should_not raise_error
       lambda { @securable.rights :to_party, "The Dude" }.should raise_error(ArgumentError)
     end
 
     it "should allow you to specify :full_control, :modify, :read_execute, :read, and :write deny_rights" do
-      lambda { @securable.deny_rights :full_control, "The Dude" }.should_not raise_error(ArgumentError)
-      lambda { @securable.deny_rights :modify, "The Dude" }.should_not raise_error(ArgumentError)
-      lambda { @securable.deny_rights :read_execute, "The Dude" }.should_not raise_error(ArgumentError)
-      lambda { @securable.deny_rights :read, "The Dude" }.should_not raise_error(ArgumentError)
-      lambda { @securable.deny_rights :write, "The Dude" }.should_not raise_error(ArgumentError)
+      lambda { @securable.deny_rights :full_control, "The Dude" }.should_not raise_error
+      lambda { @securable.deny_rights :modify, "The Dude" }.should_not raise_error
+      lambda { @securable.deny_rights :read_execute, "The Dude" }.should_not raise_error
+      lambda { @securable.deny_rights :read, "The Dude" }.should_not raise_error
+      lambda { @securable.deny_rights :write, "The Dude" }.should_not raise_error
       lambda { @securable.deny_rights :to_party, "The Dude" }.should raise_error(ArgumentError)
     end
 
     it "should accept a principal as a string or an array" do
-      lambda { @securable.rights :read, "The Dude" }.should_not raise_error(ArgumentError)
-      lambda { @securable.rights :read, ["The Dude","Donny"] }.should_not raise_error(ArgumentError)
+      lambda { @securable.rights :read, "The Dude" }.should_not raise_error
+      lambda { @securable.rights :read, ["The Dude","Donny"] }.should_not raise_error
       lambda { @securable.rights :read, 3 }.should raise_error(ArgumentError)
     end
 
     it "should allow you to specify whether the permissions applies_to_children with true/false/:containers_only/:objects_only" do
-      lambda { @securable.rights :read, "The Dude", :applies_to_children => false }.should_not raise_error(ArgumentError)
-      lambda { @securable.rights :read, "The Dude", :applies_to_children => true }.should_not raise_error(ArgumentError)
-      lambda { @securable.rights :read, "The Dude", :applies_to_children => :containers_only }.should_not raise_error(ArgumentError)
-      lambda { @securable.rights :read, "The Dude", :applies_to_children => :objects_only }.should_not raise_error(ArgumentError)
+      lambda { @securable.rights :read, "The Dude", :applies_to_children => false }.should_not raise_error
+      lambda { @securable.rights :read, "The Dude", :applies_to_children => true }.should_not raise_error
+      lambda { @securable.rights :read, "The Dude", :applies_to_children => :containers_only }.should_not raise_error
+      lambda { @securable.rights :read, "The Dude", :applies_to_children => :objects_only }.should_not raise_error
       lambda { @securable.rights :read, "The Dude", :applies_to_children => 'poop' }.should raise_error(ArgumentError)
     end
 
     it "should allow you to specify whether the permissions applies_to_self with true/false" do
-      lambda { @securable.rights :read, "The Dude", :applies_to_children => true, :applies_to_self => false }.should_not raise_error(ArgumentError)
-      lambda { @securable.rights :read, "The Dude", :applies_to_self => true }.should_not raise_error(ArgumentError)
+      lambda { @securable.rights :read, "The Dude", :applies_to_children => true, :applies_to_self => false }.should_not raise_error
+      lambda { @securable.rights :read, "The Dude", :applies_to_self => true }.should_not raise_error
       lambda { @securable.rights :read, "The Dude", :applies_to_self => 'poop' }.should raise_error(ArgumentError)
     end
 
     it "should allow you to specify whether the permissions applies one_level_deep with true/false" do
-      lambda { @securable.rights :read, "The Dude", :applies_to_children => true, :one_level_deep => false }.should_not raise_error(ArgumentError)
-      lambda { @securable.rights :read, "The Dude", :applies_to_children => true, :one_level_deep => true }.should_not raise_error(ArgumentError)
+      lambda { @securable.rights :read, "The Dude", :applies_to_children => true, :one_level_deep => false }.should_not raise_error
+      lambda { @securable.rights :read, "The Dude", :applies_to_children => true, :one_level_deep => true }.should_not raise_error
       lambda { @securable.rights :read, "The Dude", :applies_to_children => true, :one_level_deep => 'poop' }.should raise_error(ArgumentError)
     end
 
@@ -290,26 +290,26 @@ describe Chef::Mixin::Securable do
     end
 
     it "should allow you to specify whether the permission applies_to_self only if you specified applies_to_children" do
-      lambda { @securable.rights :read, "The Dude", :applies_to_children => true, :applies_to_self => true }.should_not raise_error(ArgumentError)
-      lambda { @securable.rights :read, "The Dude", :applies_to_children => true, :applies_to_self => false }.should_not raise_error(ArgumentError)
-      lambda { @securable.rights :read, "The Dude", :applies_to_children => false, :applies_to_self => true }.should_not raise_error(ArgumentError)
+      lambda { @securable.rights :read, "The Dude", :applies_to_children => true, :applies_to_self => true }.should_not raise_error
+      lambda { @securable.rights :read, "The Dude", :applies_to_children => true, :applies_to_self => false }.should_not raise_error
+      lambda { @securable.rights :read, "The Dude", :applies_to_children => false, :applies_to_self => true }.should_not raise_error
       lambda { @securable.rights :read, "The Dude", :applies_to_children => false, :applies_to_self => false }.should raise_error(ArgumentError)
-      lambda { @securable.rights :read, "The Dude", :applies_to_self => true }.should_not raise_error(ArgumentError)
-      lambda { @securable.rights :read, "The Dude", :applies_to_self => false }.should_not raise_error(ArgumentError)
+      lambda { @securable.rights :read, "The Dude", :applies_to_self => true }.should_not raise_error
+      lambda { @securable.rights :read, "The Dude", :applies_to_self => false }.should_not raise_error
     end
 
     it "should allow you to specify whether the permission applies one_level_deep only if you specified applies_to_children" do
-      lambda { @securable.rights :read, "The Dude", :applies_to_children => true, :one_level_deep => true }.should_not raise_error(ArgumentError)
-      lambda { @securable.rights :read, "The Dude", :applies_to_children => true, :one_level_deep => false }.should_not raise_error(ArgumentError)
+      lambda { @securable.rights :read, "The Dude", :applies_to_children => true, :one_level_deep => true }.should_not raise_error
+      lambda { @securable.rights :read, "The Dude", :applies_to_children => true, :one_level_deep => false }.should_not raise_error
       lambda { @securable.rights :read, "The Dude", :applies_to_children => false, :one_level_deep => true }.should raise_error(ArgumentError)
-      lambda { @securable.rights :read, "The Dude", :applies_to_children => false, :one_level_deep => false }.should_not raise_error(ArgumentError)
-      lambda { @securable.rights :read, "The Dude", :one_level_deep => true }.should_not raise_error(ArgumentError)
-      lambda { @securable.rights :read, "The Dude", :one_level_deep => false }.should_not raise_error(ArgumentError)
+      lambda { @securable.rights :read, "The Dude", :applies_to_children => false, :one_level_deep => false }.should_not raise_error
+      lambda { @securable.rights :read, "The Dude", :one_level_deep => true }.should_not raise_error
+      lambda { @securable.rights :read, "The Dude", :one_level_deep => false }.should_not raise_error
     end
 
     it "should allow you to specify whether the permissions inherit with true/false" do
-      lambda { @securable.inherits true }.should_not raise_error(ArgumentError)
-      lambda { @securable.inherits false }.should_not raise_error(ArgumentError)
+      lambda { @securable.inherits true }.should_not raise_error
+      lambda { @securable.inherits false }.should_not raise_error
       lambda { @securable.inherits "monkey" }.should raise_error(ArgumentError)
     end
   end