puppet 3.8.7 → 4.0.0

data/spec/unit/util/constant_inflector_spec.rb

@@ -5,52 +5,52 @@ require 'puppet/util/constant_inflector'
 
 describe Puppet::Util::ConstantInflector, "when converting file names to constants" do
   it "should capitalize terms" do
-    subject.file2constant("file").should == "File"
+    expect(subject.file2constant("file")).to eq("File")
   end
 
   it "should switch all '/' characters to double colons" do
-    subject.file2constant("file/other").should == "File::Other"
+    expect(subject.file2constant("file/other")).to eq("File::Other")
   end
 
   it "should remove underscores and capitalize the proceeding letter" do
-    subject.file2constant("file_other").should == "FileOther"
+    expect(subject.file2constant("file_other")).to eq("FileOther")
   end
 
   it "should correctly replace as many underscores as exist in the file name" do
-    subject.file2constant("two_under_scores/with_some_more_underscores").should == "TwoUnderScores::WithSomeMoreUnderscores"
+    expect(subject.file2constant("two_under_scores/with_some_more_underscores")).to eq("TwoUnderScores::WithSomeMoreUnderscores")
   end
 
   it "should collapse multiple underscores" do
-    subject.file2constant("many___scores").should == "ManyScores"
+    expect(subject.file2constant("many___scores")).to eq("ManyScores")
   end
 
   it "should correctly handle file names deeper than two directories" do
-    subject.file2constant("one_two/three_four/five_six").should == "OneTwo::ThreeFour::FiveSix"
+    expect(subject.file2constant("one_two/three_four/five_six")).to eq("OneTwo::ThreeFour::FiveSix")
   end
 end
 
 describe Puppet::Util::ConstantInflector, "when converting constnats to file names" do
   it "should convert them to a string if necessary" do
-    subject.constant2file(Puppet::Util::ConstantInflector).should be_instance_of(String)
+    expect(subject.constant2file(Puppet::Util::ConstantInflector)).to be_instance_of(String)
   end
 
   it "should accept string inputs" do
-    subject.constant2file("Puppet::Util::ConstantInflector").should be_instance_of(String)
+    expect(subject.constant2file("Puppet::Util::ConstantInflector")).to be_instance_of(String)
   end
 
   it "should downcase all terms" do
-    subject.constant2file("Puppet").should == "puppet"
+    expect(subject.constant2file("Puppet")).to eq("puppet")
   end
 
   it "should convert '::' to '/'" do
-    subject.constant2file("Puppet::Util::Constant").should == "puppet/util/constant"
+    expect(subject.constant2file("Puppet::Util::Constant")).to eq("puppet/util/constant")
   end
 
   it "should convert mid-word capitalization to an underscore" do
-    subject.constant2file("OneTwo::ThreeFour").should == "one_two/three_four"
+    expect(subject.constant2file("OneTwo::ThreeFour")).to eq("one_two/three_four")
   end
 
   it "should correctly handle constants with more than two parts" do
-    subject.constant2file("OneTwoThree::FourFiveSixSeven").should == "one_two_three/four_five_six_seven"
+    expect(subject.constant2file("OneTwoThree::FourFiveSixSeven")).to eq("one_two_three/four_five_six_seven")
   end
 end

data/spec/unit/util/diff_spec.rb

@@ -10,7 +10,7 @@ describe Puppet::Util::Diff do
       Puppet[:diff_args] = 'bar'
 
       Puppet::Util::Execution.expects(:execute).with(['foo', 'bar', 'a', 'b'], {:failonfail => false, :combine => false}).returns('baz')
-      subject.diff('a', 'b').should == 'baz'
+      expect(subject.diff('a', 'b')).to eq('baz')
     end
 
     it "should execute the diff command with multiple arguments" do
@@ -18,7 +18,7 @@ describe Puppet::Util::Diff do
       Puppet[:diff_args] = 'bar qux'
 
       Puppet::Util::Execution.expects(:execute).with(['foo', 'bar', 'qux', 'a', 'b'], anything).returns('baz')
-      subject.diff('a', 'b').should == 'baz'
+      expect(subject.diff('a', 'b')).to eq('baz')
     end
 
     it "should omit diff arguments if none are specified" do
@@ -26,14 +26,14 @@ describe Puppet::Util::Diff do
       Puppet[:diff_args] = ''
 
       Puppet::Util::Execution.expects(:execute).with(['foo', 'a', 'b'], {:failonfail => false, :combine => false}).returns('baz')
-      subject.diff('a', 'b').should == 'baz'
+      expect(subject.diff('a', 'b')).to eq('baz')
     end
 
     it "should return empty string if the diff command is empty" do
       Puppet[:diff] = ''
 
       Puppet::Util::Execution.expects(:execute).never
-      subject.diff('a', 'b').should == ''
+      expect(subject.diff('a', 'b')).to eq('')
     end
   end
 end

data/spec/unit/util/errors_spec.rb

@@ -14,24 +14,24 @@ describe Puppet::Util::Errors do
   end
 
   it "should provide a 'fail' method" do
-    @tester.should respond_to(:fail)
+    expect(@tester).to respond_to(:fail)
   end
 
   it "should provide a 'devfail' method" do
-    @tester.should respond_to(:devfail)
+    expect(@tester).to respond_to(:devfail)
   end
 
   it "should raise any provided error when failing" do
-    lambda { @tester.fail(Puppet::ParseError, "stuff") }.should raise_error(Puppet::ParseError)
+    expect { @tester.fail(Puppet::ParseError, "stuff") }.to raise_error(Puppet::ParseError)
   end
 
   it "should default to Puppet::Error when failing" do
-    lambda { @tester.fail("stuff") }.should raise_error(Puppet::Error)
+    expect { @tester.fail("stuff") }.to raise_error(Puppet::Error)
   end
 
   it "should have a method for converting error context into a string" do
     @tester.file = "/my/file"
     @tester.line = 50
-    @tester.error_context.should == " at /my/file:50"
+    expect(@tester.error_context).to eq(" at /my/file:50")
   end
 end

data/spec/unit/util/execution_spec.rb

@@ -69,8 +69,8 @@ describe Puppet::Util::Execution do
 
         # we will get some fairly useless output if we just use the raw == operator on the hashes here, so we'll
         #  be a bit more explicit and laborious in the name of making the error more useful...
-        @saved_env.each_pair { |key,val| cur_env[key].should == val }
-        (cur_env.keys - @saved_env.keys).should == []
+        @saved_env.each_pair { |key,val| expect(cur_env[key]).to eq(val) }
+        expect(cur_env.keys - @saved_env.keys).to eq([])
 
       end
 
@@ -116,7 +116,7 @@ describe Puppet::Util::Execution do
       end
 
       it "should return the pid of the child process" do
-        call_exec_posix('test command', {}, @stdin, @stdout, @stderr).should == pid
+        expect(call_exec_posix('test command', {}, @stdin, @stdout, @stderr)).to eq(pid)
       end
     end
 
@@ -141,7 +141,7 @@ describe Puppet::Util::Execution do
       end
 
       it "should return the process info of the child process" do
-        call_exec_windows('test command', {}, @stdin, @stdout, @stderr).should == proc_info_stub
+        expect(call_exec_windows('test command', {}, @stdin, @stdout, @stderr)).to eq(proc_info_stub)
       end
 
       it "should quote arguments containing spaces if command is specified as an array" do
@@ -166,7 +166,7 @@ describe Puppet::Util::Execution do
         end
 
         it "should call the block on the stub" do
-          Puppet::Util::Execution.execute("/usr/bin/run_my_execute_stub").should == "execution stub output"
+          expect(Puppet::Util::Execution.execute("/usr/bin/run_my_execute_stub")).to eq("execution stub output")
         end
 
         it "should not actually execute anything" do
@@ -313,7 +313,7 @@ describe Puppet::Util::Execution do
           stub_process_wait(real_exit_status)
           $CHILD_STATUS.stubs(:exitstatus).returns(real_exit_status % 256) # The exitstatus is changed to be mod 256 so that ruby can fit it into 8 bits.
 
-          Puppet::Util::Execution.execute('test command', :failonfail => false).exitstatus.should == real_exit_status
+          expect(Puppet::Util::Execution.execute('test command', :failonfail => false).exitstatus).to eq(real_exit_status)
         end
       end
     end
@@ -334,8 +334,8 @@ describe Puppet::Util::Execution do
         cur_env = ENV.to_hash
         # we will get some fairly useless output if we just use the raw == operator on the hashes here, so we'll
         #  be a bit more explicit and laborious in the name of making the error more useful...
-        @saved_env.each_pair { |key,val| cur_env[key].should == val }
-        (cur_env.keys - @saved_env.keys).should == []
+        @saved_env.each_pair { |key,val| expect(cur_env[key]).to eq(val) }
+        expect(cur_env.keys - @saved_env.keys).to eq([])
       end
 
 
@@ -358,7 +358,7 @@ describe Puppet::Util::Execution do
           Puppet::Util::POSIX::LOCALE_ENV_VARS.each do |var|
             # we expect that all of the POSIX vars will have been cleared except for LANG and LC_ALL
             expected_value = (['LANG', 'LC_ALL'].include?(var)) ? "C" : ""
-            Puppet::Util::execute(get_env_var_cmd % var).strip.should == expected_value
+            expect(Puppet::Util::Execution.execute(get_env_var_cmd % var).strip).to eq(expected_value)
           end
         end
       end
@@ -370,7 +370,7 @@ describe Puppet::Util::Execution do
           Puppet::Util::POSIX::LOCALE_ENV_VARS.each do |var|
             # we expect that all of the POSIX vars will have been cleared except for LANG and LC_ALL
             expected_value = (['LANG', 'LC_ALL'].include?(var)) ? "C" : ""
-            Puppet::Util::execute(get_env_var_cmd % var, {:override_locale => true}).strip.should == expected_value
+            expect(Puppet::Util::Execution.execute(get_env_var_cmd % var, {:override_locale => true}).strip).to eq(expected_value)
           end
         end
       end
@@ -380,7 +380,7 @@ describe Puppet::Util::Execution do
         # execute is not setting them.
         Puppet::Util.withenv(locale_sentinel_env) do
           Puppet::Util::POSIX::LOCALE_ENV_VARS.each do |var|
-            Puppet::Util::execute(get_env_var_cmd % var, {:override_locale => false}).strip.should == lang_sentinel_value
+            expect(Puppet::Util::Execution.execute(get_env_var_cmd % var, {:override_locale => false}).strip).to eq(lang_sentinel_value)
           end
         end
       end
@@ -392,19 +392,19 @@ describe Puppet::Util::Execution do
           orig_env_vals[var] = ENV[var]
         end
         # now we can really execute any command--doesn't matter what it is...
-        Puppet::Util::execute(get_env_var_cmd % 'anything', {:override_locale => true})
+        Puppet::Util::Execution.execute(get_env_var_cmd % 'anything', {:override_locale => true})
         # now we check and make sure the original environment was restored
         Puppet::Util::POSIX::LOCALE_ENV_VARS.each do |var|
-          ENV[var].should == orig_env_vals[var]
+          expect(ENV[var]).to eq(orig_env_vals[var])
         end
 
         # now, once more... but with our sentinel values
         Puppet::Util.withenv(locale_sentinel_env) do
           # now we can really execute any command--doesn't matter what it is...
-          Puppet::Util::execute(get_env_var_cmd % 'anything', {:override_locale => true})
+          Puppet::Util::Execution.execute(get_env_var_cmd % 'anything', {:override_locale => true})
           # now we check and make sure the original environment was restored
           Puppet::Util::POSIX::LOCALE_ENV_VARS.each do |var|
-            ENV[var].should == locale_sentinel_env[var]
+            expect(ENV[var]).to eq(locale_sentinel_env[var])
           end
         end
 
@@ -431,13 +431,13 @@ describe Puppet::Util::Execution do
           # with this environment, we loop over the vars in question
           Puppet::Util::POSIX::USER_ENV_VARS.each do |var|
             # ensure that our temporary environment is set up as we expect
-            ENV[var].should == user_sentinel_env[var]
+            expect(ENV[var]).to eq(user_sentinel_env[var])
 
             # run an "exec" via the provider and ensure that it unsets the vars
-            Puppet::Util::execute(get_env_var_cmd % var).strip.should == ""
+            expect(Puppet::Util::Execution.execute(get_env_var_cmd % var).strip).to eq("")
 
             # ensure that after the exec, our temporary env is still intact
-            ENV[var].should == user_sentinel_env[var]
+            expect(ENV[var]).to eq(user_sentinel_env[var])
           end
 
         end
@@ -450,25 +450,70 @@ describe Puppet::Util::Execution do
           orig_env_vals[var] = ENV[var]
         end
         # now we can really execute any command--doesn't matter what it is...
-        Puppet::Util::execute(get_env_var_cmd % 'anything')
+        Puppet::Util::Execution.execute(get_env_var_cmd % 'anything')
         # now we check and make sure the original environment was restored
         Puppet::Util::POSIX::USER_ENV_VARS.each do |var|
-          ENV[var].should == orig_env_vals[var]
+          expect(ENV[var]).to eq(orig_env_vals[var])
         end
 
         # now, once more... but with our sentinel values
         Puppet::Util.withenv(user_sentinel_env) do
           # now we can really execute any command--doesn't matter what it is...
-          Puppet::Util::execute(get_env_var_cmd % 'anything')
+          Puppet::Util::Execution.execute(get_env_var_cmd % 'anything')
           # now we check and make sure the original environment was restored
           Puppet::Util::POSIX::USER_ENV_VARS.each do |var|
-            ENV[var].should == user_sentinel_env[var]
+            expect(ENV[var]).to eq(user_sentinel_env[var])
           end
         end
 
       end
     end
 
+    describe "#execute (debug logging)" do
+      before :each do
+        stub_process_wait(0)
+
+        if Puppet.features.microsoft_windows?
+          Puppet::Util::Execution.stubs(:execute_windows).returns(proc_info_stub)
+        else
+          Puppet::Util::Execution.stubs(:execute_posix).returns(pid)
+        end
+      end
+
+      it "should log if no uid or gid specified" do
+        Puppet::Util::Execution.expects(:debug).with("Executing: 'echo hello'")
+        Puppet::Util::Execution.execute('echo hello')
+      end
+      it "should log numeric uid if specified" do
+        Puppet::Util::Execution.expects(:debug).with("Executing with uid=100: 'echo hello'")
+        Puppet::Util::Execution.execute('echo hello', {:uid => 100})
+      end
+      it "should log numeric gid if specified" do
+        Puppet::Util::Execution.expects(:debug).with("Executing with gid=500: 'echo hello'")
+        Puppet::Util::Execution.execute('echo hello', {:gid => 500})
+      end
+      it "should log numeric uid and gid if specified" do
+        Puppet::Util::Execution.expects(:debug).with("Executing with uid=100 gid=500: 'echo hello'")
+        Puppet::Util::Execution.execute('echo hello', {:uid => 100, :gid => 500})
+      end
+      it "should log string uid if specified" do
+        Puppet::Util::Execution.expects(:debug).with("Executing with uid=myuser: 'echo hello'")
+        Puppet::Util::Execution.execute('echo hello', {:uid => 'myuser'})
+      end
+      it "should log string gid if specified" do
+        Puppet::Util::Execution.expects(:debug).with("Executing with gid=mygroup: 'echo hello'")
+        Puppet::Util::Execution.execute('echo hello', {:gid => 'mygroup'})
+      end
+      it "should log string uid and gid if specified" do
+        Puppet::Util::Execution.expects(:debug).with("Executing with uid=myuser gid=mygroup: 'echo hello'")
+        Puppet::Util::Execution.execute('echo hello', {:uid => 'myuser', :gid => 'mygroup'})
+      end
+      it "should log numeric uid and string gid if specified" do
+        Puppet::Util::Execution.expects(:debug).with("Executing with uid=100 gid=mygroup: 'echo hello'")
+        Puppet::Util::Execution.execute('echo hello', {:uid => 100, :gid => 'mygroup'})
+      end
+    end
+
     describe "after execution" do
       before :each do
         stub_process_wait(0)
@@ -505,7 +550,7 @@ describe Puppet::Util::Execution do
         Puppet::FileSystem::Uniquefile.stubs(:new).returns(stdout)
         stdout.write("My expected command output")
 
-        Puppet::Util::Execution.execute('test command').should == "My expected command output"
+        expect(Puppet::Util::Execution.execute('test command')).to eq("My expected command output")
       end
 
       it "should not read the output if squelch is true" do
@@ -513,7 +558,7 @@ describe Puppet::Util::Execution do
         Puppet::FileSystem::Uniquefile.stubs(:new).returns(stdout)
         stdout.write("My expected command output")
 
-        Puppet::Util::Execution.execute('test command', :squelch => true).should == ''
+        expect(Puppet::Util::Execution.execute('test command', :squelch => true)).to eq('')
       end
 
       it "should delete the file used for output if squelch is false" do
@@ -523,7 +568,7 @@ describe Puppet::Util::Execution do
 
         Puppet::Util::Execution.execute('test command')
 
-        Puppet::FileSystem.exist?(path).should be_false
+        expect(Puppet::FileSystem.exist?(path)).to be_falsey
       end
 
       it "should not raise an error if the file is open" do
@@ -531,7 +576,7 @@ describe Puppet::Util::Execution do
         Puppet::FileSystem::Uniquefile.stubs(:new).returns(stdout)
         file = File.new(stdout.path, 'r')
 
-        Puppet::Util.execute('test command')
+        Puppet::Util::Execution.execute('test command')
       end
 
       it "should raise an error if failonfail is true and the child failed" do
@@ -592,7 +637,7 @@ describe Puppet::Util::Execution do
     it "should execute a string as a string" do
       Puppet::Util::Execution.expects(:open).with('| echo hello 2>&1').returns('hello')
       Puppet::Util::Execution.expects(:exitstatus).returns(0)
-      Puppet::Util::Execution.execpipe('echo hello').should == 'hello'
+      expect(Puppet::Util::Execution.execpipe('echo hello')).to eq('hello')
     end
 
     it "should print meaningful debug message for string argument" do
@@ -612,7 +657,7 @@ describe Puppet::Util::Execution do
     it "should execute an array by pasting together with spaces" do
       Puppet::Util::Execution.expects(:open).with('| echo hello 2>&1').returns('hello')
       Puppet::Util::Execution.expects(:exitstatus).returns(0)
-      Puppet::Util::Execution.execpipe(['echo', 'hello']).should == 'hello'
+      expect(Puppet::Util::Execution.execpipe(['echo', 'hello'])).to eq('hello')
     end
 
     it "should fail if asked to fail, and the child does" do
@@ -624,7 +669,7 @@ describe Puppet::Util::Execution do
 
     it "should not fail if asked not to fail, and the child does" do
       Puppet::Util::Execution.stubs(:open).returns('error message')
-      Puppet::Util::Execution.execpipe('echo hello', false).should == 'error message'
+      expect(Puppet::Util::Execution.execpipe('echo hello', false)).to eq('error message')
     end
   end
 end

data/spec/unit/util/execution_stub_spec.rb

@@ -4,16 +4,16 @@ require 'spec_helper'
 describe Puppet::Util::ExecutionStub do
   it "should use the provided stub code when 'set' is called" do
     Puppet::Util::ExecutionStub.set do |command, options|
-      command.should == ['/bin/foo', 'bar']
+      expect(command).to eq(['/bin/foo', 'bar'])
       "stub output"
     end
-    Puppet::Util::ExecutionStub.current_value.should_not == nil
-    Puppet::Util::Execution.execute(['/bin/foo', 'bar']).should == "stub output"
+    expect(Puppet::Util::ExecutionStub.current_value).not_to eq(nil)
+    expect(Puppet::Util::Execution.execute(['/bin/foo', 'bar'])).to eq("stub output")
   end
 
   it "should automatically restore normal execution at the conclusion of each spec test" do
     # Note: this test relies on the previous test creating a stub.
-    Puppet::Util::ExecutionStub.current_value.should == nil
+    expect(Puppet::Util::ExecutionStub.current_value).to eq(nil)
   end
 
   it "should restore normal execution after 'reset' is called" do
@@ -25,15 +25,15 @@ describe Puppet::Util::ExecutionStub do
     end
     stub_call_count = 0
     Puppet::Util::ExecutionStub.set do |command, options|
-      command.should == true_command
+      expect(command).to eq(true_command)
       stub_call_count += 1
       'stub called'
     end
-    Puppet::Util::Execution.execute(true_command).should == 'stub called'
-    stub_call_count.should == 1
+    expect(Puppet::Util::Execution.execute(true_command)).to eq('stub called')
+    expect(stub_call_count).to eq(1)
     Puppet::Util::ExecutionStub.reset
-    Puppet::Util::ExecutionStub.current_value.should == nil
-    Puppet::Util::Execution.execute(true_command).should == ''
-    stub_call_count.should == 1
+    expect(Puppet::Util::ExecutionStub.current_value).to eq(nil)
+    expect(Puppet::Util::Execution.execute(true_command)).to eq('')
+    expect(stub_call_count).to eq(1)
   end
 end

data/spec/unit/util/feature_spec.rb

@@ -9,34 +9,30 @@ describe Puppet::Util::Feature do
     @features.stubs(:warn)
   end
 
-  it "should consider undefined features to be absent" do
-    @features.should_not be_defined_feature
-  end
-
   it "should be able to add new features" do
     @features.add(:myfeature) {}
-    @features.should respond_to(:myfeature?)
+    expect(@features).to respond_to(:myfeature?)
   end
 
   it "should call associated code when loading a feature" do
     $loaded_feature = false
     @features.add(:myfeature) { $loaded_feature = true}
-    $loaded_feature.should be_true
+    expect($loaded_feature).to be_truthy
   end
 
   it "should consider a feature absent when the feature load fails" do
     @features.add(:failer) { raise "foo" }
-    @features.should_not be_failer
+    expect(@features).not_to be_failer
   end
 
   it "should consider a feature to be absent when the feature load returns false" do
     @features.add(:failer) { false }
-    @features.should_not be_failer
+    expect(@features).not_to be_failer
   end
 
   it "should consider a feature to be present when the feature load returns true" do
     @features.add(:available) { true }
-    @features.should be_available
+    expect(@features).to be_available
   end
 
   it "should cache the results of a feature load via code block" do
@@ -44,21 +40,21 @@ describe Puppet::Util::Feature do
     @features.add(:myfeature) { $loaded_feature += 1 }
     @features.myfeature?
     @features.myfeature?
-    $loaded_feature.should == 1
+    expect($loaded_feature).to eq(1)
   end
 
   it "should invalidate the cache for the feature when loading" do
     # block defined features are evaluated at load time
     @features.add(:myfeature) { false }
-    @features.should_not be_myfeature
+    expect(@features).not_to be_myfeature
     # features with no block have deferred evaluation so an existing cached
     # value would take precedence
     @features.add(:myfeature)
-    @features.should be_myfeature
+    expect(@features).to be_myfeature
   end
 
   it "should support features with libraries" do
-    lambda { @features.add(:puppet, :libs => %w{puppet}) }.should_not raise_error
+    expect { @features.add(:puppet, :libs => %w{puppet}) }.not_to raise_error
   end
 
   it "should consider a feature to be present if all of its libraries are present" do
@@ -66,7 +62,7 @@ describe Puppet::Util::Feature do
     @features.expects(:require).with("foo")
     @features.expects(:require).with("bar")
 
-    @features.should be_myfeature
+    expect(@features).to be_myfeature
   end
 
   it "should log and consider a feature to be absent if any of its libraries are absent" do
@@ -76,7 +72,7 @@ describe Puppet::Util::Feature do
 
     Puppet.expects(:debug)
 
-    @features.should_not be_myfeature
+    expect(@features).not_to be_myfeature
   end
 
   it "should change the feature to be present when its libraries become available" do
@@ -88,8 +84,8 @@ describe Puppet::Util::Feature do
 
     Puppet.expects(:debug)
 
-    @features.should_not be_myfeature
-    @features.should be_myfeature
+    expect(@features).not_to be_myfeature
+    expect(@features).to be_myfeature
   end
 
   it "should cache load failures when configured to do so" do
@@ -98,9 +94,9 @@ describe Puppet::Util::Feature do
     @features.add(:myfeature, :libs => %w{foo bar})
     @features.expects(:require).with("foo").raises(LoadError)
 
-    @features.should_not be_myfeature
+    expect(@features).not_to be_myfeature
     # second call would cause an expectation exception if 'require' was
     # called a second time
-    @features.should_not be_myfeature
+    expect(@features).not_to be_myfeature
   end
 end

data/spec/unit/util/filetype_spec.rb

@@ -11,7 +11,7 @@ describe Puppet::Util::FileType do
     let(:file) { type.new(path) }
 
     it "should exist" do
-      type.should_not be_nil
+      expect(type).not_to be_nil
     end
 
     describe "when the file already exists" do
@@ -19,7 +19,7 @@ describe Puppet::Util::FileType do
         Puppet::FileSystem.expects(:exist?).with(path).returns true
         File.expects(:read).with(path).returns "my text"
 
-        file.read.should == "my text"
+        expect(file.read).to eq("my text")
       end
 
       it "should unlink the file when asked to remove it" do
@@ -34,7 +34,7 @@ describe Puppet::Util::FileType do
       it "should return an empty string when asked to read the file" do
         Puppet::FileSystem.expects(:exist?).with(path).returns false
 
-        file.read.should == ""
+        expect(file.read).to eq("")
       end
     end
 
@@ -84,7 +84,7 @@ describe Puppet::Util::FileType do
 
         Puppet::Type.type(:filebucket).expects(:mkdefaultbucket).returns bucket
 
-        file.bucket.should == "mybucket"
+        expect(file.bucket).to eq("mybucket")
       end
     end
   end
@@ -97,7 +97,7 @@ describe Puppet::Util::FileType do
     let(:user_options) { options.merge({:uid => uid}) }
 
     it "should exist" do
-      type.should_not be_nil
+      expect(type).not_to be_nil
     end
 
     # make Puppet::Util::SUIDManager return something deterministic, not the
@@ -109,19 +109,19 @@ describe Puppet::Util::FileType do
     describe "#read" do
       it "should run crontab -l as the target user" do
         Puppet::Util::Execution.expects(:execute).with(['crontab', '-l'], user_options).returns crontab
-        cron.read.should == crontab
+        expect(cron.read).to eq(crontab)
       end
 
       it "should not switch user if current user is the target user" do
         Puppet::Util.expects(:uid).with(uid).returns 9000
         Puppet::Util::SUIDManager.expects(:uid).returns 9000
         Puppet::Util::Execution.expects(:execute).with(['crontab', '-l'], options).returns crontab
-        cron.read.should == crontab
+        expect(cron.read).to eq(crontab)
       end
 
       it "should treat an absent crontab as empty" do
         Puppet::Util::Execution.expects(:execute).with(['crontab', '-l'], user_options).raises(Puppet::ExecutionFailure, absent_crontab)
-        cron.read.should == ''
+        expect(cron.read).to eq('')
       end
 
       it "should raise an error if the user is not authorized to use cron" do
@@ -155,7 +155,7 @@ describe Puppet::Util::FileType do
       end
 
       after :each do
-        Puppet::FileSystem.exist?(@tmp_cron_path).should be_false
+        expect(Puppet::FileSystem.exist?(@tmp_cron_path)).to be_falsey
       end
 
       it "should run crontab as the target user on a temporary file" do