puppet 6.0.10-universal-darwin → 6.1.0-universal-darwin

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

@@ -1,3 +1,8 @@
+#! /usr/bin/env ruby
+#
+# Unit testing for the Init service Provider
+#
+
 require 'spec_helper'
 
 describe 'Puppet::Type::Service::Provider::Init', unless: Puppet::Util::Platform.jruby? do
@@ -40,12 +45,12 @@ describe 'Puppet::Type::Service::Provider::Init', unless: Puppet::Util::Platform
 
   describe "when getting all service instances" do
     before :each do
-      allow(provider_class).to receive(:defpath).and_return('tmp')
+      provider_class.stubs(:defpath).returns('tmp')
 
       @services = ['one', 'two', 'three', 'four', 'umountfs']
-      allow(Dir).to receive(:entries).with('tmp').and_return(@services)
-      expect(FileTest).to receive(:directory?).with('tmp').and_return(true)
-      allow(FileTest).to receive(:executable?).and_return(true)
+      Dir.stubs(:entries).with('tmp').returns @services
+      FileTest.expects(:directory?).with('tmp').returns(true)
+      FileTest.stubs(:executable?).returns(true)
     end
 
     it "should return instances for all services" do
@@ -63,7 +68,7 @@ describe 'Puppet::Type::Service::Provider::Init', unless: Puppet::Util::Platform
     end
 
     it "should omit Yocto services on cisco-wrlinux" do
-      allow(Facter).to receive(:value).with(:osfamily).and_return('cisco-wrlinux')
+      Facter.stubs(:value).with(:osfamily).returns 'cisco-wrlinux'
       exclude = 'umountfs'
       expect(provider_class.get_services(provider_class.defpath).map(&:name)).to eq(@services - [exclude])
     end
@@ -83,33 +88,33 @@ describe 'Puppet::Type::Service::Provider::Init', unless: Puppet::Util::Platform
     it "should discard upstart jobs", :if => Puppet.features.manages_symlinks? do
       not_init_service, *valid_services = @services
       path = "tmp/#{not_init_service}"
-      allow(Puppet::FileSystem).to receive(:symlink?).at_least(:once).and_return(false)
-      allow(Puppet::FileSystem).to receive(:symlink?).with(Puppet::FileSystem.pathname(path)).and_return(true)
-      allow(Puppet::FileSystem).to receive(:readlink).with(Puppet::FileSystem.pathname(path)).and_return("/lib/init/upstart-job")
+      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")
       expect(provider_class.instances.map(&:name)).to eq(valid_services)
     end
 
     it "should discard non-initscript scripts" do
       valid_services = @services
       all_services = valid_services + excludes
-      expect(Dir).to receive(:entries).with('tmp').and_return(all_services)
+      Dir.expects(:entries).with('tmp').returns all_services
       expect(provider_class.instances.map(&:name)).to match_array(valid_services)
     end
   end
 
   describe "when checking valid paths" do
     it "should discard paths that do not exist" do
-      expect(File).to receive(:directory?).with(paths[0]).and_return(false)
-      expect(Puppet::FileSystem).to receive(:exist?).with(paths[0]).and_return(false)
-      expect(File).to receive(:directory?).with(paths[1]).and_return(true)
+      File.expects(:directory?).with(paths[0]).returns false
+      Puppet::FileSystem.expects(:exist?).with(paths[0]).returns false
+      File.expects(:directory?).with(paths[1]).returns true
 
       expect(provider.paths).to eq([paths[1]])
     end
 
     it "should discard paths that are not directories" do
       paths.each do |path|
-        expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
-        expect(File).to receive(:directory?).with(path).and_return(false)
+        Puppet::FileSystem.expects(:exist?).with(path).returns true
+        File.expects(:directory?).with(path).returns false
       end
       expect(provider.paths).to be_empty
     end
@@ -117,32 +122,32 @@ describe 'Puppet::Type::Service::Provider::Init', unless: Puppet::Util::Platform
 
   describe "when searching for the init script" do
     before :each do
-      paths.each {|path| expect(File).to receive(:directory?).with(path).and_return(true) }
+      paths.each {|path| File.expects(:directory?).with(path).returns true }
     end
 
     it "should be able to find the init script in the service path" do
-      expect(Puppet::FileSystem).to receive(:exist?).with("#{paths[0]}/myservice").and_return(true)
-      expect(Puppet::FileSystem).not_to receive(:exist?).with("#{paths[1]}/myservice") # 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
       expect(provider.initscript).to eq("/service/path/myservice")
     end
 
     it "should be able to find the init script in an alternate service path" do
-      expect(Puppet::FileSystem).to receive(:exist?).with("#{paths[0]}/myservice").and_return(false)
-      expect(Puppet::FileSystem).to receive(:exist?).with("#{paths[1]}/myservice").and_return(true)
+      Puppet::FileSystem.expects(:exist?).with("#{paths[0]}/myservice").returns false
+      Puppet::FileSystem.expects(:exist?).with("#{paths[1]}/myservice").returns true
       expect(provider.initscript).to eq("/alt/service/path/myservice")
     end
 
     it "should be able to find the init script if it ends with .sh" do
-      expect(Puppet::FileSystem).to receive(:exist?).with("#{paths[0]}/myservice").and_return(false)
-      expect(Puppet::FileSystem).to receive(:exist?).with("#{paths[1]}/myservice").and_return(false)
-      expect(Puppet::FileSystem).to receive(:exist?).with("#{paths[0]}/myservice.sh").and_return(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
       expect(provider.initscript).to eq("/service/path/myservice.sh")
     end
 
     it "should fail if the service isn't there" do
       paths.each do |path|
-        expect(Puppet::FileSystem).to receive(:exist?).with("#{path}/myservice").and_return(false)
-        expect(Puppet::FileSystem).to receive(:exist?).with("#{path}/myservice.sh").and_return(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
@@ -150,24 +155,23 @@ describe 'Puppet::Type::Service::Provider::Init', unless: Puppet::Util::Platform
 
   describe "if the init script is present" do
     before :each do
-      allow(File).to receive(:directory?).with("/service/path").and_return(true)
-      allow(File).to receive(:directory?).with("/alt/service/path").and_return(true)
-      allow(Puppet::FileSystem).to receive(:exist?).with("/service/path/myservice").and_return(true)
+      File.stubs(:directory?).with("/service/path").returns true
+      File.stubs(:directory?).with("/alt/service/path").returns true
+      Puppet::FileSystem.stubs(:exist?).with("/service/path/myservice").returns true
     end
 
     [:start, :stop, :status, :restart].each do |method|
       it "should have a #{method} method" do
         expect(provider).to respond_to(method)
       end
-
       describe "when running #{method}" do
         before :each do
-          allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+          $CHILD_STATUS.stubs(:exitstatus).returns(0)
         end
 
         it "should use any provided explicit command" do
           resource[method] = "/user/specified/command"
-          expect(provider).to receive(:execute).with(["/user/specified/command"], any_args)
+          provider.expects(:execute).with { |command, *args| command == ["/user/specified/command"] }
 
           provider.send(method)
         end
@@ -175,7 +179,7 @@ describe 'Puppet::Type::Service::Provider::Init', unless: Puppet::Util::Platform
         it "should pass #{method} to the init script when no explicit command is provided" do
           resource[:hasrestart] = :true
           resource[:hasstatus] = :true
-          expect(provider).to receive(:execute).with(["/service/path/myservice", method], any_args)
+          provider.expects(:execute).with { |command, *args| command ==  ["/service/path/myservice",method]}
 
           provider.send(method)
         end
@@ -187,40 +191,35 @@ describe 'Puppet::Type::Service::Provider::Init', unless: Puppet::Util::Platform
         before :each do
           resource[:hasstatus] = :true
         end
-
         it "should execute the command" do
-          expect(provider).to receive(:texecute).with(:status, ['/service/path/myservice', :status], false).and_return("")
-          allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+          provider.expects(:texecute).with(:status, ['/service/path/myservice', :status], false).returns("")
+          $CHILD_STATUS.stubs(:exitstatus).returns(0)
           provider.status
         end
-
         it "should consider the process running if the command returns 0" do
-          expect(provider).to receive(:texecute).with(:status, ['/service/path/myservice', :status], false).and_return("")
-          allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+          provider.expects(:texecute).with(:status, ['/service/path/myservice', :status], false).returns("")
+          $CHILD_STATUS.stubs(:exitstatus).returns(0)
           expect(provider.status).to eq(:running)
         end
-
         [-10,-1,1,10].each { |ec|
           it "should consider the process stopped if the command returns something non-0" do
-            expect(provider).to receive(:texecute).with(:status, ['/service/path/myservice', :status], false).and_return("")
-            allow($CHILD_STATUS).to receive(:exitstatus).and_return(ec)
+            provider.expects(:texecute).with(:status, ['/service/path/myservice', :status], false).returns("")
+            $CHILD_STATUS.stubs(:exitstatus).returns(ec)
             expect(provider.status).to eq(:stopped)
           end
         }
       end
-
       describe "when hasstatus is not :true" do
         before :each do
           resource[:hasstatus] = :false
         end
 
         it "should consider the service :running if it has a pid" do
-          expect(provider).to receive(:getpid).and_return("1234")
+          provider.expects(:getpid).returns "1234"
           expect(provider.status).to eq(:running)
         end
-
         it "should consider the service :stopped if it doesn't have a pid" do
-          expect(provider).to receive(:getpid).and_return(nil)
+          provider.expects(:getpid).returns nil
           expect(provider.status).to eq(:stopped)
         end
       end
@@ -232,27 +231,27 @@ describe 'Puppet::Type::Service::Provider::Init', unless: Puppet::Util::Platform
       end
 
       it "should stop and restart the process" do
-        expect(provider).to receive(:texecute).with(:stop,  ['/service/path/myservice', :stop ], true).and_return("")
-        expect(provider).to receive(:texecute).with(:start, ['/service/path/myservice', :start], true).and_return("")
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+        provider.expects(:texecute).with(:stop, ['/service/path/myservice', :stop ], true).returns("")
+        provider.expects(:texecute).with(:start,['/service/path/myservice', :start], true).returns("")
+        $CHILD_STATUS.stubs(:exitstatus).returns(0)
         provider.restart
       end
     end
 
     describe "when starting a service on Solaris" do
       it "should use ctrun" do
-        allow(Facter).to receive(:value).with(:osfamily).and_return('Solaris')
-        expect(provider).to receive(:execute).with('/usr/bin/ctrun -l child /service/path/myservice start', {:failonfail => true, :override_locale => false, :squelch => false, :combine => true}).and_return("")
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+        Facter.stubs(:value).with(:osfamily).returns 'Solaris'
+        provider.expects(:execute).with('/usr/bin/ctrun -l child /service/path/myservice start', {:failonfail => true, :override_locale => false, :squelch => false, :combine => true}).returns("")
+        $CHILD_STATUS.stubs(:exitstatus).returns(0)
         provider.start
       end
     end
 
     describe "when starting a service on RedHat" do
       it "should not use ctrun" do
-        allow(Facter).to receive(:value).with(:osfamily).and_return('RedHat')
-        expect(provider).to receive(:execute).with(['/service/path/myservice', :start], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true}).and_return("")
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+        Facter.stubs(:value).with(:osfamily).returns 'RedHat'
+        provider.expects(:execute).with(['/service/path/myservice', :start], {:failonfail => true, :override_locale => false, :squelch => false, :combine => true}).returns("")
+        $CHILD_STATUS.stubs(:exitstatus).returns(0)
         provider.start
       end
     end

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

@@ -1,3 +1,6 @@
+# Spec Tests for the Launchd provider
+#
+
 require 'spec_helper'
 
 describe 'Puppet::Type::Service::Provider::Launchd', unless: Puppet::Util::Platform.jruby? do
@@ -25,23 +28,20 @@ describe 'Puppet::Type::Service::Provider::Launchd', unless: Puppet::Util::Platf
 
   describe 'the status of the services' do
     it "should call the external command 'launchctl list' once" do
-      expect(provider).to receive(:launchctl).with(:list).and_return(joblabel)
-      expect(provider).to receive(:jobsearch).and_return({joblabel => "/Library/LaunchDaemons/#{joblabel}"})
+      provider.expects(:launchctl).with(:list).returns(joblabel)
+      provider.expects(:jobsearch).with(nil).returns({joblabel => "/Library/LaunchDaemons/#{joblabel}"})
       provider.prefetch({})
     end
-
     it "should return stopped if not listed in launchctl list output" do
-      expect(provider).to receive(:launchctl).with(:list).and_return('com.bar.is_running')
-      expect(provider).to receive(:jobsearch).and_return({'com.bar.is_not_running' => "/Library/LaunchDaemons/com.bar.is_not_running"})
-      expect(provider.prefetch({}).last.status).to eq(:stopped)
+      provider.expects(:launchctl).with(:list).returns('com.bar.is_running')
+      provider.expects(:jobsearch).with(nil).returns({'com.bar.is_not_running' => "/Library/LaunchDaemons/com.bar.is_not_running"})
+      expect(provider.prefetch({}).last.status).to eq :stopped
     end
-
     it "should return running if listed in launchctl list output" do
-      expect(provider).to receive(:launchctl).with(:list).and_return('com.bar.is_running')
-      expect(provider).to receive(:jobsearch).and_return({'com.bar.is_running' => "/Library/LaunchDaemons/com.bar.is_running"})
-      expect(provider.prefetch({}).last.status).to eq(:running)
+      provider.expects(:launchctl).with(:list).returns('com.bar.is_running')
+      provider.expects(:jobsearch).with(nil).returns({'com.bar.is_running' => "/Library/LaunchDaemons/com.bar.is_running"})
+      expect(provider.prefetch({}).last.status).to eq :running
     end
-
     after :each do
       provider.instance_variable_set(:@job_list, nil)
     end
@@ -53,20 +53,20 @@ describe 'Puppet::Type::Service::Provider::Launchd', unless: Puppet::Util::Platf
 
       it "should use the user-provided status command if present and return running if true" do
         resource[:status] = '/bin/true'
-        expect(subject).to receive(:texecute).with(:status, ["/bin/true"], false).and_return(0)
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+        subject.expects(:texecute).with(:status, ["/bin/true"], false).returns(0)
+        $CHILD_STATUS.stubs(:exitstatus).returns(0)
         expect(subject.status).to eq(:running)
       end
 
       it "should use the user-provided status command if present and return stopped if false" do
         resource[:status] = '/bin/false'
-        expect(subject).to receive(:texecute).with(:status, ["/bin/false"], false).and_return(nil)
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(1)
+        subject.expects(:texecute).with(:status, ["/bin/false"], false).returns(nil)
+        $CHILD_STATUS.stubs(:exitstatus).returns(1)
         expect(subject.status).to eq(:stopped)
       end
 
       it "should fall back to getpid if no status command is provided" do
-        expect(subject).to receive(:getpid).and_return(123)
+        subject.expects(:getpid).returns(123)
         expect(subject.status).to eq(:running)
       end
     end
@@ -75,26 +75,24 @@ describe 'Puppet::Type::Service::Provider::Launchd', unless: Puppet::Util::Platf
   [[10, '10.6'], [13, '10.9']].each do |kernel, version|
     describe "when checking whether the service is enabled on OS X #{version}" do
       it "should return true if the job plist says disabled is true and the global overrides says disabled is false" do
-        expect(provider).to receive(:get_os_version).and_return(kernel).at_least(:once)
-        expect(subject).to receive(:plist_from_label).and_return([joblabel, {"Disabled" => true}])
-        expect(plistlib).to receive(:read_plist_file).with(launchd_overrides_6_9).and_return({joblabel => {"Disabled" => false}})
-        expect(FileTest).to receive(:file?).with(launchd_overrides_6_9).and_return(true)
+        provider.expects(:get_os_version).returns(kernel).at_least_once
+        subject.expects(:plist_from_label).returns([joblabel, {"Disabled" => true}])
+        plistlib.expects(:read_plist_file).with(launchd_overrides_6_9).returns({joblabel => {"Disabled" => false}})
+        FileTest.expects(:file?).with(launchd_overrides_6_9).returns(true)
         expect(subject.enabled?).to eq(:true)
       end
-
       it "should return false if the job plist says disabled is false and the global overrides says disabled is true" do
-        expect(provider).to receive(:get_os_version).and_return(kernel).at_least(:once)
-        expect(subject).to receive(:plist_from_label).and_return([joblabel, {"Disabled" => false}])
-        expect(plistlib).to receive(:read_plist_file).with(launchd_overrides_6_9).and_return({joblabel => {"Disabled" => true}})
-        expect(FileTest).to receive(:file?).with(launchd_overrides_6_9).and_return(true)
+        provider.expects(:get_os_version).returns(kernel).at_least_once
+        subject.expects(:plist_from_label).returns([joblabel, {"Disabled" => false}])
+        plistlib.expects(:read_plist_file).with(launchd_overrides_6_9).returns({joblabel => {"Disabled" => true}})
+        FileTest.expects(:file?).with(launchd_overrides_6_9).returns(true)
         expect(subject.enabled?).to eq(:false)
       end
-
       it "should return true if the job plist and the global overrides have no disabled keys" do
-        expect(provider).to receive(:get_os_version).and_return(kernel).at_least(:once)
-        expect(subject).to receive(:plist_from_label).and_return([joblabel, {}])
-        expect(plistlib).to receive(:read_plist_file).with(launchd_overrides_6_9).and_return({})
-        expect(FileTest).to receive(:file?).with(launchd_overrides_6_9).and_return(true)
+        provider.expects(:get_os_version).returns(kernel).at_least_once
+        subject.expects(:plist_from_label).returns([joblabel, {}])
+        plistlib.expects(:read_plist_file).with(launchd_overrides_6_9).returns({})
+        FileTest.expects(:file?).with(launchd_overrides_6_9).returns(true)
         expect(subject.enabled?).to eq(:true)
       end
     end
@@ -102,26 +100,24 @@ describe 'Puppet::Type::Service::Provider::Launchd', unless: Puppet::Util::Platf
 
   describe "when checking whether the service is enabled on OS X 10.10" do
     it "should return true if the job plist says disabled is true and the global overrides says disabled is false" do
-      expect(provider).to receive(:get_os_version).and_return(14).at_least(:once)
-      expect(subject).to receive(:plist_from_label).and_return([joblabel, {"Disabled" => true}])
-      expect(plistlib).to receive(:read_plist_file).with(launchd_overrides_10_).and_return({joblabel => false})
-      expect(FileTest).to receive(:file?).with(launchd_overrides_10_).and_return(true)
+      provider.expects(:get_os_version).returns(14).at_least_once
+      subject.expects(:plist_from_label).returns([joblabel, {"Disabled" => true}])
+      plistlib.expects(:read_plist_file).with(launchd_overrides_10_).returns({joblabel => false})
+      FileTest.expects(:file?).with(launchd_overrides_10_).returns(true)
       expect(subject.enabled?).to eq(:true)
     end
-
     it "should return false if the job plist says disabled is false and the global overrides says disabled is true" do
-      expect(provider).to receive(:get_os_version).and_return(14).at_least(:once)
-      expect(subject).to receive(:plist_from_label).and_return([joblabel, {"Disabled" => false}])
-      expect(plistlib).to receive(:read_plist_file).with(launchd_overrides_10_).and_return({joblabel => true})
-      expect(FileTest).to receive(:file?).with(launchd_overrides_10_).and_return(true)
+      provider.expects(:get_os_version).returns(14).at_least_once
+      subject.expects(:plist_from_label).returns([joblabel, {"Disabled" => false}])
+      plistlib.expects(:read_plist_file).with(launchd_overrides_10_).returns({joblabel => true})
+      FileTest.expects(:file?).with(launchd_overrides_10_).returns(true)
       expect(subject.enabled?).to eq(:false)
     end
-
     it "should return true if the job plist and the global overrides have no disabled keys" do
-      expect(provider).to receive(:get_os_version).and_return(14).at_least(:once)
-      expect(subject).to receive(:plist_from_label).and_return([joblabel, {}])
-      expect(plistlib).to receive(:read_plist_file).with(launchd_overrides_10_).and_return({})
-      expect(FileTest).to receive(:file?).with(launchd_overrides_10_).and_return(true)
+      provider.expects(:get_os_version).returns(14).at_least_once
+      subject.expects(:plist_from_label).returns([joblabel, {}])
+      plistlib.expects(:read_plist_file).with(launchd_overrides_10_).returns({})
+      FileTest.expects(:file?).with(launchd_overrides_10_).returns(true)
       expect(subject.enabled?).to eq(:true)
     end
   end
@@ -129,51 +125,47 @@ describe 'Puppet::Type::Service::Provider::Launchd', unless: Puppet::Util::Platf
   describe "when starting the service" do
     it "should call any explicit 'start' command" do
       resource[:start] = "/bin/false"
-      expect(subject).to receive(:texecute).with(:start, ["/bin/false"], true)
+      subject.expects(:texecute).with(:start, ["/bin/false"], true)
       subject.start
     end
 
     it "should look for the relevant plist once" do
-      expect(subject).to receive(:plist_from_label).and_return([joblabel, {}]).once
-      expect(subject).to receive(:enabled?).and_return(:true)
-      expect(subject).to receive(:execute).with([:launchctl, :load, "-w", joblabel])
+      subject.expects(:plist_from_label).returns([joblabel, {}]).once
+      subject.expects(:enabled?).returns :true
+      subject.expects(:execute).with([:launchctl, :load, "-w", joblabel])
       subject.start
     end
-
     it "should execute 'launchctl load' once without writing to the plist if the job is enabled" do
-      expect(subject).to receive(:plist_from_label).and_return([joblabel, {}])
-      expect(subject).to receive(:enabled?).and_return(:true)
-      expect(subject).to receive(:execute).with([:launchctl, :load, "-w", joblabel]).once
+      subject.expects(:plist_from_label).returns([joblabel, {}])
+      subject.expects(:enabled?).returns :true
+      subject.expects(:execute).with([:launchctl, :load, "-w", joblabel]).once
       subject.start
     end
-
     it "should execute 'launchctl load' with writing to the plist once if the job is disabled" do
-      expect(subject).to receive(:plist_from_label).and_return([joblabel, {}])
-      expect(subject).to receive(:enabled?).and_return(:false)
-      expect(subject).to receive(:execute).with([:launchctl, :load, "-w", joblabel]).once
+      subject.expects(:plist_from_label).returns([joblabel, {}])
+      subject.expects(:enabled?).returns(:false)
+      subject.expects(:execute).with([:launchctl, :load, "-w", joblabel]).once
       subject.start
     end
-
     it "should disable the job once if the job is disabled and should be disabled at boot" do
       resource[:enable] = false
-      expect(subject).to receive(:plist_from_label).and_return([joblabel, {"Disabled" => true}])
-      expect(subject).to receive(:enabled?).and_return(:false)
-      expect(subject).to receive(:execute).with([:launchctl, :load, "-w", joblabel])
-      expect(subject).to receive(:disable).once
+      subject.expects(:plist_from_label).returns([joblabel, {"Disabled" => true}])
+      subject.expects(:enabled?).returns :false
+      subject.expects(:execute).with([:launchctl, :load, "-w", joblabel])
+      subject.expects(:disable).once
       subject.start
     end
-
     it "(#2773) should execute 'launchctl load -w' if the job is enabled but stopped" do
-      expect(subject).to receive(:plist_from_label).and_return([joblabel, {}])
-      expect(subject).to receive(:enabled?).and_return(:true)
-      expect(subject).to receive(:status).and_return(:stopped)
-      expect(subject).to receive(:execute).with([:launchctl, :load, '-w', joblabel])
+      subject.expects(:plist_from_label).returns([joblabel, {}])
+      subject.expects(:enabled?).returns(:true)
+      subject.expects(:status).returns(:stopped)
+      subject.expects(:execute).with([:launchctl, :load, '-w', joblabel])
       subject.start
     end
 
     it "(#16271) Should stop and start the service when a restart is called" do
-      expect(subject).to receive(:stop)
-      expect(subject).to receive(:start)
+      subject.expects(:stop)
+      subject.expects(:start)
       subject.restart
     end
   end
@@ -181,37 +173,34 @@ describe 'Puppet::Type::Service::Provider::Launchd', unless: Puppet::Util::Platf
   describe "when stopping the service" do
     it "should call any explicit 'stop' command" do
       resource[:stop] = "/bin/false"
-      expect(subject).to receive(:texecute).with(:stop, ["/bin/false"], true)
+      subject.expects(:texecute).with(:stop, ["/bin/false"], true)
       subject.stop
     end
 
     it "should look for the relevant plist once" do
-      expect(subject).to receive(:plist_from_label).and_return([joblabel, {}]).once
-      expect(subject).to receive(:enabled?).and_return(:true)
-      expect(subject).to receive(:execute).with([:launchctl, :unload, '-w', joblabel])
+      subject.expects(:plist_from_label).returns([joblabel, {}]).once
+      subject.expects(:enabled?).returns :true
+      subject.expects(:execute).with([:launchctl, :unload, '-w', joblabel])
       subject.stop
     end
-
     it "should execute 'launchctl unload' once without writing to the plist if the job is disabled" do
-      expect(subject).to receive(:plist_from_label).and_return([joblabel, {}])
-      expect(subject).to receive(:enabled?).and_return(:false)
-      expect(subject).to receive(:execute).with([:launchctl, :unload, joblabel]).once
+      subject.expects(:plist_from_label).returns([joblabel, {}])
+      subject.expects(:enabled?).returns :false
+      subject.expects(:execute).with([:launchctl, :unload, joblabel]).once
       subject.stop
     end
-
     it "should execute 'launchctl unload' with writing to the plist once if the job is enabled" do
-      expect(subject).to receive(:plist_from_label).and_return([joblabel, {}])
-      expect(subject).to receive(:enabled?).and_return(:true)
-      expect(subject).to receive(:execute).with([:launchctl, :unload, '-w', joblabel]).once
+      subject.expects(:plist_from_label).returns([joblabel, {}])
+      subject.expects(:enabled?).returns :true
+      subject.expects(:execute).with([:launchctl, :unload, '-w', joblabel]).once
       subject.stop
     end
-
     it "should enable the job once if the job is enabled and should be enabled at boot" do
       resource[:enable] = true
-      expect(subject).to receive(:plist_from_label).and_return([joblabel, {"Disabled" => false}])
-      expect(subject).to receive(:enabled?).and_return(:true)
-      expect(subject).to receive(:execute).with([:launchctl, :unload, "-w", joblabel])
-      expect(subject).to receive(:enable).once
+      subject.expects(:plist_from_label).returns([joblabel, {"Disabled" => false}])
+      subject.expects(:enabled?).returns :true
+      subject.expects(:execute).with([:launchctl, :unload, "-w", joblabel])
+      subject.expects(:enable).once
       subject.stop
     end
   end
@@ -219,17 +208,16 @@ describe 'Puppet::Type::Service::Provider::Launchd', unless: Puppet::Util::Platf
   describe "when enabling the service" do
     it "should look for the relevant plist once" do   ### Do we need this test?  Differentiating it?
       resource[:enable] = true
-      expect(subject).to receive(:plist_from_label).and_return([joblabel, {}]).once
-      expect(subject).to receive(:enabled?).and_return(:false)
-      expect(subject).to receive(:execute).with([:launchctl, :unload, joblabel])
+      subject.expects(:plist_from_label).returns([joblabel, {}]).once
+      subject.expects(:enabled?).returns :false
+      subject.expects(:execute).with([:launchctl, :unload, joblabel])
       subject.stop
     end
-
     it "should check if the job is enabled once" do
       resource[:enable] = true
-      expect(subject).to receive(:plist_from_label).and_return([joblabel, {}]).once
-      expect(subject).to receive(:enabled?).once
-      expect(subject).to receive(:execute).with([:launchctl, :unload, joblabel])
+      subject.expects(:plist_from_label).returns([joblabel, {}]).once
+      subject.expects(:enabled?).once
+      subject.expects(:execute).with([:launchctl, :unload, joblabel])
       subject.stop
     end
   end
@@ -237,9 +225,9 @@ describe 'Puppet::Type::Service::Provider::Launchd', unless: Puppet::Util::Platf
   describe "when disabling the service" do
     it "should look for the relevant plist once" do
       resource[:enable] = false
-      expect(subject).to receive(:plist_from_label).and_return([joblabel, {}]).once
-      expect(subject).to receive(:enabled?).and_return(:true)
-      expect(subject).to receive(:execute).with([:launchctl, :unload, '-w', joblabel])
+      subject.expects(:plist_from_label).returns([joblabel, {}]).once
+      subject.expects(:enabled?).returns :true
+      subject.expects(:execute).with([:launchctl, :unload, '-w', joblabel])
       subject.stop
     end
   end
@@ -248,9 +236,9 @@ describe 'Puppet::Type::Service::Provider::Launchd', unless: Puppet::Util::Platf
     describe "when enabling the service on OS X #{version}" do
       it "should write to the global launchd overrides file once" do
         resource[:enable] = true
-        expect(provider).to receive(:get_os_version).and_return(kernel).at_least(:once)
-        expect(plistlib).to receive(:read_plist_file).with(launchd_overrides_6_9).and_return({})
-        expect(plistlib).to receive(:write_plist_file).with(hash_including(resource[:name] => {'Disabled' => false}), launchd_overrides_6_9).once
+        provider.expects(:get_os_version).returns(kernel).at_least_once
+        plistlib.expects(:read_plist_file).with(launchd_overrides_6_9).returns({})
+        plistlib.expects(:write_plist_file).with(has_entry(resource[:name], {'Disabled' => false}), launchd_overrides_6_9).once
         subject.enable
       end
     end
@@ -258,9 +246,9 @@ describe 'Puppet::Type::Service::Provider::Launchd', unless: Puppet::Util::Platf
     describe "when disabling the service on OS X #{version}" do
       it "should write to the global launchd overrides file once" do
         resource[:enable] = false
-        expect(provider).to receive(:get_os_version).and_return(kernel).at_least(:once)
-        expect(plistlib).to receive(:read_plist_file).with(launchd_overrides_6_9).and_return({})
-        expect(plistlib).to receive(:write_plist_file).with(hash_including(resource[:name] => {'Disabled' => true}), launchd_overrides_6_9).once
+        provider.expects(:get_os_version).returns(kernel).at_least_once
+        plistlib.expects(:read_plist_file).with(launchd_overrides_6_9).returns({})
+        plistlib.expects(:write_plist_file).with(has_entry(resource[:name], {'Disabled' => true}), launchd_overrides_6_9).once
         subject.disable
       end
     end
@@ -269,9 +257,9 @@ describe 'Puppet::Type::Service::Provider::Launchd', unless: Puppet::Util::Platf
   describe "when enabling the service on OS X 10.10" do
     it "should write to the global launchd overrides file once" do
       resource[:enable] = true
-      expect(provider).to receive(:get_os_version).and_return(14).at_least(:once)
-      expect(plistlib).to receive(:read_plist_file).with(launchd_overrides_10_).and_return({})
-      expect(plistlib).to receive(:write_plist_file).with(hash_including(resource[:name] => false), launchd_overrides_10_).once
+      provider.expects(:get_os_version).returns(14).at_least_once
+      plistlib.expects(:read_plist_file).with(launchd_overrides_10_).returns({})
+      plistlib.expects(:write_plist_file).with(has_entry(resource[:name], false), launchd_overrides_10_).once
       subject.enable
     end
   end
@@ -279,9 +267,9 @@ describe 'Puppet::Type::Service::Provider::Launchd', unless: Puppet::Util::Platf
   describe "when disabling the service on OS X 10.10" do
     it "should write to the global launchd overrides file once" do
       resource[:enable] = false
-      expect(provider).to receive(:get_os_version).and_return(14).at_least(:once)
-      expect(plistlib).to receive(:read_plist_file).with(launchd_overrides_10_).and_return({})
-      expect(plistlib).to receive(:write_plist_file).with(hash_including(resource[:name] => true), launchd_overrides_10_).once
+      provider.expects(:get_os_version).returns(14).at_least_once
+      plistlib.expects(:read_plist_file).with(launchd_overrides_10_).returns({})
+      plistlib.expects(:write_plist_file).with(has_entry(resource[:name], true), launchd_overrides_10_).once
       subject.disable
     end
   end
@@ -293,7 +281,6 @@ describe 'Puppet::Type::Service::Provider::Launchd', unless: Puppet::Util::Platf
         provider.send(:remove_instance_variable, :@label_to_path_map)
       end
     end
-
     describe "when encountering malformed plists" do
       let(:plist_without_label) do
         {
@@ -304,36 +291,31 @@ describe 'Puppet::Type::Service::Provider::Launchd', unless: Puppet::Util::Platf
       let(:binary_plist_path) { '/Library/LaunchAgents/org.binary.plist' }
 
       it "[17624] should warn that the plist in question is being skipped" do
-        expect(provider).to receive(:launchd_paths).and_return(['/Library/LaunchAgents'])
-        expect(provider).to receive(:return_globbed_list_of_file_paths).with('/Library/LaunchAgents').and_return([busted_plist_path])
-        expect(plistlib).to receive(:read_plist_file).with(busted_plist_path).and_return(plist_without_label)
-        expect(Puppet).to receive(:debug).with("Reading launchd plist #{busted_plist_path}")
-        expect(Puppet).to receive(:debug).with("The #{busted_plist_path} plist does not contain a 'label' key; Puppet is skipping it")
+        provider.expects(:launchd_paths).returns(['/Library/LaunchAgents'])
+        provider.expects(:return_globbed_list_of_file_paths).with('/Library/LaunchAgents').returns([busted_plist_path])
+        plistlib.expects(:read_plist_file).with(busted_plist_path).returns(plist_without_label)
+        Puppet.expects(:debug).with("Reading launchd plist #{busted_plist_path}")
+        Puppet.expects(:debug).with("The #{busted_plist_path} plist does not contain a 'label' key; Puppet is skipping it")
         provider.make_label_to_path_map
       end
     end
-
     it "should return the cached value when available" do
       provider.instance_variable_set(:@label_to_path_map, {'xx'=>'yy'})
       expect(provider.make_label_to_path_map).to eq({'xx'=>'yy'})
     end
-
     describe "when successful" do
       let(:launchd_dir) { '/Library/LaunchAgents' }
       let(:plist) { launchd_dir + '/foo.bar.service.plist' }
       let(:label) { 'foo.bar.service' }
-
       before do
         provider.instance_variable_set(:@label_to_path_map, nil)
-        expect(provider).to receive(:launchd_paths).and_return([launchd_dir])
-        expect(provider).to receive(:return_globbed_list_of_file_paths).with(launchd_dir).and_return([plist])
-        expect(plistlib).to receive(:read_plist_file).with(plist).and_return({'Label'=>'foo.bar.service'})
+        provider.expects(:launchd_paths).returns([launchd_dir])
+        provider.expects(:return_globbed_list_of_file_paths).with(launchd_dir).returns([plist])
+        plistlib.expects(:read_plist_file).with(plist).returns({'Label'=>'foo.bar.service'})
       end
-
       it "should read the plists and return their contents" do
         expect(provider.make_label_to_path_map).to eq({label=>plist})
       end
-
       it "should re-read the plists and return their contents when refreshed" do
         provider.instance_variable_set(:@label_to_path_map, {'xx'=>'yy'})
         expect(provider.make_label_to_path_map(true)).to eq({label=>plist})
@@ -344,46 +326,42 @@ describe 'Puppet::Type::Service::Provider::Launchd', unless: Puppet::Util::Platf
   describe "jobsearch" do
     let(:map) { {"org.mozilla.puppet" => "/path/to/puppet.plist",
                  "org.mozilla.python" => "/path/to/python.plist"} }
-
-                 it "returns the entire map with no args" do
-      expect(provider).to receive(:make_label_to_path_map).and_return(map)
+    it "returns the entire map with no args" do
+      provider.expects(:make_label_to_path_map).returns(map)
       expect(provider.jobsearch).to eq(map)
     end
-
     it "returns a singleton hash when given a label" do
-      expect(provider).to receive(:make_label_to_path_map).and_return(map)
+      provider.expects(:make_label_to_path_map).returns(map)
       expect(provider.jobsearch("org.mozilla.puppet")).to eq({ "org.mozilla.puppet" => "/path/to/puppet.plist" })
     end
-
     it "refreshes the label_to_path_map when label is not found" do
-      expect(provider).to receive(:make_label_to_path_map).and_return(map)
+      provider.expects(:make_label_to_path_map).with().returns({})
+      provider.expects(:make_label_to_path_map).with(true).returns(map)
       expect(provider.jobsearch("org.mozilla.puppet")).to eq({ "org.mozilla.puppet" => "/path/to/puppet.plist" })
     end
-
     it "raises Puppet::Error when the label is still not found" do
-      allow(provider).to receive(:make_label_to_path_map).and_return(map)
+      provider.expects(:make_label_to_path_map).with().returns(map)
+      provider.expects(:make_label_to_path_map).with(true).returns(map)
       expect { provider.jobsearch("NOSUCH") }.to raise_error(Puppet::Error)
     end
   end
 
   describe "read_overrides" do
     before do
-      allow(Kernel).to receive(:sleep)
+      Kernel.stubs(:sleep)
     end
-
     it "should read overrides" do
-      expect(provider).to receive(:read_plist).once.and_return({})
+      provider.expects(:read_plist).once.returns({})
       expect(provider.read_overrides).to eq({})
     end
-
     it "should retry if read_plist fails" do
-      allow(provider).to receive(:read_plist).and_return({}, nil)
+      provider.expects(:read_plist).once.returns({})
+      provider.expects(:read_plist).once.returns(nil)
       expect(provider.read_overrides).to eq({})
     end
-
     it "raises Puppet::Error after 20 attempts" do
-      expect(provider).to receive(:read_plist).exactly(20).times().and_return(nil)
+      provider.expects(:read_plist).times(20).returns(nil)
       expect { provider.read_overrides }.to raise_error(Puppet::Error)
     end
-  end
+ end
 end