puppet 5.0.1 → 5.1.0

data/spec/unit/pops/types/types_spec.rb

@@ -570,19 +570,19 @@ describe 'Puppet Type System' do
   context 'instantiation via new_function is supported by' do
     let(:loader) { Loader::BaseLoader.new(nil, "types_unit_test_loader") }
     it 'Integer' do
-      func_class = tf.integer.new_function(loader)
+      func_class = tf.integer.new_function
       expect(func_class).to be_a(Class)
       expect(func_class.superclass).to be(Puppet::Functions::Function)
     end
 
     it 'Optional[Integer]' do
-      func_class = tf.optional(tf.integer).new_function(loader)
+      func_class = tf.optional(tf.integer).new_function
       expect(func_class).to be_a(Class)
       expect(func_class.superclass).to be(Puppet::Functions::Function)
     end
 
     it 'Regexp' do
-      func_class = tf.regexp.new_function(loader)
+      func_class = tf.regexp.new_function
       expect(func_class).to be_a(Class)
       expect(func_class.superclass).to be(Puppet::Functions::Function)
     end
@@ -593,7 +593,7 @@ describe 'Puppet Type System' do
 
       it 'Any, Scalar, Collection' do
         [tf.any, tf.scalar, tf.collection ].each do |t|
-        expect { t.new_function(loader)
+        expect { t.new_function
         }.to raise_error(ArgumentError, /Creation of new instance of type '#{t.to_s}' is not supported/)
       end
     end
@@ -645,6 +645,18 @@ describe 'Puppet Type System' do
       expect(rx_type).to eq(tf.regexp(/[a-z]+/))
     end
   end
+
+  context 'backward compatibility' do
+    it 'PTypeType can be accessed from PType' do
+      # should appoint the exact same instance
+      expect(PType).to equal(PTypeType)
+    end
+
+    it 'PClassType can be accessed from PHostClassType' do
+      # should appoint the exact same instance
+      expect(PHostClassType).to equal(PClassType)
+    end
+  end
 end
 end
 end

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

@@ -56,7 +56,7 @@ context 'installing myresource' do
 
       it "should allow setting an install_options parameter" do
         resource[:install_options] = [ '--force', {'--bindir' => '/usr/bin' } ]
-        provider.expects(:execute).with { |args| args[5] == '--force' && args[6] == '--bindir=/usr/bin' }.returns ''
+        provider.expects(:execute).with { |args| args[2] == '--force' && args[3] == '--bindir=/usr/bin' }.returns ''
         provider.install
       end
 
@@ -137,12 +137,12 @@ context 'installing myresource' do
       end
 
       it "should return an empty array when no gems installed" do
-        provider_class.expects(:execute).with(%w{/my/gem list --local}).returns("\n")
+        provider_class.expects(:execute).with(%w{/my/gem list --local}, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).returns("\n")
         expect(provider_class.instances).to eq([])
       end
 
       it "should return ensure values as an array of installed versions" do
-        provider_class.expects(:execute).with(%w{/my/gem list --local}).returns <<-HEREDOC.gsub(/        /, '')
+        provider_class.expects(:execute).with(%w{/my/gem list --local}, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).returns <<-HEREDOC.gsub(/        /, '')
         systemu (1.2.0)
         vagrant (0.8.7, 0.6.9)
         HEREDOC
@@ -154,7 +154,7 @@ context 'installing myresource' do
       end
 
       it "should ignore platform specifications" do
-        provider_class.expects(:execute).with(%w{/my/gem list --local}).returns <<-HEREDOC.gsub(/        /, '')
+        provider_class.expects(:execute).with(%w{/my/gem list --local}, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).returns <<-HEREDOC.gsub(/        /, '')
         systemu (1.2.0)
         nokogiri (1.6.1 ruby java x86-mingw32 x86-mswin32-60, 1.4.4.1 x86-mswin32)
         HEREDOC
@@ -166,7 +166,7 @@ context 'installing myresource' do
       end
 
       it "should not fail when an unmatched line is returned" do
-        provider_class.expects(:execute).with(%w{/my/gem list --local}).
+        provider_class.expects(:execute).with(%w{/my/gem list --local}, {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).
           returns(File.read(my_fixture('line-with-1.8.5-warning')))
 
         expect(provider_class.instances.map {|p| p.properties}).
@@ -186,7 +186,7 @@ context 'installing myresource' do
     describe "listing gems" do
       describe "searching for a single package" do
         it "searches for an exact match" do
-          provider_class.expects(:execute).with(includes('^bundler$')).returns(File.read(my_fixture('gem-list-single-package')))
+          provider_class.expects(:execute).with(includes('^bundler$'), {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}}).returns(File.read(my_fixture('gem-list-single-package')))
           expected = {:name => 'bundler', :ensure => %w[1.6.2], :provider => :gem}
           expect(provider_class.gemlist({:justme => 'bundler'})).to eq(expected)
         end

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

@@ -2,11 +2,11 @@
 require 'spec_helper'
 
 provider_class = Puppet::Type.type(:package).provider(:pip)
-osfamilies = { ['All', nil] => ['pip', 'pip-python'] }
+osfamilies = { 'windows' => ['pip.exe'], 'other' => ['pip', 'pip-python'] }
 
 describe provider_class do
 
-  before do
+  before do  
     @resource = Puppet::Resource.new(:package, "fake_package")
     @provider = provider_class.new(@resource)
     @client = stub_everything('client')
@@ -31,13 +31,19 @@ describe provider_class do
   end
 
   describe "cmd" do
-    it "should return pip-python on legacy systems" do
-      Facter.stubs(:value).with(:osfamily).returns("legacy")
+
+    it "should return 'pip.exe' by default on Windows systems" do
+      Puppet.features.stubs(:microsoft_windows?).returns true
+      expect(provider_class.cmd[0]).to eq('pip.exe')
+    end
+
+    it "could return pip-python on legacy redhat systems which rename pip" do
+      Puppet.features.stubs(:microsoft_windows?).returns false
       expect(provider_class.cmd[1]).to eq('pip-python')
     end
 
-    it "should return pip by default" do
-      Facter.stubs(:value).with(:osfamily).returns("All")
+    it "should return pip by default on other systems" do
+      Puppet.features.stubs(:microsoft_windows?).returns false
       expect(provider_class.cmd[0]).to eq('pip')
     end
 
@@ -46,10 +52,10 @@ describe provider_class do
   describe "instances" do
 
     osfamilies.each do |osfamily, pip_cmds|
-      it "should return an array on #{osfamily} when #{pip_cmds.join(' or ')} is present" do
-        Facter.stubs(:value).with(:osfamily).returns(osfamily.first)
-        Facter.stubs(:value).with(:operatingsystemmajrelease).returns(osfamily.last)
-        pip_cmds.each do |pip_cmd|
+
+      it "should return an array on #{osfamily} systems when #{pip_cmds.join(' or ')} is present" do
+        Puppet.features.stubs(:microsoft_windows?).returns (osfamily == 'windows')
+        pip_cmds.each do |pip_cmd|  
           pip_cmds.each do |cmd|
             unless cmd == pip_cmd
               provider_class.expects(:which).with(cmd).returns(nil)
@@ -59,19 +65,34 @@ describe provider_class do
           provider_class.expects(:which).with(pip_cmd).returns("/fake/bin/#{pip_cmd}")
           p = stub("process")
           p.expects(:collect).yields("real_package==1.2.5")
-          provider_class.expects(:execpipe).with("/fake/bin/#{pip_cmd} freeze").yields(p)
+          provider_class.expects(:execpipe).with(["/fake/bin/#{pip_cmd}", "freeze"]).yields(p)
           provider_class.instances
         end
       end
 
-      it "should return an empty array on #{osfamily} when #{pip_cmds.join(' and ')} are missing" do
-        Facter.stubs(:value).with(:osfamily).returns(osfamily.first)
-        Facter.stubs(:value).with(:operatingsystemmajrelease).returns(osfamily.last)
+      context "with pip version >= 8.1.0" do
+        versions = ['8.1.0', '9.0.1']
+        versions.each do |version|
+          it "should use the --all option when version is '#{version}'" do
+            Puppet.features.stubs(:microsoft_windows?).returns (osfamily == 'windows')
+            provider_class.stubs(:pip_cmd).returns('/fake/bin/pip')
+            provider_class.stubs(:pip_version).returns(version)
+            p = stub("process")
+            p.expects(:collect).yields("real_package==1.2.5")
+            provider_class.expects(:execpipe).with(["/fake/bin/pip", "freeze", "--all"]).yields(p)
+            provider_class.instances
+          end
+        end
+      end
+
+      it "should return an empty array on #{osfamily} systems when #{pip_cmds.join(' and ')} are missing" do
+        Puppet.features.stubs(:microsoft_windows?).returns (osfamily == 'windows')
         pip_cmds.each do |cmd|
           provider_class.expects(:which).with(cmd).returns nil
         end
         expect(provider_class.instances).to eq([])
       end
+
     end
 
   end
@@ -125,6 +146,7 @@ describe provider_class do
         provider_class.stubs(:pip_version).returns('1.0.1')
         provider_class.stubs(:which).with('pip').returns("/fake/bin/pip")
         provider_class.stubs(:which).with('pip-python').returns("/fake/bin/pip")
+        provider_class.stubs(:which).with('pip.exe').returns("/fake/bin/pip")
       end
 
       it "should find a version number for new_pip_package" do
@@ -181,6 +203,7 @@ describe provider_class do
         provider_class.stubs(:pip_version).returns('1.5.4')
         provider_class.stubs(:which).with('pip').returns("/fake/bin/pip")
         provider_class.stubs(:which).with('pip-python').returns("/fake/bin/pip")
+        provider_class.stubs(:which).with('pip.exe').returns("/fake/bin/pip")
       end
 
       it "should find a version number for real_package" do
@@ -343,10 +366,10 @@ describe provider_class do
     end
 
     osfamilies.each do |osfamily, pip_cmds|
+
       pip_cmds.each do |pip_cmd|
-        it "should retry on #{osfamily} if #{pip_cmd} has not yet been found" do
-          Facter.stubs(:value).with(:osfamily).returns(osfamily.first)
-          Facter.stubs(:value).with(:operatingsystemmajrelease).returns(osfamily.last)
+        it "should retry on #{osfamily} systems if #{pip_cmd} has not yet been found" do
+          Puppet.features.stubs(:microsoft_windows?).returns (osfamily == 'windows')
           @provider.expects(:pip).twice.with('freeze').raises(NoMethodError).then.returns(nil)
           pip_cmds.each do |cmd|
             unless cmd == pip_cmd
@@ -358,9 +381,8 @@ describe provider_class do
         end
       end
 
-      it "should fail on #{osfamily} if #{pip_cmds.join(' and ')} are missing" do
-        Facter.stubs(:value).with(:osfamily).returns(osfamily.first)
-        Facter.stubs(:value).with(:operatingsystemmajrelease).returns(osfamily.last)
+      it "should fail on #{osfamily} systems if #{pip_cmds.join(' and ')} are missing" do
+        Puppet.features.stubs(:microsoft_windows?).returns (osfamily == 'windows')
         @provider.expects(:pip).with('freeze').raises(NoMethodError)
         pip_cmds.each do |pip_cmd|
           @provider.expects(:which).with(pip_cmd).returns(nil)
@@ -368,9 +390,8 @@ describe provider_class do
         expect { @provider.method(:lazy_pip).call("freeze") }.to raise_error(NoMethodError)
       end
 
-      it "should output a useful error message on #{osfamily} if #{pip_cmds.join(' and ')} are missing" do
-        Facter.stubs(:value).with(:osfamily).returns(osfamily.first)
-        Facter.stubs(:value).with(:operatingsystemmajrelease).returns(osfamily.last)
+      it "should output a useful error message on #{osfamily} systems if #{pip_cmds.join(' and ')} are missing" do
+        Puppet.features.stubs(:microsoft_windows?).returns (osfamily == 'windows')
         @provider.expects(:pip).with('freeze').raises(NoMethodError)
         pip_cmds.each do |pip_cmd|
           @provider.expects(:which).with(pip_cmd).returns(nil)

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

@@ -41,7 +41,7 @@ describe provider_class do
 
     it "should allow setting an install_options parameter" do
       resource[:install_options] = [ '--force', {'--bindir' => '/usr/bin' } ]
-      provider.expects(:execute).with { |args| args[5] == '--force' && args[6] == '--bindir=/usr/bin' }.returns ''
+      provider.expects(:execute).with { |args| args[2] == '--force' && args[3] == '--bindir=/usr/bin' }.returns ''
       provider.install
     end
   end

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

@@ -23,6 +23,7 @@ describe provider_class do
         expect(output['gawk.i686']).to eq([{:name => 'gawk', :epoch => '0', :version => '4.1.0', :release => '3.fc20', :arch => 'i686'}])
         expect(output['dhclient.i686']).to eq([{:name => 'dhclient', :epoch => '12', :version => '4.1.1', :release => '38.P1.fc20', :arch => 'i686'}])
         expect(output['selinux-policy.noarch']).to eq([{:name => 'selinux-policy', :epoch => '0', :version => '3.12.1', :release => '163.fc20', :arch => 'noarch'}])
+        expect(output['java-1.8.0-openjdk.x86_64']).to eq([{:name => 'java-1.8.0-openjdk', :epoch => '1', :version => '1.8.0.131', :release => '2.b11.el7_3', :arch => 'x86_64'}])
       end
     end
     describe "with multiline entries" do
@@ -61,5 +62,12 @@ describe provider_class do
         expect(output).to include("yum-plugin-fastestmirror.noarch")
       end
     end
+    describe "with improper package names in output" do
+      it "raises an exception parsing package name" do
+        expect {
+          described_class.update_to_hash('badpackagename', '1')
+        }.to raise_exception(Exception, /Failed to parse/)
+      end
+    end
   end
 end

data/spec/unit/resource/capability_finder_spec.rb

@@ -124,22 +124,21 @@ describe Puppet::Resource::CapabilityFinder do
           expect(result['host']).to eq('chost')
         end
 
-        it 'should return nil if no resource matches code_id' do
+        it 'should fail if no resource matches code_id' do
           Puppet::Resource::CapabilityFinder.stubs(:search).with('production', code_id, capability).returns []
 
-          result = Puppet::Resource::CapabilityFinder.find('production', code_id, capability)
-          expect(result).to be_nil
+          expect { Puppet::Resource::CapabilityFinder.find('production', code_id, capability) }.to raise_error(Puppet::Error, /expected exactly one resource but got 2/)
         end
 
         it 'should fail if multiple resources match code_id' do
           Puppet::Resource::CapabilityFinder.stubs(:search).with('production', code_id, capability).returns resources
 
-          expect { Puppet::Resource::CapabilityFinder.find('production', code_id, capability) }.to raise_error(Puppet::DevError, /expected exactly one resource/)
+          expect { Puppet::Resource::CapabilityFinder.find('production', code_id, capability) }.to raise_error(Puppet::DevError, /expected exactly one resource but got 2/)
         end
 
         it 'should fail if no code_id was specified' do
           Puppet::Resource::CapabilityFinder.stubs(:search).with('production', nil, capability).returns resources
-          expect { Puppet::Resource::CapabilityFinder.find('production', nil, capability) }.to raise_error(Puppet::DevError, /expected exactly one resource/)
+          expect { Puppet::Resource::CapabilityFinder.find('production', nil, capability) }.to raise_error(Puppet::DevError, /expected exactly one resource but got 2/)
         end
       end
     end

data/spec/unit/type/file_spec.rb

@@ -893,26 +893,31 @@ describe Puppet::Type.type(:file) do
     end
 
     it "should fail if it can't backup the file" do
+      # Default: file[:backup] = true
       file.stubs(:stat).returns stub('stat', :ftype => 'file')
       file.stubs(:perform_backup).returns false
 
-      expect { file.remove_existing(:file) }.to raise_error(Puppet::Error, /Could not back up; will not replace/)
+      expect { file.remove_existing(:file) }.to raise_error(Puppet::Error, /Could not back up; will not remove/)
     end
 
     describe "backing up directories" do
-      it "should not backup directories if force is false" do
+      it "should not backup directories if backup is true and force is false" do
+        # Default: file[:backup] = true
         file[:force] = false
         file.stubs(:stat).returns stub('stat', :ftype => 'directory')
+
         file.expects(:perform_backup).never
+        file.expects(:warning).with("Could not back up file of type directory")
         expect(file.remove_existing(:file)).to eq(false)
       end
 
-      it "should backup directories if force is true" do
+      it "should backup directories if backup is true and force is true" do
+        # Default: file[:backup] = true
         file[:force] = true
-        FileUtils.expects(:rmtree).with(file[:path])
-
         file.stubs(:stat).returns stub('stat', :ftype => 'directory')
-        file.expects(:perform_backup).once.returns(true)
+
+        FileUtils.expects(:rmtree).with(file[:path])
+        file.expects(:perform_backup).returns(true)
 
         expect(file.remove_existing(:file)).to eq(true)
       end
@@ -924,18 +929,17 @@ describe Puppet::Type.type(:file) do
       expect(file.remove_existing(:file)).to eq(false)
     end
 
-    it "should not remove directories and should not invalidate the stat unless force is set" do
+    it "should not remove directories and should not invalidate the stat unless force is true" do
+      file[:force] = false
       # Actually call stat to set @needs_stat to nil
       file.stat
       file.stubs(:stat).returns stub('stat', :ftype => 'directory')
 
-      file.remove_existing(:file)
-
       expect(file.instance_variable_get(:@stat)).to eq(nil)
-      expect(@logs).to be_any {|log| log.level == :notice and log.message =~ /Not removing directory; use 'force' to override/}
     end
 
-    it "should remove a directory if force is set" do
+    it "should remove a directory if backup is true and force is true" do
+      # Default: file[:backup] = true
       file[:force] = true
       file.stubs(:stat).returns stub('stat', :ftype => 'directory')
 
@@ -966,10 +970,11 @@ describe Puppet::Type.type(:file) do
       expect(Puppet::FileSystem.exist?(file[:path])).to eq(false)
     end
 
-    it "should fail if the file is not a file, link, or directory" do
-      file.stubs(:stat).returns stub('stat', :ftype => 'socket')
+    it "should fail if the file is not a directory, link, file, fifo, socket, or is unknown" do
+      file.stubs(:stat).returns stub('stat', :ftype => 'blockSpecial')
 
-      expect { file.remove_existing(:file) }.to raise_error(Puppet::Error, /Could not back up files of type socket/)
+      file.expects(:warning).with("Could not back up file of type blockSpecial")
+      expect { file.remove_existing(:file) }.to raise_error(Puppet::Error, /Could not remove files of type blockSpecial/)
     end
 
     it "should invalidate the existing stat of the file" do

data/spec/unit/util/execution_spec.rb

@@ -1,6 +1,8 @@
 #! /usr/bin/env ruby
+# encoding: UTF-8
 require 'spec_helper'
 require 'puppet/file_system/uniquefile'
+require 'puppet_spec/character_encoding'
 
 describe Puppet::Util::Execution do
   include Puppet::Util::Execution
@@ -25,10 +27,12 @@ describe Puppet::Util::Execution do
         FFI::WIN32.stubs(:CloseHandle).with(process_handle)
         FFI::WIN32.stubs(:CloseHandle).with(thread_handle)
       else
+        Process.stubs(:waitpid2).with(pid, Process::WNOHANG).returns(nil, [pid, stub('child_status', :exitstatus => exitstatus)])
         Process.stubs(:waitpid2).with(pid).returns([pid, stub('child_status', :exitstatus => exitstatus)])
       end
     end
 
+
     describe "#execute_posix (stubs)", :unless => Puppet.features.microsoft_windows? do
       before :each do
         # Most of the things this method does are bad to do during specs. :/
@@ -215,82 +219,136 @@ describe Puppet::Util::Execution do
           end
         end
 
-        describe "when squelch is not set" do
-          it "should set stdout to a temporary output file" do
-            outfile = Puppet::FileSystem::Uniquefile.new('stdout')
-            Puppet::FileSystem::Uniquefile.stubs(:new).returns(outfile)
+        describe "on POSIX", :if => Puppet.features.posix? do
+          describe "when squelch is not set" do
+            it "should set stdout to a pipe" do
+              Puppet::Util::Execution.expects(executor).with do |_,_,_,stdout,_|
+                stdout.class == IO
+              end.returns(rval)
 
-            Puppet::Util::Execution.expects(executor).with do |_,_,_,stdout,_|
-              stdout.path == outfile.path
-            end.returns(rval)
+              Puppet::Util::Execution.execute('test command', :squelch => false)
+            end
 
-            Puppet::Util::Execution.execute('test command', :squelch => false)
-          end
+            it "should set stderr to the same file as stdout if combine is true" do
+              Puppet::Util::Execution.expects(executor).with do |_,_,_,stdout,stderr|
+                stdout == stderr
+              end.returns(rval)
 
-          it "should set stderr to the same file as stdout if combine is true" do
-            outfile = Puppet::FileSystem::Uniquefile.new('stdout')
-            Puppet::FileSystem::Uniquefile.stubs(:new).returns(outfile)
+              Puppet::Util::Execution.execute('test command', :squelch => false, :combine => true)
+            end
 
-            Puppet::Util::Execution.expects(executor).with do |_,_,_,stdout,stderr|
-              stdout.path == outfile.path and stderr.path == outfile.path
-            end.returns(rval)
+            it "should set stderr to the null device if combine is false" do
+              Puppet::Util::Execution.expects(executor).with do |_,_,_,stdout,stderr|
+                stdout.class == IO and stderr.path == null_file
+              end.returns(rval)
 
-            Puppet::Util::Execution.execute('test command', :squelch => false, :combine => true)
-          end
+              Puppet::Util::Execution.execute('test command', :squelch => false, :combine => false)
+            end
 
-          it "should set stderr to the null device if combine is false" do
-            outfile = Puppet::FileSystem::Uniquefile.new('stdout')
-            Puppet::FileSystem::Uniquefile.stubs(:new).returns(outfile)
+            it "should default combine to true when no options are specified" do
+              Puppet::Util::Execution.expects(executor).with do |_,_,_,stdout,stderr|
+                stdout == stderr
+              end.returns(rval)
 
-            Puppet::Util::Execution.expects(executor).with do |_,_,_,stdout,stderr|
-              stdout.path == outfile.path and stderr.path == null_file
-            end.returns(rval)
+              Puppet::Util::Execution.execute('test command')
+            end
 
-            Puppet::Util::Execution.execute('test command', :squelch => false, :combine => false)
-          end
+            it "should default combine to false when options are specified, but combine is not" do
+              Puppet::Util::Execution.expects(executor).with do |_,_,_,stdout,stderr|
+                stdout.class == IO and stderr.path == null_file
+              end.returns(rval)
 
-          it "should combine stdout and stderr if combine is true" do
-            outfile = Puppet::FileSystem::Uniquefile.new('stdout')
-            Puppet::FileSystem::Uniquefile.stubs(:new).returns(outfile)
+              Puppet::Util::Execution.execute('test command', :failonfail => false)
+            end
 
-            Puppet::Util::Execution.expects(executor).with do |_,_,_,stdout,stderr|
-              stdout.path == outfile.path and stderr.path == outfile.path
-            end.returns(rval)
+            it "should default combine to false when an empty hash of options is specified" do
+              Puppet::Util::Execution.expects(executor).with do |_,_,_,stdout,stderr|
+                stdout.class == IO and stderr.path == null_file
+              end.returns(rval)
 
-            Puppet::Util::Execution.execute('test command', :combine => true)
+              Puppet::Util::Execution.execute('test command', {})
+            end
           end
+        end
 
-          it "should default combine to true when no options are specified" do
-            outfile = Puppet::FileSystem::Uniquefile.new('stdout')
-            Puppet::FileSystem::Uniquefile.stubs(:new).returns(outfile)
+        describe "on Windows", :if => Puppet.features.microsoft_windows? do
+          describe "when squelch is not set" do
+            it "should set stdout to a temporary output file" do
+              outfile = Puppet::FileSystem::Uniquefile.new('stdout')
+              Puppet::FileSystem::Uniquefile.stubs(:new).returns(outfile)
 
-            Puppet::Util::Execution.expects(executor).with do |_,_,_,stdout,stderr|
-              stdout.path == outfile.path and stderr.path == outfile.path
-            end.returns(rval)
+              Puppet::Util::Execution.expects(executor).with do |_,_,_,stdout,_|
+                stdout.path == outfile.path
+              end.returns(rval)
 
-            Puppet::Util::Execution.execute('test command')
-          end
+              Puppet::Util::Execution.execute('test command', :squelch => false)
+            end
 
-          it "should default combine to false when options are specified, but combine is not" do
-            outfile = Puppet::FileSystem::Uniquefile.new('stdout')
-            Puppet::FileSystem::Uniquefile.stubs(:new).returns(outfile)
+            it "should set stderr to the same file as stdout if combine is true" do
+              outfile = Puppet::FileSystem::Uniquefile.new('stdout')
+              Puppet::FileSystem::Uniquefile.stubs(:new).returns(outfile)
 
-            Puppet::Util::Execution.expects(executor).with do |_,_,_,stdout,stderr|
-              stdout.path == outfile.path and stderr.path == null_file
-            end.returns(rval)
+              Puppet::Util::Execution.expects(executor).with do |_,_,_,stdout,stderr|
+                stdout.path == outfile.path and stderr.path == outfile.path
+              end.returns(rval)
 
-            Puppet::Util::Execution.execute('test command', :failonfail => false)
-          end
+              Puppet::Util::Execution.execute('test command', :squelch => false, :combine => true)
+            end
 
-          it "should default combine to false when an empty hash of options is specified" do
-            outfile = Puppet::FileSystem::Uniquefile.new('stdout')
-            Puppet::FileSystem::Uniquefile.stubs(:new).returns(outfile)
+            it "should set stderr to the null device if combine is false" do
+              outfile = Puppet::FileSystem::Uniquefile.new('stdout')
+              Puppet::FileSystem::Uniquefile.stubs(:new).returns(outfile)
 
-            Puppet::Util::Execution.expects(executor).with do |_,_,_,stdout,stderr|
-              stdout.path == outfile.path and stderr.path == null_file
-            end.returns(rval)
+              Puppet::Util::Execution.expects(executor).with do |_,_,_,stdout,stderr|
+                stdout.path == outfile.path and stderr.path == null_file
+              end.returns(rval)
+
+              Puppet::Util::Execution.execute('test command', :squelch => false, :combine => false)
+            end
+
+            it "should combine stdout and stderr if combine is true" do
+              outfile = Puppet::FileSystem::Uniquefile.new('stdout')
+              Puppet::FileSystem::Uniquefile.stubs(:new).returns(outfile)
+
+              Puppet::Util::Execution.expects(executor).with do |_,_,_,stdout,stderr|
+                stdout.path == outfile.path and stderr.path == outfile.path
+              end.returns(rval)
+
+              Puppet::Util::Execution.execute('test command', :combine => true)
+            end
+
+            it "should default combine to true when no options are specified" do
+              outfile = Puppet::FileSystem::Uniquefile.new('stdout')
+              Puppet::FileSystem::Uniquefile.stubs(:new).returns(outfile)
+
+              Puppet::Util::Execution.expects(executor).with do |_,_,_,stdout,stderr|
+                stdout.path == outfile.path and stderr.path == outfile.path
+              end.returns(rval)
+
+              Puppet::Util::Execution.execute('test command')
+            end
+
+            it "should default combine to false when options are specified, but combine is not" do
+              outfile = Puppet::FileSystem::Uniquefile.new('stdout')
+              Puppet::FileSystem::Uniquefile.stubs(:new).returns(outfile)
+
+              Puppet::Util::Execution.expects(executor).with do |_,_,_,stdout,stderr|
+                stdout.path == outfile.path and stderr.path == null_file
+              end.returns(rval)
+
+              Puppet::Util::Execution.execute('test command', :failonfail => false)
+            end
+
+            it "should default combine to false when an empty hash of options is specified" do
+              outfile = Puppet::FileSystem::Uniquefile.new('stdout')
+              Puppet::FileSystem::Uniquefile.stubs(:new).returns(outfile)
+
+              Puppet::Util::Execution.expects(executor).with do |_,_,_,stdout,stderr|
+                stdout.path == outfile.path and stderr.path == null_file
+              end.returns(rval)
 
-            Puppet::Util::Execution.execute('test command', {})
+              Puppet::Util::Execution.execute('test command', {})
+            end
           end
         end
       end
@@ -536,9 +594,10 @@ describe Puppet::Util::Execution do
       end
 
       it "should close the stdin/stdout/stderr files used by the child" do
-        stdin = mock 'file', :close
-        stdout = mock 'file', :close
-        stderr = mock 'file', :close
+        stdin = mock 'file'
+        stdout = mock 'file'
+        stderr = mock 'file'
+        [stdin, stdout, stderr].each {|io| io.expects(:close).at_least_once}
 
         File.expects(:open).
             times(3).
@@ -549,38 +608,113 @@ describe Puppet::Util::Execution do
         Puppet::Util::Execution.execute('test command', {:squelch => true, :combine => false})
       end
 
-      it "should read and return the output if squelch is false" do
-        stdout = Puppet::FileSystem::Uniquefile.new('test')
-        Puppet::FileSystem::Uniquefile.stubs(:new).returns(stdout)
-        stdout.write("My expected command output")
+      describe "on POSIX", :if => Puppet.features.posix? do
+        context "reading the output" do
+          before :each do
+            r, w = IO.pipe
+            IO.expects(:pipe).returns([r, w])
+            w.write("My expected \u2744 command output")
+          end
 
-        expect(Puppet::Util::Execution.execute('test command')).to eq("My expected command output")
-      end
+          it "should return output with external encoding ISO_8859_1" do
+            result = PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::ISO_8859_1) do
+              Puppet::Util::Execution.execute('test command')
+            end
+            expect(result.encoding).to eq(Encoding::ISO_8859_1)
+            expect(result).to eq("My expected \u2744 command output".force_encoding(Encoding::ISO_8859_1))
+          end
 
-      it "should not read the output if squelch is true" do
-        stdout = Puppet::FileSystem::Uniquefile.new('test')
-        Puppet::FileSystem::Uniquefile.stubs(:new).returns(stdout)
-        stdout.write("My expected command output")
+          it "should return output with external encoding UTF_8" do
+            result = PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::UTF_8) do
+              Puppet::Util::Execution.execute('test command')
+            end
+            expect(result.encoding).to eq(Encoding::UTF_8)
+            expect(result).to eq("My expected \u2744 command output")
+          end
+        end
 
-        expect(Puppet::Util::Execution.execute('test command', :squelch => true)).to eq('')
-      end
+        it "should not read the output if squelch is true" do
+          IO.expects(:pipe).never
 
-      it "should delete the file used for output if squelch is false" do
-        stdout = Puppet::FileSystem::Uniquefile.new('test')
-        path = stdout.path
-        Puppet::FileSystem::Uniquefile.stubs(:new).returns(stdout)
+          expect(Puppet::Util::Execution.execute('test command', :squelch => true)).to eq('')
+        end
 
-        Puppet::Util::Execution.execute('test command')
+        it "should close the pipe used for output if squelch is false" do
+          r, w = IO.pipe
+          IO.expects(:pipe).returns([r, w])
 
-        expect(Puppet::FileSystem.exist?(path)).to be_falsey
+          expect(Puppet::Util::Execution.execute('test command')).to eq("")
+          expect(r.closed?)
+          expect(w.closed?)
+        end
+
+        it "should close the pipe used for output if squelch is false and an error is raised" do
+          r, w = IO.pipe
+          IO.expects(:pipe).returns([r, w])
+
+          if Puppet.features.microsoft_windows?
+            Puppet::Util::Execution.expects(:execute_windows).raises(Exception, 'execution failed')
+          else
+            Puppet::Util::Execution.expects(:execute_posix).raises(Exception, 'execution failed')
+          end
+
+          expect {
+            subject.execute('fail command')
+          }.to raise_error(Exception, 'execution failed')
+          expect(r.closed?)
+          expect(w.closed?)
+        end
       end
+      describe "on Windows", :if => Puppet.features.microsoft_windows? do
+        context "reading the output" do
+          before :each do
+            stdout = Puppet::FileSystem::Uniquefile.new('test')
+            Puppet::FileSystem::Uniquefile.stubs(:new).returns(stdout)
+            stdout.write("My expected \u2744 command output")
+          end
 
-      it "should not raise an error if the file is open" do
-        stdout = Puppet::FileSystem::Uniquefile.new('test')
-        Puppet::FileSystem::Uniquefile.stubs(:new).returns(stdout)
-        file = File.new(stdout.path, 'r')
+          it "should return output with external encoding ISO_8859_1" do
+            result = PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::ISO_8859_1) do
+              Puppet::Util::Execution.execute('test command')
+            end
+            expect(result.encoding).to eq(Encoding::ISO_8859_1)
+            expect(result).to eq("My expected \u2744 command output".force_encoding(Encoding::ISO_8859_1))
+          end
 
-        Puppet::Util::Execution.execute('test command')
+          it "should return output with external encoding UTF_8" do
+            result = PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::UTF_8) do
+              Puppet::Util::Execution.execute('test command')
+            end
+            expect(result.encoding).to eq(Encoding::UTF_8)
+            expect(result).to eq("My expected \u2744 command output")
+          end
+        end
+
+        it "should not read the output if squelch is true" do
+          stdout = Puppet::FileSystem::Uniquefile.new('test')
+          Puppet::FileSystem::Uniquefile.stubs(:new).returns(stdout)
+          stdout.write("My expected command output")
+
+          expect(Puppet::Util::Execution.execute('test command', :squelch => true)).to eq('')
+        end
+
+        it "should delete the file used for output if squelch is false" do
+          stdout = Puppet::FileSystem::Uniquefile.new('test')
+          path = stdout.path
+          Puppet::FileSystem::Uniquefile.stubs(:new).returns(stdout)
+
+          Puppet::Util::Execution.execute('test command')
+
+          expect(Puppet::FileSystem.exist?(path)).to be_falsey
+        end
+
+        it "should not raise an error if the file is open" do
+          stdout = Puppet::FileSystem::Uniquefile.new('test')
+          Puppet::FileSystem::Uniquefile.stubs(:new).returns(stdout)
+          file = File.new(stdout.path, 'r')
+
+          Puppet::Util::Execution.execute('test command')
+        end
       end
 
       it "should raise an error if failonfail is true and the child failed" do
@@ -710,7 +844,7 @@ describe Puppet::Util::Execution do
       Puppet::Util::Execution.stubs(:execute).raises(Puppet::ExecutionFailure, "failed to execute")
       expect {
         Puppet::Util::Execution.execfail('echo hello', nil)
-      }.to raise_error(TypeError), /exception class\/object expected/
+      }.to raise_error(TypeError, /exception class\/object expected/)
     end
   end
 end