puppet 3.4.3 → 3.5.0.rc1

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

@@ -188,36 +188,55 @@ describe provider_class do
 
     describe "on a modern RPM" do
       before(:each) do
-        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-q",  "myresource", '--nosignature', '--nodigest', "--qf", nevra_format], execute_options).returns("myresource 0 1.2.3.4 5.el4 noarch\n")
+        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-q", "--whatprovides", "myresource", '--nosignature', '--nodigest', "--qf", nevra_format], execute_options).returns("myresource 0 1.2.3.4 5.el4 noarch\n")
       end
 
       let(:rpm_version) { "RPM version 4.10.0\n" }
 
       it "includes the architecture in the package name" do
-        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-e", 'myresource-1.2.3.4-5.el4.noarch'], execute_options).returns('').at_most_once
+        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", ["-e"], 'myresource-1.2.3.4-5.el4.noarch'], execute_options).returns('').at_most_once
         provider.uninstall
       end
     end
 
     describe "on an ancient RPM" do
       before(:each) do
-        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-q",  "myresource", '', '', '--qf', nevra_format], execute_options).returns("myresource 0 1.2.3.4 5.el4 noarch\n")
+        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-q", "--whatprovides", "myresource", '', '', '--qf', nevra_format], execute_options).returns("myresource 0 1.2.3.4 5.el4 noarch\n")
       end
 
       let(:rpm_version) { "RPM version 3.0.6\n" }
 
       it "excludes the architecture from the package name" do
-        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-e", 'myresource-1.2.3.4-5.el4'], execute_options).returns('').at_most_once
+        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", ["-e"], 'myresource-1.2.3.4-5.el4'], execute_options).returns('').at_most_once
         provider.uninstall
       end
     end
 
+    describe "when uninstalled with options" do
+      before(:each) do
+        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-q", "--whatprovides", "myresource", '--nosignature', '--nodigest', "--qf", nevra_format], execute_options).returns("myresource 0 1.2.3.4 5.el4 noarch\n")
+      end
+
+      let(:resource) do
+        Puppet::Type.type(:package).new(
+          :name              => resource_name,
+          :ensure            => :absent,
+          :provider          => 'rpm',
+          :uninstall_options => ['--nodeps']
+        )
+      end
+
+      it "includes the options" do
+        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", ["-e", "--nodeps"], 'myresource-1.2.3.4-5.el4.noarch'], execute_options)
+        provider.uninstall
+      end
+    end
   end
 
   describe "parsing" do
     def parser_test(rpm_output_string, gold_hash, number_of_debug_logs = 0)
       Puppet.expects(:debug).times(number_of_debug_logs)
-      Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-q", resource_name, "--nosignature", "--nodigest", "--qf", nevra_format], execute_options).returns(rpm_output_string)
+      Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-q", "--whatprovides", resource_name, "--nosignature", "--nodigest", "--qf", nevra_format], execute_options).returns(rpm_output_string)
       expect(provider.query).to eq(gold_hash)
     end
 
@@ -256,7 +275,7 @@ describe provider_class do
 
     it "does not log or fail if rpm returns package not found" do
       Puppet.expects(:debug).never
-      Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-q", resource_name, "--nosignature", "--nodigest", "--qf", nevra_format], execute_options).raises Puppet::ExecutionFailure.new('package not found')
+      Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-q", "--whatprovides", resource_name, "--nosignature", "--nodigest", "--qf", nevra_format], execute_options).raises Puppet::ExecutionFailure.new('package not found')
 
       expect(provider.query).to be_nil
     end
@@ -281,12 +300,38 @@ describe provider_class do
       provider.resource[:install_options] = { '-Darch' => 'vax' }
       expect(provider.install_options).to eq(['-Darch=vax'])
     end
+
     it 'returns install_options when an array with hashes' do
       provider.resource[:install_options] = [ '-L', { '-Darch' => 'vax' }]
       expect(provider.install_options).to eq(['-L', '-Darch=vax'])
     end
   end
 
+  describe "#uninstall_options" do
+    it "returns empty array by default" do
+      expect(provider.uninstall_options).to eq([])
+    end
+
+    it "returns uninstall_options when set" do
+      provider.resource[:uninstall_options] = ['-n']
+      expect(provider.uninstall_options).to eq(['-n'])
+    end
+
+    it "returns multiple uninstall_options when set" do
+      provider.resource[:uninstall_options] = ['-L', '/opt/puppet']
+      expect(provider.uninstall_options).to eq(['-L', '/opt/puppet'])
+    end
+
+    it 'returns uninstall_options when set as hash' do
+      provider.resource[:uninstall_options] = { '-Darch' => 'vax' }
+      expect(provider.uninstall_options).to eq(['-Darch=vax'])
+    end
+    it 'returns uninstall_options when an array with hashes' do
+      provider.resource[:uninstall_options] = [ '-L', { '-Darch' => 'vax' }]
+      expect(provider.uninstall_options).to eq(['-L', '-Darch=vax'])
+    end
+  end
+
   describe ".nodigest" do
     { '4.0'   => nil,
       '4.0.1' => nil,

data/spec/unit/provider/service/base_spec.rb

@@ -34,15 +34,15 @@ describe "base service provider" do
     end
 
     before :each do
-      Puppet::FileSystem::File.unlink(flag) if Puppet::FileSystem::File.exist?(flag)
+      Puppet::FileSystem.unlink(flag) if Puppet::FileSystem.exist?(flag)
     end
 
     it { should be }
 
     it "should invoke the start command if not running" do
-      File.should_not be_file flag
+      File.should_not be_file(flag)
       subject.start
-      File.should be_file flag
+      File.should be_file(flag)
     end
 
     it "should be stopped before being started" do
@@ -59,7 +59,7 @@ describe "base service provider" do
       subject.status.should == :running
       subject.stop
       subject.status.should == :stopped
-      File.should_not be_file flag
+      File.should_not be_file(flag)
     end
 
     it "should start again even if already running" do

data/spec/unit/provider/service/daemontools_spec.rb

@@ -101,12 +101,10 @@ describe provider_class do
   describe "when enabling" do
     it "should create a symlink between daemon dir and service dir", :if => Puppet.features.manages_symlinks?  do
       daemon_path = File.join(@daemondir, "myservice")
-      stub_daemon = stub(daemon_path, :symlink? => false)
-      Puppet::FileSystem::File.expects(:new).with(daemon_path).returns(stub_daemon)
       service_path = File.join(@servicedir, "myservice")
-      mock_service = mock(service_path, :symlink? => false)
-      Puppet::FileSystem::File.expects(:new).with(service_path).returns(mock_service)
-      stub_daemon.expects(:symlink).returns(0)
+      Puppet::FileSystem.expects(:symlink?).with(service_path).returns(false)
+      Puppet::FileSystem.expects(:symlink).with(daemon_path, service_path).returns(0)
+
       @provider.enable
     end
   end
@@ -115,18 +113,16 @@ describe provider_class do
     it "should remove the symlink between daemon dir and service dir" do
       FileTest.stubs(:directory?).returns(false)
       path = File.join(@servicedir,"myservice")
-      mocked_file = mock(path, :symlink? => true)
-      Puppet::FileSystem::File.expects(:new).with(path).returns(mocked_file)
-      Puppet::FileSystem::File.expects(:unlink).with(path)
+      Puppet::FileSystem.expects(:symlink?).with(path).returns(true)
+      Puppet::FileSystem.expects(:unlink).with(path)
       @provider.stubs(:texecute).returns("")
       @provider.disable
     end
 
     it "should stop the service" do
       FileTest.stubs(:directory?).returns(false)
-      mocked_file = mock('anything', :symlink? => true)
-      Puppet::FileSystem::File.expects(:new).returns(mocked_file)
-      Puppet::FileSystem::File.stubs(:unlink)
+      Puppet::FileSystem.expects(:symlink?).returns(true)
+      Puppet::FileSystem.stubs(:unlink)
       @provider.expects(:stop)
       @provider.disable
     end
@@ -143,8 +139,7 @@ describe provider_class do
       it "should return #{t} if the symlink exists" do
         @provider.stubs(:status).returns(:stopped)
         path = File.join(@servicedir,"myservice")
-        mocked_file = mock(path, :symlink? => t)
-        Puppet::FileSystem::File.expects(:new).with(path).returns(mocked_file)
+        Puppet::FileSystem.expects(:symlink?).with(path).returns(t)
 
         @provider.enabled?.should == "#{t}".to_sym
       end

data/spec/unit/provider/service/freebsd_spec.rb

@@ -62,13 +62,13 @@ OUTPUT
   end
 
   it "should enable only the selected service" do
-    Puppet::FileSystem::File.stubs(:exist?).with('/etc/rc.conf').returns(true)
+    Puppet::FileSystem.stubs(:exist?).with('/etc/rc.conf').returns(true)
     File.stubs(:read).with('/etc/rc.conf').returns("openntpd_enable=\"NO\"\nntpd_enable=\"NO\"\n")
     fh = stub 'fh'
     File.stubs(:open).with('/etc/rc.conf', File::WRONLY).yields(fh)
     fh.expects(:<<).with("openntpd_enable=\"NO\"\nntpd_enable=\"YES\"\n")
-    Puppet::FileSystem::File.stubs(:exist?).with('/etc/rc.conf.local').returns(false)
-    Puppet::FileSystem::File.stubs(:exist?).with('/etc/rc.conf.d/ntpd').returns(false)
+    Puppet::FileSystem.stubs(:exist?).with('/etc/rc.conf.local').returns(false)
+    Puppet::FileSystem.stubs(:exist?).with('/etc/rc.conf.d/ntpd').returns(false)
 
     @provider.rc_replace('ntpd', 'ntpd', 'YES')
   end

data/spec/unit/provider/service/gentoo_spec.rb

@@ -14,8 +14,8 @@ describe Puppet::Type.type(:service).provider(:gentoo) do
     # before it even tries to execute an initscript. We use sshd in all the
     # tests so make sure it is considered present.
     sshd_path = '/etc/init.d/sshd'
-    stub_file = stub(sshd_path, :stat => stub('stat'))
-    Puppet::FileSystem::File.stubs(:new).with(sshd_path).returns stub_file
+#    stub_file = stub(sshd_path, :stat => stub('stat'))
+    Puppet::FileSystem.stubs(:stat).with(sshd_path).returns stub('stat')
   end
 
   let :initscripts do
@@ -45,7 +45,7 @@ describe Puppet::Type.type(:service).provider(:gentoo) do
   describe ".instances" do
 
     it "should have an instances method" do
-      described_class.should respond_to :instances
+      described_class.should respond_to(:instances)
     end
 
     it "should get a list of services from /etc/init.d but exclude helper scripts" do
@@ -58,7 +58,7 @@ describe Puppet::Type.type(:service).provider(:gentoo) do
         FileTest.expects(:executable?).with("/etc/init.d/#{script}").never
       end
 
-      Puppet::FileSystem::File.stubs(:new).returns stub('file', :symlink? => false)
+      Puppet::FileSystem.stubs(:symlink?).returns false # stub('file', :symlink? => false)
       described_class.instances.map(&:name).should == [
         'alsasound',
         'bootmisc',
@@ -75,12 +75,12 @@ describe Puppet::Type.type(:service).provider(:gentoo) do
   describe "#start" do
     it "should use the supplied start command if specified" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :start => '/bin/foo'))
-      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => true)
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.start
     end
     it "should start the service with <initscript> start otherwise" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      provider.expects(:execute).with(['/etc/init.d/sshd',:start], :failonfail => true, :override_locale => false, :squelch => true)
+      provider.expects(:execute).with(['/etc/init.d/sshd',:start], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.expects(:search).with('sshd').returns('/etc/init.d/sshd')
       provider.start
     end
@@ -89,12 +89,12 @@ describe Puppet::Type.type(:service).provider(:gentoo) do
   describe "#stop" do
     it "should use the supplied stop command if specified" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :stop => '/bin/foo'))
-      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => true)
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.stop
     end
     it "should stop the service with <initscript> stop otherwise" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      provider.expects(:execute).with(['/etc/init.d/sshd',:stop], :failonfail => true, :override_locale => false, :squelch => true)
+      provider.expects(:execute).with(['/etc/init.d/sshd',:stop], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.expects(:search).with('sshd').returns('/etc/init.d/sshd')
       provider.stop
     end
@@ -156,23 +156,23 @@ describe Puppet::Type.type(:service).provider(:gentoo) do
     describe "when a special status command is specified" do
       it "should use the status command from the resource" do
         provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
-        provider.expects(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => true).never
-        provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => true)
+        provider.expects(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).never
+        provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
         provider.status
       end
 
       it "should return :stopped when the status command returns with a non-zero exitcode" do
         provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
-        provider.expects(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => true).never
-        provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => true)
+        provider.expects(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).never
+        provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
         $CHILD_STATUS.stubs(:exitstatus).returns 3
         provider.status.should == :stopped
       end
 
       it "should return :running when the status command returns with a zero exitcode" do
         provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
-        provider.expects(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => true).never
-        provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => true)
+        provider.expects(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).never
+        provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
         $CHILD_STATUS.stubs(:exitstatus).returns 0
         provider.status.should == :running
       end
@@ -181,14 +181,14 @@ describe Puppet::Type.type(:service).provider(:gentoo) do
     describe "when hasstatus is false" do
       it "should return running if a pid can be found" do
         provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasstatus => false))
-        provider.expects(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => true).never
+        provider.expects(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).never
         provider.expects(:getpid).returns 1000
         provider.status.should == :running
       end
 
       it "should return stopped if no pid can be found" do
         provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasstatus => false))
-        provider.expects(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => true).never
+        provider.expects(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).never
         provider.expects(:getpid).returns nil
         provider.status.should == :stopped
       end
@@ -198,7 +198,7 @@ describe Puppet::Type.type(:service).provider(:gentoo) do
       it "should return running if <initscript> status exits with a zero exitcode" do
         provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasstatus => true))
         provider.expects(:search).with('sshd').returns('/etc/init.d/sshd')
-        provider.expects(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => true)
+        provider.expects(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
         $CHILD_STATUS.stubs(:exitstatus).returns 0
         provider.status.should == :running
       end
@@ -206,7 +206,7 @@ describe Puppet::Type.type(:service).provider(:gentoo) do
       it "should return stopped if <initscript> status exits with a non-zero exitcode" do
         provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasstatus => true))
         provider.expects(:search).with('sshd').returns('/etc/init.d/sshd')
-        provider.expects(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => true)
+        provider.expects(:execute).with(['/etc/init.d/sshd',:status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
         $CHILD_STATUS.stubs(:exitstatus).returns 3
         provider.status.should == :stopped
       end
@@ -216,24 +216,24 @@ describe Puppet::Type.type(:service).provider(:gentoo) do
   describe "#restart" do
     it "should use the supplied restart command if specified" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :restart => '/bin/foo'))
-      provider.expects(:execute).with(['/etc/init.d/sshd',:restart], :failonfail => true, :override_locale => false, :squelch => true).never
-      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => true)
+      provider.expects(:execute).with(['/etc/init.d/sshd',:restart], :failonfail => true, :override_locale => false, :squelch => false, :combine => true).never
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.restart
     end
 
     it "should restart the service with <initscript> restart if hasrestart is true" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasrestart => true))
       provider.expects(:search).with('sshd').returns('/etc/init.d/sshd')
-      provider.expects(:execute).with(['/etc/init.d/sshd',:restart], :failonfail => true, :override_locale => false, :squelch => true)
+      provider.expects(:execute).with(['/etc/init.d/sshd',:restart], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.restart
     end
 
     it "should restart the service with <initscript> stop/start if hasrestart is false" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasrestart => false))
       provider.expects(:search).with('sshd').returns('/etc/init.d/sshd')
-      provider.expects(:execute).with(['/etc/init.d/sshd',:restart], :failonfail => true, :override_locale => false, :squelch => true).never
-      provider.expects(:execute).with(['/etc/init.d/sshd',:stop], :failonfail => true, :override_locale => false, :squelch => true)
-      provider.expects(:execute).with(['/etc/init.d/sshd',:start], :failonfail => true, :override_locale => false, :squelch => true)
+      provider.expects(:execute).with(['/etc/init.d/sshd',:restart], :failonfail => true, :override_locale => false, :squelch => false, :combine => true).never
+      provider.expects(:execute).with(['/etc/init.d/sshd',:stop], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:execute).with(['/etc/init.d/sshd',:start], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.restart
     end
   end

data/spec/unit/provider/service/init_spec.rb

@@ -65,9 +65,9 @@ describe Puppet::Type.type(:service).provider(:init) do
     it "should discard upstart jobs", :if => Puppet.features.manages_symlinks? do
       not_init_service, *valid_services = @services
       path = "tmp/#{not_init_service}"
-      mocked_file = mock(path, :symlink? => true, :readlink => "/lib/init/upstart-job")
-      Puppet::FileSystem::File.stubs(:new).returns stub('file', :symlink? => false)
-      Puppet::FileSystem::File.expects(:new).with(path).returns(mocked_file)
+      Puppet::FileSystem.expects(:symlink?).at_least_once.returns false
+      Puppet::FileSystem.expects(:symlink?).with(Puppet::FileSystem.pathname(path)).returns(true)
+      Puppet::FileSystem.expects(:readlink).with(Puppet::FileSystem.pathname(path)).returns("/lib/init/upstart-job")
       described_class.instances.map(&:name).should == valid_services
     end
 
@@ -82,7 +82,7 @@ describe Puppet::Type.type(:service).provider(:init) do
   describe "when checking valid paths" do
     it "should discard paths that do not exist" do
       File.expects(:directory?).with(paths[0]).returns false
-      Puppet::FileSystem::File.expects(:exist?).with(paths[0]).returns false
+      Puppet::FileSystem.expects(:exist?).with(paths[0]).returns false
       File.expects(:directory?).with(paths[1]).returns true
 
       provider.paths.should == [paths[1]]
@@ -90,7 +90,7 @@ describe Puppet::Type.type(:service).provider(:init) do
 
     it "should discard paths that are not directories" do
       paths.each do |path|
-        Puppet::FileSystem::File.expects(:exist?).with(path).returns true
+        Puppet::FileSystem.expects(:exist?).with(path).returns true
         File.expects(:directory?).with(path).returns false
       end
       provider.paths.should be_empty
@@ -103,28 +103,28 @@ describe Puppet::Type.type(:service).provider(:init) do
     end
 
     it "should be able to find the init script in the service path" do
-      Puppet::FileSystem::File.expects(:exist?).with("#{paths[0]}/myservice").returns true
-      Puppet::FileSystem::File.expects(:exist?).with("#{paths[1]}/myservice").never # first one wins
+      Puppet::FileSystem.expects(:exist?).with("#{paths[0]}/myservice").returns true
+      Puppet::FileSystem.expects(:exist?).with("#{paths[1]}/myservice").never # first one wins
       provider.initscript.should == "/service/path/myservice"
     end
 
     it "should be able to find the init script in an alternate service path" do
-      Puppet::FileSystem::File.expects(:exist?).with("#{paths[0]}/myservice").returns false
-      Puppet::FileSystem::File.expects(:exist?).with("#{paths[1]}/myservice").returns true
+      Puppet::FileSystem.expects(:exist?).with("#{paths[0]}/myservice").returns false
+      Puppet::FileSystem.expects(:exist?).with("#{paths[1]}/myservice").returns true
       provider.initscript.should == "/alt/service/path/myservice"
     end
 
     it "should be able to find the init script if it ends with .sh" do
-      Puppet::FileSystem::File.expects(:exist?).with("#{paths[0]}/myservice").returns false
-      Puppet::FileSystem::File.expects(:exist?).with("#{paths[1]}/myservice").returns false
-      Puppet::FileSystem::File.expects(:exist?).with("#{paths[0]}/myservice.sh").returns true
+      Puppet::FileSystem.expects(:exist?).with("#{paths[0]}/myservice").returns false
+      Puppet::FileSystem.expects(:exist?).with("#{paths[1]}/myservice").returns false
+      Puppet::FileSystem.expects(:exist?).with("#{paths[0]}/myservice.sh").returns true
       provider.initscript.should == "/service/path/myservice.sh"
     end
 
     it "should fail if the service isn't there" do
       paths.each do |path|
-        Puppet::FileSystem::File.expects(:exist?).with("#{path}/myservice").returns false
-        Puppet::FileSystem::File.expects(:exist?).with("#{path}/myservice.sh").returns false
+        Puppet::FileSystem.expects(:exist?).with("#{path}/myservice").returns false
+        Puppet::FileSystem.expects(:exist?).with("#{path}/myservice.sh").returns false
       end
       expect { provider.initscript }.to raise_error(Puppet::Error, "Could not find init script for 'myservice'")
     end
@@ -134,7 +134,7 @@ describe Puppet::Type.type(:service).provider(:init) do
     before :each do
       File.stubs(:directory?).with("/service/path").returns true
       File.stubs(:directory?).with("/alt/service/path").returns true
-      Puppet::FileSystem::File.stubs(:exist?).with("/service/path/myservice").returns true
+      Puppet::FileSystem.stubs(:exist?).with("/service/path/myservice").returns true
     end
 
     [:start, :stop, :status, :restart].each do |method|

data/spec/unit/provider/service/openbsd_spec.rb

@@ -46,13 +46,13 @@ describe provider_class do
   describe "#start" do
     it "should use the supplied start command if specified" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :start => '/bin/foo'))
-      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => true)
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.start
     end
 
     it "should start the service otherwise" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      provider.expects(:execute).with(['/etc/rc.d/sshd', '-f', :start], :failonfail => true, :override_locale => false, :squelch => true)
+      provider.expects(:execute).with(['/etc/rc.d/sshd', '-f', :start], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.expects(:search).with('sshd').returns('/etc/rc.d/sshd')
       provider.start
     end
@@ -61,13 +61,13 @@ describe provider_class do
   describe "#stop" do
     it "should use the supplied stop command if specified" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :stop => '/bin/foo'))
-      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => true)
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.stop
     end
 
     it "should stop the service otherwise" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      provider.expects(:execute).with(['/etc/rc.d/sshd', :stop], :failonfail => true, :override_locale => false, :squelch => true)
+      provider.expects(:execute).with(['/etc/rc.d/sshd', :stop], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.expects(:search).with('sshd').returns('/etc/rc.d/sshd')
       provider.stop
     end
@@ -76,23 +76,23 @@ describe provider_class do
   describe "#status" do
     it "should use the status command from the resource" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
-      provider.expects(:execute).with(['/etc/rc.d/sshd', :status], :failonfail => false, :override_locale => false, :squelch => true).never
-      provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => true)
+      provider.expects(:execute).with(['/etc/rc.d/sshd', :status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).never
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
       provider.status
     end
 
       it "should return :stopped when status command returns with a non-zero exitcode" do
         provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
-        provider.expects(:execute).with(['/etc/rc.d/sshd', :status], :failonfail => false, :override_locale => false, :squelch => true).never
-        provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => true)
+        provider.expects(:execute).with(['/etc/rc.d/sshd', :status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).never
+        provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
         $CHILD_STATUS.stubs(:exitstatus).returns 3
         provider.status.should == :stopped
       end
 
       it "should return :running when status command returns with a zero exitcode" do
         provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :status => '/bin/foo'))
-        provider.expects(:execute).with(['/etc/rc.d/sshd', :status], :failonfail => false, :override_locale => false, :squelch => true).never
-        provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => true)
+        provider.expects(:execute).with(['/etc/rc.d/sshd', :status], :failonfail => false, :override_locale => false, :squelch => false, :combine => true).never
+        provider.expects(:execute).with(['/bin/foo'], :failonfail => false, :override_locale => false, :squelch => false, :combine => true)
         $CHILD_STATUS.stubs(:exitstatus).returns 0
         provider.status.should == :running
       end
@@ -101,23 +101,23 @@ describe provider_class do
   describe "#restart" do
     it "should use the supplied restart command if specified" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :restart => '/bin/foo'))
-      provider.expects(:execute).with(['/etc/rc.d/sshd', '-f', :restart], :failonfail => true, :override_locale => false, :squelch => true).never
-      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => true)
+      provider.expects(:execute).with(['/etc/rc.d/sshd', '-f', :restart], :failonfail => true, :override_locale => false, :squelch => false, :combine => true).never
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.restart
     end
 
     it "should restart the service with rc-service restart if hasrestart is true" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasrestart => true))
-      provider.expects(:execute).with(['/etc/rc.d/sshd', '-f', :restart], :failonfail => true, :override_locale => false, :squelch => true)
+      provider.expects(:execute).with(['/etc/rc.d/sshd', '-f', :restart], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.expects(:search).with('sshd').returns('/etc/rc.d/sshd')
       provider.restart
     end
 
     it "should restart the service with rc-service stop/start if hasrestart is false" do
       provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :hasrestart => false))
-      provider.expects(:execute).with(['/etc/rc.d/sshd', '-f', :restart], :failonfail => true, :override_locale => false, :squelch => true).never
-      provider.expects(:execute).with(['/etc/rc.d/sshd', :stop], :failonfail => true, :override_locale => false, :squelch => true)
-      provider.expects(:execute).with(['/etc/rc.d/sshd', '-f', :start], :failonfail => true, :override_locale => false, :squelch => true)
+      provider.expects(:execute).with(['/etc/rc.d/sshd', '-f', :restart], :failonfail => true, :override_locale => false, :squelch => false, :combine => true).never
+      provider.expects(:execute).with(['/etc/rc.d/sshd', :stop], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:execute).with(['/etc/rc.d/sshd', '-f', :start], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.expects(:search).with('sshd').returns('/etc/rc.d/sshd')
       provider.restart
     end