puppet 2.7.6 → 2.7.8

data/spec/unit/indirector/node/store_configs_spec.rb

@@ -1,6 +1,7 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet/node'
+require 'puppet/indirector/memory'
 require 'puppet/indirector/node/store_configs'
 
 class Puppet::Node::StoreConfigsTesting < Puppet::Indirector::Memory

data/spec/unit/indirector/resource/ral_spec.rb

@@ -2,7 +2,7 @@
 require 'spec_helper'
 
 describe "Puppet::Resource::Ral" do
-  describe "find", :fails_on_windows => true do
+  describe "find" do
     before do
       @request = stub 'request', :key => "user/root"
     end

data/spec/unit/indirector/resource_type/parser_spec.rb

@@ -25,7 +25,7 @@ describe Puppet::Indirector::ResourceType::Parser do
       @terminus.find(@request).should == type
     end
 
-    it "should attempt to load the type if none is found in memory", :fails_on_windows => true do
+    it "should attempt to load the type if none is found in memory" do
       dir = tmpdir("find_a_type")
       FileUtils.mkdir_p(dir)
       Puppet[:modulepath] = dir
@@ -122,7 +122,7 @@ describe Puppet::Indirector::ResourceType::Parser do
       @terminus.search(@request).should be_nil
     end
 
-    it "should load all resource types from all search paths", :fails_on_windows => true do
+    it "should load all resource types from all search paths" do
       dir = tmpdir("searching_in_all")
       first = File.join(dir, "first")
       second = File.join(dir, "second")

data/spec/unit/indirector/rest_spec.rb

@@ -104,7 +104,7 @@ describe Puppet::Indirector::REST do
       end.to raise_error(/This is often because the time is out of sync on the server or client/)
     end
 
-    it "should provide a helpful error message when hostname was not match with server certificate" do
+    it "should provide a helpful error message when hostname was not match with server certificate", :unless => Puppet.features.microsoft_windows? do
       Puppet[:confdir] = tmpdir('conf')
       cert = Puppet::SSL::CertificateAuthority.new.generate('not_my_server', :dns_alt_names => 'foo,bar,baz').content
 

data/spec/unit/network/handler/ca_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 require 'puppet/network/handler/ca'
 
-describe Puppet::Network::Handler::CA do
+describe Puppet::Network::Handler::CA, :unless => Puppet.features.microsoft_windows? do
   include PuppetSpec::Files
 
   describe "#getcert" do

data/spec/unit/network/http/mongrel/rest_spec.rb

@@ -57,7 +57,7 @@ describe "Puppet::Network::HTTP::MongrelREST", :if => Puppet.features.mongrel?,
       end
 
       it "should return the request body as the body" do
-        @request.expects(:body).returns StringIO.new("mybody")
+        @request.stubs(:body).returns StringIO.new("mybody")
         @handler.body(@request).should == "mybody"
       end
 
@@ -109,136 +109,165 @@ describe "Puppet::Network::HTTP::MongrelREST", :if => Puppet.features.mongrel?,
 
     describe "and determining the request parameters" do
       before do
-        @request.stubs(:params).returns({})
+        @params = {'REQUEST_METHOD' => 'GET'}
+        @request.stubs(:params).returns(@params)
       end
 
       it "should skip empty parameter values" do
-        @request.expects(:params).returns('QUERY_STRING' => "&=")
+        @params['QUERY_STRING'] = "&="
         lambda { @handler.params(@request) }.should_not raise_error
       end
 
       it "should include the HTTP request parameters, with the keys as symbols" do
-        @request.expects(:params).returns('QUERY_STRING' => 'foo=baz&bar=xyzzy')
+        @params['QUERY_STRING'] = 'foo=baz&bar=xyzzy'
         result = @handler.params(@request)
         result[:foo].should == "baz"
         result[:bar].should == "xyzzy"
       end
 
       it "should CGI-decode the HTTP parameters" do
-        encoding = CGI.escape("foo bar")
-        @request.expects(:params).returns('QUERY_STRING' => "foo=#{encoding}")
+        escaped = CGI.escape("foo bar")
+        @params['QUERY_STRING'] = "foo=#{escaped}"
         result = @handler.params(@request)
         result[:foo].should == "foo bar"
       end
 
+      it "should include parameters from the body of a POST request" do
+        @params.merge!(
+          'QUERY_STRING'   => nil,
+          'REQUEST_METHOD' => 'POST'
+        )
+        body = StringIO.new('foo=bar&baz=qux')
+        @request.stubs(:body).returns(body)
+
+        @handler.params(@request).should include(
+          :foo => 'bar',
+          :baz => 'qux'
+        )
+      end
+
       it "should convert the string 'true' to the boolean" do
-        @request.expects(:params).returns('QUERY_STRING' => 'foo=true')
+        @params['QUERY_STRING'] = 'foo=true'
         result = @handler.params(@request)
         result[:foo].should be_true
       end
 
       it "should convert the string 'false' to the boolean" do
-        @request.expects(:params).returns('QUERY_STRING' => 'foo=false')
+        @params['QUERY_STRING'] = 'foo=false'
         result = @handler.params(@request)
         result[:foo].should be_false
       end
 
       it "should convert integer arguments to Integers" do
-        @request.expects(:params).returns('QUERY_STRING' => 'foo=15')
+        @params['QUERY_STRING'] = 'foo=15'
         result = @handler.params(@request)
         result[:foo].should == 15
       end
 
       it "should convert floating point arguments to Floats" do
-        @request.expects(:params).returns('QUERY_STRING' => 'foo=1.5')
+        @params['QUERY_STRING'] = 'foo=1.5'
         result = @handler.params(@request)
         result[:foo].should == 1.5
       end
 
       it "should YAML-load and URI-decode values that are YAML-encoded" do
         escaping = CGI.escape(YAML.dump(%w{one two}))
-        @request.expects(:params).returns('QUERY_STRING' => "foo=#{escaping}")
+        @params['QUERY_STRING'] = "foo=#{escaping}"
         result = @handler.params(@request)
         result[:foo].should == %w{one two}
       end
 
       it "should not allow the client to set the node via the query string" do
-        @request.stubs(:params).returns('QUERY_STRING' => "node=foo")
+        @params['QUERY_STRING'] = "node=foo"
         @handler.params(@request)[:node].should be_nil
       end
 
       it "should not allow the client to set the IP address via the query string" do
-        @request.stubs(:params).returns('QUERY_STRING' => "ip=foo")
+        @params['QUERY_STRING'] = "ip=foo"
         @handler.params(@request)[:ip].should be_nil
       end
 
       it "should pass the client's ip address to model find" do
-        @request.stubs(:params).returns("REMOTE_ADDR" => "ipaddress")
+        @params['REMOTE_ADDR'] = "ipaddress"
         @handler.params(@request)[:ip].should == "ipaddress"
       end
 
       it "should pass the client's provided X-Forwared-For value as the ip" do
-        @request.stubs(:params).returns("HTTP_X_FORWARDED_FOR" => "ipaddress")
+        @params["HTTP_X_FORWARDED_FOR"] = "ipaddress"
         @handler.params(@request)[:ip].should == "ipaddress"
       end
 
       it "should pass the client's provided X-Forwared-For first value as the ip" do
-        @request.stubs(:params).returns("HTTP_X_FORWARDED_FOR" => "ipproxy1,ipproxy2,ipaddress")
+        @params["HTTP_X_FORWARDED_FOR"] = "ipproxy1,ipproxy2,ipaddress"
         @handler.params(@request)[:ip].should == "ipaddress"
       end
 
       it "should pass the client's provided X-Forwared-For value as the ip instead of the REMOTE_ADDR" do
-        @request.stubs(:params).returns("REMOTE_ADDR" => "remote_addr")
-        @request.stubs(:params).returns("HTTP_X_FORWARDED_FOR" => "ipaddress")
+        @params.merge!(
+          "REMOTE_ADDR"          => "remote_addr",
+          "HTTP_X_FORWARDED_FOR" => "ipaddress"
+        )
         @handler.params(@request)[:ip].should == "ipaddress"
       end
 
       it "should use the :ssl_client_header to determine the parameter when looking for the certificate" do
         Puppet.settings.stubs(:value).returns "eh"
         Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
-        @request.stubs(:params).returns("myheader" => "/CN=host.domain.com")
+        @params["myheader"] = "/CN=host.domain.com"
         @handler.params(@request)
       end
 
       it "should retrieve the hostname by matching the certificate parameter" do
         Puppet.settings.stubs(:value).returns "eh"
         Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
-        @request.stubs(:params).returns("myheader" => "/CN=host.domain.com")
+        @params["myheader"] = "/CN=host.domain.com"
         @handler.params(@request)[:node].should == "host.domain.com"
       end
 
       it "should use the :ssl_client_header to determine the parameter for checking whether the host certificate is valid" do
         Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
         Puppet.settings.expects(:value).with(:ssl_client_verify_header).returns "myheader"
-        @request.stubs(:params).returns("myheader" => "SUCCESS", "certheader" => "/CN=host.domain.com")
+        @params.merge!(
+          "myheader"   => "SUCCESS",
+          "certheader" => "/CN=host.domain.com"
+        )
         @handler.params(@request)
       end
 
       it "should consider the host authenticated if the validity parameter contains 'SUCCESS'" do
         Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
         Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
-        @request.stubs(:params).returns("myheader" => "SUCCESS", "certheader" => "/CN=host.domain.com")
+        @params.merge!(
+          "myheader"   => "SUCCESS",
+          "certheader" => "/CN=host.domain.com"
+        )
         @handler.params(@request)[:authenticated].should be_true
       end
 
       it "should consider the host unauthenticated if the validity parameter does not contain 'SUCCESS'" do
         Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
         Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
-        @request.stubs(:params).returns("myheader" => "whatever", "certheader" => "/CN=host.domain.com")
+        @params.merge!(
+          "myheader"   => "whatever",
+          "certheader" => "/CN=host.domain.com"
+        )
         @handler.params(@request)[:authenticated].should be_false
       end
 
       it "should consider the host unauthenticated if no certificate information is present" do
         Puppet.settings.stubs(:value).with(:ssl_client_header).returns "certheader"
         Puppet.settings.stubs(:value).with(:ssl_client_verify_header).returns "myheader"
-        @request.stubs(:params).returns("myheader" => nil, "certheader" => "SUCCESS")
+        @params.merge!(
+          "myheader"   => nil,
+          "certheader" => "SUCCESS"
+        )
         @handler.params(@request)[:authenticated].should be_false
       end
 
       it "should resolve the node name with an ip address look-up if no certificate is present" do
         Puppet.settings.stubs(:value).returns "eh"
         Puppet.settings.expects(:value).with(:ssl_client_header).returns "myheader"
-        @request.stubs(:params).returns("myheader" => nil)
+        @params["myheader"] = nil
         @handler.expects(:resolve_node).returns("host.domain.com")
         @handler.params(@request)[:node].should == "host.domain.com"
       end

data/spec/unit/parameter_spec.rb

@@ -157,4 +157,40 @@ describe Puppet::Parameter do
       @parameter.log "mymessage"
     end
   end
+
+  describe ".format_value_for_display" do
+    it 'should format strings appropriately' do
+      described_class.format_value_for_display('foo').should == "'foo'"
+    end
+
+    it 'should format numbers appropriately' do
+      described_class.format_value_for_display(1).should == "'1'"
+    end
+
+    it 'should format symbols appropriately' do
+      described_class.format_value_for_display(:bar).should == "'bar'"
+    end
+
+    it 'should format arrays appropriately' do
+      described_class.format_value_for_display([1, 'foo', :bar]).should == "['1', 'foo', 'bar']"
+    end
+
+    it 'should format hashes appropriately' do
+      described_class.format_value_for_display(
+        {1 => 'foo', :bar => 2, 'baz' => :qux}
+      ).should == "{'1' => 'foo', 'bar' => '2', 'baz' => 'qux'}"
+    end
+
+    it 'should format arrays with nested data appropriately' do
+      described_class.format_value_for_display(
+        [1, 'foo', :bar, [1, 2, 3], {1 => 2, 3 => 4}]
+      ).should == "['1', 'foo', 'bar', ['1', '2', '3'], {'1' => '2', '3' => '4'}]"
+    end
+
+    it 'should format hashes with nested data appropriately' do
+      described_class.format_value_for_display(
+        {1 => 'foo', :bar => [2, 3, 4], 'baz' => {:qux => 1, :quux => 'two'}}
+      ).should == "{'1' => 'foo', 'bar' => ['2', '3', '4'], 'baz' => {'quux' => 'two', 'qux' => '1'}}"
+    end
+  end
 end

data/spec/unit/parser/parser_spec.rb

@@ -369,6 +369,10 @@ describe Puppet::Parser do
       @parser.parse("class foobar { $var = val }").code[0].code.should_not be_nil
     end
 
+    it "should accept parametrized classes with trailing comma" do
+      @parser.parse("class foobar ($var1 = 0,) { $var = val }").code[0].code.should_not be_nil
+    end
+
     it "should define parameters when provided" do
       foobar = @parser.parse("class foobar($biz,$baz) {}").code[0].instantiate('')[0]
       foobar.arguments.should == {"biz" => nil, "baz" => nil}

data/spec/unit/property_spec.rb

@@ -109,12 +109,12 @@ describe Puppet::Property do
     end
   end
 
-  describe "when creating an event", :fails_on_windows => true do
+  describe "when creating an event" do
     before do
       @event = Puppet::Transaction::Event.new
 
       # Use a real resource so we can test the event creation integration
-      @resource = Puppet::Type.type(:mount).new :name => "foo"
+      @resource = Puppet::Type.type(:host).new :name => "foo"
       @instance = @class.new(:resource => @resource)
       @instance.stubs(:should).returns "myval"
     end

data/spec/unit/provider/exec/windows_spec.rb

@@ -9,6 +9,7 @@ describe Puppet::Type.type(:exec).provider(:windows) do
   let(:provider) { described_class.new(resource) }
 
   before :each do
+    Facter.stubs(:value).with(:operatingsystem).returns 'Windows'
     Puppet.features.stubs(:microsoft_windows?).returns(true)
     Puppet.features.stubs(:posix?).returns(false)
   end
@@ -77,19 +78,12 @@ describe Puppet::Type.type(:exec).provider(:windows) do
         end
 
         it "should search for executables with no extension" do
+          provider.resource[:path] = [File.expand_path('/bogus/bin')]
           provider.expects(:which).with('foo').returns('foo')
 
           provider.checkexe('foo')
         end
 
-        %w[bat com ps1 exe].each do |ext|
-          it "should search for executables with the extension '#{ext}'" do
-            provider.expects(:which).with("foo.#{ext}").returns("foo.#{ext}")
-
-            provider.checkexe('foo')
-          end
-        end
-
         it "should fail if the command isn't in the path" do
           expect { provider.checkexe('foo') }.to raise_error(ArgumentError, "Could not find command 'foo'")
         end

data/spec/unit/provider/file/posix_spec.rb

@@ -223,4 +223,10 @@ describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix
       expect { provider.group = 25 }.to raise_error(Puppet::Error, /Failed to set group to '25'/)
     end
   end
+
+  describe "when validating" do
+    it "should not perform any validation" do
+      resource.validate
+    end
+  end
 end

data/spec/unit/provider/file/windows_spec.rb

@@ -133,4 +133,22 @@ describe Puppet::Type.type(:file).provider(:windows), :if => Puppet.features.mic
       expect { provider.group = 'S-1-1-50' }.to raise_error(Puppet::Error, /Failed to set group/)
     end
   end
+
+  describe "when validating" do
+    {:owner => 'foo', :group => 'foo', :mode => 0777}.each do |k,v|
+      it "should fail if the filesystem doesn't support ACLs and we're managing #{k}" do
+        described_class.any_instance.stubs(:supports_acl?).returns false
+
+        expect {
+          Puppet::Type.type(:file).new :path => path, k => v
+        }.to raise_error(Puppet::Error, /Can only manage owner, group, and mode on filesystems that support Windows ACLs, such as NTFS/)
+      end
+    end
+
+    it "should not fail if the filesystem doesn't support ACLs and we're not managing permissions" do
+      described_class.any_instance.stubs(:supports_acl?).returns false
+
+      Puppet::Type.type(:file).new :path => path
+    end
+  end
 end

data/spec/unit/provider/group/windows_adsi_spec.rb

@@ -47,15 +47,31 @@ describe Puppet::Type.type(:group).provider(:windows_adsi) do
     end
   end
 
-  it "should be able to create a group" do
-    resource[:members] = ['user1', 'user2']
+  describe 'when creating groups' do
+    it "should be able to create a group" do
+      resource[:members] = ['user1', 'user2']
 
-    group = stub 'group'
-    Puppet::Util::ADSI::Group.expects(:create).with('testers').returns group
+      group = stub 'group'
+      Puppet::Util::ADSI::Group.expects(:create).with('testers').returns group
 
-    group.expects(:set_members).with(['user1', 'user2'])
+      create = sequence('create')
+      group.expects(:commit).in_sequence(create)
+      group.expects(:set_members).with(['user1', 'user2']).in_sequence(create)
 
-    provider.create
+      provider.create
+    end
+
+    it 'should not create a group if a user by the same name exists' do
+      Puppet::Util::ADSI::Group.expects(:create).with('testers').raises( Puppet::Error.new("Cannot create group if user 'testers' exists.") )
+      expect{ provider.create }.to raise_error( Puppet::Error,
+        /Cannot create group if user 'testers' exists./ )
+    end
+
+    it 'should commit a newly created group' do
+      provider.group.expects( :commit )
+
+      provider.flush
+    end
   end
 
   it "should be able to test whether a group exists" do

data/spec/unit/provider/mount/parsed_spec.rb

@@ -4,7 +4,7 @@ require 'shared_behaviours/all_parsedfile_providers'
 
 provider_class = Puppet::Type.type(:mount).provider(:parsed)
 
-describe provider_class, :fails_on_windows => true do
+describe provider_class, :unless => Puppet.features.microsoft_windows? do
 
   before :each do
     @mount_class = Puppet::Type.type(:mount)

data/spec/unit/provider/package/msi_spec.rb

@@ -69,7 +69,7 @@ describe 'Puppet::Provider::Package::Msi' do
       expect do
         resource = Puppet::Type.type(:package).new(
           :name => 'mysql-5.1.58-winx64'
-        )
+        ).provider.install
       end.to raise_error(Puppet::Error, /The source parameter is required when using the MSI provider/)
     end
 
@@ -115,7 +115,7 @@ describe 'Puppet::Provider::Package::Msi' do
       expect do
         resource = Puppet::Type.type(:package).new(
           :name => 'mysql-5.1.58-winx64'
-        )
+        ).provider.install
       end.to raise_error(Puppet::Error, /The source parameter is required when using the MSI provider/)
     end