puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

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

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+require 'puppet/network/http'
+
+describe Puppet::Network::HTTP::API::CA::V1 do
+  let(:response) { Puppet::Network::HTTP::MemoryResponse.new }
+  let(:ca_url_prefix) { "#{Puppet::Network::HTTP::CA_URL_PREFIX}/v1"}
+
+  let(:ca_routes) {
+    Puppet::Network::HTTP::Route.
+      path(Regexp.new("#{Puppet::Network::HTTP::CA_URL_PREFIX}/")).
+      any.
+      chain(Puppet::Network::HTTP::API::CA::V1.routes)
+  }
+
+  it "mounts ca routes" do
+    Puppet::SSL::Certificate.indirection.stubs(:find).returns "foo"
+    request = Puppet::Network::HTTP::Request.
+        from_hash(:path => "#{ca_url_prefix}/certificate/foo",
+                  :params => {:environment => "production"},
+                  :headers => {"accept" => "s"})
+    ca_routes.process(request, response)
+
+    expect(response.code).to eq(200)
+  end
+end

data/spec/unit/network/http/api/{v1_spec.rb → indirected_routes_spec.rb}

@@ -2,78 +2,17 @@
 require 'spec_helper'
 
 require 'puppet/network/http'
-require 'puppet/network/http/api/v1'
+require 'puppet/network/http/api/indirected_routes'
 require 'puppet/indirector_testing'
+require 'puppet_spec/network'
 
-describe Puppet::Network::HTTP::API::V1 do
-  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 }
+describe Puppet::Network::HTTP::API::IndirectedRoutes do
+  include PuppetSpec::Network
 
   let(:indirection) { Puppet::IndirectorTesting.indirection }
-  let(:handler) { Puppet::Network::HTTP::API::V1.new }
+  let(:handler) { Puppet::Network::HTTP::API::IndirectedRoutes.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
-
-  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
-
-  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
@@ -82,192 +21,192 @@ describe Puppet::Network::HTTP::API::V1 do
   end
 
   describe "when converting a URI into a request" do
+    let(:environment) { Puppet::Node::Environment.create(:env, []) }
+    let(:env_loaders) { Puppet::Environments::Static.new(environment) }
+    let(:params) { { :environment => "env" } }
+
     before do
       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 { handler.uri2indirection("/foo") }.should raise_error(ArgumentError)
-    end
-
-    it "should use the first field of the URI as the environment" do
-      handler.uri2indirection("GET", "/env/foo/bar", {})[3][:environment].to_s.should == "env"
+    around do |example|
+      Puppet.override(:environments => env_loaders) do
+        example.run
+      end
     end
 
-    it "should fail if the environment is not alphanumeric" do
-      lambda { handler.uri2indirection("GET", "/env ness/foo/bar", {}) }.should raise_error(ArgumentError)
+    it "should get the environment from a query parameter" do
+      expect(handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", params)[3][:environment].to_s).to eq("env")
     end
 
-    it "should use the environment from the URI even if one is specified in the parameters" do
-      handler.uri2indirection("GET", "/env/foo/bar", {:environment => "otherenv"})[3][:environment].to_s.should == "env"
+    it "should fail if there is no environment specified" do
+      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", {}) }).to raise_error(ArgumentError)
     end
 
-    it "should not pass a buck_path parameter through (See Bugs #13553, #13518, #13511)" do
-      handler.uri2indirection("GET", "/env/foo/bar", { :bucket_path => "/malicious/path" })[3].should_not include({ :bucket_path => "/malicious/path" })
+    it "should fail if the environment is not alphanumeric" do
+      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", {:environment => "env ness"}) }).to raise_error(ArgumentError)
     end
 
-    it "should pass allowed parameters through" do
-      handler.uri2indirection("GET", "/env/foo/bar", { :allowed_param => "value" })[3].should include({ :allowed_param => "value" })
+    it "should fail if the indirection does not match the prefix" do
+      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/certificate/foo", params) }).to raise_error(ArgumentError)
     end
 
-    it "should return the environment as a Puppet::Node::Environment" do
-      handler.uri2indirection("GET", "/env/foo/bar", {})[3][:environment].should be_a Puppet::Node::Environment
+    it "should fail if the indirection does not have the correct version" do
+      expect(lambda { handler.uri2indirection("GET", "#{Puppet::Network::HTTP::CA_URL_PREFIX}/v3/certificate/foo", params) }).to raise_error(ArgumentError)
     end
 
     it "should not pass a buck_path parameter through (See Bugs #13553, #13518, #13511)" do
-      handler.uri2indirection("GET", "/env/foo/bar", { :bucket_path => "/malicious/path" })[3].should_not include({ :bucket_path => "/malicious/path" })
+      expect(handler.uri2indirection("GET", "#{master_url_prefix}/node/bar",
+                              { :environment => "env",
+                                :bucket_path => "/malicious/path" })[3]).not_to include({ :bucket_path => "/malicious/path" })
     end
 
     it "should pass allowed parameters through" do
-      handler.uri2indirection("GET", "/env/foo/bar", { :allowed_param => "value" })[3].should include({ :allowed_param => "value" })
+      expect(handler.uri2indirection("GET", "#{master_url_prefix}/node/bar",
+                              { :environment => "env",
+                                :allowed_param => "value" })[3]).to include({ :allowed_param => "value" })
     end
 
-    it "should use the second field of the URI as the indirection name" do
-      handler.uri2indirection("GET", "/env/foo/bar", {})[0].should == "foo"
+    it "should return the environment as a Puppet::Node::Environment" do
+      expect(handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", params)[3][:environment]).to be_a(Puppet::Node::Environment)
+    end
+
+    it "should use the first field of the URI as the indirection name" do
+      expect(handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", params)[0].name).to eq(:node)
     end
 
     it "should fail if the indirection name is not alphanumeric" do
-      lambda { handler.uri2indirection("GET", "/env/foo ness/bar", {}) }.should raise_error(ArgumentError)
+      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/foo ness/bar", params) }).to raise_error(ArgumentError)
     end
 
     it "should use the remainder of the URI as the indirection key" do
-      handler.uri2indirection("GET", "/env/foo/bar", {})[2].should == "bar"
+      expect(handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", params)[2]).to eq("bar")
     end
 
     it "should support the indirection key being a /-separated file path" do
-      handler.uri2indirection("GET", "/env/foo/bee/baz/bomb", {})[2].should == "bee/baz/bomb"
+      expect(handler.uri2indirection("GET", "#{master_url_prefix}/node/bee/baz/bomb", params)[2]).to eq("bee/baz/bomb")
     end
 
     it "should fail if no indirection key is specified" do
-      lambda { handler.uri2indirection("GET", "/env/foo/", {}) }.should raise_error(ArgumentError)
-      lambda { handler.uri2indirection("GET", "/env/foo", {}) }.should raise_error(ArgumentError)
+      expect(lambda { handler.uri2indirection("GET", "#{master_url_prefix}/node", params) }).to 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
-      handler.uri2indirection("GET", "/env/foo/bar", {})[1].should == :find
+      expect(handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", params)[1]).to eq(:find)
     end
 
     it "should choose 'find' as the indirection method if the http method is a POST and the indirection name is singular" do
-      handler.uri2indirection("POST", "/env/foo/bar", {})[1].should == :find
+      expect(handler.uri2indirection("POST", "#{master_url_prefix}/node/bar", params)[1]).to eq(:find)
     end
 
     it "should choose 'head' as the indirection method if the http method is a HEAD and the indirection name is singular" do
-      handler.uri2indirection("HEAD", "/env/foo/bar", {})[1].should == :head
+      expect(handler.uri2indirection("HEAD", "#{master_url_prefix}/node/bar", params)[1]).to eq(:head)
     end
 
     it "should choose 'search' as the indirection method if the http method is a GET and the indirection name is plural" do
-      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
-      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
-      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
-      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
-      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
-      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
-      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
-      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
-      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
-      handler.uri2indirection("GET", "/env/facts/bar", {})[0].should == 'facts'
+      expect(handler.uri2indirection("GET", "#{master_url_prefix}/nodes/bar", params)[1]).to eq(:search)
     end
 
     it "should change indirection name to 'status' if the http method is a GET and the indirection name is statuses" do
-      handler.uri2indirection("GET", "/env/statuses/bar", {})[0].should == 'status'
+      expect(handler.uri2indirection("GET", "#{master_url_prefix}/statuses/bar", params)[0].name).to eq(:status)
     end
 
-    it "should change indirection name to 'probe' if the http method is a GET and the indirection name is probes" do
-      handler.uri2indirection("GET", "/env/probes/bar", {})[0].should == 'probe'
+    it "should change indirection name to 'node' if the http method is a GET and the indirection name is nodes" do
+      expect(handler.uri2indirection("GET", "#{master_url_prefix}/nodes/bar", params)[0].name).to eq(:node)
     end
 
     it "should choose 'delete' as the indirection method if the http method is a DELETE and the indirection name is singular" do
-      handler.uri2indirection("DELETE", "/env/foo/bar", {})[1].should == :destroy
+      expect(handler.uri2indirection("DELETE", "#{master_url_prefix}/node/bar", params)[1]).to eq(:destroy)
     end
 
     it "should choose 'save' as the indirection method if the http method is a PUT and the indirection name is singular" do
-      handler.uri2indirection("PUT", "/env/foo/bar", {})[1].should == :save
+      expect(handler.uri2indirection("PUT", "#{master_url_prefix}/node/bar", params)[1]).to eq(:save)
     end
 
     it "should fail if an indirection method cannot be picked" do
-      lambda { handler.uri2indirection("UPDATE", "/env/foo/bar", {}) }.should raise_error(ArgumentError)
+      expect(lambda { handler.uri2indirection("UPDATE", "#{master_url_prefix}/node/bar", params) }).to raise_error(ArgumentError)
     end
 
     it "should URI unescape the indirection key" do
       escaped = URI.escape("foo bar")
-      indirection_name, method, key, params = handler.uri2indirection("GET", "/env/foo/#{escaped}", {})
-      key.should == "foo bar"
+      indirection, method, key, final_params = handler.uri2indirection("GET", "#{master_url_prefix}/node/#{escaped}", params)
+      expect(key).to eq("foo bar")
+    end
+
+    it "should pass through a proper environment param in a call to check_authorization" do
+      handler.expects(:check_authorization).with(anything,
+                                                 anything,
+                                                 all_of(
+                                                   has_entry(:environment,
+                                                             is_a(Puppet::Node::Environment)),
+                                                   has_entry(:environment,
+                                                             responds_with(:name,
+                                                                           :env))))
+      handler.uri2indirection("GET", "#{master_url_prefix}/node/bar", params)
+    end
+
+    it "should not pass through an environment to check_authorization and fail if the environment is unknown" do
+      handler.expects(:check_authorization).with(anything,
+                                                 anything,
+                                                 Not(has_entry(:environment)))
+      expect(lambda { handler.uri2indirection("GET",
+                                              "#{master_url_prefix}/node/bar",
+                                              {:environment => 'bogus'}) }).to raise_error(ArgumentError)
     end
   end
 
   describe "when converting a request into a URI" do
-    let(:request) { Puppet::Indirector::Request.new(:foo, :find, "with spaces", nil, :foo => :bar, :environment => "myenv") }
+    let(:environment) { Puppet::Node::Environment.create(:myenv, []) }
+    let(:request) { Puppet::Indirector::Request.new(:foo, :find, "with spaces", nil, :foo => :bar, :environment => environment) }
 
-    it "should use the environment as the first field of the URI" do
-      handler.class.indirection2uri(request).split("/")[1].should == "myenv"
+    before do
+      handler.stubs(:handler).returns "foo"
     end
 
-    it "should use the indirection as the second field of the URI" do
-      handler.class.indirection2uri(request).split("/")[2].should == "foo"
+    it "should include the environment in the query string of the URI" do
+      expect(handler.class.request_to_uri(request)).to eq("#{master_url_prefix}/foo/with%20spaces?environment=myenv&foo=bar")
     end
 
-    it "should pluralize the indirection name if the method is 'search'" do
-      request.stubs(:method).returns :search
-      handler.class.indirection2uri(request).split("/")[2].should == "foos"
+    it "should include the correct url prefix if it is a ca request" do
+      request.stubs(:indirection_name).returns("certificate")
+      expect(handler.class.request_to_uri(request)).to eq("#{ca_url_prefix}/certificate/with%20spaces?environment=myenv&foo=bar")
     end
 
-    it "should use the escaped key as the remainder of the URI" do
-      escaped = URI.escape("with spaces")
-      handler.class.indirection2uri(request).split("/")[3].sub(/\?.+/, '').should == escaped
+    it "should pluralize the indirection name if the method is 'search'" do
+      request.stubs(:method).returns :search
+      expect(handler.class.request_to_uri(request).split("/")[3]).to eq("foos")
     end
 
     it "should add the query string to the URI" do
-      request.expects(:query_string).returns "?query"
-      handler.class.indirection2uri(request).should =~ /\?query$/
+      request.expects(:query_string).returns "query"
+      expect(handler.class.request_to_uri(request)).to match(/\&query$/)
     end
   end
 
   describe "when converting a request into a URI with body" do
-    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
-      handler.class.request_to_uri_and_body(request).first.split("/")[1].should == "myenv"
-    end
+    let(:environment) { Puppet::Node::Environment.create(:myenv, []) }
+    let(:request) { Puppet::Indirector::Request.new(:foo, :find, "with spaces", nil, :foo => :bar, :environment => environment) }
 
-    it "should use the indirection as the second field of the URI" do
-      handler.class.request_to_uri_and_body(request).first.split("/")[2].should == "foo"
+    it "should use the indirection as the first field of the URI" do
+      expect(handler.class.request_to_uri_and_body(request).first.split("/")[3]).to eq("foo")
     end
 
     it "should use the escaped key as the remainder of the URI" do
       escaped = URI.escape("with spaces")
-      handler.class.request_to_uri_and_body(request).first.split("/")[3].sub(/\?.+/, '').should == escaped
+      expect(handler.class.request_to_uri_and_body(request).first.split("/")[4].sub(/\?.+/, '')).to eq(escaped)
+    end
+
+    it "should include the correct url prefix if it is a master request" do
+      expect(handler.class.request_to_uri_and_body(request).first).to eq("#{master_url_prefix}/foo/with%20spaces")
+    end
+
+    it "should include the correct url prefix if it is a ca request" do
+      request.stubs(:indirection_name).returns("certificate")
+      expect(handler.class.request_to_uri_and_body(request).first).to eq("#{ca_url_prefix}/certificate/with%20spaces")
     end
 
     it "should return the URI and body separately" do
-      handler.class.request_to_uri_and_body(request).should == ["/myenv/foo/with%20spaces", "foo=bar"]
+      expect(handler.class.request_to_uri_and_body(request)).to eq(["#{master_url_prefix}/foo/with%20spaces", "environment=myenv&foo=bar"])
     end
   end
 
@@ -292,13 +231,13 @@ describe Puppet::Network::HTTP::API::V1 do
       expect(response.code).to eq(not_found_code)
     end
 
-    it "should return 'not found' if the environment does not exist" do
+    it "should return 'bad request' if the environment does not exist" do
       Puppet.override(:environments => Puppet::Environments::Static.new()) do
         request = a_request_that_heads(Puppet::IndirectorTesting.new("my data"))
 
         handler.call(request, response)
 
-        expect(response.code).to eq(not_found_code)
+        expect(response.code).to eq(bad_request_code)
       end
     end
 
@@ -308,7 +247,7 @@ describe Puppet::Network::HTTP::API::V1 do
 
       handler.call(request, response)
 
-      expect(response.code).to eq(400)
+      expect(response.code).to eq(bad_request_code)
       expect(response.body).to eq("The exception")
       expect(response.type).to eq("text/plain")
     end
@@ -318,7 +257,7 @@ describe Puppet::Network::HTTP::API::V1 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")
+      request = a_request_that_finds(data, :accept_header => "unknown, pson")
 
       handler.call(request, response)
 
@@ -349,7 +288,7 @@ describe Puppet::Network::HTTP::API::V1 do
     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")
+      request = a_request_that_finds(data, :accept_header => "text/pson")
       indirection.expects(:find).returns(data_string)
 
       handler.call(request, response)
@@ -360,7 +299,7 @@ describe Puppet::Network::HTTP::API::V1 do
 
     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")
+      request = a_request_that_finds(data, :accept_header => "unknown, text/pson")
 
       handler.call(request, response)
       expect(response.code).to eq(not_found_code)
@@ -371,7 +310,7 @@ describe Puppet::Network::HTTP::API::V1 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")
+      request = a_request_that_searches(Puppet::IndirectorTesting.new("my"), :accept_header => "unknown, text/pson")
 
       handler.call(request, response)
 
@@ -380,7 +319,7 @@ describe Puppet::Network::HTTP::API::V1 do
     end
 
     it "should return [] when searching returns an empty array" do
-      request = a_request_that_searches("nothing", :accept_header => "unknown, pson, yaml")
+      request = a_request_that_searches(Puppet::IndirectorTesting.new("nothing"), :accept_header => "unknown, text/pson")
 
       handler.call(request, response)
 
@@ -389,7 +328,7 @@ describe Puppet::Network::HTTP::API::V1 do
     end
 
     it "should return a not_found_code when searching returns nil" do
-      request = a_request_that_searches("nothing", :accept_header => "unknown, pson, yaml")
+      request = a_request_that_searches(Puppet::IndirectorTesting.new("nothing"), :accept_header => "unknown, text/pson")
       indirection.expects(:search).returns(nil)
 
       handler.call(request, response)
@@ -406,24 +345,24 @@ describe Puppet::Network::HTTP::API::V1 do
 
       handler.call(request, response)
 
-      Puppet::IndirectorTesting.indirection.find("my data").should be_nil
+      expect(Puppet::IndirectorTesting.indirection.find("my data")).to be_nil
     end
 
-    it "responds with yaml when no Accept header is given" do
+    it "responds with pson 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))
+      expect(response.body).to eq(data.render(:pson))
+      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
     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")
+      request = a_request_that_destroys(data, :accept_header => "unknown, text/pson")
 
       handler.call(request, response)
 
@@ -434,12 +373,12 @@ describe Puppet::Network::HTTP::API::V1 do
     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")
+      request = a_request_that_destroys(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
+      expect(Puppet::IndirectorTesting.indirection.find("my data")).not_to be_nil
     end
   end
 
@@ -455,12 +394,17 @@ describe Puppet::Network::HTTP::API::V1 do
 
       data = Puppet::IndirectorTesting.new("test")
       request = a_request_that_submits(data,
-                                       :content_type_header => "application/x-raw",
+                                       :content_type_header => "application/octet-stream",
                                        :body => '')
 
       handler.call(request, response)
 
-      Puppet::IndirectorTesting.indirection.find("test").name.should == ''
+      # PUP-3272 this test fails when yaml is removed and pson is used. Instead of returning an
+      # empty string, the a string '""' is returned - Don't know what the expecation is, if this is
+      # corrent or not.
+      # (helindbe)
+      #
+      expect(Puppet::IndirectorTesting.indirection.find("test").name).to eq('')
     end
 
     it "saves the data sent in the request" do
@@ -473,19 +417,19 @@ describe Puppet::Network::HTTP::API::V1 do
       expect(saved.name).to eq(data.name)
     end
 
-    it "responds with yaml when no Accept header is given" do
+    it "responds with pson 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))
+      expect(response.body).to eq(data.render(:pson))
+      expect(response.type).to eq(Puppet::Network::FormatHandler.format(:pson))
     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")
+      request = a_request_that_submits(data, :accept_header => "unknown, text/pson")
 
       handler.call(request, response)