chef 10.34.6-x86-mingw32 → 11.6.2-x86-mingw32

data/spec/unit/rest/auth_credentials_spec.rb

@@ -57,11 +57,8 @@ Y6S6MeZ69Rp89ma4ttMZ+kwi1+XyHqC/dlcVRW42Zl5Dc7BALRlJjQ==
 describe Chef::REST::AuthCredentials do
   before do
     @key_file_fixture = CHEF_SPEC_DATA + '/ssl/private_key.pem'
-    @auth_credentials = Chef::REST::AuthCredentials.new("client-name", @key_file_fixture)
-  end
-
-  it "has a key file value" do
-    @auth_credentials.key_file.should == @key_file_fixture
+    @key = OpenSSL::PKey::RSA.new(IO.read(@key_file_fixture).strip)
+    @auth_credentials = Chef::REST::AuthCredentials.new("client-name", @key)
   end
 
   it "has a client name" do
@@ -74,15 +71,6 @@ describe Chef::REST::AuthCredentials do
   end
 
   describe "when loading the private key" do
-    it "raises PrivateKeyMissing when the key file doesn't exist" do
-      lambda {Chef::REST::AuthCredentials.new("client-name", "/dev/null/nothing_here")}.should raise_error(Chef::Exceptions::PrivateKeyMissing)
-    end
-
-    it "raises InvalidPrivateKey when the key file doesnt' look like a key" do
-      invalid_key_file = CHEF_SPEC_DATA + "/bad-config.rb"
-      lambda {Chef::REST::AuthCredentials.new("client-name", invalid_key_file)}.should raise_error(Chef::Exceptions::InvalidPrivateKey)
-    end
-
     it "strips extra whitespace before checking the key" do
       key_file_fixture = CHEF_SPEC_DATA + '/ssl/private_key_with_whitespace.pem'
       lambda {Chef::REST::AuthCredentials.new("client-name", @key_file_fixture)}.should_not raise_error
@@ -211,11 +199,6 @@ describe Chef::REST::RESTRequest do
       new_request.http_client.read_timeout.should == 9001
     end
 
-    it "configures the HTTP client with the open timeout set in the config file" do
-      Chef::Config[:rest_timeout] = 9001
-      new_request.http_client.read_timeout.should == 9001
-    end
-
     describe "for SSL" do
       before do
         Chef::Config[:ssl_client_cert] = nil
@@ -315,7 +298,7 @@ describe Chef::REST::RESTRequest do
         Chef::Config[:http_proxy]  = "http://proxy.example.com:3128"
         Chef::Config[:https_proxy] = "http://sproxy.example.com:3129"
         Chef::Config[:http_proxy_user] = nil
-        Chef::Config[:https_proxy_pass] = nil
+        Chef::Config[:http_proxy_pass] = nil
         Chef::Config[:https_proxy_user] = nil
         Chef::Config[:https_proxy_pass] = nil
         Chef::Config[:no_proxy] = nil
@@ -325,7 +308,7 @@ describe Chef::REST::RESTRequest do
         Chef::Config[:http_proxy]  = nil
         Chef::Config[:https_proxy] = nil
         Chef::Config[:http_proxy_user] = nil
-        Chef::Config[:https_proxy_pass] = nil
+        Chef::Config[:http_proxy_pass] = nil
         Chef::Config[:https_proxy_user] = nil
         Chef::Config[:https_proxy_pass] = nil
         Chef::Config[:no_proxy] = nil

data/spec/unit/rest_spec.rb

@@ -130,6 +130,23 @@ describe Chef::REST do
       @rest.sign_requests?.should be_false
     end
 
+    it "raises PrivateKeyMissing when the key file doesn't exist" do
+      lambda {Chef::REST.new(@url, "client-name", "/dev/null/nothing_here")}.should raise_error(Chef::Exceptions::PrivateKeyMissing)
+    end
+
+    it "raises InvalidPrivateKey when the key file doesnt' look like a key" do
+      invalid_key_file = CHEF_SPEC_DATA + "/bad-config.rb"
+      lambda {Chef::REST.new(@url, "client-name", invalid_key_file)}.should raise_error(Chef::Exceptions::InvalidPrivateKey)
+    end
+
+    it "can take private key as a sting :raw_key in options during initializaton" do
+      Chef::REST.new(@url, "client-name", nil, :raw_key => SIGNING_KEY_DOT_PEM).signing_key.should == SIGNING_KEY_DOT_PEM
+    end
+
+    it "raises InvalidPrivateKey when the key passed as string :raw_key in options doesnt' look like a key" do
+      lambda {Chef::REST.new(@url, "client-name", nil, :raw_key => "bad key string")}.should raise_error(Chef::Exceptions::InvalidPrivateKey)
+    end
+
   end
 
   context "when making REST requests" do
@@ -137,7 +154,6 @@ describe Chef::REST do
       Chef::Config[:ssl_client_cert] = nil
       Chef::Config[:ssl_client_key]  = nil
       @url = URI.parse("https://one:80/?foo=bar")
-      @expected_host_header = "one:80"
 
       @http_response = Net::HTTPSuccess.new("1.1", "200", "successful rest req")
       @http_response.stub!(:read_body)
@@ -150,188 +166,63 @@ describe Chef::REST do
 
       @base_headers = { 'Accept' => 'application/json',
                         'X-Chef-Version' => Chef::VERSION,
-                        'Accept-Encoding' => Chef::REST::RESTRequest::ENCODING_GZIP_DEFLATE,
-                        'Host' => @expected_host_header }
+                        'Accept-Encoding' => Chef::REST::RESTRequest::ENCODING_GZIP_DEFLATE}
       @req_with_body_headers = @base_headers.merge("Content-Type" => "application/json", "Content-Length" => '13')
     end
 
-    describe "using the run_request API" do
-      it "should build a new HTTP GET request" do
-        request = Net::HTTP::Get.new(@url.path)
-        Net::HTTP::Get.should_receive(:new).with("/?foo=bar", @base_headers).and_return(request)
-        @rest.run_request(:GET, @url, {})
-      end
-
-      it "should build a new HTTP POST request" do
-        request = Net::HTTP::Post.new(@url.path)
-
-        Net::HTTP::Post.should_receive(:new).with("/?foo=bar", @req_with_body_headers).and_return(request)
-        @rest.run_request(:POST, @url, {}, {:one=>:two})
-        request.body.should == '{"one":"two"}'
-      end
-
-      it "should build a new HTTP PUT request" do
-        request = Net::HTTP::Put.new(@url.path)
-        expected_headers = @base_headers.merge("Content-Length" => '13')
-        Net::HTTP::Put.should_receive(:new).with("/?foo=bar", @req_with_body_headers).and_return(request)
-        @rest.run_request(:PUT, @url, {}, {:one=>:two})
-        request.body.should == '{"one":"two"}'
-      end
-
-      it "should build a new HTTP DELETE request" do
-        request = Net::HTTP::Delete.new(@url.path)
-        Net::HTTP::Delete.should_receive(:new).with("/?foo=bar", @base_headers).and_return(request)
-        @rest.run_request(:DELETE, @url)
-      end
-
-      it "should raise an error if the method is not GET/PUT/POST/DELETE" do
-        lambda { @rest.api_request(:MONKEY, @url) }.should raise_error(ArgumentError)
-      end
+    describe "streaming downloads to a tempfile" do
+      before do
+        @tempfile = Tempfile.open("chef-rspec-rest_spec-line-#{__LINE__}--")
+        Tempfile.stub!(:new).with("chef-rest").and_return(@tempfile)
+        Tempfile.stub!(:open).and_return(@tempfile)
 
-      it "returns the response body when the response is successful but content-type is not JSON" do
-        @rest.run_request(:GET, @url).should == "ninja"
-      end
+        @request_mock = {}
+        Net::HTTP::Get.stub!(:new).and_return(@request_mock)
 
-      it "should call read_body without a block if the request is not raw" do
-        @http_response.should_receive(:body)
-        @rest.run_request(:GET, @url, {}, nil, false)
+        @http_response_mock = mock("Net::HTTP Response mock")
       end
 
-      it "should inflate the body as to an object if JSON is returned" do
-        @http_response.add_field("content-type", "application/json")
-        Chef::JSONCompat.should_receive(:from_json).with("ninja").and_return("ohai2u_success")
-        @rest.run_request(:GET, @url, {}).should == "ohai2u_success"
+      after do
+        @tempfile.rspec_reset
+        @tempfile.close!
       end
 
-      it "should return false on a Not Modified response" do
-        http_response = Net::HTTPNotModified.new("1.1", "304", "It's old Bob")
-        @http_client.stub!(:request).and_yield(http_response).and_return(http_response)
-        http_response.stub!(:read_body)
-        @rest.run_request(:GET, @url).should be_false
+      it "should build a new HTTP GET request without the application/json accept header" do
+        expected_headers = {'X-Chef-Version' => Chef::VERSION, 'Accept-Encoding' => Chef::REST::RESTRequest::ENCODING_GZIP_DEFLATE}
+        Net::HTTP::Get.should_receive(:new).with("/?foo=bar", expected_headers).and_return(@request_mock)
+        @rest.streaming_request(@url, {})
       end
 
-      %w[ HTTPFound HTTPMovedPermanently HTTPSeeOther HTTPUseProxy HTTPTemporaryRedirect HTTPMultipleChoice ].each do |resp_name|
-        it "should call run_request again on a #{resp_name} response" do
-          resp_cls  = Net.const_get(resp_name)
-          resp_code = Net::HTTPResponse::CODE_TO_OBJ.keys.detect { |k| Net::HTTPResponse::CODE_TO_OBJ[k] == resp_cls }
-          http_response = resp_cls.new("1.1", resp_code, "bob somewhere else")
-          http_response.add_field("location", @url.path)
-          http_response.stub!(:read_body)
-
-          @http_client.stub!(:request).and_yield(http_response).and_return(http_response)
-          lambda { @rest.run_request(:GET, @url) }.should raise_error(Chef::Exceptions::RedirectLimitExceeded)
-        end
+      it "should create a tempfile for the output of a raw request" do
+        @rest.streaming_request(@url, {}).should equal(@tempfile)
       end
 
-      # CHEF-3140
-      context "when configured to disable compression" do
-        before do
-          @rest = Chef::REST.new(@base_url, nil, nil, :disable_gzip => true)
-        end
-
-        it "does not accept encoding gzip" do
-          @rest.send(:build_headers, :GET, @url, {}).should_not have_key("Accept-Encoding")
-        end
-
-        it "does not decompress a response encoded as gzip" do
-          @http_response.add_field("content-encoding", "gzip")
-          request = Net::HTTP::Get.new(@url.path)
-          Net::HTTP::Get.should_receive(:new).and_return(request)
-          # will raise a Zlib error if incorrect
-          @rest.api_request(:GET, @url, {}).should == "ninja"
-        end
+      it "should read the body of the response in chunks on a raw request" do
+        @http_response.should_receive(:read_body).and_return(true)
+        @rest.streaming_request(@url, {})
       end
 
-      it "should show the JSON error message on an unsuccessful request" do
-        http_response = Net::HTTPServerError.new("1.1", "500", "drooling from inside of mouth")
-        http_response.add_field("content-type", "application/json")
-        http_response.stub!(:body).and_return('{ "error":[ "Ears get sore!", "Not even four" ] }')
-        http_response.stub!(:read_body)
-        @http_client.stub!(:request).and_yield(http_response).and_return(http_response)
-        @rest.stub!(:sleep)
-        lambda {@rest.run_request(:GET, @url)}.should raise_error(Net::HTTPFatalError)
-        @log_stringio.string.should match(Regexp.escape('WARN: HTTP Request Returned 500 drooling from inside of mouth: Ears get sore!, Not even four'))
+      it "should populate the tempfile with the value of the raw request" do
+        @http_response_mock.stub!(:read_body).and_yield("ninja")
+        @tempfile.should_receive(:write).with("ninja").once.and_return(true)
+        @rest.streaming_request(@url, {})
       end
 
-      it "should raise an exception on an unsuccessful request" do
-        @http_response = Net::HTTPServerError.new("1.1", "500", "drooling from inside of mouth")
-        http_response = Net::HTTPServerError.new("1.1", "500", "drooling from inside of mouth")
-        http_response.stub!(:read_body)
-        @rest.stub!(:sleep)
-        @http_client.stub!(:request).and_yield(http_response).and_return(http_response)
-        lambda {@rest.run_request(:GET, @url)}.should raise_error(Net::HTTPFatalError)
+      it "should close the tempfile if we're doing a raw request" do
+        @tempfile.should_receive(:close).once.and_return(true)
+        @rest.streaming_request(@url, {})
       end
 
-      it "adds the rest_request object to any http exception raised" do
-        @http_response = Net::HTTPServerError.new("1.1", "500", "drooling from inside of mouth")
-        http_response = Net::HTTPServerError.new("1.1", "500", "drooling from inside of mouth")
-        http_response.stub!(:read_body)
-        @rest.stub!(:sleep)
-        @http_client.stub!(:request).and_yield(http_response).and_return(http_response)
-        exception = begin
-          @rest.api_request(:GET, @url, {})
-        rescue => e
-          e
-        end
-
-        e.chef_rest_request.url.should == @url
-        e.chef_rest_request.method.should == :GET
+      it "should not raise a divide by zero exception if the size is 0" do
+        @http_response_mock.stub!(:header).and_return({ 'Content-Length' => "5" })
+        @http_response_mock.stub!(:read_body).and_yield('')
+        lambda { @rest.streaming_request(@url, {}) }.should_not raise_error(ZeroDivisionError)
       end
 
-      describe "streaming downloads to a tempfile" do
-        before do
-          @tempfile = StringIO.new
-          @tempfile.stub(:close!)
-          @tempfile.stub(:path).and_return("/tmp/this-is-a-stringio-not-a-real-file")
-          Tempfile.stub(:new).with("chef-rest").and_return(@tempfile)
-          Tempfile.stub(:open).and_return(@tempfile)
-
-          @request_mock = {}
-          Net::HTTP::Get.stub!(:new).and_return(@request_mock)
-
-          @http_response_mock = mock("Net::HTTP Response mock")
-        end
-
-        it "should build a new HTTP GET request without the application/json accept header" do
-          expected_headers = { 'X-Chef-Version' => Chef::VERSION,
-                               'Accept-Encoding' => Chef::REST::RESTRequest::ENCODING_GZIP_DEFLATE,
-                               'Host' => @expected_host_header }
-          Net::HTTP::Get.should_receive(:new).with("/?foo=bar", expected_headers).and_return(@request_mock)
-          @rest.run_request(:GET, @url, {}, false, nil, true)
-        end
-
-        it "should create a tempfile for the output of a raw request" do
-          @rest.run_request(:GET, @url, {}, false, nil, true).should equal(@tempfile)
-        end
-
-        it "should read the body of the response in chunks on a raw request" do
-          @http_response.should_receive(:read_body).and_return(true)
-          @rest.run_request(:GET, @url, {}, false, nil, true)
-        end
-
-        it "should populate the tempfile with the value of the raw request" do
-          @http_response.should_receive(:read_body).and_yield("ninja")
-          @rest.run_request(:GET, @url, {}, false, nil, true)
-          @tempfile.string.should include("ninja")
-        end
-
-        it "should close the tempfile if we're doing a raw request" do
-          @tempfile.should_receive(:close).once.and_return(true)
-          @rest.run_request(:GET, @url, {}, false, nil, true)
-        end
-
-        it "should not raise a divide by zero exception if the size is 0" do
-          @http_response_mock.stub!(:header).and_return({ 'Content-Length' => "5" })
-          @http_response_mock.stub!(:read_body).and_yield('')
-          lambda { @rest.run_request(:GET, @url, {}, false, nil, true) }.should_not raise_error(ZeroDivisionError)
-        end
-
-        it "should not raise a divide by zero exception if the Content-Length is 0" do
-          @http_response_mock.stub!(:header).and_return({ 'Content-Length' => "0" })
-          @http_response_mock.stub!(:read_body).and_yield("ninja")
-          lambda { @rest.run_request(:GET, @url, {}, false, nil, true) }.should_not raise_error(ZeroDivisionError)
-        end
-
+      it "should not raise a divide by zero exception if the Content-Length is 0" do
+        @http_response_mock.stub!(:header).and_return({ 'Content-Length' => "0" })
+        @http_response_mock.stub!(:read_body).and_yield("ninja")
+        lambda { @rest.streaming_request(@url, {}) }.should_not raise_error(ZeroDivisionError)
       end
 
     end
@@ -343,8 +234,7 @@ describe Chef::REST do
 
         @base_headers = {"Accept" => "application/json",
           "X-Chef-Version" => Chef::VERSION,
-          "Accept-Encoding" => Chef::REST::RESTRequest::ENCODING_GZIP_DEFLATE,
-          "Host" => @expected_host_header
+          "Accept-Encoding" => Chef::REST::RESTRequest::ENCODING_GZIP_DEFLATE
         }
       end
 
@@ -360,6 +250,24 @@ describe Chef::REST do
         @request_mock['User-Agent'].should match /^Chef Client\/#{Chef::VERSION}/
       end
 
+      # CHEF-3140
+      context "when configured to disable compression" do
+        before do
+          @rest = Chef::REST.new(@base_url, nil, nil, :disable_gzip => true)
+        end
+
+        it "does not accept encoding gzip" do
+          @rest.send(:build_headers, :GET, @url, {}).should_not have_key("Accept-Encoding")
+        end
+
+        it "does not decompress a response encoded as gzip" do
+          @http_response.add_field("content-encoding", "gzip")
+          request = Net::HTTP::Get.new(@url.path)
+          Net::HTTP::Get.should_receive(:new).and_return(request)
+          # will raise a Zlib error if incorrect
+          @rest.api_request(:GET, @url, {}).should == "ninja"
+        end
+      end
       context "when configured with custom http headers" do
         before(:each) do
           @custom_headers = {
@@ -422,146 +330,90 @@ describe Chef::REST do
         @rest.api_request(:GET, @url).should == "ninja"
       end
 
-      it "returns nil when the response is a 204 and the content-type is JSON" do
-
-        @http_response = Net::HTTPNoContent.new("1.1", "204", "successful rest req")
-        @http_response.stub!(:read_body)
-        @http_response.stub!(:body).and_return(nil)
-        @http_response.add_field("Content-Length", "0")
-        @http_response.add_field("Content-Type", "application/json")
-
-        @http_client = Net::HTTP.new(@url.host, @url.port)
-        Net::HTTP.stub!(:new).and_return(@http_client)
-        @http_client.stub!(:request).and_yield(@http_response).and_return(@http_response)
-
-        @rest.api_request(:GET, @url).should be_nil
-      end
-
       it "should inflate the body as to an object if JSON is returned" do
         @http_response.add_field('content-type', "application/json")
         @http_response.stub!(:body).and_return('{"ohai2u":"json_api"}')
         @rest.api_request(:GET, @url, {}).should == {"ohai2u"=>"json_api"}
       end
 
-      context "when sending a request with a body and the content-type isn't JSON" do
+      %w[ HTTPFound HTTPMovedPermanently HTTPSeeOther HTTPUseProxy HTTPTemporaryRedirect HTTPMultipleChoice ].each do |resp_name|
+        it "should call api_request again on a #{resp_name} response" do
+          resp_cls  = Net.const_get(resp_name)
+          resp_code = Net::HTTPResponse::CODE_TO_OBJ.keys.detect { |k| Net::HTTPResponse::CODE_TO_OBJ[k] == resp_cls }
+          http_response = Net::HTTPFound.new("1.1", resp_code, "bob is somewhere else again")
+          http_response.add_field("location", @url.path)
+          http_response.stub!(:read_body)
 
-        let(:expected_headers) do
-          @base_headers.merge("content-type" => 'application/x-binary', 'Content-Length' => '13')
-        end
+          @http_client.stub!(:request).and_yield(http_response).and_return(http_response)
 
-        let(:request_headers) do
-          {"content-type" => 'application/x-binary'}
-        end
+          lambda { @rest.api_request(:GET, @url) }.should raise_error(Chef::Exceptions::RedirectLimitExceeded)
 
-        let(:request_body) do
-          Chef::JSONCompat.to_json({:one=>:two})
+          [:PUT, :POST, :DELETE].each do |method|
+            lambda { @rest.api_request(method, @url) }.should raise_error(Chef::Exceptions::InvalidRedirect)
+          end
         end
+      end
 
-        it "should build a new HTTP POST request" do
-          request = Net::HTTP::Post.new(@url.path)
-          Net::HTTP::Post.should_receive(:new).with("/?foo=bar", expected_headers).and_return(request)
-          @rest.raw_http_request(:POST, @url, request_headers, request_body)
-          request.body.should == '{"one":"two"}'
-        end
+      it "should return `false` when response is 304 NotModified" do
+        http_response = Net::HTTPNotModified.new("1.1", "304", "it's the same as when you asked 5 minutes ago")
+        http_response.stub!(:read_body)
 
-        it "should build a new HTTP PUT request" do
-          request = Net::HTTP::Put.new(@url.path)
-          Net::HTTP::Put.should_receive(:new).with("/?foo=bar",expected_headers).and_return(request)
-          @rest.raw_http_request(:PUT, @url, request_headers, request_body)
-          request.body.should == '{"one":"two"}'
-        end
+        @http_client.stub!(:request).and_yield(http_response).and_return(http_response)
 
+        @rest.api_request(:GET, @url).should be_false
       end
 
-      describe "when the server returns a redirect response" do
-        let(:redirected_url) { "https://chef.example.com:8443/foo" }
-        let(:redirected_uri) { URI.parse(redirected_url) }
-
-        def redirect_with(response_name)
-          resp_cls  = Net.const_get(response_name)
-          resp_code = Net::HTTPResponse::CODE_TO_OBJ.keys.detect { |k| Net::HTTPResponse::CODE_TO_OBJ[k] == resp_cls }
-          redirect = Net::HTTPFound.new("1.1", resp_code, "bob is somewhere else again")
-          redirect.add_field("location", redirected_url)
-          redirect.stub!(:read_body).and_return('')
-          redirect
+      describe "when the request fails" do
+        before do
+          @original_log_level = Chef::Log.level
+          Chef::Log.level = :info
         end
 
-        %w[ HTTPFound HTTPMovedPermanently HTTPSeeOther HTTPUseProxy HTTPTemporaryRedirect HTTPMultipleChoice ].each do |response_name|
-
-          it "should call api_request again on a #{response_name} response" do
-            redirect = redirect_with(response_name)
-
-            headers = { "X-Auth-Header" => "foo" }
-            auto_headers = { "Accept"=>"application/json",
-                             "Accept-Encoding"=>"gzip;q=1.0,deflate;q=0.6,identity;q=0.3",
-                             "Host" => @expected_host_header}
-            expected_headers = auto_headers.merge(headers)
-            expected_headers_on_redirect = expected_headers.dup
-            expected_headers_on_redirect["Host"] = "chef.example.com:8443"
-
-            success = Net::HTTPSuccess.new("1.1",200, "it-works")
-            success.stub!(:read_body).and_return('{"foo": "bar"}')
-            success['content-type'] = "application/json"
+        after do
+          Chef::Log.level = @original_log_level
+        end
 
-            @http_client.should_receive(:request).and_yield(redirect).and_return(redirect)
-            @http_client.should_receive(:request).and_yield(success).and_return(success)
+        it "should show the JSON error message on an unsuccessful request" do
+          http_response = Net::HTTPServerError.new("1.1", "500", "drooling from inside of mouth")
+          http_response.add_field("content-type", "application/json")
+          http_response.stub!(:body).and_return('{ "error":[ "Ears get sore!", "Not even four" ] }')
+          http_response.stub!(:read_body)
+          @rest.stub!(:sleep)
+          @http_client.stub!(:request).and_yield(http_response).and_return(http_response)
 
-            # CHEF-1848: verify that headers get passed to redirects
-            @rest.should_receive(:retriable_rest_request).with(:GET, @url, nil, expected_headers).and_call_original
-            @rest.should_receive(:retriable_rest_request).with(:GET, redirected_uri, nil, expected_headers_on_redirect).and_call_original
+          lambda {@rest.api_request(:GET, @url)}.should raise_error(Net::HTTPFatalError)
+          @log_stringio.string.should match(Regexp.escape('INFO: HTTP Request Returned 500 drooling from inside of mouth: Ears get sore!, Not even four'))
+        end
 
-            @rest.api_request(:GET, @url, headers).should == {"foo" => "bar"}
-          end
+        it "decompresses the JSON error message on an unsuccessful request" do
+          http_response = Net::HTTPServerError.new("1.1", "500", "drooling from inside of mouth")
+          http_response.add_field("content-type", "application/json")
+          http_response.add_field("content-encoding", "deflate")
+          unzipped_body = '{ "error":[ "Ears get sore!", "Not even four" ] }'
+          gzipped_body = Zlib::Deflate.deflate(unzipped_body)
+          gzipped_body.force_encoding(Encoding::BINARY) if "strings".respond_to?(:force_encoding)
 
-          context "when making a request for a method other than GET" do
+          http_response.stub!(:body).and_return gzipped_body
+          http_response.stub!(:read_body)
+          @rest.stub!(:sleep)
+          @rest.stub!(:http_retry_count).and_return(0)
+          @http_client.stub!(:request).and_yield(http_response).and_return(http_response)
 
-            [:PUT, :POST, :DELETE].each do |method|
-              it "raises an error" do
-                redirect = redirect_with(response_name)
-                @http_client.should_receive(:request).and_yield(redirect).and_return(redirect)
-                lambda { @rest.api_request(method, @url) }.should raise_error(Chef::Exceptions::InvalidRedirect)
-              end
-            end
-          end
+          lambda {@rest.api_request(:GET, @url)}.should raise_error(Net::HTTPFatalError)
+          @log_stringio.string.should match(Regexp.escape('INFO: HTTP Request Returned 500 drooling from inside of mouth: Ears get sore!, Not even four'))
         end
 
+        it "should raise an exception on an unsuccessful request" do
+          http_response = Net::HTTPServerError.new("1.1", "500", "drooling from inside of mouth")
+          http_response.stub!(:body)
+          http_response.stub!(:read_body)
+          @rest.stub!(:sleep)
+          @http_client.stub!(:request).and_yield(http_response).and_return(http_response)
+          lambda {@rest.api_request(:GET, @url)}.should raise_error(Net::HTTPFatalError)
+        end
       end
 
-      it "should show the JSON error message on an unsuccessful request" do
-        http_response = Net::HTTPServerError.new("1.1", "500", "drooling from inside of mouth")
-        http_response.add_field("content-type", "application/json")
-        http_response.stub!(:body).and_return('{ "error":[ "Ears get sore!", "Not even four" ] }')
-        http_response.stub!(:read_body)
-        @rest.stub!(:sleep)
-        @http_client.stub!(:request).and_yield(http_response).and_return(http_response)
-
-        lambda {@rest.run_request(:GET, @url)}.should raise_error(Net::HTTPFatalError)
-        @log_stringio.string.should match(Regexp.escape('WARN: HTTP Request Returned 500 drooling from inside of mouth: Ears get sore!, Not even four'))
-      end
-
-      it "decompresses the JSON error message on an unsuccessful request" do
-        http_response = Net::HTTPServerError.new("1.1", "500", "drooling from inside of mouth")
-        http_response.add_field("content-type", "application/json")
-        http_response.add_field("content-encoding", "deflate")
-        unzipped_body = '{ "error":[ "Ears get sore!", "Not even four" ] }'
-        gzipped_body = Zlib::Deflate.deflate(unzipped_body, 1)
-        http_response.stub!(:body).and_return gzipped_body
-        http_response.stub!(:read_body)
-        @rest.stub!(:sleep)
-        @http_client.stub!(:request).and_yield(http_response).and_return(http_response)
-
-        lambda {@rest.run_request(:GET, @url)}.should raise_error(Net::HTTPFatalError)
-        @log_stringio.string.should match(Regexp.escape('WARN: HTTP Request Returned 500 drooling from inside of mouth: Ears get sore!, Not even four'))
-      end
 
-      it "should raise an exception on an unsuccessful request" do
-        http_response = Net::HTTPServerError.new("1.1", "500", "drooling from inside of mouth")
-        http_response.stub!(:body)
-        http_response.stub!(:read_body)
-        @rest.stub!(:sleep)
-        @http_client.stub!(:request).and_yield(http_response).and_return(http_response)
-        lambda {@rest.api_request(:GET, @url)}.should raise_error(Net::HTTPFatalError)
-      end
     end
 
     context "when streaming downloads to a tempfile" do
@@ -577,13 +429,12 @@ describe Chef::REST do
       end
 
       after do
+        @tempfile.rspec_reset
         @tempfile.close!
       end
 
       it " build a new HTTP GET request without the application/json accept header" do
-        expected_headers = { 'X-Chef-Version' => Chef::VERSION,
-                             'Accept-Encoding' => Chef::REST::RESTRequest::ENCODING_GZIP_DEFLATE,
-                             'Host' => @expected_host_header }
+        expected_headers = {'X-Chef-Version' => Chef::VERSION, 'Accept-Encoding' => Chef::REST::RESTRequest::ENCODING_GZIP_DEFLATE}
         Net::HTTP::Get.should_receive(:new).with("/?foo=bar", expected_headers).and_return(@request_mock)
         @rest.streaming_request(@url, {})
       end
@@ -645,7 +496,8 @@ describe Chef::REST do
       end
 
       it "closes and unlinks the tempfile when the response is a redirect" do
-        tempfile = mock("die", :path => "/tmp/ragefist", :close => true, :binmode => nil)
+        Tempfile.rspec_reset
+        tempfile = mock("die", :path => "/tmp/ragefist", :close => true, :binmode => true)
         tempfile.should_receive(:close!).at_least(2).times
         Tempfile.stub!(:new).with("chef-rest").and_return(tempfile)
 
@@ -658,9 +510,7 @@ describe Chef::REST do
       end
 
       it "passes the original block to the redirected request" do
-        tempfile = mock("die", :path => "/tmp/ragefist", :close => true, :binmode => nil)
-        tempfile.should_receive(:close!).at_least(2).times
-        Tempfile.stub!(:new).with("chef-rest").and_return(tempfile)
+        Tempfile.rspec_reset
 
         http_response = Net::HTTPFound.new("1.1", "302", "bob is taking care of that one for me today")
         http_response.add_field("location","/that-thing-is-here-now")