chef 11.10.0.alpha.1 → 11.10.0.rc.0

data/spec/unit/policy_builder_spec.rb

@@ -0,0 +1,26 @@
+#
+# Author:: Daniel DeLeo (<dan@getchef.com>)
+# Copyright:: Copyright 2014 Chef Software, 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'
+require 'chef/policy_builder'
+
+describe Chef::PolicyBuilder do
+
+  # TODO: test the strategy method
+
+end

data/spec/unit/provider/deploy_spec.rb

@@ -69,6 +69,7 @@ describe Chef::Provider::Deploy do
 
     it "creates deploy_to dir" do
       ::Dir.should_receive(:chdir).with(@expected_release_dir).exactly(4).times
+      @provider.should_receive(:enforce_ownership).twice
       @provider.stub(:update_cached_repo)
       @provider.deploy
     end
@@ -80,6 +81,7 @@ describe Chef::Provider::Deploy do
     ::Dir.should_receive(:chdir).with(@expected_release_dir).exactly(4).times
     FileUtils.should_not_receive(:mkdir_p).with(@resource.deploy_to)
     FileUtils.should_not_receive(:mkdir_p).with(@resource.shared_path)
+    @provider.should_receive(:enforce_ownership).twice
     @provider.stub(:copy_cached_repo)
     @provider.stub(:update_cached_repo)
     @provider.stub(:symlink)
@@ -94,6 +96,7 @@ describe Chef::Provider::Deploy do
     @provider.stub(:copy_cached_repo)
     @provider.stub(:update_cached_repo)
     @provider.stub(:install_gems)
+    @provider.should_receive(:enforce_ownership).ordered
     @provider.stub(:enforce_ownership)
     @provider.stub(:symlink)
     @provider.stub(:migrate)

data/spec/unit/provider/group/windows_spec.rb

@@ -55,6 +55,7 @@ describe Chef::Provider::Group::Windows do
       Chef::Util::Windows::NetGroup.stub!(:new).and_return(@net_group)
       @net_group.stub!(:local_add_members)
       @net_group.stub!(:local_set_members)
+      @provider.stub(:local_group_name_to_sid)
       @provider.current_resource = @current_resource
     end
 

data/spec/unit/provider/http_request_spec.rb

@@ -103,6 +103,8 @@ describe Chef::Provider::HttpRequest do
       end
     end
 
+    # CHEF-4762: we expect a nil return value for a "200 Success" response
+    # and false for a "304 Not Modified" response
     describe "action_head" do
       before do
         @provider.http = @http
@@ -110,17 +112,37 @@ describe Chef::Provider::HttpRequest do
 
       it "should inflate a message block at runtime" do
         @new_resource.message { "return" }
-        @http.should_receive(:head).with("http://www.opscode.com/?message=return", {}).and_return("")
+        @http.should_receive(:head).with("http://www.opscode.com/?message=return", {}).and_return(nil)
         @provider.run_action(:head)
         @new_resource.should be_updated
       end
 
       it "should run a HEAD request" do
+        @http.should_receive(:head).with("http://www.opscode.com/?message=is cool", {}).and_return(nil)
+        @provider.run_action(:head)
+        @new_resource.should be_updated
+      end
+
+      it "should update a HEAD request with empty string response body (CHEF-4762)" do
         @http.should_receive(:head).with("http://www.opscode.com/?message=is cool", {}).and_return("")
         @provider.run_action(:head)
         @new_resource.should be_updated
       end
 
+      it "should update a HEAD request with nil response body (CHEF-4762)" do
+        @http.should_receive(:head).with("http://www.opscode.com/?message=is cool", {}).and_return(nil)
+        @provider.run_action(:head)
+        @new_resource.should be_updated
+      end
+
+      it "should not update a HEAD request if a not modified response (CHEF-4762)" do
+        if_modified_since = File.mtime(__FILE__).httpdate
+        @new_resource.headers "If-Modified-Since" => if_modified_since
+        @http.should_receive(:head).with("http://www.opscode.com/?message=is cool", {"If-Modified-Since" => if_modified_since}).and_return(false)
+        @provider.run_action(:head)
+        @new_resource.should_not be_updated
+      end
+
       it "should run a HEAD request with If-Modified-Since header" do
         @new_resource.headers "If-Modified-Since" => File.mtime(__FILE__).httpdate
         @http.should_receive(:head).with("http://www.opscode.com/?message=is cool", @new_resource.headers)

data/spec/unit/provider/service/debian_service_spec.rb

@@ -126,11 +126,19 @@ describe Chef::Provider::Service::Debian do
      /etc/rc5.d/S20chef
      /etc/rc6.d/K20chef
           STDOUT
-          "stderr" => ""
+          "stderr" => "",
+          "priorities" => {
+            "0"=>[:stop, "20"],
+            "1"=>[:stop, "20"],
+            "2"=>[:start, "20"],
+            "3"=>[:start, "20"],
+            "4"=>[:start, "20"],
+            "5"=>[:start, "20"],
+            "6"=>[:stop, "20"]
+          }
         },
         "not linked" => {
-          "stdout" =>
-            " Removing any system startup links for /etc/init.d/chef ...",
+          "stdout" => " Removing any system startup links for /etc/init.d/chef ...",
           "stderr" => ""
         },
       },
@@ -147,20 +155,51 @@ insserv: remove service /etc/init.d/../rc0.d/K20chef-client
   insserv: remove service /etc/init.d/../rc6.d/K20chef-client
   insserv: dryrun, not creating .depend.boot, .depend.start, and .depend.stop
           STDERR
+          "priorities" => {
+            "0"=>[:stop, "20"],
+            "1"=>[:stop, "20"],
+            "2"=>[:start, "20"],
+            "3"=>[:start, "20"],
+            "4"=>[:start, "20"],
+            "5"=>[:start, "20"],
+            "6"=>[:stop, "20"]
+          }
         },
         "not linked" => {
           "stdout" => "update-rc.d: using dependency based boot sequencing",
           "stderr" => ""
         }
+      },
+      "Debian/Wheezy and earlier, a service only starting at run level S" => {
+        "linked" => {
+          "stdout" => "",
+          "stderr" => <<-STDERR,
+insserv: remove service /etc/init.d/../rc0.d/K06rpcbind
+insserv: remove service /etc/init.d/../rc1.d/K06rpcbind
+insserv: remove service /etc/init.d/../rc6.d/K06rpcbind
+insserv: remove service /etc/init.d/../rcS.d/S13rpcbind
+insserv: dryrun, not creating .depend.boot, .depend.start, and .depend.stop
+          STDERR
+          "priorities" => {
+            "0"=>[:stop, "06"],
+            "1"=>[:stop, "06"],
+            "6"=>[:stop, "06"],
+            "S"=>[:start, "13"]
+          }
+        },
+        "not linked" => {
+          "stdout" => "",
+          "stderr" => "insserv: dryrun, not creating .depend.boot, .depend.start, and .depend.stop"
+        }
       }
-    }.each do |model, streams|
+    }.each do |model, expected_results|
       context "on #{model}" do
         context "when update-rc.d shows init linked to rc*.d/" do
           before do
             @provider.stub!(:assert_update_rcd_available)
 
-            @stdout = StringIO.new(streams["linked"]["stdout"])
-            @stderr = StringIO.new(streams["linked"]["stderr"])
+            @stdout = StringIO.new(expected_results["linked"]["stdout"])
+            @stderr = StringIO.new(expected_results["linked"]["stderr"])
             @status = mock("Status", :exitstatus => 0, :stdout => @stdout)
             @provider.stub!(:shell_out!).and_return(@status)
             @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
@@ -178,22 +217,15 @@ insserv: remove service /etc/init.d/../rc0.d/K20chef-client
 
           it "stores the start/stop priorities of the service" do
             @provider.load_current_resource
-            expected_priorities = {"6"=>[:stop, "20"],
-              "0"=>[:stop, "20"],
-              "1"=>[:stop, "20"],
-              "2"=>[:start, "20"],
-              "3"=>[:start, "20"],
-              "4"=>[:start, "20"],
-              "5"=>[:start, "20"]}
-            @provider.current_resource.priority.should == expected_priorities
+            @provider.current_resource.priority.should == expected_results["linked"]["priorities"]
           end
         end
 
         context "when update-rc.d shows init isn't linked to rc*.d/" do
           before do
             @provider.stub!(:assert_update_rcd_available)
-            @stdout = StringIO.new(streams["not linked"]["stdout"])
-            @stderr = StringIO.new(streams["not linked"]["stderr"])
+            @stdout = StringIO.new(expected_results["not linked"]["stdout"])
+            @stderr = StringIO.new(expected_results["not linked"]["stderr"])
             @status = mock("Status", :exitstatus => 0, :stdout => @stdout)
             @provider.stub!(:shell_out!).and_return(@status)
             @provider.stub!(:popen4).and_yield(@pid, @stdin, @stdout, @stderr).and_return(@status)
@@ -244,6 +276,7 @@ insserv: remove service /etc/init.d/../rc0.d/K20chef-client
     context "when the service is enabled" do
       before do
         @current_resource.enabled(true)
+	@current_resource.priority(80)
       end
 
       context "and the service sets no priority" do
@@ -252,7 +285,6 @@ insserv: remove service /etc/init.d/../rc0.d/K20chef-client
 
       context "and the service requests the same priority as is set" do
         before do
-          @current_resource.priority(80)
           @new_resource.priority(80)
         end
         it_behaves_like "the service is up to date"
@@ -260,8 +292,7 @@ insserv: remove service /etc/init.d/../rc0.d/K20chef-client
 
       context "and the service requests a different priority than is set" do
         before do
-          @current_resource.priority(20)
-          @new_resource.priority(80)
+          @new_resource.priority(20)
         end
         it_behaves_like "the service is not up to date"
       end

data/spec/unit/recipe_spec.rb

@@ -193,6 +193,7 @@ describe Chef::Recipe do
 
   describe "include_recipe" do
     it "should evaluate another recipe with include_recipe" do
+      @node.should_receive(:loaded_recipe).with(:openldap, "gigantor")
       @run_context.include_recipe "openldap::gigantor"
       res = @run_context.resource_collection.resources(:cat => "blanket")
       res.name.should eql("blanket")
@@ -200,6 +201,7 @@ describe Chef::Recipe do
     end
 
     it "should load the default recipe for a cookbook if include_recipe is called without a ::" do
+      @node.should_receive(:loaded_recipe).with(:openldap, "default")
       @run_context.include_recipe "openldap"
       res = @run_context.resource_collection.resources(:cat => "blanket")
       res.name.should eql("blanket")
@@ -207,11 +209,13 @@ describe Chef::Recipe do
     end
 
     it "should store that it has seen a recipe in the run_context" do
+      @node.should_receive(:loaded_recipe).with(:openldap, "default")
       @run_context.include_recipe "openldap"
       @run_context.loaded_recipe?("openldap").should be_true
     end
 
     it "should not include the same recipe twice" do
+      @node.should_receive(:loaded_recipe).with(:openldap, "default").exactly(:once)
       @cookbook_collection[:openldap].should_receive(:load_recipe).with("default", @run_context)
       @recipe.include_recipe "openldap"
       @cookbook_collection[:openldap].should_not_receive(:load_recipe).with("default", @run_context)

data/spec/unit/resource/package_spec.rb

@@ -49,6 +49,11 @@ describe Chef::Resource::Package do
     @resource.response_file.should eql("something")
   end
 
+  it "should accept a hash for response file template variables" do
+    @resource.response_file_variables({:variables => true})
+    @resource.response_file_variables.should eql({:variables => true})
+  end
+
   it "should accept a string for the source" do
     @resource.source "something"
     @resource.source.should eql("something")

data/spec/unit/rest_spec.rb

@@ -53,70 +53,115 @@ Y6S6MeZ69Rp89ma4ttMZ+kwi1+XyHqC/dlcVRW42Zl5Dc7BALRlJjQ==
 -----END RSA PRIVATE KEY-----"
 
 describe Chef::REST do
-  before(:each) do
-    @log_stringio = StringIO.new
-    Chef::Log.init(@log_stringio)
+  let(:base_url) { "http://chef.example.com:4000" }
 
-    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)
+  let(:monkey_uri) { URI.parse("http://chef.example.com:4000/monkey") }
 
+  let(:log_stringio) { StringIO.new }
+
+  let(:rest) do
+    Chef::REST::CookieJar.stub(:instance).and_return({})
+    rest = Chef::REST.new(base_url, nil, nil)
     Chef::REST::CookieJar.instance.clear
+    rest
   end
 
+  before(:each) do
+    Chef::Log.init(log_stringio)
+  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
-      @rest.create_url("foo/bar/baz").should == URI.parse(@base_url + "/foo/bar/baz")
+      expect(rest.create_url("foo/bar/baz")).to eq(URI.parse(base_url + "/foo/bar/baz"))
     end
 
     it "replaces the base URL when given an absolute URL" do
-      @rest.create_url("http://chef-rulez.example.com:9000").should == URI.parse("http://chef-rulez.example.com:9000")
+      expect(rest.create_url("http://chef-rulez.example.com:9000")).to eq(URI.parse("http://chef-rulez.example.com:9000"))
     end
 
     it "makes a :GET request with the composed url object" do
-      @rest.should_receive(:send_http_request).
-        with(:GET, @monkey_uri, STANDARD_READ_HEADERS, false).
+      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")
+      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', {})
-      @rest.get_rest("monkey", true)
+      rest.should_receive(:streaming_request).with('monkey', {})
+      rest.get_rest("monkey", true)
     end
 
     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).
+      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")
+      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(:send_http_request).
-        with(:POST, @monkey_uri, STANDARD_WRITE_HEADERS, "\"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")
+      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(:send_http_request).
-        with(:PUT, @monkey_uri, STANDARD_WRITE_HEADERS, "\"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")
+      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
+
+  describe "legacy API" do
+    let(:rest) do
+      Chef::REST.new(base_url)
+    end
+
+    before(:each) do
+      Chef::Config[:node_name]  = "webmonkey.example.com"
+      Chef::Config[:client_key] = CHEF_SPEC_DATA + "/ssl/private_key.pem"
+    end
+
+    it 'responds to raw_http_request as a public method' do
+      expect(rest.public_methods.map(&:to_s)).to include("raw_http_request")
+    end
+
+    it 'calls the authn middleware' do
+      data = "\"secure data\""
+
+      auth_headers = STANDARD_WRITE_HEADERS.merge({"auth_done"=>"yep"})
+
+      rest.authenticator.should_receive(:handle_request).
+        with(:POST, monkey_uri, STANDARD_WRITE_HEADERS, data).
+        and_return([:POST, monkey_uri, auth_headers, data])
+      rest.should_receive(:send_http_request).
+        with(:POST, monkey_uri, auth_headers, data).
+        and_return([1,2,3])
+      rest.should_receive('success_response?'.to_sym).with(1).and_return(true)
+      rest.raw_http_request(:POST, monkey_uri, STANDARD_WRITE_HEADERS, data)
+    end
+
+    it 'sets correct authn headers' do
+      data = "\"secure data\""
+      method, uri, auth_headers, d = rest.authenticator.handle_request(:POST, monkey_uri, STANDARD_WRITE_HEADERS, data)
+
+      rest.should_receive(:send_http_request).
+        with(:POST, monkey_uri, auth_headers, data).
+        and_return([1,2,3])
+      rest.should_receive('success_response?'.to_sym).with(1).and_return(true)
+      rest.raw_http_request(:POST, monkey_uri, STANDARD_WRITE_HEADERS, data)
     end
   end
 
@@ -137,202 +182,185 @@ describe Chef::REST do
       auth_headers = STANDARD_WRITE_HEADERS.merge({"auth_done"=>"yep"})
 
       @rest.authenticator.should_receive(:handle_request).
-        with(:POST, @monkey_uri, STANDARD_WRITE_HEADERS, data).
-        and_return([:POST, @monkey_uri, auth_headers, data])
+        with(:POST, monkey_uri, STANDARD_WRITE_HEADERS, data).
+        and_return([:POST, monkey_uri, auth_headers, data])
       @rest.should_receive(:send_http_request).
-        with(:POST, @monkey_uri, auth_headers, data).
+        with(:POST, monkey_uri, auth_headers, data).
         and_return([1,2,3])
       @rest.should_receive('success_response?'.to_sym).with(1).and_return(true)
-      @rest.raw_http_request(:POST, @monkey_uri, STANDARD_WRITE_HEADERS, data)
+      @rest.raw_http_request(:POST, monkey_uri, STANDARD_WRITE_HEADERS, data)
     end
 
     it 'sets correct authn headers' do
       data = "\"secure data\""
-      method, uri, auth_headers, d = @rest.authenticator.handle_request(:POST, @monkey_uri, STANDARD_WRITE_HEADERS, data)
+      method, uri, auth_headers, d = @rest.authenticator.handle_request(:POST, monkey_uri, STANDARD_WRITE_HEADERS, data)
 
       @rest.should_receive(:send_http_request).
-        with(:POST, @monkey_uri, auth_headers, data).
+        with(:POST, monkey_uri, auth_headers, data).
         and_return([1,2,3])
       @rest.should_receive('success_response?'.to_sym).with(1).and_return(true)
-      @rest.raw_http_request(:POST, @monkey_uri, STANDARD_WRITE_HEADERS, data)
+      @rest.raw_http_request(:POST, monkey_uri, STANDARD_WRITE_HEADERS, data)
     end
   end
 
 
   describe "when configured to authenticate to the Chef server" do
+    let(:base_url) { URI.parse("http://chef.example.com:4000") }
+
+    let(:rest) do
+      Chef::REST.new(base_url)
+    end
+
     before do
-      @url = URI.parse("http://chef.example.com:4000")
       Chef::Config[:node_name]  = "webmonkey.example.com"
       Chef::Config[:client_key] = CHEF_SPEC_DATA + "/ssl/private_key.pem"
-      @rest = Chef::REST.new(@url)
     end
 
     it "configures itself to use the node_name and client_key in the config by default" do
-      @rest.client_name.should == "webmonkey.example.com"
-      @rest.signing_key_filename.should == CHEF_SPEC_DATA + "/ssl/private_key.pem"
+      expect(rest.client_name).to eq("webmonkey.example.com")
+      expect(rest.signing_key_filename).to eq(CHEF_SPEC_DATA + "/ssl/private_key.pem")
     end
 
     it "provides access to the raw key data" do
-      @rest.signing_key.should == SIGNING_KEY_DOT_PEM
+      expect(rest.signing_key).to eq(SIGNING_KEY_DOT_PEM)
     end
 
     it "does not error out when initialized without credentials" do
-      @rest = Chef::REST.new(@url, nil, nil) #should_not raise_error hides the bt from you, so screw it.
-      @rest.client_name.should be_nil
-      @rest.signing_key.should be_nil
+      rest = Chef::REST.new(base_url, nil, nil) #should_not raise_error hides the bt from you, so screw it.
+      expect(rest.client_name).to be_nil
+      expect(rest.signing_key).to be_nil
     end
 
     it "indicates that requests should not be signed when it has no credentials" do
-      @rest = Chef::REST.new(@url, nil, nil)
-      @rest.sign_requests?.should be_false
+      rest = Chef::REST.new(base_url, nil, nil)
+      expect(rest.sign_requests?).to 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)
+      expect {Chef::REST.new(base_url, "client-name", "/dev/null/nothing_here")}.to 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)
+      expect {Chef::REST.new(base_url, "client-name", invalid_key_file)}.to 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
+      expect(Chef::REST.new(base_url, "client-name", nil, :raw_key => SIGNING_KEY_DOT_PEM).signing_key).to eq(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)
+      expect {Chef::REST.new(base_url, "client-name", nil, :raw_key => "bad key string")}.to raise_error(Chef::Exceptions::InvalidPrivateKey)
     end
 
   end
 
   context "when making REST requests" do
-    before(:each) do
-      Chef::Config[:ssl_client_cert] = nil
-      Chef::Config[:ssl_client_key]  = nil
-      @url = URI.parse("https://one:80/?foo=bar")
-
-      @host_header = "one:80"
-
-      @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.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)
-
-      @base_headers = { 'Accept' => 'application/json',
-                        'X-Chef-Version' => Chef::VERSION,
-                        'Accept-Encoding' => Chef::REST::RESTRequest::ENCODING_GZIP_DEFLATE}
-      @req_with_body_headers = @base_headers.merge("Content-Type" => "application/json", "Content-Length" => '13')
+    let(:body) { "ninja" }
+
+    let(:http_response) do
+      http_response = Net::HTTPSuccess.new("1.1", "200", "successful rest req")
+      http_response.stub(:read_body)
+      http_response.stub(:body).and_return(body)
+      http_response["Content-Length"] = body.bytesize.to_s
+      http_response
     end
 
-    describe "streaming downloads to a tempfile" do
-      before do
-        @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)
-      end
-
-      it "should build a new HTTP GET request without the application/json accept header" do
-        expected_headers = {'Accept' => "*/*",
-                            'X-Chef-Version' => Chef::VERSION,
-                            'Accept-Encoding' => Chef::REST::RESTRequest::ENCODING_GZIP_DEFLATE,
-                            'Host' => @host_header}
-        Net::HTTP::Get.should_receive(:new).with("/?foo=bar", expected_headers).and_return(@request_mock)
-        @rest.streaming_request(@url, {})
-      end
+    let(:host_header) { "one:80" }
 
-      it "should create a tempfile for the output of a raw request" do
-        @rest.streaming_request(@url, {}).should equal(@tempfile)
-      end
+    let(:url) { URI.parse("https://one:80/?foo=bar") }
 
-      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
+    let(:base_url) { "http://chef.example.com:4000" }
 
-      it "should populate the tempfile with the value of the raw request" do
-        @http_response.should_receive(:read_body).and_yield("ninja")
-        @rest.streaming_request(@url, {})
-        #@tempfile.string.should include("ninja")
-      end
+    let!(:http_client) do
+      http_client = Net::HTTP.new(url.host, url.port)
+      http_client.stub(:request).and_yield(http_response).and_return(http_response)
+      http_client
+    end
 
-      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
+    let(:rest) do
+      Net::HTTP.stub(:new).and_return(http_client)
+      Chef::REST::CookieJar.stub(:instance).and_return({})
+      rest = Chef::REST.new(base_url, nil, nil)
+      Chef::REST::CookieJar.instance.clear
+      rest
+    end
 
-      it "should not raise a divide by zero exception if the size is 0" do
-        @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
+    let(:base_headers) do
+      {
+        'Accept' => 'application/json',
+        'X-Chef-Version' => Chef::VERSION,
+        'Accept-Encoding' => Chef::REST::RESTRequest::ENCODING_GZIP_DEFLATE,
+      }
+    end
 
-      it "should not raise a divide by zero exception if the Content-Length is 0" do
-        @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
+    let (:req_with_body_headers) do
+      base_headers.merge("Content-Type" => "application/json", "Content-Length" => '13')
+    end
 
+    before(:each) do
+      Chef::Config[:ssl_client_cert] = nil
+      Chef::Config[:ssl_client_key]  = nil
     end
 
     describe "as JSON API requests" do
-      before do
-        @request_mock = {}
-        Net::HTTP::Get.stub(:new).and_return(@request_mock)
-
-        @base_headers = {"Accept" => "application/json",
-          "X-Chef-Version" => Chef::VERSION,
-          "Accept-Encoding" => Chef::REST::RESTRequest::ENCODING_GZIP_DEFLATE,
-          "Host" => @host_header
+      let(:request_mock) { {} }
+
+      let(:base_headers) do  #FIXME: huh?
+        {
+          'Accept' => 'application/json',
+          'X-Chef-Version' => Chef::VERSION,
+          'Accept-Encoding' => Chef::REST::RESTRequest::ENCODING_GZIP_DEFLATE,
+          'Host' => host_header,
         }
       end
 
+      before do
+        Net::HTTP::Get.stub(:new).and_return(request_mock)
+      end
+
       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.request(:GET, @url, {})
+        Net::HTTP::Get.should_receive(:new).with("/?foo=bar", base_headers).and_return(request_mock)
+        rest.request(:GET, url, {})
       end
 
       it "sets the user agent to chef-client" do
-        # must reset to default b/c knife changes the UA
+        # XXX: must reset to default b/c knife changes the UA
         Chef::REST::RESTRequest.user_agent = Chef::REST::RESTRequest::DEFAULT_UA
-        @rest.request(:GET, @url, {})
-        @request_mock['User-Agent'].should match(/^Chef Client\/#{Chef::VERSION}/)
+        rest.request(:GET, url, {})
+        expect(request_mock['User-Agent']).to 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)
+        let(:rest) do
+          Net::HTTP.stub(:new).and_return(http_client)
+          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")
+          expect(rest.send(:build_headers, :GET, url, {})).not_to 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)
+          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.request(:GET, @url, {}).should == "ninja"
+          expect(rest.request(:GET, url, {})).to eq("ninja")
         end
       end
+
       context "when configured with custom http headers" do
-        before(:each) do
-          @custom_headers = {
+        let(:custom_headers) do
+          {
             'X-Custom-ChefSecret' => 'sharpknives',
             'X-Custom-RequestPriority' => 'extremely low'
           }
-          Chef::Config[:custom_http_headers] = @custom_headers
+        end
+
+        before(:each) do
+          Chef::Config[:custom_http_headers] = custom_headers
         end
 
         after(:each) do
@@ -341,84 +369,111 @@ describe Chef::REST do
 
         it "should set them on the http request" do
           url_string = an_instance_of(String)
-          header_hash = hash_including(@custom_headers)
+          header_hash = hash_including(custom_headers)
           Net::HTTP::Get.should_receive(:new).with(url_string, header_hash)
-          @rest.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.request(:GET, @url, {})
+      context "when setting cookies" do
+        let(:rest) do
+          Net::HTTP.stub(:new).and_return(http_client)
+          Chef::REST::CookieJar.instance["#{url.host}:#{url.port}"] = "cookie monster"
+          rest = Chef::REST.new(base_url, nil, nil)
+          rest
+        end
+
+        it "should set the cookie for this request if one exists for the given host:port" do
+          Net::HTTP::Get.should_receive(:new).with("/?foo=bar", base_headers.merge('Cookie' => "cookie monster")).and_return(request_mock)
+          rest.request(:GET, url, {})
+        end
       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.request(:GET, @url, {})
+        Net::HTTP::Get.should_receive(:new).with("/?foo=bar", base_headers).and_return(request_mock)
+        rest.request(:GET, url, {})
       end
 
       it "should build a new HTTP POST request" do
-        request = Net::HTTP::Post.new(@url.path)
-        expected_headers = @base_headers.merge("Content-Type" => 'application/json', 'Content-Length' => '13')
+        request = Net::HTTP::Post.new(url.path)
+        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.request(:POST, @url, {}, {:one=>:two})
-        request.body.should == '{"one":"two"}'
+        rest.request(:POST, url, {}, {:one=>:two})
+        expect(request.body).to eq('{"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-Type" => 'application/json', 'Content-Length' => '13')
+        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.request(:PUT, @url, {}, {:one=>:two})
-        request.body.should == '{"one":"two"}'
+        rest.request(:PUT, url, {}, {:one=>:two})
+        expect(request.body).to eq('{"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.request(:DELETE, @url)
+        Net::HTTP::Delete.should_receive(:new).with("/?foo=bar", base_headers).and_return(request_mock)
+        rest.request(:DELETE, url)
       end
 
       it "should raise an error if the method is not GET/PUT/POST/DELETE" do
-        lambda { @rest.request(:MONKEY, @url) }.should raise_error(ArgumentError)
+        expect { rest.request(:MONKEY, url) }.to raise_error(ArgumentError)
       end
 
       it "returns nil when the response is successful but content-type is not JSON" do
-        @rest.request(:GET, @url).should == "ninja"
+        expect(rest.request(:GET, url)).to eq("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.request(:GET, @url, {}).should == {"ohai2u"=>"json_api"}
+      it "should fail if the response is truncated" do
+        http_response["Content-Length"] = (body.bytesize + 99).to_s
+        expect { rest.request(:GET, url) }.to raise_error(Chef::Exceptions::ContentLengthMismatch)
       end
 
-      %w[ HTTPFound HTTPMovedPermanently HTTPSeeOther HTTPUseProxy HTTPTemporaryRedirect HTTPMultipleChoice ].each do |resp_name|
-        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)
+      context "when JSON is returned" do
+        let(:body) { '{"ohai2u":"json_api"}' }
+        it "should inflate the body as to an object" do
+          http_response.add_field('content-type', "application/json")
+          expect(rest.request(:GET, url, {})).to eq({"ohai2u"=>"json_api"})
+        end
 
-          @http_client.stub(:request).and_yield(http_response).and_return(http_response)
+        it "should fail if the response is truncated" do
+          http_response.add_field('content-type', "application/json")
+          http_response["Content-Length"] = (body.bytesize + 99).to_s
+          expect { rest.request(:GET, url, {}) }.to raise_error(Chef::Exceptions::ContentLengthMismatch)
+        end
+      end
+
+      %w[ HTTPFound HTTPMovedPermanently HTTPSeeOther HTTPUseProxy HTTPTemporaryRedirect HTTPMultipleChoice ].each do |resp_name|
+        describe "when encountering a #{resp_name} redirect" do
+          let(:http_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
+          end
+          it "should call request again" do
 
-          lambda { @rest.request(:GET, @url) }.should raise_error(Chef::Exceptions::RedirectLimitExceeded)
+            expect { rest.request(:GET, url) }.to raise_error(Chef::Exceptions::RedirectLimitExceeded)
 
-          [:PUT, :POST, :DELETE].each do |method|
-            lambda { @rest.request(method, @url) }.should raise_error(Chef::Exceptions::InvalidRedirect)
+            [:PUT, :POST, :DELETE].each do |method|
+              expect { rest.request(method, url) }.to raise_error(Chef::Exceptions::InvalidRedirect)
+            end
           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_client.stub(:request).and_yield(http_response).and_return(http_response)
+      context "when the response is 304 NotModified" do
+        let (:http_response) 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
+        end
 
-        @rest.request(:GET, @url).should be_false
+        it "should return `false`" do
+          expect(rest.request(:GET, url)).to be_false
+        end
       end
 
       describe "when the request fails" do
@@ -431,128 +486,167 @@ describe Chef::REST do
           Chef::Log.level = @original_log_level
         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)
+        context "on an unsuccessful response with a JSON error" do
+          let(:http_response) 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_response
+          end
 
-          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 show the JSON error message" do
+            rest.stub(:sleep)
 
-        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)
+            expect {rest.request(:GET, url)}.to raise_error(Net::HTTPFatalError)
+            expect(log_stringio.string).to match(Regexp.escape('INFO: HTTP Request Returned 500 drooling from inside of mouth: Ears get sore!, Not even four'))
+          end
+        end
 
-          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)
+        context "on an unsuccessful response with a JSON error that is compressed" do
+          let(:http_response) 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)
+            http_response
+          end
+          it "decompresses the JSON error message" do
+            rest.stub(:sleep)
+            rest.stub(:http_retry_count).and_return(0)
 
-          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'))
+            expect {rest.request(:GET, url)}.to raise_error(Net::HTTPFatalError)
+            expect(log_stringio.string).to match(Regexp.escape('INFO: HTTP Request Returned 500 drooling from inside of mouth: Ears get sore!, Not even four'))
+          end
+          it "fails when the compressed body is truncated" do
+            http_response["Content-Length"] = (body.bytesize + 99).to_s
+            expect {rest.request(:GET, url)}.to raise_error(Chef::Exceptions::ContentLengthMismatch)
+          end
         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.request(:GET, @url)}.should raise_error(Net::HTTPFatalError)
+        context "on a generic unsuccessful request" do
+          let(:http_response) do
+            http_response = Net::HTTPServerError.new("1.1", "500", "drooling from inside of mouth")
+            http_response.stub(:body)
+            http_response.stub(:read_body)
+            http_response
+          end
+          it "throws an exception" do
+            rest.stub(:sleep)
+            expect {rest.request(:GET, url)}.to raise_error(Net::HTTPFatalError)
+          end
         end
       end
-
-
     end
 
     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)
-        @request_mock = {}
-        Net::HTTP::Get.stub(:new).and_return(@request_mock)
+      let!(:tempfile) {  Tempfile.open("chef-rspec-rest_spec-line-@{__LINE__}--") }
+
+      let(:request_mock) { {} }
+
+      let(:http_response) do
+        http_response = Net::HTTPSuccess.new("1.1",200, "it-works")
+
+        http_response.stub(:read_body)
+        http_response.should_not_receive(:body)
+        http_response["Content-Length"] = "0" # call set_content_length (in test), if otherwise
+        http_response
+      end
+
+      def set_content_length
+        content_length = 0
+        http_response.read_body do |chunk|
+          content_length += chunk.bytesize
+        end
+        http_response["Content-Length"] = content_length.to_s
+      end
 
-        @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)
+      before do
+        Tempfile.stub(:new).with("chef-rest").and_return(tempfile)
+        Net::HTTP::Get.stub(:new).and_return(request_mock)
       end
 
       after do
-        @tempfile.close!
+        tempfile.close!
       end
 
       it " build a new HTTP GET request without the application/json accept header" do
         expected_headers = {'Accept' => "*/*",
                             'X-Chef-Version' => Chef::VERSION,
                             'Accept-Encoding' => Chef::REST::RESTRequest::ENCODING_GZIP_DEFLATE,
-                            'Host' => @host_header}
-        Net::HTTP::Get.should_receive(:new).with("/?foo=bar", expected_headers).and_return(@request_mock)
-        @rest.streaming_request(@url, {})
+                            'Host' => host_header}
+        Net::HTTP::Get.should_receive(:new).with("/?foo=bar", expected_headers).and_return(request_mock)
+        rest.streaming_request(url, {})
       end
 
       it "returns a tempfile containing the streamed response body" do
-        @rest.streaming_request(@url, {}).should equal(@tempfile)
+        expect(rest.streaming_request(url, {})).to equal(tempfile)
       end
 
       it "writes the response body to a tempfile" do
-        @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"
+        http_response.stub(:read_body).and_yield("real").and_yield("ultimate").and_yield("power")
+        set_content_length
+        rest.streaming_request(url, {})
+        expect(IO.read(tempfile.path).chomp).to eq("realultimatepower")
       end
 
       it "closes the tempfile" do
-        @rest.streaming_request(@url, {})
-        @tempfile.should be_closed
+        rest.streaming_request(url, {})
+        expect(tempfile).to be_closed
       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")
+        set_content_length
         tempfile_path = nil
-        @rest.streaming_request(@url, {}) do |tempfile|
+        rest.streaming_request(url, {}) do |tempfile|
           tempfile_path = tempfile.path
-          File.exist?(tempfile.path).should be_true
-          IO.read(@tempfile.path).chomp.should == "realultimatepower"
+          expect(File.exist?(tempfile.path)).to be_true
+          expect(IO.read(tempfile.path).chomp).to eq("realultimatepower")
         end
-        File.exist?(tempfile_path).should be_false
+        expect(File.exist?(tempfile_path)).to be_false
       end
 
       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
+        http_response['Content-Length'] = "5"
+        http_response.stub(:read_body).and_yield('')
+        expect { rest.streaming_request(url, {}) }.to_not raise_error(ZeroDivisionError)
       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
+        http_response['Content-Length'] = "0"
+        http_response.stub(:read_body).and_yield("ninja")
+        expect { rest.streaming_request(url, {}) }.to_not raise_error(ZeroDivisionError)
+      end
+
+      it "it raises an exception when the download is truncated" do
+        http_response["Content-Length"] = (body.bytesize + 99).to_s
+        http_response.stub(:read_body).and_yield("ninja")
+        expect { rest.streaming_request(url, {}) }.to raise_error(Chef::Exceptions::ContentLengthMismatch)
       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")
+        set_content_length
         tempfile_path = nil
-        @rest.fetch("cookbooks/a_cookbook") do |tempfile|
+        rest.fetch("cookbooks/a_cookbook") do |tempfile|
           tempfile_path = tempfile.path
-          IO.read(@tempfile.path).chomp.should == "realultimatepower"
+          expect(IO.read(tempfile.path).chomp).to eq("realultimatepower")
         end
-        File.exist?(tempfile_path).should be_false
+        expect(File.exist?(tempfile_path)).to be_false
       end
 
       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)
-        @rest.fetch("cookbooks/a_cookbook") {|tmpfile| "shouldn't get here"}
-        File.exists?(path).should be_false
+        path = tempfile.path
+        expect(path).not_to be_nil
+        tempfile.stub(:write).and_raise(IOError)
+        rest.fetch("cookbooks/a_cookbook") {|tmpfile| "shouldn't get here"}
+        expect(File.exists?(path)).to be_false
       end
 
       it "closes and unlinks the tempfile when the response is a redirect" do
@@ -561,80 +655,83 @@ describe Chef::REST do
         Tempfile.stub(:new).with("chef-rest").and_return(tempfile)
 
         redirect = Net::HTTPFound.new("1.1", "302", "bob is taking care of that one for me today")
-        redirect.add_field("location", @url.path)
+        redirect.add_field("location", url.path)
         redirect.stub(:read_body)
 
-        @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"}
+        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
-        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_redirect = Net::HTTPFound.new("1.1", "302", "bob is taking care of that one for me today")
+        http_redirect.add_field("location","/that-thing-is-here-now")
+        http_redirect.stub(:read_body)
 
         block_called = false
-        @http_client.stub(:request).and_yield(@http_response).and_return(http_response, @http_response)
-        @rest.fetch("cookbooks/a_cookbook") do |tmpfile|
+        http_client.stub(:request).and_yield(http_response).and_return(http_redirect, http_response)
+        rest.fetch("cookbooks/a_cookbook") do |tmpfile|
           block_called = true
         end
-        block_called.should be_true
+        expect(block_called).to be_true
       end
     end
   end
 
   context "when following redirects" do
+    let(:rest) do
+      Chef::REST.new(base_url)
+    end
+
     before do
       Chef::Config[:node_name]  = "webmonkey.example.com"
       Chef::Config[:client_key] = CHEF_SPEC_DATA + "/ssl/private_key.pem"
-      @rest = Chef::REST.new(@url)
     end
 
     it "raises a RedirectLimitExceeded when redirected more than 10 times" do
-      redirected = lambda {@rest.follow_redirect { redirected.call }}
-      lambda {redirected.call}.should raise_error(Chef::Exceptions::RedirectLimitExceeded)
+      redirected = lambda {rest.follow_redirect { redirected.call }}
+      expect {redirected.call}.to raise_error(Chef::Exceptions::RedirectLimitExceeded)
     end
 
     it "does not count redirects from previous calls against the redirect limit" do
       total_redirects = 0
       redirected = lambda do
-        @rest.follow_redirect do
+        rest.follow_redirect do
           total_redirects += 1
           redirected.call unless total_redirects >= 9
         end
       end
-      lambda {redirected.call}.should_not raise_error
+      expect {redirected.call}.not_to raise_error
       total_redirects = 0
-      lambda {redirected.call}.should_not raise_error
+      expect {redirected.call}.not_to raise_error
     end
 
     it "does not sign the redirected request when sign_on_redirect is false" do
-      @rest.sign_on_redirect = false
-      @rest.follow_redirect { @rest.sign_requests?.should be_false }
+      rest.sign_on_redirect = false
+      rest.follow_redirect { expect(rest.sign_requests?).to be_false }
     end
 
     it "resets sign_requests to the original value after following an unsigned redirect" do
-      @rest.sign_on_redirect = false
-      @rest.sign_requests?.should be_true
+      rest.sign_on_redirect = false
+      expect(rest.sign_requests?).to be_true
 
-      @rest.follow_redirect { @rest.sign_requests?.should be_false }
-      @rest.sign_requests?.should be_true
+      rest.follow_redirect { expect(rest.sign_requests?).to be_false }
+      expect(rest.sign_requests?).to be_true
     end
 
     it "configures the redirect limit" do
       total_redirects = 0
       redirected = lambda do
-        @rest.follow_redirect do
+        rest.follow_redirect do
           total_redirects += 1
           redirected.call unless total_redirects >= 9
         end
       end
-      lambda {redirected.call}.should_not raise_error
+      expect {redirected.call}.not_to raise_error
 
       total_redirects = 0
-      @rest.redirect_limit = 3
-      lambda {redirected.call}.should raise_error(Chef::Exceptions::RedirectLimitExceeded)
+      rest.redirect_limit = 3
+      expect {redirected.call}.to raise_error(Chef::Exceptions::RedirectLimitExceeded)
     end
 
   end