puppet 6.27.0 → 7.0.0

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

@@ -191,27 +191,6 @@ OUTPUT
           expect(versions[version]).to eq(:rpm)
         end
       end
-
-      it "should be able to parse RPM package listings with letters in version" do
-        showres_output = <<END
-cairo                                                              ALL  @@R:cairo _all_filesets
-   @@R:cairo-1.14.6-2waixX11 1.14.6-2waixX11
-END
-        packages = subject.send(:parse_showres_output, showres_output)
-        expect(Set.new(packages.keys)).to eq(Set.new(['cairo']))
-        versions = packages['cairo']
-        expect(versions.has_key?('1.14.6-2waixX11')).to eq(true)
-        expect(versions['1.14.6-2waixX11']).to eq(:rpm)
-      end
-
-      it "should raise error when parsing invalid RPM package listings" do
-              showres_output = <<END
-cairo                                                              ALL  @@R:cairo _all_filesets
-   @@R:cairo-invalid_version invalid_version
-END
-        expect{ subject.send(:parse_showres_output, showres_output) }.to raise_error(Puppet::Error,
-          /Unable to parse output from nimclient showres: package string does not match expected rpm package string format/)
-      end
     end
 
     context "#determine_latest_version" do
@@ -241,27 +220,6 @@ END
       it "should return :installp for installp/bff packages" do
         expect(subject.send(:determine_package_type, bff_showres_output, 'mypackage.foo', '1.2.3.4')).to eq(:installp)
       end
-
-      it "should return :installp for security updates" do
-        nimclient_showres_output = <<END
-bos.net                                                            ALL  @@S:bos.net _all_filesets
- + 7.2.0.1  TCP/IP ntp Applications                                     @@S:bos.net.tcp.ntp 7.2.0.1
- + 7.2.0.2  TCP/IP ntp Applications                                     @@S:bos.net.tcp.ntp 7.2.0.2
-
-END
-        expect(subject.send(:determine_package_type, nimclient_showres_output, 'bos.net.tcp.ntp', '7.2.0.2')).to eq(:installp)
-      end
-
-      it "should raise error when invalid header format is given" do
-        nimclient_showres_output = <<END
-bos.net                                                            ALL  @@INVALID_TYPE:bos.net _all_filesets
- + 7.2.0.1  TCP/IP ntp Applications                                     @@INVALID_TYPE:bos.net.tcp.ntp 7.2.0.1
- + 7.2.0.2  TCP/IP ntp Applications                                     @@INVALID_TYPE:bos.net.tcp.ntp 7.2.0.2
-
-END
-        expect{ subject.send(:determine_package_type, nimclient_showres_output, 'bos.net.tcp.ntp', '7.2.0.2') }.to raise_error(
-          Puppet::Error, /Unable to parse output from nimclient showres: line does not match expected package header format/)
-      end
     end
   end
 end

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

@@ -32,12 +32,10 @@ describe Puppet::Type.type(:package).provider(:pacman) do
     end
 
     it "should call yaourt to install the right package quietly when yaourt is installed" do
-      without_partial_double_verification do
-        allow(described_class).to receive(:yaourt?).and_return(true)
-        args = ['--noconfirm', '--needed', '--noprogressbar', '-S', resource[:name]]
-        expect(provider).to receive(:yaourt).at_least(:once).with(*args).and_return('')
-        provider.install
-      end
+      allow(described_class).to receive(:yaourt?).and_return(true)
+      args = ['--noconfirm', '--needed', '--noprogressbar', '-S', resource[:name]]
+      expect(provider).to receive(:yaourt).at_least(:once).with(*args).and_return('')
+      provider.install
     end
 
     it "should raise an Puppet::Error if the installation failed" do
@@ -76,12 +74,10 @@ describe Puppet::Type.type(:package).provider(:pacman) do
       end
 
       it "should call yaourt to install the right package quietly when yaourt is installed" do
-        without_partial_double_verification do
-          expect(described_class).to receive(:yaourt?).and_return(true)
-          args = ['--noconfirm', '--needed', '--noprogressbar', '-x', '--arg=value', '-S', resource[:name]]
-          expect(provider).to receive(:yaourt).at_least(:once).with(*args).and_return('')
-          provider.install
-        end
+        expect(described_class).to receive(:yaourt?).and_return(true)
+        args = ['--noconfirm', '--needed', '--noprogressbar', '-x', '--arg=value', '-S', resource[:name]]
+        expect(provider).to receive(:yaourt).at_least(:once).with(*args).and_return('')
+        provider.install
       end
     end
 
@@ -176,12 +172,10 @@ describe Puppet::Type.type(:package).provider(:pacman) do
     end
 
     it "should call yaourt to remove the right package quietly" do
-      without_partial_double_verification do
-        allow(described_class).to receive(:yaourt?).and_return(true)
-        args = ["--noconfirm", "--noprogressbar", "-R", resource[:name]]
-        expect(provider).to receive(:yaourt).with(*args)
-        provider.uninstall
-      end
+      allow(described_class).to receive(:yaourt?).and_return(true)
+      args = ["--noconfirm", "--noprogressbar", "-R", resource[:name]]
+      expect(provider).to receive(:yaourt).with(*args)
+      provider.uninstall
     end
 
     it "adds any uninstall_options" do

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

@@ -24,7 +24,7 @@ describe Puppet::Type.type(:package).provider(:pip2) do
     end
 
     context 'when is defaultfor' do
-      let(:os) {  Puppet.runtime[:facter].value(:operatingsystem) }
+      let(:os) {  Facter.value(:operatingsystem) }
       subject do
         described_class.defaultfor(operatingsystem: os)
         described_class.specificity

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

@@ -24,7 +24,7 @@ describe Puppet::Type.type(:package).provider(:pip3) do
     end
 
     context 'when is defaultfor' do
-      let(:os) {  Puppet.runtime[:facter].value(:operatingsystem) }
+      let(:os) {  Facter.value(:operatingsystem) }
       subject do
         described_class.defaultfor(operatingsystem: os)
         described_class.specificity

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

@@ -14,8 +14,9 @@ describe Puppet::Type.type(:package).provider(:pip) do
   it { is_expected.to be_version_ranges }
 
   before do
-    @resource = Puppet::Type.type(:package).new(name: "fake_package", provider: :pip)
-    @provider = @resource.provider
+    @resource = Puppet::Resource.new(:package, "fake_package")
+    allow(@resource).to receive(:original_parameters).and_return({})
+    @provider = described_class.new(@resource)
     @client = double('client')
     allow(@client).to receive(:call).with('package_releases', 'real_package').and_return(["1.3", "1.2.5", "1.2.4"])
     allow(@client).to receive(:call).with('package_releases', 'fake_package').and_return([])
@@ -266,43 +267,6 @@ describe Puppet::Type.type(:package).provider(:pip) do
       let(:pip_version) { '1.5.4' }
       let(:pip_path) { '/fake/bin/pip' }
 
-      context "with pip version >= 20.3 and < 21.1" do
-        let(:pip_version) { '20.3.1' }
-        let(:pip_path) { '/fake/bin/pip' }
-
-        it "should use legacy-resolver argument" do
-          p = StringIO.new(
-            <<-EOS
-            Collecting real-package==versionplease
-              Could not find a version that satisfies the requirement real-package==versionplease (from versions: 1.1.3, 1.0, 1.9b1)
-            No matching distribution found for real-package==versionplease
-            EOS
-          )
-          expect(Puppet::Util::Execution).to receive(:execpipe).with(["/fake/bin/pip", "install", "real_package==versionplease",
-            "--use-deprecated=legacy-resolver"]).and_yield(p).once
-          @resource[:name] = "real_package"
-          @provider.latest
-        end
-      end
-
-      context "with pip version >= 21.1" do
-        let(:pip_version) { '21.1' }
-        let(:pip_path) { '/fake/bin/pip' }
-
-        it "should not use legacy-resolver argument" do
-          p = StringIO.new(
-            <<-EOS
-            Collecting real-package==versionplease
-              Could not find a version that satisfies the requirement real-package==versionplease (from versions: 1.1.3, 1.0, 1.9b1)
-            No matching distribution found for real-package==versionplease
-            EOS
-          )
-          expect(Puppet::Util::Execution).to receive(:execpipe).with(["/fake/bin/pip", "install", "real_package==versionplease"]).and_yield(p).once
-          @resource[:name] = "real_package"
-          @provider.latest
-        end
-      end
-
       it "should find a version number for real_package" do
         p = StringIO.new(
           <<-EOS
@@ -371,6 +335,7 @@ describe Puppet::Type.type(:package).provider(:pip) do
 
     it "should install" do
       @resource[:ensure] = :installed
+      @resource[:source] = nil
       expect(@provider).to receive(:execute).with(["/fake/bin/pip", ["install", "-q", "fake_package"]])
       @provider.install
     end
@@ -403,6 +368,7 @@ describe Puppet::Type.type(:package).provider(:pip) do
 
     it "should install a particular version" do
       @resource[:ensure] = "0.0.0"
+      @resource[:source] = nil
       # TJK
       expect(@provider).to receive(:execute).with(["/fake/bin/pip", ["install", "-q", "fake_package==0.0.0"]])
       @provider.install
@@ -410,6 +376,7 @@ describe Puppet::Type.type(:package).provider(:pip) do
 
     it "should upgrade" do
       @resource[:ensure] = :latest
+      @resource[:source] = nil
       # TJK
       expect(@provider).to receive(:execute).with(["/fake/bin/pip", ["install", "-q", "--upgrade", "fake_package"]])
       @provider.install
@@ -417,6 +384,7 @@ describe Puppet::Type.type(:package).provider(:pip) do
 
     it "should handle install options" do
       @resource[:ensure] = :installed
+      @resource[:source] = nil
       @resource[:install_options] = [{"--timeout" => "10"}, "--no-index"]
       expect(@provider).to receive(:execute).with(["/fake/bin/pip", ["install", "-q", "--timeout=10", "--no-index", "fake_package"]])
       @provider.install
@@ -447,7 +415,7 @@ describe Puppet::Type.type(:package).provider(:pip) do
     let(:pip) { '/fake/bin/pip' }
 
     it "should look up version if pip is present" do
-      allow(described_class).to receive(:cmd).and_return(pip)
+      allow(described_class).to receive(:pip_cmd).and_return(pip)
       process = ['pip 8.0.2 from /usr/local/lib/python2.7/dist-packages (python 2.7)']
       allow(described_class).to receive(:execpipe).with([pip, '--version']).and_yield(process)
 
@@ -455,7 +423,7 @@ describe Puppet::Type.type(:package).provider(:pip) do
     end
 
     it "parses multiple lines of output" do
-      allow(described_class).to receive(:cmd).and_return(pip)
+      allow(described_class).to receive(:pip_cmd).and_return(pip)
       process = [
         "/usr/local/lib/python2.7/dist-packages/urllib3/contrib/socks.py:37: DependencyWarning: SOCKS support in urllib3 requires the installation of optional dependencies: specifically, PySocks. For more information, see https://urllib3.readthedocs.io/en/latest/contrib.html#socks-proxies",
         "  DependencyWarning",
@@ -467,7 +435,7 @@ describe Puppet::Type.type(:package).provider(:pip) do
     end
 
     it "raises if there isn't a version string" do
-      allow(described_class).to receive(:cmd).and_return(pip)
+      allow(described_class).to receive(:pip_cmd).and_return(pip)
       allow(described_class).to receive(:execpipe).with([pip, '--version']).and_yield([""])
       expect {
         described_class.pip_version(pip)
@@ -476,7 +444,7 @@ describe Puppet::Type.type(:package).provider(:pip) do
 
     it "quotes commands with spaces" do
       pip = 'C:\Program Files\Python27\Scripts\pip.exe'
-      allow(described_class).to receive(:cmd).and_return(pip)
+      allow(described_class).to receive(:pip_cmd).and_return(pip)
       process = ["pip 18.1 from c:\program files\python27\lib\site-packages\pip (python 2.7)\r\n"]
       allow(described_class).to receive(:execpipe).with(["\"#{pip}\"", '--version']).and_yield(process)
 
@@ -491,7 +459,7 @@ describe Puppet::Type.type(:package).provider(:pip) do
     end
 
     context 'when is defaultfor' do
-      let(:os) {  Puppet.runtime[:facter].value(:operatingsystem) }
+      let(:os) {  Facter.value(:operatingsystem) }
       subject do
         described_class.defaultfor(operatingsystem: os)
         described_class.specificity

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

@@ -352,15 +352,12 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
             resource[:ensure] = '1.0-0.151006'
             is = :absent
             expect(provider).to receive(:query).with(no_args).and_return({:ensure => is})
-            expect(provider).to receive(:properties).and_return({:mark => :hold}).exactly(3).times
-
+            expect(provider).to receive(:properties).and_return({:mark => :hold})
             expect(described_class).to receive(:pkg)
               .with(:list, '-Hvfa', 'dummy@1.0-0.151006')
               .and_return(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_implicit_version')), 0))
             expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'install', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
-            expect(provider).to receive(:unhold).with(no_args).twice
-            expect(described_class).to receive(:pkg)
-              .with(:freeze, 'dummy')
+            expect(provider).to receive(:unhold).with(no_args)
             expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'install', *hash[:flags], 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
             allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
             provider.insync?(is)
@@ -371,14 +368,10 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
             resource[:ensure] = '1.0-0.151006'
             is = '1.0,5.11-0.151006:20140219T191204Z'
             expect(provider).to receive(:query).with(no_args).and_return({:ensure => is})
-            expect(provider).to receive(:properties).and_return({:mark => :hold}).exactly(3).times
-
+            expect(provider).to receive(:properties).and_return({:mark => :hold})
             expect(described_class).to receive(:pkg).with(:list, '-Hvfa', 'dummy@1.0-0.151006').and_return(File.read(my_fixture('dummy_implicit_version')))
-            expect(described_class).to receive(:pkg)
-              .with(:freeze, 'dummy')
             expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'update', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
-              .and_return(File.read(my_fixture('dummy_implicit_version')))
-            expect(provider).to receive(:unhold).with(no_args).twice
+            expect(provider).to receive(:unhold).with(no_args)
             expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'update', *hash[:flags], 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
             allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
             provider.insync?(is)
@@ -392,8 +385,6 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
             expect(described_class).to receive(:pkg)
               .with(:list, '-Hvfa', 'dummy@1.0-0.151006')
               .and_return(Puppet::Util::Execution::ProcessOutput.new(File.read(my_fixture('dummy_implicit_version')), 0))
-            expect(Puppet::Util::Execution).to receive(:execute).with(["/bin/pkg", "list", "-Hv", "dummy"], {:failonfail => false, :combine => true})
-              .and_return(File.read(my_fixture('dummy_implicit_version')))
             expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'update', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
             allow($CHILD_STATUS).to receive(:exitstatus).and_return(4)
             provider.insync?(is)
@@ -405,26 +396,10 @@ describe Puppet::Type.type(:package).provider(:pkg), unless: Puppet::Util::Platf
             expect(provider).to receive(:warning).with("Implicit version 1.0-0.151006 has 3 possible matches")
             expect(provider).to receive(:warning).with("Selecting version '1.0,5.11-0.151006:20140220T084443Z' for implicit '1.0-0.151006'")
             expect(described_class).to receive(:pkg).with(:list, '-Hvfa', 'dummy@1.0-0.151006').and_return(File.read(my_fixture('dummy_implicit_version')))
-            expect(Puppet::Util::Execution).to receive(:execute).with(["/bin/pkg", "list", "-Hv", "dummy"], {:failonfail => false, :combine => true})
-              .and_return(File.read(my_fixture('dummy_implicit_version')))
             expect(Puppet::Util::Execution).to receive(:execute).with(['/bin/pkg', 'install', '-n', 'dummy@1.0,5.11-0.151006:20140220T084443Z'], {:failonfail => false, :combine => true})
             allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
             provider.insync?(is)
           end
-          
-          it "should try 5 times to install and fail when all tries failed" do
-            allow_any_instance_of(Kernel).to receive(:sleep)
-              
-            expect(provider).to receive(:query).and_return({:ensure => :absent})
-            expect(provider).to receive(:properties).and_return({:mark => :hold})
-            expect(provider).to receive(:unhold)
-            expect(Puppet::Util::Execution).to receive(:execute)
-              .with(['/bin/pkg', 'install', *hash[:flags], 'dummy'], {:failonfail => false, :combine => true}).exactly(5).times
-            allow($CHILD_STATUS).to receive(:exitstatus).and_return(7)
-            expect {
-              provider.update
-            }.to raise_error(Puppet::Error, /Pkg could not install dummy after 5 tries. Aborting run/)
-          end
         end
       end
     end

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

@@ -8,6 +8,10 @@ describe Puppet::Type.type(:package).provider(:pkgdmg) do
   it { is_expected.not_to be_uninstallable }
 
   describe "when installing it should fail when" do
+    before :each do
+      expect(Puppet::Util).not_to receive(:execute)
+    end
+
     it "no source is specified" do
       expect { provider.install }.to raise_error(Puppet::Error, /must specify a package source/)
     end

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

@@ -15,19 +15,20 @@ describe Puppet::Type.type(:package).provider(:puppet_gem) do
   end
 
   if Puppet::Util::Platform.windows?
-    let(:provider_gem_cmd) { 'gem' }
+    let(:provider_gem_cmd) { 'C:\Program Files\Puppet Labs\Puppet\puppet\bin\gem.bat' }
   else
     let(:provider_gem_cmd) { '/opt/puppetlabs/puppet/bin/gem' }
   end
 
   custom_environment = {"HOME"=>ENV["HOME"]}
-  custom_environment['PKG_CONFIG_PATH'] = '/opt/puppetlabs/puppet/lib/pkgconfig' unless Puppet::Util::Platform.windows?
+  custom_environment['PKG_CONFIG_PATH'] = '/opt/puppetlabs/puppet/lib/pkgconfig'
 
   let(:execute_options) { {:failonfail => true, :combine => true, :custom_environment => custom_environment} }
 
   before :each do
     resource.provider = provider
     allow(described_class).to receive(:command).with(:gemcmd).and_return(provider_gem_cmd)
+    allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
   end
 
   context "when installing" do
@@ -87,7 +88,7 @@ describe Puppet::Type.type(:package).provider(:puppet_gem) do
     end
 
     context 'when is defaultfor' do
-      let(:os) {  Puppet.runtime[:facter].value(:operatingsystem) }
+      let(:os) {  Facter.value(:operatingsystem) }
       subject do
         described_class.defaultfor(operatingsystem: os)
         described_class.specificity

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

@@ -125,7 +125,7 @@ describe Puppet::Type.type(:package).provider(:puppetserver_gem) do
     end
 
     context 'when is defaultfor' do
-      let(:os) {  Puppet.runtime[:facter].value(:operatingsystem) }
+      let(:os) {  Facter.value(:operatingsystem) }
       subject do
         described_class.defaultfor(operatingsystem: os)
         described_class.specificity

data/spec/unit/provider/parsedfile_spec.rb

@@ -79,16 +79,6 @@ describe Puppet::Provider::ParsedFile do
 
       provider.instances
     end
-
-    it "should raise if parsing returns nil" do
-      expect(provider).to receive(:targets).and_return(%w{/one})
-      expect_any_instance_of(Puppet::Util::FileType::FileTypeFlat).to receive(:read).and_return('a=b')
-      expect(provider).to receive(:parse).and_return(nil)
-
-      expect {
-        provider.instances
-      }.to raise_error(Puppet::DevError, %r{Prefetching /one for provider parsedfile_provider returned nil})
-    end
   end
 
   describe "when matching resources to existing records" do

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

@@ -10,8 +10,8 @@ describe 'Puppet::Type::Service::Provider::Gentoo',
 
   before :each do
     allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(provider_class)
-    allow(Puppet::FileSystem).to receive(:file?).with('/sbin/rc-update').and_return(true)
-    allow(Puppet::FileSystem).to receive(:executable?).with('/sbin/rc-update').and_return(true)
+    allow(FileTest).to receive(:file?).with('/sbin/rc-update').and_return(true)
+    allow(FileTest).to receive(:executable?).with('/sbin/rc-update').and_return(true)
     allow(Facter).to receive(:value).with(:operatingsystem).and_return('Gentoo')
     allow(Facter).to receive(:value).with(:osfamily).and_return('Gentoo')
 
@@ -52,14 +52,13 @@ describe 'Puppet::Type::Service::Provider::Gentoo',
     end
 
     it "should get a list of services from /etc/init.d but exclude helper scripts" do
-      allow(Puppet::FileSystem).to receive(:directory?).and_call_original
-      allow(Puppet::FileSystem).to receive(:directory?).with('/etc/init.d').and_return(true)
+      expect(FileTest).to receive(:directory?).with('/etc/init.d').and_return(true)
       expect(Dir).to receive(:entries).with('/etc/init.d').and_return(initscripts)
       (initscripts - helperscripts).each do |script|
-        expect(Puppet::FileSystem).to receive(:executable?).with("/etc/init.d/#{script}").and_return(true)
+        expect(FileTest).to receive(:executable?).with("/etc/init.d/#{script}").and_return(true)
       end
       helperscripts.each do |script|
-        expect(Puppet::FileSystem).not_to receive(:executable?).with("/etc/init.d/#{script}")
+        expect(FileTest).not_to receive(:executable?).with("/etc/init.d/#{script}")
       end
 
       allow(Puppet::FileSystem).to receive(:symlink?).and_return(false)

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

@@ -83,22 +83,15 @@ describe 'Puppet::Type::Service::Provider::Init',
       allow(provider_class).to receive(:defpath).and_return('tmp')
 
       @services = ['one', 'two', 'three', 'four', 'umountfs']
-      allow(Dir).to receive(:entries).and_call_original
       allow(Dir).to receive(:entries).with('tmp').and_return(@services)
-      allow(Puppet::FileSystem).to receive(:directory?).and_call_original
-      allow(Puppet::FileSystem).to receive(:directory?).with('tmp').and_return(true)
-      allow(Puppet::FileSystem).to receive(:executable?).and_return(true)
+      expect(FileTest).to receive(:directory?).with('tmp').and_return(true)
+      allow(FileTest).to receive(:executable?).and_return(true)
     end
 
     it "should return instances for all services" do
       expect(provider_class.instances.map(&:name)).to eq(@services)
     end
 
-    it "should omit directories from the service list" do
-      expect(Puppet::FileSystem).to receive(:directory?).with('tmp/four').and_return(true)
-      expect(provider_class.instances.map(&:name)).to eq(@services - ['four'])
-    end
-
     it "should omit an array of services from exclude list" do
       exclude = ['two', 'four']
       expect(provider_class.get_services(provider_class.defpath, exclude).map(&:name)).to eq(@services - exclude)
@@ -146,9 +139,9 @@ describe 'Puppet::Type::Service::Provider::Init',
 
   describe "when checking valid paths" do
     it "should discard paths that do not exist" do
-      expect(Puppet::FileSystem).to receive(:directory?).with(paths[0]).and_return(false)
+      expect(File).to receive(:directory?).with(paths[0]).and_return(false)
       expect(Puppet::FileSystem).to receive(:exist?).with(paths[0]).and_return(false)
-      expect(Puppet::FileSystem).to receive(:directory?).with(paths[1]).and_return(true)
+      expect(File).to receive(:directory?).with(paths[1]).and_return(true)
 
       expect(provider.paths).to eq([paths[1]])
     end
@@ -156,7 +149,7 @@ describe 'Puppet::Type::Service::Provider::Init',
     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(Puppet::FileSystem).to receive(:directory?).with(path).and_return(false)
+        expect(File).to receive(:directory?).with(path).and_return(false)
       end
       expect(provider.paths).to be_empty
     end
@@ -164,7 +157,7 @@ describe 'Puppet::Type::Service::Provider::Init',
 
   describe "when searching for the init script" do
     before :each do
-      paths.each {|path| expect(Puppet::FileSystem).to receive(:directory?).with(path).and_return(true) }
+      paths.each {|path| expect(File).to receive(:directory?).with(path).and_return(true) }
     end
 
     it "should be able to find the init script in the service path" do
@@ -197,9 +190,9 @@ describe 'Puppet::Type::Service::Provider::Init',
 
   describe "if the init script is present" do
     before :each do
-      allow(Puppet::FileSystem).to receive(:directory?).and_call_original
-      allow(Puppet::FileSystem).to receive(:directory?).with("/service/path").and_return(true)
-      allow(Puppet::FileSystem).to receive(:directory?).with("/alt/service/path").and_return(true)
+      allow(File).to receive(:directory?).and_call_original
+      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)
     end
 

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

@@ -327,7 +327,6 @@ describe 'Puppet::Type::Service::Provider::Launchd',
           'LimitLoadToSessionType' => 'Aqua'
         }
       end
-      let(:plist_without_label_not_hash) { 'just a string' }
       let(:busted_plist_path) { '/Library/LaunchAgents/org.busted.plist' }
       let(:binary_plist_path) { '/Library/LaunchAgents/org.binary.plist' }
 
@@ -339,16 +338,6 @@ describe 'Puppet::Type::Service::Provider::Launchd',
         expect(Puppet).to receive(:debug).with("The #{busted_plist_path} plist does not contain a 'label' key; Puppet is skipping it")
         provider.make_label_to_path_map
       end
-
-      it "it should warn that the malformed 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_not_hash)
-        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.make_label_to_path_map
-      end
-
     end
 
     it "should return the cached value when available" do

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

@@ -2,56 +2,61 @@ require 'spec_helper'
 
 describe 'Puppet::Type::Service::Provider::Openwrt',
          unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
-
   let(:provider_class) { Puppet::Type.type(:service).provider(:openwrt) }
 
   let(:resource) do
-    Puppet::Type.type(:service).new(
-      :name       => 'myservice',
-      :path       => '/etc/init.d',
-      :hasrestart => true,
-    )
+    resource = double('resource')
+    allow(resource).to receive(:[]).and_return(nil)
+    allow(resource).to receive(:[]).with(:name).and_return("myservice")
+    allow(resource).to receive(:[]).with(:path).and_return(["/etc/init.d"])
+
+    resource
   end
 
   let(:provider) do
     provider = provider_class.new
-    provider.resource = resource
+    allow(provider).to receive(:get).with(:hasstatus).and_return(false)
+
     provider
   end
 
   before :each do
-    resource.provider = provider
+    allow(resource).to receive(:provider).and_return(provider)
+    provider.resource = resource
+
+    allow(FileTest).to receive(:file?).with('/etc/rc.common').and_return(true)
+    allow(FileTest).to receive(:executable?).with('/etc/rc.common').and_return(true)
 
     # All OpenWrt tests operate on the init script directly. It must exist.
-    allow(Puppet::FileSystem).to receive(:directory?).and_call_original
-    allow(Puppet::FileSystem).to receive(:directory?).with('/etc/init.d').and_return(true)
+    allow(File).to receive(:directory?).and_call_original
+    allow(File).to receive(:directory?).with('/etc/init.d').and_return(true)
 
     allow(Puppet::FileSystem).to receive(:exist?).with('/etc/init.d/myservice').and_return(true)
-    allow(Puppet::FileSystem).to receive(:file?).and_call_original
-    allow(Puppet::FileSystem).to receive(:file?).with('/etc/init.d/myservice').and_return(true)
-    allow(Puppet::FileSystem).to receive(:executable?).with('/etc/init.d/myservice').and_return(true)
+    allow(FileTest).to receive(:file?).with('/etc/init.d/myservice').and_return(true)
+    allow(FileTest).to receive(:executable?).with('/etc/init.d/myservice').and_return(true)
   end
 
-  it "should be the default provider on 'openwrt'" do
-    expect(Facter).to receive(:value).with(:operatingsystem).and_return('openwrt')
+  operatingsystem = 'openwrt'
+  it "should be the default provider on #{operatingsystem}" do
+    expect(Facter).to receive(:value).with(:operatingsystem).and_return(operatingsystem)
     expect(provider_class.default?).to be_truthy
   end
 
   # test self.instances
   describe "when getting all service instances" do
-    let(:services) { ['dnsmasq', 'dropbear', 'firewall', 'led', 'puppet', 'uhttpd' ] }
+    let(:services) {['dnsmasq', 'dropbear', 'firewall', 'led', 'puppet', 'uhttpd' ]}
 
     before :each do
-      allow(Dir).to receive(:entries).and_call_original
-      allow(Dir).to receive(:entries).with('/etc/init.d').and_return(services)
-      allow(Puppet::FileSystem).to receive(:executable?).and_return(true)
+      allow(Dir).to receive(:entries).and_return(services)
+      allow(FileTest).to receive(:directory?).and_return(true)
+      allow(FileTest).to receive(:executable?).and_return(true)
     end
 
     it "should return instances for all services" do
       services.each do |inst|
         expect(provider_class).to receive(:new).with(hash_including(:name => inst, :path => '/etc/init.d')).and_return("#{inst}_instance")
       end
-      results = services.collect { |x| "#{x}_instance"}
+      results = services.collect {|x| "#{x}_instance"}
       expect(provider_class.instances).to eq(results)
     end
   end
@@ -75,13 +80,14 @@ describe 'Puppet::Type::Service::Provider::Openwrt',
 
     describe "when running #{method}" do
       it "should use any provided explicit command" do
-        resource[method] = '/user/specified/command'
-        expect(provider).to receive(:execute).with(['/user/specified/command'], any_args)
+        allow(resource).to receive(:[]).with(method).and_return("/user/specified/command")
+        expect(provider).to receive(:execute).with(["/user/specified/command"], any_args)
         provider.send(method)
       end
 
       it "should execute the init script with #{method} when no explicit command is provided" do
-        expect(provider).to receive(:execute).with(['/etc/init.d/myservice', method], any_args)
+        allow(resource).to receive(:[]).with("has#{method}".intern).and_return(:true)
+        expect(provider).to receive(:execute).with(['/etc/init.d/myservice', method ], any_args)
         provider.send(method)
       end
     end

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

@@ -50,9 +50,8 @@ describe 'Puppet::Type::Service::Provider::Redhat',
       @services = ['one', 'two', 'three', 'four', 'kudzu', 'functions', 'halt', 'killall', 'single', 'linuxconf', 'boot', 'reboot']
       @not_services = ['functions', 'halt', 'killall', 'single', 'linuxconf', 'reboot', 'boot']
       allow(Dir).to receive(:entries).and_return(@services)
-      allow(Puppet::FileSystem).to receive(:directory?).and_call_original
-      allow(Puppet::FileSystem).to receive(:directory?).with('/etc/init.d').and_return(true)
-      allow(Puppet::FileSystem).to receive(:executable?).and_return(true)
+      allow(FileTest).to receive(:directory?).and_return(true)
+      allow(FileTest).to receive(:executable?).and_return(true)
     end
 
     it "should return instances for all services" do