chef 12.0.3-x86-mingw32 → 12.1.0.rc.0-x86-mingw32

data/spec/unit/resource_collection_spec.rb

@@ -29,39 +29,39 @@ describe Chef::ResourceCollection do
 
   describe "initialize" do
     it "should return a Chef::ResourceCollection" do
-      rc.should be_kind_of(Chef::ResourceCollection)
+      expect(rc).to be_kind_of(Chef::ResourceCollection)
     end
   end
 
   describe "[]" do
     it "should accept Chef::Resources through [index]" do
-      lambda { rc[0] = resource }.should_not raise_error
-      lambda { rc[0] = "string" }.should raise_error(ArgumentError)
+      expect { rc[0] = resource }.not_to raise_error
+      expect { rc[0] = "string" }.to raise_error(ArgumentError)
     end
 
     it "should allow you to fetch Chef::Resources by position" do
       rc[0] = resource
-      rc[0].should eql(resource)
+      expect(rc[0]).to eql(resource)
     end
   end
 
   describe "push" do
     it "should accept Chef::Resources through pushing" do
-      lambda { rc.push(resource) }.should_not raise_error
-      lambda { rc.push("string") }.should raise_error(ArgumentError)
+      expect { rc.push(resource) }.not_to raise_error
+      expect { rc.push("string") }.to raise_error(ArgumentError)
     end
   end
 
   describe "<<" do
     it "should accept the << operator" do
-      lambda { rc << resource }.should_not raise_error
+      expect { rc << resource }.not_to raise_error
     end
   end
 
   describe "insert" do
     it "should accept only Chef::Resources" do
-      lambda { rc.insert(resource) }.should_not raise_error
-      lambda { rc.insert("string") }.should raise_error(ArgumentError)
+      expect { rc.insert(resource) }.not_to raise_error
+      expect { rc.insert("string") }.to raise_error(ArgumentError)
     end
 
     it "should accept named arguments in any order" do
@@ -73,8 +73,8 @@ describe Chef::ResourceCollection do
       zmr = Chef::Resource::ZenMaster.new("there is no spoon")
       rc.insert(resource)
       rc.insert(zmr)
-      rc[0].should eql(resource)
-      rc[1].should eql(zmr)
+      expect(rc[0]).to eql(resource)
+      expect(rc[1]).to eql(zmr)
     end
 
     it "should insert resources to the middle of the collection if called while executing a run" do
@@ -88,9 +88,9 @@ describe Chef::ResourceCollection do
         rc.insert(resource_to_inject) if resource == zmr
       end
 
-      rc[0].should eql(zmr)
-      rc[1].should eql(resource_to_inject)
-      rc[2].should eql(dummy)
+      expect(rc[0]).to eql(zmr)
+      expect(rc[1]).to eql(resource_to_inject)
+      expect(rc[2]).to eql(dummy)
     end
   end
 
@@ -98,19 +98,19 @@ describe Chef::ResourceCollection do
     it "should allow you to iterate over every resource in the collection" do
       load_up_resources
       results = Array.new
-      lambda {
+      expect {
         rc.each do |r|
           results << r.name
         end
-      }.should_not raise_error
+      }.not_to raise_error
       results.each_index do |i|
         case i
         when 0
-          results[i].should eql("dog")
+          expect(results[i]).to eql("dog")
         when 1
-          results[i].should eql("cat")
+          expect(results[i]).to eql("cat")
         when 2
-          results[i].should eql("monkey")
+          expect(results[i]).to eql("monkey")
         end
       end
     end
@@ -120,19 +120,19 @@ describe Chef::ResourceCollection do
     it "should allow you to iterate over every resource by index" do
       load_up_resources
       results = Array.new
-      lambda {
+      expect {
         rc.each_index do |i|
           results << rc[i].name
         end
-      }.should_not raise_error
+      }.not_to raise_error
       results.each_index do |i|
         case i
         when 0
-          results[i].should eql("dog")
+          expect(results[i]).to eql("dog")
         when 1
-          results[i].should eql("cat")
+          expect(results[i]).to eql("cat")
         when 2
-          results[i].should eql("monkey")
+          expect(results[i]).to eql("monkey")
         end
       end
     end
@@ -142,23 +142,23 @@ describe Chef::ResourceCollection do
     it "should allow you to find resources by name via lookup" do
       zmr = Chef::Resource::ZenMaster.new("dog")
       rc << zmr
-      rc.lookup(zmr.to_s).should eql(zmr)
+      expect(rc.lookup(zmr.to_s)).to eql(zmr)
 
       zmr = Chef::Resource::ZenMaster.new("cat")
       rc[0] = zmr
-      rc.lookup(zmr).should eql(zmr)
+      expect(rc.lookup(zmr)).to eql(zmr)
 
       zmr = Chef::Resource::ZenMaster.new("monkey")
       rc.push(zmr)
-      rc.lookup(zmr).should eql(zmr)
+      expect(rc.lookup(zmr)).to eql(zmr)
     end
 
     it "should raise an exception if you send something strange to lookup" do
-      lambda { rc.lookup(:symbol) }.should raise_error(ArgumentError)
+      expect { rc.lookup(:symbol) }.to raise_error(ArgumentError)
     end
 
     it "should raise an exception if it cannot find a resource with lookup" do
-      lambda { rc.lookup("zen_master[dog]") }.should raise_error(Chef::Exceptions::ResourceNotFound)
+      expect { rc.lookup("zen_master[dog]") }.to raise_error(Chef::Exceptions::ResourceNotFound)
     end
   end
 
@@ -166,81 +166,81 @@ describe Chef::ResourceCollection do
 
     it "should find a resource by symbol and name (:zen_master => monkey)" do
       load_up_resources
-      rc.resources(:zen_master => "monkey").name.should eql("monkey")
+      expect(rc.resources(:zen_master => "monkey").name).to eql("monkey")
     end
 
     it "should find a resource by symbol and array of names (:zen_master => [a,b])" do
       load_up_resources
       results = rc.resources(:zen_master => [ "monkey", "dog" ])
-      results.length.should eql(2)
+      expect(results.length).to eql(2)
       check_by_names(results, "monkey", "dog")
     end
 
     it "should find resources of multiple kinds (:zen_master => a, :file => b)" do
       load_up_resources
       results = rc.resources(:zen_master => "monkey", :file => "something")
-      results.length.should eql(2)
+      expect(results.length).to eql(2)
       check_by_names(results, "monkey", "something")
     end
 
     it "should find a resource by string zen_master[a]" do
       load_up_resources
-      rc.resources("zen_master[monkey]").name.should eql("monkey")
+      expect(rc.resources("zen_master[monkey]").name).to eql("monkey")
     end
 
     it "should find resources by strings of zen_master[a,b]" do
       load_up_resources
       results = rc.resources("zen_master[monkey,dog]")
-      results.length.should eql(2)
+      expect(results.length).to eql(2)
       check_by_names(results, "monkey", "dog")
     end
 
     it "should find resources of multiple types by strings of zen_master[a]" do
       load_up_resources
       results = rc.resources("zen_master[monkey]", "file[something]")
-      results.length.should eql(2)
+      expect(results.length).to eql(2)
       check_by_names(results, "monkey", "something")
     end
 
     it "should raise an exception if you pass a bad name to resources" do
-      lambda { rc.resources("michael jackson") }.should raise_error(ArgumentError)
+      expect { rc.resources("michael jackson") }.to raise_error(ArgumentError)
     end
 
     it "should raise an exception if you pass something other than a string or hash to resource" do
-      lambda { rc.resources([Array.new]) }.should raise_error(ArgumentError)
+      expect { rc.resources([Array.new]) }.to raise_error(ArgumentError)
     end
 
     it "raises an error when attempting to find a resource that does not exist" do
-      lambda {rc.find("script[nonesuch]")}.should raise_error(Chef::Exceptions::ResourceNotFound)
+      expect {rc.find("script[nonesuch]")}.to raise_error(Chef::Exceptions::ResourceNotFound)
     end
 
   end
 
   describe "when validating a resource query object" do
     it "accepts a string of the form 'resource_type[resource_name]'" do
-      rc.validate_lookup_spec!("resource_type[resource_name]").should be_true
+      expect(rc.validate_lookup_spec!("resource_type[resource_name]")).to be_truthy
     end
 
     it "accepts a single-element :resource_type => 'resource_name' Hash" do
-      rc.validate_lookup_spec!(:service => "apache2").should be_true
+      expect(rc.validate_lookup_spec!(:service => "apache2")).to be_truthy
     end
 
 
     it "accepts a chef resource object" do
       res = Chef::Resource.new("foo", nil)
-      rc.validate_lookup_spec!(res).should be_true
+      expect(rc.validate_lookup_spec!(res)).to be_truthy
     end
 
     it "rejects a malformed query string" do
-      lambda do
+      expect do
         rc.validate_lookup_spec!("resource_type[missing-end-bracket")
-      end.should raise_error(Chef::Exceptions::InvalidResourceSpecification)
+      end.to raise_error(Chef::Exceptions::InvalidResourceSpecification)
     end
 
     it "rejects an argument that is not a String, Hash, or Chef::Resource" do
-      lambda do
+      expect do
         rc.validate_lookup_spec!(Object.new)
-      end.should raise_error(Chef::Exceptions::InvalidResourceSpecification)
+      end.to raise_error(Chef::Exceptions::InvalidResourceSpecification)
     end
 
   end
@@ -248,8 +248,8 @@ describe Chef::ResourceCollection do
   describe "to_json" do
     it "should serialize to json" do
       json = rc.to_json
-      json.should =~ /json_class/
-      json.should =~ /instance_vars/
+      expect(json).to match(/json_class/)
+      expect(json).to match(/instance_vars/)
     end
 
     include_examples "to_json equalivent to Chef::JSONCompat.to_json" do
@@ -266,27 +266,27 @@ describe Chef::ResourceCollection do
       rc << resource
       json = Chef::JSONCompat.to_json(rc)
       s_rc = Chef::JSONCompat.from_json(json)
-      s_rc.should be_a_kind_of(Chef::ResourceCollection)
-      s_rc[0].name.should eql(resource.name)
+      expect(s_rc).to be_a_kind_of(Chef::ResourceCollection)
+      expect(s_rc[0].name).to eql(resource.name)
     end
   end
 
   describe "provides access to the raw resources array" do
     it "returns the resources via the all_resources method" do
-      rc.all_resources.should equal(rc.instance_variable_get(:@resource_list).instance_variable_get(:@resources))
+      expect(rc.all_resources).to equal(rc.instance_variable_get(:@resource_list).instance_variable_get(:@resources))
     end
   end
 
   describe "provides access to stepable iterator" do
     it "returns the iterator object" do
       rc.instance_variable_get(:@resource_list).instance_variable_set(:@iterator, :fooboar)
-      rc.iterator.should == :fooboar
+      expect(rc.iterator).to eq(:fooboar)
     end
   end
 
   def check_by_names(results, *names)
     names.each do |res_name|
-      results.detect{ |res| res.name == res_name }.should_not eql(nil)
+      expect(results.detect{ |res| res.name == res_name }).not_to eql(nil)
     end
   end
 

data/spec/unit/resource_definition_spec.rb

@@ -85,7 +85,7 @@ describe Chef::ResourceDefinition do
     expect(defn.recipe.call).to eql("I am what I am")
   end
 
-  it "should set paramaters based on method_missing" do
+  it "should set parameters based on method_missing" do
     defn.mind "to fly"
     expect(defn.params[:mind]).to eql("to fly")
   end

data/spec/unit/resource_reporter_spec.rb

@@ -37,13 +37,13 @@ describe Chef::ResourceReporter do
     @node = Chef::Node.new
     @node.name("spitfire")
     @rest_client = double("Chef::REST (mock)")
-    @rest_client.stub(:post_rest).and_return(true)
+    allow(@rest_client).to receive(:post_rest).and_return(true)
     @resource_reporter = Chef::ResourceReporter.new(@rest_client)
     @new_resource      = Chef::Resource::File.new("/tmp/a-file.txt")
     @cookbook_name = "monkey"
     @new_resource.cookbook_name = @cookbook_name
     @cookbook_version = double("Cookbook::Version", :version => "1.2.3")
-    @new_resource.stub(:cookbook_version).and_return(@cookbook_version)
+    allow(@new_resource).to receive(:cookbook_version).and_return(@cookbook_version)
     @current_resource  = Chef::Resource::File.new("/tmp/a-file.txt")
     @start_time = Time.new
     @end_time = Time.new + 20
@@ -51,25 +51,25 @@ describe Chef::ResourceReporter do
     @run_context = Chef::RunContext.new(@node, {}, @events)
     @run_status = Chef::RunStatus.new(@node, @events)
     @run_id = @run_status.run_id
-    Time.stub(:now).and_return(@start_time, @end_time)
+    allow(Time).to receive(:now).and_return(@start_time, @end_time)
   end
 
   context "when first created" do
 
     it "has no updated resources" do
-      @resource_reporter.should have(0).updated_resources
+      expect(@resource_reporter.updated_resources.size).to eq(0)
     end
 
     it "reports a successful run" do
-      @resource_reporter.status.should == "success"
+      expect(@resource_reporter.status).to eq("success")
     end
 
     it "assumes the resource history feature is supported" do
-      @resource_reporter.reporting_enabled?.should be_true
+      expect(@resource_reporter.reporting_enabled?).to be_truthy
     end
 
     it "should have no error_descriptions" do
-      @resource_reporter.error_descriptions.should eq({})
+      expect(@resource_reporter.error_descriptions).to eq({})
       # @resource_reporter.error_descriptions.should be_empty
       # @resource_reporter.should have(0).error_descriptions
     end
@@ -82,16 +82,16 @@ describe Chef::ResourceReporter do
     end
 
     it "reports a successful run" do
-      pending "refactor how node gets set."
-      @resource_reporter.status.should == "success"
+      skip "refactor how node gets set."
+      expect(@resource_reporter.status).to eq("success")
     end
   end
 
   context "when chef fails" do
     before do
-      @rest_client.stub(:create_url).and_return("reports/nodes/spitfire/runs/#{@run_id}");
-      @rest_client.stub(:raw_http_request).and_return({"result"=>"ok"});
-      @rest_client.stub(:post_rest).and_return({"uri"=>"https://example.com/reports/nodes/spitfire/runs/#{@run_id}"});
+      allow(@rest_client).to receive(:create_url).and_return("reports/nodes/spitfire/runs/#{@run_id}");
+      allow(@rest_client).to receive(:raw_http_request).and_return({"result"=>"ok"});
+      allow(@rest_client).to receive(:post_rest).and_return({"uri"=>"https://example.com/reports/nodes/spitfire/runs/#{@run_id}"});
 
     end
 
@@ -103,11 +103,11 @@ describe Chef::ResourceReporter do
       end
 
       it "sets the run status to 'failure'" do
-        @resource_reporter.status.should == "failure"
+        expect(@resource_reporter.status).to eq("failure")
       end
 
       it "keeps the exception data" do
-        @resource_reporter.exception.should == @exception
+        expect(@resource_reporter.exception).to eq(@exception)
       end
     end
 
@@ -121,12 +121,12 @@ describe Chef::ResourceReporter do
       end
 
       it "collects the resource as an updated resource" do
-        @resource_reporter.should have(1).updated_resources
+        expect(@resource_reporter.updated_resources.size).to eq(1)
       end
 
       it "collects the desired state of the resource" do
         update_record = @resource_reporter.updated_resources.first
-        update_record.new_resource.should == @new_resource
+        expect(update_record.new_resource).to eq(@new_resource)
       end
     end
 
@@ -145,7 +145,7 @@ describe Chef::ResourceReporter do
         end
 
         it "has no updated resources" do
-          @resource_reporter.should have(0).updated_resources
+          expect(@resource_reporter.updated_resources.size).to eq(0)
         end
       end
 
@@ -158,17 +158,17 @@ describe Chef::ResourceReporter do
         end
 
         it "collects the updated resource" do
-          @resource_reporter.should have(1).updated_resources
+          expect(@resource_reporter.updated_resources.size).to eq(1)
         end
 
         it "collects the old state of the resource" do
           update_record = @resource_reporter.updated_resources.first
-          update_record.current_resource.should == @current_resource
+          expect(update_record.current_resource).to eq(@current_resource)
         end
 
         it "collects the new state of the resource" do
           update_record = @resource_reporter.updated_resources.first
-          update_record.new_resource.should == @new_resource
+          expect(update_record.new_resource).to eq(@new_resource)
         end
 
         context "and a subsequent resource fails before loading current resource" do
@@ -182,12 +182,12 @@ describe Chef::ResourceReporter do
 
           it "collects the desired state of the failed resource" do
             failed_resource_update = @resource_reporter.updated_resources.last
-            failed_resource_update.new_resource.should == @next_new_resource
+            expect(failed_resource_update.new_resource).to eq(@next_new_resource)
           end
 
           it "does not have the current state of the failed resource" do
             failed_resource_update = @resource_reporter.updated_resources.last
-            failed_resource_update.current_resource.should be_nil
+            expect(failed_resource_update.current_resource).to be_nil
           end
         end
       end
@@ -208,7 +208,7 @@ describe Chef::ResourceReporter do
       end
 
         it "does not collect data about the nested resource" do
-          @resource_reporter.should have(1).updated_resources
+          expect(@resource_reporter.updated_resources.size).to eq(1)
         end
       end
 
@@ -224,7 +224,7 @@ describe Chef::ResourceReporter do
         end
 
         it "does not collect data about the nested resource" do
-          @resource_reporter.should have(1).updated_resources
+          expect(@resource_reporter.updated_resources.size).to eq(1)
         end
       end
 
@@ -237,17 +237,17 @@ describe Chef::ResourceReporter do
         end
 
         it "collects the resource as an updated resource" do
-          @resource_reporter.should have(1).updated_resources
+          expect(@resource_reporter.updated_resources.size).to eq(1)
         end
 
         it "collects the desired state of the resource" do
           update_record = @resource_reporter.updated_resources.first
-          update_record.new_resource.should == @new_resource
+          expect(update_record.new_resource).to eq(@new_resource)
         end
 
         it "collects the current state of the resource" do
           update_record = @resource_reporter.updated_resources.first
-          update_record.current_resource.should == @current_resource
+          expect(update_record.current_resource).to eq(@current_resource)
         end
       end
 
@@ -257,9 +257,9 @@ describe Chef::ResourceReporter do
   describe "when generating a report for the server" do
 
     before do
-      @rest_client.stub(:create_url).and_return("reports/nodes/spitfire/runs/#{@run_id}");
-      @rest_client.stub(:raw_http_request).and_return({"result"=>"ok"});
-      @rest_client.stub(:post_rest).and_return({"uri"=>"https://example.com/reports/nodes/spitfire/runs/#{@run_id}"});
+      allow(@rest_client).to receive(:create_url).and_return("reports/nodes/spitfire/runs/#{@run_id}");
+      allow(@rest_client).to receive(:raw_http_request).and_return({"result"=>"ok"});
+      allow(@rest_client).to receive(:post_rest).and_return({"uri"=>"https://example.com/reports/nodes/spitfire/runs/#{@run_id}"});
 
       @resource_reporter.run_started(@run_status)
     end
@@ -268,8 +268,8 @@ describe Chef::ResourceReporter do
       context "the new_resource name and id are nil" do
         before do
           @bad_resource = Chef::Resource::File.new("/tmp/nameless_file.txt")
-          @bad_resource.stub(:name).and_return(nil)
-          @bad_resource.stub(:identity).and_return(nil)
+          allow(@bad_resource).to receive(:name).and_return(nil)
+          allow(@bad_resource).to receive(:identity).and_return(nil)
           @resource_reporter.resource_action_start(@bad_resource, :create)
           @resource_reporter.resource_current_state_loaded(@bad_resource, :create, @current_resource)
           @resource_reporter.resource_updated(@bad_resource, :create)
@@ -280,19 +280,19 @@ describe Chef::ResourceReporter do
         end
 
         it "resource_name in prepared_run_data is a string" do
-          @first_update_report["name"].class.should == String
+          expect(@first_update_report["name"].class).to eq(String)
         end
 
         it "resource_id in prepared_run_data is a string" do
-          @first_update_report["id"].class.should == String
+          expect(@first_update_report["id"].class).to eq(String)
         end
       end
 
       context "the new_resource name and id are hashes" do
         before do
           @bad_resource = Chef::Resource::File.new("/tmp/filename_as_hash.txt")
-          @bad_resource.stub(:name).and_return({:foo=>:bar})
-          @bad_resource.stub(:identity).and_return({:foo=>:bar})
+          allow(@bad_resource).to receive(:name).and_return({:foo=>:bar})
+          allow(@bad_resource).to receive(:identity).and_return({:foo=>:bar})
           @resource_reporter.resource_action_start(@bad_resource, :create)
           @resource_reporter.resource_current_state_loaded(@bad_resource, :create, @current_resource)
           @resource_reporter.resource_updated(@bad_resource, :create)
@@ -309,11 +309,11 @@ describe Chef::ResourceReporter do
         # => "{:foo=>:bar}"
         # Hence checking for the class instead of the actual value.
         it "resource_name in prepared_run_data is a string" do
-          @first_update_report["name"].class.should == String
+          expect(@first_update_report["name"].class).to eq(String)
         end
 
         it "resource_id in prepared_run_data is a string" do
-          @first_update_report["id"].class.should == String
+          expect(@first_update_report["id"].class).to eq(String)
         end
       end
     end
@@ -360,73 +360,73 @@ describe Chef::ResourceReporter do
       end
 
       it "includes the run's status" do
-        @report.should have_key("status")
+        expect(@report).to have_key("status")
       end
 
       it "includes a list of updated resources" do
-        @report.should have_key("resources")
+        expect(@report).to have_key("resources")
       end
 
       it "includes an updated resource's type" do
-        @first_update_report.should have_key("type")
+        expect(@first_update_report).to have_key("type")
       end
 
       it "includes an updated resource's initial state" do
-        @first_update_report["before"].should == current_resource.state
+        expect(@first_update_report["before"]).to eq(current_resource.state)
       end
 
       it "includes an updated resource's final state" do
-        @first_update_report["after"].should == new_resource.state
+        expect(@first_update_report["after"]).to eq(new_resource.state)
       end
 
       it "includes the resource's name" do
-        @first_update_report["name"].should == new_resource.name
+        expect(@first_update_report["name"]).to eq(new_resource.name)
       end
 
       it "includes the resource's id attribute" do
-        @first_update_report["id"].should == new_resource.identity
+        expect(@first_update_report["id"]).to eq(new_resource.identity)
       end
 
       it "includes the elapsed time for the resource to converge" do
         # TODO: API takes integer number of milliseconds as a string. This
         # should be an int.
-        @first_update_report.should have_key("duration")
-        @first_update_report["duration"].to_i.should be_within(100).of(0)
+        expect(@first_update_report).to have_key("duration")
+        expect(@first_update_report["duration"].to_i).to be_within(100).of(0)
       end
 
       it "includes the action executed by the resource" do
         # TODO: rename as "action"
-        @first_update_report["result"].should == "create"
+        expect(@first_update_report["result"]).to eq("create")
       end
 
       it "includes the cookbook name of the resource" do
-        @first_update_report.should have_key("cookbook_name")
-        @first_update_report["cookbook_name"].should == @cookbook_name
+        expect(@first_update_report).to have_key("cookbook_name")
+        expect(@first_update_report["cookbook_name"]).to eq(@cookbook_name)
       end
 
       it "includes the cookbook version of the resource" do
-        @first_update_report.should have_key("cookbook_version")
-        @first_update_report["cookbook_version"].should == "1.2.3"
+        expect(@first_update_report).to have_key("cookbook_version")
+        expect(@first_update_report["cookbook_version"]).to eq("1.2.3")
       end
 
       it "includes the total resource count" do
-        @report.should have_key("total_res_count")
-        @report["total_res_count"].should == "1"
+        expect(@report).to have_key("total_res_count")
+        expect(@report["total_res_count"]).to eq("1")
       end
 
       it "includes the data hash" do
-        @report.should have_key("data")
-        @report["data"].should == {}
+        expect(@report).to have_key("data")
+        expect(@report["data"]).to eq({})
       end
 
       it "includes the run_list" do
-        @report.should have_key("run_list")
-        @report["run_list"].should == Chef::JSONCompat.to_json(@run_status.node.run_list)
+        expect(@report).to have_key("run_list")
+        expect(@report["run_list"]).to eq(Chef::JSONCompat.to_json(@run_status.node.run_list))
       end
 
       it "includes the end_time" do
-        @report.should have_key("end_time")
-        @report["end_time"].should == @run_status.end_time.to_s
+        expect(@report).to have_key("end_time")
+        expect(@report["end_time"]).to eq(@run_status.end_time.to_s)
       end
 
     end
@@ -442,8 +442,8 @@ describe Chef::ResourceReporter do
       let(:new_resource) do
         resource = Chef::Resource::RegistryKey.new('Wubba\Lubba\Dub\Dubs')
         resource.values([ { :name => 'rick', :type => :binary, :data => 255.chr * 1 } ])
-        resource.stub(:cookbook_name).and_return(@cookbook_name)
-        resource.stub(:cookbook_version).and_return(@cookbook_version)
+        allow(resource).to receive(:cookbook_name).and_return(@cookbook_name)
+        allow(resource).to receive(:cookbook_version).and_return(@cookbook_version)
         resource
       end
 
@@ -463,33 +463,33 @@ describe Chef::ResourceReporter do
         @node = Chef::Node.new
         @node.name("spitfire")
         @exception = ArgumentError.new
-        @exception.stub(:inspect).and_return("Net::HTTPServerException")
-        @exception.stub(:message).and_return("Object not found")
-        @exception.stub(:backtrace).and_return(@backtrace)
+        allow(@exception).to receive(:inspect).and_return("Net::HTTPServerException")
+        allow(@exception).to receive(:message).and_return("Object not found")
+        allow(@exception).to receive(:backtrace).and_return(@backtrace)
         @resource_reporter.run_list_expand_failed(@node, @exception)
         @resource_reporter.run_failed(@exception)
         @report = @resource_reporter.prepare_run_data
       end
 
       it "includes the exception type in the event data" do
-        @report.should have_key("data")
-        @report["data"]["exception"].should have_key("class")
-        @report["data"]["exception"]["class"].should == "Net::HTTPServerException"
+        expect(@report).to have_key("data")
+        expect(@report["data"]["exception"]).to have_key("class")
+        expect(@report["data"]["exception"]["class"]).to eq("Net::HTTPServerException")
       end
 
       it "includes the exception message in the event data" do
-        @report["data"]["exception"].should have_key("message")
-        @report["data"]["exception"]["message"].should == "Object not found"
+        expect(@report["data"]["exception"]).to have_key("message")
+        expect(@report["data"]["exception"]["message"]).to eq("Object not found")
       end
 
       it "includes the exception trace in the event data" do
-        @report["data"]["exception"].should have_key("backtrace")
-        @report["data"]["exception"]["backtrace"].should == Chef::JSONCompat.to_json(@backtrace)
+        expect(@report["data"]["exception"]).to have_key("backtrace")
+        expect(@report["data"]["exception"]["backtrace"]).to eq(Chef::JSONCompat.to_json(@backtrace))
       end
 
       it "includes the error inspector output in the event data" do
-        @report["data"]["exception"].should have_key("description")
-        @report["data"]["exception"]["description"].should include({"title"=>"Error expanding the run_list:", "sections"=>[{"Unexpected Error:" => "ArgumentError: Object not found"}]})
+        expect(@report["data"]["exception"]).to have_key("description")
+        expect(@report["data"]["exception"]["description"]).to include({"title"=>"Error expanding the run_list:", "sections"=>[{"Unexpected Error:" => "ArgumentError: Object not found"}]})
       end
 
     end
@@ -509,39 +509,39 @@ describe Chef::ResourceReporter do
       end
 
       it "includes an updated resource's initial state" do
-        @first_update_report["before"].should == @current_resource.state
+        expect(@first_update_report["before"]).to eq(@current_resource.state)
       end
 
       it "includes an updated resource's final state" do
-        @first_update_report["after"].should == @new_resource.state
+        expect(@first_update_report["after"]).to eq(@new_resource.state)
       end
 
       it "includes the resource's name" do
-        @first_update_report["name"].should == @new_resource.name
+        expect(@first_update_report["name"]).to eq(@new_resource.name)
       end
 
       it "includes the resource's id attribute" do
-        @first_update_report["id"].should == @new_resource.identity
+        expect(@first_update_report["id"]).to eq(@new_resource.identity)
       end
 
       it "includes the elapsed time for the resource to converge" do
         # TODO: API takes integer number of milliseconds as a string. This
         # should be an int.
-        @first_update_report.should have_key("duration")
-        @first_update_report["duration"].to_i.should be_within(100).of(0)
+        expect(@first_update_report).to have_key("duration")
+        expect(@first_update_report["duration"].to_i).to be_within(100).of(0)
       end
 
       it "includes the action executed by the resource" do
         # TODO: rename as "action"
-        @first_update_report["result"].should == "create"
+        expect(@first_update_report["result"]).to eq("create")
       end
 
       it "does not include a cookbook name for the resource" do
-        @first_update_report.should_not have_key("cookbook_name")
+        expect(@first_update_report).not_to have_key("cookbook_name")
       end
 
       it "does not include a cookbook version for the resource" do
-        @first_update_report.should_not have_key("cookbook_version")
+        expect(@first_update_report).not_to have_key("cookbook_version")
       end
     end
 
@@ -562,13 +562,13 @@ describe Chef::ResourceReporter do
       end
 
       it "sets before to {} instead of nil" do
-        @first_update_report.should have_key("before")
-        @first_update_report['before'].should eq({})
+        expect(@first_update_report).to have_key("before")
+        expect(@first_update_report['before']).to eq({})
       end
 
       it "sets after to {} instead of 'Running'" do
-        @first_update_report.should have_key("after")
-        @first_update_report['after'].should eq({})
+        expect(@first_update_report).to have_key("after")
+        expect(@first_update_report['after']).to eq({})
       end
     end
 
@@ -585,7 +585,7 @@ describe Chef::ResourceReporter do
         # 404 getting the run_id
         @response = Net::HTTPNotFound.new("a response body", "404", "Not Found")
         @error = Net::HTTPServerException.new("404 message", @response)
-        @rest_client.should_receive(:post_rest).
+        expect(@rest_client).to receive(:post_rest).
           with("reports/nodes/spitfire/runs", {:action => :start, :run_id => @run_id,
                                                :start_time => @start_time.to_s},
                {'X-Ops-Reporting-Protocol-Version' => Chef::ResourceReporter::PROTOCOL_VERSION}).
@@ -594,17 +594,17 @@ describe Chef::ResourceReporter do
 
       it "assumes the feature is not enabled" do
         @resource_reporter.run_started(@run_status)
-        @resource_reporter.reporting_enabled?.should be_false
+        expect(@resource_reporter.reporting_enabled?).to be_falsey
       end
 
       it "does not send a resource report to the server" do
         @resource_reporter.run_started(@run_status)
-        @rest_client.should_not_receive(:post_rest)
+        expect(@rest_client).not_to receive(:post_rest)
         @resource_reporter.run_completed(@node)
       end
 
       it "prints an error about the 404" do
-        Chef::Log.should_receive(:debug).with(/404/)
+        expect(Chef::Log).to receive(:debug).with(/404/)
         @resource_reporter.run_started(@run_status)
       end
 
@@ -615,7 +615,7 @@ describe Chef::ResourceReporter do
         # 500 getting the run_id
         @response = Net::HTTPInternalServerError.new("a response body", "500", "Internal Server Error")
         @error = Net::HTTPServerException.new("500 message", @response)
-        @rest_client.should_receive(:post_rest).
+        expect(@rest_client).to receive(:post_rest).
           with("reports/nodes/spitfire/runs", {:action => :start, :run_id => @run_id, :start_time => @start_time.to_s},
                {'X-Ops-Reporting-Protocol-Version' => Chef::ResourceReporter::PROTOCOL_VERSION}).
           and_raise(@error)
@@ -623,17 +623,17 @@ describe Chef::ResourceReporter do
 
       it "assumes the feature is not enabled" do
         @resource_reporter.run_started(@run_status)
-        @resource_reporter.reporting_enabled?.should be_false
+        expect(@resource_reporter.reporting_enabled?).to be_falsey
       end
 
       it "does not send a resource report to the server" do
         @resource_reporter.run_started(@run_status)
-        @rest_client.should_not_receive(:post_rest)
+        expect(@rest_client).not_to receive(:post_rest)
         @resource_reporter.run_completed(@node)
       end
 
       it "prints an error about the error" do
-        Chef::Log.should_receive(:info).with(/500/)
+        expect(Chef::Log).to receive(:info).with(/500/)
         @resource_reporter.run_started(@run_status)
       end
     end
@@ -645,7 +645,7 @@ describe Chef::ResourceReporter do
         # 500 getting the run_id
         @response = Net::HTTPInternalServerError.new("a response body", "500", "Internal Server Error")
         @error = Net::HTTPServerException.new("500 message", @response)
-        @rest_client.should_receive(:post_rest).
+        expect(@rest_client).to receive(:post_rest).
           with("reports/nodes/spitfire/runs", {:action => :start, :run_id => @run_id, :start_time => @start_time.to_s},
                {'X-Ops-Reporting-Protocol-Version' => Chef::ResourceReporter::PROTOCOL_VERSION}).
           and_raise(@error)
@@ -656,17 +656,17 @@ describe Chef::ResourceReporter do
       end
 
       it "fails the run and prints an message about the error" do
-        Chef::Log.should_receive(:error).with(/500/)
-        lambda {
+        expect(Chef::Log).to receive(:error).with(/500/)
+        expect {
           @resource_reporter.run_started(@run_status)
-        }.should raise_error(Net::HTTPServerException)
+        }.to raise_error(Net::HTTPServerException)
       end
     end
 
     context "after creating the run history document" do
       before do
         response = {"uri"=>"https://example.com/reports/nodes/spitfire/runs/@run_id"}
-        @rest_client.should_receive(:post_rest).
+        expect(@rest_client).to receive(:post_rest).
           with("reports/nodes/spitfire/runs", {:action => :start, :run_id => @run_id, :start_time => @start_time.to_s},
                {'X-Ops-Reporting-Protocol-Version' => Chef::ResourceReporter::PROTOCOL_VERSION}).
           and_return(response)
@@ -674,7 +674,7 @@ describe Chef::ResourceReporter do
       end
 
       it "creates a run document on the server at the start of the run" do
-        @resource_reporter.run_id.should == @run_id
+        expect(@resource_reporter.run_id).to eq(@run_id)
       end
 
       it "updates the run document with resource updates at the end of the run" do
@@ -683,25 +683,25 @@ describe Chef::ResourceReporter do
         @resource_reporter.resource_current_state_loaded(@new_resource, :create, @current_resource)
         @resource_reporter.resource_updated(@new_resource, :create)
 
-        @resource_reporter.stub(:end_time).and_return(@end_time)
+        allow(@resource_reporter).to receive(:end_time).and_return(@end_time)
         @expected_data = @resource_reporter.prepare_run_data
 
         post_url = "https://chef_server/example_url"
         response = {"result"=>"ok"}
 
-        @rest_client.should_receive(:create_url).
+        expect(@rest_client).to receive(:create_url).
           with("reports/nodes/spitfire/runs/#{@run_id}").
           ordered.
           and_return(post_url)
-        @rest_client.should_receive(:raw_http_request).ordered do |method, url, headers, data|
-          method.should eq(:POST)
-          url.should eq(post_url)
-          headers.should eq({'Content-Encoding' => 'gzip',
+        expect(@rest_client).to receive(:raw_http_request).ordered do |method, url, headers, data|
+          expect(method).to eq(:POST)
+          expect(url).to eq(post_url)
+          expect(headers).to eq({'Content-Encoding' => 'gzip',
                              'X-Ops-Reporting-Protocol-Version' => Chef::ResourceReporter::PROTOCOL_VERSION
           })
           data_stream = Zlib::GzipReader.new(StringIO.new(data))
           data = data_stream.read
-          data.should eq(Chef::JSONCompat.to_json(@expected_data))
+          expect(data).to eq(Chef::JSONCompat.to_json(@expected_data))
           response
         end
 
@@ -714,7 +714,7 @@ describe Chef::ResourceReporter do
         @enable_reporting_url_fatals = Chef::Config[:enable_reporting_url_fatals]
         Chef::Config[:enable_reporting_url_fatals] = true
         # this call doesn't matter for this context
-        @rest_client.stub(:create_url)
+        allow(@rest_client).to receive(:create_url)
       end
 
       after do
@@ -724,8 +724,8 @@ describe Chef::ResourceReporter do
       it "should log 4xx errors" do
         response = Net::HTTPClientError.new("forbidden", "403", "Forbidden")
         error = Net::HTTPServerException.new("403 message", response)
-        @rest_client.stub(:raw_http_request).and_raise(error)
-        Chef::Log.should_receive(:error).with(/403/)
+        allow(@rest_client).to receive(:raw_http_request).and_raise(error)
+        expect(Chef::Log).to receive(:error).with(/403/)
 
         @resource_reporter.post_reporting_data
       end
@@ -733,26 +733,26 @@ describe Chef::ResourceReporter do
       it "should log error 5xx errors" do
         response = Net::HTTPServerError.new("internal error", "500", "Internal Server Error")
         error = Net::HTTPFatalError.new("500 message", response)
-        @rest_client.stub(:raw_http_request).and_raise(error)
-        Chef::Log.should_receive(:error).with(/500/)
+        allow(@rest_client).to receive(:raw_http_request).and_raise(error)
+        expect(Chef::Log).to receive(:error).with(/500/)
 
         @resource_reporter.post_reporting_data
       end
 
       it "should log if a socket error happens" do
-        @rest_client.stub(:raw_http_request).and_raise(SocketError.new("test socket error"))
-        Chef::Log.should_receive(:error).with(/test socket error/)
+        allow(@rest_client).to receive(:raw_http_request).and_raise(SocketError.new("test socket error"))
+        expect(Chef::Log).to receive(:error).with(/test socket error/)
 
         @resource_reporter.post_reporting_data
 
       end
 
       it "should raise if an unkwown error happens" do
-        @rest_client.stub(:raw_http_request).and_raise(Exception.new)
+        allow(@rest_client).to receive(:raw_http_request).and_raise(Exception.new)
 
-        lambda {
+        expect {
           @resource_reporter.post_reporting_data
-        }.should raise_error(Exception)
+        }.to raise_error(Exception)
       end
     end
   end