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

data/spec/unit/util/powershell/cmdlet_spec.rb

@@ -51,18 +51,18 @@ describe Chef::Util::Powershell::Cmdlet do
     # Is this list really complete?
     %w{` " # '}.each do |c|
       it "escapse #{c}" do
-        @cmdlet.send(:escape_parameter_value, "stuff #{c}").should eql("stuff `#{c}")
+        expect(@cmdlet.send(:escape_parameter_value, "stuff #{c}")).to eql("stuff `#{c}")
       end
     end
 
     it 'does not do anything to a string without special characters' do
-      @cmdlet.send(:escape_parameter_value, 'stuff').should eql('stuff')
+      expect(@cmdlet.send(:escape_parameter_value, 'stuff')).to eql('stuff')
     end
   end
 
   describe '#escape_string_parameter_value' do
     it "surrounds a string with ''" do
-      @cmdlet.send(:escape_string_parameter_value, 'stuff').should eql("'stuff'")
+      expect(@cmdlet.send(:escape_string_parameter_value, 'stuff')).to eql("'stuff'")
     end
   end
 
@@ -80,27 +80,27 @@ describe Chef::Util::Powershell::Cmdlet do
     end
 
     it 'ignores switches with a false value' do
-      @cmdlet.send(:command_switches_string, {foo: false}).should eql('')
+      expect(@cmdlet.send(:command_switches_string, {foo: false})).to eql('')
     end
 
     it 'should correctly handle a value type of string' do
-      @cmdlet.send(:command_switches_string, {foo: 'bar'}).should eql("-foo 'bar'")
+      expect(@cmdlet.send(:command_switches_string, {foo: 'bar'})).to eql("-foo 'bar'")
     end
 
     it 'should correctly handle a value type of string even when it is 0 length' do
-      @cmdlet.send(:command_switches_string, {foo: ''}).should eql("-foo ''")
+      expect(@cmdlet.send(:command_switches_string, {foo: ''})).to eql("-foo ''")
     end
 
     it 'should not quote integers' do
-      @cmdlet.send(:command_switches_string, {foo: 1}).should eql("-foo 1")
+      expect(@cmdlet.send(:command_switches_string, {foo: 1})).to eql("-foo 1")
     end
 
     it 'should not quote floats' do
-      @cmdlet.send(:command_switches_string, {foo: 1.0}).should eql("-foo 1.0")
+      expect(@cmdlet.send(:command_switches_string, {foo: 1.0})).to eql("-foo 1.0")
     end
 
     it 'has just the switch when the value is true' do
-      @cmdlet.send(:command_switches_string, {foo: true}).should eql("-foo")
+      expect(@cmdlet.send(:command_switches_string, {foo: true})).to eql("-foo")
     end
   end
 end

data/spec/unit/util/selinux_spec.rb

@@ -44,17 +44,17 @@ describe Chef::Util::Selinux do
 
     expected_paths.each do |bin_path|
       selinux_path = File.join(bin_path, "selinuxenabled")
-      File.should_receive(:executable?).with(selinux_path).and_return(false)
+      expect(File).to receive(:executable?).with(selinux_path).and_return(false)
     end
 
-    @test_instance.selinux_enabled?.should be_false
+    expect(@test_instance.selinux_enabled?).to be_falsey
   end
 
   describe "when selinuxenabled binary exists" do
     before do
       @selinux_enabled_path = File.join("/sbin", "selinuxenabled")
-      File.stub(:executable?) do |file_path|
-        file_path.end_with?("selinuxenabled").should be_true
+      allow(File).to receive(:executable?) do |file_path|
+        expect(file_path.end_with?("selinuxenabled")).to be_truthy
         file_path == @selinux_enabled_path
       end
     end
@@ -62,54 +62,54 @@ describe Chef::Util::Selinux do
     describe "when selinux is enabled" do
       before do
         cmd_result = double("Cmd Result", :exitstatus => 0)
-        @test_instance.should_receive(:shell_out!).once.with(@selinux_enabled_path, {:returns=>[0, 1]}).and_return(cmd_result)
+        expect(@test_instance).to receive(:shell_out!).once.with(@selinux_enabled_path, {:returns=>[0, 1]}).and_return(cmd_result)
       end
 
       it "should report selinux is enabled" do
-        @test_instance.selinux_enabled?.should be_true
+        expect(@test_instance.selinux_enabled?).to be_truthy
         # should check the file system only once for multiple calls
-        @test_instance.selinux_enabled?.should be_true
+        expect(@test_instance.selinux_enabled?).to be_truthy
       end
     end
 
     describe "when selinux is disabled" do
       before do
         cmd_result = double("Cmd Result", :exitstatus => 1)
-        @test_instance.should_receive(:shell_out!).once.with(@selinux_enabled_path, {:returns=>[0, 1]}).and_return(cmd_result)
+        expect(@test_instance).to receive(:shell_out!).once.with(@selinux_enabled_path, {:returns=>[0, 1]}).and_return(cmd_result)
       end
 
       it "should report selinux is disabled" do
-        @test_instance.selinux_enabled?.should be_false
+        expect(@test_instance.selinux_enabled?).to be_falsey
         # should check the file system only once for multiple calls
-        @test_instance.selinux_enabled?.should be_false
+        expect(@test_instance.selinux_enabled?).to be_falsey
       end
     end
 
     describe "when selinux gives an unexpected status" do
       before do
         cmd_result = double("Cmd Result", :exitstatus => 101)
-        @test_instance.should_receive(:shell_out!).once.with(@selinux_enabled_path, {:returns=>[0, 1]}).and_return(cmd_result)
+        expect(@test_instance).to receive(:shell_out!).once.with(@selinux_enabled_path, {:returns=>[0, 1]}).and_return(cmd_result)
       end
 
       it "should throw an error" do
-        lambda {@test_instance.selinux_enabled?}.should raise_error(RuntimeError)
+        expect {@test_instance.selinux_enabled?}.to raise_error(RuntimeError)
       end
     end
   end
 
   describe "when selinuxenabled binary doesn't exist" do
     before do
-      File.stub(:executable?) do |file_path|
-        file_path.end_with?("selinuxenabled").should be_true
+      allow(File).to receive(:executable?) do |file_path|
+        expect(file_path.end_with?("selinuxenabled")).to be_truthy
         false
       end
     end
 
     it "should report selinux is disabled" do
-      @test_instance.selinux_enabled?.should be_false
+      expect(@test_instance.selinux_enabled?).to be_falsey
       # should check the file system only once for multiple calls
-      File.should_not_receive(:executable?)
-      @test_instance.selinux_enabled?.should be_false
+      expect(File).not_to receive(:executable?)
+      expect(@test_instance.selinux_enabled?).to be_falsey
     end
   end
 
@@ -118,53 +118,53 @@ describe Chef::Util::Selinux do
 
     before do
       @restorecon_enabled_path = File.join("/sbin", "restorecon")
-      File.stub(:executable?) do |file_path|
-        file_path.end_with?("restorecon").should be_true
+      allow(File).to receive(:executable?) do |file_path|
+        expect(file_path.end_with?("restorecon")).to be_truthy
         file_path == @restorecon_enabled_path
       end
     end
 
     it "should call restorecon non-recursive by default" do
       restorecon_command = "#{@restorecon_enabled_path} -R \"#{path}\""
-      @test_instance.should_receive(:shell_out!).twice.with(restorecon_command)
+      expect(@test_instance).to receive(:shell_out!).twice.with(restorecon_command)
       @test_instance.restore_security_context(path)
-      File.should_not_receive(:executable?)
+      expect(File).not_to receive(:executable?)
       @test_instance.restore_security_context(path)
     end
 
     it "should call restorecon recursive when recursive is set" do
       restorecon_command = "#{@restorecon_enabled_path} -R -r \"#{path}\""
-      @test_instance.should_receive(:shell_out!).twice.with(restorecon_command)
+      expect(@test_instance).to receive(:shell_out!).twice.with(restorecon_command)
       @test_instance.restore_security_context(path, true)
-      File.should_not_receive(:executable?)
+      expect(File).not_to receive(:executable?)
       @test_instance.restore_security_context(path, true)
     end
 
     it "should call restorecon non-recursive when recursive is not set" do
       restorecon_command = "#{@restorecon_enabled_path} -R \"#{path}\""
-      @test_instance.should_receive(:shell_out!).twice.with(restorecon_command)
+      expect(@test_instance).to receive(:shell_out!).twice.with(restorecon_command)
       @test_instance.restore_security_context(path)
-      File.should_not_receive(:executable?)
+      expect(File).not_to receive(:executable?)
       @test_instance.restore_security_context(path)
     end
 
     describe "when restorecon doesn't exist on the system" do
       before do
-        File.stub(:executable?) do |file_path|
-          file_path.end_with?("restorecon").should be_true
+        allow(File).to receive(:executable?) do |file_path|
+          expect(file_path.end_with?("restorecon")).to be_truthy
           false
         end
       end
 
       it "should log a warning message" do
         log = [ ]
-        Chef::Log.stub(:warn) do |message|
+        allow(Chef::Log).to receive(:warn) do |message|
           log << message
         end
 
         @test_instance.restore_security_context(path)
-        log.should_not be_empty
-        File.should_not_receive(:executable?)
+        expect(log).not_to be_empty
+        expect(File).not_to receive(:executable?)
         @test_instance.restore_security_context(path)
       end
     end

data/spec/unit/util/threaded_job_queue_spec.rb

@@ -23,8 +23,8 @@ describe Chef::Util::ThreadedJobQueue do
 
   it "should pass mutex to jobs with an arity of 1" do
     job = double()
-    job.should_receive(:arity).at_least(:once).and_return(1)
-    job.should_receive(:call).exactly(5).times.with(an_instance_of(Mutex))
+    expect(job).to receive(:arity).at_least(:once).and_return(1)
+    expect(job).to receive(:call).exactly(5).times.with(an_instance_of(Mutex))
 
     5.times { queue << job }
     queue.process
@@ -32,20 +32,20 @@ describe Chef::Util::ThreadedJobQueue do
 
   it "should pass nothing to jobs with an arity of 0" do
     job = double()
-    job.should_receive(:arity).at_least(:once).and_return(0)
-    job.should_receive(:call).exactly(5).times.with(no_args)
+    expect(job).to receive(:arity).at_least(:once).and_return(0)
+    expect(job).to receive(:call).exactly(5).times.with(no_args)
 
     5.times { queue << job }
     queue.process
   end
 
   it "should use specified number of threads" do
-    Thread.should_receive(:new).exactly(7).times.and_call_original
+    expect(Thread).to receive(:new).exactly(7).times.and_call_original
     queue.process(7)
   end
 
   it "should propagate exceptions to the main thread" do
     queue << lambda { raise WorkerThreadError }
-    lambda { queue.process }.should raise_error(WorkerThreadError)
+    expect { queue.process }.to raise_error(WorkerThreadError)
   end
 end

data/spec/unit/version/platform_spec.rb

@@ -21,12 +21,12 @@ describe Chef::Version::Platform do
 
   it "is a subclass of Chef::Version" do
     v = Chef::Version::Platform.new('1.1')
-    v.should be_an_instance_of(Chef::Version::Platform)
-    v.should be_a_kind_of(Chef::Version)
+    expect(v).to be_an_instance_of(Chef::Version::Platform)
+    expect(v).to be_a_kind_of(Chef::Version)
   end
 
   it "should transform 1 to 1.0.0" do
-    Chef::Version::Platform.new("1").to_s.should == "1.0.0"
+    expect(Chef::Version::Platform.new("1").to_s).to eq("1.0.0")
   end
 
   describe "when creating valid Versions" do
@@ -44,7 +44,7 @@ describe Chef::Version::Platform do
     the_error = Chef::Exceptions::InvalidPlatformVersion
     bad_versions.each do |v|
       it "should raise #{the_error} when given '#{v}'" do
-        lambda { Chef::Version::Platform.new v }.should raise_error(the_error)
+        expect { Chef::Version::Platform.new v }.to raise_error(the_error)
       end
     end
   end
@@ -52,7 +52,7 @@ describe Chef::Version::Platform do
   describe "<=>" do
 
     it "should equate versions 1 and 1.0.0" do
-      Chef::Version::Platform.new("1").should == Chef::Version::Platform.new("1.0.0")
+      expect(Chef::Version::Platform.new("1")).to eq(Chef::Version::Platform.new("1.0.0"))
     end
 
   end

data/spec/unit/version_class_spec.rb

@@ -25,22 +25,22 @@ describe Chef::Version do
   end
 
   it "should turn itself into a string" do
-    @v0.to_s.should == "0.0.0"
-    @v123.to_s.should == "1.2.3"
+    expect(@v0.to_s).to eq("0.0.0")
+    expect(@v123.to_s).to eq("1.2.3")
   end
 
   it "should make a round trip with its string representation" do
     a = Chef::Version.new(@v123.to_s)
-    a.should == @v123
+    expect(a).to eq(@v123)
   end
 
   it "should transform 1.2 to 1.2.0" do
-    Chef::Version.new("1.2").to_s.should == "1.2.0"
+    expect(Chef::Version.new("1.2").to_s).to eq("1.2.0")
   end
 
   it "should transform 01.002.0003 to 1.2.3" do
     a = Chef::Version.new "01.002.0003"
-    a.should == @v123
+    expect(a).to eq(@v123)
   end
 
   describe "when creating valid Versions" do
@@ -58,7 +58,7 @@ describe Chef::Version do
     the_error = Chef::Exceptions::InvalidCookbookVersion
     bad_versions.each do |v|
       it "should raise #{the_error} when given '#{v}'" do
-        lambda { Chef::Version.new v }.should raise_error(the_error)
+        expect { Chef::Version.new v }.to raise_error(the_error)
       end
     end
   end
@@ -66,15 +66,15 @@ describe Chef::Version do
   describe "<=>" do
 
     it "should equate versions 1.2 and 1.2.0" do
-      Chef::Version.new("1.2").should == Chef::Version.new("1.2.0")
+      expect(Chef::Version.new("1.2")).to eq(Chef::Version.new("1.2.0"))
     end
 
     it "should equate version 1.04 and 1.4" do
-      Chef::Version.new("1.04").should == Chef::Version.new("1.4")
+      expect(Chef::Version.new("1.04")).to eq(Chef::Version.new("1.4"))
     end
 
     it "should treat versions as numbers in the right way" do
-      Chef::Version.new("2.0").should be < Chef::Version.new("11.0")
+      expect(Chef::Version.new("2.0")).to be < Chef::Version.new("11.0")
     end
 
     it "should sort based on the version number" do
@@ -95,9 +95,9 @@ describe Chef::Version do
       examples.each do |smaller, larger|
         sm = Chef::Version.new(smaller)
         lg = Chef::Version.new(larger)
-        sm.should be < lg
-        lg.should be > sm
-        sm.should_not == lg
+        expect(sm).to be < lg
+        expect(lg).to be > sm
+        expect(sm).not_to eq(lg)
       end
     end
 
@@ -106,7 +106,7 @@ describe Chef::Version do
         Chef::Version.new(s)
       end
       got = a.sort.map {|v| v.to_s }
-      got.should == %w{0.0.0 0.0.1 0.1.0 0.1.1 1.0.0 1.1.0 1.1.1}
+      expect(got).to eq(%w{0.0.0 0.0.1 0.1.0 0.1.1 1.0.0 1.1.0 1.1.1})
     end
 
     it "should sort an array of versions, part 2" do
@@ -114,7 +114,7 @@ describe Chef::Version do
         Chef::Version.new(s)
       end
       got = a.sort.map { |v| v.to_s }
-      got.should == %w{0.8.6 1.0.0 1.2.3 3.5.7 4.4.6 4.5.5 4.5.6 5.9.8 9.8.7}
+      expect(got).to eq(%w{0.8.6 1.0.0 1.2.3 3.5.7 4.4.6 4.5.5 4.5.6 5.9.8 9.8.7})
     end
 
     describe "comparison examples" do
@@ -163,7 +163,7 @@ describe Chef::Version do
         it "(#{spec.first(3).join(' ')}) should be #{spec[3]}" do
           got = Chef::Version.new(spec[0]).send(spec[1],
                                                 Chef::Version.new(spec[2]))
-          got.should == spec[3]
+          expect(got).to eq(spec[3])
         end
       end
     end

data/spec/unit/version_constraint/platform_spec.rb

@@ -21,24 +21,24 @@ describe Chef::VersionConstraint::Platform do
 
   it "is a subclass of Chef::VersionConstraint" do
     v = Chef::VersionConstraint::Platform.new
-    v.should be_an_instance_of(Chef::VersionConstraint::Platform)
-    v.should be_a_kind_of(Chef::VersionConstraint)
+    expect(v).to be_an_instance_of(Chef::VersionConstraint::Platform)
+    expect(v).to be_a_kind_of(Chef::VersionConstraint)
   end
 
   it "should work with Chef::Version::Platform classes" do
     vc = Chef::VersionConstraint::Platform.new("1.0")
-    vc.version.should be_an_instance_of(Chef::Version::Platform)
+    expect(vc.version).to be_an_instance_of(Chef::Version::Platform)
   end
 
   describe "include?" do
 
     it "pessimistic ~> x" do
       vc = Chef::VersionConstraint::Platform.new "~> 1"
-      vc.should include "1.3.3"
-      vc.should include "1.4"
+      expect(vc).to include "1.3.3"
+      expect(vc).to include "1.4"
 
-      vc.should_not include "2.2"
-      vc.should_not include "0.3.0"
+      expect(vc).not_to include "2.2"
+      expect(vc).not_to include "0.3.0"
     end
 
   end

data/spec/unit/version_constraint_spec.rb

@@ -26,18 +26,18 @@ describe Chef::VersionConstraint do
     v_error = Chef::Exceptions::InvalidCookbookVersion
     bad_version.each do |s|
       it "should raise #{v_error} when given #{s}" do
-        lambda { Chef::VersionConstraint.new s }.should raise_error(v_error)
+        expect { Chef::VersionConstraint.new s }.to raise_error(v_error)
       end
     end
     bad_op.each do |s|
       it "should raise #{o_error} when given #{s}" do
-        lambda { Chef::VersionConstraint.new s }.should raise_error(o_error)
+        expect { Chef::VersionConstraint.new s }.to raise_error(o_error)
       end
     end
 
     it "should interpret a lone version number as implicit = OP" do
       vc = Chef::VersionConstraint.new("1.2.3")
-      vc.to_s.should == "= 1.2.3"
+      expect(vc.to_s).to eq("= 1.2.3")
     end
 
     it "should allow initialization with [] for back compatibility" do
@@ -52,28 +52,28 @@ describe Chef::VersionConstraint do
 
   it "should default to >= 0.0.0" do
     vc = Chef::VersionConstraint.new
-    vc.to_s.should == ">= 0.0.0"
+    expect(vc.to_s).to eq(">= 0.0.0")
   end
 
   it "should default to >= 0.0.0 when initialized with nil" do
-    Chef::VersionConstraint.new(nil).to_s.should == ">= 0.0.0"
+    expect(Chef::VersionConstraint.new(nil).to_s).to eq(">= 0.0.0")
   end
 
   it "should work with Chef::Version classes" do
     vc = Chef::VersionConstraint.new("1.0")
-    vc.version.should be_an_instance_of(Chef::Version)
+    expect(vc.version).to be_an_instance_of(Chef::Version)
   end
 
   it "should allow ops without space separator" do
-    Chef::VersionConstraint.new("=1.2.3").should eql(Chef::VersionConstraint.new("= 1.2.3"))
-    Chef::VersionConstraint.new(">1.2.3").should eql(Chef::VersionConstraint.new("> 1.2.3"))
-    Chef::VersionConstraint.new("<1.2.3").should eql(Chef::VersionConstraint.new("< 1.2.3"))
-    Chef::VersionConstraint.new(">=1.2.3").should eql(Chef::VersionConstraint.new(">= 1.2.3"))
-    Chef::VersionConstraint.new("<=1.2.3").should eql(Chef::VersionConstraint.new("<= 1.2.3"))
+    expect(Chef::VersionConstraint.new("=1.2.3")).to eql(Chef::VersionConstraint.new("= 1.2.3"))
+    expect(Chef::VersionConstraint.new(">1.2.3")).to eql(Chef::VersionConstraint.new("> 1.2.3"))
+    expect(Chef::VersionConstraint.new("<1.2.3")).to eql(Chef::VersionConstraint.new("< 1.2.3"))
+    expect(Chef::VersionConstraint.new(">=1.2.3")).to eql(Chef::VersionConstraint.new(">= 1.2.3"))
+    expect(Chef::VersionConstraint.new("<=1.2.3")).to eql(Chef::VersionConstraint.new("<= 1.2.3"))
   end
 
   it "should allow ops with multiple spaces" do
-    Chef::VersionConstraint.new("=  1.2.3").should eql(Chef::VersionConstraint.new("= 1.2.3"))
+    expect(Chef::VersionConstraint.new("=  1.2.3")).to eql(Chef::VersionConstraint.new("= 1.2.3"))
   end
 
   describe "include?" do
@@ -82,70 +82,70 @@ describe Chef::VersionConstraint do
         @vc = Chef::VersionConstraint.new "> 1.2.3"
       end
       it "String" do
-        @vc.should include "1.4"
+        expect(@vc).to include "1.4"
       end
       it "Chef::Version" do
-        @vc.should include Chef::Version.new("1.4")
+        expect(@vc).to include Chef::Version.new("1.4")
       end
       it "Chef::CookbookVersion" do
         cv = Chef::CookbookVersion.new("alice", '/tmp/blah.txt')
         cv.version = "1.4"
-        @vc.should include cv
+        expect(@vc).to include cv
       end
     end
 
     it "strictly less than" do
       vc = Chef::VersionConstraint.new "< 1.2.3"
-      vc.should_not include "1.3.0"
-      vc.should_not include "1.2.3"
-      vc.should include "1.2.2"
+      expect(vc).not_to include "1.3.0"
+      expect(vc).not_to include "1.2.3"
+      expect(vc).to include "1.2.2"
     end
 
     it "strictly greater than" do
       vc = Chef::VersionConstraint.new "> 1.2.3"
-      vc.should include "1.3.0"
-      vc.should_not include "1.2.3"
-      vc.should_not include "1.2.2"
+      expect(vc).to include "1.3.0"
+      expect(vc).not_to include "1.2.3"
+      expect(vc).not_to include "1.2.2"
     end
 
     it "less than or equal to" do
       vc = Chef::VersionConstraint.new "<= 1.2.3"
-      vc.should_not include "1.3.0"
-      vc.should include "1.2.3"
-      vc.should include "1.2.2"
+      expect(vc).not_to include "1.3.0"
+      expect(vc).to include "1.2.3"
+      expect(vc).to include "1.2.2"
     end
 
     it "greater than or equal to" do
       vc = Chef::VersionConstraint.new ">= 1.2.3"
-      vc.should include "1.3.0"
-      vc.should include "1.2.3"
-      vc.should_not include "1.2.2"
+      expect(vc).to include "1.3.0"
+      expect(vc).to include "1.2.3"
+      expect(vc).not_to include "1.2.2"
     end
 
     it "equal to" do
       vc = Chef::VersionConstraint.new "= 1.2.3"
-      vc.should_not include "1.3.0"
-      vc.should include "1.2.3"
-      vc.should_not include "0.3.0"
+      expect(vc).not_to include "1.3.0"
+      expect(vc).to include "1.2.3"
+      expect(vc).not_to include "0.3.0"
     end
 
     it "pessimistic ~> x.y.z" do
       vc = Chef::VersionConstraint.new "~> 1.2.3"
-      vc.should include "1.2.3"
-      vc.should include "1.2.4"
+      expect(vc).to include "1.2.3"
+      expect(vc).to include "1.2.4"
 
-      vc.should_not include "1.2.2"
-      vc.should_not include "1.3.0"
-      vc.should_not include "2.0.0"
+      expect(vc).not_to include "1.2.2"
+      expect(vc).not_to include "1.3.0"
+      expect(vc).not_to include "2.0.0"
     end
 
     it "pessimistic ~> x.y" do
       vc = Chef::VersionConstraint.new "~> 1.2"
-      vc.should include "1.3.3"
-      vc.should include "1.4"
+      expect(vc).to include "1.3.3"
+      expect(vc).to include "1.4"
 
-      vc.should_not include "2.2"
-      vc.should_not include "0.3.0"
+      expect(vc).not_to include "2.2"
+      expect(vc).not_to include "0.3.0"
     end
   end
 
@@ -153,13 +153,13 @@ describe Chef::VersionConstraint do
     it 'shows a patch-level if one is given' do
       vc = Chef::VersionConstraint.new '~> 1.2.0'
 
-      vc.to_s.should == '~> 1.2.0'
+      expect(vc.to_s).to eq('~> 1.2.0')
     end
 
     it 'shows no patch-level if one is not given' do
       vc = Chef::VersionConstraint.new '~> 1.2'
 
-      vc.to_s.should == '~> 1.2'
+      expect(vc.to_s).to eq('~> 1.2')
     end
   end
 
@@ -167,13 +167,13 @@ describe Chef::VersionConstraint do
     it 'shows a patch-level if one is given' do
       vc = Chef::VersionConstraint.new '~> 1.2.0'
 
-      vc.inspect.should == '(~> 1.2.0)'
+      expect(vc.inspect).to eq('(~> 1.2.0)')
     end
 
     it 'shows no patch-level if one is not given' do
       vc = Chef::VersionConstraint.new '~> 1.2'
 
-      vc.inspect.should == '(~> 1.2)'
+      expect(vc.inspect).to eq('(~> 1.2)')
     end
   end
 end