puppet 3.6.2 → 3.7.0

data/spec/unit/type/user_spec.rb

@@ -494,7 +494,7 @@ describe Puppet::Type.type(:user) do
         let(:resources) { subject.generate }
         it "should contain a resource for each key" do
           names = resources.collect { |res| res.name }
-          names.should include("keyname1")
+          names.should include("key1 name")
           names.should include("keyname2")
         end
         it "should not include keys in comment lines" do

data/spec/unit/type/yumrepo_spec.rb

@@ -10,6 +10,37 @@ shared_examples_for "a yumrepo parameter that can be absent" do |param|
   end
 end
 
+shared_examples_for "a yumrepo parameter that expects a natural value" do |param|
+  it "accepts a valid positive integer" do
+    instance = described_class.new(:name => 'puppetlabs', param => '12')
+    expect(instance[param]).to eq '12'
+  end
+  it "rejects invalid negative integer" do
+    expect {
+      described_class.new(
+        :name => 'puppetlabs',
+        param => '-12'
+      )
+    }.to raise_error(Puppet::ResourceError, /Parameter #{param} failed/)
+  end
+  it "rejects invalid non-integer" do
+    expect {
+      described_class.new(
+        :name => 'puppetlabs',
+        param => 'I\'m a six'
+      )
+    }.to raise_error(Puppet::ResourceError, /Parameter #{param} failed/)
+  end
+  it "rejects invalid string with integers inside" do
+    expect {
+      described_class.new(
+        :name => 'puppetlabs',
+        param => 'I\'m a 6'
+      )
+    }.to raise_error(Puppet::ResourceError, /Parameter #{param} failed/)
+  end
+end
+
 shared_examples_for "a yumrepo parameter that expects a boolean parameter" do |param|
   valid_values = %w[True False 0 1 No Yes]
 
@@ -22,6 +53,14 @@ shared_examples_for "a yumrepo parameter that expects a boolean parameter" do |p
       instance = described_class.new(:name => 'puppetlabs', param => value.downcase)
       expect(instance[param]).to eq value.downcase
     end
+    it "fails on valid value #{value} contained in another value" do
+        expect {
+          described_class.new(
+            :name => 'puppetlabs',
+            param => "bla#{value}bla"
+          )
+        }.to raise_error(Puppet::ResourceError, /Parameter #{param} failed/)
+    end
   end
 
   it "rejects invalid boolean values" do
@@ -76,6 +115,26 @@ shared_examples_for "a yumrepo parameter that accepts multiple URLs" do |param|
   end
 end
 
+shared_examples_for "a yumrepo parameter that accepts kMG units" do |param|
+  %w[k M G].each do |unit|
+    it "can accept an integer with #{unit} units" do
+      described_class.new(
+        :name => 'puppetlabs',
+        param => "123#{unit}"
+      )
+    end
+  end
+
+  it "fails if wrong unit passed" do
+    expect {
+      described_class.new(
+        :name => 'puppetlabs',
+        param => '123J'
+      )
+    }.to raise_error(Puppet::ResourceError, /Parameter #{param} failed/)
+  end
+end
+
 describe Puppet::Type.type(:yumrepo) do
   it "has :name as its namevar" do
     expect(described_class.key_attributes).to eq [:name]
@@ -154,6 +213,14 @@ describe Puppet::Type.type(:yumrepo) do
         it "accepts a value of #{value}" do
           described_class.new(:name => "puppetlabs", :failovermethod => value)
         end
+        it "fails on valid value #{value} contained in another value" do
+          expect {
+            described_class.new(
+              :name => 'puppetlabs',
+              :failovermethod => "bla#{value}bla"
+            )
+          }.to raise_error(Puppet::ResourceError, /Parameter failovermethod failed/)
+        end
       end
 
       it "raises an error if an invalid value is given" do
@@ -175,6 +242,14 @@ describe Puppet::Type.type(:yumrepo) do
         it "accepts a valid value of #{value}" do
           described_class.new(:name => 'puppetlabs', :http_caching => value)
         end
+        it "fails on valid value #{value} contained in another value" do
+          expect {
+            described_class.new(
+              :name => 'puppetlabs',
+              :http_caching => "bla#{value}bla"
+            )
+          }.to raise_error(Puppet::ResourceError, /Parameter http_caching failed/)
+        end
       end
 
       it "rejects invalid values" do
@@ -188,10 +263,25 @@ describe Puppet::Type.type(:yumrepo) do
 
     describe "timeout" do
       it_behaves_like "a yumrepo parameter that can be absent", :timeout
+      it_behaves_like "a yumrepo parameter that expects a natural value", :timeout
     end
 
     describe "metadata_expire" do
       it_behaves_like "a yumrepo parameter that can be absent", :metadata_expire
+      it_behaves_like "a yumrepo parameter that expects a natural value", :metadata_expire
+
+      it "accepts dhm units" do
+        %W[d h m].each do |unit|
+          described_class.new(
+            :name            => 'puppetlabs',
+            :metadata_expire => "123#{unit}"
+          )
+        end
+      end
+
+      it "accepts never as value" do
+        described_class.new(:name => 'puppetlabs', :metadata_expire => 'never')
+      end
     end
 
     describe "protect" do
@@ -205,6 +295,12 @@ describe Puppet::Type.type(:yumrepo) do
 
     describe "proxy" do
       it_behaves_like "a yumrepo parameter that can be absent", :proxy
+      it "accepts _none_" do
+        described_class.new(
+          :name  => 'puppetlabs',
+          :proxy => "_none_"
+        )
+      end
       it_behaves_like "a yumrepo parameter that accepts a single URL", :proxy
     end
 
@@ -247,5 +343,45 @@ describe Puppet::Type.type(:yumrepo) do
       it_behaves_like "a yumrepo parameter that can be absent", :metalink
       it_behaves_like "a yumrepo parameter that accepts a single URL", :metalink
     end
+
+
+    describe "cost" do
+      it_behaves_like "a yumrepo parameter that can be absent", :cost
+      it_behaves_like "a yumrepo parameter that expects a natural value", :cost
+    end
+
+    describe "throttle" do
+      it_behaves_like "a yumrepo parameter that can be absent", :throttle
+      it_behaves_like "a yumrepo parameter that expects a natural value", :throttle
+      it_behaves_like "a yumrepo parameter that accepts kMG units", :throttle
+
+      it "accepts percentage as unit" do
+        described_class.new(
+          :name     => 'puppetlabs',
+          :throttle => '123%'
+        )
+      end
+    end
+
+    describe "bandwidth" do
+      it_behaves_like "a yumrepo parameter that can be absent", :bandwidth
+      it_behaves_like "a yumrepo parameter that expects a natural value", :bandwidth
+      it_behaves_like "a yumrepo parameter that accepts kMG units", :bandwidth
+    end
+
+    describe "gpgcakey" do
+      it_behaves_like "a yumrepo parameter that can be absent", :gpgcakey
+      it_behaves_like "a yumrepo parameter that accepts a single URL", :gpgcakey
+    end
+
+    describe "retries" do
+      it_behaves_like "a yumrepo parameter that can be absent", :retries
+      it_behaves_like "a yumrepo parameter that expects a natural value", :retries
+    end
+
+    describe "mirrorlist_expire" do
+      it_behaves_like "a yumrepo parameter that can be absent", :mirrorlist_expire
+      it_behaves_like "a yumrepo parameter that expects a natural value", :mirrorlist_expire
+    end
   end
 end

data/spec/unit/type/zone_spec.rb

@@ -2,8 +2,11 @@
 require 'spec_helper'
 
 describe Puppet::Type.type(:zone) do
-  let(:zone)     { described_class.new(:name => 'dummy', :path => '/dummy', :provider => :solaris) }
+  let(:zone)     { described_class.new(:name => 'dummy', :path => '/dummy', :provider => :solaris, :ip=>'if:1.2.3.4:2.3.4.5', :inherit=>'/', :dataset=>'tank') }
   let(:provider) { zone.provider }
+  let(:ip)      { zone.property(:ip) }
+  let(:inherit) { zone.property(:inherit) }
+  let(:dataset) { zone.property(:dataset) }
 
   parameters = [:create_args, :install_args, :sysidcfg, :realhostname]
 
@@ -21,6 +24,46 @@ describe Puppet::Type.type(:zone) do
     end
   end
 
+  describe  "when trying to set a property that is empty" do
+    it "should verify that property.insync? of nil or :absent is true" do
+      [inherit, ip, dataset].each do |prop|
+        prop.stubs(:should).returns []
+      end
+      [inherit, ip, dataset].each do |prop|
+        prop.insync?(nil).should be_true
+      end
+      [inherit, ip, dataset].each do |prop|
+        prop.insync?(:absent).should be_true
+      end
+    end
+  end
+  describe  "when trying to set a property that is non empty" do
+    it "should verify that property.insync? of nil or :absent is false" do
+      [inherit, ip, dataset].each do |prop|
+        prop.stubs(:should).returns ['a','b']
+      end
+      [inherit, ip, dataset].each do |prop|
+        prop.insync?(nil).should be_false
+      end
+      [inherit, ip, dataset].each do |prop|
+        prop.insync?(:absent).should be_false
+      end
+    end
+  end
+  describe  "when trying to set a property that is non empty" do
+    it "insync? should return true or false depending on the current value, and new value" do
+      [inherit, ip, dataset].each do |prop|
+        prop.stubs(:should).returns ['a','b']
+      end
+      [inherit, ip, dataset].each do |prop|
+        prop.insync?(['b', 'a']).should be_true
+      end
+      [inherit, ip, dataset].each do |prop|
+        prop.insync?(['a']).should be_false
+      end
+    end
+  end
+
   it "should be valid when only :path is given" do
     described_class.new(:name => "dummy", :path => '/dummy', :provider => :solaris)
   end

data/spec/unit/type_spec.rb

@@ -328,6 +328,26 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
       provider.ancestors.should include(Puppet::Provider)
       provider.should == @type.provider(:test_provider)
     end
+
+    describe "with a parent class from another type" do
+      before :each do
+        @parent_type = Puppet::Type.newtype(:provider_parent_type) do
+          newparam(:name) { isnamevar }
+        end
+        @parent_provider = @parent_type.provide(:parent_provider)
+      end
+
+      it "should be created successfully" do
+        child_provider = @type.provide(:child_provider, :parent => @parent_provider)
+        child_provider.ancestors.should include(@parent_provider)
+      end
+
+      it "should be registered as a provider of the child type" do
+        child_provider = @type.provide(:child_provider, :parent => @parent_provider)
+        @type.providers.should include(:child_provider)
+        @parent_type.providers.should_not include(:child_provider)
+      end
+    end
   end
 
   describe "when choosing a default provider" do

data/spec/unit/util/colors_spec.rb

@@ -67,17 +67,23 @@ describe Puppet::Util::Colors do
     end
   end
 
-  describe "on Windows", :if => Puppet.features.microsoft_windows? do
-    it "expects a trailing embedded NULL character in the wide string" do
-      message = "hello"
+  context "on Windows in Ruby 1.x", :if => Puppet.features.microsoft_windows? && RUBY_VERSION =~ /^1./ do
+    it "should define WideConsole" do
+      expect(defined?(Puppet::Util::Colors::WideConsole)).to be_true
+    end
 
-      console = Puppet::Util::Colors::WideConsole.new
-      wstr, nchars = console.string_encode(message)
+    it "should define WideIO" do
+      expect(defined?(Puppet::Util::Colors::WideIO)).to be_true
+    end
+  end
 
-      expect(nchars).to eq(message.length)
+  context "on Windows in Ruby 2.x", :if => Puppet.features.microsoft_windows? && RUBY_VERSION =~ /^2./ do
+    it "should not define WideConsole" do
+      expect(defined?(Puppet::Util::Colors::WideConsole)).to be_false
+    end
 
-      expect(wstr.length).to eq(nchars + 1)
-      expect(wstr[-1].ord).to be_zero
+    it "should not define WideIO" do
+      expect(defined?(Puppet::Util::Colors::WideIO)).to be_false
     end
   end
 end

data/spec/unit/util/command_line_spec.rb

@@ -70,7 +70,7 @@ describe Puppet::Util::CommandLine do
       it "should print the version and exit if #{arg} is given" do
         expect do
           described_class.new("puppet", [arg]).execute
-        end.to have_printed(/^#{Puppet.version}$/)
+        end.to have_printed(/^#{Regexp.escape(Puppet.version)}$/)
       end
     end
   end
@@ -93,35 +93,39 @@ describe Puppet::Util::CommandLine do
       end
 
       describe "and an external implementation cannot be found" do
+        before :each do
+          Puppet::Util::CommandLine::UnknownSubcommand.any_instance.stubs(:console_has_color?).returns false
+        end
+
         it "should abort and show the usage message" do
-          commandline = Puppet::Util::CommandLine.new("puppet", ['whatever', 'argument'])
           Puppet::Util.expects(:which).with('puppet-whatever').returns(nil)
+          commandline = Puppet::Util::CommandLine.new("puppet", ['whatever', 'argument'])
           commandline.expects(:exec).never
 
           expect {
             commandline.execute
-          }.to have_printed(/Unknown Puppet subcommand 'whatever'/)
+          }.to have_printed(/Unknown Puppet subcommand 'whatever'/).and_exit_with(1)
         end
 
         it "should abort and show the help message" do
-          commandline = Puppet::Util::CommandLine.new("puppet", ['whatever', 'argument'])
           Puppet::Util.expects(:which).with('puppet-whatever').returns(nil)
+          commandline = Puppet::Util::CommandLine.new("puppet", ['whatever', 'argument'])
           commandline.expects(:exec).never
 
           expect {
             commandline.execute
-          }.to have_printed(/See 'puppet help' for help on available puppet subcommands/)
+          }.to have_printed(/See 'puppet help' for help on available puppet subcommands/).and_exit_with(1)
         end
 
         %w{--version -V}.each do |arg|
           it "should abort and display #{arg} information" do
-            commandline = Puppet::Util::CommandLine.new("puppet", ['whatever', arg])
             Puppet::Util.expects(:which).with('puppet-whatever').returns(nil)
+            commandline = Puppet::Util::CommandLine.new("puppet", ['whatever', arg])
             commandline.expects(:exec).never
 
             expect {
               commandline.execute
-            }.to have_printed(/^#{Puppet.version}$/)
+            }.to have_printed(%r[^#{Regexp.escape(Puppet.version)}$]).and_exit_with(1)
           end
         end
       end

data/spec/unit/util/execution_spec.rb

@@ -1,15 +1,9 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
+require 'puppet/file_system/uniquefile'
 
 describe Puppet::Util::Execution do
   include Puppet::Util::Execution
-  # utility method to help deal with some windows vs. unix differences
-  def process_status(exitstatus)
-    return exitstatus if Puppet.features.microsoft_windows?
-
-    stub('child_status', :exitstatus => exitstatus)
-  end
-
   # utility methods to help us test some private methods without being quite so verbose
   def call_exec_posix(command, arguments, stdin, stdout, stderr)
     Puppet::Util::Execution.send(:execute_posix, command, arguments, stdin, stdout, stderr)
@@ -28,8 +22,8 @@ describe Puppet::Util::Execution do
     def stub_process_wait(exitstatus)
       if Puppet.features.microsoft_windows?
         Puppet::Util::Windows::Process.stubs(:wait_process).with(process_handle).returns(exitstatus)
-        Process.stubs(:CloseHandle).with(process_handle)
-        Process.stubs(:CloseHandle).with(thread_handle)
+        FFI::WIN32.stubs(:CloseHandle).with(process_handle)
+        FFI::WIN32.stubs(:CloseHandle).with(thread_handle)
       else
         Process.stubs(:waitpid2).with(pid).returns([pid, stub('child_status', :exitstatus => exitstatus)])
       end
@@ -52,7 +46,7 @@ describe Puppet::Util::Execution do
         $stderr.stubs(:reopen)
 
         @stdin  = File.open(null_file, 'r')
-        @stdout = Tempfile.new('stdout')
+        @stdout = Puppet::FileSystem::Uniquefile.new('stdout')
         @stderr = File.open(null_file, 'w')
 
         # there is a danger here that ENV will be modified by exec_posix.  Normally it would only affect the ENV
@@ -132,7 +126,7 @@ describe Puppet::Util::Execution do
         stub_process_wait(0)
 
         @stdin  = File.open(null_file, 'r')
-        @stdout = Tempfile.new('stdout')
+        @stdout = Puppet::FileSystem::Uniquefile.new('stdout')
         @stderr = File.open(null_file, 'w')
       end
 
@@ -223,8 +217,8 @@ describe Puppet::Util::Execution do
 
         describe "when squelch is not set" do
           it "should set stdout to a temporary output file" do
-            outfile = Tempfile.new('stdout')
-            Tempfile.stubs(:new).returns(outfile)
+            outfile = Puppet::FileSystem::Uniquefile.new('stdout')
+            Puppet::FileSystem::Uniquefile.stubs(:new).returns(outfile)
 
             Puppet::Util::Execution.expects(executor).with do |_,_,_,stdout,_|
               stdout.path == outfile.path
@@ -234,8 +228,8 @@ describe Puppet::Util::Execution do
           end
 
           it "should set stderr to the same file as stdout if combine is true" do
-            outfile = Tempfile.new('stdout')
-            Tempfile.stubs(:new).returns(outfile)
+            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
@@ -245,8 +239,8 @@ describe Puppet::Util::Execution do
           end
 
           it "should set stderr to the null device if combine is false" do
-            outfile = Tempfile.new('stdout')
-            Tempfile.stubs(:new).returns(outfile)
+            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
@@ -256,8 +250,8 @@ describe Puppet::Util::Execution do
           end
 
           it "should combine stdout and stderr if combine is true" do
-            outfile = Tempfile.new('stdout')
-            Tempfile.stubs(:new).returns(outfile)
+            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
@@ -267,8 +261,8 @@ describe Puppet::Util::Execution do
           end
 
           it "should default combine to true when no options are specified" do
-            outfile = Tempfile.new('stdout')
-            Tempfile.stubs(:new).returns(outfile)
+            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
@@ -278,8 +272,8 @@ describe Puppet::Util::Execution do
           end
 
           it "should default combine to false when options are specified, but combine is not" do
-            outfile = Tempfile.new('stdout')
-            Tempfile.stubs(:new).returns(outfile)
+            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
@@ -289,8 +283,8 @@ describe Puppet::Util::Execution do
           end
 
           it "should default combine to false when an empty hash of options is specified" do
-            outfile = Tempfile.new('stdout')
-            Tempfile.stubs(:new).returns(outfile)
+            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
@@ -306,8 +300,8 @@ describe Puppet::Util::Execution do
           Puppet::Util::Execution.stubs(:execute_windows).returns(proc_info_stub)
 
           Puppet::Util::Windows::Process.expects(:wait_process).with(process_handle).raises('whatever')
-          Puppet::Util::Windows::Process.expects(:CloseHandle).with(thread_handle)
-          Puppet::Util::Windows::Process.expects(:CloseHandle).with(process_handle)
+          FFI::WIN32.expects(:CloseHandle).with(thread_handle)
+          FFI::WIN32.expects(:CloseHandle).with(process_handle)
 
           expect { Puppet::Util::Execution.execute('test command') }.to raise_error(RuntimeError)
         end
@@ -507,25 +501,25 @@ describe Puppet::Util::Execution do
       end
 
       it "should read and return the output if squelch is false" do
-        stdout = Tempfile.new('test')
-        Tempfile.stubs(:new).returns(stdout)
+        stdout = Puppet::FileSystem::Uniquefile.new('test')
+        Puppet::FileSystem::Uniquefile.stubs(:new).returns(stdout)
         stdout.write("My expected command output")
 
         Puppet::Util::Execution.execute('test command').should == "My expected command output"
       end
 
       it "should not read the output if squelch is true" do
-        stdout = Tempfile.new('test')
-        Tempfile.stubs(:new).returns(stdout)
+        stdout = Puppet::FileSystem::Uniquefile.new('test')
+        Puppet::FileSystem::Uniquefile.stubs(:new).returns(stdout)
         stdout.write("My expected command output")
 
         Puppet::Util::Execution.execute('test command', :squelch => true).should == ''
       end
 
       it "should delete the file used for output if squelch is false" do
-        stdout = Tempfile.new('test')
+        stdout = Puppet::FileSystem::Uniquefile.new('test')
         path = stdout.path
-        Tempfile.stubs(:new).returns(stdout)
+        Puppet::FileSystem::Uniquefile.stubs(:new).returns(stdout)
 
         Puppet::Util::Execution.execute('test command')
 
@@ -533,8 +527,8 @@ describe Puppet::Util::Execution do
       end
 
       it "should not raise an error if the file is open" do
-        stdout = Tempfile.new('test')
-        Tempfile.stubs(:new).returns(stdout)
+        stdout = Puppet::FileSystem::Uniquefile.new('test')
+        Puppet::FileSystem::Uniquefile.stubs(:new).returns(stdout)
         file = File.new(stdout.path, 'r')
 
         Puppet::Util.execute('test command')
@@ -597,40 +591,39 @@ describe Puppet::Util::Execution do
   describe "#execpipe" do
     it "should execute a string as a string" do
       Puppet::Util::Execution.expects(:open).with('| echo hello 2>&1').returns('hello')
-      $CHILD_STATUS.expects(:==).with(0).returns(true)
+      Puppet::Util::Execution.expects(:exitstatus).returns(0)
       Puppet::Util::Execution.execpipe('echo hello').should == 'hello'
     end
 
     it "should print meaningful debug message for string argument" do
       Puppet::Util::Execution.expects(:debug).with("Executing 'echo hello'")
       Puppet::Util::Execution.expects(:open).with('| echo hello 2>&1').returns('hello')
-      $CHILD_STATUS.expects(:==).with(0).returns(true)
+      Puppet::Util::Execution.expects(:exitstatus).returns(0)
       Puppet::Util::Execution.execpipe('echo hello')
     end
 
     it "should print meaningful debug message for array argument" do
       Puppet::Util::Execution.expects(:debug).with("Executing 'echo hello'")
       Puppet::Util::Execution.expects(:open).with('| echo hello 2>&1').returns('hello')
-      $CHILD_STATUS.expects(:==).with(0).returns(true)
+      Puppet::Util::Execution.expects(:exitstatus).returns(0)
       Puppet::Util::Execution.execpipe(['echo','hello'])
     end
 
     it "should execute an array by pasting together with spaces" do
       Puppet::Util::Execution.expects(:open).with('| echo hello 2>&1').returns('hello')
-      $CHILD_STATUS.expects(:==).with(0).returns(true)
+      Puppet::Util::Execution.expects(:exitstatus).returns(0)
       Puppet::Util::Execution.execpipe(['echo', 'hello']).should == 'hello'
     end
 
     it "should fail if asked to fail, and the child does" do
-      Puppet::Util::Execution.stubs(:open).returns('error message')
-      $CHILD_STATUS.expects(:==).with(0).returns(false)
+      Puppet::Util::Execution.stubs(:open).with('| echo hello 2>&1').returns('error message')
+      Puppet::Util::Execution.expects(:exitstatus).returns(1)
       expect { Puppet::Util::Execution.execpipe('echo hello') }.
         to raise_error Puppet::ExecutionFailure, /error message/
     end
 
     it "should not fail if asked not to fail, and the child does" do
       Puppet::Util::Execution.stubs(:open).returns('error message')
-      $CHILD_STATUS.stubs(:==).with(0).returns(false)
       Puppet::Util::Execution.execpipe('echo hello', false).should == 'error message'
     end
   end