puppet 4.10.0 → 5.0.0

data/spec/unit/indirector/catalog/json_spec.rb

@@ -1,12 +1,61 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
+require 'puppet_spec/files'
 require 'puppet/resource/catalog'
 require 'puppet/indirector/catalog/json'
 
 describe Puppet::Resource::Catalog::Json do
-  # This is it for local functionality: we don't *do* anything else.
+  include PuppetSpec::Files
+
+  # This is it for local functionality
   it "should be registered with the catalog store indirection" do
     expect(Puppet::Resource::Catalog.indirection.terminus(:json)).
       to be_an_instance_of described_class
   end
+
+  describe "when handling requests" do
+    let(:binary) { "\xC0\xFF".force_encoding(Encoding::BINARY) }
+    let(:key)    { 'foo' }
+    let(:file)   { subject.path(key) }
+    let(:catalog) do
+      catalog = Puppet::Resource::Catalog.new(key, Puppet::Node::Environment.create(:testing, []))
+      catalog.add_resource(Puppet::Resource.new(:file, '/tmp/a_file', :parameters => { :content => binary }))
+      catalog
+    end
+
+    before :each do
+      Puppet.run_mode.stubs(:master?).returns(true)
+      Puppet[:server_datadir] = tmpdir('jsondir')
+      FileUtils.mkdir_p(File.join(Puppet[:server_datadir], 'indirector_testing'))
+    end
+
+    it 'saves a catalog containing binary content' do
+      request = subject.indirection.request(:save, key, catalog)
+
+      subject.save(request)
+    end
+
+    it 'finds a catalog containing binary content' do
+      request = subject.indirection.request(:save, key, catalog)
+      subject.save(request)
+
+      request = subject.indirection.request(:find, key, nil)
+      parsed_catalog = subject.find(request)
+
+      content = parsed_catalog.resource(:file, '/tmp/a_file')[:content]
+      expect(content.bytes.to_a).to eq(binary.bytes.to_a)
+    end
+
+    it 'searches for catalogs contains binary content' do
+      request = subject.indirection.request(:save, key, catalog)
+      subject.save(request)
+
+      request = subject.indirection.request(:search, '*', nil)
+      parsed_catalogs = subject.search(request)
+
+      expect(parsed_catalogs.size).to eq(1)
+      content = parsed_catalogs.first.resource(:file, '/tmp/a_file')[:content]
+      expect(content.bytes.to_a).to eq(binary.bytes.to_a)
+    end
+  end
 end

data/spec/unit/indirector/facts/facter_spec.rb

@@ -51,9 +51,8 @@ describe Puppet::Node::Facts::Facter do
       @facter.find(@request)
     end
 
-    it 'should include external facts when feature is present' do
+    it 'should include external facts' do
       reset = sequence 'reset'
-      Puppet.features.stubs(:external_facts?).returns true
       Facter.expects(:reset).in_sequence(reset)
       Puppet::Node::Facts::Facter.expects(:setup_external_search_paths).in_sequence(reset)
       Puppet::Node::Facts::Facter.expects(:setup_search_paths).in_sequence(reset)

data/spec/unit/indirector/file_bucket_file/file_spec.rb

@@ -166,7 +166,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
 
             # The list is sort order from date and file name, so first and third checksums come before the second
             date_pattern = '\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}'
-            expect(find_result.to_s).to match(Regexp.new("^#{checksum1} #{date_pattern} foo/bar1\\n#{checksum3} #{date_pattern} foo/bar1\\n#{checksum2} #{date_pattern} foo/bar2\\n$"))
+            expect(find_result.to_s).to match(Regexp.new("^(#{checksum1}|#{checksum3}) #{date_pattern} foo/bar1\\n(#{checksum3}|#{checksum1}) #{date_pattern} foo/bar1\\n#{checksum2} #{date_pattern} foo/bar2\\n$"))
           end
 
           it "should fail in an informative way when provided dates are not in the right format" do

data/spec/unit/indirector/file_server_spec.rb

@@ -249,6 +249,7 @@ describe Puppet::Indirector::FileServer do
       @configuration.stubs(:split_path).with(@request).returns([@mount, "rel/path"])
       @request.stubs(:node).returns("mynode")
       @request.stubs(:ip).returns("myip")
+      @mount.stubs(:name).returns "myname"
       @mount.stubs(:allowed?).with("mynode", "myip").returns "something"
     end
 
@@ -274,8 +275,22 @@ describe Puppet::Indirector::FileServer do
       expect(@file_server).not_to be_authorized(@request)
     end
 
-    it "should return the results of asking the mount whether the node and IP are authorized" do
-      expect(@file_server.authorized?(@request)).to eq("something")
+    it "should return true when no auth directives are defined for the mount point" do
+      @mount.stubs(:empty?).returns true
+      @mount.stubs(:globalallow?).returns nil
+      expect(@file_server).to be_authorized(@request)
+    end
+
+    it "should return true when a global allow directive is defined for the mount point" do
+      @mount.stubs(:empty?).returns false
+      @mount.stubs(:globalallow?).returns true
+      expect(@file_server).to be_authorized(@request)
+    end
+
+    it "should return false when a non-global allow directive is defined for the mount point" do
+      @mount.stubs(:empty?).returns false
+      @mount.stubs(:globalallow?).returns false
+      expect(@file_server).not_to be_authorized(@request)
     end
   end
 end

data/spec/unit/indirector/indirection_spec.rb

@@ -14,42 +14,7 @@ shared_examples_for "Indirection Delegator" do
     @indirection.send(@method, "mystuff", :one => :two)
   end
 
-  it "should let the :select_terminus method choose the terminus using the created request if the :select_terminus method is available" do
-    # Define the method, so our respond_to? hook matches.
-    class << @indirection
-      def select_terminus(request)
-      end
-    end
-
-    request = Puppet::Indirector::Request.new(:indirection, :find, "me", nil)
-
-    @indirection.stubs(:request).returns request
-
-    @indirection.expects(:select_terminus).with(request).returns :test_terminus
-
-    @indirection.stubs(:check_authorization)
-    @terminus.expects(@method)
-
-    @indirection.send(@method, "me")
-  end
-
-  it "should fail if the :select_terminus hook does not return a terminus name" do
-    # Define the method, so our respond_to? hook matches.
-    class << @indirection
-      def select_terminus(request)
-      end
-    end
-
-    request = Puppet::Indirector::Request.new(:indirection, :find, "me", nil)
-
-    @indirection.stubs(:request).returns request
-
-    @indirection.expects(:select_terminus).with(request).returns nil
-
-    expect { @indirection.send(@method, "me") }.to raise_error(ArgumentError)
-  end
-
-  it "should choose the terminus returned by the :terminus_class method if no :select_terminus method is available" do
+  it "should choose the terminus returned by the :terminus_class" do
     @indirection.expects(:terminus_class).returns :test_terminus
 
     @terminus.expects(@method)

data/spec/unit/indirector/json_spec.rb

@@ -60,7 +60,7 @@ describe Puppet::Indirector::JSON do
 
     def with_content(text)
       FileUtils.mkdir_p(File.dirname(file))
-      File.open(file, 'w') {|f| f.puts text }
+      File.binwrite(file, text)
       yield if block_given?
     end
 
@@ -77,11 +77,11 @@ describe Puppet::Indirector::JSON do
       end
 
       it "raises a descriptive error when the file can't be read" do
-        with_content(model.new('foo').to_pson) do
+        with_content(model.new('foo').to_json) do
           # I don't like this, but there isn't a credible alternative that
           # also works on Windows, so a stub it is. At least the expectation
           # will fail if the implementation changes. Sorry to the next dev.
-          Puppet::FileSystem.expects(:read).with(file).raises(Errno::EPERM)
+          Puppet::FileSystem.expects(:read).with(file, anything).raises(Errno::EPERM)
           expect { subject.find(request) }.
             to raise_error Puppet::Error, /Could not read JSON/
         end
@@ -94,8 +94,18 @@ describe Puppet::Indirector::JSON do
         end
       end
 
+      it "raises if the content contains binary" do
+        binary = "\xC0\xFF".force_encoding(Encoding::BINARY)
+
+        with_content(binary) do
+          expect {
+            subject.find(request)
+          }.to raise_error Puppet::Error, /Could not parse JSON data/
+        end
+      end
+
       it "should return an instance of the indirected object when valid" do
-        with_content(model.new(1).to_pson) do
+        with_content(model.new(1).to_json) do
           instance = subject.find(request)
           expect(instance).to be_an_instance_of model
           expect(instance.value).to eq(1)
@@ -160,8 +170,8 @@ describe Puppet::Indirector::JSON do
     end
 
     def create_file(name, value = 12)
-      File.open(subject.path(name, ''), 'w') do |f|
-        f.puts Puppet::IndirectorTesting.new(value).to_pson
+      File.open(subject.path(name, ''), 'wb') do |f|
+        f.puts Puppet::IndirectorTesting.new(value).to_json
       end
     end
 
@@ -188,5 +198,16 @@ describe Puppet::Indirector::JSON do
       create_file('foo.json~', 'foo-backup')
       expect(subject.search(request('f*')).map(&:value)).to eq(['foo-json'])
     end
+
+    it "raises if the content contains binary" do
+      binary = "\xC0\xFF".force_encoding(Encoding::BINARY)
+
+      File.binwrite(subject.path('foo.json', ''), "foo-json")
+      File.binwrite(subject.path("foo#{binary}.bin", ''), "foo-binary")
+
+      expect {
+        subject.search(request('*'))
+      }.to raise_error Puppet::Error, /Could not parse JSON data/
+    end
   end
 end

data/spec/unit/indirector/node/exec_spec.rb

@@ -26,7 +26,7 @@ describe Puppet::Node::Exec do
   describe "when handling the results of the command" do
     let(:testing_env) { Puppet::Node::Environment.create(:testing, []) }
     let(:other_env) { Puppet::Node::Environment.create(:other, []) }
-
+    let(:request) { Puppet::Indirector::Request.new(:node, :find, @name, nil) }
     before do
       @name = "yay"
       @node = Puppet::Node.new(@name)
@@ -38,8 +38,6 @@ describe Puppet::Node::Exec do
       @searcher.meta_def(:execute) do |command, arguments|
         return YAML.dump(result)
       end
-
-      @request = Puppet::Indirector::Request.new(:node, :find, @name, nil)
     end
 
     around do |example|
@@ -52,35 +50,37 @@ describe Puppet::Node::Exec do
 
     it "should translate the YAML into a Node instance" do
       # Use an empty hash
-      expect(@searcher.find(@request)).to equal(@node)
+      expect(@searcher.find(request)).to equal(@node)
     end
 
     it "should set the resulting parameters as the node parameters" do
       @result[:parameters] = {"a" => "b", "c" => "d"}
-      @searcher.find(@request)
+      @searcher.find(request)
       expect(@node.parameters).to eq({"a" => "b", "c" => "d"})
     end
 
     it "should set the resulting classes as the node classes" do
       @result[:classes] = %w{one two}
-      @searcher.find(@request)
+      @searcher.find(request)
       expect(@node.classes).to eq([ 'one', 'two' ])
     end
 
-    it "should merge the node's facts with its parameters" do
-      @node.expects(:fact_merge)
-      @searcher.find(@request)
+    it "should merge facts from the request if supplied" do
+      facts = Puppet::Node::Facts.new('test', 'foo' => 'bar')
+      request.options[:facts] = facts
+      @node.expects(:fact_merge).with(facts)
+      @searcher.find(request)
     end
 
     it "should set the node's environment if one is provided" do
       @result[:environment] = "testing"
-      @searcher.find(@request)
+      @searcher.find(request)
       expect(@node.environment.name).to eq(:testing)
     end
 
     it "should set the node's environment based on the request if not otherwise provided" do
-      @request.environment = "other"
-      @searcher.find(@request)
+      request.environment = "other"
+      @searcher.find(request)
       expect(@node.environment.name).to eq(:other)
     end
   end

data/spec/unit/indirector/node/ldap_spec.rb

@@ -191,15 +191,36 @@ describe Puppet::Node::Ldap do
         expect(node_indirection.find(request).parameters).to include({"one" => false})
       end
 
-      it "should merge the node's facts after the parameters from ldap are assigned" do
-        # Make sure we've got data to start with, so the parameters are actually set.
-        params = {"one" => "yay", "two" => "hooray"}
-        @result[:parameters] = params
+      context("when merging facts") do
+        let(:request_facts) { Puppet::Node::Facts.new('test', 'foo' => 'bar') }
+        let(:indirection_facts) { Puppet::Node::Facts.new('test', 'baz' => 'qux') }
+
+        it "should merge facts from the request if supplied" do
+          request.options[:facts] = request_facts
+          Puppet::Node::Facts.stubs(:find) { indirection_facts }
+
+          expect(node_indirection.find(request).parameters).to include(request_facts.values)
+          expect(node_indirection.find(request).facts).to eq(request_facts)
+        end
+
+        it "should find facts if none are supplied" do
+          Puppet::Node::Facts.indirection.stubs(:find).with(nodename, :environment => environment).returns(indirection_facts)
+          request.options.delete(:facts)
 
-        # Node implements its own merge so that an existing param takes
-        # precedence over facts. We get the same result here by merging params
-        # into facts
-        expect(node_indirection.find(request).parameters).to eq(facts.values.merge(params))
+          expect(node_indirection.find(request).parameters).to include(indirection_facts.values)
+          expect(node_indirection.find(request).facts).to eq(indirection_facts)
+        end
+
+        it "should merge the node's facts after the parameters from ldap are assigned" do
+          # Make sure we've got data to start with, so the parameters are actually set.
+          params = {"one" => "yay", "two" => "hooray"}
+          @result[:parameters] = params
+
+          # Node implements its own merge so that an existing param takes
+          # precedence over facts. We get the same result here by merging params
+          # into facts
+          expect(node_indirection.find(request).parameters).to eq(facts.values.merge(params))
+        end
       end
 
       describe "and a parent node is specified" do

data/spec/unit/indirector/node/plain_spec.rb

@@ -5,18 +5,28 @@ require 'puppet/indirector/node/plain'
 
 describe Puppet::Node::Plain do
   let(:nodename) { "mynode" }
-  let(:fact_values) { {:afact => "a value"} }
-  let(:facts) { Puppet::Node::Facts.new(nodename, fact_values) }
+  let(:indirection_fact_values) { {:afact => "a value"} }
+  let(:indirection_facts) { Puppet::Node::Facts.new(nodename, indirection_fact_values) }
+  let(:request_fact_values) { {:foo => "bar" } }
+  let(:request_facts) { Puppet::Node::Facts.new(nodename, request_fact_values)}
   let(:environment) { Puppet::Node::Environment.create(:myenv, []) }
   let(:request) { Puppet::Indirector::Request.new(:node, :find, nodename, nil, :environment => environment) }
   let(:node_indirection) { Puppet::Node::Plain.new }
 
-  before do
-    Puppet::Node::Facts.indirection.expects(:find).with(nodename, :environment => environment).returns(facts)
+  it "should merge facts from the request if supplied" do
+    Puppet::Node::Facts.indirection.expects(:find).never
+    request.options[:facts] = request_facts
+    node = node_indirection.find(request)
+    expect(node.parameters).to include(request_fact_values)
+    expect(node.facts).to eq(request_facts)
   end
 
-  it "merges facts into the node" do
-    expect(node_indirection.find(request).parameters).to include(fact_values)
+  it "should find facts if none are supplied" do
+    Puppet::Node::Facts.indirection.expects(:find).with(nodename, :environment => environment).returns(indirection_facts)
+    request.options.delete(:facts)
+    node = node_indirection.find(request)
+    expect(node.parameters).to include(indirection_fact_values)
+    expect(node.facts).to eq(indirection_facts)
   end
 
   it "should set the node environment from the request" do

data/spec/unit/indirector/node/write_only_yaml_spec.rb

@@ -0,0 +1,12 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+require 'puppet/node'
+require 'puppet/indirector/node/write_only_yaml'
+
+describe Puppet::Node::WriteOnlyYaml do
+  it "should be deprecated" do
+    Puppet.expects(:warn_once).with('deprecations', 'Puppet::Node::WriteOnlyYaml', 'Puppet::Node::WriteOnlyYaml is deprecated and will be removed in a future release of Puppet.')
+    described_class.new
+  end
+end

data/spec/unit/indirector/report/processor_spec.rb

@@ -30,7 +30,7 @@ describe Puppet::Transaction::Report::Processor, " when processing a report" do
     Puppet[:reports] = 'none'
 
     request = Puppet::Indirector::Request.new(:indirection_name, :head, "key", nil)
-    report = Puppet::Transaction::Report.new('apply')
+    report = Puppet::Transaction::Report.new
     request.instance = report
 
     @reporter.save(request)
@@ -66,7 +66,7 @@ describe Puppet::Transaction::Report::Processor, " when processing a report" do
     @report_type = mock 'one'
     @dup_report = mock 'dupe report'
     @dup_report.stubs(:process)
-    @report = Puppet::Transaction::Report.new('apply')
+    @report = Puppet::Transaction::Report.new
     @report.expects(:dup).returns(@dup_report)
 
     @request = stub 'request', :instance => @report

data/spec/unit/indirector/report/rest_spec.rb

@@ -45,23 +45,49 @@ describe Puppet::Transaction::Report::Rest do
   end
 
   describe "#save" do
-    let(:http_method) { :put }
     let(:response) { mock_response(200, 'body') }
     let(:connection) { stub('mock http connection', :put => response, :verify_callback= => nil) }
     let(:instance) { model.new('the thing', 'some contents') }
     let(:request) { save_request(instance.name, instance) }
+    let(:body) { ["store", "http"].to_pson }
 
     before :each do
       terminus.stubs(:network).returns(connection)
     end
 
     it "deserializes the response as an array of report processor names" do
-      processors = ["store", "http"]
-      body = processors.to_pson()
       response = mock_response('200', body, 'text/pson')
       connection.expects(:put).returns response
 
       expect(terminus.save(request)).to eq(["store", "http"])
     end
+
+    describe "when handling the response" do
+      describe "when the server major version is less than 5" do
+        it "raises if the save fails and we're not using pson" do
+          Puppet[:preferred_serialization_format] = "json"
+
+          response = mock_response('500', '{}', 'text/pson')
+          response.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns("4.10.1")
+          connection.expects(:put).returns response
+
+          expect {
+            terminus.save(request)
+          }.to raise_error(Puppet::Error, /Server version 4.10.1 does not accept reports in 'json'/)
+        end
+
+        it "raises with HTTP 500 if the save fails and we're already using pson" do
+          Puppet[:preferred_serialization_format] = "pson"
+
+          response = mock_response('500', '{}', 'text/pson')
+          response.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns("4.10.1")
+          connection.expects(:put).returns response
+
+          expect {
+            terminus.save(request)
+          }.to raise_error(Net::HTTPError, /Error 500 on SERVER/)
+        end
+      end
+    end
   end
 end

data/spec/unit/indirector/request_spec.rb

@@ -149,6 +149,21 @@ describe Puppet::Indirector::Request do
         expect(request.key.encoding).to eq(Encoding::UTF_8)
       end
 
+      it "should set the request key properly given a UTF-8 URI" do
+        # different UTF-8 widths
+        # 1-byte A
+        # 2-byte ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
+        # 3-byte ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
+        # 4-byte <U+070E> - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
+        mixed_utf8 = "A\u06FF\u16A0\u{2070E}" # Aۿᚠ<U+070E>
+
+        key = "a/path/stu ff/#{mixed_utf8}"
+        req = Puppet::Indirector::Request.new(:ind, :method, "http:///#{key}", nil)
+        expect(req.key).to eq(key)
+        expect(req.key.encoding).to eq(Encoding::UTF_8)
+        expect(req.uri).to eq("http:///#{key}")
+      end
+
       it "should set the :uri attribute to the full URI" do
         expect(Puppet::Indirector::Request.new(:ind, :method, "http:///a/path/stu ff", nil).uri).to eq('http:///a/path/stu ff')
       end
@@ -230,10 +245,6 @@ describe Puppet::Indirector::Request do
     expect(Puppet::Indirector::Request.new(:myind, :find, "key", nil).description).to eq("/myind/key")
   end
 
-  it "should be able to return the URI-escaped key" do
-    expect(Puppet::Indirector::Request.new(:myind, :find, "my key", nil).escaped_key).to eq(URI.escape("my key"))
-  end
-
   it "should set its environment to an environment instance when a string is specified as its environment" do
     env = Puppet::Node::Environment.create(:foo, [])
 

data/spec/unit/indirector/rest_spec.rb

@@ -11,14 +11,50 @@ HTTP_ERROR_CODES = [300, 400, 500]
 # Just one from each category since the code makes no real distinctions
 shared_examples_for "a REST terminus method" do |terminus_method|
 
+  describe "when handling the response" do
+    let(:response) do
+      mock_response(200, 'OK')
+    end
+
+    it "falls back to pson for future requests" do
+      response.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns("4.10.1")
+      terminus.send(terminus_method, request)
+
+      expect(Puppet[:preferred_serialization_format]).to eq("pson")
+    end
+
+    it "doesn't change the serialization format if the X-Puppet-Version header is missing" do
+      response.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns(nil)
+
+      terminus.send(terminus_method, request)
+
+      expect(Puppet[:preferred_serialization_format]).to eq("json")
+    end
+
+    it "doesn't change the serialization format if the server major version is 5" do
+      response.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns("5.0.3")
+
+      terminus.send(terminus_method, request)
+
+      expect(Puppet[:preferred_serialization_format]).to eq("json")
+    end
+
+    it "doesn't change the serialization format if the current format is already pson" do
+      response.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns("4.10.1")
+      Puppet[:preferred_serialization_format] = "pson"
+      terminus.send(terminus_method, request)
+
+      expect(Puppet[:preferred_serialization_format]).to eq("pson")
+    end
+  end
+
   HTTP_ERROR_CODES.each do |code|
     describe "when the response code is #{code}" do
       let(:message) { 'error messaged!!!' }
       let(:body) do
         JSON.generate({
           :issue_kind => 'server-error',
-          :message    => message,
-          :stacktrace => ['worst/stack/trace/ever.rb:4']
+          :message    => message
         })
       end
       let(:response) { mock_response(code, body, 'application/json') }
@@ -277,15 +313,21 @@ describe Puppet::Indirector::REST do
   end
 
   it 'excludes yaml from the Accept header' do
-    model.expects(:supported_formats).returns([:pson, :yaml, :binary])
+    model.expects(:supported_formats).returns([:json, :pson, :yaml, :binary])
 
-    expect(terminus.headers['Accept']).to eq('pson, binary')
+    expect(terminus.headers['Accept']).to eq('application/json, text/pson, application/octet-stream')
   end
 
   it 'excludes b64_zlib_yaml from the Accept header' do
-    model.expects(:supported_formats).returns([:pson, :b64_zlib_yaml])
+    model.expects(:supported_formats).returns([:json, :pson, :b64_zlib_yaml])
+
+    expect(terminus.headers['Accept']).to eq('application/json, text/pson')
+  end
+
+  it 'excludes dot from the Accept header' do
+    model.expects(:supported_formats).returns([:json, :dot])
 
-    expect(terminus.headers['Accept']).to eq('pson')
+    expect(terminus.headers['Accept']).to eq('application/json')
   end
 
   describe "when creating an HTTP client" do
@@ -433,10 +475,10 @@ describe Puppet::Indirector::REST do
       expect(terminus.find(request)).to eq(model.new('name', 'decoded body'))
     end
 
-    it "provides an Accept header containing the list of supported formats joined with commas" do
-      connection.expects(:get).with(anything, has_entry("Accept" => "supported, formats")).returns(response)
+    it "provides an Accept header containing the list of supported mime types joined with commas" do
+      connection.expects(:get).with(anything, has_entry("Accept" => "application/json, text/pson")).returns(response)
 
-      terminus.model.expects(:supported_formats).returns %w{supported formats}
+      terminus.model.expects(:supported_formats).returns [:json, :pson]
       terminus.find(request)
     end
 
@@ -539,9 +581,9 @@ describe Puppet::Indirector::REST do
     end
 
     it "should provide an Accept header containing the list of supported formats joined with commas" do
-      connection.expects(:get).with(anything, has_entry("Accept" => "supported, formats")).returns(mock_response(200, ''))
+      connection.expects(:get).with(anything, has_entry("Accept" => "application/json, text/pson")).returns(mock_response(200, ''))
 
-      terminus.model.expects(:supported_formats).returns %w{supported formats}
+      terminus.model.expects(:supported_formats).returns [:json, :pson]
       terminus.search(request)
     end
 
@@ -598,9 +640,9 @@ describe Puppet::Indirector::REST do
     end
 
     it "should provide an Accept header containing the list of supported formats joined with commas" do
-      connection.expects(:delete).with(anything, has_entry("Accept" => "supported, formats")).returns(response)
+      connection.expects(:delete).with(anything, has_entry("Accept" => "application/json, text/pson")).returns(response)
 
-      terminus.model.expects(:supported_formats).returns %w{supported formats}
+      terminus.model.expects(:supported_formats).returns [:json, :pson]
       terminus.destroy(request)
     end
 
@@ -658,10 +700,10 @@ describe Puppet::Indirector::REST do
     end
 
     it "should provide an Accept header containing the list of supported formats joined with commas" do
-      connection.expects(:put).with(anything, anything, has_entry("Accept" => "supported, formats")).returns(response)
+      connection.expects(:put).with(anything, anything, has_entry("Accept" => "application/json, text/pson")).returns(response)
 
       instance.expects(:render).returns('')
-      model.expects(:supported_formats).returns %w{supported formats}
+      model.expects(:supported_formats).returns [:json, :pson]
       instance.expects(:mime).returns "supported"
 
       terminus.save(request)