puppet 3.8.7 → 4.0.0.rc1

data/spec/unit/file_serving/content_spec.rb

@@ -7,73 +7,61 @@ describe Puppet::FileServing::Content do
   let(:path) { File.expand_path('/path') }
 
   it "should be a subclass of Base" do
-    Puppet::FileServing::Content.superclass.should equal(Puppet::FileServing::Base)
+    expect(Puppet::FileServing::Content.superclass).to equal(Puppet::FileServing::Base)
   end
 
   it "should indirect file_content" do
-    Puppet::FileServing::Content.indirection.name.should == :file_content
+    expect(Puppet::FileServing::Content.indirection.name).to eq(:file_content)
   end
 
-  it "should only support the raw format" do
-    Puppet::FileServing::Content.supported_formats.should == [:raw]
+  it "should only support the binary format" do
+    expect(Puppet::FileServing::Content.supported_formats).to eq([:binary])
   end
 
   it "should have a method for collecting its attributes" do
-    Puppet::FileServing::Content.new(path).should respond_to(:collect)
+    expect(Puppet::FileServing::Content.new(path)).to respond_to(:collect)
   end
 
-  it "should not retrieve and store its contents when its attributes are collected if the file is a normal file" do
+  it "should not retrieve and store its contents when its attributes are collected" do
     content = Puppet::FileServing::Content.new(path)
 
     result = "foo"
-    Puppet::FileSystem.expects(:lstat).with(path).returns stub('stat', :ftype => "file")
     File.expects(:read).with(path).never
     content.collect
 
-    content.instance_variable_get("@content").should be_nil
-  end
-
-  it "should not attempt to retrieve its contents if the file is a directory" do
-    content = Puppet::FileServing::Content.new(path)
-
-    result = "foo"
-    Puppet::FileSystem.expects(:lstat).with(path).returns stub('stat', :ftype => "directory")
-    File.expects(:read).with(path).never
-    content.collect
-
-    content.instance_variable_get("@content").should be_nil
+    expect(content.instance_variable_get("@content")).to be_nil
   end
 
   it "should have a method for setting its content" do
     content = Puppet::FileServing::Content.new(path)
-    content.should respond_to(:content=)
+    expect(content).to respond_to(:content=)
   end
 
   it "should make content available when set externally" do
     content = Puppet::FileServing::Content.new(path)
     content.content = "foo/bar"
-    content.content.should == "foo/bar"
+    expect(content.content).to eq("foo/bar")
   end
 
-  it "should be able to create a content instance from raw file contents" do
-    Puppet::FileServing::Content.should respond_to(:from_raw)
+  it "should be able to create a content instance from binary file contents" do
+    expect(Puppet::FileServing::Content).to respond_to(:from_binary)
   end
 
-  it "should create an instance with a fake file name and correct content when converting from raw" do
+  it "should create an instance with a fake file name and correct content when converting from binary" do
     instance = mock 'instance'
     Puppet::FileServing::Content.expects(:new).with("/this/is/a/fake/path").returns instance
 
     instance.expects(:content=).with "foo/bar"
 
-    Puppet::FileServing::Content.from_raw("foo/bar").should equal(instance)
+    expect(Puppet::FileServing::Content.from_binary("foo/bar")).to equal(instance)
   end
 
-  it "should return an opened File when converted to raw" do
+  it "should return an opened File when converted to binary" do
     content = Puppet::FileServing::Content.new(path)
 
     File.expects(:new).with(path, "rb").returns :file
 
-    content.to_raw.should == :file
+    expect(content.to_binary).to eq(:file)
   end
 end
 
@@ -84,22 +72,22 @@ describe Puppet::FileServing::Content, "when returning the contents" do
   it "should fail if the file is a symlink and links are set to :manage" do
     content.links = :manage
     Puppet::FileSystem.expects(:lstat).with(path).returns stub("stat", :ftype => "symlink")
-    proc { content.content }.should raise_error(ArgumentError)
+    expect { content.content }.to raise_error(ArgumentError)
   end
 
   it "should fail if a path is not set" do
-    proc { content.content }.should raise_error(Errno::ENOENT)
+    expect { content.content }.to raise_error(Errno::ENOENT)
   end
 
   it "should raise Errno::ENOENT if the file is absent" do
     content.path = File.expand_path("/there/is/absolutely/no/chance/that/this/path/exists")
-    proc { content.content }.should raise_error(Errno::ENOENT)
+    expect { content.content }.to raise_error(Errno::ENOENT)
   end
 
   it "should return the contents of the path if the file exists" do
     Puppet::FileSystem.expects(:stat).with(path).returns(stub('stat', :ftype => 'file'))
     Puppet::FileSystem.expects(:binread).with(path).returns(:mycontent)
-    content.content.should == :mycontent
+    expect(content.content).to eq(:mycontent)
   end
 
   it "should cache the returned contents" do

data/spec/unit/file_serving/fileset_spec.rb

@@ -20,14 +20,14 @@ describe Puppet::FileServing::Fileset do
       path_with_separator = "#{somefile}#{File::SEPARATOR}"
       Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       fileset = Puppet::FileServing::Fileset.new(path_with_separator)
-      fileset.path.should == somefile
+      expect(fileset.path).to eq(somefile)
     end
 
     it "can be created from the root directory" do
       path = File.expand_path(File::SEPARATOR)
       Puppet::FileSystem.expects(:lstat).with(path).returns stub('stat')
       fileset = Puppet::FileServing::Fileset.new(path)
-      fileset.path.should == path
+      expect(fileset.path).to eq(path)
     end
 
     it "fails if its path does not exist" do
@@ -38,31 +38,31 @@ describe Puppet::FileServing::Fileset do
     it "accepts a 'recurse' option" do
       Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       set = Puppet::FileServing::Fileset.new(somefile, :recurse => true)
-      set.recurse.should be_true
+      expect(set.recurse).to be_truthy
     end
 
     it "accepts a 'recurselimit' option" do
       Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       set = Puppet::FileServing::Fileset.new(somefile, :recurselimit => 3)
-      set.recurselimit.should == 3
+      expect(set.recurselimit).to eq(3)
     end
 
     it "accepts an 'ignore' option" do
       Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       set = Puppet::FileServing::Fileset.new(somefile, :ignore => ".svn")
-      set.ignore.should == [".svn"]
+      expect(set.ignore).to eq([".svn"])
     end
 
     it "accepts a 'links' option" do
       Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       set = Puppet::FileServing::Fileset.new(somefile, :links => :manage)
-      set.links.should == :manage
+      expect(set.links).to eq(:manage)
     end
 
     it "accepts a 'checksum_type' option" do
       Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
       set = Puppet::FileServing::Fileset.new(somefile, :checksum_type => :test)
-      set.checksum_type.should == :test
+      expect(set.checksum_type).to eq(:test)
     end
 
     it "fails if 'links' is set to anything other than :manage or :follow" do
@@ -71,27 +71,26 @@ describe Puppet::FileServing::Fileset do
 
     it "defaults to 'false' for recurse" do
       Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
-      Puppet::FileServing::Fileset.new(somefile).recurse.should == false
+      expect(Puppet::FileServing::Fileset.new(somefile).recurse).to eq(false)
     end
 
     it "defaults to :infinite for recurselimit" do
       Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
-      Puppet::FileServing::Fileset.new(somefile).recurselimit.should == :infinite
+      expect(Puppet::FileServing::Fileset.new(somefile).recurselimit).to eq(:infinite)
     end
 
     it "defaults to an empty ignore list" do
       Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
-      Puppet::FileServing::Fileset.new(somefile).ignore.should == []
+      expect(Puppet::FileServing::Fileset.new(somefile).ignore).to eq([])
     end
 
     it "defaults to :manage for links" do
       Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
-      Puppet::FileServing::Fileset.new(somefile).links.should == :manage
+      expect(Puppet::FileServing::Fileset.new(somefile).links).to eq(:manage)
     end
 
     describe "using an indirector request" do
       let(:values) { { :links => :manage, :ignore => %w{a b}, :recurse => true, :recurselimit => 1234 } }
-      let(:stub_file) { stub(somefile, :lstat => stub('stat')) }
 
       before :each do
         Puppet::FileSystem.expects(:lstat).with(somefile).returns stub('stat')
@@ -101,7 +100,7 @@ describe Puppet::FileServing::Fileset do
         it "passes the #{option} option on to the fileset if present" do
           request = Puppet::Indirector::Request.new(:file_serving, :find, "foo", nil, {option => values[option]})
 
-          Puppet::FileServing::Fileset.new(somefile, request).send(option).should == values[option]
+          expect(Puppet::FileServing::Fileset.new(somefile, request).send(option)).to eq(values[option])
         end
       end
 
@@ -109,21 +108,21 @@ describe Puppet::FileServing::Fileset do
         request = Puppet::Indirector::Request.new(:file_serving, :find, "foo", nil,
                                                   {:recurselimit => "1234"})
 
-        Puppet::FileServing::Fileset.new(somefile, request).recurselimit.should == 1234
+        expect(Puppet::FileServing::Fileset.new(somefile, request).recurselimit).to eq(1234)
       end
 
       it "converts the string 'true' to the boolean true when setting options" do
         request = Puppet::Indirector::Request.new(:file_serving, :find, "foo", nil,
                                                   {:recurse => "true"})
 
-        Puppet::FileServing::Fileset.new(somefile, request).recurse.should == true
+        expect(Puppet::FileServing::Fileset.new(somefile, request).recurse).to eq(true)
       end
 
       it "converts the string 'false' to the boolean false when setting options" do
         request = Puppet::Indirector::Request.new(:file_serving, :find, "foo", nil,
                                                   {:recurse => "false"})
 
-        Puppet::FileServing::Fileset.new(somefile, request).recurse.should == false
+        expect(Puppet::FileServing::Fileset.new(somefile, request).recurse).to eq(false)
       end
     end
   end
@@ -198,32 +197,32 @@ describe Puppet::FileServing::Fileset do
       fileset = Puppet::FileServing::Fileset.new(make_absolute('/your/path'))
       fileset.recurse = true
       fileset.links = :manage
-      fileset.files.should == [".", "dir1", "file", "dir1/a", "dir1/a/f"]
+      expect(fileset.files).to eq([".", "dir1", "file", "dir1/a", "dir1/a/f"])
     end
 
     it "recurses through the whole file tree if :recurse is set to 'true'" do
       mock_dir_structure(@path)
       @fileset.recurse = true
-      @fileset.files.sort.should == @files.sort
+      expect(@fileset.files.sort).to eq(@files.sort)
     end
 
     it "does not recurse if :recurse is set to 'false'" do
       mock_dir_structure(@path)
       @fileset.recurse = false
-      @fileset.files.should == %w{.}
+      expect(@fileset.files).to eq(%w{.})
     end
 
     it "recurses to the level set by :recurselimit" do
       mock_dir_structure(@path)
       @fileset.recurse = true
       @fileset.recurselimit = 1
-      @fileset.files.should == %w{. one two .svn CVS}
+      expect(@fileset.files).to eq(%w{. one two .svn CVS})
     end
 
     it "ignores the '.' and '..' directories in subdirectories" do
       mock_dir_structure(@path)
       @fileset.recurse = true
-      @fileset.files.sort.should == @files.sort
+      expect(@fileset.files.sort).to eq(@files.sort)
     end
 
     it "does not fail if the :ignore value provided is nil" do
@@ -237,42 +236,42 @@ describe Puppet::FileServing::Fileset do
       mock_dir_structure(@path)
       @fileset.recurse = true
       @fileset.ignore = ".svn"
-      @fileset.files.find { |file| file.include?(".svn") }.should be_nil
+      expect(@fileset.files.find { |file| file.include?(".svn") }).to be_nil
     end
 
     it "ignores files that match any of multiple patterns in the ignore list" do
       mock_dir_structure(@path)
       @fileset.recurse = true
       @fileset.ignore = %w{.svn CVS}
-      @fileset.files.find { |file| file.include?(".svn") or file.include?("CVS") }.should be_nil
+      expect(@fileset.files.find { |file| file.include?(".svn") or file.include?("CVS") }).to be_nil
     end
 
     it "ignores files that match a pattern given as a number" do
       mock_dir_structure(@path)
       @fileset.recurse = true
       @fileset.ignore = [0]
-      @fileset.files.find { |file| file.include?("0") }.should be_nil
+      expect(@fileset.files.find { |file| file.include?("0") }).to be_nil
     end
 
     it "ignores files that match a pattern given as a boolean" do
       mock_dir_structure(@path)
       @fileset.recurse = true
       @fileset.ignore = [false]
-      @fileset.files.find { |file| file.include?("false") }.should be_nil
+      expect(@fileset.files.find { |file| file.include?("false") }).to be_nil
     end
 
     it "uses Puppet::FileSystem#stat if :links is set to :follow" do
       mock_dir_structure(@path, :stat)
       @fileset.recurse = true
       @fileset.links = :follow
-      @fileset.files.sort.should == @files.sort
+      expect(@fileset.files.sort).to eq(@files.sort)
     end
 
     it "uses Puppet::FileSystem#lstat if :links is set to :manage" do
       mock_dir_structure(@path, :lstat)
       @fileset.recurse = true
       @fileset.links = :manage
-      @fileset.files.sort.should == @files.sort
+      expect(@fileset.files.sort).to eq(@files.sort)
     end
 
     it "works when paths have regexp significant characters" do
@@ -283,7 +282,7 @@ describe Puppet::FileServing::Fileset do
       @fileset = Puppet::FileServing::Fileset.new(@path)
       mock_dir_structure(@path)
       @fileset.recurse = true
-      @fileset.files.sort.should == @files.sort
+      expect(@fileset.files.sort).to eq(@files.sort)
     end
   end
 
@@ -304,7 +303,7 @@ describe Puppet::FileServing::Fileset do
     fileset.links = :follow
     fileset.recurse = true
 
-    fileset.files.sort.should == %w{. mylink}.sort
+    expect(fileset.files.sort).to eq(%w{. mylink}.sort)
   end
 
   context "when merging other filesets" do
@@ -325,7 +324,7 @@ describe Puppet::FileServing::Fileset do
       Dir.expects(:entries).with(make_absolute("/second/path")).returns(%w{two dos})
       Dir.expects(:entries).with(make_absolute("/third/path")).returns(%w{three tres})
 
-      Puppet::FileServing::Fileset.merge(*@filesets).should == {
+      expect(Puppet::FileServing::Fileset.merge(*@filesets)).to eq({
         "." => make_absolute("/first/path"),
         "one" => make_absolute("/first/path"),
         "uno" => make_absolute("/first/path"),
@@ -333,21 +332,21 @@ describe Puppet::FileServing::Fileset do
         "dos" => make_absolute("/second/path"),
         "three" => make_absolute("/third/path"),
         "tres" => make_absolute("/third/path"),
-      }
+      })
     end
 
     it "includes the base directory from the first fileset" do
       Dir.expects(:entries).with(make_absolute("/first/path")).returns(%w{one})
       Dir.expects(:entries).with(make_absolute("/second/path")).returns(%w{two})
 
-      Puppet::FileServing::Fileset.merge(*@filesets)["."].should == make_absolute("/first/path")
+      expect(Puppet::FileServing::Fileset.merge(*@filesets)["."]).to eq(make_absolute("/first/path"))
     end
 
     it "uses the base path of the first found file when relative file paths conflict" do
       Dir.expects(:entries).with(make_absolute("/first/path")).returns(%w{one})
       Dir.expects(:entries).with(make_absolute("/second/path")).returns(%w{one})
 
-      Puppet::FileServing::Fileset.merge(*@filesets)["one"].should == make_absolute("/first/path")
+      expect(Puppet::FileServing::Fileset.merge(*@filesets)["one"]).to eq(make_absolute("/first/path"))
     end
   end
 end

data/spec/unit/file_serving/metadata_spec.rb

@@ -7,82 +7,74 @@ describe Puppet::FileServing::Metadata do
   let(:foobar) { File.expand_path('/foo/bar') }
 
   it "should be a subclass of Base" do
-    Puppet::FileServing::Metadata.superclass.should equal(Puppet::FileServing::Base)
+    expect(Puppet::FileServing::Metadata.superclass).to equal(Puppet::FileServing::Base)
   end
 
   it "should indirect file_metadata" do
-    Puppet::FileServing::Metadata.indirection.name.should == :file_metadata
+    expect(Puppet::FileServing::Metadata.indirection.name).to eq(:file_metadata)
   end
 
   it "should have a method that triggers attribute collection" do
-    Puppet::FileServing::Metadata.new(foobar).should respond_to(:collect)
+    expect(Puppet::FileServing::Metadata.new(foobar)).to respond_to(:collect)
   end
 
   it "should support pson serialization" do
-    Puppet::FileServing::Metadata.new(foobar).should respond_to(:to_pson)
-  end
-
-  it "should support to_pson_data_hash" do
-    Puppet::FileServing::Metadata.new(foobar).should respond_to(:to_pson_data_hash)
+    expect(Puppet::FileServing::Metadata.new(foobar)).to respond_to(:to_pson)
   end
 
   it "should support deserialization" do
-    Puppet::FileServing::Metadata.should respond_to(:from_data_hash)
+    expect(Puppet::FileServing::Metadata).to respond_to(:from_data_hash)
   end
 
   describe "when serializing" do
     let(:metadata) { Puppet::FileServing::Metadata.new(foobar) }
 
-    it "should serialize as FileMetadata" do
-      metadata.to_pson_data_hash['document_type'].should == "FileMetadata"
-    end
-
     it "the data should include the path, relative_path, links, owner, group, mode, checksum, type, and destination" do
-      metadata.to_pson_data_hash['data'].keys.sort.should == %w{ path relative_path links owner group mode checksum type destination }.sort
+      expect(metadata.to_data_hash.keys.sort).to eq(%w{ path relative_path links owner group mode checksum type destination }.sort)
     end
 
     it "should pass the path in the hash verbatim" do
-      metadata.to_pson_data_hash['data']['path'].should == metadata.path
+      expect(metadata.to_data_hash['path']).to eq(metadata.path)
     end
 
     it "should pass the relative_path in the hash verbatim" do
-      metadata.to_pson_data_hash['data']['relative_path'].should == metadata.relative_path
+      expect(metadata.to_data_hash['relative_path']).to eq(metadata.relative_path)
     end
 
     it "should pass the links in the hash verbatim" do
-      metadata.to_pson_data_hash['data']['links'].should == metadata.links
+      expect(metadata.to_data_hash['links']).to eq(metadata.links)
     end
 
     it "should pass the path owner in the hash verbatim" do
-      metadata.to_pson_data_hash['data']['owner'].should == metadata.owner
+      expect(metadata.to_data_hash['owner']).to eq(metadata.owner)
     end
 
     it "should pass the group in the hash verbatim" do
-      metadata.to_pson_data_hash['data']['group'].should == metadata.group
+      expect(metadata.to_data_hash['group']).to eq(metadata.group)
     end
 
     it "should pass the mode in the hash verbatim" do
-      metadata.to_pson_data_hash['data']['mode'].should == metadata.mode
+      expect(metadata.to_data_hash['mode']).to eq(metadata.mode)
     end
 
     it "should pass the ftype in the hash verbatim as the 'type'" do
-      metadata.to_pson_data_hash['data']['type'].should == metadata.ftype
+      expect(metadata.to_data_hash['type']).to eq(metadata.ftype)
     end
 
     it "should pass the destination verbatim" do
-      metadata.to_pson_data_hash['data']['destination'].should == metadata.destination
+      expect(metadata.to_data_hash['destination']).to eq(metadata.destination)
     end
 
     it "should pass the checksum in the hash as a nested hash" do
-      metadata.to_pson_data_hash['data']['checksum'].should be_is_a(Hash)
+      expect(metadata.to_data_hash['checksum']).to be_is_a(Hash)
     end
 
     it "should pass the checksum_type in the hash verbatim as the checksum's type" do
-      metadata.to_pson_data_hash['data']['checksum']['type'].should == metadata.checksum_type
+      expect(metadata.to_data_hash['checksum']['type']).to eq(metadata.checksum_type)
     end
 
     it "should pass the checksum in the hash verbatim as the checksum's value" do
-      metadata.to_pson_data_hash['data']['checksum']['value'].should == metadata.checksum
+      expect(metadata.to_data_hash['checksum']['value']).to eq(metadata.checksum)
     end
   end
 end
@@ -101,25 +93,12 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
     describe "when collecting attributes" do
       describe "when managing files" do
         let(:path) { tmpfile('file_serving_metadata') }
+        let(:time) { Time.now }
 
         before :each do
           FileUtils.touch(path)
         end
 
-        it "should set the owner to the file's current owner" do
-          metadata.owner.should == owner
-        end
-
-        it "should set the group to the file's current group" do
-          metadata.group.should == group
-        end
-
-        it "should set the mode to the file's masked mode" do
-          set_mode(33261, path)
-
-          metadata.mode.should == 0755
-        end
-
         describe "checksumming" do
           with_digest_algorithms do
             before :each do
@@ -127,17 +106,30 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
             end
 
             it "should default to a checksum of the proper type with the file's current checksum" do
-              metadata.checksum.should == "{#{digest_algorithm}}#{checksum}"
+              expect(metadata.checksum).to eq("{#{digest_algorithm}}#{checksum}")
             end
 
-            it "should give a mtime checksum when checksum_type is set" do
-              time = Time.now
-              metadata.checksum_type = "mtime"
-              metadata.expects(:mtime_file).returns(@time)
+            it "should give a #{Puppet[:digest_algorithm]} when checksum_type is set" do
+              Puppet[:digest_algorithm] = nil
+              metadata.checksum_type = digest_algorithm
               metadata.collect
-              metadata.checksum.should == "{mtime}#{@time}"
+              expect(metadata.checksum).to eq("{#{digest_algorithm}}#{checksum}")
             end
           end
+
+          it "should give a mtime checksum when checksum_type is set" do
+            metadata.checksum_type = "mtime"
+            metadata.expects(:mtime_file).returns(time)
+            metadata.collect
+            expect(metadata.checksum).to eq("{mtime}#{time}")
+          end
+
+          it "should give a ctime checksum when checksum_type is set" do
+            metadata.checksum_type = "ctime"
+            metadata.expects(:ctime_file).returns(time)
+            metadata.collect
+            expect(metadata.checksum).to eq("{ctime}#{time}")
+          end
         end
 
         it "should validate against the schema" do
@@ -155,14 +147,14 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
 
         it "should only use checksums of type 'ctime' for directories" do
           metadata.collect
-          metadata.checksum.should == "{ctime}#{time}"
+          expect(metadata.checksum).to eq("{ctime}#{time}")
         end
 
         it "should only use checksums of type 'ctime' for directories even if checksum_type set" do
           metadata.checksum_type = "mtime"
           metadata.expects(:mtime_file).never
           metadata.collect
-          metadata.checksum.should == "{ctime}#{time}"
+          expect(metadata.checksum).to eq("{ctime}#{time}")
         end
 
         it "should validate against the schema" do
@@ -189,9 +181,9 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
 
       win_stat = Puppet::FileServing::Metadata::WindowsStat.new(stat, path)
 
-      win_stat.owner.should == 'S-1-5-32-544'
-      win_stat.group.should == 'S-1-0-0'
-      win_stat.mode.should == 0644
+      expect(win_stat.owner).to eq('S-1-5-32-544')
+      expect(win_stat.group).to eq('S-1-0-0')
+      expect(win_stat.mode).to eq(0644)
     end
 
     it "should still raise errors that are not the result of an 'Invalid DACL'" do
@@ -199,17 +191,13 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
       path = tmpfile('bar')
       FileUtils.touch(path)
 
-      Puppet::Util::Windows::Security.stubs(:get_owner).with(path).raises(invalid_error)
-      Puppet::Util::Windows::Security.stubs(:get_group).with(path).raises(invalid_error)
-      Puppet::Util::Windows::Security.stubs(:get_mode).with(path).raises(invalid_error)
+      Puppet::Util::Windows::Security.stubs(:get_owner).with(path, :use).raises(invalid_error)
+      Puppet::Util::Windows::Security.stubs(:get_group).with(path, :use).raises(invalid_error)
+      Puppet::Util::Windows::Security.stubs(:get_mode).with(path, :use).raises(invalid_error)
 
       stat = Puppet::FileSystem.stat(path)
 
-      win_stat = Puppet::FileServing::Metadata::WindowsStat.new(stat, path)
-
-      expect { win_stat.owner }.to raise_error(ArgumentError)
-      expect { win_stat.group }.to raise_error(ArgumentError)
-      expect { win_stat.mode }.to raise_error(ArgumentError)
+      expect { Puppet::FileServing::Metadata::WindowsStat.new(stat, path, :use) }.to raise_error("Unsupported Windows source permissions option use")
     end
   end
 
@@ -236,7 +224,7 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
         end
 
         it "should read links instead of returning their checksums" do
-          metadata.destination.should == target
+          expect(metadata.destination).to eq(target)
         end
 
         it "should validate against the schema" do
@@ -270,7 +258,7 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
       it "should raise an exception if the file does not exist" do
         File.delete(path)
 
-        proc { metadata.collect}.should raise_error(Errno::ENOENT)
+        expect { metadata.collect}.to raise_error(Errno::ENOENT)
       end
 
       it "should validate against the schema" do
@@ -288,6 +276,34 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
       File::Stat.any_instance.stubs(:gid).returns group
     end
 
+    describe "when collecting attributes when managing files" do
+      let(:metadata) do
+        data = described_class.new(path)
+        data.collect
+        data
+      end
+
+      let(:path) { tmpfile('file_serving_metadata') }
+
+      before :each do
+        FileUtils.touch(path)
+      end
+
+      it "should set the owner to the Process's current owner" do
+        expect(metadata.owner).to eq(Process.euid)
+      end
+
+      it "should set the group to the Process's current group" do
+        expect(metadata.group).to eq(Process.egid)
+      end
+
+      it "should set the mode to the default mode" do
+        set_mode(33261, path)
+
+        expect(metadata.mode).to eq(0644)
+      end
+    end
+
     it_should_behave_like "metadata collector"
     it_should_behave_like "metadata collector symlinks"
 
@@ -306,6 +322,34 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
       Puppet::Util::Windows::Security.stubs(:get_group).returns group
     end
 
+    describe "when collecting attributes when managing files" do
+      let(:metadata) do
+        data = described_class.new(path)
+        data.collect
+        data
+      end
+
+      let(:path) { tmpfile('file_serving_metadata') }
+
+      before :each do
+        FileUtils.touch(path)
+      end
+
+      it "should set the owner to the Process's current owner" do
+        expect(metadata.owner).to eq("S-1-5-32-544")
+      end
+
+      it "should set the group to the Process's current group" do
+        expect(metadata.group).to eq("S-1-0-0")
+      end
+
+      it "should set the mode to the default mode" do
+        set_mode(33261, path)
+
+        expect(metadata.mode).to eq(0644)
+      end
+    end
+
     it_should_behave_like "metadata collector"
     it_should_behave_like "metadata collector symlinks" if Puppet.features.manages_symlinks?
 
@@ -323,19 +367,19 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
       it "should default owner" do
         Puppet::Util::Windows::Security.stubs(:get_owner).returns nil
 
-        metadata.owner.should == 'S-1-5-32-544'
+        expect(metadata.owner).to eq('S-1-5-32-544')
       end
 
       it "should default group" do
         Puppet::Util::Windows::Security.stubs(:get_group).returns nil
 
-        metadata.group.should == 'S-1-0-0'
+        expect(metadata.group).to eq('S-1-0-0')
       end
 
       it "should default mode" do
         Puppet::Util::Windows::Security.stubs(:get_mode).returns nil
 
-        metadata.mode.should == 0644
+        expect(metadata.mode).to eq(0644)
       end
 
       describe "when the path raises an Invalid ACL error" do
@@ -343,19 +387,19 @@ describe Puppet::FileServing::Metadata, :uses_checksums => true do
         it "should default owner" do
           Puppet::Util::Windows::Security.stubs(:get_owner).raises(invalid_dacl_error)
 
-          metadata.owner.should == 'S-1-5-32-544'
+          expect(metadata.owner).to eq('S-1-5-32-544')
         end
 
         it "should default group" do
           Puppet::Util::Windows::Security.stubs(:get_group).raises(invalid_dacl_error)
 
-          metadata.group.should == 'S-1-0-0'
+          expect(metadata.group).to eq('S-1-0-0')
         end
 
         it "should default mode" do
           Puppet::Util::Windows::Security.stubs(:get_mode).raises(invalid_dacl_error)
 
-          metadata.mode.should == 0644
+          expect(metadata.mode).to eq(0644)
         end
       end
 
@@ -390,16 +434,16 @@ describe Puppet::FileServing::Metadata, " when pointing to a link", :if => Puppe
 
       it "should store the destination of the link in :destination if links are :manage" do
         @file.collect
-        @file.destination.should == "/some/other/path"
+        expect(@file.destination).to eq("/some/other/path")
       end
       pending "should not collect the checksum if links are :manage" do
         # We'd like this to be true, but we need to always collect the checksum because in the server/client/server round trip we lose the distintion between manage and follow.
         @file.collect
-        @file.checksum.should be_nil
+        expect(@file.checksum).to be_nil
       end
       it "should collect the checksum if links are :manage" do # see pending note above
         @file.collect
-        @file.checksum.should == "{#{digest_algorithm}}#{checksum}"
+        expect(@file.checksum).to eq("{#{digest_algorithm}}#{checksum}")
       end
     end
 
@@ -421,11 +465,11 @@ describe Puppet::FileServing::Metadata, " when pointing to a link", :if => Puppe
       end
       it "should not store the destination of the link in :destination if links are :follow" do
         @file.collect
-        @file.destination.should be_nil
+        expect(@file.destination).to be_nil
       end
       it "should collect the checksum if links are :follow" do
         @file.collect
-        @file.checksum.should == "{#{digest_algorithm}}#{checksum}"
+        expect(@file.checksum).to eq("{#{digest_algorithm}}#{checksum}")
       end
     end
   end