puppet 3.4.3 → 3.5.0.rc1

data/spec/unit/forge/errors_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require 'puppet/forge/errors'
+require 'puppet/forge'
 
 describe Puppet::Forge::Errors do
   describe 'SSLVerifyError' do

data/spec/unit/forge/repository_spec.rb

@@ -1,9 +1,7 @@
 # encoding: utf-8
 require 'spec_helper'
 require 'net/http'
-require 'puppet/forge/repository'
-require 'puppet/forge/cache'
-require 'puppet/forge/errors'
+require 'puppet/forge'
 
 describe Puppet::Forge::Repository do
   let(:consumer_version) { "Test/1.0" }

data/spec/unit/hiera/scope_spec.rb

@@ -1,8 +1,12 @@
 require 'spec_helper'
 require 'hiera/scope'
 
+require 'puppet_spec/scope'
+
 describe Hiera::Scope do
-  let(:real) { Puppet::Parser::Scope.new_for_test_harness("test_node") }
+  include PuppetSpec::Scope
+
+  let(:real) { create_test_scope_for_node("test_node") }
   let(:scope) { Hiera::Scope.new(real) }
 
   describe "#initialize" do
@@ -57,7 +61,7 @@ describe Hiera::Scope do
     end
 
     it "looks for the class which includes the defined type as the calling_class" do
-      parent = Puppet::Parser::Scope.new_for_test_harness("parent")
+      parent = create_test_scope_for_node("parent")
       real.parent = parent
       parent.source = Puppet::Resource::Type.new(:hostclass,
                                                  "name_of_the_class_including_the_definition",

data/spec/unit/hiera_puppet_spec.rb

@@ -1,7 +1,14 @@
 require 'spec_helper'
 require 'hiera_puppet'
+require 'puppet_spec/scope'
 
 describe 'HieraPuppet' do
+  include PuppetSpec::Scope
+
+  after(:all) do
+    HieraPuppet.instance_variable_set(:@hiera, nil)
+  end
+
   describe 'HieraPuppet#hiera_config' do
     let(:hiera_config_data) do
       { :backend => 'yaml' }
@@ -39,7 +46,7 @@ describe 'HieraPuppet' do
       begin
         Puppet.settings[:hiera_config] = nil
       rescue ArgumentError => detail
-        raise unless detail.message =~ /unknown configuration parameter/
+        raise unless detail.message =~ /unknown setting/
       end
       HieraPuppet.send(:hiera_config_file).should be_nil
     end
@@ -48,11 +55,11 @@ describe 'HieraPuppet' do
       begin
         Puppet.settings[:hiera_config] = "/dev/null/my_hiera.yaml"
       rescue ArgumentError => detail
-        raise unless detail.message =~ /unknown configuration parameter/
+        raise unless detail.message =~ /unknown setting/
         pending("This example does not apply to Puppet #{Puppet.version} because it does not have this setting")
       end
 
-      Puppet::FileSystem::File.stubs(:exist?).with(Puppet[:hiera_config]).returns(true)
+      Puppet::FileSystem.stubs(:exist?).with(Puppet[:hiera_config]).returns(true)
       HieraPuppet.send(:hiera_config_file).should == Puppet[:hiera_config]
     end
 
@@ -60,18 +67,18 @@ describe 'HieraPuppet' do
       begin
         Puppet.settings[:hiera_config] = nil
       rescue ArgumentError => detail
-        raise unless detail.message =~ /unknown configuration parameter/
+        raise unless detail.message =~ /unknown setting/
       end
       Puppet.settings[:confdir] = "/dev/null/puppet"
       hiera_config = File.join(Puppet[:confdir], 'hiera.yaml')
-      Puppet::FileSystem::File.stubs(:exist?).with(hiera_config).returns(true)
+      Puppet::FileSystem.stubs(:exist?).with(hiera_config).returns(true)
 
       HieraPuppet.send(:hiera_config_file).should == hiera_config
     end
   end
 
   describe 'HieraPuppet#lookup' do
-    let :scope do Puppet::Parser::Scope.new_for_test_harness('foo') end
+    let :scope do create_test_scope_for_node('foo') end
 
     before :each do
       Puppet[:hiera_config] = PuppetSpec::Files.tmpfile('hiera_config')

data/spec/unit/indirector/catalog/msgpack_spec.rb

@@ -0,0 +1,12 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/resource/catalog'
+require 'puppet/indirector/catalog/msgpack'
+
+describe Puppet::Resource::Catalog::Msgpack, :if => Puppet.features.msgpack? do
+  # This is it for local functionality: we don't *do* anything else.
+  it "should be registered with the catalog store indirection" do
+    Puppet::Resource::Catalog.indirection.terminus(:msgpack).
+      should be_an_instance_of described_class
+  end
+end

data/spec/unit/indirector/catalog/static_compiler_spec.rb

@@ -10,6 +10,11 @@ describe Puppet::Resource::Catalog::StaticCompiler do
     @num_file_resources = 10
   end
 
+  before :each do
+    Facter.stubs(:to_hash).returns({})
+    Facter.stubs(:value)
+  end
+
   let(:request) do
     Puppet::Indirector::Request.new(:the_indirection_named_foo,
                                     :find,
@@ -23,10 +28,7 @@ describe Puppet::Resource::Catalog::StaticCompiler do
     end
 
     it "returns nil if there is no compiled catalog" do
-      compiler = mock('compiler indirection')
-      compiler.expects(:find).with(request).returns(nil)
-
-      subject.expects(:compiler).returns(compiler)
+      subject.expects(:compile).returns(nil)
       subject.find(request).should be_nil
     end
 
@@ -67,9 +69,6 @@ describe Puppet::Resource::Catalog::StaticCompiler do
 
   describe "(#15193) when storing content to the filebucket" do
     it "explicitly uses the indirection method" do
-      # Do not stub the store_content method which is stubbed by default in the
-      # value of the stub_methods option.
-      stub_the_compiler(:stub_methods => false)
 
       # We expect the content to be retrieved from the FileServer ...
       fake_content = mock('FileServer Content')
@@ -96,6 +95,7 @@ describe Puppet::Resource::Catalog::StaticCompiler do
       end
 
       # Obtain the Static Catalog
+      subject.stubs(:compile).returns(build_catalog)
       resource_catalog = subject.find(request)
 
       # Ensure all of the file resources were filtered
@@ -136,9 +136,11 @@ describe Puppet::Resource::Catalog::StaticCompiler do
     # Stub the call to the FileServer metadata API so we don't have to have
     # a real fileserver initialized for testing.
     Puppet::FileServing::Metadata.
-      indirection.stubs(:find).
-      with() { |*args| args[0] == options[:source].sub('puppet:///','') and args[1] == {:links => :manage, :environment => nil}}.
-      returns(fake_fileserver_metadata)
+      indirection.stubs(:find).with do |uri, opts|
+        expect(uri).to eq options[:source].sub('puppet:///','')
+        expect(opts[:links]).to eq :manage
+        expect(opts[:environment]).to eq nil
+      end.returns(fake_fileserver_metadata)
 
     # I want a resource that all the file resources require and another
     # that requires them.
@@ -171,12 +173,41 @@ describe Puppet::Resource::Catalog::StaticCompiler do
     catalog
   end
 
+  describe "(#22744) when filtering resources" do
+    let(:catalog) { stub_everything 'catalog' }
+
+    it "should delegate to the catalog instance filtering" do
+      catalog.expects(:filter)
+      subject.filter(catalog)
+    end
+
+    it "should filter out virtual resources" do
+      resource = mock 'resource', :virtual? => true
+      catalog.stubs(:filter).yields(resource)
+
+      subject.filter(catalog)
+    end
+
+    it "should return the same catalog if it doesn't support filtering" do
+      catalog.stubs(:respond_to?).with(:filter)
+      subject.filter(catalog).should == catalog
+    end
+
+    it "should return the filtered catalog" do
+      filtered_catalog = stub 'filtered catalog'
+      catalog.stubs(:filter).returns(filtered_catalog)
+
+      subject.filter(catalog).should == filtered_catalog
+    end
+
+  end
+
   def fileserver_metadata(options = {})
     yaml = <<EOFILESERVERMETADATA
 --- !ruby/object:Puppet::FileServing::Metadata
   checksum: "{md5}361fadf1c712e812d198c4cab5712a79"
   checksum_type: md5
-  destination: 
+  destination:
   expiration: #{Time.now + 1800}
   ftype: file
   group: 0

data/spec/unit/indirector/direct_file_server_spec.rb

@@ -26,12 +26,12 @@ describe Puppet::Indirector::DirectFileServer do
   describe Puppet::Indirector::DirectFileServer, "when finding a single file" do
 
     it "should return nil if the file does not exist" do
-      Puppet::FileSystem::File.expects(:exist?).with(@path).returns false
+      Puppet::FileSystem.expects(:exist?).with(@path).returns false
       @server.find(@request).should be_nil
     end
 
     it "should return a Content instance created with the full path to the file if the file exists" do
-      Puppet::FileSystem::File.expects(:exist?).with(@path).returns true
+      Puppet::FileSystem.expects(:exist?).with(@path).returns true
       @model.expects(:new).returns(:mycontent)
       @server.find(@request).should == :mycontent
     end
@@ -42,7 +42,7 @@ describe Puppet::Indirector::DirectFileServer do
     before do
       @data = mock 'content'
       @data.stubs(:collect)
-      Puppet::FileSystem::File.expects(:exist?).with(@path).returns true
+      Puppet::FileSystem.expects(:exist?).with(@path).returns true
     end
 
     it "should pass the full path to the instance" do
@@ -61,18 +61,18 @@ describe Puppet::Indirector::DirectFileServer do
 
   describe Puppet::Indirector::DirectFileServer, "when searching for multiple files" do
     it "should return nil if the file does not exist" do
-      Puppet::FileSystem::File.expects(:exist?).with(@path).returns false
+      Puppet::FileSystem.expects(:exist?).with(@path).returns false
       @server.find(@request).should be_nil
     end
 
     it "should use :path2instances from the terminus_helper to return instances if the file exists" do
-      Puppet::FileSystem::File.expects(:exist?).with(@path).returns true
+      Puppet::FileSystem.expects(:exist?).with(@path).returns true
       @server.expects(:path2instances)
       @server.search(@request)
     end
 
     it "should pass the original request to :path2instances" do
-      Puppet::FileSystem::File.expects(:exist?).with(@path).returns true
+      Puppet::FileSystem.expects(:exist?).with(@path).returns true
       @server.expects(:path2instances).with(@request, @path)
       @server.search(@request)
     end

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

@@ -144,17 +144,17 @@ describe Puppet::Node::Facts::Facter do
   end
 
   it "should include pluginfactdest when loading external facts",
-     :if => Puppet.features.external_facts?, :unless => Puppet.features.microsoft_windows? do
+     :if => (Puppet.features.external_facts? and not Puppet.features.microsoft_windows?) do
     Puppet[:pluginfactdest] = "/plugin/dest"
     @facter.find(@request)
-    Facter::Util::Config.external_facts_dirs.include?("/plugin/dest")
+    Facter.search_external_path.include?("/plugin/dest")
   end
 
   it "should include pluginfactdest when loading external facts",
-    :if => Puppet.features.external_facts?, :if => Puppet.features.microsoft_windows? do
+    :if => (Puppet.features.external_facts? and Puppet.features.microsoft_windows?) do
     Puppet[:pluginfactdest] = "/plugin/dest"
     @facter.find(@request)
-    Facter::Util::Config.external_facts_dirs.include?("C:/plugin/dest")
+    Facter.search_external_path.include?("C:/plugin/dest")
   end
 
   describe "when loading fact plugins from disk" do
@@ -191,7 +191,7 @@ describe Puppet::Node::Facts::Facter do
       mod = Puppet::Module.new("mymodule", "#{one}/mymodule", @request.environment)
       @request.environment.stubs(:modules).returns([mod])
       @facter.find(@request)
-      Facter::Util::Config.external_facts_dirs.include?("#{one}/mymodule/facts.d")
+      Facter.search_external_path.include?("#{one}/mymodule/facts.d")
     end
   end
 end

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

@@ -68,10 +68,10 @@ describe Puppet::FileBucketFile::File do
           checksum = save_bucket_file("stuff\r\n", "/foo/bar")
 
           dir_path = "#{Puppet[:bucketdir]}/f/c/7/7/7/c/0/b/fc777c0bc467e1ab98b4c6915af802ec"
-          contents_file = Puppet::FileSystem::File.new("#{dir_path}/contents")
-          paths_file = Puppet::FileSystem::File.new("#{dir_path}/paths")
-          contents_file.binread.should == "stuff\r\n"
-          paths_file.read.should == "foo/bar\n"
+          contents_file = "#{dir_path}/contents"
+          paths_file = "#{dir_path}/paths"
+          Puppet::FileSystem.binread(contents_file).should == "stuff\r\n"
+          Puppet::FileSystem.read(paths_file).should == "foo/bar\n"
         end
 
         it "should leave the paths file alone if the path is already stored" do

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

@@ -19,7 +19,7 @@ describe Puppet::Indirector::FileMetadata::File do
       @uri = Puppet::Util.path_to_uri(@path).to_s
       @data = mock 'metadata'
       @data.stubs(:collect)
-      Puppet::FileSystem::File.expects(:exist?).with(@path).returns true
+      Puppet::FileSystem.expects(:exist?).with(@path).returns true
 
       @request = Puppet::Indirector::Request.new(:file_metadata, :find, @uri, nil)
     end
@@ -42,7 +42,7 @@ describe Puppet::Indirector::FileMetadata::File do
     end
 
     it "should collect the attributes of the instances returned" do
-      Puppet::FileSystem::File.expects(:exist?).with(@path).returns true
+      Puppet::FileSystem.expects(:exist?).with(@path).returns true
       @metadata.expects(:path2instances).returns( [mock("one", :collect => nil), mock("two", :collect => nil)] )
       @metadata.search(@request)
     end

data/spec/unit/indirector/file_server_spec.rb

@@ -154,7 +154,7 @@ describe Puppet::Indirector::FileServer do
 
       @mount.expects(:search).with { |key, request| key == "rel/path" }.returns %w{/one /two}
 
-      Puppet::FileSystem::File.stubs(:exist?).returns true
+      Puppet::FileSystem.stubs(:exist?).returns true
 
       one = mock 'fileset_one'
       Puppet::FileServing::Fileset.expects(:new).with("/one", @request).returns(one)
@@ -171,7 +171,7 @@ describe Puppet::Indirector::FileServer do
 
       @mount.expects(:search).with { |key, request| key == "rel/path" }.returns []
 
-      Puppet::FileSystem::File.stubs(:exist?).returns true
+      Puppet::FileSystem.stubs(:exist?).returns true
 
       Puppet::FileServing::Fileset.expects(:merge).returns("one" => "/one", "two" => "/two")
 
@@ -193,7 +193,7 @@ describe Puppet::Indirector::FileServer do
 
       @mount.expects(:search).with { |key, request| key == "rel/path" }.returns []
 
-      Puppet::FileSystem::File.stubs(:exist?).returns true
+      Puppet::FileSystem.stubs(:exist?).returns true
 
       Puppet::FileServing::Fileset.expects(:merge).returns("one" => "/one")
 
@@ -211,7 +211,7 @@ describe Puppet::Indirector::FileServer do
 
       @mount.expects(:search).with { |key, options| key == "rel/path" }.returns []
 
-      Puppet::FileSystem::File.stubs(:exist?).returns true
+      Puppet::FileSystem.stubs(:exist?).returns true
 
       Puppet::FileServing::Fileset.expects(:merge).returns("one" => "/one")
 

data/spec/unit/indirector/json_spec.rb

@@ -120,7 +120,7 @@ describe Puppet::Indirector::JSON do
 
         subject.save(request)
 
-        File.should be_directory target
+        File.should be_directory(target)
       end
     end
 
@@ -131,20 +131,20 @@ describe Puppet::Indirector::JSON do
         with_content('hello') do
           subject.destroy(request)
         end
-        Puppet::FileSystem::File.exist?(file).should be_false
+        Puppet::FileSystem.exist?(file).should be_false
       end
 
       it "silently succeeds when files don't exist" do
-        Puppet::FileSystem::File.unlink(file) rescue nil
+        Puppet::FileSystem.unlink(file) rescue nil
         subject.destroy(request).should be_true
       end
 
       it "raises an informative error for other failures" do
-        Puppet::FileSystem::File.stubs(:unlink).with(file).raises(Errno::EPERM, 'fake permission problem')
+        Puppet::FileSystem.stubs(:unlink).with(file).raises(Errno::EPERM, 'fake permission problem')
         with_content('hello') do
-          expect { subject.destroy(request) }.to raise_error Puppet::Error
+          expect { subject.destroy(request) }.to raise_error(Puppet::Error)
         end
-        Puppet::FileSystem::File.unstub(:unlink)    # thanks, mocha
+        Puppet::FileSystem.unstub(:unlink)    # thanks, mocha
       end
     end
   end

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

@@ -76,20 +76,20 @@ describe Puppet::SSL::Key::File do
     end
 
     it "should destroy the public key when destroying the private key" do
-      Puppet::FileSystem::File.stubs(:unlink).with(@private_key_path)
-      Puppet::FileSystem::File.stubs(:exist?).with(@private_key_path).returns true
-      Puppet::FileSystem::File.expects(:exist?).with(@public_key_path).returns true
-      Puppet::FileSystem::File.expects(:unlink).with(@public_key_path)
+      Puppet::FileSystem.expects(:unlink).with(Puppet::FileSystem.pathname(@private_key_path))
+      Puppet::FileSystem.expects(:exist?).with(Puppet::FileSystem.pathname(@private_key_path)).returns true
+      Puppet::FileSystem.expects(:exist?).with(Puppet::FileSystem.pathname(@public_key_path)).returns true
+      Puppet::FileSystem.expects(:unlink).with(Puppet::FileSystem.pathname(@public_key_path))
 
       @searcher.destroy(@request)
     end
 
     it "should not fail if the public key does not exist when deleting the private key" do
-      Puppet::FileSystem::File.stubs(:unlink).with(@private_key_path)
+      Puppet::FileSystem.stubs(:unlink).with(Puppet::FileSystem.pathname(@private_key_path))
 
-      Puppet::FileSystem::File.stubs(:exist?).with(@private_key_path).returns true
-      Puppet::FileSystem::File.expects(:exist?).with(@public_key_path).returns false
-      Puppet::FileSystem::File.expects(:unlink).with(@public_key_path).never
+      Puppet::FileSystem.stubs(:exist?).with(Puppet::FileSystem.pathname(@private_key_path)).returns true
+      Puppet::FileSystem.expects(:exist?).with(Puppet::FileSystem.pathname(@public_key_path)).returns false
+      Puppet::FileSystem.expects(:unlink).with(Puppet::FileSystem.pathname(@public_key_path)).never
 
       @searcher.destroy(@request)
     end

data/spec/unit/indirector/msgpack_spec.rb

@@ -0,0 +1,191 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet_spec/files'
+require 'puppet/indirector/indirector_testing/msgpack'
+
+describe Puppet::Indirector::Msgpack, :if => Puppet.features.msgpack? do
+  include PuppetSpec::Files
+
+  subject { Puppet::IndirectorTesting::Msgpack.new }
+  let :model       do Puppet::IndirectorTesting end
+  let :indirection do model.indirection end
+
+  context "#path" do
+    before :each do
+      Puppet[:server_datadir] = '/sample/datadir/master'
+      Puppet[:client_datadir] = '/sample/datadir/client'
+    end
+
+    it "uses the :server_datadir setting if this is the master" do
+      Puppet.run_mode.stubs(:master?).returns(true)
+      expected = File.join(Puppet[:server_datadir], 'indirector_testing', 'testing.msgpack')
+      subject.path('testing').should == expected
+    end
+
+    it "uses the :client_datadir setting if this is not the master" do
+      Puppet.run_mode.stubs(:master?).returns(false)
+      expected = File.join(Puppet[:client_datadir], 'indirector_testing', 'testing.msgpack')
+      subject.path('testing').should == expected
+    end
+
+    it "overrides the default extension with a supplied value" do
+      Puppet.run_mode.stubs(:master?).returns(true)
+      expected = File.join(Puppet[:server_datadir], 'indirector_testing', 'testing.not-msgpack')
+      subject.path('testing', '.not-msgpack').should == expected
+    end
+
+    ['../foo', '..\\foo', './../foo', '.\\..\\foo',
+     '/foo', '//foo', '\\foo', '\\\\goo',
+     "test\0/../bar", "test\0\\..\\bar",
+     "..\\/bar", "/tmp/bar", "/tmp\\bar", "tmp\\bar",
+     " / bar", " /../ bar", " \\..\\ bar",
+     "c:\\foo", "c:/foo", "\\\\?\\UNC\\bar", "\\\\foo\\bar",
+     "\\\\?\\c:\\foo", "//?/UNC/bar", "//foo/bar",
+     "//?/c:/foo",
+    ].each do |input|
+      it "should resist directory traversal attacks (#{input.inspect})" do
+        expect { subject.path(input) }.to raise_error ArgumentError, 'invalid key'
+      end
+    end
+  end
+
+  context "handling requests" do
+    before :each do
+      Puppet.run_mode.stubs(:master?).returns(true)
+      Puppet[:server_datadir] = tmpdir('msgpackdir')
+      FileUtils.mkdir_p(File.join(Puppet[:server_datadir], 'indirector_testing'))
+    end
+
+    let :file do subject.path(request.key) end
+
+    def with_content(text)
+      FileUtils.mkdir_p(File.dirname(file))
+      File.open(file, 'w') {|f| f.write text }
+      yield if block_given?
+    end
+
+    it "data saves and then loads again correctly" do
+      subject.save(indirection.request(:save, 'example', model.new('banana')))
+      subject.find(indirection.request(:find, 'example', nil)).value.should == 'banana'
+    end
+
+    context "#find" do
+      let :request do indirection.request(:find, 'example', nil) end
+
+      it "returns nil if the file doesn't exist" do
+        subject.find(request).should be_nil
+      end
+
+      it "raises a descriptive error when the file can't be read" do
+        with_content(model.new('foo').to_msgpack) do
+          # I don't like this, but there isn't a credible alternative that
+          # also works on Windows, so a stub it is. At least the expectation
+          # will fail if the implementation changes. Sorry to the next dev.
+          File.expects(:read).with(file).raises(Errno::EPERM)
+          expect { subject.find(request) }.
+            to raise_error Puppet::Error, /Could not read MessagePack/
+        end
+      end
+
+      it "raises a descriptive error when the file content is invalid" do
+        with_content("this is totally invalid MessagePack") do
+          expect { subject.find(request) }.
+            to raise_error Puppet::Error, /Could not parse MessagePack data/
+        end
+      end
+
+      it "should return an instance of the indirected object when valid" do
+        with_content(model.new(1).to_msgpack) do
+          instance = subject.find(request)
+          instance.should be_an_instance_of model
+          instance.value.should == 1
+        end
+      end
+    end
+
+    context "#save" do
+      let :instance do model.new(4) end
+      let :request  do indirection.request(:find, 'example', instance) end
+
+      it "should save the instance of the request as MessagePack to disk" do
+        subject.save(request)
+        content = File.read(file)
+        MessagePack.unpack(content)['value'].should == 4
+      end
+
+      it "should create the indirection directory if required" do
+        target = File.join(Puppet[:server_datadir], 'indirector_testing')
+        Dir.rmdir(target)
+
+        subject.save(request)
+
+        File.should be_directory(target)
+      end
+    end
+
+    context "#destroy" do
+      let :request do indirection.request(:find, 'example', nil) end
+
+      it "removes an existing file" do
+        with_content('hello') do
+          subject.destroy(request)
+        end
+        Puppet::FileSystem.exist?(file).should be_false
+      end
+
+      it "silently succeeds when files don't exist" do
+        Puppet::FileSystem.unlink(file) rescue nil
+        subject.destroy(request).should be_true
+      end
+
+      it "raises an informative error for other failures" do
+        Puppet::FileSystem.stubs(:unlink).with(file).raises(Errno::EPERM, 'fake permission problem')
+        with_content('hello') do
+          expect { subject.destroy(request) }.to raise_error(Puppet::Error)
+        end
+        Puppet::FileSystem.unstub(:unlink)    # thanks, mocha
+      end
+    end
+  end
+
+  context "#search" do
+    before :each do
+      Puppet.run_mode.stubs(:master?).returns(true)
+      Puppet[:server_datadir] = tmpdir('msgpackdir')
+      FileUtils.mkdir_p(File.join(Puppet[:server_datadir], 'indirector_testing'))
+    end
+
+    def request(glob)
+      indirection.request(:search, glob, nil)
+    end
+
+    def create_file(name, value = 12)
+      File.open(subject.path(name, ''), 'w') do |f|
+        f.write Puppet::IndirectorTesting.new(value).to_msgpack
+      end
+    end
+
+    it "returns an empty array when nothing matches the key as a glob" do
+      subject.search(request('*')).should == []
+    end
+
+    it "returns an array with one item if one item matches" do
+      create_file('foo.msgpack', 'foo')
+      create_file('bar.msgpack', 'bar')
+      subject.search(request('f*')).map(&:value).should == ['foo']
+    end
+
+    it "returns an array of items when more than one item matches" do
+      create_file('foo.msgpack', 'foo')
+      create_file('bar.msgpack', 'bar')
+      create_file('baz.msgpack', 'baz')
+      subject.search(request('b*')).map(&:value).should =~ ['bar', 'baz']
+    end
+
+    it "only items with the .msgpack extension" do
+      create_file('foo.msgpack', 'foo-msgpack')
+      create_file('foo.msgpack~', 'foo-backup')
+      subject.search(request('f*')).map(&:value).should == ['foo-msgpack']
+    end
+  end
+end