microwave 1.0.4 → 11.400.2

data/spec/unit/resource/log_spec.rb

@@ -38,6 +38,15 @@ describe Chef::Resource::Log do
   it "should allow you to set a log string" do
     @resource.name.should == @log_str
   end
+
+  it "should set the message to the first argument to new" do
+    @resource.message.should == @log_str
+  end
+
+  it "should accept a string for the log message" do
+    @resource.message "this is different"
+    @resource.message.should == "this is different"
+  end
   
   it "should accept a vaild level option" do
     @resource.level :debug

data/spec/unit/resource/registry_key_spec.rb

@@ -0,0 +1,171 @@
+#
+# Author:: Lamont Granquist (<lamont@opscode.com>)
+# Copyright:: Copyright (c) 2012 OpsCode, Inc.
+# License:: Apache License, Version 2.0
+#
+# 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.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+
+describe Chef::Resource::RegistryKey, "initialize" do
+  before(:each) do
+    @resource = Chef::Resource::RegistryKey.new('HKCU\Software\Raxicoricofallapatorius')
+  end
+
+  it "should create a new Chef::Resource::RegistryKey" do
+    @resource.should be_a_kind_of(Chef::Resource)
+    @resource.should be_a_kind_of(Chef::Resource::RegistryKey)
+  end
+
+  it "should set the resource_name to :registry_key" do
+    @resource.resource_name.should eql(:registry_key)
+  end
+
+  it "should set the key equal to the argument to initialize" do
+    @resource.key.should eql('HKCU\Software\Raxicoricofallapatorius')
+  end
+
+  it "should default recursive to false" do
+    @resource.recursive.should eql(false)
+  end
+
+  it "should default architecture to :machine" do
+    @resource.architecture.should eql(:machine)
+  end
+
+  it "should set action to :create" do
+    @resource.action.should eql(:create)
+  end
+
+  %w{create create_if_missing delete delete_key}.each do |action|
+    it "should allow action #{action}" do
+      @resource.allowed_actions.detect { |a| a == action.to_sym }.should eql(action.to_sym)
+    end
+  end
+end
+
+describe Chef::Resource::RegistryKey, "key" do
+  before(:each) do
+    @resource = Chef::Resource::RegistryKey.new('HKCU\Software\Raxicoricofallapatorius')
+  end
+
+  it "should allow a string" do
+    @resource.key 'HKCU\Software\Poosh'
+    @resource.key.should eql('HKCU\Software\Poosh')
+  end
+
+  it "should not allow an integer" do
+    lambda { @resource.send(:key, 100) }.should raise_error(ArgumentError)
+  end
+
+  it "should not allow a hash" do
+    lambda { @resource.send(:key, { :sonic => "screwdriver" }) }.should raise_error(ArgumentError)
+  end
+end
+
+describe Chef::Resource::RegistryKey, "values" do
+  before(:each) do
+    @resource = Chef::Resource::RegistryKey.new('HKCU\Software\Raxicoricofallapatorius')
+  end
+
+  it "should allow a single proper hash of registry values" do
+    @resource.values( { :name => 'poosh', :type => :string, :data => 'carmen' } )
+    @resource.values.should eql([ { :name => 'poosh', :type => :string, :data => 'carmen' } ])
+  end
+
+  it "should allow an array of proper hashes of registry values" do
+    @resource.values [ { :name => 'poosh', :type => :string, :data => 'carmen' } ]
+    @resource.values.should eql([ { :name => 'poosh', :type => :string, :data => 'carmen' } ])
+  end
+
+  it "should throw an exception if the name field is missing" do
+    lambda { @resource.values [ { :type => :string, :data => 'carmen' } ] }.should raise_error(ArgumentError)
+  end
+
+  it "should throw an exception if the type field is missing" do
+    lambda { @resource.values [ { :name => 'poosh', :data => 'carmen' } ] }.should raise_error(ArgumentError)
+  end
+
+  it "should throw an exception if the data field is missing" do
+    lambda { @resource.values [ { :name => 'poosh', :type => :string } ] }.should raise_error(ArgumentError)
+  end
+
+  it "should throw an exception if extra fields are present" do
+    lambda { @resource.values [ { :name => 'poosh', :type => :string, :data => 'carmen', :screwdriver => 'sonic' } ] }.should raise_error(ArgumentError)
+  end
+
+  it "should not allow a string" do
+    lambda { @resource.send(:values, 'souffle') }.should raise_error(ArgumentError)
+  end
+
+  it "should not allow an integer" do
+    lambda { @resource.send(:values, 100) }.should raise_error(ArgumentError)
+  end
+end
+
+describe Chef::Resource::RegistryKey, "recursive" do
+  before(:each) do
+    @resource = Chef::Resource::RegistryKey.new('HKCU\Software\Raxicoricofallapatorius')
+  end
+
+  it "should allow a boolean" do
+    @resource.recursive(true)
+    @resource.recursive.should eql(true)
+  end
+
+  it "should not allow a hash" do
+    lambda { @resource.recursive({:sonic => :screwdriver}) }.should raise_error(ArgumentError)
+  end
+
+  it "should not allow an array" do
+    lambda { @resource.recursive([:nose, :chin]) }.should raise_error(ArgumentError)
+  end
+
+  it "should not allow a string" do
+    lambda { @resource.recursive('souffle') }.should raise_error(ArgumentError)
+  end
+
+  it "should not allow an integer" do
+    lambda { @resource.recursive(100) }.should raise_error(ArgumentError)
+  end
+end
+
+describe Chef::Resource::RegistryKey, "architecture" do
+  before(:each) do
+    @resource = Chef::Resource::RegistryKey.new('HKCU\Software\Raxicoricofallapatorius')
+  end
+
+  [ :i386, :x86_64, :machine ].each do |arch|
+    it "should allow #{arch} as a symbol" do
+      @resource.architecture(arch)
+      @resource.architecture.should eql(arch)
+    end
+  end
+
+  it "should not allow a hash" do
+    lambda { @resource.architecture({:sonic => :screwdriver}) }.should raise_error(ArgumentError)
+  end
+
+  it "should not allow an array" do
+    lambda { @resource.architecture([:nose, :chin]) }.should raise_error(ArgumentError)
+  end
+
+  it "should not allow a string" do
+    lambda { @resource.architecture('souffle') }.should raise_error(ArgumentError)
+  end
+
+  it "should not allow an integer" do
+    lambda { @resource.architecture(100) }.should raise_error(ArgumentError)
+  end
+end

data/spec/unit/resource/remote_file_spec.rb

@@ -39,37 +39,35 @@ describe Chef::Resource::RemoteFile do
     Chef::Platform.find_provider(:noplatform, 'noversion', @resource).should == Chef::Provider::RemoteFile
   end
 
-  it "says its provider is CookbookFile when the source is a relative URI" do
-    @resource.source('seattle.txt')
-    @resource.provider.should == Chef::Provider::CookbookFile
-    Chef::Platform.find_provider(:noplatform, 'noversion', @resource).should == Chef::Provider::CookbookFile
-  end
-  
+
   describe "source" do
-    it "should accept a string for the remote file source" do
-      @resource.source "something"
-      @resource.source.should eql("something")
+    it "does not have a default value for 'source'" do
+      @resource.source.should be_nil
     end
 
-    it "should have a default based on the param name" do
-      @resource.source.should eql("fakey_fakerton")
+    it "should accept a URI for the remote file source" do
+      @resource.source "http://opscode.com/"
+      @resource.source.should eql([ "http://opscode.com/" ])
     end
 
-    it "should use only the basename of the file as the default" do
-      r = Chef::Resource::RemoteFile.new("/tmp/obit/fakey_fakerton")
-      r.source.should eql("fakey_fakerton")
+    it "should accept an array of URIs for the remote file source" do
+      @resource.source([ "http://opscode.com/", "http://puppetlabs.com/" ])
+      @resource.source.should eql([ "http://opscode.com/", "http://puppetlabs.com/" ])
     end
-  end
-  
-  describe "cookbook" do
-    it "should accept a string for the cookbook name" do
-      @resource.cookbook "something"
-      @resource.cookbook.should eql("something")
+
+    it "should accept an multiple URIs as arguments for the remote file source" do
+      @resource.source("http://opscode.com/", "http://puppetlabs.com/")
+      @resource.source.should eql([ "http://opscode.com/", "http://puppetlabs.com/" ])
     end
-    
-    it "should default to nil" do
-      @resource.cookbook.should == nil
+
+    it "does not accept a non-URI as the source" do
+      lambda { @resource.source("not-a-uri") }.should raise_error(Chef::Exceptions::InvalidRemoteFileURI)
     end
+
+    it "should raise and exception when source is an empty array" do
+      lambda { @resource.source([]) }.should raise_error(ArgumentError)
+    end
+
   end
 
   describe "checksum" do

data/spec/unit/resource/ruby_block_spec.rb

@@ -23,7 +23,7 @@ describe Chef::Resource::RubyBlock do
 
   before(:each) do
     @resource = Chef::Resource::RubyBlock.new("fakey_fakerton")
-  end  
+  end
 
   it "should create a new Chef::Resource::RubyBlock" do
     @resource.should be_a_kind_of(Chef::Resource)
@@ -31,7 +31,7 @@ describe Chef::Resource::RubyBlock do
   end
 
   it "should have a default action of 'create'" do
-    @resource.action.should eql("create")
+    @resource.action.should eql("run")
   end
   
   it "should have a resource name of :ruby_block" do
@@ -44,6 +44,11 @@ describe Chef::Resource::RubyBlock do
     end.call.should eql("foo")
   end
 
+  it "allows the action to be 'create'" do
+    @resource.action :create
+    @resource.action.should == [:create]
+  end
+
   describe "when it has been initialized with block code" do
     before do 
       @resource.block_name("puts 'harrrr'")
@@ -53,5 +58,4 @@ describe Chef::Resource::RubyBlock do
       @resource.identity.should == "puts 'harrrr'"
     end
   end
-
 end

data/spec/unit/resource/service_spec.rb

@@ -109,6 +109,17 @@ describe Chef::Resource::Service do
     }.should raise_error(ArgumentError)
   end
   
+  it "should accept a string for the service init command" do
+    @resource.init_command "/etc/init.d/chef"
+    @resource.init_command.should eql("/etc/init.d/chef")
+  end
+
+  it "should not accept a regexp for the service init command" do
+    lambda {
+      @resource.init_command /.*/
+    }.should raise_error(ArgumentError)
+  end
+
   %w{enabled running}.each do |attrib|
     it "should accept true for #{attrib}" do
       @resource.send(attrib, true) 

data/spec/unit/resource_spec.rb

@@ -273,6 +273,29 @@ describe Chef::Resource do
     end
   end
 
+  describe "defined_at" do
+    it "should correctly parse source_line on unix-like operating systems" do
+      @resource.source_line = "/some/path/to/file.rb:80:in `wombat_tears'"
+      @resource.defined_at.should == "/some/path/to/file.rb line 80"
+    end
+
+    it "should correctly parse source_line on Windows" do
+      @resource.source_line = "C:/some/path/to/file.rb:80 in 1`wombat_tears'"
+      @resource.defined_at.should == "C:/some/path/to/file.rb line 80"
+    end
+
+    it "should include the cookbook and recipe when it knows it" do
+      @resource.source_line = "/some/path/to/file.rb:80:in `wombat_tears'"
+      @resource.recipe_name = "wombats"
+      @resource.cookbook_name = "animals"
+      @resource.defined_at.should == "animals::wombats line 80"
+    end
+
+    it "should recognize dynamically defined resources" do
+      @resource.defined_at.should == "dynamically defined"
+    end
+  end
+
   describe "to_s" do
     it "should become a string like resource_name[name]" do
       zm = Chef::Resource::ZenMaster.new("coffee")
@@ -425,8 +448,8 @@ describe Chef::Resource do
     before do
       @resource = Chef::Resource.new("provided", @run_context)
       @resource.provider = Chef::Provider::SnakeOil
-      @node[:platform] = "fubuntu"
-      @node[:platform_version] = '10.04'
+      @node.automatic_attrs[:platform] = "fubuntu"
+      @node.automatic_attrs[:platform_version] = '10.04'
     end
 
     it "does not run only_if if no only_if command is given" do
@@ -522,8 +545,8 @@ describe Chef::Resource do
     before(:each) do
       @node = Chef::Node.new
       @node.name("bumblebee")
-      @node.platform("autobots")
-      @node.platform_version("6.1")
+      @node.automatic[:platform] = "autobots"
+      @node.automatic[:platform_version] = "6.1"
       Object.const_set('Soundwave', Class.new(Chef::Resource))
       Object.const_set('Grimlock', Class.new(Chef::Resource){ provides :dinobot, :on_platforms => ['autobots'] })
     end

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

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
@@ -153,184 +170,59 @@ describe Chef::REST do
       @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 = Tempfile.open("chef-rspec-rest_spec-line-#{__LINE__}--")
-          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!
-        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}
-          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_mock.stub!(:read_body).and_yield("ninja")
-          @tempfile.should_receive(:write).with("ninja").once.and_return(true)
-          @rest.run_request(:GET, @url, {}, false, nil, true)
-        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
@@ -358,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 = {
@@ -440,41 +350,66 @@ describe Chef::REST do
         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" ] }')
+      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)
-        @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'))
+        @rest.api_request(:GET, @url).should be_false
       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)
+      describe "when the request fails" do
+        before do
+          @original_log_level = Chef::Log.level
+          Chef::Log.level = :info
+        end
 
-        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
+        after do
+          Chef::Log.level = @original_log_level
+        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)
+        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.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 "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)
+
+          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)
+          @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
+
+
     end
 
     context "when streaming downloads to a tempfile" do