puppet 3.2.4 → 3.3.0.rc2

data/spec/unit/network/format_support_spec.rb

@@ -0,0 +1,199 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+require 'puppet/network/format_handler'
+require 'puppet/network/format_support'
+
+class FormatTester
+  include Puppet::Network::FormatSupport
+end
+
+describe Puppet::Network::FormatHandler do
+  before(:each) do
+    @saved_formats = Puppet::Network::FormatHandler.instance_variable_get(:@formats).dup
+    Puppet::Network::FormatHandler.instance_variable_set(:@formats, {})
+  end
+
+  after(:each) do
+    Puppet::Network::FormatHandler.instance_variable_set(:@formats, @saved_formats)
+  end
+
+  describe "when listing formats" do
+    before(:each) do
+      one = Puppet::Network::FormatHandler.create(:one, :weight => 1)
+      one.stubs(:supported?).returns(true)
+      two = Puppet::Network::FormatHandler.create(:two, :weight => 6)
+      two.stubs(:supported?).returns(true)
+      three = Puppet::Network::FormatHandler.create(:three, :weight => 2)
+      three.stubs(:supported?).returns(true)
+      four = Puppet::Network::FormatHandler.create(:four, :weight => 8)
+      four.stubs(:supported?).returns(false)
+    end
+
+    it "should return all supported formats in decreasing order of weight" do
+      FormatTester.supported_formats.should == [:two, :three, :one]
+    end
+  end
+
+  it "should return the first format as the default format" do
+    FormatTester.expects(:supported_formats).returns [:one, :two]
+    FormatTester.default_format.should == :one
+  end
+
+  describe "with a preferred serialization format setting" do
+    before do
+      one = Puppet::Network::FormatHandler.create(:one, :weight => 1)
+      one.stubs(:supported?).returns(true)
+      two = Puppet::Network::FormatHandler.create(:two, :weight => 6)
+      two.stubs(:supported?).returns(true)
+    end
+
+    describe "that is supported" do
+      before do
+        Puppet[:preferred_serialization_format] = :one
+      end
+
+      it "should return the preferred serialization format first" do
+        FormatTester.supported_formats.should == [:one, :two]
+      end
+    end
+
+    describe "that is not supported" do
+      before do
+        Puppet[:preferred_serialization_format] = :unsupported
+      end
+
+      it "should return the default format first" do
+        FormatTester.supported_formats.should == [:two, :one]
+      end
+
+      it "should log a debug message" do
+        Puppet.expects(:debug).with("Value of 'preferred_serialization_format' (unsupported) is invalid for FormatTester, using default (two)")
+        Puppet.expects(:debug).with("FormatTester supports formats: two one")
+        FormatTester.supported_formats
+      end
+    end
+  end
+
+  describe "when using formats" do
+    let(:format) { Puppet::Network::FormatHandler.create(:my_format, :mime => "text/myformat") }
+
+    it "should use the Format to determine whether a given format is supported" do
+      format.expects(:supported?).with(FormatTester)
+      FormatTester.support_format?(:my_format)
+    end
+
+    it "should call the format-specific converter when asked to convert from a given format" do
+      format.expects(:intern).with(FormatTester, "mydata")
+      FormatTester.convert_from(:my_format, "mydata")
+    end
+
+    it "should call the format-specific converter when asked to convert from a given format by mime-type" do
+      format.expects(:intern).with(FormatTester, "mydata")
+      FormatTester.convert_from("text/myformat", "mydata")
+    end
+
+    it "should call the format-specific converter when asked to convert from a given format by format instance" do
+      format.expects(:intern).with(FormatTester, "mydata")
+      FormatTester.convert_from(format, "mydata")
+    end
+
+    it "should raise a FormatError when an exception is encountered when converting from a format" do
+      format.expects(:intern).with(FormatTester, "mydata").raises "foo"
+      expect do
+        FormatTester.convert_from(:my_format, "mydata")
+      end.to raise_error(
+        Puppet::Network::FormatHandler::FormatError,
+        'Could not intern from my_format: foo'
+      )
+    end
+
+    it "should be able to use a specific hook for converting into multiple instances" do
+      format.expects(:intern_multiple).with(FormatTester, "mydata")
+
+      FormatTester.convert_from_multiple(:my_format, "mydata")
+    end
+
+    it "should raise a FormatError when an exception is encountered when converting multiple items from a format" do
+      format.expects(:intern_multiple).with(FormatTester, "mydata").raises "foo"
+      expect do
+        FormatTester.convert_from_multiple(:my_format, "mydata")
+      end.to raise_error(Puppet::Network::FormatHandler::FormatError, 'Could not intern_multiple from my_format: foo')
+    end
+
+    it "should be able to use a specific hook for rendering multiple instances" do
+      format.expects(:render_multiple).with("mydata")
+
+      FormatTester.render_multiple(:my_format, "mydata")
+    end
+
+    it "should raise a FormatError when an exception is encountered when rendering multiple items into a format" do
+      format.expects(:render_multiple).with("mydata").raises "foo"
+      expect do
+        FormatTester.render_multiple(:my_format, "mydata")
+      end.to raise_error(Puppet::Network::FormatHandler::FormatError, 'Could not render_multiple to my_format: foo')
+    end
+  end
+
+  describe "when an instance" do
+    let(:format) { Puppet::Network::FormatHandler.create(:foo, :mime => "text/foo") }
+
+    it "should list as supported a format that reports itself supported" do
+      format.expects(:supported?).returns true
+      FormatTester.new.support_format?(:foo).should be_true
+    end
+
+    it "should raise a FormatError when a rendering error is encountered" do
+      tester = FormatTester.new
+      format.expects(:render).with(tester).raises "eh"
+
+      expect do
+        tester.render(:foo)
+      end.to raise_error(Puppet::Network::FormatHandler::FormatError, 'Could not render to foo: eh')
+    end
+
+    it "should call the format-specific converter when asked to convert to a given format" do
+      tester = FormatTester.new
+      format.expects(:render).with(tester).returns "foo"
+
+      tester.render(:foo).should == "foo"
+    end
+
+    it "should call the format-specific converter when asked to convert to a given format by mime-type" do
+      tester = FormatTester.new
+      format.expects(:render).with(tester).returns "foo"
+
+      tester.render("text/foo").should == "foo"
+    end
+
+    it "should call the format converter when asked to convert to a given format instance" do
+      tester = FormatTester.new
+      format.expects(:render).with(tester).returns "foo"
+
+      tester.render(format).should == "foo"
+    end
+
+    it "should render to the default format if no format is provided when rendering" do
+      FormatTester.expects(:default_format).returns :foo
+      tester = FormatTester.new
+
+      format.expects(:render).with(tester)
+      tester.render
+    end
+
+    it "should call the format-specific converter when asked for the mime-type of a given format" do
+      tester = FormatTester.new
+      format.expects(:mime).returns "text/foo"
+
+      tester.mime(:foo).should == "text/foo"
+    end
+
+    it "should return the default format mime-type if no format is provided" do
+      FormatTester.expects(:default_format).returns :foo
+      tester = FormatTester.new
+
+      format.expects(:mime).returns "text/foo"
+      tester.mime.should == "text/foo"
+    end
+  end
+end

data/spec/unit/network/formats_spec.rb

@@ -315,8 +315,8 @@ describe "Puppet Network Format" do
     end
 
     [[1, 2], ["one"], [{ 1 => 1 }]].each do |input|
-      it "should render #{input.inspect} as JSON" do
-        subject.render(input).should == json.render(input).chomp
+      it "should render #{input.inspect} as one item per line" do
+        subject.render(input).should == input.collect { |item| item.to_s + "\n" }.join('')
       end
     end
 

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

@@ -39,8 +39,47 @@ describe Puppet::Network::HTTP::Connection do
       end
 
       it "can set ssl using an option" do
-        Puppet::Network::HTTP::Connection.new(host, port, false).send(:connection).should_not be_use_ssl
-        Puppet::Network::HTTP::Connection.new(host, port, true).send(:connection).should be_use_ssl
+        Puppet::Network::HTTP::Connection.new(host, port, :use_ssl => false).send(:connection).should_not be_use_ssl
+        Puppet::Network::HTTP::Connection.new(host, port, :use_ssl => true).send(:connection).should be_use_ssl
+      end
+
+      describe "peer verification" do
+        def setup_standard_ssl_configuration
+          ca_cert_file = File.expand_path('/path/to/ssl/certs/ca_cert.pem')
+          FileTest.stubs(:exist?).with(ca_cert_file).returns(true)
+
+          ssl_configuration = stub('ssl_configuration', :ca_auth_file => ca_cert_file)
+          Puppet::Network::HTTP::Connection.any_instance.stubs(:ssl_configuration).returns(ssl_configuration)
+        end
+
+        def setup_standard_hostcert
+          host_cert_file = File.expand_path('/path/to/ssl/certs/host_cert.pem')
+          FileTest.stubs(:exist?).with(host_cert_file).returns(true)
+
+          Puppet[:hostcert] = host_cert_file
+        end
+
+        def setup_standard_ssl_host
+          cert = stub('cert', :content => 'real_cert')
+          key  = stub('key',  :content => 'real_key')
+          host = stub('host', :certificate => cert, :key => key, :ssl_store => stub('store'))
+
+          Puppet::Network::HTTP::Connection.any_instance.stubs(:ssl_host).returns(host)
+        end
+
+        before do
+          setup_standard_ssl_configuration
+          setup_standard_hostcert
+          setup_standard_ssl_host
+        end
+
+        it "can enable peer verification" do
+          Puppet::Network::HTTP::Connection.new(host, port, :verify_peer => true).send(:connection).verify_mode.should == OpenSSL::SSL::VERIFY_PEER
+        end
+
+        it "can disable peer verification" do
+          Puppet::Network::HTTP::Connection.new(host, port, :verify_peer => false).send(:connection).verify_mode.should == OpenSSL::SSL::VERIFY_NONE
+        end
       end
 
       context "proxy and timeout settings should propagate" do
@@ -62,6 +101,10 @@ describe Puppet::Network::HTTP::Connection do
         subject.send(:connection).proxy_address.should be_nil
       end
 
+      it "should raise Puppet::Error when invalid options are specified" do
+        expect { Puppet::Network::HTTP::Connection.new(host, port, :invalid_option => nil) }.to raise_error(Puppet::Error, 'Unrecognized option(s): :invalid_option')
+      end
+
     end
 
     describe "when doing SSL setup for http instances" do
@@ -86,7 +129,7 @@ describe Puppet::Network::HTTP::Connection do
       end
 
       shared_examples "HTTPS setup without all certificates" do
-        subject { Puppet::Network::HTTP::Connection.new(host, port, true).send(:connection) }
+        subject { Puppet::Network::HTTP::Connection.new(host, port, :use_ssl => true).send(:connection) }
 
         it                { should be_use_ssl }
         its(:cert)        { should be_nil }
@@ -123,7 +166,7 @@ describe Puppet::Network::HTTP::Connection do
       end
 
       context "with both the host and CA cert" do
-        subject { Puppet::Network::HTTP::Connection.new(host, port, true).send(:connection) }
+        subject { Puppet::Network::HTTP::Connection.new(host, port, :use_ssl => true).send(:connection) }
 
         before :each do
           FileTest.expects(:exist?).with(Puppet[:hostcert]).returns(true)
@@ -145,11 +188,10 @@ describe Puppet::Network::HTTP::Connection do
     end
   end
 
-
   context "when methods that accept a block are called with a block" do
     let (:host) { "my_server" }
     let (:port) { 8140 }
-    let (:subject) { Puppet::Network::HTTP::Connection.new(host, port, false) }
+    let (:subject) { Puppet::Network::HTTP::Connection.new(host, port, :use_ssl => false) }
     let (:httpok) { Net::HTTPOK.new('1.1', 200, '') }
 
     before :each do
@@ -185,6 +227,7 @@ describe Puppet::Network::HTTP::Connection do
 
     let (:host) { "my_server" }
     let (:port) { 8140 }
+    let (:httpok) { Net::HTTPOK.new('1.1', 200, '') }
     let (:subject) { Puppet::Network::HTTP::Connection.new(host, port) }
 
     def a_connection_that_verifies(args)
@@ -269,11 +312,49 @@ describe Puppet::Network::HTTP::Connection do
         connection.verify_callback.call(true, context)
         connection.verify_callback.call(true, context)
         true
-      end
+      end.returns(httpok)
 
       subject.expects(:warn_if_near_expiration).with(cert, cert)
 
       subject.request(:get, stubs('request'))
     end
   end
+
+  context "when response is a redirect" do
+    let (:other_host) { "redirected" }
+    let (:other_port) { 9292 }
+    let (:other_path) { "other-path" }
+    let (:subject) { Puppet::Network::HTTP::Connection.new("my_server", 8140, :use_ssl => false) }
+    let (:httpredirection) { Net::HTTPFound.new('1.1', 302, 'Moved Temporarily') }
+    let (:httpok) { Net::HTTPOK.new('1.1', 200, '') }
+
+    before :each do
+      httpredirection['location'] = "http://#{other_host}:#{other_port}/#{other_path}"
+      httpredirection.stubs(:read_body).returns("This resource has moved")
+
+      socket = stub_everything("socket")
+      TCPSocket.stubs(:open).returns(socket)
+
+      Net::HTTP::Get.any_instance.stubs(:exec).returns("")
+      Net::HTTP::Post.any_instance.stubs(:exec).returns("")
+    end
+
+    it "should redirect to the final resource location" do
+      httpok.stubs(:read_body).returns(:body)
+      Net::HTTPResponse.stubs(:read_new).returns(httpredirection).then.returns(httpok)
+
+      subject.get("/foo").body.should == :body
+      subject.port.should == other_port
+      subject.address.should == other_host
+    end
+
+    it "should raise an error after too many redirections" do
+      Net::HTTPResponse.stubs(:read_new).returns(httpredirection)
+
+      expect {
+        subject.get("/foo")
+      }.to raise_error(Puppet::Network::HTTP::RedirectionLimitExceededException)
+    end
+  end
+
 end

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

@@ -4,8 +4,126 @@ require 'puppet/network/http'
 require 'puppet/network/http/handler'
 require 'puppet/network/authorization'
 require 'puppet/network/authentication'
+require 'puppet/indirector/memory'
 
 describe Puppet::Network::HTTP::Handler do
+  before :each do
+    class Puppet::TestModel
+      extend Puppet::Indirector
+      indirects :test_model
+      attr_accessor :name, :data
+      def initialize(name = "name", data = '')
+        @name = name
+        @data = data
+      end
+
+      def self.from_pson(pson)
+        new(pson["name"], pson["data"])
+      end
+
+      def to_pson
+        {
+          "name" => @name,
+          "data" => @data
+        }.to_pson
+      end
+
+      def ==(other)
+        other.is_a? Puppet::TestModel and other.name == name and other.data == data
+      end
+    end
+
+    # The subclass must not be all caps even though the superclass is
+    class Puppet::TestModel::Memory < Puppet::Indirector::Memory
+    end
+
+    Puppet::TestModel.indirection.terminus_class = :memory
+  end
+
+  after :each do
+    Puppet::TestModel.indirection.delete
+    # Remove the class, unlinking it from the rest of the system.
+    Puppet.send(:remove_const, :TestModel)
+  end
+
+  let(:terminus_class) { Puppet::TestModel::Memory }
+  let(:terminus) { Puppet::TestModel.indirection.terminus(:memory) }
+  let(:indirection) { Puppet::TestModel.indirection }
+  let(:model) { Puppet::TestModel }
+
+  def a_request
+    {
+      :accept_header => "pson",
+      :content_type_header => "text/yaml",
+      :http_method => "HEAD",
+      :path => "/production/#{indirection.name}/unknown",
+      :params => {},
+      :client_cert => nil,
+      :headers => {},
+      :body => nil
+    }
+  end
+
+  def a_request_that_heads(data, request = {})
+    {
+      :accept_header => request[:accept_header],
+      :content_type_header => "text/yaml",
+      :http_method => "HEAD",
+      :path => "/production/#{indirection.name}/#{data.name}",
+      :params => {},
+      :client_cert => nil,
+      :body => nil
+    }
+  end
+
+  def a_request_that_submits(data, request = {})
+    {
+      :accept_header => request[:accept_header],
+      :content_type_header => "text/yaml",
+      :http_method => "PUT",
+      :path => "/production/#{indirection.name}/#{data.name}",
+      :params => {},
+      :client_cert => nil,
+      :body => data.render("text/yaml")
+    }
+  end
+
+  def a_request_that_destroys(data, request = {})
+    {
+      :accept_header => request[:accept_header],
+      :content_type_header => "text/yaml",
+      :http_method => "DELETE",
+      :path => "/production/#{indirection.name}/#{data.name}",
+      :params => {},
+      :client_cert => nil,
+      :body => ''
+    }
+  end
+
+  def a_request_that_finds(data, request = {})
+    {
+      :accept_header => request[:accept_header],
+      :content_type_header => "text/yaml",
+      :http_method => "GET",
+      :path => "/production/#{indirection.name}/#{data.name}",
+      :params => {},
+      :client_cert => nil,
+      :body => ''
+    }
+  end
+
+  def a_request_that_searches(key, request = {})
+    {
+      :accept_header => request[:accept_header],
+      :content_type_header => "text/yaml",
+      :http_method => "GET",
+      :path => "/production/#{indirection.name}s/#{key}",
+      :params => {},
+      :client_cert => nil,
+      :body => ''
+    }
+  end
+
   let(:handler) { TestingHandler.new }
 
   it "should include the v1 REST API" do
@@ -28,37 +146,15 @@ describe Puppet::Network::HTTP::Handler do
   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
-      @model_class = stub('indirected model class')
-      @indirection = stub('indirection')
-      @model_class.stubs(:indirection).returns(@indirection)
-
-      @result = stub 'result', :render => "mytext"
-
-      request[:headers] = {
-          "Content-Type"  => request[:content_type_header],
-          "Accept"        => request[:accept_header]
-      }
-
       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
+      request = a_request
       cert = mock 'cert'
       handler.stubs(:uri2indirection).returns(["facts", :mymethod, "key", {:node => "name"}])
       handler.expects(:client_cert).returns(cert).with(request)
@@ -68,6 +164,7 @@ describe Puppet::Network::HTTP::Handler do
     end
 
     it "should setup a profiler when the puppet-profiling header exists" do
+      request = a_request
       request[:headers][Puppet::Network::HTTP::HEADER_ENABLE_PROFILING.downcase] = "true"
 
       handler.process(request, response)
@@ -76,6 +173,7 @@ describe Puppet::Network::HTTP::Handler do
     end
 
     it "should not setup profiler when the profile parameter is missing" do
+      request = a_request
       request[:params] = { }
 
       handler.process(request, response)
@@ -84,6 +182,7 @@ describe Puppet::Network::HTTP::Handler do
     end
 
     it "should create an indirection request from the path, parameters, and http method" do
+      request = a_request
       request[:path] = "mypath"
       request[:http_method] = "mymethod"
       request[:params] = { :params => "mine" }
@@ -96,6 +195,7 @@ describe Puppet::Network::HTTP::Handler do
     end
 
     it "should call the 'do' method and delegate authorization to the authorization layer" do
+      request = a_request
       handler.expects(:uri2indirection).returns(["facts", :mymethod, "key", {:node => "name"}])
 
       handler.expects(:do_mymethod).with("facts", "key", {:node => "name"}, request, response)
@@ -106,6 +206,7 @@ describe Puppet::Network::HTTP::Handler do
     end
 
     it "should return 403 if the request is not authorized" do
+      request = a_request
       handler.expects(:uri2indirection).returns(["facts", :mymethod, "key", {:node => "name"}])
 
       handler.expects(:do_mymethod).never
@@ -118,6 +219,7 @@ describe Puppet::Network::HTTP::Handler do
     end
 
     it "should serialize a controller exception when an exception is thrown while finding the model instance" do
+      request = a_request
       handler.expects(:uri2indirection).returns(["facts", :find, "key", {:node => "name"}])
 
       handler.expects(:do_find).raises(ArgumentError, "The exception")
@@ -127,15 +229,33 @@ describe Puppet::Network::HTTP::Handler do
 
     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)
+    end
+
+    it "sends an exception string with the given status" do
+      handler.expects(:set_response).with(response, "A test", 404)
+
       handler.do_exception(response, "A test", 404)
     end
 
+    it "sends an exception error with the exception's status" do
+      data = Puppet::TestModel.new("not_found", "not found")
+      request = a_request_that_finds(data, :accept_header => "pson")
+
+      error = Puppet::Network::HTTP::Handler::HTTPNotFoundError.new("Could not find test_model not_found")
+      handler.expects(:set_response).with(response, error.to_s, error.status)
+
+      handler.process(request, response)
+    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
     end
 
     it "should still find the correct format if content type contains charset information" do
+      request = a_request
       handler.stubs(:content_type_header).returns "text/plain; charset=UTF-8"
       handler.request_format(request).should == "s"
     end
@@ -157,310 +277,204 @@ describe Puppet::Network::HTTP::Handler do
     end
 
     describe "when finding a model instance" do
-      before do
-        @indirection.stubs(:find).returns @result
-        Puppet::Indirector::Indirection.expects(:instance).with(:my_handler).returns( stub "indirection", :model => @model_class )
+      it "uses the first supported format for the response" do
+        data = Puppet::TestModel.new("my data", "some data")
+        indirection.save(data, "my data")
+        request = a_request_that_finds(data, :accept_header => "unknown, pson, yaml")
 
-        @format = stub 'format', :suitable? => true, :mime => "text/format", :name => "format"
-        Puppet::Network::FormatHandler.stubs(:format).returns @format
+        handler.expects(:set_response).with(response, data.render(:pson))
+        handler.expects(:set_content_type).with(response, Puppet::Network::FormatHandler.format(:pson))
 
-        @oneformat = stub 'one', :suitable? => true, :mime => "text/one", :name => "one"
-        Puppet::Network::FormatHandler.stubs(:format).with("one").returns @oneformat
+        handler.do_find(indirection.name, "my data", {}, request, response)
       end
 
-      it "should use the indirection request to find the model class" do
-        handler.do_find("my_handler", "my_result", {}, request, response)
-      end
-
-      it "should use the escaped request key" do
-        @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(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)
-      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)
-      end
+      it "responds with a 406 error when no accept header is provided" do
+        data = Puppet::TestModel.new("my data", "some data")
+        indirection.save(data, "my data")
+        request = a_request_that_finds(data, :accept_header => nil)
 
-      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)
+        expect do
+          handler.do_find(indirection.name, "my data", {}, request, response)
+        end.to raise_error(Puppet::Network::HTTP::Handler::HTTPNotAcceptableError)
       end
 
-      it "should not use an unsuitable format" do
-        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
+      it "raises an error when no accepted formats are known" do
+        data = Puppet::TestModel.new("my data", "some data")
+        indirection.save(data, "my data")
+        request = a_request_that_finds(data, :accept_header => "unknown, also/unknown")
 
-        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"
-        @result.expects(:render).with(@oneformat)
-
-        handler.do_find("my_handler", "my_result", {}, request, response)
+        expect do
+          handler.do_find(indirection.name, "my data", {}, request, response)
+        end.to raise_error(Puppet::Network::HTTP::Handler::HTTPNotAcceptableError)
       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)
-      end
-
-      it "should use the default status when a model find call succeeds" do
-        handler.expects(:set_response).with(anything, anything, nil)
-        handler.do_find("my_handler", "my_result", {}, request, response)
-      end
+        data = Puppet::TestModel.new("my data", "some data")
+        data_string = "my data string"
+        request = a_request_that_finds(data, :accept_header => "pson")
+        indirection.expects(:find).returns(data_string)
 
-      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, data_string)
+        handler.expects(:set_content_type).with(response, Puppet::Network::FormatHandler.format(:pson))
 
-        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(indirection.name, "my data", {}, 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(anything, anything, 404)
-        @indirection.stubs(:find).returns(nil)
-        handler.do_find("my_handler", "my_result", {}, request, response)
-      end
-
-      it "should write a log message when no model instance can be found" do
-        @model_class.stubs(:name).returns "my name"
-        @indirection.stubs(:find).returns(nil)
-
-        Puppet.expects(:info).with("Could not find my_handler for 'my_result'")
+        data = Puppet::TestModel.new("my data", "some data")
+        request = a_request_that_finds(data, :accept_header => "unknown, pson, yaml")
 
-        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)
-        @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)
+        expect do
+          handler.do_find(indirection.name, "my data", {}, request, response)
+        end.to raise_error(Puppet::Network::HTTP::Handler::HTTPNotFoundError)
       end
     end
 
     describe "when performing head operation" do
-      before do
-        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("my_result", anything).returns true
-        handler.process(request, response)
-      end
-
       it "should not generate a response when a model head call succeeds" do
+        data = Puppet::TestModel.new("my data", "some data")
+        indirection.save(data, "my data")
+        request = a_request_that_heads(data)
+
         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(anything, anything, 404)
-        @model_class.stubs(:head).returns(false)
+        data = Puppet::TestModel.new("my data", "data not there")
+        request = a_request_that_heads(data)
+
+        handler.expects(:set_response).with(response, "Not Found: Could not find test_model my data", 404)
+
         handler.process(request, response)
       end
     end
 
     describe "when searching for model instances" do
-      before do
-        Puppet::Indirector::Indirection.expects(:instance).with(:my_handler).returns( stub "indirection", :model => @model_class )
+      it "uses the first supported format for the response" do
+        data = Puppet::TestModel.new("my data", "some data")
+        indirection.save(data, "my data")
+        request = a_request_that_searches("my", :accept_header => "unknown, pson, yaml")
 
-        result1 = mock 'result1'
-        result2 = mock 'results'
+        handler.expects(:set_response).with(response, Puppet::TestModel.render_multiple(:pson, [data]))
+        handler.expects(:set_content_type).with(response, Puppet::Network::FormatHandler.format(:pson))
 
-        @result = [result1, result2]
-        @model_class.stubs(:render_multiple).returns "my rendered instances"
-        @indirection.stubs(:search).returns(@result)
-
-        @format = stub 'format', :suitable? => true, :mime => "text/format", :name => "format"
-        Puppet::Network::FormatHandler.stubs(:format).returns @format
-
-        @oneformat = stub 'one', :suitable? => true, :mime => "text/one", :name => "one"
-        Puppet::Network::FormatHandler.stubs(:format).with("one").returns @oneformat
-      end
-
-      it "should use the indirection request to find the model" do
-        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(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)
-      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.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"
-
-        @indirection.stubs(:search).returns(@result)
-
-        @model_class.expects(:render_multiple).with(@oneformat, @result).returns "my rendered instances"
-
-        handler.expects(:set_response).with(anything, "my rendered instances")
-        handler.do_search("my_handler", "my_result", {}, request, response)
+        handler.do_search(indirection.name, "my", {}, request, response)
       end
 
       it "should return [] when searching returns an empty array" do
-        handler.expects(:accept_header).with(request).returns "one,two"
-        @indirection.stubs(:search).returns([])
-        @model_class.expects(:render_multiple).with(@oneformat, []).returns "[]"
+        request = a_request_that_searches("nothing", :accept_header => "unknown, pson, yaml")
 
+        handler.expects(:set_response).with(response, Puppet::TestModel.render_multiple(:pson, []))
+        handler.expects(:set_content_type).with(response, Puppet::Network::FormatHandler.format(:pson))
 
-        handler.expects(:set_response).with(anything, "[]")
-        handler.do_search("my_handler", "my_result", {}, request, response)
+        handler.do_search(indirection.name, "nothing", {}, 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(anything, anything, 404)
-        @indirection.stubs(:search).returns(nil)
-        handler.do_search("my_handler", "my_result", {}, request, response)
+        request = a_request_that_searches("nothing", :accept_header => "unknown, pson, yaml")
+        indirection.expects(:search).returns(nil)
+
+        expect do
+          handler.do_search(indirection.name, "nothing", {}, request, response)
+        end.to raise_error(Puppet::Network::HTTP::Handler::HTTPNotFoundError)
       end
     end
 
     describe "when destroying a model instance" do
-      before do
-        Puppet::Indirector::Indirection.expects(:instance).with(:my_handler).returns( stub "indirection", :model => @model_class )
+      it "destroys the data indicated in the request" do
+        data = Puppet::TestModel.new("my data", "some data")
+        indirection.save(data, "my data")
+        request = a_request_that_destroys(data)
 
-        @result = stub 'result', :render => "the result"
-        @indirection.stubs(:destroy).returns @result
-      end
+        handler.do_destroy(indirection.name, "my data", {}, request, response)
 
-      it "should use the indirection request to find the model" do
-        handler.do_destroy("my_handler", "my_result", {}, request, response)
+        Puppet::TestModel.indirection.find("my data").should be_nil
       end
 
-      it "should use the escaped request key to destroy the instance in the model" do
-        @indirection.expects(:destroy).with("foo bar", anything)
-        handler.do_destroy("my_handler", "foo bar", {}, request, response)
-      end
+      it "responds with yaml when no Accept header is given" do
+        data = Puppet::TestModel.new("my data", "some data")
+        indirection.save(data, "my data")
+        request = a_request_that_destroys(data, :accept_header => nil)
+
+        handler.expects(:set_response).with(response, data.render(:yaml))
+        handler.expects(:set_content_type).with(response, Puppet::Network::FormatHandler.format(:yaml))
 
-      it "should use a common method for determining the request parameters" do
-        @indirection.expects(:destroy).with(anything, has_entries(:foo => :baz, :bar => :xyzzy))
-        handler.do_destroy("my_handler", "my_result", {:foo => :baz, :bar => :xyzzy}, request, response)
+        handler.do_destroy(indirection.name, "my data", {}, request, response)
       end
 
-      it "should use the default status code a model destroy call succeeds" do
-        handler.expects(:set_response).with(anything, anything, nil)
-        handler.do_destroy("my_handler", "my_result", {}, request, response)
+      it "uses the first supported format for the response" do
+        data = Puppet::TestModel.new("my data", "some data")
+        indirection.save(data, "my data")
+        request = a_request_that_destroys(data, :accept_header => "unknown, pson, yaml")
+
+        handler.expects(:set_response).with(response, data.render(:pson))
+        handler.expects(:set_content_type).with(response, Puppet::Network::FormatHandler.format(:pson))
+
+        handler.do_destroy(indirection.name, "my data", {}, 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)
+      it "raises an error and does not destory when no accepted formats are known" do
+        data = Puppet::TestModel.new("my data", "some data")
+        indirection.save(data, "my data")
+        request = a_request_that_submits(data, :accept_header => "unknown, also/unknown")
 
-        handler.expects(:set_response).with(anything, "the result", anything)
+        expect do
+          handler.do_destroy(indirection.name, "my data", {}, request, response)
+        end.to raise_error(Puppet::Network::HTTP::Handler::HTTPNotAcceptableError)
 
-        handler.do_destroy("my_handler", "my_result", {}, request, response)
+        Puppet::TestModel.indirection.find("my data").should_not be_nil
       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")
-
-        @result = stub 'result', :render => "the result"
-
-        @model_instance = stub('indirected model instance')
-        @model_class.stubs(:convert_from).returns(@model_instance)
-        @indirection.stubs(:save)
+      it "should fail to save model if data is not specified" do
+        data = Puppet::TestModel.new("my data", "some data")
+        request = a_request_that_submits(data)
+        request[:body] = ''
 
-        @format = stub 'format', :suitable? => true, :name => "format", :mime => "text/format"
-        Puppet::Network::FormatHandler.stubs(:format).returns @format
-        @yamlformat = stub 'yaml', :suitable? => true, :name => "yaml", :mime => "text/yaml"
-        Puppet::Network::FormatHandler.stubs(:format).with("yaml").returns @yamlformat
+        expect { handler.do_save("my_handler", "my_result", {}, request, response) }.to raise_error(ArgumentError)
       end
 
-      it "should use the indirection request to find the model" do
-        handler.do_save("my_handler", "my_result", {}, request, response)
-      end
+      it "saves the data sent in the request" do
+        data = Puppet::TestModel.new("my data", "some data")
+        request = a_request_that_submits(data)
 
-      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(anything, "my body").returns @model_instance
+        handler.do_save(indirection.name, "my data", {}, request, response)
 
-        handler.do_save("my_handler", "my_result", {}, request, response)
+        Puppet::TestModel.indirection.find("my data").should == data
       end
 
-      it "should fail to save model if data is not specified" do
-        handler.stubs(:body).returns('')
+      it "responds with yaml when no Accept header is given" do
+        data = Puppet::TestModel.new("my data", "some data")
+        request = a_request_that_submits(data, :accept_header => nil)
 
-        lambda { handler.do_save("my_handler", "my_result", {}, request, response) }.should raise_error(ArgumentError)
-      end
+        handler.expects(:set_response).with(response, data.render(:yaml))
+        handler.expects(:set_content_type).with(response, Puppet::Network::FormatHandler.format(:yaml))
 
-      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(indirection.name, "my data", {}, request, response)
       end
 
-      it "should use the default status when a model save call succeeds" do
-        handler.expects(:set_response).with(anything, anything, nil)
-        handler.do_save("my_handler", "my_result", {}, request, response)
-      end
+      it "uses the first supported format for the response" do
+        data = Puppet::TestModel.new("my data", "some data")
+        request = a_request_that_submits(data, :accept_header => "unknown, pson, yaml")
 
-      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)
-      end
+        handler.expects(:set_response).with(response, data.render(:pson))
+        handler.expects(:set_content_type).with(response, Puppet::Network::FormatHandler.format(:pson))
 
-      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.do_save(indirection.name, "my data", {}, request, response)
       end
 
-      it "should use the content-type header to know the body format" do
-        handler.expects(:content_type_header).returns("text/format")
-        Puppet::Network::FormatHandler.stubs(:mime).with("text/format").returns @format
+      it "raises an error and does not save when no accepted formats are known" do
+        data = Puppet::TestModel.new("my data", "some data")
+        request = a_request_that_submits(data, :accept_header => "unknown, also/unknown")
 
-        @model_class.expects(:convert_from).with("format", anything).returns @model_instance
+        expect do
+          handler.do_save(indirection.name, "my data", {}, request, response)
+        end.to raise_error(Puppet::Network::HTTP::Handler::HTTPNotAcceptableError)
 
-        handler.do_save("my_handler", "my_result", {}, request, response)
+        Puppet::TestModel.indirection.find("my data").should be_nil
       end
     end
   end
@@ -519,5 +533,13 @@ describe Puppet::Network::HTTP::Handler do
     def client_cert(request)
       request[:client_cert]
     end
+
+    def body(request)
+      request[:body]
+    end
+
+    def headers(request)
+      request[:headers] || {}
+    end
   end
 end