puppet 6.0.10-x64-mingw32 → 6.1.0-x64-mingw32

data/spec/unit/util/rdoc_spec.rb

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

data/spec/unit/util/reference_spec.rb

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

data/spec/unit/util/resource_template_spec.rb

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

data/spec/unit/util/retry_action_spec.rb

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

data/spec/unit/util/rubygems_spec.rb

@@ -4,22 +4,22 @@ 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) { double(:full_gem_path => gem_path) }
+  let(:fake_gem) { stub(:full_gem_path => gem_path) }
 
   describe "::new" do
     it "returns NoGemsSource if rubygems is not present" do
-      expect(described_class).to receive(:has_rubygems?).and_return(false)
+      described_class.expects(:has_rubygems?).returns(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
-      expect(described_class).to receive(:has_rubygems?).and_return(true)
+      described_class.expects(:has_rubygems?).returns(true)
       expect(described_class.new).to be_kind_of(Puppet::Util::RubyGems::Gems18Source)
     end
   end
 
   describe '::NoGemsSource' do
-    before(:each) { allow(described_class).to receive(:source).and_return(Puppet::Util::RubyGems::NoGemsSource) }
+    before(:each) { described_class.stubs(:source).returns(Puppet::Util::RubyGems::NoGemsSource) }
 
     it "#directories returns an empty list" do
       expect(described_class.new.directories).to eq([])
@@ -31,17 +31,18 @@ describe Puppet::Util::RubyGems::Source do
   end
 
   describe '::Gems18Source' do
-    before(:each) { allow(described_class).to receive(:source).and_return(Puppet::Util::RubyGems::Gems18Source) }
+    before(:each) { described_class.stubs(:source).returns(Puppet::Util::RubyGems::Gems18Source) }
 
     it "#directories returns the lib subdirs of Gem::Specification.latest_specs" do
-      expect(Gem::Specification).to receive(:latest_specs).with(true).and_return([fake_gem])
+      Gem::Specification.expects(:latest_specs).with(true).returns([fake_gem])
 
       expect(described_class.new.directories).to eq([gem_lib])
     end
 
     it "#clear_paths calls Gem.clear_paths" do
-      expect(Gem).to receive(:clear_paths)
+      Gem.expects(:clear_paths)
       described_class.new.clear_paths
     end
   end
 end
+

data/spec/unit/util/run_mode_spec.rb

@@ -1,6 +1,8 @@
+#! /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
@@ -29,7 +31,6 @@ 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
@@ -294,12 +295,12 @@ describe Puppet::Util::RunMode do
   end
 
   def as_root
-    allow(Puppet.features).to receive(:root?).and_return(true)
+    Puppet.features.stubs(:root?).returns(true)
     yield
   end
 
   def as_non_root
-    allow(Puppet.features).to receive(:root?).and_return(false)
+    Puppet.features.stubs(:root?).returns(false)
     yield
   end
 

data/spec/unit/util/selinux_spec.rb

@@ -1,7 +1,9 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'pathname'
 require 'puppet/util/selinux'
+include Puppet::Util::SELinux
 
 unless defined?(Selinux)
   module Selinux
@@ -12,42 +14,35 @@ 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
-      expect(Selinux).to receive(:is_selinux_enabled).and_return(1)
+      Selinux.expects(:is_selinux_enabled).returns 1
       expect(selinux_support?).to be_truthy
     end
 
     it "should return :false if this system lacks SELinux" do
-      expect(Selinux).to receive(:is_selinux_enabled).and_return(0)
+      Selinux.expects(:is_selinux_enabled).returns 0
       expect(selinux_support?).to be_falsey
     end
 
     it "should return nil if /proc/mounts does not exist" do
-      allow(File).to receive(:open).with("/proc/mounts").and_raise("No such file or directory - /proc/mounts")
+      File.stubs(:open).with("/proc/mounts").raises("No such file or directory - /proc/mounts")
       expect(read_mounts).to eq(nil)
     end
   end
 
   describe "read_mounts" do
     before :each do
-      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()
+      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
     end
 
     it "should parse the contents of /proc/mounts" do
-      result = read_mounts
-      expect(result).to  eq({
+      expect(read_mounts).to  eq({
         '/' => 'ext3',
         '/sys' => 'sysfs',
         '/mnt/nfs' => 'nfs',
@@ -58,7 +53,7 @@ describe Puppet::Util::SELinux do
 
   describe "filesystem detection" do
     before :each do
-      allow(self).to receive(:read_mounts).and_return({
+      self.stubs(:read_mounts).returns({
         '/'        => 'ext3',
         '/sys'     => 'sysfs',
         '/mnt/nfs' => 'nfs',
@@ -89,10 +84,10 @@ describe Puppet::Util::SELinux do
     it "(#8714) don't follow symlinks when determining file systems", :unless => Puppet::Util::Platform.windows? do
       scratch = Pathname(PuppetSpec::Files.tmpdir('selinux'))
 
-      allow(self).to receive(:read_mounts).and_return({
-        '/'             => 'ext3',
-        scratch + 'nfs' => 'nfs',
-      })
+      self.stubs(:read_mounts).returns({
+          '/'             => 'ext3',
+          scratch + 'nfs' => 'nfs',
+        })
 
       (scratch + 'foo').make_symlink('nfs/bar')
       expect(selinux_label_support?(scratch + 'foo')).to be_truthy
@@ -106,72 +101,73 @@ describe Puppet::Util::SELinux do
 
   describe "get_selinux_current_context" do
     it "should return nil if no SELinux support" do
-      expect(self).to receive(:selinux_support?).and_return(false)
+      self.expects(:selinux_support?).returns false
       expect(get_selinux_current_context("/foo")).to be_nil
     end
 
     it "should return a context" 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"])
+      self.expects(:selinux_support?).returns true
+      Selinux.expects(:lgetfilecon).with("/foo").returns [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
-      expect(self).to receive(:selinux_support?).and_return(true)
-      expect(Selinux).to receive(:lgetfilecon).with("/foo").and_return(-1)
+      self.expects(:selinux_support?).returns true
+      Selinux.expects(:lgetfilecon).with("/foo").returns(-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
-      expect(self).to receive(:selinux_support?).and_return(false)
+      self.expects(:selinux_support?).returns false
       expect(get_selinux_default_context("/foo")).to be_nil
     end
 
     it "should return a context if a default context exists" 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"])
+      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(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
-      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")
+      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")
 
       expect(get_selinux_default_context("/root/chuj")).to be_nil
     end
 
     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")
+      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")
 
       expect(get_selinux_default_context("/root/chuj")).to be_nil
     end
 
     it "should return nil if matchpathcon returns failure" 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)
+      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(get_selinux_default_context("/foo")).to be_nil
     end
 
     it "should return nil if selinux_label_support returns false" do
-      expect(self).to receive(:selinux_support?).and_return(true)
-      expect(self).to receive(:find_fs).with("/foo").and_return("nfs")
+      self.expects(:selinux_support?).returns true
+      self.expects(:find_fs).with("/foo").returns "nfs"
       expect(get_selinux_default_context("/foo")).to be_nil
     end
+
   end
 
   describe "parse_selinux_context" do
@@ -236,87 +232,84 @@ describe Puppet::Util::SELinux do
 
   describe "set_selinux_context" do
     before :each do
-      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
-
+      fh = stub 'fh', :close => nil
+      File.stubs(:open).with("/proc/mounts").returns fh
+      fh.stubs(:read_nonblock).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\n"
-      end
+        ).then.raises EOFError
     end
 
     it "should return nil if there is no SELinux support" do
-      expect(self).to receive(:selinux_support?).and_return(false)
+      self.expects(:selinux_support?).returns 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
-      expect(self).to receive(:selinux_support?).and_return(true)
-      expect(self).to receive(:selinux_label_support?).with("/foo").and_return(false)
+      self.expects(:selinux_support?).returns true
+      self.expects(:selinux_label_support?).with("/foo").returns 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
-      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)
+      self.expects(:selinux_support?).returns true
+      Selinux.expects(:lsetfilecon).with("/foo", "user_u:role_r:type_t:s0").returns 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
-      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)
+      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(set_selinux_context("/foo", "user_u", :seluser)).to be_truthy
     end
 
     it "should use lsetfilecon to set role_r role context" 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)
+      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(set_selinux_context("/foo", "role_r", :selrole)).to be_truthy
     end
 
     it "should use lsetfilecon to set type_t type context" 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)
+      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(set_selinux_context("/foo", "type_t", :seltype)).to be_truthy
     end
 
     it "should use lsetfilecon to set s0:c3,c5 range context" 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)
+      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(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
-      expect(self).to receive(:selinux_support?).and_return(false)
+      self.expects(:selinux_support?).returns false
       expect(set_selinux_default_context("/foo")).to be_nil
     end
 
     it "should return nil if no default context exists" do
-      expect(self).to receive(:get_selinux_default_context).with("/foo").and_return(nil)
+      self.expects(:get_selinux_default_context).with("/foo").returns 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").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")
+      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(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").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)
+      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(set_selinux_default_context("/foo")).to eq("user_u:role_r:type_t")
     end
   end
+
 end