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

data/spec/unit/mixin/checksum_spec.rb

@@ -30,11 +30,11 @@ describe Chef::Mixin::Checksum do
     @cache = Chef::Digester.instance
     @file = CHEF_SPEC_DATA + "/checksum/random.txt"
     @stat = double("File::Stat", { :mtime => Time.at(0) })
-    File.stub(:stat).and_return(@stat)
+    allow(File).to receive(:stat).and_return(@stat)
   end
 
   it "gets the checksum of a file" do
-    @checksum_user.checksum(@file).should == "09ee9c8cc70501763563bcf9c218d71b2fbf4186bf8e1e0da07f0f42c80a3394"
+    expect(@checksum_user.checksum(@file)).to eq("09ee9c8cc70501763563bcf9c218d71b2fbf4186bf8e1e0da07f0f42c80a3394")
   end
 
 end

data/spec/unit/mixin/command_spec.rb

@@ -31,41 +31,41 @@ describe Chef::Mixin::Command, :volatile do
 
       it "should be possible to read the child process's stdout and stderr" do
         popen4("sh -c 'echo hello && echo world >&2'") do |pid, stdin, stdout, stderr|
-          stdout.read.should == "hello\n"
-          stderr.read.should == "world\n"
+          expect(stdout.read).to eq("hello\n")
+          expect(stderr.read).to eq("world\n")
         end
       end
 
       it "should default all commands to be run in the POSIX standard C locale" do
         popen4("echo $LC_ALL") do |pid, stdin, stdout, stderr|
-          stdout.read.strip.should == "C"
+          expect(stdout.read.strip).to eq("C")
         end
       end
 
       it "should respect locale when specified explicitly" do
         popen4("echo $LC_ALL", :environment => {"LC_ALL" => "es"}) do |pid, stdin, stdout, stderr|
-          stdout.read.strip.should == "es"
+          expect(stdout.read.strip).to eq("es")
         end
       end
 
       it "should end when the child process reads from STDIN and a block is given" do
-        lambda {Timeout.timeout(10) do
+        expect {Timeout.timeout(10) do
             popen4("ruby -e 'while gets; end'", :waitlast => true) do |pid, stdin, stdout, stderr|
               (1..5).each { |i| stdin.puts "#{i}" }
             end
           end
-        }.should_not raise_error
+        }.not_to raise_error
       end
 
       describe "when a process detaches but doesn't close STDOUT and STDERR [CHEF-584]" do
 
         it "returns immediately after the first child process exits" do
-          lambda {Timeout.timeout(10) do
+          expect {Timeout.timeout(10) do
             pid, stdin,stdout,stderr = nil,nil,nil,nil
             evil_forker="exit if fork; 10.times { sleep 1}"
             popen4("ruby -e '#{evil_forker}'") do |pid,stdin,stdout,stderr|
             end
-          end}.should_not raise_error
+          end}.not_to raise_error
         end
 
       end
@@ -76,13 +76,13 @@ describe Chef::Mixin::Command, :volatile do
       include Chef::Mixin::Command
 
       it "logs the command's stderr and stdout output if the command failed" do
-        Chef::Log.stub(:level).and_return(:debug)
+        allow(Chef::Log).to receive(:level).and_return(:debug)
         begin
           run_command(:command => "sh -c 'echo hello; echo world >&2; false'")
           violated "Exception expected, but nothing raised."
         rescue => e
-          e.message.should =~ /STDOUT: hello/
-          e.message.should =~ /STDERR: world/
+          expect(e.message).to match(/STDOUT: hello/)
+          expect(e.message).to match(/STDERR: world/)
         end
       end
 
@@ -93,10 +93,10 @@ describe Chef::Mixin::Command, :volatile do
           # btm
           # Serdar - During Solaris tests, we've seen that processes
           # are taking a long time to exit. Bumping timeout now to 10.
-          lambda {Timeout.timeout(10) do
+          expect {Timeout.timeout(10) do
             evil_forker="exit if fork; 10.times { sleep 1}"
             run_command(:command => "ruby -e '#{evil_forker}'")
-          end}.should_not raise_error
+          end}.not_to raise_error
         end
 
       end

data/spec/unit/mixin/convert_to_class_name_spec.rb

@@ -29,26 +29,26 @@ describe Chef::Mixin::ConvertToClassName do
   end
 
   it "converts a_snake_case_word to a CamelCaseWord" do
-    @convert.convert_to_class_name("now_camelized").should == "NowCamelized"
+    expect(@convert.convert_to_class_name("now_camelized")).to eq("NowCamelized")
   end
 
   it "converts a CamelCaseWord to a snake_case_word" do
-    @convert.convert_to_snake_case("NowImASnake").should == "now_im_a_snake"
+    expect(@convert.convert_to_snake_case("NowImASnake")).to eq("now_im_a_snake")
   end
 
   it "removes the base classes before snake casing" do
-    @convert.convert_to_snake_case("NameSpaced::Class::ThisIsWin", "NameSpaced::Class").should == "this_is_win"
+    expect(@convert.convert_to_snake_case("NameSpaced::Class::ThisIsWin", "NameSpaced::Class")).to eq("this_is_win")
   end
 
   it "removes the base classes without explicitly naming them and returns snake case" do
-    @convert.snake_case_basename("NameSpaced::Class::ExtraWin").should == "extra_win"
+    expect(@convert.snake_case_basename("NameSpaced::Class::ExtraWin")).to eq("extra_win")
   end
 
   it "interprets non-alphanumeric characters in snake case as word boundaries" do
-    @convert.convert_to_class_name("now_camelized_without-hyphen").should == "NowCamelizedWithoutHyphen"
+    expect(@convert.convert_to_class_name("now_camelized_without-hyphen")).to eq("NowCamelizedWithoutHyphen")
   end
 
   it "interprets underscore" do
-    @convert.convert_to_class_name("_remove_leading_underscore").should == "RemoveLeadingUnderscore"
+    expect(@convert.convert_to_class_name("_remove_leading_underscore")).to eq("RemoveLeadingUnderscore")
   end
 end

data/spec/unit/mixin/deep_merge_spec.rb

@@ -37,175 +37,175 @@ describe Chef::Mixin::DeepMerge, "deep_merge!" do
     hash_src = {'id' => '2'}
     hash_dst = {}
     @dm.deep_merge!(hash_src.dup, hash_dst)
-    hash_dst.should == hash_src
+    expect(hash_dst).to eq(hash_src)
   end
 
   it "tests merging an hash w/array into blank hash" do
     hash_src = {'region' => {'id' => ['227', '2']}}
     hash_dst = {}
     @dm.deep_merge!(hash_src, hash_dst)
-    hash_dst.should == hash_src
+    expect(hash_dst).to eq(hash_src)
   end
 
   it "tests merge from empty hash" do
     hash_src = {}
     hash_dst = {"property" => ["2","4"]}
     @dm.deep_merge!(hash_src, hash_dst)
-    hash_dst.should == {"property" => ["2","4"]}
+    expect(hash_dst).to eq({"property" => ["2","4"]})
   end
 
   it "tests merge to empty hash" do
     hash_src = {"property" => ["2","4"]}
     hash_dst = {}
     @dm.deep_merge!(hash_src, hash_dst)
-    hash_dst.should == {"property" => ["2","4"]}
+    expect(hash_dst).to eq({"property" => ["2","4"]})
   end
 
   it "tests simple string overwrite" do
     hash_src = {"name" => "value"}
     hash_dst = {"name" => "value1"}
     @dm.deep_merge!(hash_src, hash_dst)
-    hash_dst.should == {"name" => "value"}
+    expect(hash_dst).to eq({"name" => "value"})
   end
 
   it "tests simple string overwrite of empty hash" do
     hash_src = {"name" => "value"}
     hash_dst = {}
     @dm.deep_merge!(hash_src, hash_dst)
-    hash_dst.should == hash_src
+    expect(hash_dst).to eq(hash_src)
   end
 
   it "tests hashes holding array" do
     hash_src = {"property" => ["1","3"]}
     hash_dst = {"property" => ["2","4"]}
     @dm.deep_merge!(hash_src, hash_dst)
-    hash_dst.should == {"property" => ["2","4","1","3"]}
+    expect(hash_dst).to eq({"property" => ["2","4","1","3"]})
   end
 
   it "tests hashes holding hashes holding arrays (array with duplicate elements is merged with dest then src" do
     hash_src = {"property" => {"bedroom_count" => ["1", "2"], "bathroom_count" => ["1", "4+"]}}
     hash_dst = {"property" => {"bedroom_count" => ["3", "2"], "bathroom_count" => ["2"]}}
     @dm.deep_merge!(hash_src, hash_dst)
-    hash_dst.should == {"property" => {"bedroom_count" => ["3","2","1"], "bathroom_count" => ["2", "1", "4+"]}}
+    expect(hash_dst).to eq({"property" => {"bedroom_count" => ["3","2","1"], "bathroom_count" => ["2", "1", "4+"]}})
   end
 
   it "tests hash holding hash holding array v string (string is overwritten by array)" do
     hash_src = {"property" => {"bedroom_count" => ["1", "2"], "bathroom_count" => ["1", "4+"]}}
     hash_dst = {"property" => {"bedroom_count" => "3", "bathroom_count" => ["2"]}}
     @dm.deep_merge!(hash_src, hash_dst)
-    hash_dst.should == {"property" => {"bedroom_count" => ["1", "2"], "bathroom_count" => ["2","1","4+"]}}
+    expect(hash_dst).to eq({"property" => {"bedroom_count" => ["1", "2"], "bathroom_count" => ["2","1","4+"]}})
   end
 
   it "tests hash holding hash holding string v array (array is overwritten by string)" do
     hash_src = {"property" => {"bedroom_count" => "3", "bathroom_count" => ["1", "4+"]}}
     hash_dst = {"property" => {"bedroom_count" => ["1", "2"], "bathroom_count" => ["2"]}}
     @dm.deep_merge!(hash_src, hash_dst)
-    hash_dst.should == {"property" => {"bedroom_count" => "3", "bathroom_count" => ["2","1","4+"]}}
+    expect(hash_dst).to eq({"property" => {"bedroom_count" => "3", "bathroom_count" => ["2","1","4+"]}})
   end
 
   it "tests hash holding hash holding hash v array (array is overwritten by hash)" do
     hash_src = {"property" => {"bedroom_count" => {"king_bed" => 3, "queen_bed" => 1}, "bathroom_count" => ["1", "4+"]}}
     hash_dst = {"property" => {"bedroom_count" => ["1", "2"], "bathroom_count" => ["2"]}}
     @dm.deep_merge!(hash_src, hash_dst)
-    hash_dst.should == {"property" => {"bedroom_count" => {"king_bed" => 3, "queen_bed" => 1}, "bathroom_count" => ["2","1","4+"]}}
+    expect(hash_dst).to eq({"property" => {"bedroom_count" => {"king_bed" => 3, "queen_bed" => 1}, "bathroom_count" => ["2","1","4+"]}})
   end
 
   it "tests 3 hash layers holding integers (integers are overwritten by source)" do
     hash_src = {"property" => {"bedroom_count" => {"king_bed" => 3, "queen_bed" => 1}, "bathroom_count" => ["1", "4+"]}}
     hash_dst = {"property" => {"bedroom_count" => {"king_bed" => 2, "queen_bed" => 4}, "bathroom_count" => ["2"]}}
     @dm.deep_merge!(hash_src, hash_dst)
-    hash_dst.should == {"property" => {"bedroom_count" => {"king_bed" => 3, "queen_bed" => 1}, "bathroom_count" => ["2","1","4+"]}}
+    expect(hash_dst).to eq({"property" => {"bedroom_count" => {"king_bed" => 3, "queen_bed" => 1}, "bathroom_count" => ["2","1","4+"]}})
   end
 
   it "tests 3 hash layers holding arrays of int (arrays are merged)" do
     hash_src = {"property" => {"bedroom_count" => {"king_bed" => [3], "queen_bed" => [1]}, "bathroom_count" => ["1", "4+"]}}
     hash_dst = {"property" => {"bedroom_count" => {"king_bed" => [2], "queen_bed" => [4]}, "bathroom_count" => ["2"]}}
     @dm.deep_merge!(hash_src, hash_dst)
-    hash_dst.should == {"property" => {"bedroom_count" => {"king_bed" => [2,3], "queen_bed" => [4,1]}, "bathroom_count" => ["2","1","4+"]}}
+    expect(hash_dst).to eq({"property" => {"bedroom_count" => {"king_bed" => [2,3], "queen_bed" => [4,1]}, "bathroom_count" => ["2","1","4+"]}})
   end
 
   it "tests 1 hash overwriting 3 hash layers holding arrays of int" do
     hash_src = {"property" => "1"}
     hash_dst = {"property" => {"bedroom_count" => {"king_bed" => [2], "queen_bed" => [4]}, "bathroom_count" => ["2"]}}
     @dm.deep_merge!(hash_src, hash_dst)
-    hash_dst.should == {"property" => "1"}
+    expect(hash_dst).to eq({"property" => "1"})
   end
 
   it "tests 3 hash layers holding arrays of int (arrays are merged) but second hash's array is overwritten" do
     hash_src = {"property" => {"bedroom_count" => {"king_bed" => [3], "queen_bed" => [1]}, "bathroom_count" => "1"}}
     hash_dst = {"property" => {"bedroom_count" => {"king_bed" => [2], "queen_bed" => [4]}, "bathroom_count" => ["2"]}}
     @dm.deep_merge!(hash_src, hash_dst)
-    hash_dst.should == {"property" => {"bedroom_count" => {"king_bed" => [2,3], "queen_bed" => [4,1]}, "bathroom_count" => "1"}}
+    expect(hash_dst).to eq({"property" => {"bedroom_count" => {"king_bed" => [2,3], "queen_bed" => [4,1]}, "bathroom_count" => "1"}})
   end
 
   it "tests 3 hash layers holding arrays of int, but one holds int. This one overwrites, but the rest merge" do
     hash_src = {"property" => {"bedroom_count" => {"king_bed" => 3, "queen_bed" => [1]}, "bathroom_count" => ["1"]}}
     hash_dst = {"property" => {"bedroom_count" => {"king_bed" => [2], "queen_bed" => [4]}, "bathroom_count" => ["2"]}}
     @dm.deep_merge!(hash_src, hash_dst)
-    hash_dst.should == {"property" => {"bedroom_count" => {"king_bed" => 3, "queen_bed" => [4,1]}, "bathroom_count" => ["2","1"]}}
+    expect(hash_dst).to eq({"property" => {"bedroom_count" => {"king_bed" => 3, "queen_bed" => [4,1]}, "bathroom_count" => ["2","1"]}})
   end
 
   it "tests 3 hash layers holding arrays of int, but source is incomplete." do
     hash_src = {"property" => {"bedroom_count" => {"king_bed" => [3]}, "bathroom_count" => ["1"]}}
     hash_dst = {"property" => {"bedroom_count" => {"king_bed" => [2], "queen_bed" => [4]}, "bathroom_count" => ["2"]}}
     @dm.deep_merge!(hash_src, hash_dst)
-    hash_dst.should == {"property" => {"bedroom_count" => {"king_bed" => [2,3], "queen_bed" => [4]}, "bathroom_count" => ["2","1"]}}
+    expect(hash_dst).to eq({"property" => {"bedroom_count" => {"king_bed" => [2,3], "queen_bed" => [4]}, "bathroom_count" => ["2","1"]}})
   end
 
   it "tests 3 hash layers holding arrays of int, but source is shorter and has new 2nd level ints." do
     hash_src = {"property" => {"bedroom_count" => {2=>3, "king_bed" => [3]}, "bathroom_count" => ["1"]}}
     hash_dst = {"property" => {"bedroom_count" => {"king_bed" => [2], "queen_bed" => [4]}, "bathroom_count" => ["2"]}}
     @dm.deep_merge!(hash_src, hash_dst)
-    hash_dst.should == {"property" => {"bedroom_count" => {2=>3, "king_bed" => [2,3], "queen_bed" => [4]}, "bathroom_count" => ["2","1"]}}
+    expect(hash_dst).to eq({"property" => {"bedroom_count" => {2=>3, "king_bed" => [2,3], "queen_bed" => [4]}, "bathroom_count" => ["2","1"]}})
   end
 
   it "tests 3 hash layers holding arrays of int, but source is empty" do
     hash_src = {}
     hash_dst = {"property" => {"bedroom_count" => {"king_bed" => [2], "queen_bed" => [4]}, "bathroom_count" => ["2"]}}
     @dm.deep_merge!(hash_src, hash_dst)
-    hash_dst.should == {"property" => {"bedroom_count" => {"king_bed" => [2], "queen_bed" => [4]}, "bathroom_count" => ["2"]}}
+    expect(hash_dst).to eq({"property" => {"bedroom_count" => {"king_bed" => [2], "queen_bed" => [4]}, "bathroom_count" => ["2"]}})
   end
 
   it "tests 3 hash layers holding arrays of int, but dest is empty" do
     hash_src = {"property" => {"bedroom_count" => {2=>3, "king_bed" => [3]}, "bathroom_count" => ["1"]}}
     hash_dst = {}
     @dm.deep_merge!(hash_src, hash_dst)
-    hash_dst.should == {"property" => {"bedroom_count" => {2=>3, "king_bed" => [3]}, "bathroom_count" => ["1"]}}
+    expect(hash_dst).to eq({"property" => {"bedroom_count" => {2=>3, "king_bed" => [3]}, "bathroom_count" => ["1"]}})
   end
 
   it "tests hash holding arrays of arrays" do
     hash_src = {["1", "2", "3"] => ["1", "2"]}
     hash_dst = {["4", "5"] => ["3"]}
     @dm.deep_merge!(hash_src, hash_dst)
-    hash_dst.should == {["1","2","3"] => ["1", "2"], ["4", "5"] => ["3"]}
+    expect(hash_dst).to eq({["1","2","3"] => ["1", "2"], ["4", "5"] => ["3"]})
   end
 
   it "tests merging of hash with blank hash, and make sure that source array split does not function when turned off" do
     hash_src = {'property' => {'bedroom_count' => ["1","2,3"]}}
     hash_dst = {}
     @dm.deep_merge!(hash_src, hash_dst)
-    hash_dst.should == {'property' => {'bedroom_count' => ["1","2,3"]}}
+    expect(hash_dst).to eq({'property' => {'bedroom_count' => ["1","2,3"]}})
   end
 
   it "tests merging into a blank hash" do
     hash_src = {"action"=>"browse", "controller"=>"results"}
     hash_dst = {}
     @dm.deep_merge!(hash_src, hash_dst)
-    hash_dst.should == hash_src
+    expect(hash_dst).to eq(hash_src)
   end
 
   it "tests are unmerged hashes passed unmodified w/out :unpack_arrays?" do
     hash_src = {"amenity"=>{"id"=>["26,27"]}}
     hash_dst = {}
     @dm.deep_merge!(hash_src, hash_dst)
-    hash_dst.should == {"amenity"=>{"id"=>["26,27"]}}
+    expect(hash_dst).to eq({"amenity"=>{"id"=>["26,27"]}})
   end
 
   it "tests hash of array of hashes" do
     hash_src = {"item" => [{"1" => "3"}, {"2" => "4"}]}
     hash_dst = {"item" => [{"3" => "5"}]}
     @dm.deep_merge!(hash_src, hash_dst)
-    hash_dst.should == {"item" => [{"3" => "5"}, {"1" => "3"}, {"2" => "4"}]}
+    expect(hash_dst).to eq({"item" => [{"3" => "5"}, {"1" => "3"}, {"2" => "4"}]})
   end
 
   # Additions since import
@@ -213,28 +213,28 @@ describe Chef::Mixin::DeepMerge, "deep_merge!" do
     hash_src = {"valid" => false}
     hash_dst = {"valid" => true}
     @dm.deep_merge!(hash_src, hash_dst)
-    hash_dst.should == {"valid" => false}
+    expect(hash_dst).to eq({"valid" => false})
   end
 
   it "should overwrite false with true when merging boolean values" do
     hash_src = {"valid" => true}
     hash_dst = {"valid" => false}
     @dm.deep_merge!(hash_src, hash_dst)
-    hash_dst.should == {"valid" => true}
+    expect(hash_dst).to eq({"valid" => true})
   end
 
   it "should overwrite a string with an empty string when merging string values" do
     hash_src = {"item" => " "}
     hash_dst = {"item" => "orange"}
     @dm.deep_merge!(hash_src, hash_dst)
-    hash_dst.should == {"item" => " "}
+    expect(hash_dst).to eq({"item" => " "})
   end
 
   it "should overwrite an empty string with a string when merging string values" do
     hash_src = {"item" => "orange"}
     hash_dst = {"item" => " "}
     @dm.deep_merge!(hash_src, hash_dst)
-    hash_dst.should == {"item" => "orange"}
+    expect(hash_dst).to eq({"item" => "orange"})
   end
 end # deep_merge!
 
@@ -248,40 +248,40 @@ describe Chef::Mixin::DeepMerge do
     it "should merge a hash into an empty hash" do
       hash_dst = {}
       hash_src = {'id' => '2'}
-      @dm.merge(hash_dst, hash_src).should == hash_src
+      expect(@dm.merge(hash_dst, hash_src)).to eq(hash_src)
     end
 
     it "should merge a nested hash into an empty hash" do
       hash_dst = {}
       hash_src = {'region' => {'id' => ['227', '2']}}
-      @dm.merge(hash_dst, hash_src).should == hash_src
+      expect(@dm.merge(hash_dst, hash_src)).to eq(hash_src)
     end
 
     it "should overwrite as string value when merging hashes" do
       hash_dst = {"name" => "value1"}
       hash_src = {"name" => "value"}
-      @dm.merge(hash_dst, hash_src).should == {"name" => "value"}
+      expect(@dm.merge(hash_dst, hash_src)).to eq({"name" => "value"})
     end
 
     it "should merge arrays within hashes" do
       hash_dst = {"property" => ["2","4"]}
       hash_src = {"property" => ["1","3"]}
-      @dm.merge(hash_dst, hash_src).should == {"property" => ["2","4","1","3"]}
+      expect(@dm.merge(hash_dst, hash_src)).to eq({"property" => ["2","4","1","3"]})
     end
 
     it "should merge deeply nested hashes" do
       hash_dst = {"property" => {"values" => {"are" => "falling", "can" => "change"}}}
       hash_src = {"property" => {"values" => {"are" => "stable", "may" => "rise"}}}
-      @dm.merge(hash_dst, hash_src).should == {"property" => {"values" => {"are" => "stable", "can" => "change", "may" => "rise"}}}
+      expect(@dm.merge(hash_dst, hash_src)).to eq({"property" => {"values" => {"are" => "stable", "can" => "change", "may" => "rise"}}})
     end
 
     it "should not modify the source or destination during the merge" do
       hash_dst = {"property" => ["1","2","3"]}
       hash_src = {"property" => ["4","5","6"]}
       ret = @dm.merge(hash_dst, hash_src)
-      hash_dst.should == {"property" => ["1","2","3"]}
-      hash_src.should == {"property" => ["4","5","6"]}
-      ret.should == {"property" => ["1","2","3","4","5","6"]}
+      expect(hash_dst).to eq({"property" => ["1","2","3"]})
+      expect(hash_src).to eq({"property" => ["4","5","6"]})
+      expect(ret).to eq({"property" => ["1","2","3","4","5","6"]})
     end
 
     it "should not error merging un-dupable objects" do
@@ -297,10 +297,10 @@ describe Chef::Mixin::DeepMerge do
 
       merged_result = @dm.hash_only_merge(merge_ee_hash, merge_with_hash)
 
-      merged_result["top_level_b"].should == "top-level-b-merged-onto"
-      merged_result["top_level_a"]["1_deep_a"].should == "1-a-merge-ee"
-      merged_result["top_level_a"]["1_deep_b"].should == "1-deep-b-merged-onto"
-      merged_result["top_level_a"]["1_deep_c"].should == "1-deep-c-merged-onto"
+      expect(merged_result["top_level_b"]).to eq("top-level-b-merged-onto")
+      expect(merged_result["top_level_a"]["1_deep_a"]).to eq("1-a-merge-ee")
+      expect(merged_result["top_level_a"]["1_deep_b"]).to eq("1-deep-b-merged-onto")
+      expect(merged_result["top_level_a"]["1_deep_c"]).to eq("1-deep-c-merged-onto")
     end
 
     it "replaces arrays rather than merging them" do
@@ -309,9 +309,9 @@ describe Chef::Mixin::DeepMerge do
 
       merged_result = @dm.hash_only_merge(merge_ee_hash, merge_with_hash)
 
-      merged_result["top_level_b"].should == "top-level-b-merged-onto"
-      merged_result["top_level_a"]["1_deep_a"].should == "1-a-merge-ee"
-      merged_result["top_level_a"]["1_deep_b"].should == %w[B B B]
+      expect(merged_result["top_level_b"]).to eq("top-level-b-merged-onto")
+      expect(merged_result["top_level_a"]["1_deep_a"]).to eq("1-a-merge-ee")
+      expect(merged_result["top_level_a"]["1_deep_b"]).to eq(%w[B B B])
     end
 
     it "replaces non-hash items with hashes when there's a conflict" do
@@ -320,17 +320,17 @@ describe Chef::Mixin::DeepMerge do
 
       merged_result = @dm.hash_only_merge(merge_ee_hash, merge_with_hash)
 
-      merged_result["top_level_a"].should be_a(Hash)
-      merged_result["top_level_a"]["1_deep_a"].should be_nil
-      merged_result["top_level_a"]["1_deep_b"].should == %w[B B B]
+      expect(merged_result["top_level_a"]).to be_a(Hash)
+      expect(merged_result["top_level_a"]["1_deep_a"]).to be_nil
+      expect(merged_result["top_level_a"]["1_deep_b"]).to eq(%w[B B B])
     end
 
     it "does not mutate deeply-nested original hashes by default" do
       merge_ee_hash =   {"top_level_a" => {"1_deep_a" => { "2_deep_a" => { "3_deep_a" => "foo" }}}}
       merge_with_hash = {"top_level_a" => {"1_deep_a" => { "2_deep_a" => { "3_deep_b" => "bar" }}}}
       @dm.hash_only_merge(merge_ee_hash, merge_with_hash)
-      merge_ee_hash.should == {"top_level_a" => {"1_deep_a" => { "2_deep_a" => { "3_deep_a" => "foo" }}}}
-      merge_with_hash.should == {"top_level_a" => {"1_deep_a" => { "2_deep_a" => { "3_deep_b" => "bar" }}}}
+      expect(merge_ee_hash).to eq({"top_level_a" => {"1_deep_a" => { "2_deep_a" => { "3_deep_a" => "foo" }}}})
+      expect(merge_with_hash).to eq({"top_level_a" => {"1_deep_a" => { "2_deep_a" => { "3_deep_b" => "bar" }}}})
     end
 
     it "does not error merging un-dupable items" do