chef 12.0.0.alpha.2-x86-mingw32 → 12.0.0.rc.0-x86-mingw32

data/spec/unit/resource_reporter_spec.rb

@@ -421,7 +421,7 @@ describe Chef::ResourceReporter do
 
       it "includes the run_list" do
         @report.should have_key("run_list")
-        @report["run_list"].should == @run_status.node.run_list.to_json
+        @report["run_list"].should == Chef::JSONCompat.to_json(@run_status.node.run_list)
       end
 
       it "includes the end_time" do
@@ -484,7 +484,7 @@ describe Chef::ResourceReporter do
 
       it "includes the exception trace in the event data" do
         @report["data"]["exception"].should have_key("backtrace")
-        @report["data"]["exception"]["backtrace"].should == @backtrace.to_json
+        @report["data"]["exception"]["backtrace"].should == Chef::JSONCompat.to_json(@backtrace)
       end
 
       it "includes the error inspector output in the event data" do
@@ -701,7 +701,7 @@ describe Chef::ResourceReporter do
           })
           data_stream = Zlib::GzipReader.new(StringIO.new(data))
           data = data_stream.read
-          data.should eq(@expected_data.to_json)
+          data.should eq(Chef::JSONCompat.to_json(@expected_data))
           response
         end
 

data/spec/unit/resource_spec.rb

@@ -174,12 +174,12 @@ describe Chef::Resource do
     end
 
     it "should load the attributes of a prior resource" do
-      @resource.load_prior_resource
+      @resource.load_prior_resource(@resource.resource_name, @resource.name)
       @resource.supports.should == { :funky => true }
     end
 
     it "should not inherit the action from the prior resource" do
-      @resource.load_prior_resource
+      @resource.load_prior_resource(@resource.resource_name, @resource.name)
       @resource.action.should_not == @prior_resource.action
     end
   end
@@ -336,6 +336,10 @@ describe Chef::Resource do
       json.should =~ /json_class/
       json.should =~ /instance_vars/
     end
+
+    include_examples "to_json equalivent to Chef::JSONCompat.to_json" do
+      let(:jsonable) { @resource }
+    end
   end
 
   describe "to_hash" do
@@ -345,7 +349,7 @@ describe Chef::Resource do
         :updated_by_last_action, :before, :supports,
         :noop, :ignore_failure, :name, :source_line,
         :action, :retries, :retry_delay, :elapsed_time,
-        :guard_interpreter, :sensitive ]
+        :default_guard_interpreter, :guard_interpreter, :sensitive ]
       (hash.keys - expected_keys).should == []
       (expected_keys - hash.keys).should == []
       hash[:name].should eql("funk")
@@ -354,7 +358,7 @@ describe Chef::Resource do
 
   describe "self.json_create" do
     it "should deserialize itself from json" do
-      json = @resource.to_json
+      json = Chef::JSONCompat.to_json(@resource)
       serialized_node = Chef::JSONCompat.from_json(json)
       serialized_node.should be_a_kind_of(Chef::Resource)
       serialized_node.name.should eql(@resource.name)
@@ -390,22 +394,44 @@ describe Chef::Resource do
   end
 
   describe "retries" do
+    before do
+      @retriable_resource = Chef::Resource::Cat.new("precious", @run_context)
+      @retriable_resource.provider = Chef::Provider::SnakeOil
+      @retriable_resource.action = :purr
+
+      @node.automatic_attrs[:platform] = "fubuntu"
+      @node.automatic_attrs[:platform_version] = '10.04'
+    end
+
     it "should default to not retrying if a provider fails for a resource" do
-      @resource.retries.should == 0
+      @retriable_resource.retries.should == 0
     end
 
     it "should allow you to set how many retries a provider should attempt after a failure" do
-      @resource.retries(2)
-      @resource.retries.should == 2
+      @retriable_resource.retries(2)
+      @retriable_resource.retries.should == 2
     end
 
     it "should default to a retry delay of 2 seconds" do
-      @resource.retry_delay.should == 2
+      @retriable_resource.retry_delay.should == 2
     end
 
     it "should allow you to set the retry delay" do
-      @resource.retry_delay(10)
-      @resource.retry_delay.should == 10
+      @retriable_resource.retry_delay(10)
+      @retriable_resource.retry_delay.should == 10
+    end
+
+    it "should keep given value of retries intact after the provider fails for a resource" do
+      @retriable_resource.retries(3)
+      @retriable_resource.retry_delay(0) # No need to wait.
+
+      provider = Chef::Provider::SnakeOil.new(@retriable_resource, @run_context)
+      Chef::Provider::SnakeOil.stub(:new).and_return(provider)
+      provider.stub(:action_purr).and_raise
+
+      @retriable_resource.should_receive(:sleep).exactly(3).times
+      expect { @retriable_resource.run_action(:purr) }.to raise_error
+      @retriable_resource.retries.should == 3
     end
   end
 
@@ -464,7 +490,8 @@ describe Chef::Resource do
     end
 
     it "does not run only_if if no only_if command is given" do
-      @resource.not_if.clear
+      expect_any_instance_of(Chef::Resource::Conditional).not_to receive(:evaluate)
+      @resource.only_if.clear
       @resource.run_action(:purr)
     end
 
@@ -506,6 +533,8 @@ describe Chef::Resource do
     end
 
     it "does not run not_if if no not_if command is given" do
+      expect_any_instance_of(Chef::Resource::Conditional).not_to receive(:evaluate)
+      @resource.not_if.clear
       @resource.run_action(:purr)
     end
 
@@ -551,7 +580,6 @@ describe Chef::Resource do
         expect { resource.guard_interpreter(:command_dot_com) }.not_to raise_error
       end
     end
-
   end
 
   describe "should_skip?" do
@@ -664,24 +692,33 @@ describe Chef::Resource do
 
   describe "building the platform map" do
 
+    let(:klz) { Class.new(Chef::Resource) }
+
+    before do
+      Chef::Resource::Klz = klz
+    end
+
+    after do
+      Chef::Resource.send(:remove_const, :Klz)
+    end
+
     it 'adds mappings for a single platform' do
-      klz = Class.new(Chef::Resource)
-      Chef::Resource.platform_map.should_receive(:set).with(
-        :platform => :autobots, :short_name => :dinobot, :resource => klz
+      expect(Chef::Resource.node_map).to receive(:set).with(
+        :dinobot, Chef::Resource::Klz, { platform: ['autobots'] }
       )
-      klz.provides :dinobot, :on_platforms => ['autobots']
+      klz.provides :dinobot, platform: ['autobots']
     end
 
     it 'adds mappings for multiple platforms' do
-      klz = Class.new(Chef::Resource)
-      Chef::Resource.platform_map.should_receive(:set).twice
-      klz.provides :energy, :on_platforms => ['autobots','decepticons']
+      expect(Chef::Resource.node_map).to receive(:set).with(
+        :energy, Chef::Resource::Klz, { platform: ['autobots', 'decepticons']}
+      )
+      klz.provides :energy, platform: ['autobots', 'decepticons']
     end
 
     it 'adds mappings for all platforms' do
-      klz = Class.new(Chef::Resource)
-      Chef::Resource.platform_map.should_receive(:set).with(
-        :short_name => :tape_deck, :resource => klz
+      expect(Chef::Resource.node_map).to receive(:set).with(
+        :tape_deck, Chef::Resource::Klz, {}
       )
       klz.provides :tape_deck
     end
@@ -689,28 +726,26 @@ describe Chef::Resource do
   end
 
   describe "lookups from the platform map" do
+    let(:klz1) { Class.new(Chef::Resource) }
+    let(:klz2) { Class.new(Chef::Resource) }
 
     before(:each) do
+      Chef::Resource::Klz1 = klz1
+      Chef::Resource::Klz2 = klz2
       @node = Chef::Node.new
       @node.name("bumblebee")
       @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'] })
+      Object.const_set('Soundwave', klz1)
+      klz2.provides :dinobot, :on_platforms => ['autobots']
+      Object.const_set('Grimlock', klz2)
     end
 
     after(:each) do
       Object.send(:remove_const, :Soundwave)
       Object.send(:remove_const, :Grimlock)
-    end
-
-    describe "resource_for_platform" do
-      it 'return a resource by short_name and platform' do
-        Chef::Resource.resource_for_platform(:dinobot,'autobots','6.1').should eql(Grimlock)
-      end
-      it "returns a resource by short_name if nothing else matches" do
-        Chef::Resource.resource_for_node(:soundwave, @node).should eql(Soundwave)
-      end
+      Chef::Resource.send(:remove_const, :Klz1)
+      Chef::Resource.send(:remove_const, :Klz2)
     end
 
     describe "resource_for_node" do

data/spec/unit/rest_spec.rb

@@ -62,8 +62,8 @@ describe Chef::REST do
   let(:request_id) {"1234"}
 
   let(:rest) do
-    Chef::REST::CookieJar.stub(:instance).and_return({})
-    Chef::RequestID.instance.stub(:request_id).and_return(request_id)
+    allow(Chef::REST::CookieJar).to receive(:instance).and_return({})
+    allow(Chef::RequestID.instance).to receive(:request_id).and_return(request_id)
     rest = Chef::REST.new(base_url, nil, nil)
     Chef::REST::CookieJar.instance.clear
     rest
@@ -81,9 +81,9 @@ describe Chef::REST do
     content_length = middlewares.find_index { |e| e.is_a? Chef::HTTP::ValidateContentLength }
     decompressor = middlewares.find_index { |e| e.is_a? Chef::HTTP::Decompressor }
 
-    content_length.should_not be_nil
-    decompressor.should_not be_nil
-    (decompressor < content_length).should be_true
+    expect(content_length).not_to be_nil
+    expect(decompressor).not_to be_nil
+    expect(decompressor < content_length).to be_true
   end
 
   it "should allow the options hash to be frozen" do
@@ -102,43 +102,43 @@ describe Chef::REST do
     end
 
     it "makes a :GET request with the composed url object" do
-      rest.should_receive(:send_http_request).
+      expect(rest).to 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)
+      expect(rest).to receive(:apply_response_middleware).with(1,2,3).and_return([1,2,3])
+      expect(rest).to 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', {})
+      expect(rest).to 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(:send_http_request).
+      expect(rest).to 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)
+      expect(rest).to receive(:apply_response_middleware).with(1,2,3).and_return([1,2,3])
+      expect(rest).to 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).
+      expect(rest).to 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)
+      expect(rest).to receive(:apply_response_middleware).with(1,2,3).and_return([1,2,3])
+      expect(rest).to 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).
+      expect(rest).to 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)
+      expect(rest).to receive(:apply_response_middleware).with(1,2,3).and_return([1,2,3])
+      expect(rest).to receive('success_response?'.to_sym).with(1).and_return(true)
       rest.put_rest("monkey", "data")
     end
   end
@@ -162,13 +162,13 @@ describe Chef::REST do
 
       auth_headers = standard_write_headers.merge({"auth_done"=>"yep"})
 
-      rest.authenticator.should_receive(:handle_request).
+      expect(rest.authenticator).to 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).
+      expect(rest).to 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)
+      expect(rest).to receive('success_response?'.to_sym).with(1).and_return(true)
       rest.raw_http_request(:POST, monkey_uri, standard_write_headers, data)
     end
 
@@ -176,10 +176,10 @@ describe Chef::REST 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).
+      expect(rest).to 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)
+      expect(rest).to receive('success_response?'.to_sym).with(1).and_return(true)
       rest.raw_http_request(:POST, monkey_uri, standard_write_headers, data)
     end
   end
@@ -241,8 +241,8 @@ describe Chef::REST do
 
     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)
+      allow(http_response).to receive(:read_body)
+      allow(http_response).to receive(:body).and_return(body)
       http_response["Content-Length"] = body.bytesize.to_s
       http_response
     end
@@ -255,14 +255,14 @@ describe Chef::REST do
 
     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)
+      allow(http_client).to receive(:request).and_yield(http_response).and_return(http_response)
       http_client
     end
 
     let(:rest) do
-      Net::HTTP.stub(:new).and_return(http_client)
-      Chef::REST::CookieJar.stub(:instance).and_return({})
-      Chef::RequestID.instance.stub(:request_id).and_return(request_id)
+      allow(Net::HTTP).to receive(:new).and_return(http_client)
+      allow(Chef::REST::CookieJar).to receive(:instance).and_return({})
+      allow(Chef::RequestID.instance).to receive(:request_id).and_return(request_id)
       rest = Chef::REST.new(base_url, nil, nil)
       Chef::REST::CookieJar.instance.clear
       rest
@@ -300,16 +300,16 @@ describe Chef::REST do
       end
 
       before do
-        Net::HTTP::Get.stub(:new).and_return(request_mock)
+        allow(Net::HTTP::Get).to receive(: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)
+        expect(Net::HTTP::Get).to receive(:new).with("/?foo=bar", base_headers).and_return(request_mock)
         rest.request(:GET, url, {})
       end
 
       it "should always include the X-Remote-Request-Id header" do
-        Net::HTTP::Get.should_receive(:new).with("/?foo=bar", base_headers).and_return(request_mock)
+        expect(Net::HTTP::Get).to receive(:new).with("/?foo=bar", base_headers).and_return(request_mock)
         rest.request(:GET, url, {})
       end
 
@@ -323,7 +323,7 @@ describe Chef::REST do
       # CHEF-3140
       context "when configured to disable compression" do
         let(:rest) do
-          Net::HTTP.stub(:new).and_return(http_client)
+          allow(Net::HTTP).to receive(:new).and_return(http_client)
           Chef::REST.new(base_url, nil, nil,  :disable_gzip => true)
         end
 
@@ -334,7 +334,7 @@ describe Chef::REST do
         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)
+          expect(Net::HTTP::Get).to receive(:new).and_return(request)
           # will raise a Zlib error if incorrect
           expect(rest.request(:GET, url, {})).to eq("ninja")
         end
@@ -359,28 +359,28 @@ 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)
-          Net::HTTP::Get.should_receive(:new).with(url_string, header_hash)
+          expect(Net::HTTP::Get).to receive(:new).with(url_string, header_hash)
           rest.request(:GET, url, {})
         end
       end
 
       context "when setting cookies" do
         let(:rest) do
-          Net::HTTP.stub(:new).and_return(http_client)
+          allow(Net::HTTP).to receive(:new).and_return(http_client)
           Chef::REST::CookieJar.instance["#{url.host}:#{url.port}"] = "cookie monster"
-          Chef::RequestID.instance.stub(:request_id).and_return(request_id)
+          allow(Chef::RequestID.instance).to receive(:request_id).and_return(request_id)
           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)
+          expect(Net::HTTP::Get).to 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)
+        expect(Net::HTTP::Get).to receive(:new).with("/?foo=bar", base_headers).and_return(request_mock)
         rest.request(:GET, url, {})
       end
 
@@ -388,7 +388,7 @@ describe Chef::REST do
         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)
+        expect(Net::HTTP::Post).to receive(:new).with("/?foo=bar", expected_headers).and_return(request)
         rest.request(:POST, url, {}, {:one=>:two})
         expect(request.body).to eq('{"one":"two"}')
       end
@@ -396,13 +396,13 @@ describe Chef::REST do
       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')
-        Net::HTTP::Put.should_receive(:new).with("/?foo=bar",expected_headers).and_return(request)
+        expect(Net::HTTP::Put).to receive(:new).with("/?foo=bar",expected_headers).and_return(request)
         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)
+        expect(Net::HTTP::Delete).to receive(:new).with("/?foo=bar", base_headers).and_return(request_mock)
         rest.request(:DELETE, url)
       end
 
@@ -440,7 +440,7 @@ describe Chef::REST do
             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)
+            allow(http_response).to receive(:read_body)
             http_response
           end
           it "should call request again" do
@@ -457,7 +457,7 @@ describe Chef::REST do
       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)
+          allow(http_response).to receive(:read_body)
           http_response
         end
 
@@ -480,13 +480,13 @@ describe Chef::REST 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)
+            allow(http_response).to receive(:body).and_return('{ "error":[ "Ears get sore!", "Not even four" ] }')
+            allow(http_response).to receive(:read_body)
             http_response
           end
 
           it "should show the JSON error message" do
-            rest.stub(:sleep)
+            allow(rest).to receive(:sleep)
 
             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'))
@@ -502,17 +502,21 @@ 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)
+            allow(http_response).to receive(:body).and_return gzipped_body
+            allow(http_response).to receive(:read_body)
             http_response
           end
-          it "decompresses the JSON error message" do
-            rest.stub(:sleep)
-            rest.stub(:http_retry_count).and_return(0)
 
+          before do
+            allow(rest).to receive(:sleep)
+            allow(rest).to receive(:http_retry_count).and_return(0)
+          end
+
+          it "decompresses the JSON error message" do
             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)
@@ -522,13 +526,16 @@ describe Chef::REST do
         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)
+            allow(http_response).to receive(:body)
+            allow(http_response).to receive(:read_body)
             http_response
           end
-          it "throws an exception" do
-            rest.stub(:sleep)
+
+          it "retries then throws an exception" do
+            allow(rest).to receive(:sleep)
             expect {rest.request(:GET, url)}.to raise_error(Net::HTTPFatalError)
+            count = Chef::Config[:http_retry_count]
+            expect(log_stringio.string).to match(Regexp.escape("ERROR: Server returned error 500 for #{url}, retrying #{count}/#{count}"))
           end
         end
       end
@@ -542,8 +549,8 @@ describe Chef::REST do
       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)
+        allow(http_response).to receive(:read_body)
+        expect(http_response).not_to receive(:body)
         http_response["Content-Length"] = "0" # call set_content_length (in test), if otherwise
         http_response
       end
@@ -557,8 +564,8 @@ describe Chef::REST do
       end
 
       before do
-        Tempfile.stub(:new).with("chef-rest").and_return(tempfile)
-        Net::HTTP::Get.stub(:new).and_return(request_mock)
+        allow(Tempfile).to receive(:new).with("chef-rest").and_return(tempfile)
+        allow(Net::HTTP::Get).to receive(:new).and_return(request_mock)
       end
 
       after do
@@ -572,7 +579,7 @@ describe Chef::REST do
                             'Host' => host_header,
                             'X-REMOTE-REQUEST-ID'=> request_id
                             }
-        Net::HTTP::Get.should_receive(:new).with("/?foo=bar", expected_headers).and_return(request_mock)
+        expect(Net::HTTP::Get).to receive(:new).with("/?foo=bar", expected_headers).and_return(request_mock)
         rest.streaming_request(url, {})
       end
 
@@ -583,7 +590,7 @@ describe Chef::REST do
                             'Host' => host_header,
                             'X-REMOTE-REQUEST-ID'=> request_id
                             }
-        Net::HTTP::Get.should_receive(:new).with("/?foo=bar", expected_headers).and_return(request_mock)
+        expect(Net::HTTP::Get).to receive(:new).with("/?foo=bar", expected_headers).and_return(request_mock)
         rest.streaming_request(url, {})
       end
 
@@ -592,7 +599,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")
+        allow(http_response).to receive(: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")
@@ -604,7 +611,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")
+        allow(http_response).to receive(:read_body).and_yield("real").and_yield("ultimate").and_yield("power")
         set_content_length
         tempfile_path = nil
         rest.streaming_request(url, {}) do |tempfile|
@@ -617,24 +624,24 @@ describe Chef::REST do
 
       it "does not raise a divide by zero exception if the content's actual size is 0" do
         http_response['Content-Length'] = "5"
-        http_response.stub(:read_body).and_yield('')
+        allow(http_response).to receive(:read_body).and_yield('')
         expect { rest.streaming_request(url, {}) }.to raise_error(Chef::Exceptions::ContentLengthMismatch)
       end
 
       it "does not raise a divide by zero exception when the Content-Length is 0" do
         http_response['Content-Length'] = "0"
-        http_response.stub(:read_body).and_yield("ninja")
+        allow(http_response).to receive(:read_body).and_yield("ninja")
         expect { rest.streaming_request(url, {}) }.to raise_error(Chef::Exceptions::ContentLengthMismatch)
       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")
+        allow(http_response).to receive(: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")
+        allow(http_response).to receive(:read_body).and_yield("real").and_yield("ultimate").and_yield("power")
         set_content_length
         tempfile_path = nil
         rest.fetch("cookbooks/a_cookbook") do |tempfile|
@@ -647,32 +654,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
         expect(path).not_to be_nil
-        tempfile.stub(:write).and_raise(IOError)
+        allow(tempfile).to receive(: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
         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)
+        expect(tempfile).to receive(:close!).at_least(1).times
+        allow(Tempfile).to receive(: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.stub(:read_body)
+        allow(redirect).to receive(: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)
+        expect(http_client).to receive(:request).and_yield(redirect).and_return(redirect)
+        expect(http_client).to 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_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)
+        allow(http_redirect).to receive(:read_body)
 
         block_called = false
-        http_client.stub(:request).and_yield(http_response).and_return(http_redirect, http_response)
+        allow(http_client).to receive(:request).and_yield(http_response).and_return(http_redirect, http_response)
         rest.fetch("cookbooks/a_cookbook") do |tmpfile|
           block_called = true
         end