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

data/spec/unit/indirector/facts/facter_spec.rb

@@ -7,20 +7,20 @@ describe Puppet::Node::Facts::Facter do
   FS = Puppet::FileSystem
 
   it "should be a subclass of the Code terminus" do
-    Puppet::Node::Facts::Facter.superclass.should equal(Puppet::Indirector::Code)
+    expect(Puppet::Node::Facts::Facter.superclass).to equal(Puppet::Indirector::Code)
   end
 
   it "should have documentation" do
-    Puppet::Node::Facts::Facter.doc.should_not be_nil
+    expect(Puppet::Node::Facts::Facter.doc).not_to be_nil
   end
 
   it "should be registered with the configuration store indirection" do
     indirection = Puppet::Indirector::Indirection.instance(:facts)
-    Puppet::Node::Facts::Facter.indirection.should equal(indirection)
+    expect(Puppet::Node::Facts::Facter.indirection).to equal(indirection)
   end
 
   it "should have its name set to :facter" do
-    Puppet::Node::Facts::Facter.name.should == :facter
+    expect(Puppet::Node::Facts::Facter.name).to eq(:facter)
   end
 
   before :each do
@@ -61,17 +61,17 @@ describe Puppet::Node::Facts::Facter do
     end
 
     it "should return a Facts instance" do
-      @facter.find(@request).should be_instance_of(Puppet::Node::Facts)
+      expect(@facter.find(@request)).to be_instance_of(Puppet::Node::Facts)
     end
 
     it "should return a Facts instance with the provided key as the name" do
-      @facter.find(@request).name.should == @name
+      expect(@facter.find(@request).name).to eq(@name)
     end
 
     it "should return the Facter facts as the values in the Facts instance" do
       Facter.expects(:to_hash).returns("one" => "two")
       facts = @facter.find(@request)
-      facts.values["one"].should == "two"
+      expect(facts.values["one"]).to eq("two")
     end
 
     it "should add local facts" do
@@ -82,17 +82,7 @@ describe Puppet::Node::Facts::Facter do
       @facter.find(@request)
     end
 
-    it "should convert facts into strings when stringify_facts is true" do
-      Puppet[:stringify_facts] = true
-      facts = Puppet::Node::Facts.new("foo")
-      Puppet::Node::Facts.expects(:new).returns facts
-      facts.expects(:stringify)
-
-      @facter.find(@request)
-    end
-
-    it "should sanitize facts when stringify_facts is false" do
-      Puppet[:stringify_facts] = false
+    it "should sanitize facts" do
       facts = Puppet::Node::Facts.new("foo")
       Puppet::Node::Facts.expects(:new).returns facts
       facts.expects(:sanitize)
@@ -102,11 +92,11 @@ describe Puppet::Node::Facts::Facter do
   end
 
   it 'should fail when saving facts' do
-    proc { @facter.save(@facts) }.should raise_error(Puppet::DevError)
+    expect { @facter.save(@facts) }.to raise_error(Puppet::DevError)
   end
 
   it 'should fail when destroying facts' do
-    proc { @facter.destroy(@facts) }.should raise_error(Puppet::DevError)
+    expect { @facter.destroy(@facts) }.to raise_error(Puppet::DevError)
   end
 
   describe 'when setting up search paths' do

data/spec/unit/indirector/facts/network_device_spec.rb

@@ -6,20 +6,20 @@ require 'puppet/indirector/facts/network_device'
 
 describe Puppet::Node::Facts::NetworkDevice do
   it "should be a subclass of the Code terminus" do
-    Puppet::Node::Facts::NetworkDevice.superclass.should equal(Puppet::Indirector::Code)
+    expect(Puppet::Node::Facts::NetworkDevice.superclass).to equal(Puppet::Indirector::Code)
   end
 
   it "should have documentation" do
-    Puppet::Node::Facts::NetworkDevice.doc.should_not be_nil
+    expect(Puppet::Node::Facts::NetworkDevice.doc).not_to be_nil
   end
 
   it "should be registered with the configuration store indirection" do
     indirection = Puppet::Indirector::Indirection.instance(:facts)
-    Puppet::Node::Facts::NetworkDevice.indirection.should equal(indirection)
+    expect(Puppet::Node::Facts::NetworkDevice.indirection).to equal(indirection)
   end
 
   it "should have its name set to :facter" do
-    Puppet::Node::Facts::NetworkDevice.name.should == :network_device
+    expect(Puppet::Node::Facts::NetworkDevice.name).to eq(:network_device)
   end
 end
 
@@ -34,17 +34,17 @@ describe Puppet::Node::Facts::NetworkDevice do
 
   describe Puppet::Node::Facts::NetworkDevice, " when finding facts" do
     it "should return a Facts instance" do
-      @device.find(@request).should be_instance_of(Puppet::Node::Facts)
+      expect(@device.find(@request)).to be_instance_of(Puppet::Node::Facts)
     end
 
     it "should return a Facts instance with the provided key as the name" do
-      @device.find(@request).name.should == @name
+      expect(@device.find(@request).name).to eq(@name)
     end
 
     it "should return the device facts as the values in the Facts instance" do
       @remote_device.expects(:facts).returns("one" => "two")
       facts = @device.find(@request)
-      facts.values["one"].should == "two"
+      expect(facts.values["one"]).to eq("two")
     end
 
     it "should add local facts" do
@@ -55,17 +55,7 @@ describe Puppet::Node::Facts::NetworkDevice do
       @device.find(@request)
     end
 
-    it "should convert facts into strings when stringify_facts is true" do
-      Puppet[:stringify_facts] = true
-      facts = Puppet::Node::Facts.new("foo")
-      Puppet::Node::Facts.expects(:new).returns facts
-      facts.expects(:stringify)
-
-      @device.find(@request)
-    end
-
-    it "should sanitizer facts when stringify_facts is false" do
-      Puppet[:stringify_facts] = false
+    it "should sanitize facts" do
       facts = Puppet::Node::Facts.new("foo")
       Puppet::Node::Facts.expects(:new).returns facts
       facts.expects(:sanitize)
@@ -76,13 +66,13 @@ describe Puppet::Node::Facts::NetworkDevice do
 
   describe Puppet::Node::Facts::NetworkDevice, " when saving facts" do
     it "should fail" do
-      proc { @device.save(@facts) }.should raise_error(Puppet::DevError)
+      expect { @device.save(@facts) }.to raise_error(Puppet::DevError)
     end
   end
 
   describe Puppet::Node::Facts::NetworkDevice, " when destroying facts" do
     it "should fail" do
-      proc { @device.destroy(@facts) }.should raise_error(Puppet::DevError)
+      expect { @device.destroy(@facts) }.to raise_error(Puppet::DevError)
     end
   end
 end

data/spec/unit/indirector/facts/yaml_spec.rb

@@ -6,21 +6,21 @@ require 'puppet/indirector/facts/yaml'
 
 describe Puppet::Node::Facts::Yaml do
   it "should be a subclass of the Yaml terminus" do
-    Puppet::Node::Facts::Yaml.superclass.should equal(Puppet::Indirector::Yaml)
+    expect(Puppet::Node::Facts::Yaml.superclass).to equal(Puppet::Indirector::Yaml)
   end
 
   it "should have documentation" do
-    Puppet::Node::Facts::Yaml.doc.should_not be_nil
-    Puppet::Node::Facts::Yaml.doc.should_not be_empty
+    expect(Puppet::Node::Facts::Yaml.doc).not_to be_nil
+    expect(Puppet::Node::Facts::Yaml.doc).not_to be_empty
   end
 
   it "should be registered with the facts indirection" do
     indirection = Puppet::Indirector::Indirection.instance(:facts)
-    Puppet::Node::Facts::Yaml.indirection.should equal(indirection)
+    expect(Puppet::Node::Facts::Yaml.indirection).to equal(indirection)
   end
 
   it "should have its name set to :yaml" do
-    Puppet::Node::Facts::Yaml.name.should == :yaml
+    expect(Puppet::Node::Facts::Yaml.name).to eq(:yaml)
   end
 
   describe "#search" do
@@ -33,7 +33,7 @@ describe Puppet::Node::Facts::Yaml do
           YAML.stubs(:load_file).with(key).returns value
         end
       end
-      Puppet::Node::Facts::Yaml.new.search(request).should =~ matching.values.map {|facts| facts.name}
+      expect(Puppet::Node::Facts::Yaml.new.search(request)).to match_array(matching.values.map {|facts| facts.name})
     end
 
     it "should return node names that match the search query options" do

data/spec/unit/indirector/file_bucket_file/file_spec.rb

@@ -20,7 +20,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
       it "should return a result whose content is empty" do
         bucket_file = Puppet::FileBucket::File.new('stuff')
         result = Puppet::FileBucket::File.indirection.save(bucket_file, "md5/c13d88cb4cb02003daedb8a84e5d272a")
-        result.contents.should be_empty
+        expect(result.contents).to be_empty
       end
 
       it "deals with multiple processes saving at the same time", :unless => Puppet::Util::Platform.windows? do
@@ -36,8 +36,8 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
         children.each { |child| Process.wait(child) }
 
         paths = File.read("#{Puppet[:bucketdir]}/9/8/b/f/7/d/8/c/98bf7d8c15784f0a3d63204441e1e2aa/paths").lines.to_a
-        paths.length.should == 1
-        Puppet::FileBucket::File.indirection.head("#{bucket_file.checksum_type}/#{bucket_file.checksum_data}/testing").should be_true
+        expect(paths.length).to eq(1)
+        expect(Puppet::FileBucket::File.indirection.head("#{bucket_file.checksum_type}/#{bucket_file.checksum_data}/testing")).to be_truthy
       end
 
       it "fails if the contents collide with existing contents" do
@@ -67,16 +67,16 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
             dir_path = "#{Puppet[:bucketdir]}/#{bucket_dir}"
             contents_file = "#{dir_path}/contents"
             paths_file = "#{dir_path}/paths"
-            Puppet::FileSystem.binread(contents_file).should == plaintext
-            Puppet::FileSystem.read(paths_file).should == "foo/bar\n"
+            expect(Puppet::FileSystem.binread(contents_file)).to eq(plaintext)
+            expect(Puppet::FileSystem.read(paths_file)).to eq("foo/bar\n")
           end
 
           it "should leave the paths file alone if the path is already stored" do
             checksum = save_bucket_file(plaintext, "/foo/bar")
             checksum = save_bucket_file(plaintext, "/foo/bar")
             dir_path = "#{Puppet[:bucketdir]}/#{bucket_dir}"
-            Puppet::FileSystem.binread("#{dir_path}/contents").should == plaintext
-            File.read("#{dir_path}/paths").should == "foo/bar\n"
+            expect(Puppet::FileSystem.binread("#{dir_path}/contents")).to eq(plaintext)
+            expect(File.read("#{dir_path}/paths")).to eq("foo/bar\n")
           end
 
           it "should store an additional path if the new path differs from those already stored" do
@@ -85,8 +85,8 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
             checksum = save_bucket_file(plaintext, "/foo/baz")
 
             dir_path = "#{Puppet[:bucketdir]}/#{bucket_dir}"
-            Puppet::FileSystem.binread("#{dir_path}/contents").should == plaintext
-            File.read("#{dir_path}/paths").should == "foo/bar\nfoo/baz\n"
+            expect(Puppet::FileSystem.binread("#{dir_path}/contents")).to eq(plaintext)
+            expect(File.read("#{dir_path}/paths")).to eq("foo/bar\nfoo/baz\n")
           end
         end
       end
@@ -97,8 +97,8 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
             checksum = save_bucket_file(plaintext, "")
 
             dir_path = "#{Puppet[:bucketdir]}/#{bucket_dir}"
-            Puppet::FileSystem.binread("#{dir_path}/contents").should == plaintext
-            File.read("#{dir_path}/paths").should == ""
+            expect(Puppet::FileSystem.binread("#{dir_path}/contents")).to eq(plaintext)
+            expect(File.read("#{dir_path}/paths")).to eq("")
           end
         end
       end
@@ -111,15 +111,15 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
 
         describe "when supplying a path" do
           it "should return false/nil if the file isn't bucketed" do
-            Puppet::FileBucket::File.indirection.head("#{digest_algorithm}/#{not_bucketed_checksum}/foo/bar").should == false
-            Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{not_bucketed_checksum}/foo/bar").should == nil
+            expect(Puppet::FileBucket::File.indirection.head("#{digest_algorithm}/#{not_bucketed_checksum}/foo/bar")).to eq(false)
+            expect(Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{not_bucketed_checksum}/foo/bar")).to eq(nil)
           end
 
           it "should return false/nil if the file is bucketed but with a different path" do
             checksum = save_bucket_file("I'm the contents of a file", '/foo/bar')
 
-            Puppet::FileBucket::File.indirection.head("#{digest_algorithm}/#{checksum}/foo/baz").should == false
-            Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum}/foo/baz").should == nil
+            expect(Puppet::FileBucket::File.indirection.head("#{digest_algorithm}/#{checksum}/foo/baz")).to eq(false)
+            expect(Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum}/foo/baz")).to eq(nil)
           end
 
           it "should return true/file if the file is already bucketed with the given path" do
@@ -127,10 +127,10 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
 
             checksum = save_bucket_file(contents, '/foo/bar')
 
-            Puppet::FileBucket::File.indirection.head("#{digest_algorithm}/#{checksum}/foo/bar").should == true
+            expect(Puppet::FileBucket::File.indirection.head("#{digest_algorithm}/#{checksum}/foo/bar")).to eq(true)
             find_result = Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum}/foo/bar")
-            find_result.checksum.should == "{#{digest_algorithm}}#{checksum}"
-            find_result.to_s.should == contents
+            expect(find_result.checksum).to eq("{#{digest_algorithm}}#{checksum}")
+            expect(find_result.to_s).to eq(contents)
           end
         end
 
@@ -140,8 +140,8 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
               trailing_string = trailing_slash ? '/' : ''
 
               it "should return false/nil if the file isn't bucketed" do
-                Puppet::FileBucket::File.indirection.head("#{digest_algorithm}/#{not_bucketed_checksum}#{trailing_string}").should == false
-                Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{not_bucketed_checksum}#{trailing_string}").should == nil
+                expect(Puppet::FileBucket::File.indirection.head("#{digest_algorithm}/#{not_bucketed_checksum}#{trailing_string}")).to eq(false)
+                expect(Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{not_bucketed_checksum}#{trailing_string}")).to eq(nil)
               end
 
               it "should return true/file if the file is already bucketed" do
@@ -151,10 +151,10 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
 
                 checksum = save_bucket_file(contents, '/foo/bar')
 
-                Puppet::FileBucket::File.indirection.head("#{digest_algorithm}/#{checksum}#{trailing_string}").should == true
+                expect(Puppet::FileBucket::File.indirection.head("#{digest_algorithm}/#{checksum}#{trailing_string}")).to eq(true)
                 find_result = Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum}#{trailing_string}")
-                find_result.checksum.should == "{#{digest_algorithm}}#{checksum}"
-                find_result.to_s.should == contents
+                expect(find_result.checksum).to eq("{#{digest_algorithm}}#{checksum}")
+                expect(find_result.to_s).to eq(contents)
               end
             end
           end
@@ -169,7 +169,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
 
         it "should generate an empty string if there is no diff" do
           checksum = save_bucket_file("I'm the contents of a file")
-          Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum}", :diff_with => checksum).should == ''
+          expect(Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum}", :diff_with => checksum)).to eq('')
         end
 
         it "should generate a proper diff if there is a diff" do
@@ -177,7 +177,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
           checksum2 = save_bucket_file("foo\nbiz\nbaz")
 
           diff = Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum1}", :diff_with => checksum2)
-          diff.should == "2c2\n< bar\n---\n> biz\n"
+          expect(diff).to eq("2c2\n< bar\n---\n> biz\n")
         end
 
         it "should raise an exception if the hash to diff against isn't found" do
@@ -191,7 +191,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
         it "should return nil if the hash to diff from isn't found" do
           checksum = save_bucket_file("whatever")
 
-          Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{not_bucketed_checksum}", :diff_with => checksum).should == nil
+          expect(Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{not_bucketed_checksum}", :diff_with => checksum)).to eq(nil)
         end
       end
     end
@@ -243,19 +243,19 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
                 make_bucketed_file
 
                 if supply_path
-                  @store.find(@request).should == nil
-                  @store.head(@request).should == false # because path didn't match
+                  expect(@store.find(@request)).to eq(nil)
+                  expect(@store.head(@request)).to eq(false) # because path didn't match
                 else
                   bucketfile = @store.find(@request)
-                  bucketfile.should be_a(Puppet::FileBucket::File)
-                  bucketfile.contents.should == plaintext
-                  @store.head(@request).should == true
+                  expect(bucketfile).to be_a(Puppet::FileBucket::File)
+                  expect(bucketfile.contents).to eq(plaintext)
+                  expect(@store.head(@request)).to eq(true)
                 end
               end
 
               it "should return nil if no file is found" do
-                @store.find(@request).should be_nil
-                @store.head(@request).should == false
+                expect(@store.find(@request)).to be_nil
+                expect(@store.head(@request)).to eq(false)
               end
             end
 
@@ -275,7 +275,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
                 request = Puppet::Indirector::Request.new(:indirection_name, :save, key, file_instance)
 
                 @store.save(request)
-                Puppet::FileSystem.binread("#{@dir}/contents").should == plaintext
+                expect(Puppet::FileSystem.binread("#{@dir}/contents")).to eq(plaintext)
               end
             end
           end

data/spec/unit/indirector/file_bucket_file/rest_spec.rb

@@ -5,6 +5,6 @@ require 'puppet/indirector/file_bucket_file/rest'
 
 describe Puppet::FileBucketFile::Rest do
   it "should be a sublcass of Puppet::Indirector::REST" do
-    Puppet::FileBucketFile::Rest.superclass.should equal(Puppet::Indirector::REST)
+    expect(Puppet::FileBucketFile::Rest.superclass).to equal(Puppet::Indirector::REST)
   end
 end

data/spec/unit/indirector/file_content/file_server_spec.rb

@@ -5,10 +5,10 @@ require 'puppet/indirector/file_content/file_server'
 
 describe Puppet::Indirector::FileContent::FileServer do
   it "should be registered with the file_content indirection" do
-    Puppet::Indirector::Terminus.terminus_class(:file_content, :file_server).should equal(Puppet::Indirector::FileContent::FileServer)
+    expect(Puppet::Indirector::Terminus.terminus_class(:file_content, :file_server)).to equal(Puppet::Indirector::FileContent::FileServer)
   end
 
   it "should be a subclass of the FileServer terminus" do
-    Puppet::Indirector::FileContent::FileServer.superclass.should equal(Puppet::Indirector::FileServer)
+    expect(Puppet::Indirector::FileContent::FileServer.superclass).to equal(Puppet::Indirector::FileServer)
   end
 end

data/spec/unit/indirector/file_content/file_spec.rb

@@ -5,10 +5,10 @@ require 'puppet/indirector/file_content/file'
 
 describe Puppet::Indirector::FileContent::File do
   it "should be registered with the file_content indirection" do
-    Puppet::Indirector::Terminus.terminus_class(:file_content, :file).should equal(Puppet::Indirector::FileContent::File)
+    expect(Puppet::Indirector::Terminus.terminus_class(:file_content, :file)).to equal(Puppet::Indirector::FileContent::File)
   end
 
   it "should be a subclass of the DirectFileServer terminus" do
-    Puppet::Indirector::FileContent::File.superclass.should equal(Puppet::Indirector::DirectFileServer)
+    expect(Puppet::Indirector::FileContent::File.superclass).to equal(Puppet::Indirector::DirectFileServer)
   end
 end

data/spec/unit/indirector/file_content/rest_spec.rb

@@ -9,6 +9,6 @@ describe Puppet::Indirector::FileContent::Rest do
   it "should set the content type to text/plain"
 
   it "should use the :fileserver SRV service" do
-    Puppet::Indirector::FileContent::Rest.srv_service.should == :fileserver
+    expect(Puppet::Indirector::FileContent::Rest.srv_service).to eq(:fileserver)
   end
 end

data/spec/unit/indirector/file_metadata/file_server_spec.rb

@@ -5,10 +5,10 @@ require 'puppet/indirector/file_metadata/file_server'
 
 describe Puppet::Indirector::FileMetadata::FileServer do
   it "should be registered with the file_metadata indirection" do
-    Puppet::Indirector::Terminus.terminus_class(:file_metadata, :file_server).should equal(Puppet::Indirector::FileMetadata::FileServer)
+    expect(Puppet::Indirector::Terminus.terminus_class(:file_metadata, :file_server)).to equal(Puppet::Indirector::FileMetadata::FileServer)
   end
 
   it "should be a subclass of the FileServer terminus" do
-    Puppet::Indirector::FileMetadata::FileServer.superclass.should equal(Puppet::Indirector::FileServer)
+    expect(Puppet::Indirector::FileMetadata::FileServer.superclass).to equal(Puppet::Indirector::FileServer)
   end
 end

data/spec/unit/indirector/file_metadata/file_spec.rb

@@ -5,11 +5,11 @@ require 'puppet/indirector/file_metadata/file'
 
 describe Puppet::Indirector::FileMetadata::File do
   it "should be registered with the file_metadata indirection" do
-    Puppet::Indirector::Terminus.terminus_class(:file_metadata, :file).should equal(Puppet::Indirector::FileMetadata::File)
+    expect(Puppet::Indirector::Terminus.terminus_class(:file_metadata, :file)).to equal(Puppet::Indirector::FileMetadata::File)
   end
 
   it "should be a subclass of the DirectFileServer terminus" do
-    Puppet::Indirector::FileMetadata::File.superclass.should equal(Puppet::Indirector::DirectFileServer)
+    expect(Puppet::Indirector::FileMetadata::File.superclass).to equal(Puppet::Indirector::DirectFileServer)
   end
 
   describe "when creating the instance for a single found file" do
@@ -28,7 +28,7 @@ describe Puppet::Indirector::FileMetadata::File do
       @data.expects(:collect)
 
       Puppet::FileServing::Metadata.expects(:new).returns(@data)
-      @metadata.find(@request).should == @data
+      expect(@metadata.find(@request)).to eq(@data)
     end
   end
 
@@ -43,8 +43,16 @@ describe Puppet::Indirector::FileMetadata::File do
 
     it "should collect the attributes of the instances returned" do
       Puppet::FileSystem.expects(:exist?).with(@path).returns true
-      @metadata.expects(:path2instances).returns( [mock("one", :collect => nil), mock("two", :collect => nil)] )
-      @metadata.search(@request)
+      Puppet::FileServing::Fileset.expects(:new).with(@path, @request).returns mock("fileset")
+      Puppet::FileServing::Fileset.expects(:merge).returns [["one", @path], ["two", @path]]
+
+      one = mock("one", :collect => nil)
+      Puppet::FileServing::Metadata.expects(:new).with(@path, {:relative_path => "one"}).returns one
+
+      two = mock("two", :collect => nil)
+      Puppet::FileServing::Metadata.expects(:new).with(@path, {:relative_path => "two"}).returns two
+
+      expect(@metadata.search(@request)).to eq([one, two])
     end
   end
 end