puppet 3.1.1 → 3.2.0.rc1

data/spec/unit/module_tool/applications/searcher_spec.rb

@@ -8,9 +8,7 @@ describe Puppet::ModuleTool::Applications::Searcher do
   describe "when searching" do
     let(:forge) { mock 'forge' }
     let(:searcher) do
-      pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
-        described_class.new('search_term', forge)
-      end
+      described_class.new('search_term', forge)
     end
 
     it "should return results from a forge query when successful" do

data/spec/unit/module_tool/applications/uninstaller_spec.rb

@@ -64,23 +64,19 @@ describe Puppet::ModuleTool::Applications::Uninstaller do
     context "when the module is installed" do
 
       it "should uninstall the module" do
-        pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
-          PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
+        PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
 
-          results = @uninstaller.new("puppetlabs-foo", options).run
-          results[:affected_modules].first.forge_name.should == "puppetlabs/foo"
-        end
+        results = @uninstaller.new("puppetlabs-foo", options).run
+        results[:affected_modules].first.forge_name.should == "puppetlabs/foo"
       end
 
       it "should only uninstall the requested module" do
-        pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
-          PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
-          PuppetSpec::Modules.create('bar', modpath1, :metadata => bar_metadata)
+        PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
+        PuppetSpec::Modules.create('bar', modpath1, :metadata => bar_metadata)
 
-          results = @uninstaller.new("puppetlabs-foo", options).run
-          results[:affected_modules].length == 1
-          results[:affected_modules].first.forge_name.should == "puppetlabs/foo"
-        end
+        results = @uninstaller.new("puppetlabs-foo", options).run
+        results[:affected_modules].length == 1
+        results[:affected_modules].first.forge_name.should == "puppetlabs/foo"
       end
 
       it "should uninstall fail if a module exists twice in the modpath" do
@@ -93,16 +89,14 @@ describe Puppet::ModuleTool::Applications::Uninstaller do
       context "when options[:version] is specified" do
 
         it "should uninstall the module if the version matches" do
-          pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
-            PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
+          PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
 
-            options[:version] = "1.0.0"
+          options[:version] = "1.0.0"
 
-            results = @uninstaller.new("puppetlabs-foo", options).run
-            results[:affected_modules].length.should == 1
-            results[:affected_modules].first.forge_name.should == "puppetlabs/foo"
-            results[:affected_modules].first.version.should == "1.0.0"
-          end
+          results = @uninstaller.new("puppetlabs-foo", options).run
+          results[:affected_modules].length.should == 1
+          results[:affected_modules].first.forge_name.should == "puppetlabs/foo"
+          results[:affected_modules].first.version.should == "1.0.0"
         end
 
         it "should not uninstall the module if the version does not match" do
@@ -137,13 +131,11 @@ describe Puppet::ModuleTool::Applications::Uninstaller do
       context "when the module does not have local changes" do
 
         it "should uninstall the module" do
-          pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
-            PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
+          PuppetSpec::Modules.create('foo', modpath1, :metadata => foo_metadata)
 
-            results = @uninstaller.new("puppetlabs-foo", options).run
-            results[:affected_modules].length.should == 1
-            results[:affected_modules].first.forge_name.should == "puppetlabs/foo"
-          end
+          results = @uninstaller.new("puppetlabs-foo", options).run
+          results[:affected_modules].length.should == 1
+          results[:affected_modules].first.forge_name.should == "puppetlabs/foo"
         end
       end
 

data/spec/unit/module_tool/applications/unpacker_spec.rb

@@ -5,63 +5,30 @@ require 'puppet_spec/modules'
 describe Puppet::ModuleTool::Applications::Unpacker do
   include PuppetSpec::Files
 
-  let(:target) { tmpdir("unpacker") }
-
-  context "initialization" do
-    it "should support filename and basic options" do
-      pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
-        Puppet::ModuleTool::Applications::Unpacker.new("myusername-mytarball-1.0.0.tar.gz", :target_dir => target)
-      end
-    end
-
-    it "should raise ArgumentError when filename is invalid" do
-      expect { Puppet::ModuleTool::Applications::Unpacker.new("invalid.tar.gz", :target_dir => target) }.to raise_error(ArgumentError)
-    end
+  let(:target)      { tmpdir("unpacker") }
+  let(:module_name) { 'myusername-mytarball' }
+  let(:filename)    { tmpdir("module") + "/#{module_name}-1.0.0.tar.gz" }
+  let(:working_dir) { tmpdir("working_dir") }
+  let(:unpacker) do
+    Puppet::ModuleTool::Applications::Unpacker.new(filename, :target_dir => target)
   end
 
-  context "#run" do
-    let(:cache_base_path) { Pathname.new(tmpdir("unpacker")) }
-    let(:filename) { tmpdir("module") + "/myusername-mytarball-1.0.0.tar.gz" }
-    let(:build_dir) { Pathname.new(tmpdir("build_dir")) }
-    let(:unpacker) do
-      pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
-        Puppet::ModuleTool::Applications::Unpacker.new(filename, :target_dir => target)
-      end
-    end
+  before :each do
+    Puppet.settings[:module_working_dir] = working_dir
+  end
 
-    before :each do
-      # Mock redhat for most test cases
-      Facter.stubs(:value).with("osfamily").returns("Redhat")
-      build_dir.stubs(:mkpath => nil, :rmtree => nil, :children => [])
-      unpacker.stubs(:build_dir).at_least_once.returns(build_dir)
-      FileUtils.stubs(:mv)
-    end
+  it "should raise ArgumentError when filename is invalid" do
+    expect { Puppet::ModuleTool::Applications::Unpacker.new("invalid.tar.gz", :target_dir => target) }.to raise_error(ArgumentError)
+  end
 
-    context "on linux" do
-      it "should attempt to untar file to temporary location using system tar" do
-        pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
-          Puppet::Util::Execution.expects(:execute).with("tar xzf #{filename} -C #{build_dir}").returns(true)
-          unpacker.run
-        end
-      end
+  it "should attempt to untar file to temporary location" do
+    untarrer = mock('untarrer')
+    Puppet::ModuleTool::Tar.expects(:instance).with(module_name).returns(untarrer)
+    untarrer.expects(:unpack).with(filename, regexp_matches(/^#{Regexp.escape(working_dir)}/)) do |src, dest|
+      FileUtils.mkdir(File.join(dest, 'extractedmodule'))
     end
 
-    context "on solaris" do
-      before :each do
-        Facter.expects(:value).with("osfamily").returns("Solaris")
-      end
-
-      it "should attempt to untar file to temporary location using gnu tar" do
-        Puppet::Util.stubs(:which).with('gtar').returns('/usr/sfw/bin/gtar')
-        Puppet::Util::Execution.expects(:execute).with("gtar xzf #{filename} -C #{build_dir}").returns(true)
-        unpacker.run
-      end
-
-      it "should throw exception if gtar is not in the path exists" do
-        Puppet::Util.stubs(:which).with('gtar').returns(nil)
-        expect { unpacker.run }.to raise_error RuntimeError, "Cannot find the command 'gtar'. Make sure GNU tar is installed, and is in your PATH."
-      end
-    end
+    unpacker.run
+    File.should be_directory(File.join(target, 'mytarball'))
   end
-
 end

data/spec/unit/module_tool/tar/gnu_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'puppet/module_tool'
+
+describe Puppet::ModuleTool::Tar::Gnu do
+  let(:sourcefile) { '/the/module.tar.gz' }
+  let(:destdir)    { '/the/dest/dir' }
+  let(:sourcedir)  { '/the/src/dir' }
+  let(:destfile)   { '/the/dest/file.tar.gz' }
+
+  it "unpacks a tar file" do
+    Puppet::Util::Execution.expects(:execute).with("tar xzf #{sourcefile} -C #{destdir}")
+    subject.unpack(sourcefile, destdir)
+  end
+
+  it "packs a tar file" do
+    Puppet::Util::Execution.expects(:execute).with("tar cf - #{sourcedir} | gzip -c > #{destfile}")
+    subject.pack(sourcedir, destfile)
+  end
+end

data/spec/unit/module_tool/tar/mini_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+require 'puppet/module_tool'
+
+describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? and Puppet.features.zlib?) do
+  let(:sourcefile) { '/the/module.tar.gz' }
+  let(:destdir)    { File.expand_path '/the/dest/dir' }
+  let(:sourcedir)  { '/the/src/dir' }
+  let(:destfile)   { '/the/dest/file.tar.gz' }
+  let(:minitar)    { described_class.new('nginx') }
+
+  it "unpacks a tar file" do
+    unpacks_the_entry(:file_start, 'thefile')
+
+    minitar.unpack(sourcefile, destdir)
+  end
+
+  it "does not allow an absolute path" do
+    unpacks_the_entry(:file_start, '/thefile')
+
+    expect {
+      minitar.unpack(sourcefile, destdir)
+    }.to raise_error(Puppet::ModuleTool::Errors::InvalidPathInPackageError,
+                     "Attempt to install file into \"/thefile\" under \"#{destdir}\"")
+  end
+
+  it "does not allow a file to be written outside the destination directory" do
+    unpacks_the_entry(:file_start, '../../thefile')
+
+    expect {
+      minitar.unpack(sourcefile, destdir)
+    }.to raise_error(Puppet::ModuleTool::Errors::InvalidPathInPackageError,
+                     "Attempt to install file into \"#{File.expand_path('/the/thefile')}\" under \"#{destdir}\"")
+  end
+
+  it "does not allow a directory to be written outside the destination directory" do
+    unpacks_the_entry(:dir, '../../thedir')
+
+    expect {
+      minitar.unpack(sourcefile, destdir)
+    }.to raise_error(Puppet::ModuleTool::Errors::InvalidPathInPackageError,
+                     "Attempt to install file into \"#{File.expand_path('/the/thedir')}\" under \"#{destdir}\"")
+  end
+
+  it "packs a tar file" do
+    writer = mock('GzipWriter')
+
+    Zlib::GzipWriter.expects(:open).with(destfile).yields(writer)
+    Archive::Tar::Minitar.expects(:pack).with(sourcedir, writer)
+
+    minitar.pack(sourcedir, destfile)
+  end
+
+  def unpacks_the_entry(type, name)
+    reader = mock('GzipReader')
+
+    Zlib::GzipReader.expects(:open).with(sourcefile).yields(reader)
+    Archive::Tar::Minitar.expects(:unpack).with(reader, destdir).yields(type, name, nil)
+  end
+end

data/spec/unit/module_tool/tar/solaris_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'puppet/module_tool'
+
+describe Puppet::ModuleTool::Tar::Solaris do
+  let(:sourcefile) { '/the/module.tar.gz' }
+  let(:destdir)    { '/the/dest/dir' }
+  let(:sourcedir)  { '/the/src/dir' }
+  let(:destfile)   { '/the/dest/file.tar.gz' }
+
+  it "unpacks a tar file" do
+    Puppet::Util::Execution.expects(:execute).with("gtar xzf #{sourcefile} -C #{destdir}")
+    subject.unpack(sourcefile, destdir)
+  end
+
+  it "packs a tar file" do
+    Puppet::Util::Execution.expects(:execute).with("tar cf - #{sourcedir} | gzip -c > #{destfile}")
+    subject.pack(sourcedir, destfile)
+  end
+end

data/spec/unit/network/http/connection_spec.rb

@@ -199,9 +199,14 @@ describe Puppet::Network::HTTP::Connection do
 
     def a_store_context(args)
       Puppet[:confdir] = tmpdir('conf')
-      cert = Puppet::SSL::CertificateAuthority.new.generate(args[:for_server], :dns_alt_names => args[:for_aliases]).content
       ssl_context = mock('OpenSSL::X509::StoreContext')
-      ssl_context.stubs(:current_cert).returns(cert)
+      if args[:verify_raises]
+        ssl_context.stubs(:current_cert).raises("oh noes")
+      else
+        cert = Puppet::SSL::CertificateAuthority.new.generate(args[:for_server], :dns_alt_names => args[:for_aliases]).content
+        ssl_context.stubs(:current_cert).returns(cert)
+      end
+      ssl_context.stubs(:chain).returns([])
       ssl_context.stubs(:error_string).returns(args[:with_error_string])
       ssl_context
     end
@@ -217,6 +222,16 @@ describe Puppet::Network::HTTP::Connection do
       end.to raise_error(Puppet::Error, "certificate verify failed: [shady looking signature for /CN=not_my_server]")
     end
 
+    it "should provide a useful error message when verify_callback raises", :unless => Puppet.features.microsoft_windows? do
+      subject.stubs(:create_connection).
+          returns(a_connection_that_verifies(:has_passed_pre_checks => false,
+                                             :in_context => a_store_context(:verify_raises => true),
+                                             :fails_with => 'certificate verify failed'))
+      expect do
+        subject.request(:get, stub('request'))
+      end.to raise_error(Puppet::Error, "certificate verify failed: [oh noes]")
+    end
+
     it "should provide a helpful error message when hostname was not match with server certificate", :unless => Puppet.features.microsoft_windows? do
       subject.stubs(:create_connection).
           returns(a_connection_that_verifies(:has_passed_pre_checks => true,

data/spec/unit/network/http/handler_spec.rb

@@ -1,17 +1,12 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
+require 'puppet/network/http'
 require 'puppet/network/http/handler'
 require 'puppet/network/authorization'
 require 'puppet/network/authentication'
 
-class HttpHandled
-  include Puppet::Network::HTTP::Handler
-end
-
 describe Puppet::Network::HTTP::Handler do
-  before do
-    @handler = HttpHandled.new
-  end
+  let(:handler) { TestingHandler.new }
 
   it "should include the v1 REST API" do
     Puppet::Network::HTTP::Handler.ancestors.should be_include(Puppet::Network::HTTP::API::V1)
@@ -21,126 +16,134 @@ describe Puppet::Network::HTTP::Handler do
     Puppet::Network::HTTP::Handler.ancestors.should be_include(Puppet::Network::Authorization)
   end
 
-  it "should have a method for initializing" do
-    @handler.should respond_to(:initialize_for_puppet)
-  end
-
   describe "when initializing" do
     it "should fail when no server type has been provided" do
-      lambda { @handler.initialize_for_puppet }.should raise_error(ArgumentError)
+      lambda { handler.initialize_for_puppet }.should raise_error(ArgumentError)
     end
 
     it "should set server type" do
-      @handler.initialize_for_puppet("foo")
-      @handler.server.should == "foo"
+      handler.initialize_for_puppet("foo")
+      handler.server.should == "foo"
     end
   end
 
-  it "should be able to process requests" do
-    @handler.should respond_to(:process)
-  end
-
   describe "when processing a request" do
+    let(:request) do
+      {
+        :accept_header => "format_one,format_two",
+        :content_type_header => "text/yaml",
+        :http_method => "GET",
+        :path => "/my_handler/my_result",
+        :params => {},
+        :client_cert => nil
+      }
+    end
+
+    let(:response) { mock('http response') }
+
     before do
-      @request     = stub('http request')
-      @request.stubs(:[]).returns "foo"
-      @response    = stub('http response')
       @model_class = stub('indirected model class')
       @indirection = stub('indirection')
       @model_class.stubs(:indirection).returns(@indirection)
 
       @result = stub 'result', :render => "mytext"
 
-      @handler.stubs(:check_authorization)
-      @handler.stubs(:warn_if_near_expiration)
+      request[:headers] = {
+          "Content-Type"  => request[:content_type_header],
+          "Accept"        => request[:accept_header]
+      }
 
-      stub_server_interface
-    end
-
-    # Stub out the interface we require our including classes to
-    # implement.
-    def stub_server_interface
-      @handler.stubs(:accept_header      ).returns "format_one,format_two"
-      @handler.stubs(:content_type_header).returns "text/yaml"
-      @handler.stubs(:set_content_type   ).returns "my_result"
-      @handler.stubs(:set_response       ).returns "my_result"
-      @handler.stubs(:path               ).returns "/my_handler/my_result"
-      @handler.stubs(:http_method        ).returns("GET")
-      @handler.stubs(:params             ).returns({})
-      @handler.stubs(:content_type       ).returns("text/plain")
-      @handler.stubs(:client_cert        ).returns(nil)
+      handler.stubs(:check_authorization)
+      handler.stubs(:warn_if_near_expiration)
+      handler.stubs(:headers).returns(request[:headers])
     end
 
     it "should check the client certificate for upcoming expiration" do
       cert = mock 'cert'
-      @handler.stubs(:uri2indirection).returns(["facts", :mymethod, "key", {:node => "name"}])
-      @handler.expects(:client_cert).returns(cert).with(@request)
-      @handler.expects(:warn_if_near_expiration).with(cert)
+      handler.stubs(:uri2indirection).returns(["facts", :mymethod, "key", {:node => "name"}])
+      handler.expects(:client_cert).returns(cert).with(request)
+      handler.expects(:warn_if_near_expiration).with(cert)
+
+      handler.process(request, response)
+    end
+
+    it "should setup a profiler when the puppet-profiling header exists" do
+      request[:headers][Puppet::Network::HTTP::HEADER_ENABLE_PROFILING.downcase] = "true"
+
+      handler.process(request, response)
+
+      Puppet::Util::Profiler.current.should be_kind_of(Puppet::Util::Profiler::WallClock)
+    end
+
+    it "should not setup profiler when the profile parameter is missing" do
+      request[:params] = { }
+
+      handler.process(request, response)
 
-      @handler.process(@request, @response)
+      Puppet::Util::Profiler.current.should == Puppet::Util::Profiler::NONE
     end
 
     it "should create an indirection request from the path, parameters, and http method" do
-      @handler.expects(:path).with(@request).returns "mypath"
-      @handler.expects(:http_method).with(@request).returns "mymethod"
-      @handler.expects(:params).with(@request).returns "myparams"
+      request[:path] = "mypath"
+      request[:http_method] = "mymethod"
+      request[:params] = { :params => "mine" }
 
-      @handler.expects(:uri2indirection).with("mymethod", "mypath", "myparams").returns stub("request", :method => :find)
+      handler.expects(:uri2indirection).with("mymethod", "mypath", { :params => "mine" }).returns stub("request", :method => :find)
 
-      @handler.stubs(:do_find)
+      handler.stubs(:do_find)
 
-      @handler.process(@request, @response)
+      handler.process(request, response)
     end
 
     it "should call the 'do' method and delegate authorization to the authorization layer" do
-      @handler.expects(:uri2indirection).returns(["facts", :mymethod, "key", {:node => "name"}])
+      handler.expects(:uri2indirection).returns(["facts", :mymethod, "key", {:node => "name"}])
 
-      @handler.expects(:do_mymethod).with("facts", "key", {:node => "name"}, @request, @response)
+      handler.expects(:do_mymethod).with("facts", "key", {:node => "name"}, request, response)
 
-      @handler.expects(:check_authorization).with("facts", :mymethod, "key", {:node => "name"})
+      handler.expects(:check_authorization).with("facts", :mymethod, "key", {:node => "name"})
 
-      @handler.process(@request, @response)
+      handler.process(request, response)
     end
 
     it "should return 403 if the request is not authorized" do
-      @handler.expects(:uri2indirection).returns(["facts", :mymethod, "key", {:node => "name"}])
+      handler.expects(:uri2indirection).returns(["facts", :mymethod, "key", {:node => "name"}])
 
-      @handler.expects(:do_mymethod).never
+      handler.expects(:do_mymethod).never
 
-      @handler.expects(:check_authorization).with("facts", :mymethod, "key", {:node => "name"}).raises(Puppet::Network::AuthorizationError.new("forbidden"))
+      handler.expects(:check_authorization).with("facts", :mymethod, "key", {:node => "name"}).raises(Puppet::Network::AuthorizationError.new("forbidden"))
 
-      @handler.expects(:set_response).with { |response, body, status| status == 403 }
+      handler.expects(:set_response).with(anything, anything, 403)
 
-      @handler.process(@request, @response)
+      handler.process(request, response)
     end
 
     it "should serialize a controller exception when an exception is thrown while finding the model instance" do
-      @handler.expects(:uri2indirection).returns(["facts", :find, "key", {:node => "name"}])
+      handler.expects(:uri2indirection).returns(["facts", :find, "key", {:node => "name"}])
 
-      @handler.expects(:do_find).raises(ArgumentError, "The exception")
-      @handler.expects(:set_response).with { |response, body, status| body == "The exception" and status == 400 }
-      @handler.process(@request, @response)
+      handler.expects(:do_find).raises(ArgumentError, "The exception")
+      handler.expects(:set_response).with(anything, "The exception", 400)
+      handler.process(request, response)
     end
 
     it "should set the format to text/plain when serializing an exception" do
-      @handler.expects(:set_content_type).with(@response, "text/plain")
-      @handler.do_exception(@response, "A test", 404)
+      handler.expects(:set_content_type).with(response, "text/plain")
+      handler.do_exception(response, "A test", 404)
     end
 
     it "should raise an error if the request is formatted in an unknown format" do
-      @handler.stubs(:content_type_header).returns "unknown format"
-      lambda { @handler.request_format(@request) }.should raise_error
+      handler.stubs(:content_type_header).returns "unknown format"
+      lambda { handler.request_format(request) }.should raise_error
     end
 
     it "should still find the correct format if content type contains charset information" do
-      @handler.stubs(:content_type_header).returns "text/plain; charset=UTF-8"
-      @handler.request_format(@request).should == "s"
+      handler.stubs(:content_type_header).returns "text/plain; charset=UTF-8"
+      handler.request_format(request).should == "s"
     end
 
     it "should deserialize YAML parameters" do
       params = {'my_param' => [1,2,3].to_yaml}
 
-      decoded_params = @handler.send(:decode_params, params)
+      decoded_params = handler.send(:decode_params, params)
 
       decoded_params.should == {:my_param => [1,2,3]}
     end
@@ -148,7 +151,7 @@ describe Puppet::Network::HTTP::Handler do
     it "should accept YAML parameters with !ruby/hash tags on Ruby 1.8", :if => RUBY_VERSION =~ /^1\.8/ do
       params = {'my_param' => "--- !ruby/hash:Array {}"}
 
-      decoded_params = @handler.send(:decode_params, params)
+      decoded_params = handler.send(:decode_params, params)
 
       decoded_params[:my_param].should be_an(Array)
     end
@@ -159,7 +162,7 @@ describe Puppet::Network::HTTP::Handler do
     it "should fail if YAML parameters have !ruby/hash tags on Ruby 1.9", :unless => RUBY_VERSION =~ /^1\.8/ do
       params = {'my_param' => "--- !ruby/hash:Array {}"}
 
-      expect { @handler.send(:decode_params, params) }.to raise_error(ArgumentError, /Illegal YAML mapping found/)
+      expect { handler.send(:decode_params, params) }.to raise_error(ArgumentError, /Illegal YAML mapping found/)
     end
 
     describe "when finding a model instance" do
@@ -175,84 +178,81 @@ describe Puppet::Network::HTTP::Handler do
       end
 
       it "should use the indirection request to find the model class" do
-        @handler.do_find("my_handler", "my_result", {}, @request, @response)
+        handler.do_find("my_handler", "my_result", {}, request, response)
       end
 
       it "should use the escaped request key" do
-        @indirection.expects(:find).with do |key, args|
-          key == "my_result"
-        end.returns @result
-        @handler.do_find("my_handler", "my_result", {}, @request, @response)
+        @indirection.expects(:find).with("my_result", anything).returns @result
+        handler.do_find("my_handler", "my_result", {}, request, response)
       end
 
       it "should use a common method for determining the request parameters" do
-        @indirection.expects(:find).with do |key, args|
-          args[:foo] == :baz and args[:bar] == :xyzzy
-        end.returns @result
-        @handler.do_find("my_handler", "my_result", {:foo => :baz, :bar => :xyzzy}, @request, @response)
+        @indirection.expects(:find).with(anything, has_entries(:foo => :baz, :bar => :xyzzy)).returns @result
+
+        handler.do_find("my_handler", "my_result", {:foo => :baz, :bar => :xyzzy}, request, response)
       end
 
       it "should set the content type to the first format specified in the accept header" do
-        @handler.expects(:accept_header).with(@request).returns "one,two"
-        @handler.expects(:set_content_type).with(@response, @oneformat)
-        @handler.do_find("my_handler", "my_result", {}, @request, @response)
+        handler.expects(:accept_header).with(request).returns "one,two"
+        handler.expects(:set_content_type).with(response, @oneformat)
+        handler.do_find("my_handler", "my_result", {}, request, response)
       end
 
       it "should fail if no accept header is provided" do
-        @handler.expects(:accept_header).with(@request).returns nil
-        lambda { @handler.do_find("my_handler", "my_result", {}, @request, @response) }.should raise_error(ArgumentError)
+        handler.expects(:accept_header).with(request).returns nil
+        lambda { handler.do_find("my_handler", "my_result", {}, request, response) }.should raise_error(ArgumentError)
       end
 
       it "should fail if the accept header does not contain a valid format" do
-        @handler.expects(:accept_header).with(@request).returns ""
-        lambda { @handler.do_find("my_handler", "my_result", {}, @request, @response) }.should raise_error(RuntimeError)
+        handler.expects(:accept_header).with(request).returns ""
+        lambda { handler.do_find("my_handler", "my_result", {}, request, response) }.should raise_error(RuntimeError)
       end
 
       it "should not use an unsuitable format" do
-        @handler.expects(:accept_header).with(@request).returns "foo,bar"
+        handler.expects(:accept_header).with(request).returns "foo,bar"
         foo = mock 'foo', :suitable? => false
         bar = mock 'bar', :suitable? => true
         Puppet::Network::FormatHandler.expects(:format).with("foo").returns foo
         Puppet::Network::FormatHandler.expects(:format).with("bar").returns bar
 
-        @handler.expects(:set_content_type).with(@response, bar) # the suitable one
+        handler.expects(:set_content_type).with(response, bar) # the suitable one
 
-        @handler.do_find("my_handler", "my_result", {}, @request, @response)
+        handler.do_find("my_handler", "my_result", {}, request, response)
       end
 
       it "should render the result using the first format specified in the accept header" do
 
-        @handler.expects(:accept_header).with(@request).returns "one,two"
+        handler.expects(:accept_header).with(request).returns "one,two"
         @result.expects(:render).with(@oneformat)
 
-        @handler.do_find("my_handler", "my_result", {}, @request, @response)
+        handler.do_find("my_handler", "my_result", {}, request, response)
       end
 
       it "should pass the result through without rendering it if the result is a string" do
         @indirection.stubs(:find).returns "foo"
-        @handler.expects(:set_response).with(@response, "foo")
-        @handler.do_find("my_handler", "my_result", {}, @request, @response)
+        handler.expects(:set_response).with(response, "foo")
+        handler.do_find("my_handler", "my_result", {}, request, response)
       end
 
       it "should use the default status when a model find call succeeds" do
-        @handler.expects(:set_response).with { |response, body, status| status.nil? }
-        @handler.do_find("my_handler", "my_result", {}, @request, @response)
+        handler.expects(:set_response).with(anything, anything, nil)
+        handler.do_find("my_handler", "my_result", {}, request, response)
       end
 
       it "should return a serialized object when a model find call succeeds" do
         @model_instance = stub('model instance')
         @model_instance.expects(:render).returns "my_rendered_object"
 
-        @handler.expects(:set_response).with { |response, body, status| body == "my_rendered_object" }
+        handler.expects(:set_response).with(anything, "my_rendered_object", anything)
         @indirection.stubs(:find).returns(@model_instance)
-        @handler.do_find("my_handler", "my_result", {}, @request, @response)
+        handler.do_find("my_handler", "my_result", {}, request, response)
       end
 
       it "should return a 404 when no model instance can be found" do
         @model_class.stubs(:name).returns "my name"
-        @handler.expects(:set_response).with { |response, body, status| status == 404 }
+        handler.expects(:set_response).with(anything, anything, 404)
         @indirection.stubs(:find).returns(nil)
-        @handler.do_find("my_handler", "my_result", {}, @request, @response)
+        handler.do_find("my_handler", "my_result", {}, request, response)
       end
 
       it "should write a log message when no model instance can be found" do
@@ -261,46 +261,44 @@ describe Puppet::Network::HTTP::Handler do
 
         Puppet.expects(:info).with("Could not find my_handler for 'my_result'")
 
-        @handler.do_find("my_handler", "my_result", {}, @request, @response)
+        handler.do_find("my_handler", "my_result", {}, request, response)
       end
 
 
       it "should serialize the result in with the appropriate format" do
         @model_instance = stub('model instance')
 
-        @handler.expects(:format_to_use).returns(@oneformat)
+        handler.expects(:format_to_use).returns(@oneformat)
         @model_instance.expects(:render).with(@oneformat).returns "my_rendered_object"
         @indirection.stubs(:find).returns(@model_instance)
-        @handler.do_find("my_handler", "my_result", {}, @request, @response)
+        handler.do_find("my_handler", "my_result", {}, request, response)
       end
     end
 
     describe "when performing head operation" do
       before do
-        @handler.stubs(:model).with("my_handler").returns(stub 'model', :indirection => @model_class)
-        @handler.stubs(:http_method).with(@request).returns("HEAD")
-        @handler.stubs(:path).with(@request).returns("/production/my_handler/my_result")
-        @handler.stubs(:params).with(@request).returns({})
+        handler.stubs(:model).with("my_handler").returns(stub 'model', :indirection => @model_class)
+        request[:http_method] = "HEAD"
+        request[:path] = "/production/my_handler/my_result"
+        request[:params] = {}
 
         @model_class.stubs(:head).returns true
       end
 
       it "should use the escaped request key" do
-        @model_class.expects(:head).with do |key, args|
-          key == "my_result"
-        end.returns true
-        @handler.process(@request, @response)
+        @model_class.expects(:head).with("my_result", anything).returns true
+        handler.process(request, response)
       end
 
       it "should not generate a response when a model head call succeeds" do
-        @handler.expects(:set_response).never
-        @handler.process(@request, @response)
+        handler.expects(:set_response).never
+        handler.process(request, response)
       end
 
       it "should return a 404 when the model head call returns false" do
-        @handler.expects(:set_response).with { |response, body, status| status == 404 }
+        handler.expects(:set_response).with(anything, anything, 404)
         @model_class.stubs(:head).returns(false)
-        @handler.process(@request, @response)
+        handler.process(request, response)
       end
     end
 
@@ -308,10 +306,10 @@ describe Puppet::Network::HTTP::Handler do
       before do
         Puppet::Indirector::Indirection.expects(:instance).with(:my_handler).returns( stub "indirection", :model => @model_class )
 
-        @result1 = mock 'result1'
-        @result2 = mock 'results'
+        result1 = mock 'result1'
+        result2 = mock 'results'
 
-        @result = [@result1, @result2]
+        @result = [result1, result2]
         @model_class.stubs(:render_multiple).returns "my rendered instances"
         @indirection.stubs(:search).returns(@result)
 
@@ -323,54 +321,52 @@ describe Puppet::Network::HTTP::Handler do
       end
 
       it "should use the indirection request to find the model" do
-        @handler.do_search("my_handler", "my_result", {}, @request, @response)
+        handler.do_search("my_handler", "my_result", {}, request, response)
       end
 
       it "should use a common method for determining the request parameters" do
-        @indirection.expects(:search).with do |key, args|
-          args[:foo] == :baz and args[:bar] == :xyzzy
-        end.returns @result
-        @handler.do_search("my_handler", "my_result", {:foo => :baz, :bar => :xyzzy}, @request, @response)
+        @indirection.expects(:search).with(anything, has_entries(:foo => :baz, :bar => :xyzzy)).returns @result
+        handler.do_search("my_handler", "my_result", {:foo => :baz, :bar => :xyzzy}, request, response)
       end
 
       it "should use the default status when a model search call succeeds" do
         @indirection.stubs(:search).returns(@result)
-        @handler.do_search("my_handler", "my_result", {}, @request, @response)
+        handler.do_search("my_handler", "my_result", {}, request, response)
       end
 
       it "should set the content type to the first format returned by the accept header" do
-        @handler.expects(:accept_header).with(@request).returns "one,two"
-        @handler.expects(:set_content_type).with(@response, @oneformat)
+        handler.expects(:accept_header).with(request).returns "one,two"
+        handler.expects(:set_content_type).with(response, @oneformat)
 
-        @handler.do_search("my_handler", "my_result", {}, @request, @response)
+        handler.do_search("my_handler", "my_result", {}, request, response)
       end
 
       it "should return a list of serialized objects when a model search call succeeds" do
-        @handler.expects(:accept_header).with(@request).returns "one,two"
+        handler.expects(:accept_header).with(request).returns "one,two"
 
         @indirection.stubs(:search).returns(@result)
 
         @model_class.expects(:render_multiple).with(@oneformat, @result).returns "my rendered instances"
 
-        @handler.expects(:set_response).with { |response, data| data == "my rendered instances" }
-        @handler.do_search("my_handler", "my_result", {}, @request, @response)
+        handler.expects(:set_response).with(anything, "my rendered instances")
+        handler.do_search("my_handler", "my_result", {}, request, response)
       end
 
       it "should return [] when searching returns an empty array" do
-        @handler.expects(:accept_header).with(@request).returns "one,two"
+        handler.expects(:accept_header).with(request).returns "one,two"
         @indirection.stubs(:search).returns([])
         @model_class.expects(:render_multiple).with(@oneformat, []).returns "[]"
 
 
-        @handler.expects(:set_response).with { |response, data| data == "[]" }
-        @handler.do_search("my_handler", "my_result", {}, @request, @response)
+        handler.expects(:set_response).with(anything, "[]")
+        handler.do_search("my_handler", "my_result", {}, request, response)
       end
 
       it "should return a 404 when searching returns nil" do
         @model_class.stubs(:name).returns "my name"
-        @handler.expects(:set_response).with { |response, body, status| status == 404 }
+        handler.expects(:set_response).with(anything, anything, 404)
         @indirection.stubs(:search).returns(nil)
-        @handler.do_search("my_handler", "my_result", {}, @request, @response)
+        handler.do_search("my_handler", "my_result", {}, request, response)
       end
     end
 
@@ -383,43 +379,39 @@ describe Puppet::Network::HTTP::Handler do
       end
 
       it "should use the indirection request to find the model" do
-        @handler.do_destroy("my_handler", "my_result", {}, @request, @response)
+        handler.do_destroy("my_handler", "my_result", {}, request, response)
       end
 
       it "should use the escaped request key to destroy the instance in the model" do
-        @indirection.expects(:destroy).with do |key, args|
-          key == "foo bar"
-        end
-        @handler.do_destroy("my_handler", "foo bar", {}, @request, @response)
+        @indirection.expects(:destroy).with("foo bar", anything)
+        handler.do_destroy("my_handler", "foo bar", {}, request, response)
       end
 
       it "should use a common method for determining the request parameters" do
-        @indirection.expects(:destroy).with do |key, args|
-          args[:foo] == :baz and args[:bar] == :xyzzy
-        end
-        @handler.do_destroy("my_handler", "my_result", {:foo => :baz, :bar => :xyzzy}, @request, @response)
+        @indirection.expects(:destroy).with(anything, has_entries(:foo => :baz, :bar => :xyzzy))
+        handler.do_destroy("my_handler", "my_result", {:foo => :baz, :bar => :xyzzy}, request, response)
       end
 
       it "should use the default status code a model destroy call succeeds" do
-        @handler.expects(:set_response).with { |response, body, status| status.nil? }
-        @handler.do_destroy("my_handler", "my_result", {}, @request, @response)
+        handler.expects(:set_response).with(anything, anything, nil)
+        handler.do_destroy("my_handler", "my_result", {}, request, response)
       end
 
       it "should return a yaml-encoded result when a model destroy call succeeds" do
         @result = stub 'result', :to_yaml => "the result"
         @indirection.expects(:destroy).returns(@result)
 
-        @handler.expects(:set_response).with { |response, body, status| body == "the result" }
+        handler.expects(:set_response).with(anything, "the result", anything)
 
-        @handler.do_destroy("my_handler", "my_result", {}, @request, @response)
+        handler.do_destroy("my_handler", "my_result", {}, request, response)
       end
     end
 
     describe "when saving a model instance" do
       before do
         Puppet::Indirector::Indirection.stubs(:instance).with(:my_handler).returns( stub "indirection", :model => @model_class )
-        @handler.stubs(:body).returns('my stuff')
-        @handler.stubs(:content_type_header).returns("text/yaml")
+        handler.stubs(:body).returns('my stuff')
+        handler.stubs(:content_type_header).returns("text/yaml")
 
         @result = stub 'result', :render => "the result"
 
@@ -434,50 +426,50 @@ describe Puppet::Network::HTTP::Handler do
       end
 
       it "should use the indirection request to find the model" do
-        @handler.do_save("my_handler", "my_result", {}, @request, @response)
+        handler.do_save("my_handler", "my_result", {}, request, response)
       end
 
       it "should use the 'body' hook to retrieve the body of the request" do
-        @handler.expects(:body).returns "my body"
-        @model_class.expects(:convert_from).with { |format, body| body == "my body" }.returns @model_instance
+        handler.expects(:body).returns "my body"
+        @model_class.expects(:convert_from).with(anything, "my body").returns @model_instance
 
-        @handler.do_save("my_handler", "my_result", {}, @request, @response)
+        handler.do_save("my_handler", "my_result", {}, request, response)
       end
 
       it "should fail to save model if data is not specified" do
-        @handler.stubs(:body).returns('')
+        handler.stubs(:body).returns('')
 
-        lambda { @handler.do_save("my_handler", "my_result", {}, @request, @response) }.should raise_error(ArgumentError)
+        lambda { handler.do_save("my_handler", "my_result", {}, request, response) }.should raise_error(ArgumentError)
       end
 
       it "should use a common method for determining the request parameters" do
         @indirection.expects(:save).with(@model_instance, 'key').once
-        @handler.do_save("my_handler", "key", {}, @request, @response)
+        handler.do_save("my_handler", "key", {}, request, response)
       end
 
       it "should use the default status when a model save call succeeds" do
-        @handler.expects(:set_response).with { |response, body, status| status.nil? }
-        @handler.do_save("my_handler", "my_result", {}, @request, @response)
+        handler.expects(:set_response).with(anything, anything, nil)
+        handler.do_save("my_handler", "my_result", {}, request, response)
       end
 
       it "should return the yaml-serialized result when a model save call succeeds" do
         @indirection.stubs(:save).returns(@model_instance)
         @model_instance.expects(:to_yaml).returns('foo')
-        @handler.do_save("my_handler", "my_result", {}, @request, @response)
+        handler.do_save("my_handler", "my_result", {}, request, response)
       end
 
       it "should set the content to yaml" do
-        @handler.expects(:set_content_type).with(@response, @yamlformat)
-        @handler.do_save("my_handler", "my_result", {}, @request, @response)
+        handler.expects(:set_content_type).with(response, @yamlformat)
+        handler.do_save("my_handler", "my_result", {}, request, response)
       end
 
       it "should use the content-type header to know the body format" do
-        @handler.expects(:content_type_header).returns("text/format")
+        handler.expects(:content_type_header).returns("text/format")
         Puppet::Network::FormatHandler.stubs(:mime).with("text/format").returns @format
 
-        @model_class.expects(:convert_from).with { |format, body| format == "format" }.returns @model_instance
+        @model_class.expects(:convert_from).with("format", anything).returns @model_instance
 
-        @handler.do_save("my_handler", "my_result", {}, @request, @response)
+        handler.do_save("my_handler", "my_result", {}, request, response)
       end
     end
   end
@@ -486,19 +478,55 @@ describe Puppet::Network::HTTP::Handler do
     it "should use a look-up from the ip address" do
       Resolv.expects(:getname).with("1.2.3.4").returns("host.domain.com")
 
-      @handler.resolve_node(:ip => "1.2.3.4")
+      handler.resolve_node(:ip => "1.2.3.4")
     end
 
     it "should return the look-up result" do
       Resolv.stubs(:getname).with("1.2.3.4").returns("host.domain.com")
 
-      @handler.resolve_node(:ip => "1.2.3.4").should == "host.domain.com"
+      handler.resolve_node(:ip => "1.2.3.4").should == "host.domain.com"
     end
 
     it "should return the ip address if resolving fails" do
       Resolv.stubs(:getname).with("1.2.3.4").raises(RuntimeError, "no such host")
 
-      @handler.resolve_node(:ip => "1.2.3.4").should == "1.2.3.4"
+      handler.resolve_node(:ip => "1.2.3.4").should == "1.2.3.4"
+    end
+  end
+
+  class TestingHandler
+    include Puppet::Network::HTTP::Handler
+
+    def accept_header(request)
+      request[:accept_header]
+    end
+
+    def content_type_header(request)
+      request[:content_type_header]
+    end
+
+    def set_content_type(response, format)
+      "my_result"
+    end
+
+    def set_response(response, body, status = 200)
+      "my_result"
+    end
+
+    def http_method(request)
+      request[:http_method]
+    end
+
+    def path(request)
+      request[:path]
+    end
+
+    def params(request)
+      request[:params]
+    end
+
+    def client_cert(request)
+      request[:client_cert]
     end
   end
 end