puppet 5.5.12-x64-mingw32 → 5.5.13-x64-mingw32

data/spec/unit/util/rdoc_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/rdoc'
@@ -7,48 +6,48 @@ require 'rdoc/rdoc'
 describe Puppet::Util::RDoc do
   describe "when generating RDoc HTML documentation" do
     before :each do
-      @rdoc = stub_everything 'rdoc'
-      RDoc::RDoc.stubs(:new).returns(@rdoc)
+      @rdoc = double('rdoc')
+      allow(RDoc::RDoc).to receive(:new).and_return(@rdoc)
     end
 
     it "should tell RDoc to generate documentation using the Puppet generator" do
-      @rdoc.expects(:document).with { |args| args.include?("--fmt") and args.include?("puppet") }
+      expect(@rdoc).to receive(:document).with(include("--fmt").and(include("puppet")))
 
       Puppet::Util::RDoc.rdoc("output", [])
     end
 
     it "should tell RDoc to be quiet" do
-      @rdoc.expects(:document).with { |args| args.include?("--quiet") }
+      expect(@rdoc).to receive(:document).with(include("--quiet"))
 
       Puppet::Util::RDoc.rdoc("output", [])
     end
 
     it "should pass charset to RDoc" do
-      @rdoc.expects(:document).with { |args| args.include?("--charset") and args.include?("utf-8") }
+      expect(@rdoc).to receive(:document).with(include("--charset").and(include("utf-8")))
 
       Puppet::Util::RDoc.rdoc("output", [], "utf-8")
     end
 
     it "should tell RDoc to use the given outputdir" do
-      @rdoc.expects(:document).with { |args| args.include?("--op") and args.include?("myoutputdir") }
+      expect(@rdoc).to receive(:document).with(include("--op").and(include("myoutputdir")))
 
       Puppet::Util::RDoc.rdoc("myoutputdir", [])
     end
 
     it "should tell RDoc to exclude all files under any modules/<mod>/files section" do
-      @rdoc.expects(:document).with { |args| args.include?("--exclude") and args.include?("/modules/[^/]*/files/.*$") }
+      expect(@rdoc).to receive(:document).with(include("--exclude").and(include("/modules/[^/]*/files/.*$")))
 
       Puppet::Util::RDoc.rdoc("myoutputdir", [])
     end
 
     it "should tell RDoc to exclude all files under any modules/<mod>/templates section" do
-      @rdoc.expects(:document).with { |args| args.include?("--exclude") and args.include?("/modules/[^/]*/templates/.*$") }
+      expect(@rdoc).to receive(:document).with(include("--exclude").and(include("/modules/[^/]*/templates/.*$")))
 
       Puppet::Util::RDoc.rdoc("myoutputdir", [])
     end
 
     it "should give all the source directories to RDoc" do
-      @rdoc.expects(:document).with { |args| args.include?("sourcedir") }
+      expect(@rdoc).to receive(:document).with(include("sourcedir"))
 
       Puppet::Util::RDoc.rdoc("output", ["sourcedir"])
     end

data/spec/unit/util/reference_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/util/reference'
 

data/spec/unit/util/resource_template_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/resource_template'
@@ -6,51 +5,52 @@ require 'puppet/util/resource_template'
 describe Puppet::Util::ResourceTemplate do
   describe "when initializing" do
     it "should fail if the template does not exist" do
-      Puppet::FileSystem.expects(:exist?).with("/my/template").returns false
-      expect { Puppet::Util::ResourceTemplate.new("/my/template", mock('resource')) }.to raise_error(ArgumentError)
+      expect(Puppet::FileSystem).to receive(:exist?).with("/my/template").and_return(false)
+      expect { Puppet::Util::ResourceTemplate.new("/my/template", double('resource')) }.to raise_error(ArgumentError)
     end
 
     it "should not create the ERB template" do
-      ERB.expects(:new).never
-      Puppet::FileSystem.expects(:exist?).with("/my/template").returns true
-      Puppet::Util::ResourceTemplate.new("/my/template", mock('resource'))
+      expect(ERB).not_to receive(:new)
+      expect(Puppet::FileSystem).to receive(:exist?).with("/my/template").and_return(true)
+      Puppet::Util::ResourceTemplate.new("/my/template", double('resource'))
     end
   end
 
   describe "when evaluating" do
     before do
-      Puppet::FileSystem.stubs(:exist?).returns true
-      Puppet::FileSystem.stubs(:read).returns "eh"
+      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
+      allow(Puppet::FileSystem).to receive(:read).and_return("eh")
 
-      @template = stub 'template', :result => nil
-      ERB.stubs(:new).returns @template
+      @template = double('template', :result => nil)
+      allow(ERB).to receive(:new).and_return(@template)
 
-      @resource = mock 'resource'
+      @resource = double('resource')
       @wrapper = Puppet::Util::ResourceTemplate.new("/my/template", @resource)
     end
 
     it "should set all of the resource's parameters as instance variables" do
-      @resource.expects(:to_hash).returns(:one => "uno", :two => "dos")
-      @template.expects(:result).with do |bind|
-        eval("@one", bind) == "uno" and eval("@two", bind) == "dos"
+      expect(@resource).to receive(:to_hash).and_return(:one => "uno", :two => "dos")
+      expect(@template).to receive(:result) do |bind|
+        expect(eval("@one", bind)).to eq("uno")
+        expect(eval("@two", bind)).to eq("dos")
       end
       @wrapper.evaluate
     end
 
     it "should create a template instance with the contents of the file" do
-      Puppet::FileSystem.expects(:read).with("/my/template", :encoding => 'utf-8').returns "yay"
-      ERB.expects(:new).with("yay", 0, "-").returns(@template)
+      expect(Puppet::FileSystem).to receive(:read).with("/my/template", :encoding => 'utf-8').and_return("yay")
+      expect(ERB).to receive(:new).with("yay", 0, "-").and_return(@template)
 
-      @wrapper.stubs :set_resource_variables
+      allow(@wrapper).to receive(:set_resource_variables)
 
       @wrapper.evaluate
     end
 
     it "should return the result of the template" do
-      @wrapper.stubs :set_resource_variables
+      allow(@wrapper).to receive(:set_resource_variables)
 
-      @wrapper.expects(:binding).returns "mybinding"
-      @template.expects(:result).with("mybinding").returns "myresult"
+      expect(@wrapper).to receive(:binding).and_return("mybinding")
+      expect(@template).to receive(:result).with("mybinding").and_return("myresult")
       expect(@wrapper.evaluate).to eq("myresult")
     end
   end

data/spec/unit/util/retry_action_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/retry_action'
@@ -23,8 +22,8 @@ describe Puppet::Util::RetryAction do
   end
 
   it 'should retry on any exception if no acceptable exceptions given' do
-    Puppet::Util::RetryAction.expects(:sleep).with( (((2 ** 1) -1) * 0.1) )
-    Puppet::Util::RetryAction.expects(:sleep).with( (((2 ** 2) -1) * 0.1) )
+    expect(Puppet::Util::RetryAction).to receive(:sleep).with( (((2 ** 1) -1) * 0.1) )
+    expect(Puppet::Util::RetryAction).to receive(:sleep).with( (((2 ** 2) -1) * 0.1) )
 
     expect do
       Puppet::Util::RetryAction.retry_action( :retries => 2 ) do
@@ -34,8 +33,8 @@ describe Puppet::Util::RetryAction do
   end
 
   it 'should retry on acceptable exceptions' do
-    Puppet::Util::RetryAction.expects(:sleep).with( (((2 ** 1) -1) * 0.1) )
-    Puppet::Util::RetryAction.expects(:sleep).with( (((2 ** 2) -1) * 0.1) )
+    expect(Puppet::Util::RetryAction).to receive(:sleep).with( (((2 ** 1) -1) * 0.1) )
+    expect(Puppet::Util::RetryAction).to receive(:sleep).with( (((2 ** 2) -1) * 0.1) )
 
     expect do
       Puppet::Util::RetryAction.retry_action( :retries => 2, :retry_exceptions => exceptions) do
@@ -45,7 +44,7 @@ describe Puppet::Util::RetryAction do
   end
 
   it 'should not retry on unacceptable exceptions' do
-    Puppet::Util::RetryAction.expects(:sleep).never
+    expect(Puppet::Util::RetryAction).not_to receive(:sleep)
 
     expect do
       Puppet::Util::RetryAction.retry_action( :retries => 2, :retry_exceptions => exceptions) do
@@ -55,7 +54,7 @@ describe Puppet::Util::RetryAction do
   end
 
   it 'should succeed if nothing is raised' do
-    Puppet::Util::RetryAction.expects(:sleep).never
+    expect(Puppet::Util::RetryAction).not_to receive(:sleep)
 
     Puppet::Util::RetryAction.retry_action( :retries => 2) do
       true
@@ -64,7 +63,7 @@ describe Puppet::Util::RetryAction do
 
   it 'should succeed if an expected exception is raised retried and succeeds' do
     should_retry = nil
-    Puppet::Util::RetryAction.expects(:sleep).once
+    expect(Puppet::Util::RetryAction).to receive(:sleep).once
 
     Puppet::Util::RetryAction.retry_action( :retries => 2, :retry_exceptions => exceptions) do
       if should_retry

data/spec/unit/util/rubygems_spec.rb

@@ -4,29 +4,29 @@ require 'puppet/util/rubygems'
 describe Puppet::Util::RubyGems::Source do
   let(:gem_path) { File.expand_path('/foo/gems') }
   let(:gem_lib) { File.join(gem_path, 'lib') }
-  let(:fake_gem) { stub(:full_gem_path => gem_path) }
+  let(:fake_gem) { double(:full_gem_path => gem_path) }
 
   describe "::new" do
     it "returns NoGemsSource if rubygems is not present" do
-      described_class.expects(:has_rubygems?).returns(false)
+      expect(described_class).to receive(:has_rubygems?).and_return(false)
       expect(described_class.new).to be_kind_of(Puppet::Util::RubyGems::NoGemsSource)
     end
 
     it "returns Gems18Source if Gem::Specification responds to latest_specs" do
-      described_class.expects(:has_rubygems?).returns(true)
-      Gem::Specification.expects(:respond_to?).with(:latest_specs).returns(true)
+      expect(described_class).to receive(:has_rubygems?).and_return(true)
+      expect(Gem::Specification).to receive(:respond_to?).with(:latest_specs).and_return(true)
       expect(described_class.new).to be_kind_of(Puppet::Util::RubyGems::Gems18Source)
     end
 
     it "returns Gems18Source if Gem::Specification does not respond to latest_specs" do
-      described_class.expects(:has_rubygems?).returns(true)
-      Gem::Specification.expects(:respond_to?).with(:latest_specs).returns(false)
+      expect(described_class).to receive(:has_rubygems?).and_return(true)
+      expect(Gem::Specification).to receive(:respond_to?).with(:latest_specs).and_return(false)
       expect(described_class.new).to be_kind_of(Puppet::Util::RubyGems::OldGemsSource)
     end
   end
 
   describe '::NoGemsSource' do
-    before(:each) { described_class.stubs(:source).returns(Puppet::Util::RubyGems::NoGemsSource) }
+    before(:each) { allow(described_class).to receive(:source).and_return(Puppet::Util::RubyGems::NoGemsSource) }
 
     it "#directories returns an empty list" do
       expect(described_class.new.directories).to eq([])
@@ -38,25 +38,25 @@ describe Puppet::Util::RubyGems::Source do
   end
 
   describe '::Gems18Source' do
-    before(:each) { described_class.stubs(:source).returns(Puppet::Util::RubyGems::Gems18Source) }
+    before(:each) { allow(described_class).to receive(:source).and_return(Puppet::Util::RubyGems::Gems18Source) }
 
     it "#directories returns the lib subdirs of Gem::Specification.latest_specs" do
-      Gem::Specification.expects(:latest_specs).with(true).returns([fake_gem])
+      expect(Gem::Specification).to receive(:latest_specs).with(true).and_return([fake_gem])
 
       expect(described_class.new.directories).to eq([gem_lib])
     end
 
     it "#clear_paths calls Gem.clear_paths" do
-      Gem.expects(:clear_paths)
+      expect(Gem).to receive(:clear_paths)
       described_class.new.clear_paths
     end
   end
 
   describe '::OldGemsSource' do
-    before(:each) { described_class.stubs(:source).returns(Puppet::Util::RubyGems::OldGemsSource) }
+    before(:each) { allow(described_class).to receive(:source).and_return(Puppet::Util::RubyGems::OldGemsSource) }
 
     it "#directories returns the contents of Gem.latest_load_paths" do
-      Gem.expects(:latest_load_paths).returns([gem_lib])
+      expect(Gem).to receive(:latest_load_paths).and_return([gem_lib])
 
       expect(described_class.new.directories).to eq([gem_lib])
     end
@@ -66,7 +66,7 @@ describe Puppet::Util::RubyGems::Source do
     # set of results we don't trigger this bug. This behavior was seen on ruby 1.8.7-p334
     # using rubygems v1.6.2
     it "caches the gem paths (works around a bug in older rubygems)" do
-      Gem.expects(:latest_load_paths).returns([gem_lib]).once
+      expect(Gem).to receive(:latest_load_paths).and_return([gem_lib]).once
 
       source = described_class.new
 
@@ -74,7 +74,7 @@ describe Puppet::Util::RubyGems::Source do
     end
 
     it "#clear_paths calls Gem.clear_paths" do
-      Gem.expects(:clear_paths)
+      expect(Gem).to receive(:clear_paths)
       described_class.new.clear_paths
     end
   end

data/spec/unit/util/run_mode_spec.rb

@@ -1,8 +1,6 @@
-#! /usr/bin/env ruby
 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
@@ -31,6 +29,7 @@ describe Puppet::Util::RunMode do
         before do
           @run_mode = Puppet::Util::UnixRunMode.new('master')
         end
+
         it "has confdir ~/.puppetlabs/etc/puppet when run as non-root and master run mode" do
           as_non_root { expect(@run_mode.conf_dir).to eq(File.expand_path('~/.puppetlabs/etc/puppet')) }
         end
@@ -295,12 +294,12 @@ describe Puppet::Util::RunMode do
   end
 
   def as_root
-    Puppet.features.stubs(:root?).returns(true)
+    allow(Puppet.features).to receive(:root?).and_return(true)
     yield
   end
 
   def as_non_root
-    Puppet.features.stubs(:root?).returns(false)
+    allow(Puppet.features).to receive(:root?).and_return(false)
     yield
   end
 

data/spec/unit/util/selinux_spec.rb

@@ -1,9 +1,7 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'pathname'
 require 'puppet/util/selinux'
-include Puppet::Util::SELinux
 
 unless defined?(Selinux)
   module Selinux
@@ -14,35 +12,42 @@ unless defined?(Selinux)
 end
 
 describe Puppet::Util::SELinux do
+  include Puppet::Util::SELinux
 
   describe "selinux_support?" do
-    before do
-    end
     it "should return :true if this system has SELinux enabled" do
-      Selinux.expects(:is_selinux_enabled).returns 1
+      expect(Selinux).to receive(:is_selinux_enabled).and_return(1)
       expect(selinux_support?).to be_truthy
     end
 
     it "should return :false if this system lacks SELinux" do
-      Selinux.expects(:is_selinux_enabled).returns 0
+      expect(Selinux).to receive(:is_selinux_enabled).and_return(0)
       expect(selinux_support?).to be_falsey
     end
 
     it "should return nil if /proc/mounts does not exist" do
-      File.stubs(:open).with("/proc/mounts").raises("No such file or directory - /proc/mounts")
+      allow(File).to receive(:open).with("/proc/mounts").and_raise("No such file or directory - /proc/mounts")
       expect(read_mounts).to eq(nil)
     end
   end
 
   describe "read_mounts" do
     before :each do
-      fh = stub 'fh', :close => nil
-      File.stubs(:open).with("/proc/mounts").returns fh
-      fh.expects(:read_nonblock).times(2).returns("rootfs / rootfs rw 0 0\n/dev/root / ext3 rw,relatime,errors=continue,user_xattr,acl,data=ordered 0 0\n/dev /dev tmpfs rw,relatime,mode=755 0 0\n/proc /proc proc rw,relatime 0 0\n/sys /sys sysfs rw,relatime 0 0\n192.168.1.1:/var/export /mnt/nfs nfs rw,relatime,vers=3,rsize=32768,wsize=32768,namlen=255,hard,nointr,proto=tcp,timeo=600,retrans=2,sec=sys,mountaddr=192.168.1.1,mountvers=3,mountproto=udp,addr=192.168.1.1 0 0\n").then.raises EOFError
+      fh = double('fh', :close => nil)
+      allow(File).to receive(:open).and_call_original()
+      allow(File).to receive(:open).with("/proc/mounts").and_return(fh)
+      times_fh_called = 0
+      expect(fh).to receive(:read_nonblock) do
+        times_fh_called += 1
+        raise EOFError if times_fh_called > 1
+
+        "rootfs / rootfs rw 0 0\n/dev/root / ext3 rw,relatime,errors=continue,user_xattr,acl,data=ordered 0 0\n/dev /dev tmpfs rw,relatime,mode=755 0 0\n/proc /proc proc rw,relatime 0 0\n/sys /sys sysfs rw,relatime 0 0\n192.168.1.1:/var/export /mnt/nfs nfs rw,relatime,vers=3,rsize=32768,wsize=32768,namlen=255,hard,nointr,proto=tcp,timeo=600,retrans=2,sec=sys,mountaddr=192.168.1.1,mountvers=3,mountproto=udp,addr=192.168.1.1 0 0\n"
+      end.twice()
     end
 
     it "should parse the contents of /proc/mounts" do
-      expect(read_mounts).to  eq({
+      result = read_mounts
+      expect(result).to  eq({
         '/' => 'ext3',
         '/sys' => 'sysfs',
         '/mnt/nfs' => 'nfs',
@@ -53,7 +58,7 @@ describe Puppet::Util::SELinux do
 
   describe "filesystem detection" do
     before :each do
-      self.stubs(:read_mounts).returns({
+      allow(self).to receive(:read_mounts).and_return({
         '/'        => 'ext3',
         '/sys'     => 'sysfs',
         '/mnt/nfs' => 'nfs',
@@ -84,10 +89,10 @@ describe Puppet::Util::SELinux do
     it "(#8714) don't follow symlinks when determining file systems", :unless => Puppet.features.microsoft_windows? do
       scratch = Pathname(PuppetSpec::Files.tmpdir('selinux'))
 
-      self.stubs(:read_mounts).returns({
-          '/'             => 'ext3',
-          scratch + 'nfs' => 'nfs',
-        })
+      allow(self).to receive(:read_mounts).and_return({
+        '/'             => 'ext3',
+        scratch + 'nfs' => 'nfs',
+      })
 
       (scratch + 'foo').make_symlink('nfs/bar')
       expect(selinux_label_support?(scratch + 'foo')).to be_truthy
@@ -101,73 +106,72 @@ describe Puppet::Util::SELinux do
 
   describe "get_selinux_current_context" do
     it "should return nil if no SELinux support" do
-      self.expects(:selinux_support?).returns false
+      expect(self).to receive(:selinux_support?).and_return(false)
       expect(get_selinux_current_context("/foo")).to be_nil
     end
 
     it "should return a context" do
-      self.expects(:selinux_support?).returns true
-      Selinux.expects(:lgetfilecon).with("/foo").returns [0, "user_u:role_r:type_t:s0"]
+      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
-      self.expects(:selinux_support?).returns true
-      Selinux.expects(:lgetfilecon).with("/foo").returns(-1)
+      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
 
   describe "get_selinux_default_context" do
     it "should return nil if no SELinux support" do
-      self.expects(:selinux_support?).returns false
+      expect(self).to receive(:selinux_support?).and_return(false)
       expect(get_selinux_default_context("/foo")).to be_nil
     end
 
     it "should return a context if a default context exists" do
-      self.expects(:selinux_support?).returns true
-      fstat = stub 'File::Stat', :mode => 0
-      Puppet::FileSystem.expects(:lstat).with('/foo').returns(fstat)
-      self.expects(:find_fs).with("/foo").returns "ext3"
-      Selinux.expects(:matchpathcon).with("/foo", 0).returns [0, "user_u:role_r:type_t:s0"]
+      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
 
     it "handles permission denied errors by issuing a warning" do
-      self.stubs(:selinux_support?).returns true
-      self.stubs(:selinux_label_support?).returns true
-      Selinux.stubs(:matchpathcon).with("/root/chuj", 0).returns(-1)
-      self.stubs(:file_lstat).with("/root/chuj").raises(Errno::EACCES, "/root/chuj")
+      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
 
     it "handles no such file or directory errors by issuing a warning" do
-      self.stubs(:selinux_support?).returns true
-      self.stubs(:selinux_label_support?).returns true
-      Selinux.stubs(:matchpathcon).with("/root/chuj", 0).returns(-1)
-      self.stubs(:file_lstat).with("/root/chuj").raises(Errno::ENOENT, "/root/chuj")
+      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
 
     it "should return nil if matchpathcon returns failure" do
-      self.expects(:selinux_support?).returns true
-      fstat = stub 'File::Stat', :mode => 0
-      Puppet::FileSystem.expects(:lstat).with('/foo').returns(fstat)
-      self.expects(:find_fs).with("/foo").returns "ext3"
-      Selinux.expects(:matchpathcon).with("/foo", 0).returns(-1)
+      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
-      self.expects(:selinux_support?).returns true
-      self.expects(:find_fs).with("/foo").returns "nfs"
+      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
 
   describe "parse_selinux_context" do
@@ -232,84 +236,87 @@ describe Puppet::Util::SELinux do
 
   describe "set_selinux_context" do
     before :each do
-      fh = stub 'fh', :close => nil
-      File.stubs(:open).with("/proc/mounts").returns fh
-      fh.stubs(:read_nonblock).returns(
+      fh = double('fh', :close => nil)
+      allow(File).to receive(:open).with("/proc/mounts").and_return(fh)
+      times_fh_called = 0
+      allow(fh).to receive(:read_nonblock) do
+        times_fh_called += 1
+        raise EOFError if times_fh_called > 1
+
         "rootfs / rootfs rw 0 0\n/dev/root / ext3 rw,relatime,errors=continue,user_xattr,acl,data=ordered 0 0\n"+
         "/dev /dev tmpfs rw,relatime,mode=755 0 0\n/proc /proc proc rw,relatime 0 0\n"+
         "/sys /sys sysfs rw,relatime 0 0\n"
-        ).then.raises EOFError
+      end
     end
 
     it "should return nil if there is no SELinux support" do
-      self.expects(:selinux_support?).returns false
+      expect(self).to receive(:selinux_support?).and_return(false)
       expect(set_selinux_context("/foo", "user_u:role_r:type_t:s0")).to be_nil
     end
 
     it "should return nil if selinux_label_support returns false" do
-      self.expects(:selinux_support?).returns true
-      self.expects(:selinux_label_support?).with("/foo").returns false
+      expect(self).to receive(:selinux_support?).and_return(true)
+      expect(self).to receive(:selinux_label_support?).with("/foo").and_return(false)
       expect(set_selinux_context("/foo", "user_u:role_r:type_t:s0")).to be_nil
     end
 
     it "should use lsetfilecon to set a context" do
-      self.expects(:selinux_support?).returns true
-      Selinux.expects(:lsetfilecon).with("/foo", "user_u:role_r:type_t:s0").returns 0
+      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
-      self.expects(:selinux_support?).returns true
-      Selinux.expects(:lgetfilecon).with("/foo").returns [0, "foo:role_r:type_t:s0"]
-      Selinux.expects(:lsetfilecon).with("/foo", "user_u:role_r:type_t:s0").returns 0
+      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
-      self.expects(:selinux_support?).returns true
-      Selinux.expects(:lgetfilecon).with("/foo").returns [0, "user_u:foo:type_t:s0"]
-      Selinux.expects(:lsetfilecon).with("/foo", "user_u:role_r:type_t:s0").returns 0
+      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
-      self.expects(:selinux_support?).returns true
-      Selinux.expects(:lgetfilecon).with("/foo").returns [0, "user_u:role_r:foo:s0"]
-      Selinux.expects(:lsetfilecon).with("/foo", "user_u:role_r:type_t:s0").returns 0
+      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
-      self.expects(:selinux_support?).returns true
-      Selinux.expects(:lgetfilecon).with("/foo").returns [0, "user_u:role_r:type_t:s0"]
-      Selinux.expects(:lsetfilecon).with("/foo", "user_u:role_r:type_t:s0:c3,c5").returns 0
+      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
 
   describe "set_selinux_default_context" do
     it "should return nil if there is no SELinux support" do
-      self.expects(:selinux_support?).returns false
+      expect(self).to receive(:selinux_support?).and_return(false)
       expect(set_selinux_default_context("/foo")).to be_nil
     end
 
     it "should return nil if no default context exists" do
-      self.expects(:get_selinux_default_context).with("/foo").returns 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
-      self.expects(:get_selinux_default_context).with("/foo").returns "user_u:role_r:type_t"
-      self.expects(:get_selinux_current_context).with("/foo").returns "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
-      self.expects(:get_selinux_default_context).with("/foo").returns "user_u:role_r:type_t"
-      self.expects(:get_selinux_current_context).with("/foo").returns "olduser_u:role_r:type_t"
-      self.expects(:set_selinux_context).with("/foo", "user_u:role_r:type_t").returns true
+      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
-
 end