puppet 3.4.3 → 3.5.0.rc1

data/spec/unit/network/authorization_spec.rb

@@ -10,11 +10,21 @@ describe Puppet::Network::Authorization do
   subject { AuthTest.new }
 
   describe "when creating an authconfig object" do
-    it "creates default ACL entries if no file has been read" do
+    before :each do
       # Other tests may have created an authconfig, so we have to undo that.
+      @orig_auth_config = Puppet::Network::AuthConfigLoader.instance_variable_get(:@auth_config)
+      @orig_auth_config_file = Puppet::Network::AuthConfigLoader.instance_variable_get(:@auth_config_file)
+
       Puppet::Network::AuthConfigLoader.instance_variable_set(:@auth_config, nil)
       Puppet::Network::AuthConfigLoader.instance_variable_set(:@auth_config_file, nil)
+    end
 
+    after :each do
+      Puppet::Network::AuthConfigLoader.instance_variable_set(:@auth_config, @orig_auth_config)
+      Puppet::Network::AuthConfigLoader.instance_variable_set(:@auth_config_file, @orig_auth_config_file)
+    end
+
+    it "creates default ACL entries if no file has been read" do
       Puppet::Network::AuthConfigParser.expects(:new_from_file).raises Errno::ENOENT
       Puppet::Network::AuthConfig.any_instance.expects(:insert_default_acl)
 

data/spec/unit/network/formats_spec.rb

@@ -9,7 +9,7 @@ class PsonTest
     string == other.string
   end
 
-  def self.from_pson(data)
+  def self.from_data_hash(data)
     new(data)
   end
 
@@ -43,11 +43,34 @@ describe "Puppet Network Format" do
       @msgpack.weight.should == 20
     end
 
-    it "should fail when one element does not have a from_pson" do
+    it "should fail when one element does not have a from_data_hash" do
       expect do
         @msgpack.intern_multiple(Hash, MessagePack.pack(["foo"]))
       end.to raise_error(NoMethodError)
     end
+
+    it "should be able to serialize a catalog" do
+      cat = Puppet::Resource::Catalog.new('foo')
+      cat.add_resource(Puppet::Resource.new(:file, 'my_file'))
+      catunpack = MessagePack.unpack(cat.to_msgpack)
+      catunpack.should include(
+        "tags"=>[],
+        "name"=>"foo",
+        "version"=>nil,
+        "environment"=>"",
+        "edges"=>[],
+        "classes"=>[]
+      )
+      catunpack["resources"][0].should include(
+        "type"=>"File",
+        "title"=>"my_file",
+        "exported"=>false
+      )
+      catunpack["resources"][0]["tags"].should include(
+        "file",
+        "my_file"
+      )
+    end
   end
 
   it "should include a yaml format" do
@@ -293,10 +316,10 @@ describe "Puppet Network Format" do
         @pson.render_multiple(instances).should == "foo"
       end
 
-      it "should intern by calling 'PSON.parse' on the text and then using from_pson to convert the data into an instance" do
+      it "should intern by calling 'PSON.parse' on the text and then using from_data_hash to convert the data into an instance" do
         text = "foo"
         PSON.expects(:parse).with("foo").returns("type" => "PsonTest", "data" => "foo")
-        PsonTest.expects(:from_pson).with("foo").returns "parsed_pson"
+        PsonTest.expects(:from_data_hash).with("foo").returns "parsed_pson"
         @pson.intern(PsonTest, text).should == "parsed_pson"
       end
 
@@ -304,22 +327,22 @@ describe "Puppet Network Format" do
         text = "foo"
         instance = PsonTest.new("foo")
         PSON.expects(:parse).with("foo").returns(instance)
-        PsonTest.expects(:from_pson).never
+        PsonTest.expects(:from_data_hash).never
         @pson.intern(PsonTest, text).should equal(instance)
       end
 
-      it "should intern by calling 'PSON.parse' on the text and then using from_pson to convert the actual into an instance if the pson has no class/data separation" do
+      it "should intern by calling 'PSON.parse' on the text and then using from_data_hash to convert the actual into an instance if the pson has no class/data separation" do
         text = "foo"
         PSON.expects(:parse).with("foo").returns("foo")
-        PsonTest.expects(:from_pson).with("foo").returns "parsed_pson"
+        PsonTest.expects(:from_data_hash).with("foo").returns "parsed_pson"
         @pson.intern(PsonTest, text).should == "parsed_pson"
       end
 
       it "should intern multiples by parsing the text and using 'class.intern' on each resulting data structure" do
         text = "foo"
         PSON.expects(:parse).with("foo").returns ["bar", "baz"]
-        PsonTest.expects(:from_pson).with("bar").returns "BAR"
-        PsonTest.expects(:from_pson).with("baz").returns "BAZ"
+        PsonTest.expects(:from_data_hash).with("bar").returns "BAR"
+        PsonTest.expects(:from_data_hash).with("baz").returns "BAZ"
         @pson.intern_multiple(PsonTest, text).should == %w{BAR BAZ}
       end
 

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

@@ -1,216 +1,519 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
+require 'puppet/network/http'
 require 'puppet/network/http/api/v1'
-
-class V1RestApiTester
-  include Puppet::Network::HTTP::API::V1
-end
+require 'puppet/indirector_testing'
 
 describe Puppet::Network::HTTP::API::V1 do
-  before do
-    @tester = V1RestApiTester.new
+  let(:not_found_code) { Puppet::Network::HTTP::Error::HTTPNotFoundError::CODE }
+  let(:not_acceptable_code) { Puppet::Network::HTTP::Error::HTTPNotAcceptableError::CODE }
+  let(:not_authorized_code) { Puppet::Network::HTTP::Error::HTTPNotAuthorizedError::CODE }
+
+  let(:indirection) { Puppet::IndirectorTesting.indirection }
+  let(:handler) { Puppet::Network::HTTP::API::V1.new }
+  let(:response) { Puppet::Network::HTTP::MemoryResponse.new }
+
+  def a_request_that_heads(data, request = {})
+    Puppet::Network::HTTP::Request.from_hash({
+      :headers => {
+        'accept' => request[:accept_header],
+        'content-type' => "text/yaml", },
+      :method => "HEAD",
+      :path => "/production/#{indirection.name}/#{data.value}",
+      :params => {},
+    })
+  end
+
+  def a_request_that_submits(data, request = {})
+    Puppet::Network::HTTP::Request.from_hash({
+      :headers => {
+        'accept' => request[:accept_header],
+        'content-type' => request[:content_type_header] || "text/yaml", },
+      :method => "PUT",
+      :path => "/production/#{indirection.name}/#{data.value}",
+      :params => {},
+      :body => request[:body] || data.render("text/yaml")
+    })
+  end
+
+  def a_request_that_destroys(data, request = {})
+    Puppet::Network::HTTP::Request.from_hash({
+      :headers => {
+        'accept' => request[:accept_header],
+        'content-type' => "text/yaml", },
+      :method => "DELETE",
+      :path => "/production/#{indirection.name}/#{data.value}",
+      :params => {},
+      :body => ''
+    })
   end
 
-  it "should be able to convert a URI into a request" do
-    @tester.should respond_to(:uri2indirection)
+  def a_request_that_finds(data, request = {})
+    Puppet::Network::HTTP::Request.from_hash({
+      :headers => {
+        'accept' => request[:accept_header],
+        'content-type' => "text/yaml", },
+      :method => "GET",
+      :path => "/production/#{indirection.name}/#{data.value}",
+      :params => {},
+      :body => ''
+    })
   end
 
-  it "should be able to convert a request into a URI" do
-    @tester.should respond_to(:indirection2uri)
+  def a_request_that_searches(key, request = {})
+    Puppet::Network::HTTP::Request.from_hash({
+      :headers => {
+        'accept' => request[:accept_header],
+        'content-type' => "text/yaml", },
+      :method => "GET",
+      :path => "/production/#{indirection.name}s/#{key}",
+      :params => {},
+      :body => ''
+    })
+  end
+
+
+  before do
+    Puppet::IndirectorTesting.indirection.terminus_class = :memory
+    Puppet::IndirectorTesting.indirection.terminus.clear
+    handler.stubs(:check_authorization)
+    handler.stubs(:warn_if_near_expiration)
   end
 
   describe "when converting a URI into a request" do
     before do
-      @tester.stubs(:handler).returns "foo"
+      handler.stubs(:handler).returns "foo"
     end
 
     it "should require the http method, the URI, and the query parameters" do
       # Not a terribly useful test, but an important statement for the spec
-      lambda { @tester.uri2indirection("/foo") }.should raise_error(ArgumentError)
+      lambda { handler.uri2indirection("/foo") }.should raise_error(ArgumentError)
     end
 
     it "should use the first field of the URI as the environment" do
-      @tester.uri2indirection("GET", "/env/foo/bar", {})[3][:environment].to_s.should == "env"
+      handler.uri2indirection("GET", "/env/foo/bar", {})[3][:environment].to_s.should == "env"
     end
 
     it "should fail if the environment is not alphanumeric" do
-      lambda { @tester.uri2indirection("GET", "/env ness/foo/bar", {}) }.should raise_error(ArgumentError)
+      lambda { handler.uri2indirection("GET", "/env ness/foo/bar", {}) }.should raise_error(ArgumentError)
     end
 
     it "should use the environment from the URI even if one is specified in the parameters" do
-      @tester.uri2indirection("GET", "/env/foo/bar", {:environment => "otherenv"})[3][:environment].to_s.should == "env"
+      handler.uri2indirection("GET", "/env/foo/bar", {:environment => "otherenv"})[3][:environment].to_s.should == "env"
     end
 
     it "should not pass a buck_path parameter through (See Bugs #13553, #13518, #13511)" do
-      @tester.uri2indirection("GET", "/env/foo/bar", { :bucket_path => "/malicious/path" })[3].should_not include({ :bucket_path => "/malicious/path" })
+      handler.uri2indirection("GET", "/env/foo/bar", { :bucket_path => "/malicious/path" })[3].should_not include({ :bucket_path => "/malicious/path" })
     end
 
     it "should pass allowed parameters through" do
-      @tester.uri2indirection("GET", "/env/foo/bar", { :allowed_param => "value" })[3].should include({ :allowed_param => "value" })
+      handler.uri2indirection("GET", "/env/foo/bar", { :allowed_param => "value" })[3].should include({ :allowed_param => "value" })
     end
 
     it "should return the environment as a Puppet::Node::Environment" do
-      @tester.uri2indirection("GET", "/env/foo/bar", {})[3][:environment].should be_a Puppet::Node::Environment
+      handler.uri2indirection("GET", "/env/foo/bar", {})[3][:environment].should be_a Puppet::Node::Environment
     end
 
     it "should not pass a buck_path parameter through (See Bugs #13553, #13518, #13511)" do
-      @tester.uri2indirection("GET", "/env/foo/bar", { :bucket_path => "/malicious/path" })[3].should_not include({ :bucket_path => "/malicious/path" })
+      handler.uri2indirection("GET", "/env/foo/bar", { :bucket_path => "/malicious/path" })[3].should_not include({ :bucket_path => "/malicious/path" })
     end
 
     it "should pass allowed parameters through" do
-      @tester.uri2indirection("GET", "/env/foo/bar", { :allowed_param => "value" })[3].should include({ :allowed_param => "value" })
+      handler.uri2indirection("GET", "/env/foo/bar", { :allowed_param => "value" })[3].should include({ :allowed_param => "value" })
     end
 
     it "should use the second field of the URI as the indirection name" do
-      @tester.uri2indirection("GET", "/env/foo/bar", {})[0].should == "foo"
+      handler.uri2indirection("GET", "/env/foo/bar", {})[0].should == "foo"
     end
 
     it "should fail if the indirection name is not alphanumeric" do
-      lambda { @tester.uri2indirection("GET", "/env/foo ness/bar", {}) }.should raise_error(ArgumentError)
+      lambda { handler.uri2indirection("GET", "/env/foo ness/bar", {}) }.should raise_error(ArgumentError)
     end
 
     it "should use the remainder of the URI as the indirection key" do
-      @tester.uri2indirection("GET", "/env/foo/bar", {})[2].should == "bar"
+      handler.uri2indirection("GET", "/env/foo/bar", {})[2].should == "bar"
     end
 
     it "should support the indirection key being a /-separated file path" do
-      @tester.uri2indirection("GET", "/env/foo/bee/baz/bomb", {})[2].should == "bee/baz/bomb"
+      handler.uri2indirection("GET", "/env/foo/bee/baz/bomb", {})[2].should == "bee/baz/bomb"
     end
 
     it "should fail if no indirection key is specified" do
-      lambda { @tester.uri2indirection("GET", "/env/foo/", {}) }.should raise_error(ArgumentError)
-      lambda { @tester.uri2indirection("GET", "/env/foo", {}) }.should raise_error(ArgumentError)
+      lambda { handler.uri2indirection("GET", "/env/foo/", {}) }.should raise_error(ArgumentError)
+      lambda { handler.uri2indirection("GET", "/env/foo", {}) }.should raise_error(ArgumentError)
     end
 
     it "should choose 'find' as the indirection method if the http method is a GET and the indirection name is singular" do
-      @tester.uri2indirection("GET", "/env/foo/bar", {})[1].should == :find
+      handler.uri2indirection("GET", "/env/foo/bar", {})[1].should == :find
     end
 
     it "should choose 'find' as the indirection method if the http method is a POST and the indirection name is singular" do
-      @tester.uri2indirection("POST", "/env/foo/bar", {})[1].should == :find
+      handler.uri2indirection("POST", "/env/foo/bar", {})[1].should == :find
     end
 
     it "should choose 'head' as the indirection method if the http method is a HEAD and the indirection name is singular" do
-      @tester.uri2indirection("HEAD", "/env/foo/bar", {})[1].should == :head
+      handler.uri2indirection("HEAD", "/env/foo/bar", {})[1].should == :head
     end
 
     it "should choose 'search' as the indirection method if the http method is a GET and the indirection name is plural" do
-      @tester.uri2indirection("GET", "/env/foos/bar", {})[1].should == :search
+      handler.uri2indirection("GET", "/env/foos/bar", {})[1].should == :search
     end
 
     it "should choose 'find' as the indirection method if the http method is a GET and the indirection name is facts" do
-      @tester.uri2indirection("GET", "/env/facts/bar", {})[1].should == :find
+      handler.uri2indirection("GET", "/env/facts/bar", {})[1].should == :find
     end
 
     it "should choose 'save' as the indirection method if the http method is a PUT and the indirection name is facts" do
-      @tester.uri2indirection("PUT", "/env/facts/bar", {})[1].should == :save
+      handler.uri2indirection("PUT", "/env/facts/bar", {})[1].should == :save
     end
 
     it "should choose 'search' as the indirection method if the http method is a GET and the indirection name is inventory" do
-      @tester.uri2indirection("GET", "/env/inventory/search", {})[1].should == :search
+      handler.uri2indirection("GET", "/env/inventory/search", {})[1].should == :search
     end
 
     it "should choose 'find' as the indirection method if the http method is a GET and the indirection name is facts" do
-      @tester.uri2indirection("GET", "/env/facts/bar", {})[1].should == :find
+      handler.uri2indirection("GET", "/env/facts/bar", {})[1].should == :find
     end
 
     it "should choose 'save' as the indirection method if the http method is a PUT and the indirection name is facts" do
-      @tester.uri2indirection("PUT", "/env/facts/bar", {})[1].should == :save
+      handler.uri2indirection("PUT", "/env/facts/bar", {})[1].should == :save
     end
 
     it "should choose 'search' as the indirection method if the http method is a GET and the indirection name is inventory" do
-      @tester.uri2indirection("GET", "/env/inventory/search", {})[1].should == :search
+      handler.uri2indirection("GET", "/env/inventory/search", {})[1].should == :search
     end
 
     it "should choose 'search' as the indirection method if the http method is a GET and the indirection name is facts_search" do
-      @tester.uri2indirection("GET", "/env/facts_search/bar", {})[1].should == :search
+      handler.uri2indirection("GET", "/env/facts_search/bar", {})[1].should == :search
     end
 
     it "should change indirection name to 'facts' if the http method is a GET and the indirection name is facts_search" do
-      @tester.uri2indirection("GET", "/env/facts_search/bar", {})[0].should == 'facts'
+      handler.uri2indirection("GET", "/env/facts_search/bar", {})[0].should == 'facts'
     end
 
     it "should not change indirection name from 'facts' if the http method is a GET and the indirection name is facts" do
-      @tester.uri2indirection("GET", "/env/facts/bar", {})[0].should == 'facts'
+      handler.uri2indirection("GET", "/env/facts/bar", {})[0].should == 'facts'
     end
 
     it "should change indirection name to 'status' if the http method is a GET and the indirection name is statuses" do
-      @tester.uri2indirection("GET", "/env/statuses/bar", {})[0].should == 'status'
+      handler.uri2indirection("GET", "/env/statuses/bar", {})[0].should == 'status'
     end
 
     it "should change indirection name to 'probe' if the http method is a GET and the indirection name is probes" do
-      @tester.uri2indirection("GET", "/env/probes/bar", {})[0].should == 'probe'
+      handler.uri2indirection("GET", "/env/probes/bar", {})[0].should == 'probe'
     end
 
     it "should choose 'delete' as the indirection method if the http method is a DELETE and the indirection name is singular" do
-      @tester.uri2indirection("DELETE", "/env/foo/bar", {})[1].should == :destroy
+      handler.uri2indirection("DELETE", "/env/foo/bar", {})[1].should == :destroy
     end
 
     it "should choose 'save' as the indirection method if the http method is a PUT and the indirection name is singular" do
-      @tester.uri2indirection("PUT", "/env/foo/bar", {})[1].should == :save
+      handler.uri2indirection("PUT", "/env/foo/bar", {})[1].should == :save
     end
 
     it "should fail if an indirection method cannot be picked" do
-      lambda { @tester.uri2indirection("UPDATE", "/env/foo/bar", {}) }.should raise_error(ArgumentError)
+      lambda { handler.uri2indirection("UPDATE", "/env/foo/bar", {}) }.should raise_error(ArgumentError)
     end
 
     it "should URI unescape the indirection key" do
       escaped = URI.escape("foo bar")
-      indirection_name, method, key, params = @tester.uri2indirection("GET", "/env/foo/#{escaped}", {})
+      indirection_name, method, key, params = handler.uri2indirection("GET", "/env/foo/#{escaped}", {})
       key.should == "foo bar"
     end
   end
 
   describe "when converting a request into a URI" do
-    before do
-      @request = Puppet::Indirector::Request.new(:foo, :find, "with spaces", nil, :foo => :bar, :environment => "myenv")
-    end
+    let(:request) { Puppet::Indirector::Request.new(:foo, :find, "with spaces", nil, :foo => :bar, :environment => "myenv") }
 
     it "should use the environment as the first field of the URI" do
-      @tester.indirection2uri(@request).split("/")[1].should == "myenv"
+      handler.class.indirection2uri(request).split("/")[1].should == "myenv"
     end
 
     it "should use the indirection as the second field of the URI" do
-      @tester.indirection2uri(@request).split("/")[2].should == "foo"
+      handler.class.indirection2uri(request).split("/")[2].should == "foo"
     end
 
     it "should pluralize the indirection name if the method is 'search'" do
-      @request.stubs(:method).returns :search
-      @tester.indirection2uri(@request).split("/")[2].should == "foos"
+      request.stubs(:method).returns :search
+      handler.class.indirection2uri(request).split("/")[2].should == "foos"
     end
 
     it "should use the escaped key as the remainder of the URI" do
       escaped = URI.escape("with spaces")
-      @tester.indirection2uri(@request).split("/")[3].sub(/\?.+/, '').should == escaped
+      handler.class.indirection2uri(request).split("/")[3].sub(/\?.+/, '').should == escaped
     end
 
     it "should add the query string to the URI" do
-      @request.expects(:query_string).returns "?query"
-      @tester.indirection2uri(@request).should =~ /\?query$/
+      request.expects(:query_string).returns "?query"
+      handler.class.indirection2uri(request).should =~ /\?query$/
     end
   end
 
   describe "when converting a request into a URI with body" do
-    before :each do
-      @request = Puppet::Indirector::Request.new(:foo, :find, "with spaces", nil, :foo => :bar, :environment => "myenv")
-    end
+    let(:request) { Puppet::Indirector::Request.new(:foo, :find, "with spaces", nil, :foo => :bar, :environment => "myenv") }
 
     it "should use the environment as the first field of the URI" do
-      @tester.request_to_uri_and_body(@request).first.split("/")[1].should == "myenv"
+      handler.class.request_to_uri_and_body(request).first.split("/")[1].should == "myenv"
     end
 
     it "should use the indirection as the second field of the URI" do
-      @tester.request_to_uri_and_body(@request).first.split("/")[2].should == "foo"
+      handler.class.request_to_uri_and_body(request).first.split("/")[2].should == "foo"
     end
 
     it "should use the escaped key as the remainder of the URI" do
       escaped = URI.escape("with spaces")
-      @tester.request_to_uri_and_body(@request).first.split("/")[3].sub(/\?.+/, '').should == escaped
+      handler.class.request_to_uri_and_body(request).first.split("/")[3].sub(/\?.+/, '').should == escaped
     end
 
     it "should return the URI and body separately" do
-      @tester.request_to_uri_and_body(@request).should == ["/myenv/foo/with%20spaces", "foo=bar"]
+      handler.class.request_to_uri_and_body(request).should == ["/myenv/foo/with%20spaces", "foo=bar"]
+    end
+  end
+
+  describe "when processing a request" do
+    it "should return not_authorized_code if the request is not authorized" do
+      request = a_request_that_heads(Puppet::IndirectorTesting.new("my data"))
+
+      handler.expects(:check_authorization).raises(Puppet::Network::AuthorizationError.new("forbidden"))
+
+      handler.call(request, response)
+
+      expect(response.code).to eq(not_authorized_code)
+    end
+
+    it "should return an error code if the indirection does not support remote requests" do
+      request = a_request_that_heads(Puppet::IndirectorTesting.new("my data"))
+
+      indirection.expects(:allow_remote_requests?).returns(false)
+
+      handler.call(request, response)
+
+      expect(response.code).to eq(not_found_code)
+    end
+
+    it "should serialize a controller exception when an exception is thrown while finding the model instance" do
+      request = a_request_that_finds(Puppet::IndirectorTesting.new("key"))
+      handler.expects(:do_find).raises(ArgumentError, "The exception")
+
+      handler.call(request, response)
+
+      expect(response.code).to eq(400)
+      expect(response.body).to eq("The exception")
+      expect(response.type).to eq("text/plain")
+    end
+  end
+
+  describe "when finding a model instance" do
+    it "uses the first supported format for the response" do
+      data = Puppet::IndirectorTesting.new("my data")
+      indirection.save(data, "my data")
+      request = a_request_that_finds(data, :accept_header => "unknown, pson, yaml")
+
+      handler.call(request, response)
+
+      expect(response.body).to eq(data.render(:pson))
+      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
+    end
+
+    it "responds with a not_acceptable_code error when no accept header is provided" do
+      data = Puppet::IndirectorTesting.new("my data")
+      indirection.save(data, "my data")
+      request = a_request_that_finds(data, :accept_header => nil)
+
+      handler.call(request, response)
+
+      expect(response.code).to eq(not_acceptable_code)
+    end
+
+    it "raises an error when no accepted formats are known" do
+      data = Puppet::IndirectorTesting.new("my data")
+      indirection.save(data, "my data")
+      request = a_request_that_finds(data, :accept_header => "unknown, also/unknown")
+
+      handler.call(request, response)
+
+      expect(response.code).to eq(not_acceptable_code)
+    end
+
+    it "should pass the result through without rendering it if the result is a string" do
+      data = Puppet::IndirectorTesting.new("my data")
+      data_string = "my data string"
+      request = a_request_that_finds(data, :accept_header => "pson")
+      indirection.expects(:find).returns(data_string)
+
+      handler.call(request, response)
+
+      expect(response.body).to eq(data_string)
+      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
+    end
+
+    it "should return a not_found_code when no model instance can be found" do
+      data = Puppet::IndirectorTesting.new("my data")
+      request = a_request_that_finds(data, :accept_header => "unknown, pson, yaml")
+
+      handler.call(request, response)
+      expect(response.code).to eq(not_found_code)
+    end
+  end
+
+  describe "when searching for model instances" do
+    it "uses the first supported format for the response" do
+      data = Puppet::IndirectorTesting.new("my data")
+      indirection.save(data, "my data")
+      request = a_request_that_searches("my", :accept_header => "unknown, pson, yaml")
+
+      handler.call(request, response)
+
+      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
+      expect(response.body).to eq(Puppet::IndirectorTesting.render_multiple(:pson, [data]))
+    end
+
+    it "should return [] when searching returns an empty array" do
+      request = a_request_that_searches("nothing", :accept_header => "unknown, pson, yaml")
+
+      handler.call(request, response)
+
+      expect(response.body).to eq("[]")
+      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
+    end
+
+    it "should return a not_found_code when searching returns nil" do
+      request = a_request_that_searches("nothing", :accept_header => "unknown, pson, yaml")
+      indirection.expects(:search).returns(nil)
+
+      handler.call(request, response)
+
+      expect(response.code).to eq(not_found_code)
+    end
+  end
+
+  describe "when destroying a model instance" do
+    it "destroys the data indicated in the request" do
+      data = Puppet::IndirectorTesting.new("my data")
+      indirection.save(data, "my data")
+      request = a_request_that_destroys(data)
+
+      handler.call(request, response)
+
+      Puppet::IndirectorTesting.indirection.find("my data").should be_nil
+    end
+
+    it "responds with yaml when no Accept header is given" do
+      data = Puppet::IndirectorTesting.new("my data")
+      indirection.save(data, "my data")
+      request = a_request_that_destroys(data, :accept_header => nil)
+
+      handler.call(request, response)
+
+      expect(response.body).to eq(data.render(:yaml))
+      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:yaml))
+    end
+
+    it "uses the first supported format for the response" do
+      data = Puppet::IndirectorTesting.new("my data")
+      indirection.save(data, "my data")
+      request = a_request_that_destroys(data, :accept_header => "unknown, pson, yaml")
+
+      handler.call(request, response)
+
+      expect(response.body).to eq(data.render(:pson))
+      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
+    end
+
+    it "raises an error and does not destroy when no accepted formats are known" do
+      data = Puppet::IndirectorTesting.new("my data")
+      indirection.save(data, "my data")
+      request = a_request_that_submits(data, :accept_header => "unknown, also/unknown")
+
+      handler.call(request, response)
+
+      expect(response.code).to eq(not_acceptable_code)
+      Puppet::IndirectorTesting.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::IndirectorTesting::Nonvalidatingmemory < Puppet::IndirectorTesting::Memory
+        def validate_key(_)
+          # nothing
+        end
+      end
+
+      indirection.terminus_class = :nonvalidatingmemory
+
+      data = Puppet::IndirectorTesting.new("test")
+      request = a_request_that_submits(data,
+                                       :content_type_header => "application/x-raw",
+                                       :body => '')
+
+      handler.call(request, response)
+
+      Puppet::IndirectorTesting.indirection.find("test").name.should == ''
+    end
+
+    it "saves the data sent in the request" do
+      data = Puppet::IndirectorTesting.new("my data")
+      request = a_request_that_submits(data)
+
+      handler.call(request, response)
+
+      saved = Puppet::IndirectorTesting.indirection.find("my data")
+      expect(saved.name).to eq(data.name)
+    end
+
+    it "responds with yaml when no Accept header is given" do
+      data = Puppet::IndirectorTesting.new("my data")
+      request = a_request_that_submits(data, :accept_header => nil)
+
+      handler.call(request, response)
+
+      expect(response.body).to eq(data.render(:yaml))
+      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:yaml))
+    end
+
+    it "uses the first supported format for the response" do
+      data = Puppet::IndirectorTesting.new("my data")
+      request = a_request_that_submits(data, :accept_header => "unknown, pson, yaml")
+
+      handler.call(request, response)
+
+      expect(response.body).to eq(data.render(:pson))
+      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
+    end
+
+    it "raises an error and does not save when no accepted formats are known" do
+      data = Puppet::IndirectorTesting.new("my data")
+      request = a_request_that_submits(data, :accept_header => "unknown, also/unknown")
+
+      handler.call(request, response)
+
+      expect(Puppet::IndirectorTesting.indirection.find("my data")).to be_nil
+      expect(response.code).to eq(not_acceptable_code)
+    end
+  end
+
+  describe "when performing head operation" do
+    it "should not generate a response when a model head call succeeds" do
+      data = Puppet::IndirectorTesting.new("my data")
+      indirection.save(data, "my data")
+      request = a_request_that_heads(data)
+
+      handler.call(request, response)
+
+      expect(response.code).to eq(nil)
+    end
+
+    it "should return a not_found_code when the model head call returns false" do
+      data = Puppet::IndirectorTesting.new("my data")
+      request = a_request_that_heads(data)
+
+      handler.call(request, response)
+
+      expect(response.code).to eq(not_found_code)
+      expect(response.type).to eq("text/plain")
+      expect(response.body).to eq("Not Found: Could not find indirector_testing my data")
     end
   end
 end