puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

data/spec/unit/util/reference_spec.rb

@@ -21,7 +21,7 @@ describe Puppet::Util::Reference do
       my_fragment = markdown_definitionlist(my_term, my_definition)
     end
     Puppet::Util::Reference.reference(:testreference).send(:to_markdown, true)
-    my_fragment.should == <<-EOT
+    expect(my_fragment).to eq <<-EOT
 A term
 : The definition of this term, marked by a colon and a space.
   We should be able to handle multi-line definitions. Each subsequent

data/spec/unit/util/resource_template_spec.rb

@@ -7,7 +7,7 @@ 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
-      lambda { Puppet::Util::ResourceTemplate.new("/my/template", mock('resource')) }.should raise_error(ArgumentError)
+      expect { Puppet::Util::ResourceTemplate.new("/my/template", mock('resource')) }.to raise_error(ArgumentError)
     end
 
     it "should not create the ERB template" do
@@ -51,7 +51,7 @@ describe Puppet::Util::ResourceTemplate do
 
       @wrapper.expects(:binding).returns "mybinding"
       @template.expects(:result).with("mybinding").returns "myresult"
-      @wrapper.evaluate.should == "myresult"
+      expect(@wrapper.evaluate).to eq("myresult")
     end
   end
 end

data/spec/unit/util/{retryaction_spec.rb → retry_action_spec.rb}

@@ -1,10 +1,26 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
-require 'puppet/util/retryaction'
+require 'puppet/util/retry_action'
 
 describe Puppet::Util::RetryAction do
-  let (:exceptions) {{ Puppet::Error => 'Puppet Error Exception' }}
+  let (:exceptions) { [ Puppet::Error, NameError ] }
+
+  it "doesn't retry SystemExit" do
+    expect do
+      Puppet::Util::RetryAction.retry_action( :retries => 0 ) do
+        raise SystemExit
+      end
+    end.to exit_with(0)
+  end
+
+  it "doesn't retry NoMemoryError" do
+    expect do
+      Puppet::Util::RetryAction.retry_action( :retries => 0 ) do
+        raise NoMemoryError, "OOM"
+      end
+    end.to raise_error(NoMemoryError, /OOM/)
+  end
 
   it 'should retry on any exception if no acceptable exceptions given' do
     Puppet::Util::RetryAction.expects(:sleep).with( (((2 ** 1) -1) * 0.1) )
@@ -59,4 +75,11 @@ describe Puppet::Util::RetryAction do
       end
     end
   end
+
+  it "doesn't mutate caller's arguments" do
+    options = { :retries => 1 }.freeze
+
+    Puppet::Util::RetryAction.retry_action(options) do
+    end
+  end
 end

data/spec/unit/util/rubygems_spec.rb

@@ -9,19 +9,19 @@ describe Puppet::Util::RubyGems::Source do
   describe "::new" do
     it "returns NoGemsSource if rubygems is not present" do
       described_class.expects(:has_rubygems?).returns(false)
-      described_class.new.should be_kind_of(Puppet::Util::RubyGems::NoGemsSource)
+      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)
-      described_class.new.should be_kind_of(Puppet::Util::RubyGems::Gems18Source)
+      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)
-      described_class.new.should be_kind_of(Puppet::Util::RubyGems::OldGemsSource)
+      expect(described_class.new).to be_kind_of(Puppet::Util::RubyGems::OldGemsSource)
     end
   end
 
@@ -29,11 +29,11 @@ describe Puppet::Util::RubyGems::Source do
     before(:each) { described_class.stubs(:source).returns(Puppet::Util::RubyGems::NoGemsSource) }
 
     it "#directories returns an empty list" do
-      described_class.new.directories.should == []
+      expect(described_class.new.directories).to eq([])
     end
 
     it "#clear_paths returns nil" do
-      described_class.new.clear_paths.should be_nil
+      expect(described_class.new.clear_paths).to be_nil
     end
   end
 
@@ -43,7 +43,7 @@ describe Puppet::Util::RubyGems::Source do
     it "#directories returns the lib subdirs of Gem::Specification.latest_specs" do
       Gem::Specification.expects(:latest_specs).with(true).returns([fake_gem])
 
-      described_class.new.directories.should == [gem_lib]
+      expect(described_class.new.directories).to eq([gem_lib])
     end
 
     it "#clear_paths calls Gem.clear_paths" do
@@ -58,7 +58,7 @@ describe Puppet::Util::RubyGems::Source do
     it "#directories returns the contents of Gem.latest_load_paths" do
       Gem.expects(:latest_load_paths).returns([gem_lib])
 
-      described_class.new.directories.should == [gem_lib]
+      expect(described_class.new.directories).to eq([gem_lib])
     end
 
     # Older rubygems seem to have a problem with rescanning the gem paths in which they
@@ -70,7 +70,7 @@ describe Puppet::Util::RubyGems::Source do
 
       source = described_class.new
 
-      source.directories.should == [gem_lib]
+      expect(source.directories).to eq([gem_lib])
     end
 
     it "#clear_paths calls Gem.clear_paths" do

data/spec/unit/util/run_mode_spec.rb

@@ -6,22 +6,18 @@ describe Puppet::Util::RunMode do
     @run_mode = Puppet::Util::RunMode.new('fake')
   end
 
-  it "has rundir depend on vardir" do
-    @run_mode.run_dir.should == '$vardir/run'
-  end
-
   describe Puppet::Util::UnixRunMode, :unless => Puppet.features.microsoft_windows? do
     before do
       @run_mode = Puppet::Util::UnixRunMode.new('fake')
     end
 
     describe "#conf_dir" do
-      it "has confdir /etc/puppet when run as root" do
-        as_root { @run_mode.conf_dir.should == File.expand_path('/etc/puppet') }
+      it "has confdir /etc/puppetlabs/puppet when run as root" do
+        as_root { expect(@run_mode.conf_dir).to eq(File.expand_path('/etc/puppetlabs/puppet')) }
       end
 
       it "has confdir ~/.puppet when run as non-root" do
-        as_non_root { @run_mode.conf_dir.should == File.expand_path('~/.puppet') }
+        as_non_root { expect(@run_mode.conf_dir).to eq(File.expand_path('~/.puppet')) }
       end
 
       context "master run mode" do
@@ -29,7 +25,7 @@ describe Puppet::Util::RunMode do
           @run_mode = Puppet::Util::UnixRunMode.new('master')
         end
         it "has confdir ~/.puppet when run as non-root and master run mode (#16337)" do
-          as_non_root { @run_mode.conf_dir.should == File.expand_path('~/.puppet') }
+          as_non_root { expect(@run_mode.conf_dir).to eq(File.expand_path('~/.puppet')) }
         end
       end
 
@@ -42,13 +38,41 @@ describe Puppet::Util::RunMode do
       end
     end
 
+    describe "#code_dir" do
+      it "has codedir /etc/puppetlabs/code when run as root" do
+        as_root { expect(@run_mode.code_dir).to eq(File.expand_path('/etc/puppetlabs/code')) }
+      end
+
+      it "has codedir ~/.puppet/code when run as non-root" do
+        as_non_root { expect(@run_mode.code_dir).to eq(File.expand_path('~/.puppet/code')) }
+      end
+
+      context "master run mode" do
+        before do
+          @run_mode = Puppet::Util::UnixRunMode.new('master')
+        end
+
+        it "has codedir ~/.puppet/code when run as non-root and master run mode" do
+          as_non_root { expect(@run_mode.code_dir).to eq(File.expand_path('~/.puppet/code')) }
+        end
+      end
+
+      it "fails when asking for the code_dir as non-root and there is no $HOME" 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
-      it "has vardir /var/lib/puppet when run as root" do
-        as_root { @run_mode.var_dir.should == File.expand_path('/var/lib/puppet') }
+      it "has vardir /opt/puppetlabs/puppet/cache when run as root" do
+        as_root { expect(@run_mode.var_dir).to eq(File.expand_path('/opt/puppetlabs/puppet/cache')) }
       end
 
       it "has vardir ~/.puppet/var when run as non-root" do
-        as_non_root { @run_mode.var_dir.should == File.expand_path('~/.puppet/var') }
+        as_non_root { expect(@run_mode.var_dir).to eq(File.expand_path('~/.puppet/var')) }
       end
 
       it "fails when asking for the var_dir as non-root and there is no $HOME" do
@@ -59,6 +83,50 @@ describe Puppet::Util::RunMode do
         end
       end
     end
+
+    describe "#log_dir" do
+      describe "when run as root" do
+        it "has logdir /var/log/puppetlabs" do
+          as_root { expect(@run_mode.log_dir).to eq(File.expand_path('/var/log/puppetlabs')) }
+        end
+      end
+
+      describe "when run as non-root" do
+        it "has default logdir ~/.puppet/var/log" do
+          as_non_root { expect(@run_mode.log_dir).to eq(File.expand_path('~/.puppet/var/log')) }
+        end
+
+        it "fails when asking for the log_dir and there is no $HOME" 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
+
+    describe "#run_dir" do
+      describe "when run as root" do
+        it "has rundir /var/run/puppetlabs" do
+          as_root { expect(@run_mode.run_dir).to eq(File.expand_path('/var/run/puppetlabs')) }
+        end
+      end
+
+      describe "when run as non-root" do
+        it "has default rundir ~/.puppet/var/run" do
+          as_non_root { expect(@run_mode.run_dir).to eq(File.expand_path('~/.puppet/var/run')) }
+        end
+
+        it "fails when asking for the run_dir and there is no $HOME" 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.features.microsoft_windows? do
@@ -77,12 +145,12 @@ describe Puppet::Util::RunMode do
     end
 
     describe "#conf_dir" do
-      it "has confdir /etc/puppet when run as root" do
-        as_root { @run_mode.conf_dir.should == File.expand_path(File.join(Dir::COMMON_APPDATA, "PuppetLabs", "puppet", "etc")) }
+      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"))) }
       end
 
       it "has confdir in ~/.puppet when run as non-root" do
-        as_non_root { @run_mode.conf_dir.should == File.expand_path("~/.puppet") }
+        as_non_root { expect(@run_mode.conf_dir).to eq(File.expand_path("~/.puppet")) }
       end
 
       it "fails when asking for the conf_dir as non-root and there is no %HOME%, %HOMEDRIVE%, and %USERPROFILE%" do
@@ -98,13 +166,35 @@ describe Puppet::Util::RunMode do
       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"))) }
+      end
+
+      it "has codedir in ~/.puppet/code when run as non-root" do
+        as_non_root { expect(@run_mode.code_dir).to eq(File.expand_path("~/.puppet/code")) }
+      end
+
+      it "fails when asking for the code_dir as non-root and there is no %HOME%, %HOMEDRIVE%, and %USERPROFILE%" 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 /var/lib/puppet when run as root" do
-        as_root { @run_mode.var_dir.should == File.expand_path(File.join(Dir::COMMON_APPDATA, "PuppetLabs", "puppet", "var")) }
+      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"))) }
       end
 
       it "has vardir in ~/.puppet/var when run as non-root" do
-        as_non_root { @run_mode.var_dir.should == File.expand_path("~/.puppet/var") }
+        as_non_root { expect(@run_mode.var_dir).to eq(File.expand_path("~/.puppet/var")) }
       end
 
       it "fails when asking for the conf_dir as non-root and there is no %HOME%, %HOMEDRIVE%, and %USERPROFILE%" do
@@ -119,6 +209,58 @@ describe Puppet::Util::RunMode do
         end
       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"))) }
+        end
+      end
+
+      describe "when run as non-root" do
+        it "has default logdir ~/.puppet/var/log" do
+          as_non_root { expect(@run_mode.log_dir).to eq(File.expand_path('~/.puppet/var/log')) }
+        end
+
+        it "fails when asking for the log_dir and there is no $HOME" 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"))) }
+        end
+      end
+
+      describe "when run as non-root" do
+        it "has default rundir ~/.puppet/var/run" do
+          as_non_root { expect(@run_mode.run_dir).to eq(File.expand_path('~/.puppet/var/run')) }
+        end
+
+        it "fails when asking for the run_dir and there is no $HOME" 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
   end
 
   def as_root

data/spec/unit/util/selinux_spec.rb

@@ -20,17 +20,17 @@ describe Puppet::Util::SELinux do
     end
     it "should return :true if this system has SELinux enabled" do
       Selinux.expects(:is_selinux_enabled).returns 1
-      selinux_support?.should be_true
+      expect(selinux_support?).to be_truthy
     end
 
     it "should return :false if this system lacks SELinux" do
       Selinux.expects(:is_selinux_enabled).returns 0
-      selinux_support?.should be_false
+      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")
-      read_mounts.should == nil
+      expect(read_mounts).to eq(nil)
     end
   end
 
@@ -42,12 +42,12 @@ describe Puppet::Util::SELinux do
     end
 
     it "should parse the contents of /proc/mounts" do
-      read_mounts.should  == {
+      expect(read_mounts).to  eq({
         '/' => 'ext3',
         '/sys' => 'sysfs',
         '/mnt/nfs' => 'nfs',
         '/proc' => 'proc',
-        '/dev' => 'tmpfs' }
+        '/dev' => 'tmpfs' })
     end
   end
 
@@ -62,19 +62,19 @@ describe Puppet::Util::SELinux do
     end
 
     it "should match a path on / to ext3" do
-      find_fs('/etc/puppet/testfile').should == "ext3"
+      expect(find_fs('/etc/puppetlabs/puppet/testfile')).to eq("ext3")
     end
 
     it "should match a path on /mnt/nfs to nfs" do
-      find_fs('/mnt/nfs/testfile/foobar').should == "nfs"
+      expect(find_fs('/mnt/nfs/testfile/foobar')).to eq("nfs")
     end
 
     it "should return true for a capable filesystem" do
-      selinux_label_support?('/etc/puppet/testfile').should be_true
+      expect(selinux_label_support?('/etc/puppetlabs/puppet/testfile')).to be_truthy
     end
 
     it "should return false for a noncapable filesystem" do
-      selinux_label_support?('/mnt/nfs/testfile').should be_false
+      expect(selinux_label_support?('/mnt/nfs/testfile')).to be_falsey
     end
 
     it "(#8714) don't follow symlinks when determining file systems", :unless => Puppet.features.microsoft_windows? do
@@ -86,38 +86,38 @@ describe Puppet::Util::SELinux do
         })
 
       (scratch + 'foo').make_symlink('nfs/bar')
-      selinux_label_support?(scratch + 'foo').should be_true
+      expect(selinux_label_support?(scratch + 'foo')).to be_truthy
     end
 
     it "should handle files that don't exist" do
       scratch = Pathname(PuppetSpec::Files.tmpdir('selinux'))
-      selinux_label_support?(scratch + 'nonesuch').should be_true
+      expect(selinux_label_support?(scratch + 'nonesuch')).to be_truthy
     end
   end
 
   describe "get_selinux_current_context" do
     it "should return nil if no SELinux support" do
       self.expects(:selinux_support?).returns false
-      get_selinux_current_context("/foo").should be_nil
+      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"]
-      get_selinux_current_context("/foo").should == "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
-      get_selinux_current_context("/foo").should be_nil
+      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
-      get_selinux_default_context("/foo").should be_nil
+      expect(get_selinux_default_context("/foo")).to be_nil
     end
 
     it "should return a context if a default context exists" do
@@ -127,7 +127,7 @@ describe Puppet::Util::SELinux do
       self.expects(:find_fs).with("/foo").returns "ext3"
       Selinux.expects(:matchpathcon).with("/foo", 0).returns [0, "user_u:role_r:type_t:s0"]
 
-      get_selinux_default_context("/foo").should == "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
@@ -136,7 +136,7 @@ describe Puppet::Util::SELinux do
       Selinux.stubs(:matchpathcon).with("/root/chuj", 0).returns(-1)
       self.stubs(:file_lstat).with("/root/chuj").raises(Errno::EACCES, "/root/chuj")
 
-      get_selinux_default_context("/root/chuj").should be_nil
+      expect(get_selinux_default_context("/root/chuj")).to be_nil
     end
 
     it "handles no such file or directory errors by issuing a warning" do
@@ -145,7 +145,7 @@ describe Puppet::Util::SELinux do
       Selinux.stubs(:matchpathcon).with("/root/chuj", 0).returns(-1)
       self.stubs(:file_lstat).with("/root/chuj").raises(Errno::ENOENT, "/root/chuj")
 
-      get_selinux_default_context("/root/chuj").should be_nil
+      expect(get_selinux_default_context("/root/chuj")).to be_nil
     end
 
     it "should return nil if matchpathcon returns failure" do
@@ -155,50 +155,72 @@ describe Puppet::Util::SELinux do
       self.expects(:find_fs).with("/foo").returns "ext3"
       Selinux.expects(:matchpathcon).with("/foo", 0).returns -1
 
-      get_selinux_default_context("/foo").should be_nil
+      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"
-      get_selinux_default_context("/foo").should be_nil
+      expect(get_selinux_default_context("/foo")).to be_nil
     end
 
   end
 
   describe "parse_selinux_context" do
     it "should return nil if no context is passed" do
-      parse_selinux_context(:seluser, nil).should be_nil
+      expect(parse_selinux_context(:seluser, nil)).to be_nil
     end
 
     it "should return nil if the context is 'unlabeled'" do
-      parse_selinux_context(:seluser, "unlabeled").should be_nil
+      expect(parse_selinux_context(:seluser, "unlabeled")).to be_nil
     end
 
     it "should return the user type when called with :seluser" do
-      parse_selinux_context(:seluser, "user_u:role_r:type_t:s0").should == "user_u"
+      expect(parse_selinux_context(:seluser, "user_u:role_r:type_t:s0")).to eq("user_u")
+      expect(parse_selinux_context(:seluser, "user-withdash_u:role_r:type_t:s0")).to eq("user-withdash_u")
     end
 
     it "should return the role type when called with :selrole" do
-      parse_selinux_context(:selrole, "user_u:role_r:type_t:s0").should == "role_r"
+      expect(parse_selinux_context(:selrole, "user_u:role_r:type_t:s0")).to eq("role_r")
+      expect(parse_selinux_context(:selrole, "user_u:role-withdash_r:type_t:s0")).to eq("role-withdash_r")
     end
 
     it "should return the type type when called with :seltype" do
-      parse_selinux_context(:seltype, "user_u:role_r:type_t:s0").should == "type_t"
+      expect(parse_selinux_context(:seltype, "user_u:role_r:type_t:s0")).to eq("type_t")
+      expect(parse_selinux_context(:seltype, "user_u:role_r:type-withdash_t:s0")).to eq("type-withdash_t")
+    end
+
+    describe "with spaces in the components" do
+      it "should raise when user contains a space" do
+        expect{parse_selinux_context(:seluser, "user with space_u:role_r:type_t:s0")}.to raise_error Puppet::Error
+      end
+
+      it "should raise when role contains a space" do
+        expect{parse_selinux_context(:selrole, "user_u:role with space_r:type_t:s0")}.to raise_error Puppet::Error
+      end
+
+      it "should raise when type contains a space" do
+        expect{parse_selinux_context(:seltype, "user_u:role_r:type with space_t:s0")}.to raise_error Puppet::Error
+      end
+
+      it "should return the range when range contains a space" do
+        expect(parse_selinux_context(:selrange, "user_u:role_r:type_t:s0 s1")).to eq("s0 s1")
+      end
     end
 
     it "should return nil for :selrange when no range is returned" do
-      parse_selinux_context(:selrange, "user_u:role_r:type_t").should be_nil
+      expect(parse_selinux_context(:selrange, "user_u:role_r:type_t")).to be_nil
     end
 
     it "should return the range type when called with :selrange" do
-      parse_selinux_context(:selrange, "user_u:role_r:type_t:s0").should == "s0"
+      expect(parse_selinux_context(:selrange, "user_u:role_r:type_t:s0")).to eq("s0")
+      expect(parse_selinux_context(:selrange, "user_u:role_r:type-withdash_t:s0")).to eq("s0")
     end
 
     describe "with a variety of SELinux range formats" do
       ['s0', 's0:c3', 's0:c3.c123', 's0:c3,c5,c8', 'TopSecret', 'TopSecret,Classified', 'Patient_Record'].each do |range|
         it "should parse range '#{range}'" do
-          parse_selinux_context(:selrange, "user_u:role_r:type_t:#{range}").should == range
+          expect(parse_selinux_context(:selrange, "user_u:role_r:type_t:#{range}")).to eq(range)
         end
       end
     end
@@ -217,72 +239,72 @@ describe Puppet::Util::SELinux do
 
     it "should return nil if there is no SELinux support" do
       self.expects(:selinux_support?).returns false
-      set_selinux_context("/foo", "user_u:role_r:type_t:s0").should be_nil
+      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
-      set_selinux_context("/foo", "user_u:role_r:type_t:s0").should be_nil
+      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
-      set_selinux_context("/foo", "user_u:role_r:type_t:s0").should be_true
+      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
-      set_selinux_context("/foo", "user_u", :seluser).should be_true
+      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
-      set_selinux_context("/foo", "role_r", :selrole).should be_true
+      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
-      set_selinux_context("/foo", "type_t", :seltype).should be_true
+      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
-      set_selinux_context("/foo", "s0:c3,c5", :selrange).should be_true
+      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
-      set_selinux_default_context("/foo").should be_nil
+      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
-      set_selinux_default_context("/foo").should be_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"
-      set_selinux_default_context("/foo").should be_nil
+      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
-      set_selinux_default_context("/foo").should == "user_u:role_r:type_t"
+      expect(set_selinux_default_context("/foo")).to eq("user_u:role_r:type_t")
     end
   end