puppet 6.29.0-x64-mingw32 → 7.0.0-x64-mingw32

data/spec/unit/util/run_mode_spec.rb

@@ -1,12 +1,6 @@
 require 'spec_helper'
 
 describe Puppet::Util::RunMode do
-  # Discriminator for tests that attempts to unset HOME since that, for reasons currently unknown,
-  # doesn't work in Ruby >= 2.4.0
-  def self.gte_ruby_2_4
-    @gte_ruby_2_4 ||= SemanticPuppet::Version.parse(RUBY_VERSION) >= SemanticPuppet::Version.parse('2.4.0')
-  end
-
   before do
     @run_mode = Puppet::Util::RunMode.new('fake')
   end
@@ -34,14 +28,6 @@ describe Puppet::Util::RunMode do
           as_non_root { expect(@run_mode.conf_dir).to eq(File.expand_path('~/.puppetlabs/etc/puppet')) }
         end
       end
-
-      it "fails when asking for the conf_dir as non-root and there is no $HOME", :unless => gte_ruby_2_4 || Puppet::Util::Platform.windows? do
-        as_non_root do
-          without_home do
-            expect { @run_mode.conf_dir }.to raise_error ArgumentError, /couldn't find HOME/
-          end
-        end
-      end
     end
 
     describe "#code_dir" do
@@ -62,14 +48,6 @@ describe Puppet::Util::RunMode do
           as_non_root { expect(@run_mode.code_dir).to eq(File.expand_path('~/.puppetlabs/etc/code')) }
         end
       end
-
-      it "fails when asking for the code_dir as non-root and there is no $HOME", :unless => gte_ruby_2_4 || Puppet::Util::Platform.windows? do
-        as_non_root do
-          without_home do
-            expect { @run_mode.code_dir }.to raise_error ArgumentError, /couldn't find HOME/
-          end
-        end
-      end
     end
 
     describe "#var_dir" do
@@ -80,13 +58,15 @@ describe Puppet::Util::RunMode do
       it "has vardir ~/.puppetlabs/opt/puppet/cache when run as non-root" do
         as_non_root { expect(@run_mode.var_dir).to eq(File.expand_path('~/.puppetlabs/opt/puppet/cache')) }
       end
+    end
+
+    describe "#public_dir" do
+      it "has publicdir /opt/puppetlabs/puppet/public when run as root" do
+        as_root { expect(@run_mode.public_dir).to eq(File.expand_path('/opt/puppetlabs/puppet/public')) }
+      end
 
-      it "fails when asking for the var_dir as non-root and there is no $HOME", :unless => gte_ruby_2_4 || Puppet::Util::Platform.windows? do
-        as_non_root do
-          without_home do
-            expect { @run_mode.var_dir }.to raise_error ArgumentError, /couldn't find HOME/
-          end
-        end
+      it "has publicdir ~/.puppetlabs/opt/puppet/public when run as non-root" do
+        as_non_root { expect(@run_mode.public_dir).to eq(File.expand_path('~/.puppetlabs/opt/puppet/public')) }
       end
     end
 
@@ -101,14 +81,6 @@ describe Puppet::Util::RunMode do
         it "has default logdir ~/.puppetlabs/var/log" do
           as_non_root { expect(@run_mode.log_dir).to eq(File.expand_path('~/.puppetlabs/var/log')) }
         end
-
-        it "fails when asking for the log_dir and there is no $HOME", :unless => gte_ruby_2_4 || Puppet::Util::Platform.windows? do
-          as_non_root do
-            without_home do
-              expect { @run_mode.log_dir }.to raise_error ArgumentError, /couldn't find HOME/
-            end
-          end
-        end
       end
     end
 
@@ -123,103 +95,59 @@ describe Puppet::Util::RunMode do
         it "has default rundir ~/.puppetlabs/var/run" do
           as_non_root { expect(@run_mode.run_dir).to eq(File.expand_path('~/.puppetlabs/var/run')) }
         end
-
-        it "fails when asking for the run_dir and there is no $HOME", :unless => gte_ruby_2_4 || Puppet::Util::Platform.windows? do
-          as_non_root do
-            without_home do
-              expect { @run_mode.run_dir }.to raise_error ArgumentError, /couldn't find HOME/
-            end
-          end
-        end
       end
     end
   end
 
   describe Puppet::Util::WindowsRunMode, :if => Puppet::Util::Platform.windows? do
     before do
-      if not Dir.const_defined? :COMMON_APPDATA
-        Dir.const_set :COMMON_APPDATA, "/CommonFakeBase"
-        @remove_const = true
-      end
       @run_mode = Puppet::Util::WindowsRunMode.new('fake')
     end
 
-    after do
-      if @remove_const
-        Dir.send :remove_const, :COMMON_APPDATA
-      end
-    end
-
     describe "#conf_dir" do
       it "has confdir ending in Puppetlabs/puppet/etc when run as root" do
-        as_root { expect(@run_mode.conf_dir).to eq(File.expand_path(File.join(Dir::COMMON_APPDATA, "PuppetLabs", "puppet", "etc"))) }
+        as_root { expect(@run_mode.conf_dir).to eq(File.expand_path(File.join(ENV['ALLUSERSPROFILE'], "PuppetLabs", "puppet", "etc"))) }
       end
 
       it "has confdir in ~/.puppetlabs/etc/puppet when run as non-root" do
         as_non_root { expect(@run_mode.conf_dir).to eq(File.expand_path("~/.puppetlabs/etc/puppet")) }
       end
-
-      it "fails when asking for the conf_dir as non-root and there is no %HOME%, %HOMEDRIVE%, and %USERPROFILE%", :unless => gte_ruby_2_4 do
-        as_non_root do
-          without_env('HOME') do
-            without_env('HOMEDRIVE') do
-              without_env('USERPROFILE') do
-                expect { @run_mode.conf_dir }.to raise_error ArgumentError, /couldn't find HOME/
-              end
-            end
-          end
-        end
-      end
     end
 
     describe "#code_dir" do
       it "has codedir ending in PuppetLabs/code when run as root" do
-        as_root { expect(@run_mode.code_dir).to eq(File.expand_path(File.join(Dir::COMMON_APPDATA, "PuppetLabs", "code"))) }
+        as_root { expect(@run_mode.code_dir).to eq(File.expand_path(File.join(ENV['ALLUSERSPROFILE'], "PuppetLabs", "code"))) }
       end
 
       it "has codedir in ~/.puppetlabs/etc/code when run as non-root" do
         as_non_root { expect(@run_mode.code_dir).to eq(File.expand_path("~/.puppetlabs/etc/code")) }
       end
-
-      it "fails when asking for the code_dir as non-root and there is no %HOME%, %HOMEDRIVE%, and %USERPROFILE%", :unless => gte_ruby_2_4 do
-        as_non_root do
-          without_env('HOME') do
-            without_env('HOMEDRIVE') do
-              without_env('USERPROFILE') do
-                expect { @run_mode.code_dir }.to raise_error ArgumentError, /couldn't find HOME/
-              end
-            end
-          end
-        end
-      end
     end
 
     describe "#var_dir" do
       it "has vardir ending in PuppetLabs/puppet/cache when run as root" do
-        as_root { expect(@run_mode.var_dir).to eq(File.expand_path(File.join(Dir::COMMON_APPDATA, "PuppetLabs", "puppet", "cache"))) }
+        as_root { expect(@run_mode.var_dir).to eq(File.expand_path(File.join(ENV['ALLUSERSPROFILE'], "PuppetLabs", "puppet", "cache"))) }
       end
 
       it "has vardir in ~/.puppetlabs/opt/puppet/cache when run as non-root" do
         as_non_root { expect(@run_mode.var_dir).to eq(File.expand_path("~/.puppetlabs/opt/puppet/cache")) }
       end
+    end
+
+    describe "#public_dir" do
+      it "has publicdir ending in PuppetLabs/puppet/public when run as root" do
+        as_root { expect(@run_mode.public_dir).to eq(File.expand_path(File.join(ENV['ALLUSERSPROFILE'], "PuppetLabs", "puppet", "public"))) }
+      end
 
-      it "fails when asking for the conf_dir as non-root and there is no %HOME%, %HOMEDRIVE%, and %USERPROFILE%", :unless => gte_ruby_2_4 do
-        as_non_root do
-          without_env('HOME') do
-            without_env('HOMEDRIVE') do
-              without_env('USERPROFILE') do
-                expect { @run_mode.var_dir }.to raise_error ArgumentError, /couldn't find HOME/
-              end
-            end
-          end
-        end
+      it "has publicdir in ~/.puppetlabs/opt/puppet/public when run as non-root" do
+        as_non_root { expect(@run_mode.public_dir).to eq(File.expand_path("~/.puppetlabs/opt/puppet/public")) }
       end
     end
 
     describe "#log_dir" do
       describe "when run as root" do
         it "has logdir ending in PuppetLabs/puppet/var/log" do
-          as_root { expect(@run_mode.log_dir).to eq(File.expand_path(File.join(Dir::COMMON_APPDATA, "PuppetLabs", "puppet", "var", "log"))) }
+          as_root { expect(@run_mode.log_dir).to eq(File.expand_path(File.join(ENV['ALLUSERSPROFILE'], "PuppetLabs", "puppet", "var", "log"))) }
         end
       end
 
@@ -227,25 +155,13 @@ describe Puppet::Util::RunMode do
         it "has default logdir ~/.puppetlabs/var/log" do
           as_non_root { expect(@run_mode.log_dir).to eq(File.expand_path('~/.puppetlabs/var/log')) }
         end
-
-        it "fails when asking for the log_dir and there is no $HOME", :unless => gte_ruby_2_4 do
-          as_non_root do
-            without_env('HOME') do
-              without_env('HOMEDRIVE') do
-                without_env('USERPROFILE') do
-                  expect { @run_mode.log_dir }.to raise_error ArgumentError, /couldn't find HOME/
-                end
-              end
-            end
-          end
-        end
       end
     end
 
     describe "#run_dir" do
       describe "when run as root" do
         it "has rundir ending in PuppetLabs/puppet/var/run" do
-          as_root { expect(@run_mode.run_dir).to eq(File.expand_path(File.join(Dir::COMMON_APPDATA, "PuppetLabs", "puppet", "var", "run"))) }
+          as_root { expect(@run_mode.run_dir).to eq(File.expand_path(File.join(ENV['ALLUSERSPROFILE'], "PuppetLabs", "puppet", "var", "run"))) }
         end
       end
 
@@ -253,18 +169,6 @@ describe Puppet::Util::RunMode do
         it "has default rundir ~/.puppetlabs/var/run" do
           as_non_root { expect(@run_mode.run_dir).to eq(File.expand_path('~/.puppetlabs/var/run')) }
         end
-
-        it "fails when asking for the run_dir and there is no $HOME", :unless => gte_ruby_2_4 do
-          as_non_root do
-            without_env('HOME') do
-              without_env('HOMEDRIVE') do
-                without_env('USERPROFILE') do
-                  expect { @run_mode.run_dir }.to raise_error ArgumentError, /couldn't find HOME/
-                end
-              end
-            end
-          end
-        end
       end
     end
 
@@ -310,8 +214,4 @@ describe Puppet::Util::RunMode do
   ensure
     Puppet::Util.set_env(name, saved)
   end
-
-  def without_home(&block)
-    without_env('HOME', &block)
-  end
 end

data/spec/unit/util/selinux_spec.rb

@@ -3,29 +3,26 @@ require 'spec_helper'
 require 'pathname'
 require 'puppet/util/selinux'
 
+unless defined?(Selinux)
+  module Selinux
+    def self.is_selinux_enabled
+      false
+    end
+  end
+end
+
 describe Puppet::Util::SELinux do
   include Puppet::Util::SELinux
 
-  let(:selinux) { double('selinux', is_selinux_enabled: false) }
-
-  before :each do
-    stub_const('Selinux', selinux)
-  end
-
   describe "selinux_support?" do
-    it "should return true if this system has SELinux enabled" do
+    it "should return :true if this system has SELinux enabled" do
       expect(Selinux).to receive(:is_selinux_enabled).and_return(1)
-      expect(selinux_support?).to eq(true)
+      expect(selinux_support?).to be_truthy
     end
 
-    it "should return false if this system has SELinux disabled" do
+    it "should return :false if this system lacks SELinux" do
       expect(Selinux).to receive(:is_selinux_enabled).and_return(0)
-      expect(selinux_support?).to eq(false)
-    end
-
-    it "should return false if this system lacks SELinux" do
-      hide_const('Selinux')
-      expect(selinux_support?).to eq(false)
+      expect(selinux_support?).to be_falsey
     end
 
     it "should return nil if /proc/mounts does not exist" do
@@ -114,19 +111,15 @@ describe Puppet::Util::SELinux do
     end
 
     it "should return a context" do
-      without_partial_double_verification do
-        expect(self).to receive(:selinux_support?).and_return(true)
-        expect(Selinux).to receive(:lgetfilecon).with("/foo").and_return([0, "user_u:role_r:type_t:s0"])
-        expect(get_selinux_current_context("/foo")).to eq("user_u:role_r:type_t:s0")
-      end
+      expect(self).to receive(:selinux_support?).and_return(true)
+      expect(Selinux).to receive(:lgetfilecon).with("/foo").and_return([0, "user_u:role_r:type_t:s0"])
+      expect(get_selinux_current_context("/foo")).to eq("user_u:role_r:type_t:s0")
     end
 
     it "should return nil if lgetfilecon fails" do
-      without_partial_double_verification do
-        expect(self).to receive(:selinux_support?).and_return(true)
-        expect(Selinux).to receive(:lgetfilecon).with("/foo").and_return(-1)
-        expect(get_selinux_current_context("/foo")).to be_nil
-      end
+      expect(self).to receive(:selinux_support?).and_return(true)
+      expect(Selinux).to receive(:lgetfilecon).with("/foo").and_return(-1)
+      expect(get_selinux_current_context("/foo")).to be_nil
     end
   end
 
@@ -137,102 +130,47 @@ describe Puppet::Util::SELinux do
     end
 
     it "should return a context if a default context exists" do
-      without_partial_double_verification do
-        expect(self).to receive(:selinux_support?).and_return(true)
-        fstat = double('File::Stat', :mode => 0)
-        expect(Puppet::FileSystem).to receive(:lstat).with('/foo').and_return(fstat)
-        expect(self).to receive(:find_fs).with("/foo").and_return("ext3")
-        expect(Selinux).to receive(:matchpathcon).with("/foo", 0).and_return([0, "user_u:role_r:type_t:s0"])
-
-        expect(get_selinux_default_context("/foo")).to eq("user_u:role_r:type_t:s0")
-      end
-    end
-
-    it "handles permission denied errors by issuing a warning" do
-      without_partial_double_verification do
-        allow(self).to receive(:selinux_support?).and_return(true)
-        allow(self).to receive(:selinux_label_support?).and_return(true)
-        allow(Selinux).to receive(:matchpathcon).with("/root/chuj", 0).and_return(-1)
-        allow(self).to receive(:file_lstat).with("/root/chuj").and_raise(Errno::EACCES, "/root/chuj")
-
-        expect(get_selinux_default_context("/root/chuj")).to be_nil
-      end
-    end
-
-    it "backward compatibly handles no such file or directory errors by issuing a warning when resource_ensure not set" do
-      without_partial_double_verification do
-        allow(self).to receive(:selinux_support?).and_return(true)
-        allow(self).to receive(:selinux_label_support?).and_return(true)
-        allow(Selinux).to receive(:matchpathcon).with("/root/chuj", 0).and_return(-1)
-        allow(self).to receive(:file_lstat).with("/root/chuj").and_raise(Errno::ENOENT, "/root/chuj")
-
-        expect(get_selinux_default_context("/root/chuj")).to be_nil
-      end
-    end
-
-    it "should determine mode based on resource ensure when set to file" do
-      without_partial_double_verification do
-        allow(self).to receive(:selinux_support?).and_return(true)
-        allow(self).to receive(:selinux_label_support?).and_return(true)
-        allow(Selinux).to receive(:matchpathcon).with("/root/chuj", 32768).and_return(-1)
-        allow(self).to receive(:file_lstat).with("/root/chuj").and_raise(Errno::ENOENT, "/root/chuj")
-
-        expect(get_selinux_default_context("/root/chuj", :present)).to be_nil
-        expect(get_selinux_default_context("/root/chuj", :file)).to be_nil
-      end
-    end
-
-    it "should determine mode based on resource ensure when set to dir" do
-      without_partial_double_verification do
-        allow(self).to receive(:selinux_support?).and_return(true)
-        allow(self).to receive(:selinux_label_support?).and_return(true)
-        allow(Selinux).to receive(:matchpathcon).with("/root/chuj", 16384).and_return(-1)
-        allow(self).to receive(:file_lstat).with("/root/chuj").and_raise(Errno::ENOENT, "/root/chuj")
+      expect(self).to receive(:selinux_support?).and_return(true)
+      fstat = double('File::Stat', :mode => 0)
+      expect(Puppet::FileSystem).to receive(:lstat).with('/foo').and_return(fstat)
+      expect(self).to receive(:find_fs).with("/foo").and_return("ext3")
+      expect(Selinux).to receive(:matchpathcon).with("/foo", 0).and_return([0, "user_u:role_r:type_t:s0"])
 
-        expect(get_selinux_default_context("/root/chuj", :directory)).to be_nil
-      end
+      expect(get_selinux_default_context("/foo")).to eq("user_u:role_r:type_t:s0")
     end
 
-    it "should determine mode based on resource ensure when set to link" do
-      without_partial_double_verification do
-        allow(self).to receive(:selinux_support?).and_return(true)
-        allow(self).to receive(:selinux_label_support?).and_return(true)
-        allow(Selinux).to receive(:matchpathcon).with("/root/chuj", 40960).and_return(-1)
-        allow(self).to receive(:file_lstat).with("/root/chuj").and_raise(Errno::ENOENT, "/root/chuj")
+    it "handles permission denied errors by issuing a warning" do
+      allow(self).to receive(:selinux_support?).and_return(true)
+      allow(self).to receive(:selinux_label_support?).and_return(true)
+      allow(Selinux).to receive(:matchpathcon).with("/root/chuj", 0).and_return(-1)
+      allow(self).to receive(:file_lstat).with("/root/chuj").and_raise(Errno::EACCES, "/root/chuj")
 
-        expect(get_selinux_default_context("/root/chuj", :link)).to be_nil
-      end
+      expect(get_selinux_default_context("/root/chuj")).to be_nil
     end
 
-    it "should determine mode based on resource ensure when set to unknown" do
-      without_partial_double_verification do
-        allow(self).to receive(:selinux_support?).and_return(true)
-        allow(self).to receive(:selinux_label_support?).and_return(true)
-        allow(Selinux).to receive(:matchpathcon).with("/root/chuj", 0).and_return(-1)
-        allow(self).to receive(:file_lstat).with("/root/chuj").and_raise(Errno::ENOENT, "/root/chuj")
+    it "handles no such file or directory errors by issuing a warning" do
+      allow(self).to receive(:selinux_support?).and_return(true)
+      allow(self).to receive(:selinux_label_support?).and_return(true)
+      allow(Selinux).to receive(:matchpathcon).with("/root/chuj", 0).and_return(-1)
+      allow(self).to receive(:file_lstat).with("/root/chuj").and_raise(Errno::ENOENT, "/root/chuj")
 
-        expect(get_selinux_default_context("/root/chuj", "unknown")).to be_nil
-      end
+      expect(get_selinux_default_context("/root/chuj")).to be_nil
     end
 
     it "should return nil if matchpathcon returns failure" do
-      without_partial_double_verification do
-        expect(self).to receive(:selinux_support?).and_return(true)
-        fstat = double('File::Stat', :mode => 0)
-        expect(Puppet::FileSystem).to receive(:lstat).with('/foo').and_return(fstat)
-        expect(self).to receive(:find_fs).with("/foo").and_return("ext3")
-        expect(Selinux).to receive(:matchpathcon).with("/foo", 0).and_return(-1)
-
-        expect(get_selinux_default_context("/foo")).to be_nil
-      end
+      expect(self).to receive(:selinux_support?).and_return(true)
+      fstat = double('File::Stat', :mode => 0)
+      expect(Puppet::FileSystem).to receive(:lstat).with('/foo').and_return(fstat)
+      expect(self).to receive(:find_fs).with("/foo").and_return("ext3")
+      expect(Selinux).to receive(:matchpathcon).with("/foo", 0).and_return(-1)
+
+      expect(get_selinux_default_context("/foo")).to be_nil
     end
 
     it "should return nil if selinux_label_support returns false" do
-      without_partial_double_verification do
-        expect(self).to receive(:selinux_support?).and_return(true)
-        expect(self).to receive(:find_fs).with("/foo").and_return("nfs")
-        expect(get_selinux_default_context("/foo")).to be_nil
-      end
+      expect(self).to receive(:selinux_support?).and_return(true)
+      expect(self).to receive(:find_fs).with("/foo").and_return("nfs")
+      expect(get_selinux_default_context("/foo")).to be_nil
     end
   end
 
@@ -323,47 +261,37 @@ describe Puppet::Util::SELinux do
     end
 
     it "should use lsetfilecon to set a context" do
-      without_partial_double_verification do
-        expect(self).to receive(:selinux_support?).and_return(true)
-        expect(Selinux).to receive(:lsetfilecon).with("/foo", "user_u:role_r:type_t:s0").and_return(0)
-        expect(set_selinux_context("/foo", "user_u:role_r:type_t:s0")).to be_truthy
-      end
+      expect(self).to receive(:selinux_support?).and_return(true)
+      expect(Selinux).to receive(:lsetfilecon).with("/foo", "user_u:role_r:type_t:s0").and_return(0)
+      expect(set_selinux_context("/foo", "user_u:role_r:type_t:s0")).to be_truthy
     end
 
     it "should use lsetfilecon to set user_u user context" do
-      without_partial_double_verification do
-        expect(self).to receive(:selinux_support?).and_return(true)
-        expect(Selinux).to receive(:lgetfilecon).with("/foo").and_return([0, "foo:role_r:type_t:s0"])
-        expect(Selinux).to receive(:lsetfilecon).with("/foo", "user_u:role_r:type_t:s0").and_return(0)
-        expect(set_selinux_context("/foo", "user_u", :seluser)).to be_truthy
-      end
+      expect(self).to receive(:selinux_support?).and_return(true)
+      expect(Selinux).to receive(:lgetfilecon).with("/foo").and_return([0, "foo:role_r:type_t:s0"])
+      expect(Selinux).to receive(:lsetfilecon).with("/foo", "user_u:role_r:type_t:s0").and_return(0)
+      expect(set_selinux_context("/foo", "user_u", :seluser)).to be_truthy
     end
 
     it "should use lsetfilecon to set role_r role context" do
-      without_partial_double_verification do
-        expect(self).to receive(:selinux_support?).and_return(true)
-        expect(Selinux).to receive(:lgetfilecon).with("/foo").and_return([0, "user_u:foo:type_t:s0"])
-        expect(Selinux).to receive(:lsetfilecon).with("/foo", "user_u:role_r:type_t:s0").and_return(0)
-        expect(set_selinux_context("/foo", "role_r", :selrole)).to be_truthy
-      end
+      expect(self).to receive(:selinux_support?).and_return(true)
+      expect(Selinux).to receive(:lgetfilecon).with("/foo").and_return([0, "user_u:foo:type_t:s0"])
+      expect(Selinux).to receive(:lsetfilecon).with("/foo", "user_u:role_r:type_t:s0").and_return(0)
+      expect(set_selinux_context("/foo", "role_r", :selrole)).to be_truthy
     end
 
     it "should use lsetfilecon to set type_t type context" do
-      without_partial_double_verification do
-        expect(self).to receive(:selinux_support?).and_return(true)
-        expect(Selinux).to receive(:lgetfilecon).with("/foo").and_return([0, "user_u:role_r:foo:s0"])
-        expect(Selinux).to receive(:lsetfilecon).with("/foo", "user_u:role_r:type_t:s0").and_return(0)
-        expect(set_selinux_context("/foo", "type_t", :seltype)).to be_truthy
-      end
+      expect(self).to receive(:selinux_support?).and_return(true)
+      expect(Selinux).to receive(:lgetfilecon).with("/foo").and_return([0, "user_u:role_r:foo:s0"])
+      expect(Selinux).to receive(:lsetfilecon).with("/foo", "user_u:role_r:type_t:s0").and_return(0)
+      expect(set_selinux_context("/foo", "type_t", :seltype)).to be_truthy
     end
 
     it "should use lsetfilecon to set s0:c3,c5 range context" do
-      without_partial_double_verification do
-        expect(self).to receive(:selinux_support?).and_return(true)
-        expect(Selinux).to receive(:lgetfilecon).with("/foo").and_return([0, "user_u:role_r:type_t:s0"])
-        expect(Selinux).to receive(:lsetfilecon).with("/foo", "user_u:role_r:type_t:s0:c3,c5").and_return(0)
-        expect(set_selinux_context("/foo", "s0:c3,c5", :selrange)).to be_truthy
-      end
+      expect(self).to receive(:selinux_support?).and_return(true)
+      expect(Selinux).to receive(:lgetfilecon).with("/foo").and_return([0, "user_u:role_r:type_t:s0"])
+      expect(Selinux).to receive(:lsetfilecon).with("/foo", "user_u:role_r:type_t:s0:c3,c5").and_return(0)
+      expect(set_selinux_context("/foo", "s0:c3,c5", :selrange)).to be_truthy
     end
   end
 
@@ -374,44 +302,21 @@ describe Puppet::Util::SELinux do
     end
 
     it "should return nil if no default context exists" do
-      expect(self).to receive(:get_selinux_default_context).with("/foo", nil).and_return(nil)
+      expect(self).to receive(:get_selinux_default_context).with("/foo").and_return(nil)
       expect(set_selinux_default_context("/foo")).to be_nil
     end
 
     it "should do nothing and return nil if the current context matches the default context" do
-      expect(self).to receive(:get_selinux_default_context).with("/foo", nil).and_return("user_u:role_r:type_t")
+      expect(self).to receive(:get_selinux_default_context).with("/foo").and_return("user_u:role_r:type_t")
       expect(self).to receive(:get_selinux_current_context).with("/foo").and_return("user_u:role_r:type_t")
       expect(set_selinux_default_context("/foo")).to be_nil
     end
 
     it "should set and return the default context if current and default do not match" do
-      expect(self).to receive(:get_selinux_default_context).with("/foo", nil).and_return("user_u:role_r:type_t")
+      expect(self).to receive(:get_selinux_default_context).with("/foo").and_return("user_u:role_r:type_t")
       expect(self).to receive(:get_selinux_current_context).with("/foo").and_return("olduser_u:role_r:type_t")
       expect(self).to receive(:set_selinux_context).with("/foo", "user_u:role_r:type_t").and_return(true)
       expect(set_selinux_default_context("/foo")).to eq("user_u:role_r:type_t")
     end
   end
-
-  describe "get_create_mode" do
-    it "should return 0 if the resource is absent" do
-      expect(get_create_mode(:absent)).to eq(0)
-    end
-
-    it "should return mode with file type set to S_IFREG when resource is file" do
-      expect(get_create_mode(:present)).to eq(32768)
-      expect(get_create_mode(:file)).to eq(32768)
-    end
-
-    it "should return mode with file type set to S_IFDIR when resource is dir" do
-      expect(get_create_mode(:directory)).to eq(16384)
-    end
-
-    it "should return mode with file type set to S_IFLNK when resource is link" do
-      expect(get_create_mode(:link)).to eq(40960)
-    end
-
-    it "should return 0 for everything else" do
-      expect(get_create_mode("unknown")).to eq(0)
-    end
-  end
 end

data/spec/unit/util/storage_spec.rb

@@ -143,11 +143,9 @@ describe Puppet::Util::Storage do
       end
 
       it "should raise an error if the state file does not contain valid YAML and cannot be renamed" do
-        allow(File).to receive(:rename).and_call_original
-
         write_state_file('{ invalid')
 
-        expect(File).to receive(:rename).with(@state_file, "#{@state_file}.bad").and_raise(SystemCallError)
+        expect(File).to receive(:rename).and_raise(SystemCallError)
 
         expect { Puppet::Util::Storage.load }.to raise_error(Puppet::Error, /Could not rename/)
       end