chef 11.6.2-x86-mingw32 → 11.8.0.rc.1-x86-mingw32

data/spec/unit/resource/yum_package_spec.rb

@@ -6,9 +6,9 @@
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-# 
+#
 #     http://www.apache.org/licenses/LICENSE-2.0
-# 
+#
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -19,19 +19,19 @@
 require 'spec_helper'
 
 describe Chef::Resource::YumPackage, "initialize" do
-  
+
   before(:each) do
     @resource = Chef::Resource::YumPackage.new("foo")
   end
-  
+
   it "should return a Chef::Resource::YumPackage" do
     @resource.should be_a_kind_of(Chef::Resource::YumPackage)
   end
-  
+
   it "should set the resource_name to :yum_package" do
     @resource.resource_name.should eql(:yum_package)
   end
-  
+
   it "should set the provider to Chef::Provider::Package::Yum" do
     @resource.provider.should eql(Chef::Provider::Package::Yum)
   end
@@ -56,7 +56,7 @@ describe Chef::Resource::YumPackage, "flush_cache" do
   it "should default the flush timing to false" do
     flush_hash = { :before => false, :after => false }
     @resource.flush_cache.should == flush_hash
-  end 
+  end
 
   it "should allow you to set the flush timing with an array" do
     flush_array = [ :before, :after ]

data/spec/unit/resource_collection/stepable_iterator_spec.rb

@@ -5,9 +5,9 @@
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-# 
+#
 #     http://www.apache.org/licenses/LICENSE-2.0
-# 
+#
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -19,17 +19,17 @@ require 'spec_helper'
 
 describe Chef::ResourceCollection::StepableIterator do
   CRSI = Chef::ResourceCollection::StepableIterator
-  
+
   it "has an empty array for its collection by default" do
     CRSI.new.collection.should == []
   end
-  
+
   describe "doing basic iteration" do
     before do
       @simple_collection = [1,2,3,4]
       @iterator = CRSI.for_collection(@simple_collection)
     end
-    
+
     it "re-initializes the instance with a collection" do
       @iterator.collection.should equal(@simple_collection)
       @iterator.size.should == 4
@@ -51,7 +51,7 @@ describe Chef::ResourceCollection::StepableIterator do
       collected_by_index.should == @simple_collection
       collected_by_index.should_not equal(@simple_collection)
     end
-    
+
     it "iterates over the collection with index and element" do
       collected = {}
       @iterator.each_with_index do |element, index|
@@ -59,32 +59,32 @@ describe Chef::ResourceCollection::StepableIterator do
       end
       collected.should == {0=>1, 1=>2, 2=>3, 3=>4}
     end
-    
+
   end
-  
+
   describe "pausing and resuming iteration" do
-    
+
     before do
       @collection = []
       @snitch_var = nil
       @collection << lambda { @snitch_var = 23 }
       @collection << lambda { @iterator.pause }
       @collection << lambda { @snitch_var = 42 }
-      
+
       @iterator = CRSI.for_collection(@collection)
       @iterator.each { |proc| proc.call }
     end
-    
+
     it "allows the iteration to be paused" do
       @snitch_var.should == 23
     end
-    
+
     it "allows the iteration to be resumed" do
       @snitch_var.should == 23
       @iterator.resume
       @snitch_var.should == 42
     end
-    
+
     it "allows iteration to be rewound" do
       @iterator.skip_back(2)
       @iterator.resume
@@ -92,13 +92,13 @@ describe Chef::ResourceCollection::StepableIterator do
       @iterator.resume
       @snitch_var.should == 42
     end
-    
+
     it "allows iteration to be fast forwarded" do
       @iterator.skip_forward
       @iterator.resume
       @snitch_var.should == 23
     end
-    
+
     it "allows iteration to be rewound" do
       @snitch_var = nil
       @iterator.rewind
@@ -106,7 +106,7 @@ describe Chef::ResourceCollection::StepableIterator do
       @iterator.resume
       @snitch_var.should == 23
     end
-    
+
     it "allows iteration to be stepped" do
       @snitch_var = nil
       @iterator.rewind
@@ -114,13 +114,13 @@ describe Chef::ResourceCollection::StepableIterator do
       @iterator.position.should == 1
       @snitch_var.should == 23
     end
-    
+
     it "doesn't step if there are no more steps" do
       @iterator.step.should == 3
       lambda {@iterator.step}.should_not raise_error
       @iterator.step.should be_nil
     end
-    
+
     it "allows the iteration to start by being stepped" do
       @snitch_var = nil
       @iterator = CRSI.for_collection(@collection)
@@ -129,7 +129,7 @@ describe Chef::ResourceCollection::StepableIterator do
       @iterator.position.should == 1
       @snitch_var.should == 23
     end
-    
+
     it "should work correctly when elements are added to the collection during iteration" do
       @collection.insert(2, lambda { @snitch_var = 815})
       @collection.insert(3, lambda { @iterator.pause })
@@ -138,7 +138,7 @@ describe Chef::ResourceCollection::StepableIterator do
       @iterator.resume
       @snitch_var.should == 42
     end
-    
+
   end
-  
+
 end

data/spec/unit/resource_definition_spec.rb

@@ -6,9 +6,9 @@
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
-# 
+#
 #     http://www.apache.org/licenses/LICENSE-2.0
-# 
+#
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -22,16 +22,16 @@ describe Chef::ResourceDefinition do
   before(:each) do
     @def = Chef::ResourceDefinition.new()
   end
-  
+
   describe "initialize" do
     it "should be a Chef::ResourceDefinition" do
       @def.should be_a_kind_of(Chef::ResourceDefinition)
     end
-    
+
     it "should not initialize a new node if one is not provided" do
       @def.node.should eql(nil)
     end
-    
+
     it "should accept a node as an argument" do
       node = Chef::Node.new
       node.name("bobo")
@@ -39,7 +39,7 @@ describe Chef::ResourceDefinition do
       @def.node.name.should == "bobo"
     end
   end
-  
+
   describe "node" do
     it "should set the node with node=" do
       node = Chef::Node.new
@@ -47,32 +47,32 @@ describe Chef::ResourceDefinition do
       @def.node = node
       @def.node.name.should == "bobo"
     end
-    
+
     it "should return the node" do
       @def.node = Chef::Node.new
       @def.node.should be_a_kind_of(Chef::Node)
     end
   end
-  
+
   it "should accept a new definition with a symbol for a name" do
-    lambda { 
-      @def.define :smoke do 
+    lambda {
+      @def.define :smoke do
       end
     }.should_not raise_error(ArgumentError)
-    lambda { 
+    lambda {
       @def.define "george washington" do
-      end 
+      end
     }.should raise_error(ArgumentError)
     @def.name.should eql(:smoke)
   end
-  
+
   it "should accept a new definition with a hash" do
-    lambda { 
+    lambda {
       @def.define :smoke, :cigar => "cuban", :cigarette => "marlboro" do
       end
     }.should_not raise_error(ArgumentError)
   end
-  
+
   it "should expose the prototype hash params in the params hash" do
     @def.define :smoke, :cigar => "cuban", :cigarette => "marlboro" do; end
     @def.params[:cigar].should eql("cuban")
@@ -86,34 +86,34 @@ describe Chef::ResourceDefinition do
     @def.recipe.should be_a_kind_of(Proc)
     @def.recipe.call.should eql("I am what I am")
   end
-  
+
   it "should set paramaters based on method_missing" do
     @def.mind "to fly"
     @def.params[:mind].should eql("to fly")
   end
-  
+
   it "should raise an exception if prototype_params is not a hash" do
     lambda {
       @def.define :monkey, Array.new do
       end
     }.should raise_error(ArgumentError)
   end
-  
+
   it "should raise an exception if define is called without a block" do
-    lambda { 
+    lambda {
       @def.define :monkey
     }.should raise_error(ArgumentError)
   end
-  
+
   it "should load a description from a file" do
     @def.from_file(File.join(CHEF_SPEC_DATA, "definitions", "test.rb"))
     @def.name.should eql(:rico_suave)
     @def.params[:rich].should eql("smooth")
-  end  
-  
+  end
+
   it "should turn itself into a string based on the name with to_s" do
     @def.name = :woot
     @def.to_s.should eql("woot")
   end
-  
+
 end

data/spec/unit/resource_reporter_spec.rb

@@ -464,6 +464,33 @@ describe Chef::ResourceReporter do
       end
     end
 
+    context "when including a resource that overrides Resource#state" do
+      before do
+        @current_state_resource = Chef::Resource::WithState.new("Stateful", @run_context)
+        @current_state_resource.state = nil
+
+        @new_state_resource = Chef::Resource::WithState.new("Stateful", @run_context)
+        @new_state_resource.state = "Running"
+        @resource_reporter.resource_action_start(@new_state_resource, :create)
+        @resource_reporter.resource_current_state_loaded(@new_state_resource, :create, @current_state_resource)
+        @resource_reporter.resource_updated(@new_state_resource, :create)
+        @resource_reporter.resource_completed(@new_state_resource)
+        @run_status.stop_clock
+        @report = @resource_reporter.prepare_run_data
+        @first_update_report = @report["resources"].first
+      end
+
+      it "sets before to {} instead of nil" do
+        @first_update_report.should have_key("before")
+        @first_update_report['before'].should eq({})
+      end
+
+      it "sets after to {} instead of 'Running'" do
+        @first_update_report.should have_key("after")
+        @first_update_report['after'].should eq({})
+      end
+    end
+
   end
 
   describe "when updating resource history on the server" do

data/spec/unit/rest/auth_credentials_spec.rb

@@ -199,100 +199,6 @@ describe Chef::REST::RESTRequest do
       new_request.http_client.read_timeout.should == 9001
     end
 
-    describe "for SSL" do
-      before do
-        Chef::Config[:ssl_client_cert] = nil
-        Chef::Config[:ssl_client_key]  = nil
-        Chef::Config[:ssl_ca_path]     = nil
-        Chef::Config[:ssl_ca_file]     = nil
-      end
-
-      after do
-        Chef::Config[:ssl_client_cert] = nil
-        Chef::Config[:ssl_client_key]  = nil
-        Chef::Config[:ssl_ca_path]     = nil
-        Chef::Config[:ssl_verify_mode] = :verify_none
-        Chef::Config[:ssl_ca_file]     = nil
-      end
-
-      describe "when configured with :ssl_verify_mode set to :verify peer" do
-        before do
-          @url = URI.parse("https://chef.example.com:4443/")
-          Chef::Config[:ssl_verify_mode] = :verify_peer
-          @request = new_request
-        end
-
-        it "configures the HTTP client to use SSL when given a URL with the https protocol" do
-          @request.http_client.use_ssl?.should be_true
-        end
-
-        it "sets the OpenSSL verify mode to verify_peer" do
-          @request.http_client.verify_mode.should == OpenSSL::SSL::VERIFY_PEER
-        end
-
-        it "raises a ConfigurationError if :ssl_ca_path is set to a path that doesn't exist" do
-          Chef::Config[:ssl_ca_path] = "/dev/null/nothing_here"
-          lambda {new_request}.should raise_error(Chef::Exceptions::ConfigurationError)
-        end
-
-        it "should set the CA path if that is set in the configuration" do
-          Chef::Config[:ssl_ca_path] = File.join(CHEF_SPEC_DATA, "ssl")
-          new_request.http_client.ca_path.should == File.join(CHEF_SPEC_DATA, "ssl")
-        end
-
-        it "raises a ConfigurationError if :ssl_ca_file is set to a file that does not exist" do
-          Chef::Config[:ssl_ca_file] = "/dev/null/nothing_here"
-          lambda {new_request}.should raise_error(Chef::Exceptions::ConfigurationError)
-        end
-
-        it "should set the CA file if that is set in the configuration" do
-          Chef::Config[:ssl_ca_file] = CHEF_SPEC_DATA + '/ssl/5e707473.0'
-          new_request.http_client.ca_file.should == CHEF_SPEC_DATA + '/ssl/5e707473.0'
-        end
-      end
-
-      describe "when configured with :ssl_verify_mode set to :verify peer" do
-        before do
-          @url = URI.parse("https://chef.example.com:4443/")
-          Chef::Config[:ssl_verify_mode] = :verify_none
-        end
-
-        it "sets the OpenSSL verify mode to :verify_none" do
-          new_request.http_client.verify_mode.should == OpenSSL::SSL::VERIFY_NONE
-        end
-      end
-
-      describe "when configured with a client certificate" do
-        before {@url = URI.parse("https://chef.example.com:4443/")}
-
-        it "raises ConfigurationError if the certificate file doesn't exist" do
-          Chef::Config[:ssl_client_cert] = "/dev/null/nothing_here"
-          Chef::Config[:ssl_client_key]  = CHEF_SPEC_DATA + '/ssl/chef-rspec.key'
-          lambda {new_request}.should raise_error(Chef::Exceptions::ConfigurationError)
-        end
-
-        it "raises ConfigurationError if the certificate file doesn't exist" do
-          Chef::Config[:ssl_client_cert] = CHEF_SPEC_DATA + '/ssl/chef-rspec.cert'
-          Chef::Config[:ssl_client_key]  = "/dev/null/nothing_here"
-          lambda {new_request}.should raise_error(Chef::Exceptions::ConfigurationError)
-        end
-
-        it "raises a ConfigurationError if one of :ssl_client_cert and :ssl_client_key is set but not both" do
-          Chef::Config[:ssl_client_cert] = "/dev/null/nothing_here"
-          Chef::Config[:ssl_client_key]  = nil
-          lambda {new_request}.should raise_error(Chef::Exceptions::ConfigurationError)
-        end
-
-        it "configures the HTTP client's cert and private key" do
-          Chef::Config[:ssl_client_cert] = CHEF_SPEC_DATA + '/ssl/chef-rspec.cert'
-          Chef::Config[:ssl_client_key]  = CHEF_SPEC_DATA + '/ssl/chef-rspec.key'
-          http_client = new_request.http_client
-          http_client.cert.to_s.should == OpenSSL::X509::Certificate.new(IO.read(CHEF_SPEC_DATA + '/ssl/chef-rspec.cert')).to_s
-          http_client.key.to_s.should  == IO.read(CHEF_SPEC_DATA + '/ssl/chef-rspec.key')
-        end
-      end
-    end
-
     describe "for proxy" do
       before do
         Chef::Config[:http_proxy]  = "http://proxy.example.com:3128"

data/spec/unit/rest_spec.rb

@@ -57,7 +57,7 @@ describe Chef::REST do
     @log_stringio = StringIO.new
     Chef::Log.init(@log_stringio)
 
-    Chef::REST::CookieJar.stub!(:instance).and_return({})
+    Chef::REST::CookieJar.stub(:instance).and_return({})
     @base_url   = "http://chef.example.com:4000"
     @monkey_uri = URI.parse("http://chef.example.com:4000/monkey")
     @rest = Chef::REST.new(@base_url, nil, nil)
@@ -65,6 +65,13 @@ describe Chef::REST do
     Chef::REST::CookieJar.instance.clear
   end
 
+  describe "legacy API" do
+    it 'responds to raw_http_request as a public method' do
+      @rest.public_methods.map(&:to_s).should include("raw_http_request")
+    end
+
+  end
+
 
   describe "calling an HTTP verb on a path or absolute URL" do
     it "adds a relative URL to the base url it was initialized with" do
@@ -76,27 +83,46 @@ describe Chef::REST do
     end
 
     it "makes a :GET request with the composed url object" do
-      @rest.should_receive(:api_request).with(:GET, @monkey_uri, {})
+      @rest.should_receive(:send_http_request).
+        with(:GET, @monkey_uri, STANDARD_READ_HEADERS, false).
+        and_return([1,2,3])
+      @rest.should_receive(:apply_response_middleware).with(1,2,3).and_return([1,2,3])
+      @rest.should_receive('success_response?'.to_sym).with(1).and_return(true)
       @rest.get_rest("monkey")
     end
 
     it "makes a :GET reqest for a streaming download with the composed url" do
-      @rest.should_receive(:streaming_request).with(@monkey_uri, {})
+      @rest.should_receive(:streaming_request).with('monkey', {})
       @rest.get_rest("monkey", true)
     end
 
-    it "makes a :DELETE  request with the composed url object" do
-      @rest.should_receive(:api_request).with(:DELETE, @monkey_uri, {})
+    STANDARD_READ_HEADERS = {"Accept"=>"application/json", "Accept"=>"application/json", "Accept-Encoding"=>"gzip;q=1.0,deflate;q=0.6,identity;q=0.3"}
+    STANDARD_WRITE_HEADERS = {"Accept"=>"application/json", "Content-Type"=>"application/json", "Accept"=>"application/json", "Accept-Encoding"=>"gzip;q=1.0,deflate;q=0.6,identity;q=0.3"}
+
+    it "makes a :DELETE request with the composed url object" do
+      @rest.should_receive(:send_http_request).
+        with(:DELETE, @monkey_uri, STANDARD_READ_HEADERS, false).
+        and_return([1,2,3])
+      @rest.should_receive(:apply_response_middleware).with(1,2,3).and_return([1,2,3])
+      @rest.should_receive('success_response?'.to_sym).with(1).and_return(true)
       @rest.delete_rest("monkey")
     end
 
     it "makes a :POST request with the composed url object and data" do
-      @rest.should_receive(:api_request).with(:POST, @monkey_uri, {}, "data")
+      @rest.should_receive(:send_http_request).
+        with(:POST, @monkey_uri, STANDARD_WRITE_HEADERS, "\"data\"").
+        and_return([1,2,3])
+      @rest.should_receive(:apply_response_middleware).with(1,2,3).and_return([1,2,3])
+      @rest.should_receive('success_response?'.to_sym).with(1).and_return(true)
       @rest.post_rest("monkey", "data")
     end
 
     it "makes a :PUT request with the composed url object and data" do
-      @rest.should_receive(:api_request).with(:PUT, @monkey_uri, {}, "data")
+      @rest.should_receive(:send_http_request).
+        with(:PUT, @monkey_uri, STANDARD_WRITE_HEADERS, "\"data\"").
+        and_return([1,2,3])
+      @rest.should_receive(:apply_response_middleware).with(1,2,3).and_return([1,2,3])
+      @rest.should_receive('success_response?'.to_sym).with(1).and_return(true)
       @rest.put_rest("monkey", "data")
     end
   end
@@ -156,13 +182,13 @@ describe Chef::REST do
       @url = URI.parse("https://one:80/?foo=bar")
 
       @http_response = Net::HTTPSuccess.new("1.1", "200", "successful rest req")
-      @http_response.stub!(:read_body)
-      @http_response.stub!(:body).and_return("ninja")
+      @http_response.stub(:read_body)
+      @http_response.stub(:body).and_return("ninja")
       @http_response.add_field("Content-Length", "5")
 
       @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)
+      Net::HTTP.stub(:new).and_return(@http_client)
+      @http_client.stub(:request).and_yield(@http_response).and_return(@http_response)
 
       @base_headers = { 'Accept' => 'application/json',
                         'X-Chef-Version' => Chef::VERSION,
@@ -172,23 +198,18 @@ describe Chef::REST do
 
     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)
+        @tempfile = StringIO.new
+        @tempfile.stub(:close!)
+        @tempfile.stub(:path).and_return("/a-temporary-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
-
-      after do
-        @tempfile.rspec_reset
-        @tempfile.close!
+        Net::HTTP::Get.stub(:new).and_return(@request_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}
+        expected_headers = {'Accept' => "*/*", '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
@@ -203,9 +224,9 @@ describe Chef::REST do
       end
 
       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)
+        @http_response.should_receive(:read_body).and_yield("ninja")
         @rest.streaming_request(@url, {})
+        #@tempfile.string.should include("ninja")
       end
 
       it "should close the tempfile if we're doing a raw request" do
@@ -214,15 +235,15 @@ describe Chef::REST do
       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.streaming_request(@url, {}) }.should_not raise_error(ZeroDivisionError)
+        @http_response.stub(:header).and_return({ 'Content-Length' => "5" })
+        @http_response.stub(:read_body).and_yield('')
+        lambda { @rest.streaming_request(@url, {}) }.should_not raise_error
       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)
+        @http_response.stub(:header).and_return({ 'Content-Length' => "0" })
+        @http_response.stub(:read_body).and_yield("ninja")
+        lambda { @rest.streaming_request(@url, {}) }.should_not raise_error
       end
 
     end
@@ -230,7 +251,7 @@ describe Chef::REST do
     describe "as JSON API requests" do
       before do
         @request_mock = {}
-        Net::HTTP::Get.stub!(:new).and_return(@request_mock)
+        Net::HTTP::Get.stub(:new).and_return(@request_mock)
 
         @base_headers = {"Accept" => "application/json",
           "X-Chef-Version" => Chef::VERSION,
@@ -240,14 +261,14 @@ describe Chef::REST do
 
       it "should always include the X-Chef-Version header" do
         Net::HTTP::Get.should_receive(:new).with("/?foo=bar", @base_headers).and_return(@request_mock)
-        @rest.api_request(:GET, @url, {})
+        @rest.request(:GET, @url, {})
       end
 
       it "sets the user agent to chef-client" do
         # must reset to default b/c knife changes the UA
         Chef::REST::RESTRequest.user_agent = Chef::REST::RESTRequest::DEFAULT_UA
-        @rest.api_request(:GET, @url, {})
-        @request_mock['User-Agent'].should match /^Chef Client\/#{Chef::VERSION}/
+        @rest.request(:GET, @url, {})
+        @request_mock['User-Agent'].should match(/^Chef Client\/#{Chef::VERSION}/)
       end
 
       # CHEF-3140
@@ -265,7 +286,7 @@ describe Chef::REST do
           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"
+          @rest.request(:GET, @url, {}).should == "ninja"
         end
       end
       context "when configured with custom http headers" do
@@ -285,19 +306,19 @@ describe Chef::REST do
           url_string = an_instance_of(String)
           header_hash = hash_including(@custom_headers)
           Net::HTTP::Get.should_receive(:new).with(url_string, header_hash)
-          @rest.api_request(:GET, @url, {})
+          @rest.request(:GET, @url, {})
         end
       end
 
       it "should set the cookie for this request if one exists for the given host:port" do
         Chef::REST::CookieJar.instance["#{@url.host}:#{@url.port}"] = "cookie monster"
         Net::HTTP::Get.should_receive(:new).with("/?foo=bar", @base_headers.merge('Cookie' => "cookie monster")).and_return(@request_mock)
-        @rest.api_request(:GET, @url, {})
+        @rest.request(:GET, @url, {})
       end
 
       it "should build a new HTTP GET request" do
         Net::HTTP::Get.should_receive(:new).with("/?foo=bar", @base_headers).and_return(@request_mock)
-        @rest.api_request(:GET, @url, {})
+        @rest.request(:GET, @url, {})
       end
 
       it "should build a new HTTP POST request" do
@@ -305,7 +326,7 @@ describe Chef::REST do
         expected_headers = @base_headers.merge("Content-Type" => 'application/json', 'Content-Length' => '13')
 
         Net::HTTP::Post.should_receive(:new).with("/?foo=bar", expected_headers).and_return(request)
-        @rest.api_request(:POST, @url, {}, {:one=>:two})
+        @rest.request(:POST, @url, {}, {:one=>:two})
         request.body.should == '{"one":"two"}'
       end
 
@@ -313,54 +334,54 @@ describe Chef::REST do
         request = Net::HTTP::Put.new(@url.path)
         expected_headers = @base_headers.merge("Content-Type" => 'application/json', 'Content-Length' => '13')
         Net::HTTP::Put.should_receive(:new).with("/?foo=bar",expected_headers).and_return(request)
-        @rest.api_request(:PUT, @url, {}, {:one=>:two})
+        @rest.request(:PUT, @url, {}, {:one=>:two})
         request.body.should == '{"one":"two"}'
       end
 
       it "should build a new HTTP DELETE request" do
         Net::HTTP::Delete.should_receive(:new).with("/?foo=bar", @base_headers).and_return(@request_mock)
-        @rest.api_request(:DELETE, @url)
+        @rest.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)
+        lambda { @rest.request(:MONKEY, @url) }.should raise_error(ArgumentError)
       end
 
       it "returns nil when the response is successful but content-type is not JSON" do
-        @rest.api_request(:GET, @url).should == "ninja"
+        @rest.request(:GET, @url).should == "ninja"
       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"}
+        @http_response.stub(:body).and_return('{"ohai2u":"json_api"}')
+        @rest.request(:GET, @url, {}).should == {"ohai2u"=>"json_api"}
       end
 
       %w[ HTTPFound HTTPMovedPermanently HTTPSeeOther HTTPUseProxy HTTPTemporaryRedirect HTTPMultipleChoice ].each do |resp_name|
-        it "should call api_request again on a #{resp_name} response" do
+        it "should call 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)
+          http_response.stub(:read_body)
 
-          @http_client.stub!(:request).and_yield(http_response).and_return(http_response)
+          @http_client.stub(:request).and_yield(http_response).and_return(http_response)
 
-          lambda { @rest.api_request(:GET, @url) }.should raise_error(Chef::Exceptions::RedirectLimitExceeded)
+          lambda { @rest.request(:GET, @url) }.should raise_error(Chef::Exceptions::RedirectLimitExceeded)
 
           [:PUT, :POST, :DELETE].each do |method|
-            lambda { @rest.api_request(method, @url) }.should raise_error(Chef::Exceptions::InvalidRedirect)
+            lambda { @rest.request(method, @url) }.should raise_error(Chef::Exceptions::InvalidRedirect)
           end
         end
       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)
+        http_response.stub(:read_body)
 
-        @http_client.stub!(:request).and_yield(http_response).and_return(http_response)
+        @http_client.stub(:request).and_yield(http_response).and_return(http_response)
 
-        @rest.api_request(:GET, @url).should be_false
+        @rest.request(:GET, @url).should be_false
       end
 
       describe "when the request fails" do
@@ -376,12 +397,12 @@ describe Chef::REST do
         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)
+          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.api_request(:GET, @url)}.should raise_error(Net::HTTPFatalError)
+          lambda {@rest.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
 
@@ -393,23 +414,23 @@ describe Chef::REST do
           gzipped_body = Zlib::Deflate.deflate(unzipped_body)
           gzipped_body.force_encoding(Encoding::BINARY) if "strings".respond_to?(:force_encoding)
 
-          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)
+          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)
 
-          lambda {@rest.api_request(:GET, @url)}.should raise_error(Net::HTTPFatalError)
+          lambda {@rest.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)
+          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.request(:GET, @url)}.should raise_error(Net::HTTPFatalError)
         end
       end
 
@@ -419,22 +440,21 @@ describe Chef::REST do
     context "when 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(:new).with("chef-rest").and_return(@tempfile)
         @request_mock = {}
-        Net::HTTP::Get.stub!(:new).and_return(@request_mock)
+        Net::HTTP::Get.stub(:new).and_return(@request_mock)
 
         @http_response = Net::HTTPSuccess.new("1.1",200, "it-works")
-        @http_response.stub!(:read_body)
-        @http_client.stub!(:request).and_yield(@http_response).and_return(@http_response)
+        @http_response.stub(:read_body)
+        @http_client.stub(:request).and_yield(@http_response).and_return(@http_response)
       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}
+        expected_headers = {'Accept' => "*/*", '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
@@ -444,7 +464,7 @@ describe Chef::REST do
       end
 
       it "writes the response body to a tempfile" do
-        @http_response.stub!(:read_body).and_yield("real").and_yield("ultimate").and_yield("power")
+        @http_response.stub(:read_body).and_yield("real").and_yield("ultimate").and_yield("power")
         @rest.streaming_request(@url, {})
         IO.read(@tempfile.path).chomp.should == "realultimatepower"
       end
@@ -455,7 +475,7 @@ describe Chef::REST do
       end
 
       it "yields the tempfile containing the streamed response body and then unlinks it when given a block" do
-        @http_response.stub!(:read_body).and_yield("real").and_yield("ultimate").and_yield("power")
+        @http_response.stub(:read_body).and_yield("real").and_yield("ultimate").and_yield("power")
         tempfile_path = nil
         @rest.streaming_request(@url, {}) do |tempfile|
           tempfile_path = tempfile.path
@@ -467,18 +487,18 @@ describe Chef::REST do
 
       it "does not raise a divide by zero exception if the content's actual size is 0" do
         @http_response.add_field('Content-Length', "5")
-        @http_response.stub!(:read_body).and_yield('')
-        lambda { @rest.streaming_request(@url, {}) }.should_not raise_error(ZeroDivisionError)
+        @http_response.stub(:read_body).and_yield('')
+        lambda { @rest.streaming_request(@url, {}) }.should_not raise_error
       end
 
       it "does not raise a divide by zero exception when the Content-Length is 0" do
         @http_response.add_field('Content-Length', "0")
-        @http_response.stub!(:read_body).and_yield("ninja")
-        lambda { @rest.streaming_request(@url, {}) }.should_not raise_error(ZeroDivisionError)
+        @http_response.stub(:read_body).and_yield("ninja")
+        lambda { @rest.streaming_request(@url, {}) }.should_not raise_error
       end
 
       it "fetches a file and yields the tempfile it is streamed to" do
-        @http_response.stub!(:read_body).and_yield("real").and_yield("ultimate").and_yield("power")
+        @http_response.stub(:read_body).and_yield("real").and_yield("ultimate").and_yield("power")
         tempfile_path = nil
         @rest.fetch("cookbooks/a_cookbook") do |tempfile|
           tempfile_path = tempfile.path
@@ -490,34 +510,32 @@ describe Chef::REST do
       it "closes and unlinks the tempfile if there is an error while streaming the content to the tempfile" do
         path = @tempfile.path
         path.should_not be_nil
-        @tempfile.stub!(:write).and_raise(IOError)
+        @tempfile.stub(:write).and_raise(IOError)
         @rest.fetch("cookbooks/a_cookbook") {|tmpfile| "shouldn't get here"}
         File.exists?(path).should be_false
       end
 
       it "closes and unlinks the tempfile when the response is a redirect" do
-        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)
+        tempfile = double("A tempfile", :path => "/tmp/ragefist", :close => true, :binmode => true)
+        tempfile.should_receive(:close!).at_least(1).times
+        Tempfile.stub(:new).with("chef-rest").and_return(tempfile)
 
-        http_response = Net::HTTPFound.new("1.1", "302", "bob is taking care of that one for me today")
-        http_response.add_field("location", @url.path)
-        http_response.stub!(:read_body)
+        redirect = Net::HTTPFound.new("1.1", "302", "bob is taking care of that one for me today")
+        redirect.add_field("location", @url.path)
+        redirect.stub(:read_body)
 
-        @http_client.stub!(:request).and_yield(http_response).and_yield(@http_response).and_return(http_response, @http_response)
+        @http_client.should_receive(:request).and_yield(redirect).and_return(redirect)
+        @http_client.should_receive(:request).and_yield(@http_response).and_return(@http_response)
         @rest.fetch("cookbooks/a_cookbook") {|tmpfile| "shouldn't get here"}
       end
 
       it "passes the original block to the redirected request" do
-        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")
-        http_response.stub!(:read_body)
+        http_response.stub(:read_body)
 
         block_called = false
-        @http_client.stub!(:request).and_yield(@http_response).and_return(http_response, @http_response)
+        @http_client.stub(:request).and_yield(@http_response).and_return(http_response, @http_response)
         @rest.fetch("cookbooks/a_cookbook") do |tmpfile|
           block_called = true
         end
@@ -546,9 +564,9 @@ describe Chef::REST do
           redirected.call unless total_redirects >= 9
         end
       end
-      lambda {redirected.call}.should_not raise_error(Chef::Exceptions::RedirectLimitExceeded)
+      lambda {redirected.call}.should_not raise_error
       total_redirects = 0
-      lambda {redirected.call}.should_not raise_error(Chef::Exceptions::RedirectLimitExceeded)
+      lambda {redirected.call}.should_not raise_error
     end
 
     it "does not sign the redirected request when sign_on_redirect is false" do
@@ -572,7 +590,7 @@ describe Chef::REST do
           redirected.call unless total_redirects >= 9
         end
       end
-      lambda {redirected.call}.should_not raise_error(Chef::Exceptions::RedirectLimitExceeded)
+      lambda {redirected.call}.should_not raise_error
 
       total_redirects = 0
       @rest.redirect_limit = 3