puppet 3.2.4 → 3.3.0.rc2

data/spec/unit/node/facts_spec.rb

@@ -14,25 +14,76 @@ describe Puppet::Node::Facts, "when indirecting" do
     @facts.values["one"].should == "1"
   end
 
-  it "should add the node's certificate name as the 'clientcert' fact when adding local facts" do
-    @facts.add_local_facts
-    @facts.values["clientcert"].should == Puppet.settings[:certname]
-  end
+  describe "adding local facts" do
+    it "should add the node's certificate name as the 'clientcert' fact" do
+      @facts.add_local_facts
+      @facts.values["clientcert"].should == Puppet.settings[:certname]
+    end
 
-  it "should add the Puppet version as a 'clientversion' fact when adding local facts" do
-    @facts.add_local_facts
-    @facts.values["clientversion"].should == Puppet.version.to_s
-  end
+    it "adds the Puppet version as a 'clientversion' fact" do
+      @facts.add_local_facts
+      @facts.values["clientversion"].should == Puppet.version.to_s
+    end
+
+    it "adds the agent side noop setting as 'clientnoop'" do
+      @facts.add_local_facts
+      @facts.values["clientnoop"].should == Puppet.settings[:noop]
+    end
 
-  it "should not add the current environment" do
-    @facts.add_local_facts
-    @facts.values.should_not include("environment")
+    it "doesn't add the current environment" do
+      @facts.add_local_facts
+      @facts.values.should_not include("environment")
+    end
+
+    it "doesn't replace any existing environment fact when adding local facts" do
+      @facts.values["environment"] = "foo"
+      @facts.add_local_facts
+      @facts.values["environment"].should == "foo"
+    end
   end
 
-  it "should not replace any existing environment fact when adding local facts" do
-    @facts.values["environment"] = "foo"
-    @facts.add_local_facts
-    @facts.values["environment"].should == "foo"
+  describe "when sanitizing facts" do
+    it "should convert fact values if needed" do
+      @facts.values["test"] = /foo/
+      @facts.sanitize
+      @facts.values["test"].should == "(?-mix:foo)"
+    end
+
+    it "should convert hash keys if needed" do
+      @facts.values["test"] = {/foo/ => "bar"}
+      @facts.sanitize
+      @facts.values["test"].should == {"(?-mix:foo)" => "bar"}
+    end
+
+    it "should convert hash values if needed" do
+      @facts.values["test"] = {"foo" => /bar/}
+      @facts.sanitize
+      @facts.values["test"].should == {"foo" => "(?-mix:bar)"}
+    end
+
+    it "should convert array elements if needed" do
+      @facts.values["test"] = [1, "foo", /bar/]
+      @facts.sanitize
+      @facts.values["test"].should == [1, "foo", "(?-mix:bar)"]
+    end
+
+    it "should handle nested arrays" do
+      @facts.values["test"] = [1, "foo", [/bar/]]
+      @facts.sanitize
+      @facts.values["test"].should == [1, "foo", ["(?-mix:bar)"]]
+    end
+
+    it "should handle nested hashes" do
+      @facts.values["test"] = {/foo/ => {"bar" => /baz/}}
+      @facts.sanitize
+      @facts.values["test"].should == {"(?-mix:foo)" => {"bar" => "(?-mix:baz)"}}
+    end
+
+    it "should handle nester arrays and hashes" do
+      @facts.values["test"] = {/foo/ => ["bar", /baz/]}
+      @facts.sanitize
+      @facts.values["test"].should == {"(?-mix:foo)" => ["bar", "(?-mix:baz)"]}
+    end
   end
 
   describe "when indirecting" do
@@ -67,7 +118,7 @@ describe Puppet::Node::Facts, "when indirecting" do
   describe "when storing and retrieving" do
     it "should add metadata to the facts" do
       facts = Puppet::Node::Facts.new("me", "one" => "two", "three" => "four")
-      facts.values[:_timestamp].should be_instance_of(Time)
+      facts.values['_timestamp'].should be_instance_of(Time)
     end
 
     describe "using pson" do
@@ -82,7 +133,7 @@ describe Puppet::Node::Facts, "when indirecting" do
         facts = format.intern(Puppet::Node::Facts,pson)
         facts.name.should == 'foo'
         facts.expiration.should == @expiration
-        facts.values.should == {'a' => '1', 'b' => '2', 'c' => '3', :_timestamp => @timestamp}
+        facts.values.should == {'a' => '1', 'b' => '2', 'c' => '3', '_timestamp' => @timestamp}
       end
 
       it "should generate properly formatted pson" do

data/spec/unit/other/selinux_spec.rb

@@ -9,23 +9,24 @@ describe Puppet::Type.type(:file), " when manipulating file contexts" do
 
   before :each do
 
-          @file = Puppet::Type::File.new(
-                
+    @file = Puppet::Type::File.new(
       :name => make_absolute("/tmp/foo"),
       :ensure => "file",
       :seluser => "user_u",
       :selrole => "role_r",
-        
-      :seltype => "type_t" )
+      :seltype => "type_t")
   end
+
   it "should use :seluser to get/set an SELinux user file context attribute" do
-    @file.property(:seluser).should == "user_u"
+    expect(@file[:seluser]).to eq("user_u")
   end
+
   it "should use :selrole to get/set an SELinux role file context attribute" do
-    @file.property(:selrole).should == "role_r"
+    expect(@file[:selrole]).to eq("role_r")
   end
+
   it "should use :seltype to get/set an SELinux user file context attribute" do
-    @file.property(:seltype).should == "type_t"
+    expect(@file[:seltype]).to eq("type_t")
   end
 end
 
@@ -34,27 +35,29 @@ describe Puppet::Type.type(:selboolean), " when manipulating booleans" do
     provider_class = Puppet::Type::Selboolean.provider(Puppet::Type::Selboolean.providers[0])
     Puppet::Type::Selboolean.stubs(:defaultprovider).returns provider_class
 
-
-          @bool = Puppet::Type::Selboolean.new(
-                
+    @bool = Puppet::Type::Selboolean.new(
       :name => "foo",
       :value => "on",
-        
       :persistent => true )
   end
+
   it "should be able to access :name" do
     @bool[:name].should == "foo"
   end
+
   it "should be able to access :value" do
-    @bool.property(:value).should == :on
+    expect(@bool.property(:value).should).to eq(:on)
   end
+
   it "should set :value to off" do
     @bool[:value] = :off
-    @bool.property(:value).should == :off
+    expect(@bool.property(:value).should).to eq(:off)
   end
+
   it "should be able to access :persistent" do
     @bool[:persistent].should == :true
   end
+
   it "should set :persistent to false" do
     @bool[:persistent] = false
     @bool[:persistent].should == :false
@@ -66,30 +69,31 @@ describe Puppet::Type.type(:selmodule), " when checking policy modules" do
     provider_class = Puppet::Type::Selmodule.provider(Puppet::Type::Selmodule.providers[0])
     Puppet::Type::Selmodule.stubs(:defaultprovider).returns provider_class
 
-
-          @module = Puppet::Type::Selmodule.new(
-                
+    @module = Puppet::Type::Selmodule.new(
       :name => "foo",
       :selmoduledir => "/some/path",
       :selmodulepath => "/some/path/foo.pp",
-        
       :syncversion => true)
   end
+
   it "should be able to access :name" do
     @module[:name].should == "foo"
   end
+
   it "should be able to access :selmoduledir" do
     @module[:selmoduledir].should == "/some/path"
   end
+
   it "should be able to access :selmodulepath" do
     @module[:selmodulepath].should == "/some/path/foo.pp"
   end
+
   it "should be able to access :syncversion" do
-    @module.property(:syncversion).should == :true
+    expect(@module[:syncversion]).to eq(:true)
   end
+
   it "should set the syncversion value to false" do
     @module[:syncversion] = :false
-    @module.property(:syncversion).should == :false
+    expect(@module[:syncversion]).to eq(:false)
   end
 end
-

data/spec/unit/parameter/boolean_spec.rb

@@ -0,0 +1,25 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet'
+require 'puppet/parameter/boolean'
+
+describe Puppet::Parameter::Boolean do
+  let (:resource) { mock('resource') }
+  subject { described_class.new(:resource => resource) }
+
+  [ true, :true, 'true', :yes, 'yes', 'TrUe', 'yEs' ].each do |arg|
+    it "should munge #{arg.inspect} as true" do
+      subject.munge(arg).should == true
+    end
+  end
+  [ false, :false, 'false', :no, 'no', 'FaLSE', 'nO' ].each do |arg|
+    it "should munge #{arg.inspect} as false" do
+      subject.munge(arg).should == false
+    end
+  end
+  [ nil, :undef, 'undef', '0', 0, '1', 1, 9284 ].each do |arg|
+    it "should fail to munge #{arg.inspect}" do
+      expect { subject.munge(arg) }.to raise_error Puppet::Error
+    end
+  end
+end

data/spec/unit/parameter/value_collection_spec.rb

@@ -27,7 +27,7 @@ describe Puppet::Parameter::ValueCollection do
   end
 
   it "should be able to add values that are empty strings" do
-    lambda { @collection.newvalue('') }.should_not raise_error
+    expect { @collection.newvalue('') }.to_not raise_error
   end
 
   it "should be able to add values that are empty strings" do
@@ -107,33 +107,33 @@ describe Puppet::Parameter::ValueCollection do
 
     it "should fail if the value is not a defined value or alias and does not match a regex" do
       @collection.newvalues :foo
-      lambda { @collection.validate("bar") }.should raise_error(ArgumentError)
+      expect { @collection.validate("bar") }.to raise_error(ArgumentError)
     end
 
     it "should succeed if the value is one of the defined values" do
       @collection.newvalues :foo
-      lambda { @collection.validate(:foo) }.should_not raise_error(ArgumentError)
+      expect { @collection.validate(:foo) }.to_not raise_error
     end
 
     it "should succeed if the value is one of the defined values even if the definition uses a symbol and the validation uses a string" do
       @collection.newvalues :foo
-      lambda { @collection.validate("foo") }.should_not raise_error(ArgumentError)
+      expect { @collection.validate("foo") }.to_not raise_error
     end
 
     it "should succeed if the value is one of the defined values even if the definition uses a string and the validation uses a symbol" do
       @collection.newvalues "foo"
-      lambda { @collection.validate(:foo) }.should_not raise_error(ArgumentError)
+      expect { @collection.validate(:foo) }.to_not raise_error
     end
 
     it "should succeed if the value is one of the defined aliases" do
       @collection.newvalues :foo
       @collection.aliasvalue :bar, :foo
-      lambda { @collection.validate("bar") }.should_not raise_error(ArgumentError)
+      expect { @collection.validate("bar") }.to_not raise_error
     end
 
     it "should succeed if the value matches one of the regexes" do
       @collection.newvalues %r{\d}
-      lambda { @collection.validate("10") }.should_not raise_error(ArgumentError)
+      expect { @collection.validate("10") }.to_not raise_error
     end
   end
 

data/spec/unit/parameter_spec.rb

@@ -37,11 +37,8 @@ describe Puppet::Parameter do
     @parameter.tags.should == %w{one two foo}
   end
 
-  it "should provide source_descriptors" do
-    @resource.expects(:line).returns 10
-    @resource.expects(:file).returns "file"
-    @resource.expects(:tags).returns %w{one two}
-    @parameter.source_descriptors.should == {:tags=>["one", "two", "foo"], :path=>"//foo", :file => "file", :line => 10}
+  it "should have a path" do
+    @parameter.path.should == "//foo"
   end
 
   describe "when returning the value" do
@@ -83,38 +80,38 @@ describe Puppet::Parameter do
 
     it "should catch abnormal failures thrown during validation" do
       @class.validate { |v| raise "This is broken" }
-      lambda { @parameter.validate("eh") }.should raise_error(Puppet::DevError)
+      expect { @parameter.validate("eh") }.to raise_error(Puppet::DevError)
     end
 
     it "should fail if the value is not a defined value or alias and does not match a regex" do
       @class.newvalues :foo
-      lambda { @parameter.validate("bar") }.should raise_error(Puppet::Error)
+      expect { @parameter.validate("bar") }.to raise_error(Puppet::Error)
     end
 
     it "should succeed if the value is one of the defined values" do
       @class.newvalues :foo
-      lambda { @parameter.validate(:foo) }.should_not raise_error(ArgumentError)
+      expect { @parameter.validate(:foo) }.to_not raise_error
     end
 
     it "should succeed if the value is one of the defined values even if the definition uses a symbol and the validation uses a string" do
       @class.newvalues :foo
-      lambda { @parameter.validate("foo") }.should_not raise_error(ArgumentError)
+      expect { @parameter.validate("foo") }.to_not raise_error
     end
 
     it "should succeed if the value is one of the defined values even if the definition uses a string and the validation uses a symbol" do
       @class.newvalues "foo"
-      lambda { @parameter.validate(:foo) }.should_not raise_error(ArgumentError)
+      expect { @parameter.validate(:foo) }.to_not raise_error
     end
 
     it "should succeed if the value is one of the defined aliases" do
       @class.newvalues :foo
       @class.aliasvalue :bar, :foo
-      lambda { @parameter.validate("bar") }.should_not raise_error(ArgumentError)
+      expect { @parameter.validate("bar") }.to_not raise_error
     end
 
     it "should succeed if the value matches one of the regexes" do
       @class.newvalues %r{\d}
-      lambda { @parameter.validate("10") }.should_not raise_error(ArgumentError)
+      expect { @parameter.validate("10") }.to_not raise_error
     end
   end
 
@@ -125,7 +122,7 @@ describe Puppet::Parameter do
 
     it "should catch abnormal failures thrown during munging" do
       @class.munge { |v| raise "This is broken" }
-      lambda { @parameter.munge("eh") }.should raise_error(Puppet::DevError)
+      expect { @parameter.munge("eh") }.to raise_error(Puppet::DevError)
     end
 
     it "should return return any matching defined values" do

data/spec/unit/parser/ast/function_spec.rb

@@ -10,7 +10,7 @@ describe Puppet::Parser::AST::Function do
     it "should not fail if the function doesn't exist" do
       Puppet::Parser::Functions.stubs(:function).returns(false)
 
-      lambda{ Puppet::Parser::AST::Function.new :name => "dontexist" }.should_not raise_error(Puppet::ParseError)
+      expect{ Puppet::Parser::AST::Function.new :name => "dontexist" }.to_not raise_error
 
     end
   end
@@ -27,7 +27,7 @@ describe Puppet::Parser::AST::Function do
       Puppet::Parser::Functions.stubs(:function).returns(false)
       func = Puppet::Parser::AST::Function.new :name => "dontexist"
 
-      lambda{ func.evaluate(@scope) }.should raise_error(Puppet::ParseError)
+      expect{ func.evaluate(@scope) }.to raise_error(Puppet::ParseError)
     end
 
     it "should fail if the function is a statement used as rvalue" do
@@ -36,7 +36,7 @@ describe Puppet::Parser::AST::Function do
 
       func = Puppet::Parser::AST::Function.new :name => "exist", :ftype => :rvalue
 
-      lambda{ func.evaluate(@scope) }.should raise_error(Puppet::ParseError, "Function 'exist' does not return a value")
+      expect{ func.evaluate(@scope) }.to raise_error(Puppet::ParseError, "Function 'exist' does not return a value")
     end
 
     it "should fail if the function is an rvalue used as statement" do
@@ -45,7 +45,7 @@ describe Puppet::Parser::AST::Function do
 
       func = Puppet::Parser::AST::Function.new :name => "exist", :ftype => :statement
 
-      lambda{ func.evaluate(@scope) }.should raise_error(Puppet::ParseError,"Function 'exist' must be the value of a statement")
+      expect{ func.evaluate(@scope) }.to raise_error(Puppet::ParseError,"Function 'exist' must be the value of a statement")
     end
 
     it "should evaluate its arguments" do

data/spec/unit/parser/ast/leaf_spec.rb

@@ -10,7 +10,7 @@ describe Puppet::Parser::AST::Leaf do
     @leaf = Puppet::Parser::AST::Leaf.new(:value => @value)
   end
 
-  it "should have a evaluate_match method" do
+  it "should have an evaluate_match method" do
     Puppet::Parser::AST::Leaf.new(:value => "value").should respond_to(:evaluate_match)
   end
 
@@ -177,7 +177,7 @@ describe Puppet::Parser::AST::HashOrArrayAccess do
       access.evaluate(@scope).should == :undef
     end
 
-    it "should be able to return an hash value" do
+    it "should be able to return a hash value" do
       @scope["a"] = { "key1" => "val1", "key2" => "val2", "key3" => "val3" }
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key2" )
@@ -193,7 +193,7 @@ describe Puppet::Parser::AST::HashOrArrayAccess do
       access.evaluate(@scope).should == :undef
     end
 
-    it "should be able to return an hash value with a numerical key" do
+    it "should be able to return a hash value with a numerical key" do
       @scope["a"] = { "key1" => "val1", "key2" => "val2", "45" => "45", "key3" => "val3" }
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "45" )
@@ -201,7 +201,7 @@ describe Puppet::Parser::AST::HashOrArrayAccess do
       access.evaluate(@scope).should == "45"
     end
 
-    it "should raise an error if the variable lookup didn't return an hash or an array" do
+    it "should raise an error if the variable lookup didn't return a hash or an array" do
       @scope["a"] = "I'm a string"
 
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key2" )
@@ -237,6 +237,45 @@ describe Puppet::Parser::AST::HashOrArrayAccess do
 
       access2.evaluate(@scope).should == 'b'
     end
+
+    it "should raise a useful error for hash access on undef" do
+      @scope["a"] = :undef
+
+      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key")
+
+      expect {
+        access.evaluate(@scope)
+      }.to raise_error(Puppet::ParseError, /not a hash or array/)
+    end
+
+    it "should raise a useful error for hash access on TrueClass" do
+      @scope["a"] = true
+
+      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key")
+
+      expect {
+        access.evaluate(@scope)
+      }.to raise_error(Puppet::ParseError, /not a hash or array/)
+    end
+
+    it "should raise a useful error for recursive undef hash access" do
+      @scope["a"] = { "key" => "val" }
+
+      access1 = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "nonexistent")
+      access2 = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => access1, :key => "subkey")
+
+      expect {
+        access2.evaluate(@scope)
+      }.to raise_error(Puppet::ParseError, /not a hash or array/)
+    end
+
+    it "should produce boolean values when value is a boolean" do
+      @scope["a"] = [true, false]
+      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => 0 )
+      expect(access.evaluate(@scope)).to be == true
+      access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => 1 )
+      expect(access.evaluate(@scope)).to be == false
+    end
   end
 
   describe "when assigning" do
@@ -274,7 +313,7 @@ describe Puppet::Parser::AST::HashOrArrayAccess do
       scope['a'].should == ["val2"]
     end
 
-    it "should raise an error when trying to overwrite an hash value" do
+    it "should raise an error when trying to overwrite a hash value" do
       @scope['a'] = { "key" => [ "a" , "b" ]}
       access = Puppet::Parser::AST::HashOrArrayAccess.new(:variable => "a", :key => "key")
 
@@ -425,7 +464,7 @@ describe Puppet::Parser::AST::HostName do
   end
 
   it "should raise an error if hostname is not valid" do
-    lambda { Puppet::Parser::AST::HostName.new( :value => "not an hostname!" ) }.should raise_error
+    lambda { Puppet::Parser::AST::HostName.new( :value => "not a hostname!" ) }.should raise_error
   end
 
   it "should not raise an error if hostname is a regex" do