puppet 3.4.3 → 3.5.0.rc1

data/spec/unit/network/http/api/v2/authorization_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+require 'puppet/network/http'
+
+describe Puppet::Network::HTTP::API::V2::Authorization do
+  HTTP = Puppet::Network::HTTP
+
+  let(:response) { HTTP::MemoryResponse.new }
+  let(:authz) { HTTP::API::V2::Authorization.new }
+
+  it "only authorizes GET requests" do
+    request = HTTP::Request.from_hash({
+      :method => "POST"
+    })
+
+    expect do
+      authz.call(request, response)
+    end.to raise_error(HTTP::Error::HTTPNotAuthorizedError)
+  end
+
+  it "accepts v2 api requests that match allowed authconfig entries" do
+    request = HTTP::Request.from_hash({
+      :path => "/v2.0/environments",
+      :method => "GET",
+      :params => { :authenticated => true, :node => "testing", :ip => "127.0.0.1" }
+    })
+
+    authz.stubs(:authconfig).returns(Puppet::Network::AuthConfigParser.new(<<-AUTH).parse)
+path /v2.0/environments
+method find
+allow *
+    AUTH
+
+    expect do
+      authz.call(request, response)
+    end.to_not raise_error
+  end
+
+  it "rejects v2 api requests that are disallowed by authconfig entries" do
+    request = HTTP::Request.from_hash({
+      :path => "/v2.0/environments",
+      :method => "GET",
+      :params => { :node => "testing", :ip => "127.0.0.1" }
+    })
+
+    authz.stubs(:authconfig).returns(Puppet::Network::AuthConfigParser.new(<<-AUTH).parse)
+path /v2.0/environments
+method find
+auth any
+deny testing
+    AUTH
+
+    expect do
+      authz.call(request, response)
+    end.to raise_error(HTTP::Error::HTTPNotAuthorizedError, /Forbidden request/)
+  end
+end

data/spec/unit/network/http/api/v2/environments_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+require 'puppet/node/environment'
+require 'puppet/network/http'
+require 'matchers/json'
+
+describe Puppet::Network::HTTP::API::V2::Environments do
+  include JSONMatchers
+
+  it "responds with all of the available environments" do
+    environment = Puppet::Node::Environment.create(:production, ["/first", "/second"], '/manifests')
+    loader = Puppet::Environments::Static.new(environment)
+    handler = Puppet::Network::HTTP::API::V2::Environments.new(loader)
+    response = Puppet::Network::HTTP::MemoryResponse.new
+
+    handler.call(Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }), response)
+
+    expect(response.code).to eq(200)
+    expect(response.type).to eq("application/json")
+    expect(JSON.parse(response.body)).to eq({
+      "search_paths" => loader.search_paths,
+      "environments" => {
+        "production" => {
+          "settings" => {
+            "modulepath" => [File.expand_path("/first"), File.expand_path("/second")],
+            "manifest" => File.expand_path("/manifests")
+          }
+        }
+      }
+    })
+  end
+
+  it "the response conforms to the environments schema" do
+    environment = Puppet::Node::Environment.create(:production, [], '')
+    handler = Puppet::Network::HTTP::API::V2::Environments.new(Puppet::Environments::Static.new(environment))
+    response = Puppet::Network::HTTP::MemoryResponse.new
+
+    handler.call(Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }), response)
+
+    expect(response.body).to validate_against('api/schemas/environments.json')
+  end
+end

data/spec/unit/network/http/api/v2_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+require 'puppet/network/http'
+
+describe Puppet::Network::HTTP::API::V2 do
+  it "responds to unknown paths with a 404" do
+    response = Puppet::Network::HTTP::MemoryResponse.new
+    request = Puppet::Network::HTTP::Request.from_hash(:path => "/v2.0/unknown")
+
+    expect do
+      Puppet::Network::HTTP::API::V2.routes.process(request, response)
+    end.to raise_error(Puppet::Network::HTTP::Error::HTTPNotFoundError)
+  end
+end

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

@@ -8,6 +8,7 @@ describe Puppet::Network::HTTP::Connection do
   let (:host) { "me" }
   let (:port) { 54321 }
   subject { Puppet::Network::HTTP::Connection.new(host, port, :verify => Puppet::SSL::Validator.no_validator) }
+  let (:httpok) { Net::HTTPOK.new('1.1', 200, '') }
 
   context "when providing HTTP connections" do
     after do
@@ -66,7 +67,6 @@ describe Puppet::Network::HTTP::Connection do
     let (:host) { "my_server" }
     let (:port) { 8140 }
     let (:subject) { Puppet::Network::HTTP::Connection.new(host, port, :use_ssl => false, :verify => Puppet::SSL::Validator.no_validator) }
-    let (:httpok) { Net::HTTPOK.new('1.1', 200, '') }
 
     before :each do
       httpok.stubs(:body).returns ""
@@ -101,7 +101,6 @@ describe Puppet::Network::HTTP::Connection do
 
     let (:host) { "my_server" }
     let (:port) { 8140 }
-    let (:httpok) { Net::HTTPOK.new('1.1', 200, '') }
 
     it "should provide a useful error message when one is available and certificate validation fails", :unless => Puppet.features.microsoft_windows? do
       connection = Puppet::Network::HTTP::Connection.new(
@@ -151,7 +150,7 @@ describe Puppet::Network::HTTP::Connection do
         host, port,
         :verify => NoProblemsValidator.new(cert))
 
-      Net::HTTP.any_instance.stubs(:get).returns(httpok)
+      Net::HTTP.any_instance.stubs(:request).returns(httpok)
 
       connection.expects(:warn_if_near_expiration).with(cert)
 
@@ -166,7 +165,7 @@ describe Puppet::Network::HTTP::Connection do
       end
 
       def setup_connection(connection)
-        connection.stubs(:get).with do
+        connection.stubs(:request).with do
           true
         end.raises(OpenSSL::SSL::SSLError.new(@fails_with))
       end
@@ -204,7 +203,6 @@ describe Puppet::Network::HTTP::Connection do
     let (:other_path) { "other-path" }
     let (:subject) { Puppet::Network::HTTP::Connection.new("my_server", 8140, :use_ssl => false, :verify => Puppet::SSL::Validator.no_validator) }
     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}"
@@ -234,4 +232,40 @@ describe Puppet::Network::HTTP::Connection do
       }.to raise_error(Puppet::Network::HTTP::RedirectionLimitExceededException)
     end
   end
+
+  it "allows setting basic auth on get requests" do
+    expect_request_with_basic_auth
+
+    subject.get('/path', nil, :basic_auth => { :user => 'user', :password => 'password' })
+  end
+
+  it "allows setting basic auth on post requests" do
+    expect_request_with_basic_auth
+
+    subject.post('/path', 'data', nil, :basic_auth => { :user => 'user', :password => 'password' })
+  end
+
+  it "allows setting basic auth on head requests" do
+    expect_request_with_basic_auth
+
+    subject.head('/path', nil, :basic_auth => { :user => 'user', :password => 'password' })
+  end
+
+  it "allows setting basic auth on delete requests" do
+    expect_request_with_basic_auth
+
+    subject.delete('/path', nil, :basic_auth => { :user => 'user', :password => 'password' })
+  end
+
+  it "allows setting basic auth on put requests" do
+    expect_request_with_basic_auth
+
+    subject.put('/path', 'data', nil, :basic_auth => { :user => 'user', :password => 'password' })
+  end
+
+  def expect_request_with_basic_auth
+    Net::HTTP.any_instance.expects(:request).with do |request|
+      expect(request['authorization']).to match(/^Basic/)
+    end.returns(httpok)
+  end
 end

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

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'matchers/json'
+
+require 'puppet/network/http'
+
+describe Puppet::Network::HTTP::Error do
+  include JSONMatchers
+
+  describe Puppet::Network::HTTP::Error::HTTPError do
+    it "should serialize to JSON that matches the error schema" do
+      error = Puppet::Network::HTTP::Error::HTTPError.new("I don't like the looks of you", 400, :SHIFTY_USER)
+
+      expect(error.to_json).to validate_against('api/schemas/error.json')
+    end
+  end
+
+  describe Puppet::Network::HTTP::Error::HTTPServerError do
+    it "should serialize to JSON that matches the error schema and has the optional stacktrace property" do
+      begin
+        raise Exception, "a wild Exception appeared!"
+      rescue Exception => e
+        culpable = e
+      end
+      error = Puppet::Network::HTTP::Error::HTTPServerError.new(culpable)
+
+      expect(error.to_json).to validate_against('api/schemas/error.json')
+    end
+  end
+
+end

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

@@ -1,68 +1,25 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
-require 'puppet/network/http'
-require 'puppet/network/http/handler'
+require 'puppet/indirector_testing'
+
 require 'puppet/network/authorization'
 require 'puppet/network/authentication'
-require 'puppet/indirector/memory'
+
+require 'puppet/network/http'
 
 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_raw(raw)
-        new(nil, raw)
-      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
-
-    class Puppet::TestModel::Memory < Puppet::Indirector::Memory
-      def supports_remote_requests?
-        true
-      end
-    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)
+    Puppet::IndirectorTesting.indirection.terminus_class = :memory
   end
 
-  let(:terminus_class) { Puppet::TestModel::Memory }
-  let(:terminus) { Puppet::TestModel.indirection.terminus(:memory) }
-  let(:indirection) { Puppet::TestModel.indirection }
-  let(:model) { Puppet::TestModel }
+  let(:indirection) { Puppet::IndirectorTesting.indirection }
 
-  def a_request
+  def a_request(method = "HEAD", path = "/production/#{indirection.name}/unknown")
     {
       :accept_header => "pson",
       :content_type_header => "text/yaml",
-      :http_method => "HEAD",
-      :path => "/production/#{indirection.name}/unknown",
+      :http_method => method,
+      :path => path,
       :params => {},
       :client_cert => nil,
       :headers => {},
@@ -70,85 +27,70 @@ describe Puppet::Network::HTTP::Handler do
     }
   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
+  let(:handler) { TestingHandler.new() }
 
-  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
+  describe "the HTTP Handler" do
+    def respond(text)
+      lambda { |req, res| res.respond_with(200, "text/plain", text) }
+    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
+    it "hands the request to the first route that matches the request path" do
+      handler = TestingHandler.new(
+        Puppet::Network::HTTP::Route.path(%r{^/foo}).get(respond("skipped")),
+        Puppet::Network::HTTP::Route.path(%r{^/vtest}).get(respond("used")),
+        Puppet::Network::HTTP::Route.path(%r{^/vtest/foo}).get(respond("ignored")))
 
-  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
+      req = a_request("GET", "/vtest/foo")
+      res = {}
 
-  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
+      handler.process(req, res)
+
+      expect(res[:body]).to eq("used")
+    end
 
-  let(:handler) { TestingHandler.new }
+    it "raises an error if multiple routes with the same path regex are registered" do
+      expect do
+        handler = TestingHandler.new(
+          Puppet::Network::HTTP::Route.path(%r{^/foo}).get(respond("ignored")),
+          Puppet::Network::HTTP::Route.path(%r{^/foo}).post(respond("also ignored")))
+      end.to raise_error(ArgumentError)
+    end
 
-  it "should include the v1 REST API" do
-    Puppet::Network::HTTP::Handler.ancestors.should be_include(Puppet::Network::HTTP::API::V1)
-  end
+    it "raises an HTTP not found error if no routes match" do
+      handler = TestingHandler.new
 
-  it "should include the Rest Authorization system" do
-    Puppet::Network::HTTP::Handler.ancestors.should be_include(Puppet::Network::Authorization)
-  end
+      req = a_request("GET", "/vtest/foo")
+      res = {}
+
+      handler.process(req, res)
 
-  describe "when initializing" do
-    it "should fail when no server type has been provided" do
-      lambda { handler.initialize_for_puppet }.should raise_error(ArgumentError)
+      res_body = JSON(res[:body])
+
+      expect(res[:content_type_header]).to eq("application/json")
+      expect(res_body["issue_kind"]).to eq("HANDLER_NOT_FOUND")
+      expect(res_body["message"]).to eq("Not Found: No route for GET /vtest/foo")
+      expect(res[:status]).to eq(404)
     end
 
-    it "should set server type" do
-      handler.initialize_for_puppet("foo")
-      handler.server.should == "foo"
+    it "returns a structured error response with a stacktrace when the server encounters an internal error" do
+      handler = TestingHandler.new(
+        Puppet::Network::HTTP::Route.path(/.*/).get(lambda { |_, _| raise Exception.new("the sky is falling!")}))
+
+      req = a_request("GET", "/vtest/foo")
+      res = {}
+
+      handler.process(req, res)
+
+      res_body = JSON(res[:body])
+
+      expect(res[:content_type_header]).to eq("application/json")
+      expect(res_body["issue_kind"]).to eq(Puppet::Network::HTTP::Issues::RUNTIME_ERROR.to_s)
+      expect(res_body["message"]).to eq("Server Error: the sky is falling!")
+      expect(res_body["stacktrace"].is_a?(Array) && !res_body["stacktrace"].empty?).to be_true
+      expect(res_body["stacktrace"][0]).to match("spec/unit/network/http/handler_spec.rb")
+      expect(res[:status]).to eq(500)
     end
+
   end
 
   describe "when processing a request" do
@@ -188,91 +130,15 @@ describe Puppet::Network::HTTP::Handler do
       Puppet::Util::Profiler.current.should == Puppet::Util::Profiler::NONE
     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" }
-
-      handler.expects(:uri2indirection).with("mymethod", "mypath", { :params => "mine" }).returns stub("request", :method => :find)
-
-      handler.stubs(:do_find)
-
-      handler.process(request, response)
-    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
-
-      handler.expects(:check_authorization).with("facts", :mymethod, "key", {:node => "name"}).raises(Puppet::Network::AuthorizationError.new("forbidden"))
-
-      handler.expects(:set_response).with(anything, anything, 403)
-
-      handler.process(request, response)
-    end
-
-    it "should return an error code if the indirection does not support remote requests" do
-      request = a_request
-
-      indirection.expects(:allow_remote_requests?).returns(false)
-
-      handler.process(request, response)
-
-      expect(response[:status]).to eq 404
-    end
-
-    it "should serialize a controller exception when an exception is thrown while finding the model instance" do
-      request = a_request_that_finds(Puppet::TestModel.new("key"))
-
-      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, Exception.new("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, Exception.new("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 "logs an HTTP response exception at info level (most are harmless)" do
-      data = Puppet::TestModel.new("not_found", "not found")
-      error = Puppet::Network::HTTP::Handler::HTTPNotFoundError.new("Could not find test_model not_found")
-
-      request = a_request_that_finds(data, :accept_header => "pson")
-      Puppet.expects(:info).with(error.message)
-
-      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"
+      request = Puppet::Network::HTTP::Request.new({ 'content-type' => "text/plain; charset=UTF-8" },
+                                                   {}, 'GET', '/', nil)
+      request.format.should == "s"
     end
 
     it "should deserialize YAML parameters" do
@@ -290,221 +156,9 @@ describe Puppet::Network::HTTP::Handler do
 
       decoded_params[:my_param].should be_a(Hash)
     end
-
-    describe "when finding a model instance" do
-      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")
-
-        handler.expects(:set_response).with(response, data.render(:pson))
-        handler.expects(:set_content_type).with(response, Puppet::Network::FormatHandler.format(:pson))
-
-        handler.do_find(indirection, "my data", {}, request, response)
-      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)
-
-        expect do
-          handler.do_find(indirection, "my data", {}, request, response)
-        end.to raise_error(Puppet::Network::HTTP::Handler::HTTPNotAcceptableError)
-      end
-
-      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")
-
-        expect do
-          handler.do_find(indirection, "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
-        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)
-
-        handler.expects(:set_response).with(response, data_string)
-        handler.expects(:set_content_type).with(response, Puppet::Network::FormatHandler.format(:pson))
-
-        handler.do_find(indirection, "my data", {}, request, response)
-      end
-
-      it "should return a 404 when no model instance can be found" do
-        data = Puppet::TestModel.new("my data", "some data")
-        request = a_request_that_finds(data, :accept_header => "unknown, pson, yaml")
-
-        expect do
-          handler.do_find(indirection, "my data", {}, request, response)
-        end.to raise_error(Puppet::Network::HTTP::Handler::HTTPNotFoundError)
-      end
-    end
-
-    describe "when performing head operation" do
-      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
-        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
-      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")
-
-        handler.expects(:set_response).with(response, Puppet::TestModel.render_multiple(:pson, [data]))
-        handler.expects(:set_content_type).with(response, Puppet::Network::FormatHandler.format(:pson))
-
-        handler.do_search(indirection, "my", {}, request, response)
-      end
-
-      it "should return [] when searching returns an empty array" do
-        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.do_search(indirection, "nothing", {}, request, response)
-      end
-
-      it "should return a 404 when searching returns nil" do
-        request = a_request_that_searches("nothing", :accept_header => "unknown, pson, yaml")
-        indirection.expects(:search).returns(nil)
-
-        expect do
-          handler.do_search(indirection, "nothing", {}, request, response)
-        end.to raise_error(Puppet::Network::HTTP::Handler::HTTPNotFoundError)
-      end
-    end
-
-    describe "when destroying a model instance" do
-      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)
-
-        handler.do_destroy(indirection, "my data", {}, request, response)
-
-        Puppet::TestModel.indirection.find("my data").should be_nil
-      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))
-
-        handler.do_destroy(indirection, "my data", {}, request, response)
-      end
-
-      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, "my data", {}, request, response)
-      end
-
-      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")
-
-        expect do
-          handler.do_destroy(indirection, "my data", {}, request, response)
-        end.to raise_error(Puppet::Network::HTTP::Handler::HTTPNotAcceptableError)
-
-        Puppet::TestModel.indirection.find("my data").should_not be_nil
-      end
-    end
-
-    describe "when saving a model instance" do
-      it "allows an empty body when the format supports it" do
-        class Puppet::TestModel::Nonvalidatingmemory < Puppet::TestModel::Memory
-          def validate_key(_)
-            # nothing
-          end
-        end
-
-        indirection.terminus_class = :nonvalidatingmemory
-
-        data = Puppet::TestModel.new("test", '')
-        request = a_request_that_submits(data)
-        request[:content_type_header] = "application/x-raw"
-        request[:body] = ''
-
-        handler.do_save(indirection, "test", {}, request, response)
-
-        Puppet::TestModel.indirection.find("test").data.should == ''
-      end
-
-      it "saves the data sent in the request" do
-        data = Puppet::TestModel.new("my data", "some data")
-        request = a_request_that_submits(data)
-
-        handler.do_save(indirection, "my data", {}, request, response)
-
-        Puppet::TestModel.indirection.find("my data").should == data
-      end
-
-      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)
-
-        handler.expects(:set_response).with(response, data.render(:yaml))
-        handler.expects(:set_content_type).with(response, Puppet::Network::FormatHandler.format(:yaml))
-
-        handler.do_save(indirection, "my data", {}, 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")
-
-        handler.expects(:set_response).with(response, data.render(:pson))
-        handler.expects(:set_content_type).with(response, Puppet::Network::FormatHandler.format(:pson))
-
-        handler.do_save(indirection, "my data", {}, request, response)
-      end
-
-      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")
-
-        expect do
-          handler.do_save(indirection, "my data", {}, request, response)
-        end.to raise_error(Puppet::Network::HTTP::Handler::HTTPNotAcceptableError)
-
-        Puppet::TestModel.indirection.find("my data").should be_nil
-      end
-    end
   end
 
+
   describe "when resolving node" do
     it "should use a look-up from the ip address" do
       Resolv.expects(:getname).with("1.2.3.4").returns("host.domain.com")
@@ -528,16 +182,12 @@ describe Puppet::Network::HTTP::Handler do
   class TestingHandler
     include Puppet::Network::HTTP::Handler
 
-    def accept_header(request)
-      request[:accept_header]
-    end
-
-    def content_type_header(request)
-      request[:content_type_header]
+    def initialize(* routes)
+      register(routes)
     end
 
     def set_content_type(response, format)
-      "my_result"
+     response[:content_type_header] = format
     end
 
     def set_response(response, body, status = 200)