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

data/spec/unit/file_serving/mount/file_spec.rb

@@ -56,28 +56,28 @@ describe Puppet::FileServing::Mount::File do
 
     it "should replace incidences of %h in the path with the client's short name" do
       @mount.path = "/dir/%h/yay"
-      @mount.path(@host).should == "/dir/host/yay"
+      expect(@mount.path(@host)).to eq("/dir/host/yay")
     end
 
     it "should replace incidences of %H in the path with the client's fully qualified name" do
       @mount.path = "/dir/%H/yay"
-      @mount.path(@host).should == "/dir/host.domain.com/yay"
+      expect(@mount.path(@host)).to eq("/dir/host.domain.com/yay")
     end
 
     it "should replace incidences of %d in the path with the client's domain name" do
       @mount.path = "/dir/%d/yay"
-      @mount.path(@host).should == "/dir/domain.com/yay"
+      expect(@mount.path(@host)).to eq("/dir/domain.com/yay")
     end
 
     it "should perform all necessary replacements" do
       @mount.path = "/%h/%d/%H"
-      @mount.path(@host).should == "/host/domain.com/host.domain.com"
+      expect(@mount.path(@host)).to eq("/host/domain.com/host.domain.com")
     end
 
     it "should use local host information if no client data is provided" do
       stub_facter("myhost.mydomain.com")
       @mount.path = "/%h/%d/%H"
-      @mount.path.should == "/myhost/mydomain.com/myhost.mydomain.com"
+      expect(@mount.path).to eq("/myhost/mydomain.com/myhost.mydomain.com")
     end
   end
 
@@ -96,7 +96,7 @@ describe Puppet::FileServing::Mount::File do
 
     it "should return nil if the file is absent" do
       Puppet::FileSystem.stubs(:exist?).returns(false)
-      @mount.complete_path("/my/path", nil).should be_nil
+      expect(@mount.complete_path("/my/path", nil)).to be_nil
     end
 
     it "should write a log message if the file is absent" do
@@ -109,31 +109,31 @@ describe Puppet::FileServing::Mount::File do
 
     it "should return the file path if the file is present" do
       Puppet::FileSystem.stubs(:exist?).with("/my/path").returns(true)
-      @mount.complete_path("/my/path", nil).should == "/mount/my/path"
+      expect(@mount.complete_path("/my/path", nil)).to eq("/mount/my/path")
     end
 
     it "should treat a nil file name as the path to the mount itself" do
       Puppet::FileSystem.stubs(:exist?).returns(true)
-      @mount.complete_path(nil, nil).should == "/mount"
+      expect(@mount.complete_path(nil, nil)).to eq("/mount")
     end
 
     it "should use the client host name if provided in the options" do
       @mount.path = "/mount/%h"
-      @mount.complete_path("/my/path", @host).should == "/mount/host/my/path"
+      expect(@mount.complete_path("/my/path", @host)).to eq("/mount/host/my/path")
     end
 
     it "should perform replacements on the base path" do
       @mount.path = "/blah/%h"
-      @mount.complete_path("/my/stuff", @host).should == "/blah/host/my/stuff"
+      expect(@mount.complete_path("/my/stuff", @host)).to eq("/blah/host/my/stuff")
     end
 
     it "should not perform replacements on the per-file path" do
       @mount.path = "/blah"
-      @mount.complete_path("/%h/stuff", @host).should == "/blah/%h/stuff"
+      expect(@mount.complete_path("/%h/stuff", @host)).to eq("/blah/%h/stuff")
     end
 
     it "should look for files relative to its base directory" do
-      @mount.complete_path("/my/stuff", @host).should == "/mount/my/stuff"
+      expect(@mount.complete_path("/my/stuff", @host)).to eq("/mount/my/stuff")
     end
   end
 
@@ -155,7 +155,7 @@ describe Puppet::FileServing::Mount::File do
     it "should return the results of the complete file path" do
       Puppet::FileSystem.stubs(:exist?).returns(false)
       @mount.expects(:complete_path).with("/my/path", "foo").returns "eh"
-      @mount.find("/my/path", @request).should == "eh"
+      expect(@mount.find("/my/path", @request)).to eq("eh")
     end
   end
 
@@ -177,13 +177,13 @@ describe Puppet::FileServing::Mount::File do
     it "should return the results of the complete file path as an array" do
       Puppet::FileSystem.stubs(:exist?).returns(false)
       @mount.expects(:complete_path).with("/my/path", "foo").returns "eh"
-      @mount.search("/my/path", @request).should == ["eh"]
+      expect(@mount.search("/my/path", @request)).to eq(["eh"])
     end
 
     it "should return nil if the complete path is nil" do
       Puppet::FileSystem.stubs(:exist?).returns(false)
       @mount.expects(:complete_path).with("/my/path", "foo").returns nil
-      @mount.search("/my/path", @request).should be_nil
+      expect(@mount.search("/my/path", @request)).to be_nil
     end
   end
 end

data/spec/unit/file_serving/mount/modules_spec.rb

@@ -35,7 +35,7 @@ describe Puppet::FileServing::Mount::Modules do
       mod = mock 'module'
       mod.expects(:file).with("bar/baz").returns "eh"
       @environment.expects(:module).with("foo").returns mod
-      @mount.find("foo/bar/baz", @request).should == "eh"
+      expect(@mount.find("foo/bar/baz", @request)).to eq("eh")
     end
   end
 
@@ -64,7 +64,7 @@ describe Puppet::FileServing::Mount::Modules do
       mod = mock 'module'
       mod.expects(:file).with("bar/baz").returns "eh"
       @environment.expects(:module).with("foo").returns mod
-      @mount.search("foo/bar/baz", @request).should == ["eh"]
+      expect(@mount.search("foo/bar/baz", @request)).to eq(["eh"])
     end
   end
 end

data/spec/unit/file_serving/mount/pluginfacts_spec.rb

@@ -23,7 +23,7 @@ describe Puppet::FileServing::Mount::PluginFacts do
       mod.stubs(:pluginfact).with("foo/bar").returns nil
 
       @environment.stubs(:modules).returns [mod]
-      @mount.find("foo/bar", @request).should be_nil
+      expect(@mount.find("foo/bar", @request)).to be_nil
     end
 
     it "should return the file path from the module" do
@@ -31,7 +31,7 @@ describe Puppet::FileServing::Mount::PluginFacts do
       mod.stubs(:pluginfact).with("foo/bar").returns "eh"
 
       @environment.stubs(:modules).returns [mod]
-      @mount.find("foo/bar", @request).should == "eh"
+      expect(@mount.find("foo/bar", @request)).to eq("eh")
     end
   end
 
@@ -50,7 +50,7 @@ describe Puppet::FileServing::Mount::PluginFacts do
       @environment.stubs(:modules).returns []
       @environment.stubs(:modulepath).returns ["/"]
       @options.expects(:[]=).with(:recurse, false)
-      @mount.search("foo/bar", @request).should == ["/"]
+      expect(@mount.search("foo/bar", @request)).to eq(["/"])
     end
 
     it "should return nil if no modules can be found that have plugins and modulepath is invalid" do
@@ -59,7 +59,7 @@ describe Puppet::FileServing::Mount::PluginFacts do
 
       @environment.stubs(:modules).returns []
       @environment.stubs(:modulepath).returns []
-      @mount.search("foo/bar", @request).should be_nil
+      expect(@mount.search("foo/bar", @request)).to be_nil
     end
 
     it "should return the plugin paths for each module that has plugins" do
@@ -67,7 +67,7 @@ describe Puppet::FileServing::Mount::PluginFacts do
       two = stub 'module', :pluginfacts? => true, :plugin_fact_directory => "/two"
 
       @environment.stubs(:modules).returns [one, two]
-      @mount.search("foo/bar", @request).should == %w{/one /two}
+      expect(@mount.search("foo/bar", @request)).to eq(%w{/one /two})
     end
   end
 end

data/spec/unit/file_serving/mount/plugins_spec.rb

@@ -23,7 +23,7 @@ describe Puppet::FileServing::Mount::Plugins do
       mod.stubs(:plugin).with("foo/bar").returns nil
 
       @environment.stubs(:modules).returns [mod]
-      @mount.find("foo/bar", @request).should be_nil
+      expect(@mount.find("foo/bar", @request)).to be_nil
     end
 
     it "should return the file path from the module" do
@@ -31,7 +31,7 @@ describe Puppet::FileServing::Mount::Plugins do
       mod.stubs(:plugin).with("foo/bar").returns "eh"
 
       @environment.stubs(:modules).returns [mod]
-      @mount.find("foo/bar", @request).should == "eh"
+      expect(@mount.find("foo/bar", @request)).to eq("eh")
     end
   end
 
@@ -50,7 +50,7 @@ describe Puppet::FileServing::Mount::Plugins do
       @environment.stubs(:modules).returns []
       @environment.stubs(:modulepath).returns ["/"]
       @options.expects(:[]=).with(:recurse, false)
-      @mount.search("foo/bar", @request).should == ["/"]
+      expect(@mount.search("foo/bar", @request)).to eq(["/"])
     end
 
     it "should return nil if no modules can be found that have plugins and modulepath is invalid" do
@@ -59,7 +59,7 @@ describe Puppet::FileServing::Mount::Plugins do
 
       @environment.stubs(:modules).returns []
       @environment.stubs(:modulepath).returns []
-      @mount.search("foo/bar", @request).should be_nil
+      expect(@mount.search("foo/bar", @request)).to be_nil
     end
 
     it "should return the plugin paths for each module that has plugins" do
@@ -67,7 +67,7 @@ describe Puppet::FileServing::Mount::Plugins do
       two = stub 'module', :plugins? => true, :plugin_directory => "/two"
 
       @environment.stubs(:modules).returns [one, two]
-      @mount.search("foo/bar", @request).should == %w{/one /two}
+      expect(@mount.search("foo/bar", @request)).to eq(%w{/one /two})
     end
   end
 end

data/spec/unit/file_serving/mount_spec.rb

@@ -4,28 +4,28 @@ require 'puppet/file_serving/mount'
 
 describe Puppet::FileServing::Mount do
   it "should use 'mount[$name]' as its string form" do
-    Puppet::FileServing::Mount.new("foo").to_s.should == "mount[foo]"
+    expect(Puppet::FileServing::Mount.new("foo").to_s).to eq("mount[foo]")
   end
 end
 
 describe Puppet::FileServing::Mount, " when initializing" do
   it "should fail on non-alphanumeric name" do
-    proc { Puppet::FileServing::Mount.new("non alpha") }.should raise_error(ArgumentError)
+    expect { Puppet::FileServing::Mount.new("non alpha") }.to raise_error(ArgumentError)
   end
 
   it "should allow dashes in its name" do
-    Puppet::FileServing::Mount.new("non-alpha").name.should == "non-alpha"
+    expect(Puppet::FileServing::Mount.new("non-alpha").name).to eq("non-alpha")
   end
 end
 
 describe Puppet::FileServing::Mount, " when finding files" do
   it "should fail" do
-    lambda { Puppet::FileServing::Mount.new("test").find("foo", :one => "two") }.should raise_error(NotImplementedError)
+    expect { Puppet::FileServing::Mount.new("test").find("foo", :one => "two") }.to raise_error(NotImplementedError)
   end
 end
 
 describe Puppet::FileServing::Mount, " when searching for files" do
   it "should fail" do
-    lambda { Puppet::FileServing::Mount.new("test").search("foo", :one => "two") }.should raise_error(NotImplementedError)
+    expect { Puppet::FileServing::Mount.new("test").search("foo", :one => "two") }.to raise_error(NotImplementedError)
   end
 end

data/spec/unit/file_serving/terminus_helper_spec.rb

@@ -17,6 +17,25 @@ describe Puppet::FileServing::TerminusHelper do
     Puppet::FileServing::Fileset.stubs(:new).with("/my/file", {}).returns(@fileset)
   end
 
+  it "should find a file with absolute path" do
+    file = stub 'file', :collect => nil
+    file.expects(:collect).with(nil)
+    @model.expects(:new).with("/my/file", {:relative_path => nil}).returns(file)
+    @helper.path2instance(@request, "/my/file")
+  end
+
+  it "should pass through links, checksum_type, and source_permissions" do
+    file = stub 'file', :checksum_type= => nil, :links= => nil, :collect => nil
+    [[:checksum_type, :sha256], [:links, true]].each {|k, v|
+      file.expects(k.to_s+'=').with(v)
+      @request.options[k] = v
+    }
+    @request.options[:source_permissions] = :yes
+    file.expects(:collect).with(:yes)
+    @model.expects(:new).with("/my/file", {:relative_path => :file}).returns(file)
+    @helper.path2instance(@request, "/my/file", {:relative_path => :file})
+  end
+
   it "should use a fileset to find paths" do
     @fileset = stub 'fileset', :files => [], :path => "/my/files"
     Puppet::FileServing::Fileset.expects(:new).with { |key, options| key == "/my/file" }.returns(@fileset)

data/spec/unit/file_serving/terminus_selector_spec.rb

@@ -14,17 +14,17 @@ describe Puppet::FileServing::TerminusSelector do
   describe "when being used to select termini" do
     it "should return :file if the request key is fully qualified" do
       @request.expects(:key).returns File.expand_path('/foo')
-      @object.select(@request).should == :file
+      expect(@object.select(@request)).to eq(:file)
     end
 
     it "should return :file if the URI protocol is set to 'file'" do
       @request.expects(:protocol).returns "file"
-      @object.select(@request).should == :file
+      expect(@object.select(@request)).to eq(:file)
     end
 
     it "should fail when a protocol other than :puppet or :file is used" do
       @request.stubs(:protocol).returns "http"
-      proc { @object.select(@request) }.should raise_error(ArgumentError)
+      expect { @object.select(@request) }.to raise_error(ArgumentError)
     end
 
     describe "and the protocol is 'puppet'" do
@@ -35,14 +35,14 @@ describe Puppet::FileServing::TerminusSelector do
       it "should choose :rest when a server is specified" do
         @request.stubs(:protocol).returns "puppet"
         @request.expects(:server).returns "foo"
-        @object.select(@request).should == :rest
+        expect(@object.select(@request)).to eq(:rest)
       end
 
       # This is so a given file location works when bootstrapping with no server.
       it "should choose :rest when default_file_terminus is rest" do
         @request.stubs(:protocol).returns "puppet"
         Puppet[:server] = 'localhost'
-        @object.select(@request).should == :rest
+        expect(@object.select(@request)).to eq(:rest)
       end
 
       it "should choose :file_server when default_file_terminus is file_server and no server is specified on the request" do
@@ -51,7 +51,7 @@ describe Puppet::FileServing::TerminusSelector do
         @request.expects(:protocol).returns "puppet"
         @request.expects(:server).returns nil
         Puppet[:default_file_terminus] = 'file_server'
-        @object.select(@request).should == :file_server
+        expect(@object.select(@request)).to eq(:file_server)
       end
     end
   end

data/spec/unit/file_system/uniquefile_spec.rb

@@ -29,7 +29,7 @@ describe Puppet::FileSystem::Uniquefile do
       file.path
     end
 
-    expect(Puppet::FileSystem.exist?(filename)).to be_false
+    expect(Puppet::FileSystem.exist?(filename)).to be_falsey
   end
 
   it "unlinks the temporary file even if the block raises an error" do
@@ -43,7 +43,7 @@ describe Puppet::FileSystem::Uniquefile do
     rescue
     end
 
-    expect(Puppet::FileSystem.exist?(filename)).to be_false
+    expect(Puppet::FileSystem.exist?(filename)).to be_falsey
   end
 
 

data/spec/unit/file_system_spec.rb

@@ -5,18 +5,6 @@ require 'puppet/util/platform'
 describe "Puppet::FileSystem" do
   include PuppetSpec::Files
 
-  def with_file_content(content)
-    path = tmpfile('file-system')
-    file = File.new(path, 'wb')
-    file.sync = true
-    file.print content
-
-    yield path
-
-  ensure
-    file.close
-  end
-
   context "#exclusive_open" do
     it "opens ands allows updating of an existing file" do
       file = file_containing("file_to_update", "the contents")
@@ -57,7 +45,7 @@ describe "Puppet::FileSystem" do
       expect(Puppet::FileSystem.read(file)).to eq("5")
     end
 
-    it "times out if the lock cannot be aquired in a specified amount of time", :unless => Puppet::Util::Platform.windows? do
+    it "times out if the lock cannot be acquired in a specified amount of time", :unless => Puppet::Util::Platform.windows? do
       file = tmpfile("file_to_update")
 
       child = spawn_process_that_locks(file)
@@ -108,32 +96,6 @@ describe "Puppet::FileSystem" do
     end
   end
 
-  context "read_preserve_line_endings" do
-    it "should read a file with line feed" do
-      with_file_content("file content \n") do |file|
-        expect(Puppet::FileSystem.read_preserve_line_endings(file)).to eq("file content \n")
-      end
-    end
-
-    it "should read a file with carriage return line feed" do
-      with_file_content("file content \r\n") do |file|
-        expect(Puppet::FileSystem.read_preserve_line_endings(file)).to eq("file content \r\n")
-      end
-    end
-
-    it "should read a mixed file using only the first line newline when lf" do
-      with_file_content("file content \nsecond line \r\n") do |file|
-        expect(Puppet::FileSystem.read_preserve_line_endings(file)).to eq("file content \nsecond line \r\n")
-      end
-    end
-
-    it "should read a mixed file using only the first line newline when crlf" do
-      with_file_content("file content \r\nsecond line \n") do |file|
-        expect(Puppet::FileSystem.read_preserve_line_endings(file)).to eq("file content \r\nsecond line \n")
-      end
-    end
-  end
-
   describe "symlink",
     :if => ! Puppet.features.manages_symlinks? &&
     Puppet.features.microsoft_windows? do
@@ -151,7 +113,7 @@ describe "Puppet::FileSystem" do
     end
 
     it "should return false when trying to check if a path is a symlink" do
-      Puppet::FileSystem.symlink?(file).should be_false
+      expect(Puppet::FileSystem.symlink?(file)).to be_falsey
     end
 
     it "should raise an error when trying to read a symlink" do
@@ -159,7 +121,7 @@ describe "Puppet::FileSystem" do
     end
 
     it "should return a File::Stat instance when calling stat on an existing file" do
-      Puppet::FileSystem.stat(file).should be_instance_of(File::Stat)
+      expect(Puppet::FileSystem.stat(file)).to be_instance_of(File::Stat)
     end
 
     it "should raise Errno::ENOENT when calling stat on a missing file" do
@@ -184,27 +146,27 @@ describe "Puppet::FileSystem" do
     end
 
     it "should return true for exist? on a present file" do
-      Puppet::FileSystem.exist?(file).should be_true
+      expect(Puppet::FileSystem.exist?(file)).to be_truthy
     end
 
     it "should return true for file? on a present file" do
-      Puppet::FileSystem.file?(file).should be_true
+      expect(Puppet::FileSystem.file?(file)).to be_truthy
     end
 
-    it "should return false for exist? on a non-existant file" do
-      Puppet::FileSystem.exist?(missing_file).should be_false
+    it "should return false for exist? on a non-existent file" do
+      expect(Puppet::FileSystem.exist?(missing_file)).to be_falsey
     end
 
     it "should return true for exist? on a present directory" do
-      Puppet::FileSystem.exist?(dir).should be_true
+      expect(Puppet::FileSystem.exist?(dir)).to be_truthy
     end
 
     it "should return false for exist? on a dangling symlink" do
       symlink = tmpfile("somefile_link")
       Puppet::FileSystem.symlink(missing_file, symlink)
 
-      Puppet::FileSystem.exist?(missing_file).should be_false
-      Puppet::FileSystem.exist?(symlink).should be_false
+      expect(Puppet::FileSystem.exist?(missing_file)).to be_falsey
+      expect(Puppet::FileSystem.exist?(symlink)).to be_falsey
     end
 
     it "should return true for exist? on valid symlinks" do
@@ -212,8 +174,8 @@ describe "Puppet::FileSystem" do
         symlink = tmpfile("#{Puppet::FileSystem.basename(target).to_s}_link")
         Puppet::FileSystem.symlink(target, symlink)
 
-        Puppet::FileSystem.exist?(target).should be_true
-        Puppet::FileSystem.exist?(symlink).should be_true
+        expect(Puppet::FileSystem.exist?(target)).to be_truthy
+        expect(Puppet::FileSystem.exist?(symlink)).to be_truthy
       end
     end
 
@@ -222,8 +184,8 @@ describe "Puppet::FileSystem" do
         symlink = tmpfile("#{Puppet::FileSystem.basename(target)}_link")
         Puppet::FileSystem.symlink(target, symlink, { :noop => true })
 
-        Puppet::FileSystem.exist?(target).should be_true
-        Puppet::FileSystem.exist?(symlink).should be_false
+        expect(Puppet::FileSystem.exist?(target)).to be_truthy
+        expect(Puppet::FileSystem.exist?(symlink)).to be_falsey
       end
     end
 
@@ -234,8 +196,8 @@ describe "Puppet::FileSystem" do
       [file, dir].each do |target|
         expect { Puppet::FileSystem.symlink(target, existing_file) }.to raise_error(Errno::EEXIST)
 
-        Puppet::FileSystem.exist?(existing_file).should be_true
-        Puppet::FileSystem.symlink?(existing_file).should be_false
+        expect(Puppet::FileSystem.exist?(existing_file)).to be_truthy
+        expect(Puppet::FileSystem.symlink?(existing_file)).to be_falsey
       end
     end
 
@@ -243,11 +205,11 @@ describe "Puppet::FileSystem" do
       existing_dir = tmpdir("#{Puppet::FileSystem.basename(file)}_dir")
 
       [file, dir].each do |target|
-        Puppet::FileSystem.symlink(target, existing_dir).should == 0
+        expect(Puppet::FileSystem.symlink(target, existing_dir)).to eq(0)
 
-        Puppet::FileSystem.exist?(existing_dir).should be_true
-        File.directory?(existing_dir).should be_true
-        Puppet::FileSystem.symlink?(existing_dir).should be_false
+        expect(Puppet::FileSystem.exist?(existing_dir)).to be_truthy
+        expect(File.directory?(existing_dir)).to be_truthy
+        expect(Puppet::FileSystem.symlink?(existing_dir)).to be_falsey
       end
     end
 
@@ -257,11 +219,11 @@ describe "Puppet::FileSystem" do
         symlink = tmpfile("#{Puppet::FileSystem.basename(existing_dir)}_link")
         Puppet::FileSystem.symlink(existing_dir, symlink)
 
-        Puppet::FileSystem.readlink(symlink).should == Puppet::FileSystem.path_string(existing_dir)
+        expect(Puppet::FileSystem.readlink(symlink)).to eq(Puppet::FileSystem.path_string(existing_dir))
 
         # now try to point it at the new target, no error raised, but file system unchanged
-        Puppet::FileSystem.symlink(target, symlink).should == 0
-        Puppet::FileSystem.readlink(symlink).should == existing_dir.to_s
+        expect(Puppet::FileSystem.symlink(target, symlink)).to eq(0)
+        expect(Puppet::FileSystem.readlink(symlink)).to eq(existing_dir.to_s)
       end
     end
 
@@ -274,7 +236,7 @@ describe "Puppet::FileSystem" do
 
       [file, dir].each do |target|
         expect { Puppet::FileSystem.symlink(target, symlink) }.to raise_error(Errno::EEXIST)
-        Puppet::FileSystem.readlink(symlink).should == file_2.to_s
+        expect(Puppet::FileSystem.readlink(symlink)).to eq(file_2.to_s)
       end
     end
 
@@ -282,12 +244,12 @@ describe "Puppet::FileSystem" do
       [file, dir].each do |target|
         existing_file = tmpfile("#{Puppet::FileSystem.basename(target)}_existing")
         FileUtils.touch(existing_file)
-        Puppet::FileSystem.symlink?(existing_file).should be_false
+        expect(Puppet::FileSystem.symlink?(existing_file)).to be_falsey
 
         Puppet::FileSystem.symlink(target, existing_file, { :force => true })
 
-        Puppet::FileSystem.symlink?(existing_file).should be_true
-        Puppet::FileSystem.readlink(existing_file).should == target.to_s
+        expect(Puppet::FileSystem.symlink?(existing_file)).to be_truthy
+        expect(Puppet::FileSystem.readlink(existing_file)).to eq(target.to_s)
       end
     end
 
@@ -298,11 +260,11 @@ describe "Puppet::FileSystem" do
         existing_symlink = tmpfile("#{Puppet::FileSystem.basename(existing_file)}_link")
         Puppet::FileSystem.symlink(existing_file, existing_symlink)
 
-        Puppet::FileSystem.readlink(existing_symlink).should == existing_file.to_s
+        expect(Puppet::FileSystem.readlink(existing_symlink)).to eq(existing_file.to_s)
 
         Puppet::FileSystem.symlink(target, existing_symlink, { :force => true })
 
-        Puppet::FileSystem.readlink(existing_symlink).should == target.to_s
+        expect(Puppet::FileSystem.readlink(existing_symlink)).to eq(target.to_s)
       end
     end
 
@@ -310,9 +272,9 @@ describe "Puppet::FileSystem" do
       [file, dir].each do |target|
         existing_dir = tmpdir("#{Puppet::FileSystem.basename(target)}_existing")
 
-        Puppet::FileSystem.symlink(target, existing_dir, { :force => true }).should == 0
+        expect(Puppet::FileSystem.symlink(target, existing_dir, { :force => true })).to eq(0)
 
-        Puppet::FileSystem.symlink?(existing_dir).should be_false
+        expect(Puppet::FileSystem.symlink?(existing_dir)).to be_falsey
       end
     end
 
@@ -322,11 +284,11 @@ describe "Puppet::FileSystem" do
         existing_symlink = tmpfile("#{Puppet::FileSystem.basename(existing_dir)}_link")
         Puppet::FileSystem.symlink(existing_dir, existing_symlink)
 
-        Puppet::FileSystem.readlink(existing_symlink).should == existing_dir.to_s
+        expect(Puppet::FileSystem.readlink(existing_symlink)).to eq(existing_dir.to_s)
 
-        Puppet::FileSystem.symlink(target, existing_symlink, { :force => true }).should == 0
+        expect(Puppet::FileSystem.symlink(target, existing_symlink, { :force => true })).to eq(0)
 
-        Puppet::FileSystem.readlink(existing_symlink).should == existing_dir.to_s
+        expect(Puppet::FileSystem.readlink(existing_symlink)).to eq(existing_dir.to_s)
       end
     end
 
@@ -334,11 +296,11 @@ describe "Puppet::FileSystem" do
       [ tmpfile('bogus1'),
         Pathname.new(tmpfile('bogus2')),
         Puppet::Util::WatchedFile.new(tmpfile('bogus3'))
-        ].each { |f| Puppet::FileSystem.exist?(f).should be_false  }
+        ].each { |f| expect(Puppet::FileSystem.exist?(f)).to be_falsey  }
     end
 
     it "should return a File::Stat instance when calling stat on an existing file" do
-      Puppet::FileSystem.stat(file).should be_instance_of(File::Stat)
+      expect(Puppet::FileSystem.stat(file)).to be_instance_of(File::Stat)
     end
 
     it "should raise Errno::ENOENT when calling stat on a missing file" do
@@ -349,12 +311,12 @@ describe "Puppet::FileSystem" do
       symlink = tmpfile("somefile_link")
       Puppet::FileSystem.symlink(file, symlink)
 
-      Puppet::FileSystem.symlink?(symlink).should be_true
+      expect(Puppet::FileSystem.symlink?(symlink)).to be_truthy
     end
 
     it "should report symlink? as false on file, directory and missing files" do
       [file, dir, missing_file].each do |f|
-      Puppet::FileSystem.symlink?(f).should be_false
+      expect(Puppet::FileSystem.symlink?(f)).to be_falsey
       end
     end
 
@@ -363,8 +325,8 @@ describe "Puppet::FileSystem" do
       Puppet::FileSystem.symlink(file, symlink)
 
       stat = Puppet::FileSystem.lstat(symlink)
-      stat.should be_instance_of(File::Stat)
-      stat.ftype.should == 'link'
+      expect(stat).to be_instance_of(File::Stat)
+      expect(stat.ftype).to eq('link')
     end
 
     it "should return a File::Stat of ftype 'link' when calling lstat on a symlink pointing to missing file" do
@@ -372,8 +334,8 @@ describe "Puppet::FileSystem" do
       Puppet::FileSystem.symlink(missing_file, symlink)
 
       stat = Puppet::FileSystem.lstat(symlink)
-      stat.should be_instance_of(File::Stat)
-      stat.ftype.should == 'link'
+      expect(stat).to be_instance_of(File::Stat)
+      expect(stat.ftype).to eq('link')
     end
 
     it "should return a File::Stat of ftype 'file' when calling stat on a symlink pointing to existing file" do
@@ -381,8 +343,8 @@ describe "Puppet::FileSystem" do
       Puppet::FileSystem.symlink(file, symlink)
 
       stat = Puppet::FileSystem.stat(symlink)
-      stat.should be_instance_of(File::Stat)
-      stat.ftype.should == 'file'
+      expect(stat).to be_instance_of(File::Stat)
+      expect(stat.ftype).to eq('file')
     end
 
     it "should return a File::Stat of ftype 'directory' when calling stat on a symlink pointing to existing directory" do
@@ -390,8 +352,8 @@ describe "Puppet::FileSystem" do
       Puppet::FileSystem.symlink(dir, symlink)
 
       stat = Puppet::FileSystem.stat(symlink)
-      stat.should be_instance_of(File::Stat)
-      stat.ftype.should == 'directory'
+      expect(stat).to be_instance_of(File::Stat)
+      expect(stat.ftype).to eq('directory')
 
       # on Windows, this won't get cleaned up if still linked
       Puppet::FileSystem.unlink(symlink)
@@ -406,7 +368,7 @@ describe "Puppet::FileSystem" do
       symlink2 = tmpfile("somefile_link2")
       Puppet::FileSystem.symlink(symlink, symlink2)
 
-      Puppet::FileSystem.stat(symlink2).ftype.should == 'file'
+      expect(Puppet::FileSystem.stat(symlink2).ftype).to eq('file')
     end
 
 
@@ -421,8 +383,8 @@ describe "Puppet::FileSystem" do
       symlink = tmpfile("somefile_link")
       Puppet::FileSystem.symlink(file, symlink)
 
-      Puppet::FileSystem.exist?(file).should be_true
-      Puppet::FileSystem.readlink(symlink).should == file.to_s
+      expect(Puppet::FileSystem.exist?(file)).to be_truthy
+      expect(Puppet::FileSystem.readlink(symlink)).to eq(file.to_s)
     end
 
     it "should not resolve entire symlink chain with readlink on a symlink'd symlink" do
@@ -434,16 +396,16 @@ describe "Puppet::FileSystem" do
       symlink2 = tmpfile("somefile_link2")
       Puppet::FileSystem.symlink(symlink, symlink2)
 
-      Puppet::FileSystem.exist?(file).should be_true
-      Puppet::FileSystem.readlink(symlink2).should == symlink.to_s
+      expect(Puppet::FileSystem.exist?(file)).to be_truthy
+      expect(Puppet::FileSystem.readlink(symlink2)).to eq(symlink.to_s)
     end
 
     it "should be able to readlink to resolve the physical path to a dangling symlink" do
       symlink = tmpfile("somefile_link")
       Puppet::FileSystem.symlink(missing_file, symlink)
 
-      Puppet::FileSystem.exist?(missing_file).should be_false
-      Puppet::FileSystem.readlink(symlink).should == missing_file.to_s
+      expect(Puppet::FileSystem.exist?(missing_file)).to be_falsey
+      expect(Puppet::FileSystem.readlink(symlink)).to eq(missing_file.to_s)
     end
 
     it "should delete only the symlink and not the target when calling unlink instance method" do
@@ -451,13 +413,13 @@ describe "Puppet::FileSystem" do
         symlink = tmpfile("#{Puppet::FileSystem.basename(target)}_link")
         Puppet::FileSystem.symlink(target, symlink)
 
-        Puppet::FileSystem.exist?(target).should be_true
-        Puppet::FileSystem.readlink(symlink).should == target.to_s
+        expect(Puppet::FileSystem.exist?(target)).to be_truthy
+        expect(Puppet::FileSystem.readlink(symlink)).to eq(target.to_s)
 
-        Puppet::FileSystem.unlink(symlink).should == 1 # count of files
+        expect(Puppet::FileSystem.unlink(symlink)).to eq(1) # count of files
 
-        Puppet::FileSystem.exist?(target).should be_true
-        Puppet::FileSystem.exist?(symlink).should be_false
+        expect(Puppet::FileSystem.exist?(target)).to be_truthy
+        expect(Puppet::FileSystem.exist?(symlink)).to be_falsey
       end
     end
 
@@ -466,48 +428,48 @@ describe "Puppet::FileSystem" do
         symlink = tmpfile("#{Puppet::FileSystem.basename(target)}_link")
         Puppet::FileSystem.symlink(target, symlink)
 
-        Puppet::FileSystem.exist?(target).should be_true
-        Puppet::FileSystem.readlink(symlink).should == target.to_s
+        expect(Puppet::FileSystem.exist?(target)).to be_truthy
+        expect(Puppet::FileSystem.readlink(symlink)).to eq(target.to_s)
 
-        Puppet::FileSystem.unlink(symlink).should == 1  # count of files
+        expect(Puppet::FileSystem.unlink(symlink)).to eq(1)  # count of files
 
-        Puppet::FileSystem.exist?(target).should be_true
-        Puppet::FileSystem.exist?(symlink).should be_false
+        expect(Puppet::FileSystem.exist?(target)).to be_truthy
+        expect(Puppet::FileSystem.exist?(symlink)).to be_falsey
       end
     end
 
     describe "unlink" do
       it "should delete files with unlink" do
-        Puppet::FileSystem.exist?(file).should be_true
+        expect(Puppet::FileSystem.exist?(file)).to be_truthy
 
-        Puppet::FileSystem.unlink(file).should == 1  # count of files
+        expect(Puppet::FileSystem.unlink(file)).to eq(1)  # count of files
 
-        Puppet::FileSystem.exist?(file).should be_false
+        expect(Puppet::FileSystem.exist?(file)).to be_falsey
       end
 
       it "should delete files with unlink class method" do
-        Puppet::FileSystem.exist?(file).should be_true
+        expect(Puppet::FileSystem.exist?(file)).to be_truthy
 
-        Puppet::FileSystem.unlink(file).should == 1  # count of files
+        expect(Puppet::FileSystem.unlink(file)).to eq(1)  # count of files
 
-        Puppet::FileSystem.exist?(file).should be_false
+        expect(Puppet::FileSystem.exist?(file)).to be_falsey
       end
 
       it "should delete multiple files with unlink class method" do
         paths = (1..3).collect do |i|
           f = tmpfile("somefile_#{i}")
           FileUtils.touch(f)
-          Puppet::FileSystem.exist?(f).should be_true
+          expect(Puppet::FileSystem.exist?(f)).to be_truthy
           f.to_s
         end
 
-        Puppet::FileSystem.unlink(*paths).should == 3  # count of files
+        expect(Puppet::FileSystem.unlink(*paths)).to eq(3)  # count of files
 
-        paths.each { |p| Puppet::FileSystem.exist?(p).should be_false  }
+        paths.each { |p| expect(Puppet::FileSystem.exist?(p)).to be_falsey  }
       end
 
       it "should raise Errno::EPERM or Errno::EISDIR when trying to delete a directory with the unlink class method" do
-        Puppet::FileSystem.exist?(dir).should be_true
+        expect(Puppet::FileSystem.exist?(dir)).to be_truthy
 
         ex = nil
         begin
@@ -516,26 +478,26 @@ describe "Puppet::FileSystem" do
           ex = e
         end
 
-        [
+        expect([
           Errno::EPERM, # Windows and OSX
           Errno::EISDIR # Linux
-        ].should include(ex.class)
+        ]).to include(ex.class)
 
-        Puppet::FileSystem.exist?(dir).should be_true
+        expect(Puppet::FileSystem.exist?(dir)).to be_truthy
       end
     end
 
     describe "exclusive_create" do
       it "should create a file that doesn't exist" do
-        Puppet::FileSystem.exist?(missing_file).should be_false
+        expect(Puppet::FileSystem.exist?(missing_file)).to be_falsey
 
         Puppet::FileSystem.exclusive_create(missing_file, nil) {}
 
-        Puppet::FileSystem.exist?(missing_file).should be_true
+        expect(Puppet::FileSystem.exist?(missing_file)).to be_truthy
       end
 
       it "should raise Errno::EEXIST creating a file that does exist" do
-        Puppet::FileSystem.exist?(file).should be_true
+        expect(Puppet::FileSystem.exist?(file)).to be_truthy
 
         expect do
           Puppet::FileSystem.exclusive_create(file, nil) {}