puppet 5.5.2-x64-mingw32 → 5.5.3-x64-mingw32

data/spec/shared_examples/rhel_package_provider.rb

@@ -68,7 +68,7 @@ shared_examples "RHEL package provider" do |provider_class, provider_name|
       before(:each) do
         Puppet::Util.stubs(:which).with("rpm").returns("/bin/rpm")
         provider.stubs(:which).with("rpm").returns("/bin/rpm")
-        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "--version"], {:combine => true, :custom_environment => {}, :failonfail => true}).returns("4.10.1\n").at_most_once
+        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "--version"], {:combine => true, :custom_environment => {}, :failonfail => true}).returns(Puppet::Util::Execution::ProcessOutput.new("4.10.1\n", 0)).at_most_once
         Facter.stubs(:value).with(:operatingsystemmajrelease).returns('6')
       end
       it "should call #{provider_name} install for :installed" do
@@ -84,7 +84,7 @@ shared_examples "RHEL package provider" do |provider_class, provider_name|
           end
           it "should catch #{provider_name} install failures when status code is wrong" do
             resource.stubs(:should).with(:ensure).returns :installed
-            Puppet::Util::Execution.expects(:execute).with(["/usr/bin/#{provider_name}", '-e', error_level, '-y', :install, name]).returns("No package #{name} available.")
+            Puppet::Util::Execution.expects(:execute).with(["/usr/bin/#{provider_name}", '-e', error_level, '-y', :install, name]).returns(Puppet::Util::Execution::ProcessOutput.new("No package #{name} available.", 0))
             expect {
               provider.install
             }.to raise_error(Puppet::Error, "Could not find package #{name}")

data/spec/unit/application/device_spec.rb

@@ -140,6 +140,11 @@ describe Puppet::Application::Device do
       @device.handle_resource(true)
     end
 
+    it "should store the facts options with --facts" do
+      @device.options.expects(:[]=).with(:facts,true)
+
+      @device.handle_facts(true)
+    end
   end
 
   describe "during setup" do
@@ -291,6 +296,7 @@ describe Puppet::Application::Device do
       @device.options.stubs(:[]).with(:detailed_exitcodes).returns(false)
       @device.options.stubs(:[]).with(:target).returns(nil)
       @device.options.stubs(:[]).with(:apply).returns(nil)
+      @device.options.stubs(:[]).with(:facts).returns(false)
       @device.options.stubs(:[]).with(:resource).returns(false)
       @device.options.stubs(:[]).with(:to_yaml).returns(false)
       @device.options.stubs(:[]).with(:client)
@@ -305,8 +311,12 @@ describe Puppet::Application::Device do
 
     it "should exit if resource is requested without target" do
       @device.options.stubs(:[]).with(:resource).returns(true)
-      Puppet.expects(:err).with "resource command requires target"
-      expect { @device.main }.to exit_with 1
+      expect { @device.main }.to raise_error(RuntimeError, "resource command requires target")
+    end
+
+    it "should exit if facts is requested without target" do
+      @device.options.stubs(:[]).with(:facts).returns(true)
+      expect { @device.main }.to raise_error(RuntimeError, "facts command requires target")
     end
 
     it "should get the device list" do
@@ -337,8 +347,7 @@ describe Puppet::Application::Device do
 
       Puppet::Util::NetworkDevice::Config.expects(:devices).returns(device_hash)
       Puppet.expects(:info).with(regexp_matches(/starting applying configuration to/)).never
-      Puppet.expects(:err).with(regexp_matches(/Target device \/ certificate 'bla' not found in .*\.conf/))
-      expect { @device.main }.to exit_with 1
+      expect { @device.main }.to raise_error(RuntimeError, /Target device \/ certificate 'bla' not found in .*\.conf/)
     end
 
     it "should error if target is passed and the apply path is incorrect" do
@@ -346,11 +355,33 @@ describe Puppet::Application::Device do
       @device.options.stubs(:[]).with(:target).returns('device1')
 
       File.expects(:file?).returns(false)
-      Puppet.expects(:err).with(regexp_matches(/does not exist, cannot apply/))
+      expect { @device.main }.to raise_error(RuntimeError, /does not exist, cannot apply/)
+    end
+
+    it "should run an apply, and not create the state folder" do
+      @device.options.stubs(:[]).with(:apply).returns('file.pp')
+      @device.options.stubs(:[]).with(:target).returns('device1')
+      device_hash = {
+        "device1" => OpenStruct.new(:name => "device1", :url => "ssh://user:pass@testhost", :provider => "cisco"),
+      }
+      Puppet::Util::NetworkDevice::Config.expects(:devices).returns(device_hash)
+      Puppet::Util::NetworkDevice.stubs(:init)
+      File.expects(:file?).returns(true)
+
+      ::File.stubs(:directory?).returns false
+      state_path = tmpfile('state')
+      Puppet[:statedir] = state_path
+      File.expects(:directory?).with(state_path).returns true
+      FileUtils.expects(:mkdir_p).with(state_path).never
+
+      Puppet::Util::CommandLine.expects(:new).once
+      Puppet::Application::Apply.expects(:new).once
+
+      Puppet::Configurer.expects(:new).never
       expect { @device.main }.to exit_with 1
     end
 
-    it "should run an apply" do
+    it "should run an apply, and create the state folder" do
       @device.options.stubs(:[]).with(:apply).returns('file.pp')
       @device.options.stubs(:[]).with(:target).returns('device1')
       device_hash = {
@@ -359,6 +390,7 @@ describe Puppet::Application::Device do
       Puppet::Util::NetworkDevice::Config.expects(:devices).returns(device_hash)
       Puppet::Util::NetworkDevice.stubs(:init)
       File.expects(:file?).returns(true)
+      FileUtils.expects(:mkdir_p).once
 
       Puppet::Util::CommandLine.expects(:new).once
       Puppet::Application::Apply.expects(:new).once
@@ -426,15 +458,17 @@ describe Puppet::Application::Device do
         @device.options.stubs(:[]).with(:target).returns('device1')
         @device.command_line.stubs(:args).returns(['user'])
         Puppet::Resource.indirection.expects(:search).with('user/', {}).returns([])
-        expect { @device.main }.to exit_with 1
+        expect { @device.main }.to exit_with 0
       end
 
       it "should retrieve named resources of a type" do
+        resource = Puppet::Type.type(:user).new(:name => "jim").to_resource
         @device.options.stubs(:[]).with(:resource).returns(true)
         @device.options.stubs(:[]).with(:target).returns('device1')
-        @device.command_line.stubs(:args).returns(['user', 'title'])
-        Puppet::Resource.indirection.expects(:find).with('user/title')
-        expect { @device.main }.to exit_with 1
+        @device.command_line.stubs(:args).returns(['user', 'jim'])
+        Puppet::Resource.indirection.expects(:find).with('user/jim').returns(resource)
+        @device.expects(:puts).with("user { 'jim':\n}")
+        expect { @device.main }.to exit_with 0
       end
 
       it "should output resources as YAML" do
@@ -447,7 +481,17 @@ describe Puppet::Application::Device do
         @device.command_line.stubs(:args).returns(['user'])
         Puppet::Resource.indirection.expects(:search).with('user/', {}).returns(resources)
         @device.expects(:puts).with("user:\n  title:\n")
-        expect { @device.main }.to exit_with 1
+        expect { @device.main }.to exit_with 0
+      end
+
+      it "should retrieve facts" do
+        indirection_fact_values = {"operatingsystem"=>"cisco_ios","clientcert"=>"3750"}
+        indirection_facts = Puppet::Node::Facts.new("nil", indirection_fact_values)
+        @device.options.stubs(:[]).with(:facts).returns(true)
+        @device.options.stubs(:[]).with(:target).returns('device1')
+        Puppet::Node::Facts.indirection.expects(:find).with(nil, anything()).returns(indirection_facts)
+        @device.expects(:puts).with(regexp_matches(/name.*3750.*\n.*values.*\n.*operatingsystem.*cisco_ios/))
+        expect { @device.main }.to exit_with 0
       end
 
       it "should make sure all the required folders and files are created" do

data/spec/unit/application/master_spec.rb

@@ -124,20 +124,21 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
           @master.options.stubs(:[]).with(:setdest).returns false
         end
 
-        it "logs to the console when --compile is given" do
+        it "should log to the console when --compile is given" do
           @master.options.stubs(:[]).with(:node).returns "default"
           Puppet::Util::Log.expects(:newdestination).with(:console)
           @master.setup
         end
 
-        it "logs to the console when the master is not daemonized or run with rack" do
+        it "should log to the console when the master is not daemonized or run with rack" do
           Puppet::Util::Log.expects(:newdestination).with(:console)
           Puppet[:daemonize] = false
           @master.options.stubs(:[]).with(:rack).returns(false)
           @master.setup
         end
 
-        it "logs to syslog when the master is daemonized" do
+        it "should log to syslog when the master is daemonized" do
+
           Puppet::Util::Log.expects(:newdestination).with(:console).never
           Puppet::Util::Log.expects(:newdestination).with(:syslog)
           Puppet[:daemonize] = true
@@ -145,7 +146,7 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
           @master.setup
         end
 
-        it "logs to syslog when the master is run with rack" do
+        it "should log to syslog when the master is run with rack" do
           Puppet::Util::Log.expects(:newdestination).with(:console).never
           Puppet::Util::Log.expects(:newdestination).with(:syslog)
           Puppet[:daemonize] = false

data/spec/unit/gettext/config_spec.rb

@@ -95,29 +95,48 @@ describe Puppet::GettextConfig do
     end
 
     it 'should copy default translations when creating a non-default text domain' do
+      Puppet::GettextConfig.reset_text_domain(:test)
+      expect(Puppet::GettextConfig.loaded_text_domains).to include(Puppet::GettextConfig::DEFAULT_TEXT_DOMAIN, :test)
+    end
+
+    it 'should normalize domain name when creating a non-default text domain' do
       Puppet::GettextConfig.reset_text_domain('test')
-      expect(Puppet::GettextConfig.loaded_text_domains).to include(Puppet::GettextConfig::DEFAULT_TEXT_DOMAIN, 'test')
+      expect(Puppet::GettextConfig.loaded_text_domains).to include(Puppet::GettextConfig::DEFAULT_TEXT_DOMAIN, :test)
+    end
+  end
+
+  describe "clearing the configured text domain" do
+    it 'succeeds' do
+      Puppet::GettextConfig.clear_text_domain
+      expect(FastGettext.text_domain).to be_nil
+    end
+
+    it 'falls back to default' do
+      Puppet::GettextConfig.reset_text_domain(:test)
+      expect(FastGettext.text_domain).to eq(:test)
+      Puppet::GettextConfig.clear_text_domain
+      expect(FastGettext.text_domain).to eq(Puppet::GettextConfig::DEFAULT_TEXT_DOMAIN)
     end
   end
 
   describe "deleting text domains" do
     it 'can delete a text domain by name' do
-      Puppet::GettextConfig.reset_text_domain('test')
-      expect(Puppet::GettextConfig.loaded_text_domains).to include(Puppet::GettextConfig::DEFAULT_TEXT_DOMAIN, 'test')
-      Puppet::GettextConfig.delete_text_domain(Puppet::GettextConfig::DEFAULT_TEXT_DOMAIN)
-      expect(Puppet::GettextConfig.loaded_text_domains).not_to include(Puppet::GettextConfig::DEFAULT_TEXT_DOMAIN)
+      Puppet::GettextConfig.reset_text_domain(:test)
+      expect(Puppet::GettextConfig.loaded_text_domains).to include(Puppet::GettextConfig::DEFAULT_TEXT_DOMAIN, :test)
+      Puppet::GettextConfig.delete_text_domain(:test)
+      expect(Puppet::GettextConfig.loaded_text_domains).to eq([Puppet::GettextConfig::DEFAULT_TEXT_DOMAIN])
     end
 
     it 'can delete all non-default text domains' do
-      Puppet::GettextConfig.reset_text_domain('test')
-      expect(Puppet::GettextConfig.loaded_text_domains).to include(Puppet::GettextConfig::DEFAULT_TEXT_DOMAIN, 'test')
+      Puppet::GettextConfig.reset_text_domain(:test)
+      expect(Puppet::GettextConfig.loaded_text_domains).to include(Puppet::GettextConfig::DEFAULT_TEXT_DOMAIN, :test)
       Puppet::GettextConfig.delete_environment_text_domains
-      expect(Puppet::GettextConfig.loaded_text_domains).not_to include('test')
+      expect(Puppet::GettextConfig.loaded_text_domains).to eq([Puppet::GettextConfig::DEFAULT_TEXT_DOMAIN])
     end
 
     it 'can delete all text domains' do
-      Puppet::GettextConfig.reset_text_domain('test')
-      expect(Puppet::GettextConfig.loaded_text_domains).to include(Puppet::GettextConfig::DEFAULT_TEXT_DOMAIN, 'test')
+      Puppet::GettextConfig.reset_text_domain(:test)
+      expect(Puppet::GettextConfig.loaded_text_domains).to include(Puppet::GettextConfig::DEFAULT_TEXT_DOMAIN, :test)
       Puppet::GettextConfig.delete_all_text_domains
       expect(Puppet::GettextConfig.loaded_text_domains).to be_empty
     end

data/spec/unit/node/environment_spec.rb

@@ -496,15 +496,16 @@ describe Puppet::Node::Environment do
     it "creates a new text domain the first time we try to use the text domain" do
       Puppet::GettextConfig.expects(:reset_text_domain).with(env.name)
       Puppet::ModuleTranslations.expects(:load_from_modulepath)
+      Puppet::GettextConfig.expects(:clear_text_domain)
 
-      env.use_text_domain
+      env.with_text_domain do; end
     end
 
     it "uses the existing text domain once it has been created" do
-      env.use_text_domain
+      env.with_text_domain do; end
 
       Puppet::GettextConfig.expects(:use_text_domain).with(env.name)
-      env.use_text_domain
+      env.with_text_domain do; end
     end
   end
 

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

@@ -23,7 +23,7 @@ describe Puppet::Type.type(:package).provider(:aptitude) do
         Puppet::Util::Execution.expects(:execute).with(
           [dpkgquery_path, '-W', '--showformat', "'${Status} ${Package} ${Version}\\n'", 'faff'],
           {:failonfail => true, :combine => true, :custom_environment => {}}
-        ).returns(output)
+        ).returns(Puppet::Util::Execution::ProcessOutput.new(output, 0))
 
         expect(pkg.property(:ensure).retrieve).to eq(expect)
       end

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

@@ -13,7 +13,7 @@ describe Puppet::Type.type(:package).provider(:aptrpm) do
     before(:each) do
       Puppet::Util.stubs(:which).with("rpm").returns("/bin/rpm")
       pkg.provider.stubs(:which).with("rpm").returns("/bin/rpm")
-      Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "--version"], {:combine => true, :custom_environment => {}, :failonfail => true}).returns("4.10.1\n").at_most_once
+      Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "--version"], {:combine => true, :custom_environment => {}, :failonfail => true}).returns(Puppet::Util::Execution::ProcessOutput.new("4.10.1\n", 0)).at_most_once
     end
 
     def rpm_args

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

@@ -68,7 +68,7 @@ describe provider_class do
     end
 
     def dpkg_query_execution_returns(output)
-      Puppet::Util::Execution.expects(:execute).with(query_args, execute_options).returns(output)
+      Puppet::Util::Execution.expects(:execute).with(query_args, execute_options).returns(Puppet::Util::Execution::ProcessOutput.new(output, 0))
     end
 
     before do

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

@@ -27,7 +27,7 @@ describe provider_class do
   end
 
   let(:bff_showres_output) {
-    <<END
+    Puppet::Util::Execution::ProcessOutput.new(<<END, 0)
 mypackage.foo                                                           ALL  @@I:mypackage.foo _all_filesets
  @ 1.2.3.1  MyPackage Runtime Environment                       @@I:mypackage.foo 1.2.3.1
  + 1.2.3.4  MyPackage Runtime Environment                       @@I:mypackage.foo 1.2.3.4
@@ -37,7 +37,7 @@ END
   }
 
   let(:rpm_showres_output) {
-    <<END
+    Puppet::Util::Execution::ProcessOutput.new(<<END, 0)
 mypackage.foo                                                                ALL  @@R:mypackage.foo _all_filesets
  @@R:mypackage.foo-1.2.3-1 1.2.3-1
  @@R:mypackage.foo-1.2.3-4 1.2.3-4
@@ -168,9 +168,6 @@ OUTPUT
 
       expect { @provider.install }.to raise_error(Puppet::Error, "NIM package provider is unable to downgrade packages")
     end
-
-
-
   end
 
   context "when uninstalling" do
@@ -187,10 +184,8 @@ OUTPUT
       @provider.class.expects(:pkglist).with(:pkgname => 'mypackage.foo').returns(nil)
       @provider.uninstall
     end
-
   end
 
-
   context "when parsing nimclient showres output" do
     describe "#parse_showres_output" do
       it "should be able to parse installp/BFF package listings" do
@@ -231,7 +226,6 @@ END
           expect(subject.send(:determine_latest_version, nimclient_showres_output, 'mypackage.foo')).to eq([:rpm, nil])
         end
       end
-
     end
 
     describe "#determine_package_type" do
@@ -244,7 +238,4 @@ END
       end
     end
   end
-
-
-
 end

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

@@ -74,7 +74,7 @@ describe Puppet::Type.type(:package).provider(:opkg) do
         end
 
         it "should install from the path segment of the URL" do
-          Puppet::Util::Execution.expects(:execute).returns("")
+          Puppet::Util::Execution.expects(:execute).returns(Puppet::Util::Execution::ProcessOutput.new("", 0))
           provider.install
         end
       end
@@ -165,7 +165,7 @@ OPKG_OUTPUT
     end
 
     it "should return a nil if the package isn't found" do
-      Puppet::Util::Execution.expects(:execute).returns("")
+      Puppet::Util::Execution.expects(:execute).returns(Puppet::Util::Execution::ProcessOutput.new("", 0))
       expect(provider.query).to be_nil
     end
 

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

@@ -115,7 +115,9 @@ describe Puppet::Type.type(:package).provider(:pkg) do
       end
 
       it "should work correctly for ensure latest on solaris 11(known UFOXI)" do
-        Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'update', '-n', 'dummy'], {:failonfail => false, :combine => true}).returns ''
+        Puppet::Util::Execution.expects(:execute)
+          .with(['/bin/pkg', 'update', '-n', 'dummy'], {:failonfail => false, :combine => true})
+          .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
         $CHILD_STATUS.stubs(:exitstatus).returns 0
 
         described_class.expects(:pkg).with(:list,'-Hvn','dummy').returns File.read(my_fixture('dummy_solaris11.known'))
@@ -180,7 +182,9 @@ describe Puppet::Type.type(:package).provider(:pkg) do
     context ":query" do
       context "on solaris 10" do
         it "should find the package" do
-          Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true}).returns File.read(my_fixture('dummy_solaris10'))
+          Puppet::Util::Execution.expects(:execute)
+            .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
+            .returns(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_solaris10')), 0))
           $CHILD_STATUS.stubs(:exitstatus).returns 0
           expect(provider.query).to eq({
             :name      => 'dummy',
@@ -192,7 +196,9 @@ describe Puppet::Type.type(:package).provider(:pkg) do
         end
 
         it "should return :absent when the package is not found" do
-          Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true}).returns ''
+          Puppet::Util::Execution.expects(:execute)
+            .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
+            .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
           $CHILD_STATUS.stubs(:exitstatus).returns 1
           expect(provider.query).to eq({:ensure => :absent, :name => "dummy"})
         end
@@ -201,7 +207,9 @@ describe Puppet::Type.type(:package).provider(:pkg) do
       context "on solaris 11" do
         it "should find the package" do
           $CHILD_STATUS.stubs(:exitstatus).returns 0
-          Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true}).returns File.read(my_fixture('dummy_solaris11.installed'))
+          Puppet::Util::Execution.expects(:execute)
+            .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
+            .returns(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_solaris11.installed')), 0))
           expect(provider.query).to eq({
             :name      => 'dummy',
             :status    => 'installed',
@@ -212,14 +220,19 @@ describe Puppet::Type.type(:package).provider(:pkg) do
         end
 
         it "should return :absent when the package is not found" do
-          Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true}).returns ''
+          Puppet::Util::Execution
+            .expects(:execute)
+            .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
+            .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
           $CHILD_STATUS.stubs(:exitstatus).returns 1
           expect(provider.query).to eq({:ensure => :absent, :name => "dummy"})
         end
       end
 
       it "should return fail when the packageline cannot be parsed" do
-        Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true}).returns(File.read(my_fixture('incomplete')))
+        Puppet::Util::Execution.expects(:execute)
+          .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
+          .returns(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('incomplete')), 0))
         $CHILD_STATUS.stubs(:exitstatus).returns 0
         expect {
           provider.query
@@ -238,8 +251,12 @@ describe Puppet::Type.type(:package).provider(:pkg) do
           end
           it "should accept all licenses" do
             provider.expects(:query).with().returns({:ensure => :absent})
-            Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'install', *hash[:flags], 'dummy'], {:failonfail => false, :combine => true}).returns ''
-            Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true}).returns ''
+            Puppet::Util::Execution.expects(:execute)
+              .with(['/bin/pkg', 'install', *hash[:flags], 'dummy'], {:failonfail => false, :combine => true})
+              .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
+            Puppet::Util::Execution.expects(:execute)
+              .with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
+              .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
             $CHILD_STATUS.stubs(:exitstatus).returns 0
             provider.install
           end
@@ -249,16 +266,24 @@ describe Puppet::Type.type(:package).provider(:pkg) do
             resource[:ensure] = '0.0.7,5.11-0.151006:20131230T130000Z'
             $CHILD_STATUS.stubs(:exitstatus).returns 0
             Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
-            Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true}).returns 'pkg://foo/dummy@0.0.6,5.11-0.151006:20131230T130000Z  installed -----'
-            Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'update', *hash[:flags], 'dummy@0.0.7,5.11-0.151006:20131230T130000Z'], {:failonfail => false, :combine => true}).returns ''
+            Puppet::Util::Execution.expects(:execute)
+              .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
+              .returns(Puppet::Util::Execution::ProcessOutput.new('pkg://foo/dummy@0.0.6,5.11-0.151006:20131230T130000Z  installed -----', 0))
+            Puppet::Util::Execution.expects(:execute)
+              .with(['/bin/pkg', 'update', *hash[:flags], 'dummy@0.0.7,5.11-0.151006:20131230T130000Z'], {:failonfail => false, :combine => true})
+              .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
             provider.install
           end
 
           it "should install specific version(2)" do
             resource[:ensure] = '0.0.8'
             Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
-            Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true}).returns 'pkg://foo/dummy@0.0.7,5.11-0.151006:20131230T130000Z  installed -----'
-            Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'update', *hash[:flags], 'dummy@0.0.8'], {:failonfail => false, :combine => true}).returns ''
+            Puppet::Util::Execution.expects(:execute)
+              .with(['/bin/pkg', 'list', '-Hv', 'dummy'], {:failonfail => false, :combine => true})
+              .returns(Puppet::Util::Execution::ProcessOutput.new('pkg://foo/dummy@0.0.7,5.11-0.151006:20131230T130000Z  installed -----', 0))
+            Puppet::Util::Execution.expects(:execute)
+              .with(['/bin/pkg', 'update', *hash[:flags], 'dummy@0.0.8'], {:failonfail => false, :combine => true})
+              .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
             $CHILD_STATUS.stubs(:exitstatus).returns 0
             provider.install
           end
@@ -268,14 +293,18 @@ describe Puppet::Type.type(:package).provider(:pkg) do
             provider.expects(:query).with().returns({:ensure => '0.0.8,5.11-0.151106:20131230T130000Z'})
             $CHILD_STATUS.stubs(:exitstatus).returns 0
             Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
-            Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'update', *hash[:flags], 'dummy@0.0.7'], {:failonfail => false, :combine => true}).returns ''
+            Puppet::Util::Execution.expects(:execute)
+              .with(['/bin/pkg', 'update', *hash[:flags], 'dummy@0.0.7'], {:failonfail => false, :combine => true})
+              .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
             provider.install
           end
 
           it "should install any if version is not specified" do
             resource[:ensure] = :present
             provider.expects(:query).with().returns({:ensure => :absent})
-            Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'install', *hash[:flags], 'dummy'], {:failonfail => false, :combine => true}).returns ''
+            Puppet::Util::Execution.expects(:execute)
+              .with(['/bin/pkg', 'install', *hash[:flags], 'dummy'], {:failonfail => false, :combine => true})
+              .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
             Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
             $CHILD_STATUS.stubs(:exitstatus).returns 0
             provider.install
@@ -285,7 +314,9 @@ describe Puppet::Type.type(:package).provider(:pkg) do
             resource[:ensure] = '0.0.7'
             provider.expects(:query).with().returns({:ensure => :absent})
             Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'unfreeze', 'dummy'], {:failonfail => false, :combine => true})
-            Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'install', *hash[:flags], 'dummy@0.0.7'], {:failonfail => false, :combine => true}).returns ''
+            Puppet::Util::Execution.expects(:execute)
+              .with(['/bin/pkg', 'install', *hash[:flags], 'dummy@0.0.7'], {:failonfail => false, :combine => true})
+              .returns(Puppet::Util::Execution::ProcessOutput.new('', 0))
             $CHILD_STATUS.stubs(:exitstatus).returns 0
             provider.install
           end
@@ -294,7 +325,9 @@ describe Puppet::Type.type(:package).provider(:pkg) do
             resource[:ensure] = '1.0-0.151006'
             is = :absent
             provider.expects(:query).with().returns({:ensure => is})
-            described_class.expects(:pkg).with(:list, '-Hvfa', 'dummy@1.0-0.151006').returns File.read(my_fixture('dummy_implicit_version'))
+            described_class.expects(:pkg)
+              .with(:list, '-Hvfa', 'dummy@1.0-0.151006')
+              .returns(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_implicit_version')), 0))
             Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'install', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
             provider.expects(:unhold).with()
             Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'install', *hash[:flags], 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
@@ -320,7 +353,9 @@ describe Puppet::Type.type(:package).provider(:pkg) do
             resource[:ensure] = '1.0-0.151006'
             is = '1.0,5.11-0.151006:20140220T084443Z'
             provider.expects(:warning).with("Implicit version 1.0-0.151006 has 3 possible matches")
-            described_class.expects(:pkg).with(:list, '-Hvfa', 'dummy@1.0-0.151006').returns File.read(my_fixture('dummy_implicit_version'))
+            described_class.expects(:pkg)
+              .with(:list, '-Hvfa', 'dummy@1.0-0.151006')
+              .returns(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_implicit_version')), 0))
             Puppet::Util::Execution.expects(:execute).with(['/bin/pkg', 'update', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
             $CHILD_STATUS.stubs(:exitstatus).returns 4
             provider.insync?(is)